diff --git a/README.md b/README.md
index d707577..598649d 100644
--- a/README.md
+++ b/README.md
@@ -1,73 +1,71 @@
 # Typegres
 
-Postgres tables wrapped in TypeScript classes. The methods on those classes —
-SQL expressions, aggregates, subqueries, role gates, state transitions — are
-your API. Clients compose typed queries against them, end-to-end-typed; no
-routes, no GraphQL schema, no auto-CRUD.
+![Typegres playground demo](./assets/demo.gif)
 
-The schema underneath stays yours to refactor. The classes are the contract.
+- **Methods on Postgres tables = your API.** No routes. No GraphQL. No auto-CRUD.
+- **Every Postgres function, fully typed.** All 77 base types, every operator, nullability tracked at the type level.
+- **Clients compose typed SQL across the wire.** Server validates the surface area you expose.
+- **Live by default.** `.live()` re-queries when the underlying data changes — pushed directly to clients.
 
-> **Status:** clean rewrite in progress. Core architecture is settled. See
-> [ARCHITECTURE.md](./ARCHITECTURE.md) for design notes.
+> [typegres.com/play](https://typegres.com/play) · [demo.mp4](./assets/demo.mp4) · [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md)
 
-## Tenets
+## Usage
 
-1. **Clients compose, server constrains.**
-   The query builder is typed end-to-end and runs client-side; the server only
-   evaluates what you've marked `@tool`. The class surface is your contract —
-   refactor the schema underneath without breaking callers.
+> **Developer preview** — surface is settled, edges still being filed. Not
+> yet recommended for production.
 
-2. **Your API is an abstract data type on top of the database.**
-   Tables are TypeScript classes; methods — plain SQL expressions, aggregates,
-   subqueries, whatever — are the public interface. Logic, permissions, and
-   state transitions live alongside the data, in one place.
+```bash
+npm install typegres pg
+```
 
-3. **Every Postgres capability, as a typed TS method.**
-   All 77 pg base types, every operator, every function — codegen'd from the
-   catalog with full overload preservation and compile-time null tracking.
-   `Int4<1>["+"](Int4<0|1>)` returns `Int4<0|1>`; pg's strictness rules are
-   captured in the types.
+```typescript
+import { typegres, Int8, Text, expose } from "typegres";
 
-## Example
+const db = await typegres({
+  type: "pg",
+  connectionString: process.env.DATABASE_URL!,
+});
 
-```typescript
 class Users extends db.Table("users") {
-  id = (Int8<1>).column({ nonNull: true, generated: true });
-  first_name = (Text<1>).column({ nonNull: true });
-  last_name = (Text<1>).column({ nonNull: true });
-  created_at = (Timestamptz<1>).column({ nonNull: true });
-
-  // Derived column — part of the public interface, not in the schema.
-  // `@tool` marks it reachable from the client.
-  @tool() fullName() {
-    return this.first_name["||"](sql` `)["||"](this.last_name);
-  }
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() first_name = (Text<1>).column({ nonNull: true });
+  @expose() last_name = (Text<1>).column({ nonNull: true });
 
-  // Related query — composable, chainable, typed end-to-end.
-  @tool() todos() {
-    return Todos.from().where((t) => t.user_id["="](this.id));
+  // Derived column — composes back into your typed query API.
+  @expose() fullName() {
+    return this.first_name["||"](" ")["||"](this.last_name);
   }
 }
 
+// `fullName()` works anywhere a column does — select, where, orderBy:
 const rows = await Users.from()
-  .orderBy(({ users }) => users.created_at)
+  .select(({ users }) => ({
+    id: users.id,
+    name: users.fullName(),
+  }))
   .execute(db);
+
+console.log(rows);
+await db.close();
 ```
 
-A live, in-browser demo runs at [/play](https://typegres.com/play) — a
-capability-rooted API (`user.orders().where(...)` auto-scopes to the
-principal), live queries, and RPC by closure transport, all over PGlite.
+For a complete scaffold with migrations + codegen, see
+[`examples/basic`](./examples/basic). Or try it interactively at
+[typegres.com/play](https://typegres.com/play).
 
-## Architecture sketch
+## How it works
 
-- **Types codegen'd from the Postgres catalog.** 77 base types, full
-  method/operator coverage, nullability tracked at the type level.
-- **Capability-based query API.** Clients can only reach what you've exposed
-  as `@tool` methods — columns, relations, scoped reads, mutations. The class
-  surface is the contract; the schema underneath is free to move.
+1. **Types codegen'd from the Postgres catalog.** 77 base types, full
+   method/operator coverage, nullability tracked at the type level.
+2. **Object-capability queries.** Clients can only reach what you've exposed
+   as `@expose` methods — columns, relations, scoped reads, mutations. The class
+   surface is the contract; the schema underneath is free to move.
+3. **Object-capability RPC.** The query builder ships to a constrained
+   interpreter on the server; only `@expose`-marked methods reach evaluation.
+4. **Live queries.** `.live()` watches the predicates your query depends
+   on and re-yields when committed mutations would change the result.
 
-Deeper dive in [ARCHITECTURE.md](./ARCHITECTURE.md); code is annotated
-throughout.
+Deeper dive in [docs/ARCHITECTURE.md](./docs/ARCHITECTURE.md).
 
 ## Status
 
@@ -76,44 +74,32 @@ throughout.
 - [x] Mutations (`.insert` / `.update` / `.delete` / `.returning`)
 - [x] Subqueries, scalar/array aggregation
 - [x] Table codegen from live schema
-- [x] Live queries — `qb.live(db)` returns an async iterable that
+- [x] Live queries — `.live()` returns an async iterable that
       re-yields when committed mutations would change the result
-- [x] Capability-rooted RPC — closures composed against `@tool`-marked
+- [x] Capability-rooted RPC — closures composed against `@expose`-marked
       classes/methods are serialized, evaluated server-side under a
       constrained interpreter, and JSON-streamed back
 
 ## Planned
 
 - [ ] SQLite backend (sql-builder is dialect-aware; adapter is stubbed)
-- [ ] `pg_notify`-driven live updates (currently polls; see `src/live/ISSUES.md` #5)
+- [ ] `pg_notify`-driven live updates (currently a single shared polling loop, not per-subscription)
+- [ ] WAL-mode for live updates (currently uses an auxiliary table)
 - [ ] Cap'n Web transport (in-flight upstream PR;
       [cloudflare/capnweb#162](https://github.com/cloudflare/capnweb/pull/162))
 
-## Quick start
-
-```bash
-npm install typegres pg
-```
-
-```typescript
-import { Database, PgDriver, sql } from "typegres";
-
-const driver = await PgDriver.create(process.env.DATABASE_URL!);
-const db = new Database(driver);
-
-const rows = await db.execute(sql`SELECT 1 + 1 AS sum`);
-```
-
-For a working scaffold with migrations + codegen, see
-[`examples/basic`](./examples/basic).
-
 ## Development
 
+> Recommended: [Nix the package manager](https://nixos.org/download/)
+> + [direnv](https://direnv.net). The `.envrc` (`use flake`) auto-activates
+> the pinned toolchain when you `cd` into the repo, and `bin/startpg`
+> works out of the box. Without Nix, point `DATABASE_URL` at any local
+> Postgres and skip `startpg`.
+
 ```bash
-./bin/startpg             # one-time dev Postgres socket
+./bin/startpg             # one-time dev Postgres socket (Nix)
 npm install
 npm run check             # lint + typecheck + tests
-./bin/tg generate         # table codegen (reads typegres.config.ts)
 ```
 
 ## License
diff --git a/assets/demo.gif b/assets/demo.gif
new file mode 100644
index 0000000..ce0cb3f
Binary files /dev/null and b/assets/demo.gif differ
diff --git a/assets/demo.mp4 b/assets/demo.mp4
new file mode 100644
index 0000000..d78a607
Binary files /dev/null and b/assets/demo.mp4 differ
diff --git a/AGENTS.md b/docs/AGENTS.md
similarity index 100%
rename from AGENTS.md
rename to docs/AGENTS.md
diff --git a/ARCHITECTURE.md b/docs/ARCHITECTURE.md
similarity index 100%
rename from ARCHITECTURE.md
rename to docs/ARCHITECTURE.md
diff --git a/ISSUES.md b/docs/ISSUES.md
similarity index 85%
rename from ISSUES.md
rename to docs/ISSUES.md
index 468cecd..0ce78eb 100644
--- a/ISSUES.md
+++ b/docs/ISSUES.md
@@ -51,15 +51,11 @@
    — bigint, bytes, dates, ±Infinity, NaN, undefined as tagged sentinels (e.g.
    `["bigint","42"]`) — is the v0.2 fix; see Endo's `pass-style` for prior art.
 
-10. **Rename `@tool` → `@expose`.** The decorator is the only gatekeeper for
-    what crosses the wire (columns, relations, methods, properties — for any
-    caller: humans, frontends, agents). The current name is sticky baggage from
-    the codemode/agents framing and undersells the broader role. `@expose`
-    matches the verb the README and landing copy already use ("Mark methods
-    exposed", "what you've marked"). Mechanical but wide: `src/exoeval/tool.ts`,
-    `src/index.ts` re-export, codegen template in `src/tables/generate.ts`, all
-    demo schemas (regen via `tg generate`), demo `api.ts`, README example, the
-    inline snapshots in `src/tables/generate.test.ts`, and site copy.
+10. ~~**Rename `@tool` → `@expose`.**~~ Done at launch prep. The exported
+    decorator and namespace are `expose` / `expose.unchecked`; the
+    `tool.ts` file kept its name internally. ESLint rule, codegen
+    template, generated/ outputs, schema files, demo, README, and site
+    copy all updated.
 
 ## Missing features
 
@@ -89,7 +85,7 @@
     Likely answer is both: pre-compiled for production traffic, gas-metered
     for dev/admin/exploratory use.
 
-15. **Site: upgrade Next.js 14 → 16.** `npm audit` reports 4 high-severity
+15. ~~**Site: upgrade Next.js 14 → 16.**~~ `npm audit` reports 4 high-severity
     Next.js CVEs, all fix-gated on the 16.x major. They're server-side
     vulnerabilities (image optimizer, RSC, rewrites, Server Components DoS)
     that don't affect our static-export deployment to GitHub Pages — no Next
diff --git a/eslint.config.js b/eslint.config.js
index 3fe2974..e83019e 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -47,12 +47,12 @@ export default [
         selector: "AssignmentExpression[left.type='MemberExpression'][left.computed=true][left.property.value='__proto__']",
         message: "Don't assign to __proto__ — use Object.setPrototypeOf if you really mean it.",
       }, {
-        // `@tool.unchecked` skips the zod schema typegres uses to validate
+        // `@expose.unchecked` skips the zod schema typegres uses to validate
         // RPC arguments. Legitimate only for internal methods with generics
         // that can't be expressed in zod, or test fixtures. Every use must
         // be acknowledged with a disable comment + reason.
-        selector: "MemberExpression[object.name='tool'][property.name='unchecked']",
-        message: "Don't use @tool.unchecked — it skips RPC arg validation. Use @tool(zSchema) instead. If the method's signature is genuinely inexpressible in zod (or this is a test fixture), add `// eslint-disable-next-line no-restricted-syntax -- <reason>`.",
+        selector: "MemberExpression[object.name='expose'][property.name='unchecked']",
+        message: "Don't use @expose.unchecked — it skips RPC arg validation. Use @expose(zSchema) instead. If the method's signature is genuinely inexpressible in zod (or this is a test fixture), add `// eslint-disable-next-line no-restricted-syntax -- <reason>`.",
       }],
       "@typescript-eslint/no-restricted-types": ["error", {
         types: {
diff --git a/site/astro.config.mjs b/site/astro.config.mjs
index 41a54a7..11e2ecd 100644
--- a/site/astro.config.mjs
+++ b/site/astro.config.mjs
@@ -8,7 +8,7 @@ import swc from "unplugin-swc";
 // interactive bits (playground, demo, dark-mode toggle).
 //
 // SWC plugin handles TC39 stage-3 decorators that typegres uses on
-// `@tool()` — the friction Next 14's compiler couldn't accommodate.
+// `@expose()` — the friction Next 14's compiler couldn't accommodate.
 //
 // Tailwind 4 is wired through postcss.config.js (Astro picks it up
 // automatically) — `@astrojs/tailwind` was only a convenience
diff --git a/site/src/components/WireLog.tsx b/site/src/components/WireLog.tsx
new file mode 100644
index 0000000..a3644aa
--- /dev/null
+++ b/site/src/components/WireLog.tsx
@@ -0,0 +1,94 @@
+// Wire activity panel for the playground. Subscribes to the demo's
+// `wireLog` and renders one row per closure-shipped / chunk-received,
+// color-coded by kind so viewers can see RPC traffic happening — the
+// thing that's invisible in a single-page demo otherwise.
+
+import { useEffect, useState } from "react";
+import type { WireEntry, WireEntryKind } from "@/demo/wire-log";
+import { wireLog } from "@/demo/wire-log";
+
+const LABELS: { [K in WireEntryKind]: { tag: string; tw: string } } = {
+  "query-request":  { tag: "RPC query request",  tw: "text-sky-400" },
+  "query-response": { tag: "RPC query response", tw: "text-emerald-400" },
+  "live-request":   { tag: "RPC live request",   tw: "text-violet-400" },
+  "live-update":    { tag: "RPC live update",    tw: "text-amber-400" },
+  "error":          { tag: "RPC error",          tw: "text-red-400" },
+};
+
+const fmtTime = (t: number): string => {
+  const d = new Date(t);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${hh}:${mm}:${ss}.${ms}`;
+};
+
+// Trim the IIFE wrapper RpcClient.run adds around the closure source.
+// `(${fnString})(api, ${captures})` → `${fnString}` so the log shows
+// just the closure the caller wrote. Multiline closures defeated a
+// `.*`-based regex; locate the `)(api, ` boundary by string search
+// instead.
+const stripIife = (code: string): string => {
+  const trimmed = code.trim();
+  if (!trimmed.startsWith("(") || !trimmed.endsWith(")")) {return trimmed;}
+  const tailIdx = trimmed.lastIndexOf(")(api, ");
+  if (tailIdx < 1) {return trimmed;}
+  return trimmed.slice(1, tailIdx);
+};
+
+const summarize = (e: WireEntry): string => {
+  switch (e.kind) {
+    case "query-request":
+    case "live-request":
+      return stripIife(e.code).replace(/\s+/g, " ");
+    case "query-response":
+    case "live-update":
+      if (e.rows !== null) {return `${e.rows.toLocaleString()} row${e.rows === 1 ? "" : "s"}`;}
+      return `${e.bytes.toLocaleString()} bytes`;
+    case "error":
+      return e.message;
+  }
+};
+
+export const WireLog = () => {
+  const [entries, setEntries] = useState<WireEntry[]>([]);
+
+  useEffect(() => wireLog.subscribe(setEntries), []);
+
+  // Newest first: viewers always see the latest event without scrolling.
+  // The bounded buffer in `wireLog.push` evicts oldest from the front, so
+  // entries[N-1] is most-recent — reverse for display.
+  const display = entries.slice().reverse();
+
+  return (
+    <div className="flex flex-col h-full min-h-0 bg-gray-950 border-t border-gray-800">
+      <div className="px-4 py-1.5 text-xs font-medium text-gray-400 uppercase tracking-wide shrink-0 flex items-center justify-between border-b border-gray-800">
+        <span>Wire</span>
+        <button
+          onClick={() => wireLog.clear()}
+          className="text-[10px] normal-case font-normal text-gray-500 hover:text-gray-300 transition-colors"
+        >
+          clear
+        </button>
+      </div>
+      <div className="flex-1 min-h-0 overflow-auto px-4 py-2 font-mono text-[11px] leading-relaxed">
+        {display.length === 0 ? (
+          <div className="text-gray-600">No traffic yet.</div>
+        ) : (
+          display.map((e, i) => {
+            const { tag, tw } = LABELS[e.kind];
+            const arrow = e.kind === "query-request" || e.kind === "live-request" ? "→" : "←";
+            return (
+              <div key={`${e.t}-${i}`} className="flex gap-2 whitespace-pre-wrap break-all">
+                <span className="text-gray-600 shrink-0">{fmtTime(e.t)}</span>
+                <span className={`${tw} shrink-0`}>{arrow} [{tag}]</span>
+                <span className="text-gray-300">{summarize(e)}</span>
+              </div>
+            );
+          })
+        )}
+      </div>
+    </div>
+  );
+};
diff --git a/site/src/demo/schema/customers.ts b/site/src/demo/schema/customers.ts
index 641947e..df68773 100644
--- a/site/src/demo/schema/customers.ts
+++ b/site/src/demo/schema/customers.ts
@@ -1,15 +1,15 @@
-import { Int8, Text, TypegresLiveEvents, tool } from "typegres";
+import { Int8, Text, TypegresLiveEvents, expose } from "typegres";
 import { db } from "../runtime";
 import { Orders } from "./orders";
 import { Organizations } from "./organizations";
 export class Customers extends db.Table("customers", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() name = (Text<1>).column({ nonNull: true });
-  @tool() email = (Text<1>).column({ nonNull: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() name = (Text<1>).column({ nonNull: true });
+  @expose() email = (Text<1>).column({ nonNull: true });
   // relations
-  @tool() organization() { return Organizations.scope(Customers.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
-  @tool() orders() { return Orders.scope(Customers.contextOf(this)).where(({ orders }) => orders.customer_id["="](this.id)).cardinality("many"); }
+  @expose() organization() { return Organizations.scope(Customers.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() orders() { return Orders.scope(Customers.contextOf(this)).where(({ orders }) => orders.customer_id["="](this.id)).cardinality("many"); }
   // @generated-end
 }
diff --git a/site/src/demo/schema/inventory_positions.ts b/site/src/demo/schema/inventory_positions.ts
index a68f47d..f0d2a6e 100644
--- a/site/src/demo/schema/inventory_positions.ts
+++ b/site/src/demo/schema/inventory_positions.ts
@@ -1,4 +1,4 @@
-import { Database, Int8, Text, TypegresLiveEvents, sql, tool } from "typegres";
+import { Database, Int8, Text, TypegresLiveEvents, sql, expose } from "typegres";
 import { z } from "zod";
 import { db } from "../runtime";
 import { Locations } from "./locations";
@@ -6,16 +6,16 @@ import { Organizations } from "./organizations";
 import { OrderLines } from "./order_lines";
 export class InventoryPositions extends db.Table("inventory_positions", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() location_id = (Int8<1>).column({ nonNull: true });
-  @tool() sku = (Text<1>).column({ nonNull: true });
-  @tool() on_hand = (Int8<1>).column({ nonNull: true, default: sql`0` });
-  @tool() reserved = (Int8<1>).column({ nonNull: true, default: sql`0` });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() location_id = (Int8<1>).column({ nonNull: true });
+  @expose() sku = (Text<1>).column({ nonNull: true });
+  @expose() on_hand = (Int8<1>).column({ nonNull: true, default: sql`0` });
+  @expose() reserved = (Int8<1>).column({ nonNull: true, default: sql`0` });
   // relations
-  @tool() location() { return Locations.scope(InventoryPositions.contextOf(this)).where(({ locations }) => locations.id["="](this.location_id)).cardinality("one"); }
-  @tool() organization() { return Organizations.scope(InventoryPositions.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
-  @tool() order_lines() { return OrderLines.scope(InventoryPositions.contextOf(this)).where(({ order_lines }) => order_lines.inventory_position_id["="](this.id)).cardinality("many"); }
+  @expose() location() { return Locations.scope(InventoryPositions.contextOf(this)).where(({ locations }) => locations.id["="](this.location_id)).cardinality("one"); }
+  @expose() organization() { return Organizations.scope(InventoryPositions.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() order_lines() { return OrderLines.scope(InventoryPositions.contextOf(this)).where(({ order_lines }) => order_lines.inventory_position_id["="](this.id)).cardinality("many"); }
   // @generated-end
 
   // inventory_control-only: adjust on_hand by a signed delta.
@@ -23,7 +23,7 @@ export class InventoryPositions extends db.Table("inventory_positions", { transf
   // returns the principal that scoped the read, and `this.id` is
   // therefore already in that principal's tenant. Only the role gate
   // is checked here.
-  @tool(z.lazy(() => z.instanceof(Database)), z.number())
+  @expose(z.lazy(() => z.instanceof(Database)), z.number())
   async adjust(db: Database<any>, delta: number): Promise<{ id: string; on_hand: string }> {
     const user = InventoryPositions.contextOf(this);
     if (!user) {
diff --git a/site/src/demo/schema/locations.ts b/site/src/demo/schema/locations.ts
index 2489f53..cb2c8aa 100644
--- a/site/src/demo/schema/locations.ts
+++ b/site/src/demo/schema/locations.ts
@@ -1,16 +1,16 @@
-import { Int8, Text, TypegresLiveEvents, tool } from "typegres";
+import { Int8, Text, TypegresLiveEvents, expose } from "typegres";
 import { db } from "../runtime";
 import { InventoryPositions } from "./inventory_positions";
 import { Organizations } from "./organizations";
 
 export class Locations extends db.Table("locations", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() code = (Text<1>).column({ nonNull: true });
-  @tool() name = (Text<1>).column({ nonNull: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() code = (Text<1>).column({ nonNull: true });
+  @expose() name = (Text<1>).column({ nonNull: true });
   // relations
-  @tool() organization() { return Organizations.scope(Locations.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
-  @tool() inventory_positions() { return InventoryPositions.scope(Locations.contextOf(this)).where(({ inventory_positions }) => inventory_positions.location_id["="](this.id)).cardinality("many"); }
+  @expose() organization() { return Organizations.scope(Locations.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() inventory_positions() { return InventoryPositions.scope(Locations.contextOf(this)).where(({ inventory_positions }) => inventory_positions.location_id["="](this.id)).cardinality("many"); }
   // @generated-end
 }
diff --git a/site/src/demo/schema/order_lines.ts b/site/src/demo/schema/order_lines.ts
index 4266752..802ee3d 100644
--- a/site/src/demo/schema/order_lines.ts
+++ b/site/src/demo/schema/order_lines.ts
@@ -1,17 +1,17 @@
-import { Int8, Text, TypegresLiveEvents, tool } from "typegres";
+import { Int8, Text, TypegresLiveEvents, expose } from "typegres";
 import { db } from "../runtime";
 import { InventoryPositions } from "./inventory_positions";
 import { Orders } from "./orders";
 
 export class OrderLines extends db.Table("order_lines", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() order_id = (Int8<1>).column({ nonNull: true });
-  @tool() sku = (Text<1>).column({ nonNull: true });
-  @tool() quantity = (Int8<1>).column({ nonNull: true });
-  @tool() inventory_position_id = (Int8<0 | 1>).column();
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() order_id = (Int8<1>).column({ nonNull: true });
+  @expose() sku = (Text<1>).column({ nonNull: true });
+  @expose() quantity = (Int8<1>).column({ nonNull: true });
+  @expose() inventory_position_id = (Int8<0 | 1>).column();
   // relations
-  @tool() inventory_position() { return InventoryPositions.scope(OrderLines.contextOf(this)).where(({ inventory_positions }) => inventory_positions.id["="](this.inventory_position_id)).cardinality("maybe"); }
-  @tool() order() { return Orders.scope(OrderLines.contextOf(this)).where(({ orders }) => orders.id["="](this.order_id)).cardinality("one"); }
+  @expose() inventory_position() { return InventoryPositions.scope(OrderLines.contextOf(this)).where(({ inventory_positions }) => inventory_positions.id["="](this.inventory_position_id)).cardinality("maybe"); }
+  @expose() order() { return Orders.scope(OrderLines.contextOf(this)).where(({ orders }) => orders.id["="](this.order_id)).cardinality("one"); }
   // @generated-end
 }
diff --git a/site/src/demo/schema/orders.ts b/site/src/demo/schema/orders.ts
index a6debe2..352ec99 100644
--- a/site/src/demo/schema/orders.ts
+++ b/site/src/demo/schema/orders.ts
@@ -1,4 +1,4 @@
-import { Database, Int8, Text, Timestamptz, TypegresLiveEvents, sql, tool } from "typegres";
+import { Database, Int8, Text, Timestamptz, TypegresLiveEvents, sql, expose } from "typegres";
 import { z } from "zod";
 import { db } from "../runtime";
 import { Customers } from "./customers";
@@ -8,18 +8,18 @@ import { Shipments } from "./shipments";
 
 export class Orders extends db.Table("orders", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() customer_id = (Int8<1>).column({ nonNull: true });
-  @tool() status = (Text<1>).column({ nonNull: true, default: sql`'draft'::text` });
-  @tool() priority = (Int8<1>).column({ nonNull: true, default: sql`0` });
-  @tool() ship_by = (Timestamptz<0 | 1>).column();
-  @tool() created_at = (Timestamptz<1>).column({ nonNull: true, default: sql`now()` });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() customer_id = (Int8<1>).column({ nonNull: true });
+  @expose() status = (Text<1>).column({ nonNull: true, default: sql`'draft'::text` });
+  @expose() priority = (Int8<1>).column({ nonNull: true, default: sql`0` });
+  @expose() ship_by = (Timestamptz<0 | 1>).column();
+  @expose() created_at = (Timestamptz<1>).column({ nonNull: true, default: sql`now()` });
   // relations
-  @tool() customer() { return Customers.scope(Orders.contextOf(this)).where(({ customers }) => customers.id["="](this.customer_id)).cardinality("one"); }
-  @tool() organization() { return Organizations.scope(Orders.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
-  @tool() order_lines() { return OrderLines.scope(Orders.contextOf(this)).where(({ order_lines }) => order_lines.order_id["="](this.id)).cardinality("many"); }
-  @tool() shipments() { return Shipments.scope(Orders.contextOf(this)).where(({ shipments }) => shipments.order_id["="](this.id)).cardinality("many"); }
+  @expose() customer() { return Customers.scope(Orders.contextOf(this)).where(({ customers }) => customers.id["="](this.customer_id)).cardinality("one"); }
+  @expose() organization() { return Organizations.scope(Orders.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() order_lines() { return OrderLines.scope(Orders.contextOf(this)).where(({ order_lines }) => order_lines.order_id["="](this.id)).cardinality("many"); }
+  @expose() shipments() { return Shipments.scope(Orders.contextOf(this)).where(({ shipments }) => shipments.order_id["="](this.id)).cardinality("many"); }
   // @generated-end
 
   // ops_lead-only: advance this order one step along the lifecycle
@@ -34,7 +34,7 @@ export class Orders extends db.Table("orders", { transformer: TypegresLiveEvents
   // check is "did anything come back from RETURNING?" — `delivered`
   // rows have no next state, so the CASE returns NULL and the WHERE
   // (which excludes NULL) keeps them unchanged.
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async advance(db: Database<any>): Promise<{ id: string; status: string }> {
     const user = Orders.contextOf(this);
     if (!user) {
diff --git a/site/src/demo/schema/organizations.ts b/site/src/demo/schema/organizations.ts
index 09c99b0..bfaa95b 100644
--- a/site/src/demo/schema/organizations.ts
+++ b/site/src/demo/schema/organizations.ts
@@ -1,4 +1,4 @@
-import { Int8, Text, TypegresLiveEvents, tool } from "typegres";
+import { Int8, Text, TypegresLiveEvents, expose } from "typegres";
 import { db } from "../runtime";
 import { Customers } from "./customers";
 import { InventoryPositions } from "./inventory_positions";
@@ -8,15 +8,15 @@ import { Orders } from "./orders";
 import { Shipments } from "./shipments";
 export class Organizations extends db.Table("organizations", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() name = (Text<1>).column({ nonNull: true });
-  @tool() slug = (Text<1>).column({ nonNull: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() name = (Text<1>).column({ nonNull: true });
+  @expose() slug = (Text<1>).column({ nonNull: true });
   // relations
-  @tool() customers() { return Customers.scope(Organizations.contextOf(this)).where(({ customers }) => customers.organization_id["="](this.id)).cardinality("many"); }
-  @tool() inventory_positions() { return InventoryPositions.scope(Organizations.contextOf(this)).where(({ inventory_positions }) => inventory_positions.organization_id["="](this.id)).cardinality("many"); }
-  @tool() locations() { return Locations.scope(Organizations.contextOf(this)).where(({ locations }) => locations.organization_id["="](this.id)).cardinality("many"); }
-  @tool() orders() { return Orders.scope(Organizations.contextOf(this)).where(({ orders }) => orders.organization_id["="](this.id)).cardinality("many"); }
-  @tool() shipments() { return Shipments.scope(Organizations.contextOf(this)).where(({ shipments }) => shipments.organization_id["="](this.id)).cardinality("many"); }
-  @tool() users() { return Users.scope(Organizations.contextOf(this)).where(({ users }) => users.organization_id["="](this.id)).cardinality("many"); }
+  @expose() customers() { return Customers.scope(Organizations.contextOf(this)).where(({ customers }) => customers.organization_id["="](this.id)).cardinality("many"); }
+  @expose() inventory_positions() { return InventoryPositions.scope(Organizations.contextOf(this)).where(({ inventory_positions }) => inventory_positions.organization_id["="](this.id)).cardinality("many"); }
+  @expose() locations() { return Locations.scope(Organizations.contextOf(this)).where(({ locations }) => locations.organization_id["="](this.id)).cardinality("many"); }
+  @expose() orders() { return Orders.scope(Organizations.contextOf(this)).where(({ orders }) => orders.organization_id["="](this.id)).cardinality("many"); }
+  @expose() shipments() { return Shipments.scope(Organizations.contextOf(this)).where(({ shipments }) => shipments.organization_id["="](this.id)).cardinality("many"); }
+  @expose() users() { return Users.scope(Organizations.contextOf(this)).where(({ users }) => users.organization_id["="](this.id)).cardinality("many"); }
   // @generated-end
 }
diff --git a/site/src/demo/schema/shipments.ts b/site/src/demo/schema/shipments.ts
index 2f1014e..edde776 100644
--- a/site/src/demo/schema/shipments.ts
+++ b/site/src/demo/schema/shipments.ts
@@ -1,18 +1,18 @@
-import { Int8, Text, Timestamptz, TypegresLiveEvents, sql, tool } from "typegres";
+import { Int8, Text, Timestamptz, TypegresLiveEvents, sql, expose } from "typegres";
 import { db } from "../runtime";
 import { Orders } from "./orders";
 import { Organizations } from "./organizations";
 export class Shipments extends db.Table("shipments", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() order_id = (Int8<1>).column({ nonNull: true });
-  @tool() carrier = (Text<1>).column({ nonNull: true });
-  @tool() cutoff_at = (Timestamptz<1>).column({ nonNull: true });
-  @tool() shipped_at = (Timestamptz<0 | 1>).column();
-  @tool() status = (Text<1>).column({ nonNull: true, default: sql`'pending'::text` });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() order_id = (Int8<1>).column({ nonNull: true });
+  @expose() carrier = (Text<1>).column({ nonNull: true });
+  @expose() cutoff_at = (Timestamptz<1>).column({ nonNull: true });
+  @expose() shipped_at = (Timestamptz<0 | 1>).column();
+  @expose() status = (Text<1>).column({ nonNull: true, default: sql`'pending'::text` });
   // relations
-  @tool() order() { return Orders.scope(Shipments.contextOf(this)).where(({ orders }) => orders.id["="](this.order_id)).cardinality("one"); }
-  @tool() organization() { return Organizations.scope(Shipments.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() order() { return Orders.scope(Shipments.contextOf(this)).where(({ orders }) => orders.id["="](this.order_id)).cardinality("one"); }
+  @expose() organization() { return Organizations.scope(Shipments.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
   // @generated-end
 }
diff --git a/site/src/demo/schema/users.ts b/site/src/demo/schema/users.ts
index 5d68c72..9cc88ce 100644
--- a/site/src/demo/schema/users.ts
+++ b/site/src/demo/schema/users.ts
@@ -1,15 +1,15 @@
-import { Int8, Text, TypegresLiveEvents, tool } from "typegres";
+import { Int8, Text, TypegresLiveEvents, expose } from "typegres";
 import { db } from "../runtime";
 import { Organizations } from "./organizations";
 export class Users extends db.Table("users", { transformer: TypegresLiveEvents.makeTransformer() }) {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() organization_id = (Int8<1>).column({ nonNull: true });
-  @tool() name = (Text<1>).column({ nonNull: true });
-  @tool() email = (Text<1>).column({ nonNull: true });
-  @tool() role = (Text<1>).column({ nonNull: true });
-  @tool() token = (Text<1>).column({ nonNull: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() organization_id = (Int8<1>).column({ nonNull: true });
+  @expose() name = (Text<1>).column({ nonNull: true });
+  @expose() email = (Text<1>).column({ nonNull: true });
+  @expose() role = (Text<1>).column({ nonNull: true });
+  @expose() token = (Text<1>).column({ nonNull: true });
   // relations
-  @tool() organization() { return Organizations.scope(Users.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
+  @expose() organization() { return Organizations.scope(Users.contextOf(this)).where(({ organizations }) => organizations.id["="](this.organization_id)).cardinality("one"); }
   // @generated-end
 }
diff --git a/site/src/demo/server/api.ts b/site/src/demo/server/api.ts
index d629ac4..744d525 100644
--- a/site/src/demo/server/api.ts
+++ b/site/src/demo/server/api.ts
@@ -10,9 +10,11 @@
 // downstream methods on the row can reach the principal via
 // `Orders.contextOf(this)` without re-threading.
 
-import { Database, RpcClient, inMemoryChannel, tool } from "typegres";
+import { Database, RpcClient, inMemoryChannel, expose } from "typegres";
+import type { RawChannel } from "typegres";
 import { z } from "zod";
 import { db } from "../runtime";
+import { wireLog } from "../wire-log";
 import { Users } from "../schema/users";
 import { Customers } from "../schema/customers";
 import { Orders } from "../schema/orders";
@@ -30,10 +32,10 @@ export type Role = "ops_lead" | "inventory_control" | "account_manager";
 // explicitly — the executor is the caller's responsibility, not the
 // principal's.
 export class UserRoot {
-  @tool() userId: string;
-  @tool() organizationId: string;
-  @tool() role: Role;
-  @tool() name: string;
+  @expose() userId: string;
+  @expose() organizationId: string;
+  @expose() role: Role;
+  @expose() name: string;
 
   constructor(opts: {
     userId: string;
@@ -50,23 +52,23 @@ export class UserRoot {
   // Scoped reads. Each returns a QueryBuilder pre-`where`'d to this
   // org and tagged with `this` as its context. Hydrated rows carry
   // the user forward through every relation traversal.
-  @tool() customers() {
+  @expose() customers() {
     return Customers.scope(this).where(({ customers }) => customers.organization_id["="](this.organizationId));
   }
-  @tool() orders() {
+  @expose() orders() {
     return Orders.scope(this).where(({ orders }) => orders.organization_id["="](this.organizationId));
   }
-  @tool() inventory() {
+  @expose() inventory() {
     return InventoryPositions.scope(this).where(({ inventory_positions: p }) => p.organization_id["="](this.organizationId));
   }
-  @tool() shipments() {
+  @expose() shipments() {
     return Shipments.scope(this).where(({ shipments }) => shipments.organization_id["="](this.organizationId));
   }
-  @tool() locations() {
+  @expose() locations() {
     return Locations.scope(this).where(({ locations }) => locations.organization_id["="](this.organizationId));
   }
   // Order lines have no direct organization_id; scope through the parent order via a join.
-  @tool() orderLines() {
+  @expose() orderLines() {
     return OrderLines.scope(this)
       .join(Orders, ({ order_lines: l, orders: o }) =>
         l.order_id["="](o.id).and(o.organization_id["="](this.organizationId)),
@@ -76,7 +78,7 @@ export class UserRoot {
   // Demo mutation. Picks a non-terminal order in this user's tenant
   // and runs its `.advance()` lifecycle step. Returns null if there's
   // nothing advanceable. Role gate happens inside Orders.advance().
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async advanceRandom(db: Database<any>): Promise<{ id: string; status: string } | null> {
     const [row] = await this.orders()
       .where(({ orders }) => orders.status["<>"]("delivered"))
@@ -89,7 +91,7 @@ export class UserRoot {
   // Demo mutation. Picks a random inventory position in this user's
   // tenant and bumps its on_hand by a small random amount. Role-
   // gated to inventory_control — Bob can do this; Alice can't.
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async restockRandom(db: Database<any>): Promise<{ id: string; on_hand: string } | null> {
     if (this.role !== "inventory_control") {
       throw new Error(`role '${this.role}' cannot restock (inventory_control required)`);
@@ -105,7 +107,7 @@ export class UserRoot {
   // Demo mutation. Inserts a fresh `draft` order for one of this
   // user's customers. Role-gated like the other writes; tenant comes
   // from the principal — no free-form `organization_id` from the wire.
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async insertDraftOrder(db: Database<any>): Promise<{ id: string }> {
     if (this.role !== "ops_lead") {
       throw new Error(`role '${this.role}' cannot insert orders (ops_lead required)`);
@@ -130,7 +132,7 @@ export class UserRoot {
 }
 
 export class Api {
-  @tool() db: Database<UserRoot>;
+  @expose() db: Database<UserRoot>;
 
   // Server-side ambient: who's "logged in" for this RPC. In the
   // playground the right-pane user dropdown writes here; in a
@@ -152,7 +154,7 @@ export class Api {
   // subscribe immediately. In a real deployment the wire would have
   // a per-iter abort channel; here we tear down the whole bus
   // because the demo only ever has one iter at a time.
-  @tool()
+  @expose()
   async resetLive(): Promise<void> {
     await this.db.stopLive();
     await this.db.startLive();
@@ -162,7 +164,7 @@ export class Api {
   // current-user token (set by the page UI via setCurrentUserToken).
   // Real deployments would set this from the request's auth cookie /
   // bearer token before dispatching the rpc closure.
-  @tool()
+  @expose()
   async currentUser(): Promise<UserRoot> {
     const token = this.#currentUserToken;
     if (!token) throw new Error("no current user — page UI hasn't set one");
@@ -198,7 +200,46 @@ export class Api {
 // JSON-serialized result(s) come back as AsyncIterable<string>.
 // Real deployments swap inMemoryChannel for a wire transport.
 const apiInstance = new Api(db);
-export const client: RpcClient<Api> = new RpcClient<Api>(inMemoryChannel(apiInstance));
+
+// Logging channel wrapper: mirrors `inMemoryChannel` but pushes a
+// wire-log entry on every closure shipped + every chunk received.
+// Live vs query is detected by `.live(` substring in the closure
+// source — typegres closures are explicit about which terminator
+// they use, so the heuristic is reliable.
+const baseChannel: RawChannel = inMemoryChannel(apiInstance);
+
+// Cheap row counter for the wire log. Arrays → length; single
+// objects (e.g. `.one()` results, `insertDraftOrder` returning a row)
+// → 1; void / null / primitives → null, falls through to bytes in
+// the renderer.
+const countRows = (chunk: string): number | null => {
+  try {
+    const v = JSON.parse(chunk);
+    if (Array.isArray(v)) {return v.length;}
+    if (v !== null && typeof v === "object") {return 1;}
+  } catch { /* fall through */ }
+  return null;
+};
+
+const loggingChannel: RawChannel = async function* (code: string) {
+  const isLive = code.includes(".live(");
+  wireLog.push({ kind: isLive ? "live-request" : "query-request", t: Date.now(), code });
+  try {
+    for await (const chunk of baseChannel(code)) {
+      wireLog.push({
+        kind: isLive ? "live-update" : "query-response",
+        t: Date.now(),
+        bytes: chunk.length,
+        rows: countRows(chunk),
+      });
+      yield chunk;
+    }
+  } catch (e) {
+    wireLog.push({ kind: "error", t: Date.now(), message: e instanceof Error ? e.message : String(e) });
+    throw e;
+  }
+};
+export const client: RpcClient<Api> = new RpcClient<Api>(loggingChannel);
 
 // Page-side hook: dropdown change → ambient current-user token. The
 // widget's `api.currentUser()` calls then resolve to whichever user
diff --git a/site/src/demo/widgets/orders.ts b/site/src/demo/widgets/orders.ts
index 21cfd7d..a9d713c 100644
--- a/site/src/demo/widgets/orders.ts
+++ b/site/src/demo/widgets/orders.ts
@@ -15,7 +15,10 @@ const result = client.run(async (api) => {
     .select(({ orders }) => ({
       status: orders.status,
       count: orders.id.count(),
+      avg_priority: orders.priority.avg(),
+      max_priority: orders.priority.max(),
     }))
+    .debug()
     .live(api.db);
 });
 
diff --git a/site/src/demo/wire-log.ts b/site/src/demo/wire-log.ts
new file mode 100644
index 0000000..5cba50a
--- /dev/null
+++ b/site/src/demo/wire-log.ts
@@ -0,0 +1,53 @@
+// Wire log: a small pub/sub for everything that crosses the
+// `inMemoryChannel` boundary. The playground subscribes via the
+// <WireLog/> component and renders entries below the result table —
+// makes it visible to viewers that closures are shipping out and
+// chunks are coming back, instead of running locally.
+//
+// In a real deployment this would be the network tab; here we
+// surface it directly because the in-memory channel is lossless for
+// the wire format.
+//
+// Four entry kinds, distinguished by whether the closure ends in
+// `.live(...)` (streaming) vs `.execute()` / etc. (one-shot):
+//   query-request   →  one-shot closure shipped
+//   query-response  ←  one-shot result chunk(s)
+//   live-request    →  streaming closure shipped
+//   live-update     ←  streaming chunk (typically one per matched commit)
+
+export type WireEntryKind =
+  | "query-request"
+  | "query-response"
+  | "live-request"
+  | "live-update"
+  | "error";
+
+export type WireEntry =
+  | { kind: "query-request" | "live-request"; t: number; code: string }
+  // `rows` is the parsed row count when the chunk is an array (the
+  // typical shape — every typegres terminator returns rows[]). Falls
+  // back to `null` for void / scalar / unparseable payloads, in which
+  // case the renderer shows bytes instead.
+  | { kind: "query-response" | "live-update"; t: number; bytes: number; rows: number | null }
+  | { kind: "error"; t: number; message: string };
+
+const MAX_ENTRIES = 200;
+
+let entries: WireEntry[] = [];
+const subs = new Set<(e: WireEntry[]) => void>();
+
+export const wireLog = {
+  push: (e: WireEntry): void => {
+    entries = [...entries.slice(-(MAX_ENTRIES - 1)), e];
+    for (const s of subs) {s(entries);}
+  },
+  subscribe: (cb: (e: WireEntry[]) => void): (() => void) => {
+    subs.add(cb);
+    cb(entries);
+    return () => { subs.delete(cb); };
+  },
+  clear: (): void => {
+    entries = [];
+    for (const s of subs) {s(entries);}
+  },
+};
diff --git a/site/src/pages/_HomePage.tsx b/site/src/pages/_HomePage.tsx
index 5e61bb5..0b3f66b 100644
--- a/site/src/pages/_HomePage.tsx
+++ b/site/src/pages/_HomePage.tsx
@@ -83,40 +83,35 @@ await todo.update({ completed: true }).execute(db);`,
     {
       title: "3. Expose your API over RPC, Safely",
       description:
-        "Give clients a composable query builder with your unescapable data boundaries. Compose queries in the client with every Postgres feature (joins, window functions, CTEs, etc.) and function as primitives.",
-      leftCode: `class User extends Table("users") {
+        "Give clients a composable query builder with your unescapable data boundaries. Compose queries in the client with rich Postgres features and function as primitives.",
+      leftCode: `class User extends db.Table("users") {
   // ...
 }
 
-class Todo extends Table("todos") {
-  // ...
-}
+class Api {
+  @expose() db = db;
 
-export class Api extends RpcTarget {
-  getUserFromToken(token: string) {
+  // Server-validated entry point — clients compose against this:
+  @expose(z.string())
+  forToken(token: string) {
     return User.from()
       .where(({ users }) => users.token.eq(token));
   }
 }
 
-// Clients receive composable query builders
-// not flat results`,
-      rightCode: `export function TodoList({ searchQuery }: { searchQuery: string }) {
-  const todos = useTypegresQuery((user) => user.todos()
-    // Arbitrarily compose your base query...
-    .select(({ todos }) => ({ id: todos.id, title: todos.title }))
-    // ...using any Postgres function such as \`ilike\`:
-    .where(({ todos }) => todos.title.ilike(\`%\${searchQuery}%\`))
-  );
-
-  return (
-    <ul>
-      {todos.map((todo) => (
-        <li key={todo.id}>{todo.title}</li>
-      ))}
-    </ul>
-  );
-}`,
+export const client = new RpcClient<Api>(...);`,
+      rightCode: `// Client-composed query — crosses the wire to a constrained
+// interpreter, where the server validates the @expose surface:
+const stream = client.run((api) =>
+  api.forToken(token)
+    .select(({ users }) => ({ id: users.id, name: users.name }))
+    // Any Postgres function — \`ilike\`, window funcs:
+    .where(({ users }) => users.name.ilike("%alice%"))
+    .live(api.db)
+);
+
+// Re-yields on every committed mutation that matches:
+for await (const rows of stream) render(rows);`,
       leftLabel: "api.ts",
       rightLabel: "frontend.tsx",
       leftLanguage: "typescript",
diff --git a/site/src/pages/_PlayActiveArea.tsx b/site/src/pages/_PlayActiveArea.tsx
index c0a3971..b291a73 100644
--- a/site/src/pages/_PlayActiveArea.tsx
+++ b/site/src/pages/_PlayActiveArea.tsx
@@ -7,9 +7,11 @@
 
 import { useEffect, useMemo, useRef, useState } from "react";
 import * as monaco from "monaco-editor";
+import { Group, Panel, Separator } from "react-resizable-panels";
 import { client, setCurrentUserToken } from "@/demo/server/api";
 import { transformCodeWithEsbuild } from "@/lib/monaco-typegres-integration";
 import { SyntaxHighlight } from "@/components/SyntaxHighlight";
+import { WireLog } from "@/components/WireLog";
 import { ORDERS_PATH, INVENTORY_PATH } from "./_PlayPaths";
 import {
   OrdersWidget,
@@ -240,22 +242,34 @@ export default function PlayActiveArea({ modelsReady, activeWidget }: PlayActive
           </span>
         )}
       </div>
-      <div className="flex-1 min-h-0 overflow-auto">
-        {error ? (
-          <pre className="px-4 py-3 text-xs font-mono whitespace-pre-wrap text-red-400">
-            {error}
-          </pre>
-        ) : outputTab === "sql" ? (
-          <SqlView entries={sqlEntries} />
-        ) : output === undefined ? (
-          <div className="px-4 py-3 text-xs text-gray-500">
-            {running
-              ? "Running…"
-              : "Click Run to execute the widget."}
-          </div>
-        ) : (
-          <OutputView value={output} />
-        )}
+      <div className="flex-1 min-h-0">
+        <Group orientation="vertical" className="h-full">
+          <Panel id="output-area" defaultSize="40%" minSize="20%">
+            <div className="h-full overflow-auto">
+              {error ? (
+                <pre className="px-4 py-3 text-xs font-mono whitespace-pre-wrap text-red-400">
+                  {error}
+                </pre>
+              ) : outputTab === "sql" ? (
+                <SqlView entries={sqlEntries} />
+              ) : (
+                // Always render — the empty/Running placeholder lives
+                // inside OutputView so its diff state (prevByIdRef,
+                // isFirstYield) survives the brief `output === undefined`
+                // window during a manual Run. Otherwise the component
+                // unmounts/remounts and the diff resets every time.
+                <OutputView value={output} running={running} />
+              )}
+            </div>
+          </Panel>
+          <Separator
+            className="h-1 bg-gray-800 hover:bg-blue-500 cursor-row-resize transition-colors"
+            aria-label="Resize wire log"
+          />
+          <Panel id="wire-log" defaultSize="60%" minSize="10%">
+            <WireLog />
+          </Panel>
+        </Group>
       </div>
     </div>
   );
@@ -272,18 +286,59 @@ const isPlainObject = (v: unknown): v is Record<string, unknown> => {
 const isRowsArray = (v: unknown): v is Record<string, unknown>[] =>
   Array.isArray(v) && v.length > 0 && v.every(isPlainObject);
 
-const OutputView = ({ value }: { value: unknown }) => {
+// Cell-level equality for the diff. Plain `===` / JSON.stringify
+// trips false positives on pg `numeric` columns (avg/max/sum etc.) —
+// pg returns them as strings with variable trailing zeros: "0", "0.0",
+// "0.00000000000000000000" all represent the same value but stringify
+// differently. Coerce string→number for purely numeric strings; fall
+// back to structural equality otherwise.
+const cellEq = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true;
+  if (typeof a === "string" && typeof b === "string") {
+    const na = Number(a);
+    const nb = Number(b);
+    if (!Number.isNaN(na) && !Number.isNaN(nb) && Number.isFinite(na) && Number.isFinite(nb) && na === nb) {
+      return true;
+    }
+  }
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+
+// Animation duration (ms). Matches the `rowFlash` / `cellFlash`
+// keyframes in globals.css — keep in sync.
+const FLASH_MS = 1800;
+
+const OutputView = ({ value, running }: { value: unknown; running: boolean }) => {
   // Diff key column adapts: prefer `id`, otherwise the first column
   // (the groupBy case — `status` is the natural key when grouped).
   const prevByIdRef = useRef<Map<string, Record<string, unknown>>>(new Map());
   const isFirstYieldRef = useRef(true);
   const [rowGen, setRowGen] = useState<Map<string, number>>(new Map());
   const [cellGen, setCellGen] = useState<Map<string, number>>(new Map());
+  // Per-key clear timers so a re-bump within the flash window cancels
+  // the previous clear and re-schedules from scratch.
+  const rowTimersRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
+  const cellTimersRef = useRef<Map<string, ReturnType<typeof setTimeout>>>(new Map());
+
+  // Cleanup pending timers on unmount.
+  useEffect(() => {
+    const rt = rowTimersRef.current;
+    const ct = cellTimersRef.current;
+    return () => {
+      for (const t of rt.values()) clearTimeout(t);
+      for (const t of ct.values()) clearTimeout(t);
+      rt.clear();
+      ct.clear();
+    };
+  }, []);
 
   useEffect(() => {
     if (!isRowsArray(value) || value.length === 0) {
-      prevByIdRef.current = new Map();
-      isFirstYieldRef.current = true;
+      // Manual `.execute()` runs flash through `setOutput(undefined)`
+      // before the new result arrives. Don't wipe the prior dataset
+      // here — the next valid value needs it to compute the diff.
+      // (Live updates never transit through undefined, so they were
+      // already fine.)
       return;
     }
     const firstRow = value[0]!;
@@ -303,7 +358,7 @@ const OutputView = ({ value }: { value: unknown }) => {
       }
       for (const col of Object.keys(r)) {
         if (col === keyCol) continue;
-        if (JSON.stringify(prev[col]) !== JSON.stringify(r[col])) {
+        if (!cellEq(prev[col], r[col])) {
           cells.add(`${key}.${col}`);
         }
       }
@@ -324,8 +379,37 @@ const OutputView = ({ value }: { value: unknown }) => {
       for (const k of cells) next.set(k, (next.get(k) ?? 0) + 1);
       return next;
     });
+    // After the animation duration, clear the entries so the
+    // `animate-*-flash` class no longer hangs on the element. Lingering
+    // classes can trigger spurious re-flashes during reconciliation when
+    // unrelated rows update.
+    for (const k of fresh) {
+      const prevTimer = rowTimersRef.current.get(k);
+      if (prevTimer) clearTimeout(prevTimer);
+      rowTimersRef.current.set(k, setTimeout(() => {
+        setRowGen((m) => { const next = new Map(m); next.delete(k); return next; });
+        rowTimersRef.current.delete(k);
+      }, FLASH_MS));
+    }
+    for (const k of cells) {
+      const prevTimer = cellTimersRef.current.get(k);
+      if (prevTimer) clearTimeout(prevTimer);
+      cellTimersRef.current.set(k, setTimeout(() => {
+        setCellGen((m) => { const next = new Map(m); next.delete(k); return next; });
+        cellTimersRef.current.delete(k);
+      }, FLASH_MS));
+    }
   }, [value]);
 
+  // Empty / undefined: placeholder. Stays mounted so diff state
+  // survives the manual-Run undefined transition.
+  if (value === undefined || value === null) {
+    return (
+      <div className="px-4 py-3 text-xs text-gray-500">
+        {running ? "Running…" : "Click Run to execute the widget."}
+      </div>
+    );
+  }
   if (!isRowsArray(value)) {
     return (
       <pre className="px-4 py-3 text-xs font-mono whitespace-pre-wrap text-gray-200">
diff --git a/site/src/pages/_PlayWidgets.tsx b/site/src/pages/_PlayWidgets.tsx
index 28d70b2..06d20d0 100644
--- a/site/src/pages/_PlayWidgets.tsx
+++ b/site/src/pages/_PlayWidgets.tsx
@@ -97,6 +97,53 @@ const ToggleButton = ({
   </button>
 );
 
+// Manual-fire button + auto-toggle as one compact unit. The fire
+// button is a regular button (style matches inactive ToggleButton);
+// the auto pill flips state on click. The error badge appears on
+// whichever side last reported the error (auto-cycle writes via
+// setError; manual fire writes via the same setter from onFire).
+const FireWithAutoToggle = ({
+  label,
+  onFire,
+  auto,
+  onAuto,
+  fireTitle,
+  autoTitle,
+  error,
+}: {
+  label: string;
+  onFire: () => void | Promise<void>;
+  auto: boolean;
+  onAuto: () => void;
+  fireTitle: string;
+  autoTitle: string;
+  error: string | null;
+}) => (
+  <div className="relative inline-flex items-center rounded border overflow-hidden border-gray-700">
+    <button
+      onClick={() => { void onFire(); }}
+      title={error ?? fireTitle}
+      className="text-[11px] normal-case px-2 py-0.5 text-gray-300 hover:bg-gray-800 transition-colors"
+    >
+      {label}
+    </button>
+    <button
+      onClick={onAuto}
+      title={error ?? autoTitle}
+      className={`text-[11px] normal-case px-2 py-0.5 border-l border-gray-700 transition-colors ${
+        auto ? "bg-blue-600/30 text-white" : "text-gray-500 hover:bg-gray-800 hover:text-gray-300"
+      }`}
+    >
+      auto
+    </button>
+    {error && (
+      <span className="absolute -top-1 -right-1 w-3 h-3 rounded-full bg-red-500 text-white text-[8px] leading-3 text-center font-bold">
+        !
+      </span>
+    )}
+  </div>
+);
+
 // Self-rescheduling auto-cycle. Each tick fires `action()` after a
 // random delay in [minMs, maxMs]; ON by default. Pauses when the
 // gate is off OR when the widget isn't visible (no point firing
@@ -187,6 +234,17 @@ function generateOrdersBlock(opts: {
       : `\n    .where(({ orders }) => orders.status.in(${statusFilter
           .map((s) => JSON.stringify(s))
           .join(", ")}))`;
+  // For grouped views, include a couple of priority aggregates beyond
+  // the row count so the table actually shifts on mutation (count alone
+  // is just integers; avg fluctuates as new draft orders land at
+  // priority 0). Skip when grouping *by* priority — the avg/max would
+  // be tautological.
+  const priorityAggs =
+    groupBy !== "none" && groupBy !== "priority"
+      ? `
+      avg_priority: orders.priority.avg(),
+      max_priority: orders.priority.max(),`
+      : "";
   const selectBody =
     groupBy === "none"
       ? `{
@@ -196,7 +254,7 @@ function generateOrdersBlock(opts: {
     }`
       : `{
       ${groupBy}: orders.${groupBy},
-      count: orders.id.count(),
+      count: orders.id.count(),${priorityAggs}
     }`;
   const groupByLine =
     groupBy === "none" ? "" : `\n    .groupBy(({ orders }) => [orders.${groupBy}])`;
@@ -246,34 +304,27 @@ export const OrdersWidget = (props: WidgetProps) => {
   const [insertError, setInsertError] = useState<string | null>(null);
   const [advanceError, setAdvanceError] = useState<string | null>(null);
 
-  useAutoCycle(
-    autoInsert && props.visible,
-    [3000, 7000],
-    [7500, 22500],
-    async () => {
-      try {
-        await rpc(async (api) => (await api.currentUser()).insertDraftOrder(api.db));
-        return null;
-      } catch (e) {
-        return e instanceof Error ? e.message : String(e);
-      }
-    },
-    setInsertError,
-  );
-  useAutoCycle(
-    autoAdvance && props.visible,
-    [7000, 11000],
-    [7500, 22500],
-    async () => {
-      try {
-        await rpc(async (api) => (await api.currentUser()).advanceRandom(api.db));
-        return null;
-      } catch (e) {
-        return e instanceof Error ? e.message : String(e);
-      }
-    },
-    setAdvanceError,
-  );
+  // Same action shared by the manual-fire buttons and the auto-cycle —
+  // returns an error string (or null) instead of throwing so both
+  // entry points report through setInsertError / setAdvanceError.
+  const fireInsert = async () => {
+    try {
+      await rpc(async (api) => (await api.currentUser()).insertDraftOrder(api.db));
+      return null;
+    } catch (e) {
+      return e instanceof Error ? e.message : String(e);
+    }
+  };
+  const fireAdvance = async () => {
+    try {
+      await rpc(async (api) => (await api.currentUser()).advanceRandom(api.db));
+      return null;
+    } catch (e) {
+      return e instanceof Error ? e.message : String(e);
+    }
+  };
+  useAutoCycle(autoInsert && props.visible, [3000, 7000], [7500, 22500], fireInsert, setInsertError);
+  useAutoCycle(autoAdvance && props.visible, [7000, 11000], [7500, 22500], fireAdvance, setAdvanceError);
 
   const next = generateOrdersBlock({ statusFilter, groupBy, orderBy, orderDir, live: props.live });
   useWidgetStamp(ORDERS_URI, props.modelsReady, props.running, props.restart, next);
@@ -333,23 +384,25 @@ export const OrdersWidget = (props: WidgetProps) => {
         </select>
       </Field>
       <LiveToggle live={props.live} onLive={props.onLive} />
-      <div className="ml-auto flex items-center gap-2">
-        <ToggleButton
-          active={autoInsert}
-          onClick={() => setAutoInsert((v) => !v)}
-          title="Auto-insert a draft order every few seconds. Click to pause."
+      <div className="ml-auto flex items-center gap-3">
+        <FireWithAutoToggle
+          label="+ insert"
+          onFire={async () => setInsertError(await fireInsert())}
+          auto={autoInsert}
+          onAuto={() => setAutoInsert((v) => !v)}
+          fireTitle="Insert a single draft order."
+          autoTitle="Auto-insert a draft order every few seconds. Click to pause."
           error={insertError}
-        >
-          + auto-insert
-        </ToggleButton>
-        <ToggleButton
-          active={autoAdvance}
-          onClick={() => setAutoAdvance((v) => !v)}
-          title="Auto-advance a random non-delivered order every few seconds. Click to pause."
+        />
+        <FireWithAutoToggle
+          label="↻ advance"
+          onFire={async () => setAdvanceError(await fireAdvance())}
+          auto={autoAdvance}
+          onAuto={() => setAutoAdvance((v) => !v)}
+          fireTitle="Advance one random non-delivered order."
+          autoTitle="Auto-advance a random non-delivered order every few seconds. Click to pause."
           error={advanceError}
-        >
-          ↻ auto-advance
-        </ToggleButton>
+        />
       </div>
     </ControlsStrip>
   );
diff --git a/src/builder/delete.ts b/src/builder/delete.ts
index c419a35..75ab646 100644
--- a/src/builder/delete.ts
+++ b/src/builder/delete.ts
@@ -5,7 +5,7 @@ import type { RowType, RowTypeToTsType } from "./query";
 import { combinePredicates, compileSelectList, isRowType, mergeReturning, reAlias } from "./query";
 import type { TableBase } from "../table";
 import { Database } from "../database";
-import { fn, tool } from "../exoeval/tool";
+import { fn, expose } from "../exoeval/tool";
 import z from "zod";
 
 type Namespace<Name extends string, T> = { [K in Name]: T };
@@ -59,7 +59,7 @@ export class DeleteBuilder<Name extends string, T extends TableBase, R extends R
   }
 
   // Multiple where() calls are combined with AND. .where(true) matches all rows.
-  @tool(z.union([z.literal(true), fn.returns(z.lazy(() => z.instanceof(Bool)))]))
+  @expose(z.union([z.literal(true), fn.returns(z.lazy(() => z.instanceof(Bool)))]))
   where(fn: ((ns: Namespace<Name, T>) => Bool<any>) | true): DeleteBuilder<Name, T, R> {
     const wrapped: (ns: Namespace<Name, T>) => Bool<any> =
       fn === true ? () => Bool.from(sql`TRUE`) as Bool<any> : fn;
@@ -69,7 +69,7 @@ export class DeleteBuilder<Name extends string, T extends TableBase, R extends R
     });
   }
 
-  @tool(fn.returns(z.custom<any>((v) => isRowType(v))))
+  @expose(fn.returns(z.custom<any>((v) => isRowType(v))))
   returning<R2 extends RowType>(fn: (ns: Namespace<Name, T>) => R2): DeleteBuilder<Name, T, R2> {
     return new DeleteBuilder({ ...this.#opts, returning: fn });
   }
@@ -116,17 +116,17 @@ export class DeleteBuilder<Name extends string, T extends TableBase, R extends R
     return [this.finalize()];
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   override async execute(db: Database<any>): Promise<RowTypeToTsType<R>[]> {
     return db.execute(this);
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async hydrate(db: Database<any>): Promise<R[]> {
     return db.hydrate<any, any, R>(this);
   }
 
-  @tool()
+  @expose()
   debug(): this {
     const compiled = compile(this, "pg");
     console.log("Debugging query:", { sql: compiled.text, parameters: compiled.values });
diff --git a/src/builder/insert.ts b/src/builder/insert.ts
index c150ef5..d64dc5f 100644
--- a/src/builder/insert.ts
+++ b/src/builder/insert.ts
@@ -6,7 +6,7 @@ import type { TableBase } from "../table";
 import { Database } from "../database";
 import { getColumn } from "../types/overrides/any";
 import { meta } from "../types/runtime";
-import { fn, tool } from "../exoeval/tool";
+import { fn, expose } from "../exoeval/tool";
 import z from "zod";
 
 type Namespace<Name extends string, T> = { [K in Name]: T };
@@ -67,7 +67,7 @@ export class InsertBuilder<Name extends string, T extends TableBase, R extends R
     return this.#opts.instance.constructor.tableName as Name;
   }
 
-  @tool(fn.returns(z.custom<any>((v) => isRowType(v))))
+  @expose(fn.returns(z.custom<any>((v) => isRowType(v))))
   returning<R2 extends RowType>(fn: (ns: Namespace<Name, T>) => R2): InsertBuilder<Name, T, R2> {
     return new InsertBuilder({ ...this.#opts, returning: fn });
   }
@@ -115,17 +115,17 @@ export class InsertBuilder<Name extends string, T extends TableBase, R extends R
     return [this.finalize()];
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   override async execute(db: Database<any>): Promise<RowTypeToTsType<R>[]> {
     return db.execute(this);
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async hydrate(db: Database<any>): Promise<R[]> {
     return db.hydrate<any, any, R>(this);
   }
 
-  @tool()
+  @expose()
   debug(): this {
     const compiled = compile(this, "pg");
     console.log("Debugging query:", { sql: compiled.text, parameters: compiled.values });
diff --git a/src/builder/query.test.ts b/src/builder/query.test.ts
index bee9ed5..62d8305 100644
--- a/src/builder/query.test.ts
+++ b/src/builder/query.test.ts
@@ -769,14 +769,14 @@ test("having: multiple calls AND-combine", async () => {
   expect(result).toEqual([{ cat: "a", total: "3" }]);
 });
 
-// --- runtime arg validation (the @tool decorators on QueryBuilder) ---
+// --- runtime arg validation (the @expose decorators on QueryBuilder) ---
 //
 // Two flavors here. Direct args (numbers, instances, strings) are validated
 // synchronously when the builder method is called and throw a TypeError
 // whose message starts with "Invalid value:" (from tool.ts's validateArgs).
 //
 // Callback returns (where/having/orderBy/select) are validated lazily — the
-// @tool wrapper replaces the user's cb with a transformed wrapper that calls
+// @expose wrapper replaces the user's cb with a transformed wrapper that calls
 // retSchema.parse() on the return; that throws a ZodError whose .message is
 // a JSON-shaped issue list. The cb isn't invoked until bind() runs (i.e., at
 // compile/execute time), so these errors only surface when the query is
diff --git a/src/builder/query.ts b/src/builder/query.ts
index fcabd77..cc54f27 100644
--- a/src/builder/query.ts
+++ b/src/builder/query.ts
@@ -4,7 +4,7 @@ import { Database } from "../database";
 import { Bool } from "../types";
 import { Any, Anyarray, Record } from "../types";
 import { type TsTypeOf, type Nullable, type AggregateRow, meta } from "../types/runtime";
-import { fn, tool } from "../exoeval/tool";
+import { fn, expose } from "../exoeval/tool";
 import { isTableClass, TableBase } from "../table";
 import z from "zod";
 import { Values } from "./values";
@@ -254,13 +254,13 @@ export class QueryBuilder<
   }
 
   // Subsequent `select` calls replace the output type (columns must be redefined).
-  @tool(fn.returns(z.custom<any>(isRowType)))
+  @expose(fn.returns(z.custom<any>(isRowType)))
   select<O2 extends RowType>(select: (n: N) => O2): QueryBuilder<N, O2, GB, Card> {
     return new QueryBuilder({ ...this.opts, select: select }, this.card);
   }
 
   // Multiple `where` calls are combined with AND
-  @tool(fn.returns(z.lazy(() => z.instanceof(Bool))))
+  @expose(fn.returns(z.lazy(() => z.instanceof(Bool))))
   where(where: (n: N) => Bool<any>): QueryBuilder<N, O, GB> {
     return new QueryBuilder({
       ...this.opts,
@@ -293,7 +293,7 @@ export class QueryBuilder<
     from: Fromable<R, A>,
     on: (ns: N & { [k in A]: R }) => Bool<any>,
   ): QueryBuilder<N & { [k in A]: R }, O, GB>;
-  @tool(z.custom<any>(isFromable), fn.returns(z.lazy(() => z.instanceof(Bool))))
+  @expose(z.custom<any>(isFromable), fn.returns(z.lazy(() => z.instanceof(Bool))))
   join(from: Fromable, on: (ns: any) => Bool<any>): any {
     this.#assertNotInNamespace(from.tsAlias);
     return new QueryBuilder({
@@ -310,7 +310,7 @@ export class QueryBuilder<
     from: Fromable<R, A>,
     onFn: (ns: N & { [k in A]: RowTypeToNullable<R> }) => Bool<any>,
   ): QueryBuilder<N & { [k in A]: RowTypeToNullable<R> }, O, GB>;
-  @tool(z.custom<Fromable>(isFromable), fn.returns(z.lazy(() => z.instanceof(Bool))))
+  @expose(z.custom<Fromable>(isFromable), fn.returns(z.lazy(() => z.instanceof(Bool))))
   leftJoin(from: Fromable, onFn: (ns: any) => Bool<any>): any {
     this.#assertNotInNamespace(from.tsAlias);
     return new QueryBuilder({
@@ -328,7 +328,7 @@ export class QueryBuilder<
   groupBy<G extends Any<any>[]>(
     groupBy: (n: N) => [...G],
   ): QueryBuilder<{ [K in keyof N]: AggregateRow<N[K]> } & G, {}, [...GB, ...G], Card>;
-  @tool(fn.returns(z.array(z.lazy(() => z.instanceof(Any)))).optional())
+  @expose(fn.returns(z.array(z.lazy(() => z.instanceof(Any)))).optional())
   groupBy(groupBy?: (n: N) => Any<any>[]): any {
     const { select: _, ...opts } = this.opts;
     if (!groupBy) {
@@ -344,7 +344,7 @@ export class QueryBuilder<
   }
 
   // Multiple `having` calls are combined with AND
-  @tool(fn.returns(z.lazy(() => z.instanceof(Bool))))
+  @expose(fn.returns(z.lazy(() => z.instanceof(Bool))))
   having(having: (n: N) => Bool<any>): QueryBuilder<N, O, GB> {
     return new QueryBuilder({
       ...this.opts,
@@ -353,7 +353,7 @@ export class QueryBuilder<
   }
 
   // Multiple `orderBy` calls are concatenated (ORDER BY a, b, c).
-  @tool(
+  @expose(
     fn.returns(
       z.union([z.custom<any>(isOrderByEntry), z.array(z.custom<any>(isOrderByEntry)).min(1)]),
     ),
@@ -376,13 +376,13 @@ export class QueryBuilder<
   }
 
   // Multiple `limit` calls are combined with `MIN` (safest option)
-  @tool(z.int().gte(0))
+  @expose(z.int().gte(0))
   limit(n: number): QueryBuilder<N, O, GB> {
     return new QueryBuilder({ ...this.opts, limit: Math.min(this.opts.limit ?? Infinity, n) });
   }
 
   // Multiple `offset` calls are combined by summing offsets (safest option)
-  @tool(z.int().gte(0))
+  @expose(z.int().gte(0))
   offset(n: number): QueryBuilder<N, O, GB> {
     return new QueryBuilder({ ...this.opts, offset: (this.opts.offset ?? 0) + n });
   }
@@ -390,7 +390,7 @@ export class QueryBuilder<
   // Fluent terminators. Narrow the Sql.execute() return type from
   // QueryResult to a row array, and expose the hydrated / single-row
   // variants as chainable terminators too.
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   override async execute(db: Database<any>): Promise<RowTypeToTsType<O>[]> {
     return db.execute(this);
   }
@@ -398,17 +398,17 @@ export class QueryBuilder<
   // Streaming terminator. Mirrors `execute` but yields the rowset on
   // every committed mutation that touches one of the live-tagged
   // tables this query reads from. Caller iterates with `for await`.
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   live(db: Database<any>): AsyncIterable<RowTypeToTsType<O>[]> {
     return db.live(this) as AsyncIterable<RowTypeToTsType<O>[]>;
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async hydrate(db: Database<any>): Promise<O[]> {
     return db.hydrate<O, GB, Card>(this);
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async one(db: Database<any>): Promise<O> {
     const [row] = await db.hydrate(this.limit(1));
     if (!row) {
@@ -417,7 +417,7 @@ export class QueryBuilder<
     return row;
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async maybeOne(db: Database<any>): Promise<O | null> {
     const [row] = await db.hydrate(this.limit(1));
     return row ?? null;
@@ -433,7 +433,7 @@ export class QueryBuilder<
       ? Record<O, 0 | 1>
       : Anyarray<Record<O, 1>, 1>;
   /* eslint-enable @typescript-eslint/no-restricted-types */
-  @tool()
+  @expose()
   scalar(): any {
     const staticCols = selectList(this.rowType());
     const RecordClass = Record.of(staticCols as any);
@@ -529,12 +529,12 @@ export class QueryBuilder<
     return [this.finalize()];
   }
 
-  @tool(ZCardinality)
+  @expose(ZCardinality)
   cardinality<C extends Cardinality>(card: C): QueryBuilder<N, O, GB, C> {
     return new QueryBuilder(this.opts, card);
   }
 
-  @tool()
+  @expose()
   debug(): this {
     const compiled = compile(this, "pg");
     console.log("Debugging query:", { sql: compiled.text, parameters: compiled.values });
diff --git a/src/builder/update.ts b/src/builder/update.ts
index 3ada669..cfc0f0d 100644
--- a/src/builder/update.ts
+++ b/src/builder/update.ts
@@ -9,7 +9,7 @@ import { combinePredicates, compileSelectList, isRowType, mergeReturning, reAlia
 import type { TableBase } from "../table";
 import { Database } from "../database";
 import { Any, getColumn } from "../types/overrides/any";
-import { fn, tool } from "../exoeval/tool";
+import { fn, expose } from "../exoeval/tool";
 import z from "zod";
 
 type Namespace<Name extends string, T> = { [K in Name]: T };
@@ -78,7 +78,7 @@ export class UpdateBuilder<Name extends string, T extends TableBase, R extends R
   }
 
   // Multiple where() calls are combined with AND. .where(true) matches all rows.
-  @tool(z.union([z.literal(true), fn.returns(z.lazy(() => z.instanceof(Bool)))]))
+  @expose(z.union([z.literal(true), fn.returns(z.lazy(() => z.instanceof(Bool)))]))
   where(fn: ((ns: Namespace<Name, T>) => Bool<any>) | true): UpdateBuilder<Name, T, R> {
     const wrapped: (ns: Namespace<Name, T>) => Bool<any> =
       fn === true ? () => Bool.from(sql`TRUE`) as Bool<any> : fn;
@@ -88,12 +88,12 @@ export class UpdateBuilder<Name extends string, T extends TableBase, R extends R
     });
   }
 
-  @tool(fn.returns(z.custom<any>((v) => isSetRow(v))))
+  @expose(fn.returns(z.custom<any>((v) => isSetRow(v))))
   set(fn: (ns: Namespace<Name, T>) => SetRow<T>): UpdateBuilder<Name, T, R> {
     return new UpdateBuilder({ ...this.#opts, set: fn });
   }
 
-  @tool(fn.returns(z.custom<any>((v) => isRowType(v))))
+  @expose(fn.returns(z.custom<any>((v) => isRowType(v))))
   returning<R2 extends RowType>(fn: (ns: Namespace<Name, T>) => R2): UpdateBuilder<Name, T, R2> {
     return new UpdateBuilder({ ...this.#opts, returning: fn });
   }
@@ -147,17 +147,17 @@ export class UpdateBuilder<Name extends string, T extends TableBase, R extends R
     return [this.finalize()];
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   override async execute(db: Database<any>): Promise<RowTypeToTsType<R>[]> {
     return db.execute(this);
   }
 
-  @tool(z.lazy(() => z.instanceof(Database)))
+  @expose(z.lazy(() => z.instanceof(Database)))
   async hydrate(db: Database<any>): Promise<R[]> {
     return db.hydrate<any, any, R>(this);
   }
 
-  @tool()
+  @expose()
   debug(): this {
     const compiled = compile(this, "pg");
     console.log("Debugging query:", { sql: compiled.text, parameters: compiled.values });
diff --git a/src/database.ts b/src/database.ts
index fe52d6e..2a2d487 100644
--- a/src/database.ts
+++ b/src/database.ts
@@ -186,6 +186,16 @@ export class Database<C = undefined> {
     });
   }
 
+  // Shut the underlying connection pool. Without this, scripts hang
+  // after their last query because pg's idle-timeout has to expire
+  // before node can exit. Idempotent on the driver side.
+  async close(): Promise<void> {
+    if (this.#boundExecute) {
+      throw new Error("close() must be called on a pool-backed Database, not inside a transaction");
+    }
+    await this.driver.close();
+  }
+
   // Entry point for non-Table Fromables (SRFs, Values, subqueries) —
   // Table classes have their own static `.from()`.
   public from<R extends RowType, A extends string>(
diff --git a/src/exoeval/builtins.ts b/src/exoeval/builtins.ts
index 2d9736a..540cfbe 100644
--- a/src/exoeval/builtins.ts
+++ b/src/exoeval/builtins.ts
@@ -3,10 +3,10 @@ import type { IExoArray, IExoBoolean, IExoDate, IExoJSON, IExoMath, IExoNumber,
 import sjson from 'secure-json-parse'
 import z from 'zod'
 import { isPlainObject } from './expr'
-import { expr, fn, tool } from './tool'
+import { expr, fn, expose } from './tool'
 import { disallowedProperties } from './utils'
 
-@tool()
+@expose()
 export class ExoArray<T = unknown> implements IExoArray<T> {
 	constructor(...args: Parameters<typeof Array>) {
 		return new Array(...args) as unknown as ExoArray<T>
@@ -14,7 +14,7 @@ export class ExoArray<T = unknown> implements IExoArray<T> {
 
 	[index: number]: T
 
-	@tool()
+	@expose()
 	get length(): number {
 		if (!Array.isArray(this)) {
 			throw new TypeError('unexpected: `this` not bound to an array')
@@ -22,105 +22,105 @@ export class ExoArray<T = unknown> implements IExoArray<T> {
 		return this.length
 	}
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get map() { return Array.prototype.map }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get filter() { return Array.prototype.filter }
 
-	@tool(fn.returns(z.any()), z.any().optional())
+	@expose(fn.returns(z.any()), z.any().optional())
 	get reduce() { return Array.prototype.reduce }
 
-	@tool(fn.returns(z.any()), z.any().optional())
+	@expose(fn.returns(z.any()), z.any().optional())
 	get reduceRight() { return Array.prototype.reduceRight }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get find() { return Array.prototype.find }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get findIndex() { return Array.prototype.findIndex }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get findLast() { return Array.prototype.findLast }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get findLastIndex() { return Array.prototype.findLastIndex }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get some() { return Array.prototype.some }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get every() { return Array.prototype.every }
 
-	@tool(fn.returns(z.any()))
+	@expose(fn.returns(z.any()))
 	get flatMap() { return Array.prototype.flatMap }
 
-	@tool(fn.returns(z.void()))
+	@expose(fn.returns(z.void()))
 	get forEach() { return Array.prototype.forEach }
 
-	@tool(fn.returns(z.any()).optional())
+	@expose(fn.returns(z.any()).optional())
 	get toSorted() { return Array.prototype.toSorted }
 
-	@tool(z.number())
+	@expose(z.number())
 	get at() { return Array.prototype.at }
 
-	@tool(z.number().optional(), z.number().optional())
+	@expose(z.number().optional(), z.number().optional())
 	get slice() { return Array.prototype.slice }
 
-	@tool(z.string().optional())
+	@expose(z.string().optional())
 	get join() { return Array.prototype.join }
 
-	@tool(z.array(z.any()))
+	@expose(z.array(z.any()))
 	get concat() { return Array.prototype.concat }
 
-	@tool(z.any(), z.number().optional())
+	@expose(z.any(), z.number().optional())
 	get indexOf() { return Array.prototype.indexOf }
 
-	@tool(z.any(), z.number().optional())
+	@expose(z.any(), z.number().optional())
 	get lastIndexOf() { return Array.prototype.lastIndexOf }
 
-	@tool(z.any())
+	@expose(z.any())
 	get includes() { return Array.prototype.includes }
 
-	@tool(z.number().optional())
+	@expose(z.number().optional())
 	get flat() { return Array.prototype.flat }
 
-	@tool()
+	@expose()
 	get entries() { return Array.prototype.entries }
 
-	@tool()
+	@expose()
 	get keys() { return Array.prototype.keys }
 
-	@tool()
+	@expose()
 	get values() { return Array.prototype.values }
 
-	@tool()
+	@expose()
 	get toReversed() { return Array.prototype.toReversed }
 
-	@tool(z.number(), z.number().optional(), z.any().optional())
+	@expose(z.number(), z.number().optional(), z.any().optional())
 	get toSpliced() { return Array.prototype.toSpliced }
 
-	@tool(z.number(), z.any())
+	@expose(z.number(), z.any())
 	get with() { return Array.prototype.with }
 
-	@tool()
+	@expose()
 	get toString() { return Array.prototype.toString }
 
 	// Statics
-	@tool(z.array(z.any()))
+	@expose(z.array(z.any()))
 	static from(arrayLike: ArrayLike<unknown>) { return Array.from(arrayLike) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static isArray(value: unknown) { return Array.isArray(value) }
 }
 
-@tool(z.union([z.string(), z.number(), z.instanceof(Date), z.boolean(), z.null(), z.undefined(), z.bigint()]))
+@expose(z.union([z.string(), z.number(), z.instanceof(Date), z.boolean(), z.null(), z.undefined(), z.bigint()]))
 export class ExoString implements IExoString {
 	constructor(...args: Parameters<typeof String>) {
 		return new String(...args) as unknown as ExoString
 	}
 
-	@tool()
+	@expose()
 	get length(): number {
 		if (!(typeof this === 'string')) {
 			throw new TypeError('unexpected: `this` not bound to a string')
@@ -128,80 +128,80 @@ export class ExoString implements IExoString {
 		return (this as string).length
 	}
 
-	@tool(z.number())
+	@expose(z.number())
 	get at() { return String.prototype.at }
 
-	@tool(z.number())
+	@expose(z.number())
 	get charAt() { return String.prototype.charAt }
 
-	@tool(z.number())
+	@expose(z.number())
 	get charCodeAt() { return String.prototype.charCodeAt }
 
-	@tool(z.number())
+	@expose(z.number())
 	get codePointAt() { return String.prototype.codePointAt }
 
-	@tool(z.string())
+	@expose(z.string())
 	get concat() { return String.prototype.concat }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get endsWith() { return String.prototype.endsWith }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get includes() { return String.prototype.includes }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get indexOf() { return String.prototype.indexOf }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get lastIndexOf() { return String.prototype.lastIndexOf }
 
-	@tool(z.number(), z.string().optional())
+	@expose(z.number(), z.string().optional())
 	get padEnd() { return String.prototype.padEnd }
 
-	@tool(z.number(), z.string().optional())
+	@expose(z.number(), z.string().optional())
 	get padStart() { return String.prototype.padStart }
 
-	@tool(z.number())
+	@expose(z.number())
 	get repeat() { return String.prototype.repeat }
 
-	@tool(z.string(), z.string())
+	@expose(z.string(), z.string())
 	get replace() { return String.prototype.replace }
 
-	@tool(z.string(), z.string())
+	@expose(z.string(), z.string())
 	get replaceAll() { return String.prototype.replaceAll }
 
-	@tool(z.number().optional(), z.number().optional())
+	@expose(z.number().optional(), z.number().optional())
 	get slice() { return String.prototype.slice }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get split() { return String.prototype.split }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	get startsWith() { return String.prototype.startsWith }
 
-	@tool(z.number().optional(), z.number().optional())
+	@expose(z.number().optional(), z.number().optional())
 	get substring() { return String.prototype.substring }
 
-	@tool()
+	@expose()
 	get toLowerCase() { return String.prototype.toLowerCase }
 
-	@tool()
+	@expose()
 	get toUpperCase() { return String.prototype.toUpperCase }
 
-	@tool()
+	@expose()
 	get trim() { return String.prototype.trim }
 
-	@tool()
+	@expose()
 	get trimEnd() { return String.prototype.trimEnd }
 
-	@tool()
+	@expose()
 	get trimStart() { return String.prototype.trimStart }
 
-	@tool()
+	@expose()
 	get toString() { return String.prototype.toString }
 }
 
-@tool(z.union([z.string(), z.number(), z.instanceof(Date)]).optional())
+@expose(z.union([z.string(), z.number(), z.instanceof(Date)]).optional())
 export class ExoDate implements IExoDate {
 	constructor()
 	constructor(value: string | number | Date)
@@ -211,53 +211,53 @@ export class ExoDate implements IExoDate {
 	}
 
 	// Date.prototype methods require native Date as this; bind raw so asTool receives correct receiver
-	@tool()
+	@expose()
 	get getTime() { return Date.prototype.getTime }
 
-	@tool()
+	@expose()
 	get getFullYear() { return Date.prototype.getFullYear }
 
-	@tool()
+	@expose()
 	get getMonth() { return Date.prototype.getMonth }
 
-	@tool()
+	@expose()
 	get getDate() { return Date.prototype.getDate }
 
-	@tool()
+	@expose()
 	get getHours() { return Date.prototype.getHours }
 
-	@tool()
+	@expose()
 	get getMinutes() { return Date.prototype.getMinutes }
 
-	@tool()
+	@expose()
 	get getSeconds() { return Date.prototype.getSeconds }
 
-	@tool()
+	@expose()
 	get getMilliseconds() { return Date.prototype.getMilliseconds }
 
-	@tool()
+	@expose()
 	get toISOString() { return Date.prototype.toISOString }
 
-	@tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
+	@expose(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
 	get toLocaleDateString() { return Date.prototype.toLocaleDateString }
 
-	@tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
+	@expose(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
 	get toLocaleTimeString() { return Date.prototype.toLocaleTimeString }
 
-	@tool(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
+	@expose(z.string().optional(), z.record(z.string(), z.union([z.string(), z.boolean(), z.undefined()])).optional())
 	get toLocaleString() { return Date.prototype.toLocaleString }
 
-	@tool()
+	@expose()
 	get valueOf() { return Date.prototype.valueOf }
 
-	@tool()
+	@expose()
 	get toString() { return Date.prototype.toString }
 
 	// Statics
-	@tool()
+	@expose()
 	static now() { return Date.now() }
 
-	@tool(z.string())
+	@expose(z.string())
 	static parse(dateString: string) { return Date.parse(dateString) }
 }
 
@@ -291,7 +291,7 @@ export class ExoObject {
 		)
 	}
 
-	@tool(z.array(z.tuple([z.intersection(z.string(), z.custom((k: unknown) => !disallowedProperties.has(k as string), {
+	@expose(z.array(z.tuple([z.intersection(z.string(), z.custom((k: unknown) => !disallowedProperties.has(k as string), {
 		error: (k: { input: unknown }) => `${k.input} is not an allowed property name`,
 	})), z.any()])))
 	static fromEntries(entries: [string, unknown][]) {
@@ -299,106 +299,106 @@ export class ExoObject {
 	}
 }
 
-@tool(z.any())
+@expose(z.any())
 export class ExoBoolean implements IExoBoolean {
 	constructor(...args: Parameters<typeof Boolean>) {
 		return new Boolean(...args)
 	}
 
-	@tool()
+	@expose()
 	get valueOf() { return Boolean.prototype.valueOf }
 
-	@tool()
+	@expose()
 	get toString() { return Boolean.prototype.toString }
 }
 
 export class ExoJSON {
-	@tool(z.string())
+	@expose(z.string())
 	static parse(text: string) { return sjson.parse(text) }
 
-	@tool(z.any(), z.union([z.null(), z.undefined()]), z.number().optional())
+	@expose(z.any(), z.union([z.null(), z.undefined()]), z.number().optional())
 	static stringify(value: unknown, replacer?: null, space?: number) {
 		return JSON.stringify(value, replacer, space)
 	}
 }
 
 export class ExoMath {
-	@tool(z.number(), z.number())
+	@expose(z.number(), z.number())
 	static min(a: number, b: number) { return Math.min(a, b) }
 
-	@tool(z.number(), z.number())
+	@expose(z.number(), z.number())
 	static max(a: number, b: number) { return Math.max(a, b) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static round(x: number) { return Math.round(x) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static floor(x: number) { return Math.floor(x) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static ceil(x: number) { return Math.ceil(x) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static abs(x: number) { return Math.abs(x) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static sqrt(x: number) { return Math.sqrt(x) }
 
-	@tool(z.number(), z.number())
+	@expose(z.number(), z.number())
 	static pow(base: number, exp: number) { return base ** exp }
 
-	@tool(z.number())
+	@expose(z.number())
 	static log(x: number) { return Math.log(x) }
 
-	@tool()
+	@expose()
 	static random() { return Math.random() }
 
-	@tool(z.number())
+	@expose(z.number())
 	static sign(x: number) { return Math.sign(x) }
 
-	@tool(z.number())
+	@expose(z.number())
 	static trunc(x: number) { return Math.trunc(x) }
 }
 
 export class ExoPromise {
-	@tool(z.array(z.any()))
+	@expose(z.array(z.any()))
 	static all(values: unknown[]) { return Promise.all(values as Promise<unknown>[]) }
 
-	@tool(z.array(z.any()))
+	@expose(z.array(z.any()))
 	static allSettled(values: unknown[]) { return Promise.allSettled(values as Promise<unknown>[]) }
 
-	@tool(z.array(z.any()))
+	@expose(z.array(z.any()))
 	static race(values: unknown[]) { return Promise.race(values as Promise<unknown>[]) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static resolve(value: unknown) { return Promise.resolve(value) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static reject(reason: unknown) { return Promise.reject(reason) }
 }
 
-@tool(z.union([z.string(), z.number(), z.bigint()]))
+@expose(z.union([z.string(), z.number(), z.bigint()]))
 export class ExoNumber implements IExoNumber {
 	constructor(...args: Parameters<typeof Number>) {
 		return new Number(...args)
 	}
 
-	@tool(z.number().optional())
+	@expose(z.number().optional())
 	get toString() { return Number.prototype.toString }
 
-	@tool(z.string(), z.number().optional())
+	@expose(z.string(), z.number().optional())
 	static parseInt(s: string, radix?: number) { return Number.parseInt(s, radix) }
 
-	@tool(z.string())
+	@expose(z.string())
 	static parseFloat(s: string) { return Number.parseFloat(s) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static isNaN(value: unknown) { return Number.isNaN(value) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static isFinite(value: unknown) { return Number.isFinite(value) }
 
-	@tool(z.any())
+	@expose(z.any())
 	static isInteger(value: unknown) { return Number.isInteger(value) }
 }
 
diff --git a/src/exoeval/evaluator.test.ts b/src/exoeval/evaluator.test.ts
index f895862..ac247f6 100644
--- a/src/exoeval/evaluator.test.ts
+++ b/src/exoeval/evaluator.test.ts
@@ -1,10 +1,10 @@
 import { describe, expect, it } from 'vitest'
 import z from 'zod'
 import { exoEval } from './index'
-import { tool } from './tool'
+import { expose } from './tool'
 
 class MockCalc {
-	@tool(z.number(), z.number())
+	@expose(z.number(), z.number())
 	add(a: number, b: number): number { return a + b }
 }
 
@@ -839,7 +839,7 @@ describe('exoEval', () => {
 			expect(exoEval('x', { x: 42 })).toBe(42)
 		})
 
-		it('injected @tool() objects are callable', () => {
+		it('injected @expose() objects are callable', () => {
 			expect(exoEval('calc.add(1, 2)', { calc: new MockCalc() })).toBe(3)
 		})
 
diff --git a/src/exoeval/index.ts b/src/exoeval/index.ts
index 188b4d7..3f4db9b 100644
--- a/src/exoeval/index.ts
+++ b/src/exoeval/index.ts
@@ -5,7 +5,7 @@ import { Evaluator } from './evaluator'
 import { ExpressionContext, IdentityContext } from './expr'
 import { Scope } from './scope'
 
-export { asToolFn, tool } from './tool'
+export { asToolFn, expose } from './tool'
 export type { ToolFunction } from './tool'
 export { RpcClient, inMemoryChannel, safeStringify } from './rpc'
 export type { RawChannel } from './rpc'
diff --git a/src/exoeval/rpc.test.ts b/src/exoeval/rpc.test.ts
index 760655e..e1d4fe6 100644
--- a/src/exoeval/rpc.test.ts
+++ b/src/exoeval/rpc.test.ts
@@ -1,5 +1,5 @@
 import { describe, test, expect } from "vitest";
-import { tool } from "./tool";
+import { expose } from "./tool";
 import { RpcClient, inMemoryChannel } from "./rpc";
 
 // Minimal end-to-end test of the exoeval RPC mechanism, in-memory.
@@ -16,20 +16,20 @@ import { RpcClient, inMemoryChannel } from "./rpc";
 // handler so the tests exercise the protocol without any wire machinery.
 
 // Test fixture: the surface here exists to drive the protocol, not to
-// validate args. Production callers always use @tool(zSchema).
+// validate args. Production callers always use @expose(zSchema).
 /* eslint-disable no-restricted-syntax -- test fixture */
 class Api {
-  @tool.unchecked()
+  @expose.unchecked()
   greet(name: string): string {
     return `Hello, ${name}!`;
   }
 
-  @tool.unchecked()
+  @expose.unchecked()
   add(a: number, b: number): number {
     return a + b;
   }
 
-  @tool.unchecked()
+  @expose.unchecked()
   echo<T>(value: T): T {
     return value;
   }
@@ -69,10 +69,10 @@ describe("exoeval rpc — in-memory", () => {
   });
 
   // Demonstrates the safeStringify guard: even though `Leaky` has a method
-  // (callable via @tool) that returns the receiver itself, the response
+  // (callable via @expose) that returns the receiver itself, the response
   // serializer refuses to walk a class instance. Without this check, every
   // own-enumerable instance field of `Leaky` would leak into the wire even
-  // though only `getSelf` is @tool-marked.
+  // though only `getSelf` is @expose-marked.
   test("safeStringify refuses to serialize a class instance returned from the wire", async () => {
     class Leaky {
       // TS-private is *not* runtime-private — `secret` is an own enumerable
@@ -80,7 +80,7 @@ describe("exoeval rpc — in-memory", () => {
       // emit it; safeStringify catches the class-instance return.
       private secret = "internals";
 
-      @tool()
+      @expose()
       getSelf(): Leaky {
         return this;
       }
@@ -94,7 +94,7 @@ describe("exoeval rpc — in-memory", () => {
   test("plain arrays are NOT streamed (one-shot semantics preserved)", async () => {
     class ListApi {
       // eslint-disable-next-line no-restricted-syntax -- test fixture
-      @tool.unchecked()
+      @expose.unchecked()
       list(): number[] {
         return [10, 20, 30];
       }
@@ -107,7 +107,7 @@ describe("exoeval rpc — in-memory", () => {
   test("runIter streams items from an async iterable", async () => {
     class AsyncStreamApi {
       // eslint-disable-next-line no-restricted-syntax -- test fixture
-      @tool.unchecked()
+      @expose.unchecked()
       async *ticks(n: number): AsyncIterable<{ i: number }> {
         for (let i = 0; i < n; i++) {yield { i };}
       }
@@ -121,7 +121,7 @@ describe("exoeval rpc — in-memory", () => {
   test("await on a streaming closure resolves to the first chunk", async () => {
     class TickApi {
       // eslint-disable-next-line no-restricted-syntax -- test fixture
-      @tool.unchecked()
+      @expose.unchecked()
       async *ticks(n: number): AsyncIterable<number> {
         for (let i = 0; i < n; i++) {yield i;}
       }
@@ -133,9 +133,9 @@ describe("exoeval rpc — in-memory", () => {
     expect(first).toBe(0);
   });
 
-  test("non-@tool methods are not callable from the wire", async () => {
+  test("non-@expose methods are not callable from the wire", async () => {
     class Internal {
-      @tool()
+      @expose()
       open(): string {
         return "ok";
       }
diff --git a/src/exoeval/tool.test.ts b/src/exoeval/tool.test.ts
index 9090f8d..c8a57c2 100644
--- a/src/exoeval/tool.test.ts
+++ b/src/exoeval/tool.test.ts
@@ -1,7 +1,7 @@
 import { describe, expect, it } from 'vitest'
 import { z } from 'zod'
 import { exoEval } from './index'
-import { fn, isToolableFunction, tool, toolFieldsSymbol, toolSymbol } from './tool'
+import { fn, isToolableFunction, expose, toolFieldsSymbol, toolSymbol } from './tool'
 
 class SampleToolset {
 	value = 10
@@ -14,12 +14,12 @@ class SampleToolset {
 		return x + y
 	}
 
-	@tool(z.number(), z.number())
+	@expose(z.number(), z.number())
 	add(x: number, y: number) {
 		return this.value + x + y
 	}
 
-	@tool()
+	@expose()
 	getValue() {
 		return this.value
 	}
@@ -65,10 +65,10 @@ describe('getter decorator', () => {
 	class WithGetters {
 		private data = [1, 2, 3]
 
-		@tool()
+		@expose()
 		get length() { return this.data.length }
 
-		@tool(fn.returns(z.any()))
+		@expose(fn.returns(z.any()))
 		get map() { return this.data.map.bind(this.data) }
 
 		// Non-tool getter
@@ -108,7 +108,7 @@ describe('getter decorator', () => {
 	it('getter-returned function runtime validation rejects invalid callback result (direct and exoEval)', () => {
 		class WithValidatedMap {
 			private data = [1, 2, 3]
-			@tool(fn.returns(z.array(z.number())))
+			@expose(fn.returns(z.array(z.number())))
 			get map() { return this.data.map.bind(this.data) }
 		}
 		const instance = new WithValidatedMap()
@@ -124,14 +124,14 @@ describe('getter decorator', () => {
 })
 
 describe('class decorator', () => {
-	@tool(z.any().optional())
+	@expose(z.any().optional())
 	class Constructable {
 		readonly value: number
 		constructor(value?: number) {
 			this.value = value ?? 42
 		}
 
-		@tool()
+		@expose()
 		get val() { return this.value }
 	}
 
@@ -158,7 +158,7 @@ describe('class decorator', () => {
 	})
 
 	it('class constructor runtime arg validation rejects invalid args (direct and exoEval)', () => {
-		@tool(z.number())
+		@expose(z.number())
 		class NumOnly {
 			constructor(public n: number) {}
 		}
@@ -172,10 +172,10 @@ describe('class decorator', () => {
 
 describe('field decorator', () => {
 	class WithFields {
-		@tool()
+		@expose()
 		label = 'hello'
 
-		@tool(z.number())
+		@expose(z.number())
 		compute = (x: number) => x * 2
 
 		plain = 'not a tool'
@@ -220,10 +220,10 @@ describe('field decorator', () => {
 
 describe('static decorator', () => {
 	class WithStatics {
-		@tool(z.number(), z.number())
+		@expose(z.number(), z.number())
 		static add(a: number, b: number) { return a + b }
 
-		@tool()
+		@expose()
 		static get name2() { return 'test' }
 	}
 
@@ -251,32 +251,32 @@ describe('static decorator', () => {
 	})
 })
 
-describe('@tool type checking', () => {
+describe('@expose type checking', () => {
 	it('rejects schema/method type mismatches', () => {
 		// These should all produce TypeScript errors.
 		// If the @ts-expect-error is unnecessary (no error), the test itself fails.
 
 		class _TypeChecks {
 			// @ts-expect-error — z.string() does not match number parameter
-			@tool(z.string())
+			@expose(z.string())
 			numMethod(x: number) { return x }
 
 			// @ts-expect-error — too few schemas (expects 2 args, only 1 schema)
-			@tool(z.number())
+			@expose(z.number())
 			twoArgs(a: number, b: number) { return a + b }
 
 			// @ts-expect-error — wrong schema type for second param
-			@tool(z.number(), z.boolean())
+			@expose(z.number(), z.boolean())
 			stringSecond(a: number, b: string) { return `${a}${b}` }
 		}
 	})
 })
 
 describe('tool with function argument', () => {
-	it('can pass arrow function from exoeval to @tool method', () => {
+	it('can pass arrow function from exoeval to @expose method', () => {
 		class EventSource {
 			callbacks: Array<(x: number) => number> = []
-			@tool(z.any())
+			@expose(z.any())
 			onEvent(cb: (x: number) => number) {
 				this.callbacks.push(cb)
 			}
diff --git a/src/exoeval/tool.ts b/src/exoeval/tool.ts
index a488b03..3cd8cd7 100644
--- a/src/exoeval/tool.ts
+++ b/src/exoeval/tool.ts
@@ -62,7 +62,7 @@ export const registerToolField = (obj: unknown, key: string) => {
 }
 
 /**
- * @tool decorator - marks a method, getter, field, or class as a tool
+ * @expose decorator - marks a method, getter, field, or class as a tool
  *
  * Methods: returns a replacement function on the prototype with validation + toolSymbol.
  * Getters: returns a replacement getter with toolSymbol on the function.
@@ -71,12 +71,12 @@ export const registerToolField = (obj: unknown, key: string) => {
  *          If value is a function with schemas, wraps with asTool.
  * Classes: returns replacement class with constructor validation + toolSymbol.
  *
- * NOTE: @tool() on a class means `new MyClass(...)` is callable by sandboxed code
+ * NOTE: @expose() on a class means `new MyClass(...)` is callable by sandboxed code
  * that has a reference to it. This is intended for builtins (e.g. `new Date`, `new Map`)
  * where construction is part of the API. For capability classes where you want to expose
  * only methods (not construction), don't decorate the class — just decorate the methods.
  */
-export function tool<Schemas extends StandardSchemaV1[]>(
+export function expose<Schemas extends StandardSchemaV1[]>(
 	...argSchemas: Schemas
 ): {
 	<This, Value extends (this: This, ...args: SchemasToParams<Schemas>) => any>(
@@ -97,7 +97,7 @@ export function tool<Schemas extends StandardSchemaV1[]>(
 		context: ClassDecoratorContext<Value>,
 	): void
 }
-export function tool<Schemas extends StandardSchemaV1[]>(...argSchemas: Schemas) {
+export function expose<Schemas extends StandardSchemaV1[]>(...argSchemas: Schemas) {
 	return function (
 		target: any,
 		context: ClassMethodDecoratorContext | ClassGetterDecoratorContext | ClassFieldDecoratorContext | ClassDecoratorContext,
@@ -168,14 +168,14 @@ export const expr = () => (target: any, _context: ClassMethodDecoratorContext):
 }
 
 /**
- * @tool.unchecked - marks a method as exposed to exoeval without arg validation.
+ * @expose.unchecked - marks a method as exposed to exoeval without arg validation.
  * For cases where the host already validates args internally
  */
 const uncheckedImpl = () => {
 	// `ClassMethodDecoratorContext<any, any>` (rather than the unparameterized
 	// default of `<unknown, (this: unknown, ...args: any) => any>`) so the
 	// caller's `this`/args shape stays whatever the method declares
-	// (e.g. `Any.in<T>(this: T, ...vals)`). tool.unchecked is the escape
+	// (e.g. `Any.in<T>(this: T, ...vals)`). expose.unchecked is the escape
 	// hatch precisely so TS doesn't have to project a fixed shape onto it.
 	return function (
 		target: any,
@@ -186,12 +186,12 @@ const uncheckedImpl = () => {
 	}
 }
 
-// Namespace-merge so callers can write `@tool.unchecked()` after a single
-// `import { tool } from "..."`.
-export namespace tool {
+// Namespace-merge so callers can write `@expose.unchecked()` after a single
+// `import { expose } from "..."`.
+export namespace expose {
 	export const unchecked = uncheckedImpl
 }
-;(tool as any).unchecked = uncheckedImpl
+;(expose as any).unchecked = uncheckedImpl
 
 export const asToolFn = <Schemas extends StandardSchemaV1[], T extends (...args: SchemasToParams<Schemas>) => unknown>(fn: T, schemas: Schemas): T & ToolFunction => {
 	const name = fn.name || 'anonymous'
diff --git a/src/index.ts b/src/index.ts
index c017afb..b3c0d05 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -5,7 +5,7 @@ export { sql, Sql } from "./builder/sql";
 export { QueryBuilder } from "./builder/query";
 export { PgDriver, PgliteDriver } from "./driver";
 export { TypegresLiveEvents } from "./live/events";
-export { tool } from "./exoeval/tool";
+export { expose } from "./exoeval/tool";
 export type { ToolFunction } from "./exoeval/tool";
 export { RpcClient, inMemoryChannel, safeStringify } from "./exoeval/rpc";
 export type { RawChannel } from "./exoeval/rpc";
diff --git a/src/readme.test.ts b/src/readme.test.ts
new file mode 100644
index 0000000..4bf3b93
--- /dev/null
+++ b/src/readme.test.ts
@@ -0,0 +1,139 @@
+// End-to-end test that the README's Usage snippet actually runs against
+// a fresh `npm install`. Catches drift between the README and the API
+// surface — anything that breaks the snippet (renamed export, changed
+// init signature, decorator semantics) fails this test in CI before the
+// README ever gets to a reader.
+//
+// Two install modes:
+//   - working-tree (default): `npm install file:<repo>`, which packs the
+//     local repo internally and honors the package.json `files`
+//     manifest. Tests what the README *will* be when this code
+//     publishes — catches drift in PRs. Requires dist/ to be built.
+//   - registry (TYPEGRES_README_TEST_REGISTRY=1): install `typegres`
+//     from npm. Tests what the README *currently is* for someone
+//     running it against the latest published version. Useful
+//     post-release.
+//
+// Why swc and not tsx / node strip-types: Node can strip TS types but
+// doesn't transform stage-3 decorators yet, and the snippet uses
+// `@expose()` on every column. We compile via @swc/core (already a dep)
+// and run the JS output with plain node — no extra runner to install.
+
+import { test, expect } from "vitest";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import * as swc from "@swc/core";
+import { sql } from "./builder/sql";
+import { setupDb, db } from "./test-helpers";
+import { requireDatabaseUrl } from "./pg";
+
+const execFileP = promisify(execFile);
+const REPO_ROOT = path.resolve(import.meta.dirname, "..");
+const README_PATH = path.join(REPO_ROOT, "README.md");
+
+setupDb();
+
+type InstallMode = "working-tree" | "registry";
+
+const runReadmeUsage = async (mode: InstallMode): Promise<void> => {
+  const readme = fs.readFileSync(README_PATH, "utf8");
+  // Scope to the Usage section so we don't pick up code blocks from
+  // other sections (Development, Status, etc.).
+  const usageSection = /## Usage[\s\S]*?(?=\n## |$)/.exec(readme)?.[0] ?? "";
+  const bashSnippet = /```bash\n([\s\S]*?)```/.exec(usageSection)?.[1]?.trim();
+  const tsSnippet = /```typescript\n([\s\S]*?)```/.exec(usageSection)?.[1];
+  if (!bashSnippet || !tsSnippet) {
+    throw new Error(
+      "README: couldn't find both ```bash``` and ```typescript``` blocks under ## Usage",
+    );
+  }
+
+  // working-tree mode installs from the repo via a file: reference,
+  // which honors `files: ["dist"]` — so dist/ must be built.
+  if (mode === "working-tree" && !fs.existsSync(path.join(REPO_ROOT, "dist", "index.mjs"))) {
+    throw new Error("working-tree mode needs dist/ — run `npm run build` first");
+  }
+
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), `typegres-readme-${mode}-`));
+  try {
+    fs.writeFileSync(
+      path.join(tmpDir, "package.json"),
+      JSON.stringify({ name: "readme-test", type: "module", private: true }),
+    );
+
+    // working-tree: file: reference to the repo. npm packs the local
+    // directory using the `files` manifest internally — same effect as
+    // `npm pack && npm install <tarball>`, no tarball management.
+    // registry: install verbatim from npm.
+    //
+    // Flags shave ~3-5s off install: skip the security audit (we're a
+    // disposable tmp dir), skip funding messages, prefer the offline
+    // cache before hitting the registry.
+    const installCmd = (
+      mode === "working-tree"
+        ? bashSnippet.replace(/\btypegres\b/, JSON.stringify(`file:${REPO_ROOT}`))
+        : bashSnippet
+    ).replace(/\bnpm install\b/, "npm install --no-audit --no-fund --prefer-offline");
+    await execFileP("sh", ["-c", installCmd], { cwd: tmpDir });
+
+    // Compile the snippet via swc — handles stage-3 decorators that
+    // node's strip-types alone can't transform.
+    const compiled = await swc.transform(tsSnippet, {
+      filename: "main.ts",
+      jsc: {
+        target: "es2022",
+        parser: { syntax: "typescript", decorators: true },
+        transform: { decoratorVersion: "2022-03" },
+      },
+      module: { type: "es6" },
+      isModule: true,
+    });
+    fs.writeFileSync(path.join(tmpDir, "main.mjs"), compiled.code);
+
+    // Seed the per-worker schema with what the snippet expects.
+    await db.execute(sql`CREATE TABLE users (
+      id         int8 GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+      first_name text NOT NULL,
+      last_name  text NOT NULL
+    )`);
+    await db.execute(sql`INSERT INTO users (first_name, last_name) VALUES
+      ('Alice', 'Smith'),
+      ('Bob', 'Jones')`);
+
+    // Same DB; PGOPTIONS pins search_path to the worker schema so bare
+    // `users` resolves into the test's namespace.
+    const schema = `test_w${process.env["VITEST_WORKER_ID"] ?? "1"}`;
+    const { stdout } = await execFileP("node", ["main.mjs"], {
+      cwd: tmpDir,
+      env: {
+        ...process.env,
+        DATABASE_URL: requireDatabaseUrl(),
+        PGOPTIONS: `-csearch_path=${schema}`,
+      },
+    });
+
+    expect(stdout).toContain("Alice Smith");
+    expect(stdout).toContain("Bob Jones");
+  } finally {
+    await db.execute(sql`DROP TABLE IF EXISTS users`).catch(() => {});
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+};
+
+test(
+  "README.md Usage snippet — working tree (file:)",
+  () => runReadmeUsage("working-tree"),
+  30_000, // typical: ~2s; generous for slow npm cache misses.
+);
+
+// Registry mode: opt-in via env var. Tests the currently-published
+// `typegres` against the README — useful post-release. Skipped by
+// default so PR CI doesn't fail on registry hiccups or version drift.
+test.runIf(process.env["TYPEGRES_README_TEST_REGISTRY"] === "1")(
+  "README.md Usage snippet — registry (npm install typegres)",
+  () => runReadmeUsage("registry"),
+  120_000,
+);
diff --git a/src/rpc.test.ts b/src/rpc.test.ts
index ec5d81a..1affd6d 100644
--- a/src/rpc.test.ts
+++ b/src/rpc.test.ts
@@ -1,7 +1,7 @@
 import { describe, test, expect } from "vitest";
 import { sql, Table, Int8, Text } from "typegres";
 import type { Database } from "typegres";
-import { tool } from "./exoeval/tool";
+import { expose } from "./exoeval/tool";
 import { RpcClient, inMemoryChannel } from "./exoeval/rpc";
 import { setupDb, withinTransaction } from "./test-helpers";
 setupDb();
@@ -23,26 +23,26 @@ setupDb();
 // The closures inside .where / .select aren't exported as stubs — they're
 // shipped as JS source and re-interpreted server-side under exoeval, with
 // the typegres namespace ({users: <Users instance>}) passed in. Every
-// QueryBuilder method is @tool-decorated, so the builder composes over
+// QueryBuilder method is @expose-decorated, so the builder composes over
 // the wire directly — no host-side wrapper class needed.
 
 class Users extends Table("users") {
-  @tool()
+  @expose()
   id = (Int8<1>).column({ nonNull: true, generated: true });
 
-  @tool()
+  @expose()
   name = (Text<1>).column({ nonNull: true });
 }
 
 class Api {
-  @tool()
+  @expose()
   db: Database;
 
   constructor(db: Database) {
     this.db = db;
   }
 
-  @tool()
+  @expose()
   users() {
     return Users.from();
   }
@@ -50,20 +50,20 @@ class Api {
   // Insert/update/delete entry points. The static methods on TableBase
   // can't be called directly from the wire (the class itself isn't a tool),
   // so expose them through Api methods that return the builder. Each
-  // returned builder is fully @tool-decorated, so the chain composes
+  // returned builder is fully @expose-decorated, so the chain composes
   // server-side.
   // eslint-disable-next-line no-restricted-syntax -- test fixture
-  @tool.unchecked()
+  @expose.unchecked()
   insertUsers(row: { name: string }) {
     return Users.insert(row);
   }
 
-  @tool()
+  @expose()
   updateUsers() {
     return Users.update();
   }
 
-  @tool()
+  @expose()
   deleteUsers() {
     return Users.delete();
   }
diff --git a/src/tables/generate.test.ts b/src/tables/generate.test.ts
index 4df9b3a..ed60b6a 100644
--- a/src/tables/generate.test.ts
+++ b/src/tables/generate.test.ts
@@ -1,6 +1,45 @@
 import { describe, test, expect } from "vitest";
+import * as swc from "@swc/core";
 import { generateTable, type ColumnInfo, type Relation } from "./generate";
 
+// Validate generated code: (1) syntactically valid TS that swc can
+// transform with the same decorator config typegres' build uses;
+// (2) every `@<name>` decorator referenced in the body has a matching
+// import. swc alone catches syntax/transform errors but happily emits
+// `(0, expose)()` even when `expose` isn't imported — the import
+// check closes that gap (caught a rename-drift bug otherwise invisible
+// to inline snapshot tests).
+const validate = async (out: string): Promise<void> => {
+  await swc.transform(out, {
+    filename: "generated.ts",
+    jsc: {
+      target: "es2022",
+      parser: { syntax: "typescript", decorators: true },
+      transform: { decoratorVersion: "2022-03" },
+    },
+    module: { type: "es6" },
+    isModule: true,
+  });
+
+  const decorators = new Set(
+    [...out.matchAll(/@(\w+)(?:\.\w+)?\(/g)].map((m) => m[1]!),
+  );
+  const imported = new Set<string>();
+  for (const m of out.matchAll(/import\s*\{([^}]*)\}/g)) {
+    for (const raw of m[1]!.split(",")) {
+      const id = raw.trim().split(/\s+as\s+/)[0]!.replace(/^type\s+/, "").trim();
+      if (id) {imported.add(id);}
+    }
+  }
+  for (const d of decorators) {
+    if (!imported.has(d)) {
+      throw new Error(
+        `generated code uses @${d}() but doesn't import \`${d}\`. Imports: [${[...imported].join(", ")}]`,
+      );
+    }
+  }
+};
+
 // Helpers — terse fixtures so each test reads as a single intent.
 const col = (
   column_name: string,
@@ -25,8 +64,8 @@ const rel = (name: string, targetTable: string, overrides: Partial<Relation> = {
   ...overrides,
 });
 
-describe("generateTable — new file", () => {
-  test("default emit: @tool on every column + relation, scope+contextOf, full file shape", () => {
+describe("generateTable — new file", async () => {
+  test("default emit: @expose on every column + relation, scope+contextOf, full file shape", async () => {
     const out = generateTable(
       "dogs",
       [
@@ -36,24 +75,25 @@ describe("generateTable — new file", () => {
       [rel("teams", "teams", { cardinality: "one", fromColumn: "team_id", toColumn: "id" })],
       { dbImport: "../db" },
     );
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { Int8, Text, tool } from "typegres";
+      import { Int8, Text, expose } from "typegres";
       import { Teams } from "./teams";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
-        @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-        @tool() name = (Text<1>).column({ nonNull: true });
+        @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+        @expose() name = (Text<1>).column({ nonNull: true });
         // relations
-        @tool() teams() { return Teams.scope(Dogs.contextOf(this)).where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
+        @expose() teams() { return Teams.scope(Dogs.contextOf(this)).where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
         // @generated-end
       }
       "
     `);
   });
 
-  test("column options: nullable, default, generated", () => {
+  test("column options: nullable, default, generated", async () => {
     const out = generateTable(
       "dogs",
       [
@@ -64,15 +104,16 @@ describe("generateTable — new file", () => {
       [],
       { dbImport: "../db" },
     );
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { Int8, Text, Timestamptz, sql, tool } from "typegres";
+      import { Int8, Text, Timestamptz, expose, sql } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
-        @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-        @tool() breed = (Text<0 | 1>).column();
-        @tool() created_at = (Timestamptz<1>).column({ nonNull: true, default: sql\`now()\` });
+        @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+        @expose() breed = (Text<0 | 1>).column();
+        @expose() created_at = (Timestamptz<1>).column({ nonNull: true, default: sql\`now()\` });
         // @generated-end
       }
       "
@@ -80,11 +121,11 @@ describe("generateTable — new file", () => {
   });
 });
 
-describe("generateTable — update mode preserves @tool() state", () => {
+describe("generateTable — update mode preserves @expose() state", async () => {
   const cols: ColumnInfo[] = [col("id", "int8", { identity_generation: "ALWAYS" }), col("name", "text")];
   const rels: Relation[] = [rel("teams", "teams", { cardinality: "one", fromColumn: "team_id", toColumn: "id" })];
 
-  test("entries the user stripped stay stripped on regen", () => {
+  test("entries the user stripped stay stripped on regen", async () => {
     const existing = `import { db } from "../db";
 import { Int8, Text } from "typegres";
 
@@ -98,6 +139,7 @@ export class Dogs extends db.Table("dogs") {
 }
 `;
     const out = generateTable("dogs", cols, rels, { dbImport: "../db", existing });
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
       import { Int8, Text } from "typegres";
@@ -114,44 +156,46 @@ export class Dogs extends db.Table("dogs") {
     `);
   });
 
-  test("entries the user decorated stay decorated on regen", () => {
+  test("entries the user decorated stay decorated on regen", async () => {
     const existing = `import { db } from "../db";
 import { Int8, Text } from "typegres";
-import { tool } from "typegres";
+import { expose } from "typegres";
 
 export class Dogs extends db.Table("dogs") {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-  @tool() name = (Text<1>).column({ nonNull: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() name = (Text<1>).column({ nonNull: true });
   // relations
-  @tool() teams() { return Teams.from().where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
+  @expose() teams() { return Teams.from().where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
   // @generated-end
 }
 `;
     const out = generateTable("dogs", cols, rels, { dbImport: "../db", existing });
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
       import { Int8, Text } from "typegres";
-      import { tool } from "typegres";
+      import { expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
-        @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
-        @tool() name = (Text<1>).column({ nonNull: true });
+        @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
+        @expose() name = (Text<1>).column({ nonNull: true });
         // relations
-        @tool() teams() { return Teams.scope(Dogs.contextOf(this)).where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
+        @expose() teams() { return Teams.scope(Dogs.contextOf(this)).where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
         // @generated-end
       }
       "
     `);
   });
 
-  test("mixed: per-entry preservation", () => {
+  test("mixed: per-entry preservation", async () => {
     const existing = `import { db } from "../db";
+import { Int8, Text, expose } from "typegres";
 
 export class Dogs extends db.Table("dogs") {
   // @generated-start
-  @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
+  @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
   name = (Text<1>).column({ nonNull: true });
   // relations
   teams() { return Teams.from().where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
@@ -159,12 +203,14 @@ export class Dogs extends db.Table("dogs") {
 }
 `;
     const out = generateTable("dogs", cols, rels, { dbImport: "../db", existing });
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
+      import { Int8, Text, expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
-        @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
+        @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
         name = (Text<1>).column({ nonNull: true });
         // relations
         teams() { return Teams.scope(Dogs.contextOf(this)).where(({ teams }) => teams.id["="](this.team_id)).cardinality("one"); }
@@ -174,13 +220,13 @@ export class Dogs extends db.Table("dogs") {
     `);
   });
 
-  test("decorator on previous line is recognized", () => {
+  test("decorator on previous line is recognized", async () => {
     const existing = `import { db } from "../db";
-import { tool } from "typegres";
+import { expose } from "typegres";
 
 export class Dogs extends db.Table("dogs") {
   // @generated-start
-  @tool()
+  @expose()
   id = (Int8<1>).column({ nonNull: true, generated: true });
   name = (Text<1>).column({ nonNull: true });
   // @generated-end
@@ -190,13 +236,14 @@ export class Dogs extends db.Table("dogs") {
       dbImport: "../db",
       existing,
     });
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
-      import { tool } from "typegres";
+      import { expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
-        @tool() id = (Int8<1>).column({ nonNull: true, generated: true });
+        @expose() id = (Int8<1>).column({ nonNull: true, generated: true });
         name = (Text<1>).column({ nonNull: true });
         // @generated-end
       }
@@ -204,8 +251,9 @@ export class Dogs extends db.Table("dogs") {
     `);
   });
 
-  test("schema migration adds new column → new entry decorated by default", () => {
+  test("schema migration adds new column → new entry decorated by default", async () => {
     const existingNoTool = `import { db } from "../db";
+import { Int8, Text, expose } from "typegres";
 
 export class Dogs extends db.Table("dogs") {
   // @generated-start
@@ -219,20 +267,22 @@ export class Dogs extends db.Table("dogs") {
       [],
       { dbImport: "../db", existing: existingNoTool },
     );
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
+      import { Int8, Text, expose } from "typegres";
 
       export class Dogs extends db.Table("dogs") {
         // @generated-start
         id = (Int8<1>).column({ nonNull: true, generated: true });
-        @tool() breed = (Text<0 | 1>).column();
+        @expose() breed = (Text<0 | 1>).column();
         // @generated-end
       }
       "
     `);
   });
 
-  test("update mode does not touch imports / preserves custom comments", () => {
+  test("update mode does not touch imports / preserves custom comments", async () => {
     const existing = `import { db } from "../db";
 import { Int8 } from "typegres";
 // my custom comment
@@ -247,6 +297,7 @@ export class Dogs extends db.Table("dogs") {
       dbImport: "../db",
       existing,
     });
+    await validate(out);
     expect(out).toMatchInlineSnapshot(`
       "import { db } from "../db";
       import { Int8 } from "typegres";
@@ -261,7 +312,7 @@ export class Dogs extends db.Table("dogs") {
     `);
   });
 
-  test("missing markers throws", () => {
+  test("missing markers throws", async () => {
     const existing = `export class Dogs extends db.Table("dogs") {}\n`;
     expect(() => generateTable("dogs", cols, rels, { dbImport: "../db", existing })).toThrow(
       /Missing @generated-start/,
diff --git a/src/tables/generate.ts b/src/tables/generate.ts
index 848edb4..139842e 100644
--- a/src/tables/generate.ts
+++ b/src/tables/generate.ts
@@ -169,14 +169,14 @@ const generateColumnLine = (col: ColumnInfo, withTool: boolean): string => {
     opts.push("generated: true");
   }
   const optsArg = opts.length > 0 ? `{ ${opts.join(", ")} }` : "";
-  const prefix = withTool ? "@tool() " : "";
+  const prefix = withTool ? "@expose() " : "";
   return `  ${prefix}${col.column_name} = (${cls}<${nullable}>).column(${optsArg});`;
 };
 
 const generateRelationLine = (rel: Relation, currentTable: string, withTool: boolean): string => {
   const targetClass = pgNameToClassName(rel.targetTable);
   const currentClass = pgNameToClassName(currentTable);
-  const prefix = withTool ? "@tool() " : "";
+  const prefix = withTool ? "@expose() " : "";
   // `Target.scope(Current.contextOf(this))` propagates the row's
   // scope tag through every relation traversal — joins n-deep stay
   // bound to the same principal. For unscoped rows, contextOf
@@ -185,9 +185,9 @@ const generateRelationLine = (rel: Relation, currentTable: string, withTool: boo
 };
 
 // Scan the existing @generated block to learn which columns/relations the
-// user opted out of `@tool()` decoration on. Default for new entries is
+// user opted out of `@expose()` decoration on. Default for new entries is
 // decorated; existing entries keep whatever decoration state they had so
-// hand-removed `@tool()`s aren't re-added on regenerate (same spirit as
+// hand-removed `@expose()`s aren't re-added on regenerate (same spirit as
 // `// @generated-start` preserving the file's surrounding code).
 const parseExistingDecorations = (
   block: string,
@@ -200,11 +200,11 @@ const parseExistingDecorations = (
     if (line === "" || line.startsWith("//")) {
       continue;
     }
-    if (/^@tool\(\)\s*$/.test(line)) {
+    if (/^@expose\(\)\s*$/.test(line)) {
       pendingTool = true;
       continue;
     }
-    const inline = /^(@tool\(\)\s+)?(\w+)\s*(=|\()/.exec(line);
+    const inline = /^(@expose\(\)\s+)?(\w+)\s*(=|\()/.exec(line);
     if (!inline) {
       pendingTool = false;
       continue;
@@ -223,7 +223,7 @@ const END_MARKER = "// @generated-end";
 
 // Pure generation entry point — no DB, no fs. `existing` (if provided)
 // must contain @generated-start/@generated-end markers; only content
-// between them is replaced, and per-entry `@tool()` state is preserved.
+// between them is replaced, and per-entry `@expose()` state is preserved.
 // Without `existing`, returns a brand-new full file.
 export const generateTable = (
   tableName: string,
@@ -250,14 +250,14 @@ const newFile = (tableName: string, columns: ColumnInfo[], relations: Relation[]
 
   // Single consolidated `from "typegres"` line — symbols are sorted
   // for stable output and easier diffs across regenerations.
-  const typegresSyms = [...typeClasses, "tool", ...(hasDefault ? ["sql"] : [])].sort();
+  const typegresSyms = [...typeClasses, "expose", ...(hasDefault ? ["sql"] : [])].sort();
   const imports = [
     `import { db } from "${dbImport}";`,
     `import { ${typegresSyms.join(", ")} } from "typegres";`,
     ...relImports,
   ];
 
-  // New file: every column/relation gets `@tool()` by default. Users can
+  // New file: every column/relation gets `@expose()` by default. Users can
   // strip individual decorators in-place; updateBlock will respect that.
   const colLines = columns.map((c) => generateColumnLine(c, true));
   const relLines = relations.map((r) => generateRelationLine(r, tableName, true));
@@ -284,7 +284,7 @@ const updateBlock = (existing: string, tableName: string, columns: ColumnInfo[],
   }
 
   // Preserve per-entry decoration state from the existing block. New
-  // entries (introduced by a schema migration) default to `@tool()`;
+  // entries (introduced by a schema migration) default to `@expose()`;
   // entries the user has stripped stay stripped.
   const blockContent = existing.slice(startIdx + START_MARKER.length, endIdx);
   const prior = parseExistingDecorations(blockContent);
diff --git a/src/types/generate.ts b/src/types/generate.ts
index 619f2c1..52168fc 100644
--- a/src/types/generate.ts
+++ b/src/types/generate.ts
@@ -201,10 +201,10 @@ const generateTypeFile = (
   const lines: string[] = [];
   lines.push("// Auto-generated — do not edit");
   lines.push('import * as runtime from "../runtime";');
-  // @tool.unchecked exposes every codegen'd method to exoeval-bound code
+  // @expose.unchecked exposes every codegen'd method to exoeval-bound code
   // without arg validation (typegres's runtime overload dispatcher already
   // validates internally). One import here, prepended on every method.
-  lines.push('import { tool } from "../../exoeval/tool";');
+  lines.push('import { expose } from "../../exoeval/tool";');
 
   // Parent class needs a direct import, not `types.Parent`: class `extends`
   // clauses evaluate at module-load time, and the barrel may not have finished
@@ -460,7 +460,7 @@ const generateTypeFile = (
       const colRuntime = f0.outColumns.map((c) => { const t = typeMap.get(c.typeOid)!; return `["${c.name}", types.${t.className}]`; });
       const sig = buildSig(f0, true);
       const ret = `runtime.PgSrf<{ ${colEntries.join("; ")} }, "${f0.name}">`;
-      lines.push(`  @tool.unchecked()`);
+      lines.push(`  @expose.unchecked()`);
       lines.push(`  ${sig}: ${ret} { return new runtime.PgSrf("${f0.name}", [${allArgs}], [${colRuntime.join(", ")}]) as any; }`);
       continue;
     }
@@ -477,7 +477,7 @@ const generateTypeFile = (
       if (group.length === 1) {
         const sig = buildSig(f0, allowMap.get(f0) ?? true, nameOverride);
         const retType = wrapRet(f0, buildRetType(f0));
-        lines.push(`  @tool.unchecked()`);
+        lines.push(`  @expose.unchecked()`);
         lines.push(`  ${sig}: ${retType} { ${buildBody(group, allowMap)} }`);
         return;
       }
@@ -497,7 +497,7 @@ const generateTypeFile = (
       const implParams = Array.from({ length: maxArity }, (_, i) =>
         `arg${i}${i >= minArity ? "?" : ""}: unknown`,
       ).join(", ");
-      lines.push(`  @tool.unchecked()`);
+      lines.push(`  @expose.unchecked()`);
       lines.push(`  ${nameOverride ?? methodName(f0)}(${implParams}): any { ${buildBody(group, allowMap)} }`);
     };
 
diff --git a/src/types/generated/aclitem.ts b/src/types/generated/aclitem.ts
index 9feefe7..bb9b0eb 100644
--- a/src/types/generated/aclitem.ts
+++ b/src/types/generated/aclitem.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,8 +17,8 @@ export class Aclitem<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`aclitem`;
   static __typnameText = "aclitem";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Aclitem<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Aclitem, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Aclitem<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Aclitem, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/any.ts b/src/types/generated/any.ts
index 7594938..d5b0233 100644
--- a/src/types/generated/any.ts
+++ b/src/types/generated/any.ts
@@ -1,37 +1,37 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import * as types from "../index";
 
 export class Any<in out N extends number> {
-  @tool.unchecked()
+  @expose.unchecked()
   numNonnulls(): types.Int4<1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("num_nonnulls", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numNulls(): types.Int4<1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("num_nulls", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   count(): types.Int8<1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("count", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cumeDist(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cume_dist", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   denseRank(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("dense_rank", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectAgg<M0 extends types.Any<any> | string>(arg0: M0): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_object_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectAggStrict<M0 extends types.Any<any> | string>(arg0: M0): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_object_agg_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectAggUnique<M0 extends types.Any<any> | string>(arg0: M0): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_object_agg_unique", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectAggUniqueStrict<M0 extends types.Any<any> | string>(arg0: M0): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_object_agg_unique_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectAgg<M0 extends types.Any<any> | string>(arg0: M0): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_object_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectAggStrict<M0 extends types.Any<any> | string>(arg0: M0): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_object_agg_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectAggUnique<M0 extends types.Any<any> | string>(arg0: M0): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_object_agg_unique", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectAggUniqueStrict<M0 extends types.Any<any> | string>(arg0: M0): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_object_agg_unique_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   percentRank(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("percent_rank", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rank(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("rank", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/anyarray.ts b/src/types/generated/anyarray.ts
index cb8ef78..04bff2f 100644
--- a/src/types/generated/anyarray.ts
+++ b/src/types/generated/anyarray.ts
@@ -1,74 +1,74 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anycompatiblearray } from "../overrides/anycompatiblearray";
 import * as types from "../index";
 
 export class Anyarray<T extends types.Any<any>, in out N extends number> extends Anycompatiblearray<T, N> {
-  @tool.unchecked()
+  @expose.unchecked()
   arrayDims(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("array_dims", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayLarger<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyarray<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayLength<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("array_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayLower<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("array_lower", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayNdims(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("array_ndims", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arraySmaller<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyarray<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayUpper<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("array_upper", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arraycontained<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("arraycontained", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arraycontains<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("arraycontains", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayoverlap<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("arrayoverlap", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cardinality(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("cardinality", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   trimArray<M0 extends types.Int4<any> | number>(arg0: M0): types.Anyarray<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("trim_array", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayAgg(): types.Anyarray<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("array_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Anyarray<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Anyarray<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
   generateSubscripts<M0 extends types.Int4<any> | number, M1 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1): runtime.PgSrf<{ generate_subscripts: types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "generate_subscripts">;
   generateSubscripts<M0 extends types.Int4<any> | number>(arg0: M0): runtime.PgSrf<{ generate_subscripts: types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> }, "generate_subscripts">;
-  @tool.unchecked()
+  @expose.unchecked()
   generateSubscripts(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return new runtime.PgSrf("generate_subscripts", [this, ...__rest], [["generate_subscripts", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   unnest(): runtime.PgSrf<{ unnest: T }, "unnest"> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgElement(this)]]); return new runtime.PgSrf("unnest", [this, ...__rest], [["unnest", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>']<M0 extends types.Anyarray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyarray, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/anycompatible.ts b/src/types/generated/anycompatible.ts
index 2dc75f9..e23cbb7 100644
--- a/src/types/generated/anycompatible.ts
+++ b/src/types/generated/anycompatible.ts
@@ -1,10 +1,10 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Any } from "../overrides/any";
 import * as types from "../index";
 
 export class Anycompatible<in out N extends number> extends Any<N> {
-  @tool.unchecked()
+  @expose.unchecked()
   arrayPrepend<M0 extends types.Anycompatiblearray<types.Any<any>, any>>(arg0: M0): types.Anycompatiblearray<types.Any<any>, 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anycompatiblearray, allowPrimitive: true }], types.Anycompatiblearray]]); return runtime.PgFunc("array_prepend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/anycompatiblearray.ts b/src/types/generated/anycompatiblearray.ts
index b315753..9e4cff8 100644
--- a/src/types/generated/anycompatiblearray.ts
+++ b/src/types/generated/anycompatiblearray.ts
@@ -1,24 +1,24 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anyelement } from "../generated/anyelement";
 import * as types from "../index";
 
 export class Anycompatiblearray<T extends types.Any<any>, in out N extends number> extends Anyelement<N> {
-  @tool.unchecked()
+  @expose.unchecked()
   arrayAppend<M0 extends T | runtime.TsTypeOf<T>>(arg0: M0): types.Anycompatiblearray<T, 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anycompatible, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_append", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayCat<M0 extends types.Anycompatiblearray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anycompatiblearray<T, 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anycompatiblearray, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_cat", [this, ...__rest], __rt) as any; }
   arrayPosition<M0 extends T | runtime.TsTypeOf<T>, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Int4<1>;
   arrayPosition<M0 extends T | runtime.TsTypeOf<T>>(arg0: M0): types.Int4<1>;
-  @tool.unchecked()
+  @expose.unchecked()
   arrayPosition(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Anycompatible, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Anycompatible, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("array_position", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayRemove<M0 extends T | runtime.TsTypeOf<T>>(arg0: M0): types.Anycompatiblearray<T, 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anycompatible, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_remove", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   arrayReplace<M0 extends T | runtime.TsTypeOf<T>, M1 extends T | runtime.TsTypeOf<T>>(arg0: M0, arg1: M1): types.Anycompatiblearray<T, 1> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Anycompatible, allowPrimitive: true }, { type: types.Anycompatible, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("array_replace", [this, ...__rest], __rt) as any; }
   ['||']<M0 extends types.Anycompatiblearray<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anycompatiblearray<T, runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['||']<M0 extends T>(arg0: M0): types.Anycompatiblearray<T, runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['||'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anycompatiblearray, allowPrimitive: true }], runtime.pgType(this)], [[{ type: types.Anycompatible }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/anycompatiblemultirange.ts b/src/types/generated/anycompatiblemultirange.ts
index ffa56af..9898fc2 100644
--- a/src/types/generated/anycompatiblemultirange.ts
+++ b/src/types/generated/anycompatiblemultirange.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anyelement } from "../generated/anyelement";
 import * as types from "../index";
 
diff --git a/src/types/generated/anycompatiblenonarray.ts b/src/types/generated/anycompatiblenonarray.ts
index a12fa99..3c4936c 100644
--- a/src/types/generated/anycompatiblenonarray.ts
+++ b/src/types/generated/anycompatiblenonarray.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anyelement } from "../generated/anyelement";
 import * as types from "../index";
 
diff --git a/src/types/generated/anycompatiblerange.ts b/src/types/generated/anycompatiblerange.ts
index 8796c93..da17e08 100644
--- a/src/types/generated/anycompatiblerange.ts
+++ b/src/types/generated/anycompatiblerange.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anyelement } from "../generated/anyelement";
 import * as types from "../index";
 
diff --git a/src/types/generated/anyelement.ts b/src/types/generated/anyelement.ts
index d9e8d17..b866969 100644
--- a/src/types/generated/anyelement.ts
+++ b/src/types/generated/anyelement.ts
@@ -1,26 +1,26 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anycompatible } from "../generated/anycompatible";
 import * as types from "../index";
 
 export class Anyelement<in out N extends number> extends Anycompatible<N> {
-  @tool.unchecked()
+  @expose.unchecked()
   anyValueTransfn<M0 extends types.Anyelement<any>>(arg0: M0): types.Anyelement<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyelement, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("any_value_transfn", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   elemContainedByMultirange<M0 extends types.Anymultirange<types.Any<any>, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("elem_contained_by_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   elemContainedByRange<M0 extends types.Anyrange<types.Any<any>, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("elem_contained_by_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   anyValue(): types.Anyelement<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("any_value", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonAgg(): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Json]]); return runtime.PgFunc("json_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonAggStrict(): types.Json<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Json]]); return runtime.PgFunc("json_agg_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbAgg(): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Jsonb]]); return runtime.PgFunc("jsonb_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbAggStrict(): types.Jsonb<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Jsonb]]); return runtime.PgFunc("jsonb_agg_strict", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   mode(): types.Anyelement<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("mode", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/anyenum.ts b/src/types/generated/anyenum.ts
index 8fc2d76..6842a9d 100644
--- a/src/types/generated/anyenum.ts
+++ b/src/types/generated/anyenum.ts
@@ -1,40 +1,40 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
 export class Anyenum<in out N extends number> extends Anynonarray<N> {
-  @tool.unchecked()
+  @expose.unchecked()
   enumLarger<M0 extends types.Anyenum<any>>(arg0: M0): types.Anyenum<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("enum_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   enumSmaller<M0 extends types.Anyenum<any>>(arg0: M0): types.Anyenum<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("enum_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Anyenum<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Anyenum<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Anyenum<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyenum, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/anymultirange.ts b/src/types/generated/anymultirange.ts
index a5b5098..bd870ce 100644
--- a/src/types/generated/anymultirange.ts
+++ b/src/types/generated/anymultirange.ts
@@ -1,135 +1,135 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anycompatiblemultirange } from "../generated/anycompatiblemultirange";
 import * as types from "../index";
 
 export class Anymultirange<T extends types.Any<any>, in out N extends number> extends Anycompatiblemultirange<T, N> {
-  @tool.unchecked()
+  @expose.unchecked()
   isempty(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isempty", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lower(): T { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgElement(this)]]); return runtime.PgFunc("lower", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lowerInc(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("lower_inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lowerInf(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("lower_inf", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeAdjacentMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_adjacent_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeAdjacentRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_adjacent_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeAfterMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_after_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeAfterRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_after_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeBeforeMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_before_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeBeforeRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_before_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeContainedByMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_contained_by_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeContainedByRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_contained_by_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeContainsElem<M0 extends T | runtime.TsTypeOf<T>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyelement, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_contains_elem", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeContainsMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_contains_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeContainsRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_contains_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeIntersectAggTransfn<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("multirange_intersect_agg_transfn", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverlapsMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overlaps_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverlapsRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overlaps_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverleftMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overleft_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverleftRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overleft_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverrightMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overright_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirangeOverrightRange<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("multirange_overright_range", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeMerge(): types.Anyrange<T, N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Anyrange]]); return runtime.PgFunc("range_merge", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upper(): T { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgElement(this)]]); return runtime.PgFunc("upper", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upperInc(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("upper_inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upperInf(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("upper_inf", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAgg(): types.Anymultirange<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("range_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeIntersectAgg(): types.Anymultirange<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("range_intersect_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   unnest(): runtime.PgSrf<{ unnest: types.Anyrange<T, N> }, "unnest"> { const [__rt, ...__rest] = runtime.match([], [[[], types.Anyrange]]); return new runtime.PgSrf("unnest", [this, ...__rest], [["unnest", __rt]]) as any; }
   ['&&']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&&']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange }], types.Bool], [[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['&<']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&<']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool], [[{ type: types.Anyrange }], types.Bool]]); return runtime.PgOp(runtime.sql`&<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['&>']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&>']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange }], types.Bool], [[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   times<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anymultirange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-|-']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-|-']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-|-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange }], types.Bool], [[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`-|-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<<']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<<']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool], [[{ type: types.Anyrange }], types.Bool]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<@']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<@']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange }], types.Bool], [[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>>']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>>']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool], [[{ type: types.Anyrange }], types.Bool]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['@>']<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['@>']<M0 extends types.Anyrange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['@>']<M0 extends T>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool], [[{ type: types.Anyrange }], types.Bool], [[{ type: types.Anyelement }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/anynonarray.ts b/src/types/generated/anynonarray.ts
index 87854df..d3d22b3 100644
--- a/src/types/generated/anynonarray.ts
+++ b/src/types/generated/anynonarray.ts
@@ -1,10 +1,10 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anycompatiblenonarray } from "../generated/anycompatiblenonarray";
 import * as types from "../index";
 
 export class Anynonarray<in out N extends number> extends Anycompatiblenonarray<N> {
-  @tool.unchecked()
+  @expose.unchecked()
   arrayAgg(): types.Anyarray<types.Any<any>, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Anyarray]]); return runtime.PgFunc("array_agg", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/anyrange.ts b/src/types/generated/anyrange.ts
index 7f18297..f4bc8de 100644
--- a/src/types/generated/anyrange.ts
+++ b/src/types/generated/anyrange.ts
@@ -1,129 +1,129 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anycompatiblerange } from "../generated/anycompatiblerange";
 import * as types from "../index";
 
 export class Anyrange<T extends types.Any<any>, in out N extends number> extends Anycompatiblerange<T, N> {
-  @tool.unchecked()
+  @expose.unchecked()
   lower(): T { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgElement(this)]]); return runtime.PgFunc("lower", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lowerInc(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("lower_inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lowerInf(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("lower_inf", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   multirange(): types.Anymultirange<T, N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Anymultirange]]); return runtime.PgFunc("multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAdjacent<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_adjacent", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAdjacentMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_adjacent_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAfter<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_after", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAfterMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_after_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeBefore<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_before", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeBeforeMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_before_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeContainedBy<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_contained_by", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeContainedByMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_contained_by_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeContainsElem<M0 extends T | runtime.TsTypeOf<T>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyelement, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_contains_elem", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeContainsMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_contains_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeIntersectAggTransfn<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgFunc("range_intersect_agg_transfn", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverlaps<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overlaps", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverlapsMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overlaps_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverleft<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overleft", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverleftMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overleft_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverright<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overright", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeOverrightMultirange<M0 extends types.Anymultirange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("range_overright_multirange", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upper(): T { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgElement(this)]]); return runtime.PgFunc("upper", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upperInc(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("upper_inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upperInf(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("upper_inf", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeAgg(): types.Anymultirange<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Anymultirange]]); return runtime.PgFunc("range_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rangeIntersectAgg(): types.Anyrange<T, 0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], runtime.pgType(this)]]); return runtime.PgFunc("range_intersect_agg", [this, ...__rest], __rt) as any; }
   ['&&']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&&']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['&<']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&<']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['&>']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['&>']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['&>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool], [[{ type: types.Anymultirange }], types.Bool]]); return runtime.PgOp(runtime.sql`&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   times<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Anyrange<T, runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], runtime.pgType(this)]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-|-']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-|-']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-|-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`-|-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<<']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<<']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<@']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<@']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool], [[{ type: types.Anymultirange }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>>']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>>']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['@>']<M0 extends T>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['@>']<M0 extends types.Anymultirange<T, any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['@>']<M0 extends types.Anyrange<T, any> | runtime.TsTypeOf<T>[]>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyelement }], types.Bool], [[{ type: types.Anymultirange }], types.Bool], [[{ type: types.Anyrange, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/bit.ts b/src/types/generated/bit.ts
index 122cb45..27274ba 100644
--- a/src/types/generated/bit.ts
+++ b/src/types/generated/bit.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,86 +17,86 @@ export class Bit<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`bit`;
   static __typnameText = "bit";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bit<M0 extends types.Int4<any> | number, M1 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitCount(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("bit_count", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("bit_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitand<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bitand", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitnot(): types.Bit<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bit]]); return runtime.PgFunc("bitnot", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitor<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bitor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitshiftleft<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bitshiftleft", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitshiftright<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bitshiftright", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitxor<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bitxor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   getBit<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("get_bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   octetLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("octet_length", [this, ...__rest], __rt) as any; }
   overlay<M0 extends types.Bit<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   overlay<M0 extends types.Bit<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   overlay(arg0: unknown, arg1: unknown, arg2?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Bit, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bit], [[{ type: types.Bit, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("overlay", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   position<M0 extends types.Bit<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("position", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setBit<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("set_bit", [this, ...__rest], __rt) as any; }
   substring<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   substring<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   substring(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit], [[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("substring", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitAnd(): types.Bit<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bit]]); return runtime.PgFunc("bit_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitOr(): types.Bit<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bit]]); return runtime.PgFunc("bit_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitXor(): types.Bit<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bit]]); return runtime.PgFunc("bit_xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['#']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgOp(runtime.sql`#`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Bit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Bit<any> | string>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bit, allowPrimitive: true }], types.Bit]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/bool.ts b/src/types/generated/bool.ts
index 5ae6752..2c2f508 100644
--- a/src/types/generated/bool.ts
+++ b/src/types/generated/bool.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -16,44 +16,44 @@ export class Bool<in out N extends number> extends Anynonarray<N> {
   };
   static __typname = runtime.sql`bool`;
   static __typnameText = "bool";
-  @tool.unchecked()
+  @expose.unchecked()
   boolandStatefunc<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("booland_statefunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   boolorStatefunc<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("boolor_statefunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   boolsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("boolsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   text(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   boolAnd(): types.Bool<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("bool_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   boolOr(): types.Bool<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("bool_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   every(): types.Bool<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("every", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Bool<any> | boolean>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/bpchar.ts b/src/types/generated/bpchar.ts
index d1d468f..e2ae856 100644
--- a/src/types/generated/bpchar.ts
+++ b/src/types/generated/bpchar.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,96 +17,96 @@ export class Bpchar<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`bpchar`;
   static __typnameText = "bpchar";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bpchar<M0 extends types.Int4<any> | number, M1 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1): types.Bpchar<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Bpchar]]); return runtime.PgFunc("bpchar", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharLarger<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bpchar<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bpchar]]); return runtime.PgFunc("bpchar_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharPatternGe<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpchar_pattern_ge", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharPatternGt<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpchar_pattern_gt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharPatternLe<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpchar_pattern_le", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharPatternLt<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpchar_pattern_lt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharSmaller<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bpchar<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bpchar]]); return runtime.PgFunc("bpchar_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpchariclike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpchariclike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharicnlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharicnlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharicregexeq<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharicregexeq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharicregexne<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharicregexne", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharnlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharnlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharregexeq<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharregexeq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bpcharregexne<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bpcharregexne", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   charLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("char_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   characterLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("character_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   octetLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("octet_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   text(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Bpchar<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bpchar]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Bpchar<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bpchar]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~<=~']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~<=~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~<~']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~<~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~>=~']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~>=~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~>~']<M0 extends types.Bpchar<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bpchar, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~>~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/bytea.ts b/src/types/generated/bytea.ts
index 46d2e93..2ad2136 100644
--- a/src/types/generated/bytea.ts
+++ b/src/types/generated/bytea.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,98 +17,98 @@ export class Bytea<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`bytea`;
   static __typnameText = "bytea";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bitCount(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("bit_count", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   btrim<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("btrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   byteacat<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("byteacat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bytealike<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("bytealike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   byteanlike<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("byteanlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   byteasend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("byteasend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   encode<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("encode", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   getBit<M0 extends types.Int8<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("get_bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   getByte<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("get_byte", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   like<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("like", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   likeEscape<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("like_escape", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ltrim<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("ltrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   md5(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("md5", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   notlike<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("notlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   octetLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("octet_length", [this, ...__rest], __rt) as any; }
   overlay<M0 extends types.Bytea<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   overlay<M0 extends types.Bytea<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   overlay(arg0: unknown, arg1: unknown, arg2?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Bytea, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea], [[{ type: types.Bytea, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("overlay", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   position<M0 extends types.Bytea<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("position", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   rtrim<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("rtrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setBit<M0 extends types.Int8<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int8, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("set_bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setByte<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("set_byte", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sha224(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("sha224", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sha256(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("sha256", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sha384(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("sha384", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sha512(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("sha512", [this, ...__rest], __rt) as any; }
   substr<M0 extends types.Int4<any> | number>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   substr<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   substr(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }], types.Bytea], [[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("substr", [this, ...__rest], __rt) as any; }
   substring<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   substring<M0 extends types.Int4<any> | number>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   substring(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Bytea], [[{ type: types.Int4, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("substring", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stringAgg<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("string_agg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~~']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['||']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bytea]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~~']<M0 extends types.Bytea<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Bytea, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/char.ts b/src/types/generated/char.ts
index 9af2c6c..a4d3389 100644
--- a/src/types/generated/char.ts
+++ b/src/types/generated/char.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,36 +17,36 @@ export class Char<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`char`;
   static __typnameText = "char";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bpchar(): types.Bpchar<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bpchar]]); return runtime.PgFunc("bpchar", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   charsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("charsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   text(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Char<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/cid.ts b/src/types/generated/cid.ts
index 2866563..ae564bf 100644
--- a/src/types/generated/cid.ts
+++ b/src/types/generated/cid.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,10 +17,10 @@ export class Cid<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`cid`;
   static __typnameText = "cid";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   cidsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("cidsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Cid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Cid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Cid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Cid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/cidr.ts b/src/types/generated/cidr.ts
index 4e39170..ea33236 100644
--- a/src/types/generated/cidr.ts
+++ b/src/types/generated/cidr.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,10 +17,10 @@ export class Cidr<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`cidr`;
   static __typnameText = "cidr";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   abbrev(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("abbrev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cidrSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("cidr_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setMasklen<M0 extends types.Int4<any> | number>(arg0: M0): types.Cidr<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Cidr]]); return runtime.PgFunc("set_masklen", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/circle.ts b/src/types/generated/circle.ts
index 1954cc1..e367659 100644
--- a/src/types/generated/circle.ts
+++ b/src/types/generated/circle.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,94 +17,94 @@ export class Circle<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`circle`;
   static __typnameText = "circle";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   area(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("area", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleAbove<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_above", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleBelow<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_below", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleContain<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_contain", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleContained<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_contained", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleDistance<M0 extends types.Circle<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("circle_distance", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleLeft<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_left", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleOverabove<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_overabove", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleOverbelow<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_overbelow", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleOverlap<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_overlap", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleOverleft<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_overleft", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleOverright<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_overright", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleRight<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_right", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleSame<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("circle_same", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   circleSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("circle_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   diameter(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("diameter", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   distCpoly<M0 extends types.Polygon<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("dist_cpoly", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polygon(): types.Polygon<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Polygon]]); return runtime.PgFunc("polygon", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   radius(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("radius", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<|']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&<|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<->']<M0 extends types.Polygon<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<->']<M0 extends types.Circle<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<->'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon }], types.Float8], [[{ type: types.Circle, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`<->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<|']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|&>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`|&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|>>']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`|>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~=']<M0 extends types.Circle<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/date.ts b/src/types/generated/date.ts
index d723772..fa42021 100644
--- a/src/types/generated/date.ts
+++ b/src/types/generated/date.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,106 +17,106 @@ export class Date<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`date`;
   static __typnameText = "date";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   dateLarger<M0 extends types.Date<any> | string>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Date]]); return runtime.PgFunc("date_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dateSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("date_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dateSmaller<M0 extends types.Date<any> | string>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Date]]); return runtime.PgFunc("date_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   daterangeSubdiff<M0 extends types.Date<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("daterange_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isfinite(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isfinite", [this, ...__rest], __rt) as any; }
   timestamp(): types.Timestamp<N>;
   timestamp<M0 extends types.Time<any> | string>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   timestamp(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[], types.Timestamp], [[{ type: types.Time, allowPrimitive: true }], types.Timestamp]]); return runtime.PgFunc("timestamp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamptz<M0 extends types.Timetz<any> | string>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("timestamptz", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Date<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Date]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Date<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Date]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
   ['+']<M0 extends types.Int4<any> | number>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Timetz<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Time<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Date], [[{ type: types.Timetz }], types.Timestamptz], [[{ type: types.Time }], types.Timestamp], [[{ type: types.Interval }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Int4<any> | number>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Timetz<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Time<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Date], [[{ type: types.Timetz }], types.Timestamptz], [[{ type: types.Time }], types.Timestamp], [[{ type: types.Interval }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Date<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int4<any> | number>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamp], [[{ type: types.Date, allowPrimitive: true }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Date]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Date<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int4<any> | number>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamp], [[{ type: types.Date, allowPrimitive: true }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Date]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Date<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/float4.ts b/src/types/generated/float4.ts
index c8e489a..1fd8094 100644
--- a/src/types/generated/float4.ts
+++ b/src/types/generated/float4.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,126 +17,126 @@ export class Float4<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`float4`;
   static __typnameText = "float4";
   declare deserialize: (raw: string) => number;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4Abs(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4Larger<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgFunc("float4larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("float4send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4Smaller<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgFunc("float4smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Float4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Float4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Float4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
   ['*']<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money], [[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money], [[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Float8<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Float4<any> | number>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Float8], [[{ type: types.Float4, allowPrimitive: true }], types.Float4]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4, allowPrimitive: true }], types.Bool], [[{ type: types.Float8 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Float8<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Float4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8 }], types.Bool], [[{ type: types.Float4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/float8.ts b/src/types/generated/float8.ts
index 643a885..2c07e1e 100644
--- a/src/types/generated/float8.ts
+++ b/src/types/generated/float8.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,258 +17,258 @@ export class Float8<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`float8`;
   static __typnameText = "float8";
   declare deserialize: (raw: string) => number;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   acos(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("acos", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   acosd(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("acosd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   acosh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("acosh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   asin(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("asin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   asind(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("asind", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   asinh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("asinh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   atan(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("atan", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   atan2<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("atan2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   atan2D<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("atan2d", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   atand(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("atand", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   atanh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("atanh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cbrt(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cbrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ceil(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("ceil", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ceiling(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("ceiling", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cos(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cos", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cosd(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cosd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cosh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cosh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cot(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cot", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cotd(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("cotd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dcbrt(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dcbrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   degrees(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("degrees", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dexp(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dexp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dlog1(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dlog1", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dlog10(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dlog10", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dround(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dround", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dsqrt(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dsqrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dtrunc(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("dtrunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   erf(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("erf", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   erfc(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("erfc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   exp(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("exp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8Abs(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8Larger<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("float8larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("float8send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8Smaller<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("float8smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   floor(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("floor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ln(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("ln", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   log(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("log", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   log10(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("log10", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pow<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("pow", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   power<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("power", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   radians(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("radians", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   round(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("round", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sign(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sign", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sin(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sind(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sind", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sinh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sinh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sqrt(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sqrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tan(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("tan", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tand(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("tand", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tanh(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("tanh", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toTimestamp(): types.Timestamptz<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamptz]]); return runtime.PgFunc("to_timestamp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   trunc(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   widthBucket<M0 extends types.Float8<any> | number, M1 extends types.Float8<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Float8, allowPrimitive: true }, { type: types.Float8, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("width_bucket", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   corr<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("corr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   covarPop<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("covar_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   covarSamp<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("covar_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
   percentileCont<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<0 | 1>;
   percentileCont<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1>;
-  @tool.unchecked()
+  @expose.unchecked()
   percentileCont(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Interval], [[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("percentile_cont", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   percentileDisc<M0 extends types.Anyelement<any>>(arg0: M0): types.Anyelement<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anyelement, allowPrimitive: true }], types.Anyelement]]); return runtime.PgFunc("percentile_disc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrAvgx<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_avgx", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrAvgy<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_avgy", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrCount<M0 extends types.Float8<any> | number>(arg0: M0): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("regr_count", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrIntercept<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_intercept", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrR2<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_r2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrSlope<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_slope", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrSxx<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_sxx", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrSxy<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_sxy", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regrSyy<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("regr_syy", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Float8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
   ['*']<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Interval<any>>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money }], types.Money], [[{ type: types.Float8, allowPrimitive: true }], types.Float8], [[{ type: types.Interval }], types.Interval], [[{ type: types.Float4 }], types.Float8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Interval<any>>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money }], types.Money], [[{ type: types.Float8, allowPrimitive: true }], types.Float8], [[{ type: types.Interval }], types.Interval], [[{ type: types.Float4 }], types.Float8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Float8], [[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Float8], [[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8], [[{ type: types.Float4 }], types.Float8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8], [[{ type: types.Float4 }], types.Float8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Float8], [[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Float4<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Float8], [[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Bool], [[{ type: types.Float4 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Bool], [[{ type: types.Float4 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Bool], [[{ type: types.Float4 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Bool], [[{ type: types.Float4 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Float4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Float8<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Bool], [[{ type: types.Float8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['^']<M0 extends types.Float8<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`^`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/gtsvector.ts b/src/types/generated/gtsvector.ts
index 093e7c8..11496d6 100644
--- a/src/types/generated/gtsvector.ts
+++ b/src/types/generated/gtsvector.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/inet.ts b/src/types/generated/inet.ts
index 258870e..93c29ca 100644
--- a/src/types/generated/inet.ts
+++ b/src/types/generated/inet.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,100 +17,100 @@ export class Inet<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`inet`;
   static __typnameText = "inet";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   abbrev(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("abbrev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   broadcast(): types.Inet<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("broadcast", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cidr(): types.Cidr<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Cidr]]); return runtime.PgFunc("cidr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   family(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("family", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   host(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("host", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   hostmask(): types.Inet<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("hostmask", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   inetSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("inet_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   inetand<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgFunc("inetand", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   inetnot(): types.Inet<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("inetnot", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   inetor<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgFunc("inetor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   masklen(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("masklen", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   netmask(): types.Inet<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("netmask", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   network(): types.Cidr<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Cidr]]); return runtime.PgFunc("network", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkLarger<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgFunc("network_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkOverlap<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("network_overlap", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkSmaller<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgFunc("network_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkSub<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("network_sub", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkSubeq<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("network_subeq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   networkSup<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("network_sup", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setMasklen<M0 extends types.Int4<any> | number>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Inet]]); return runtime.PgFunc("set_masklen", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   text(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Inet<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Inet<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Inet]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Int8<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Inet]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Int8<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Inet]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Int8<any>>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Inet<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Inet], [[{ type: types.Inet, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Int8<any>>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Inet<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Inet], [[{ type: types.Inet, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<=']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>=']<M0 extends types.Inet<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Inet<any> | string>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet, allowPrimitive: true }], types.Inet]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/int2.ts b/src/types/generated/int2.ts
index 205ac0e..562a82f 100644
--- a/src/types/generated/int2.ts
+++ b/src/types/generated/int2.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,178 +17,178 @@ export class Int2<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`int2`;
   static __typnameText = "int2";
   declare deserialize: (raw: string) => number;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Abs(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2And<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Larger<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Not(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Or<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("int2send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Shl<M0 extends types.Int4<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2shl", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Shr<M0 extends types.Int4<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2shr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Smaller<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Xor<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("int2xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   mod<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgFunc("mod", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitAnd(): types.Int2<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("bit_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitOr(): types.Int2<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("bit_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitXor(): types.Int2<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("bit_xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Int2<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Int2<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['#']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`#`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['%']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`%`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['*']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Money }], types.Money], [[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8 }], types.Int8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Money }], types.Money], [[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8 }], types.Int8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Int4 }], types.Int4]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Int4 }], types.Int4]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2], [[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Int4<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int2<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Int2<any> | number>(arg0: M0): types.Int2<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int2]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/int4.ts b/src/types/generated/int4.ts
index f113300..6c9b1e5 100644
--- a/src/types/generated/int4.ts
+++ b/src/types/generated/int4.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,218 +17,218 @@ export class Int4<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`int4`;
   static __typnameText = "int4";
   declare deserialize: (raw: string) => number;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bit<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bool(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("bool", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   char(): types.Char<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Char]]); return runtime.PgFunc("char", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   chr(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("chr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gcd<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("gcd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Abs(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4And<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Inc(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Larger<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Not(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Or<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4RangeSubdiff<M0 extends types.Int4<any> | number>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("int4range_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("int4send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Shl<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4shl", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Shr<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4shr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Smaller<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Xor<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("int4xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lcm<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("lcm", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   makeDate<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Date<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Date]]); return runtime.PgFunc("make_date", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   makeInterval<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number, M4 extends types.Int4<any> | number, M5 extends types.Float8<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3, arg4: M4, arg5: M5): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3> | runtime.NullOf<M4> | runtime.NullOf<M5>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2, arg3, arg4, arg5], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Float8, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("make_interval", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   makeTime<M0 extends types.Int4<any> | number, M1 extends types.Float8<any> | number>(arg0: M0, arg1: M1): types.Time<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Float8, allowPrimitive: true }], types.Time]]); return runtime.PgFunc("make_time", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   makeTimestamp<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number, M4 extends types.Float8<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3, arg4: M4): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3> | runtime.NullOf<M4>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2, arg3, arg4], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Float8, allowPrimitive: true }], types.Timestamp]]); return runtime.PgFunc("make_timestamp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   mod<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("mod", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgEncodingMaxLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("pg_encoding_max_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polygon<M0 extends types.Circle<any> | string>(arg0: M0): types.Polygon<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Polygon]]); return runtime.PgFunc("polygon", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toBin(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_bin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toHex(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_hex", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toOct(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_oct", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitAnd(): types.Int4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitOr(): types.Int4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitXor(): types.Int4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Int4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Int4<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
   generateSeries<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): runtime.PgSrf<{ generate_series: types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "generate_series">;
   generateSeries<M0 extends types.Int4<any> | number>(arg0: M0): runtime.PgSrf<{ generate_series: types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> }, "generate_series">;
-  @tool.unchecked()
+  @expose.unchecked()
   generateSeries(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return new runtime.PgSrf("generate_series", [this, ...__rest], [["generate_series", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['#']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`#`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['%']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`%`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['*']<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Int8], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Money }], types.Money], [[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Int8], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Money }], types.Money], [[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Date<any>>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Date], [[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Int8 }], types.Int8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Date<any>>(arg0: M0): types.Date<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int8<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Date], [[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Int8 }], types.Int8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int2 }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Int2<any>>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Int4], [[{ type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/int8.ts b/src/types/generated/int8.ts
index a22b9c5..fdccbeb 100644
--- a/src/types/generated/int8.ts
+++ b/src/types/generated/int8.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,220 +17,220 @@ export class Int8<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`int8`;
   static __typnameText = "int8";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bit<M0 extends types.Int4<any> | number>(arg0: M0): types.Bit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Bit]]); return runtime.PgFunc("bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   factorial(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("factorial", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gcd<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("gcd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2Sum<M0 extends types.Int2<any> | number>(arg0: M0): types.Int8<1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int2_sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4Sum<M0 extends types.Int4<any> | number>(arg0: M0): types.Int8<1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int4_sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Abs(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8And<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Dec(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8dec", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8DecAny<M0 extends types.Any<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8dec_any", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Inc(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8IncAny<M0 extends types.Any<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Any, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8inc_any", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8IncFloat8Float8<M0 extends types.Float8<any> | number, M1 extends types.Float8<any> | number>(arg0: M0, arg1: M1): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Float8, allowPrimitive: true }, { type: types.Float8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8inc_float8_float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Larger<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Not(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Or<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8RangeSubdiff<M0 extends types.Int8<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("int8range_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("int8send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Shl<M0 extends types.Int4<any> | number>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8shl", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Shr<M0 extends types.Int4<any> | number>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8shr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Smaller<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Xor<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("int8xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lcm<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("lcm", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   mod<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgFunc("mod", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   oid(): types.Oid<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Oid]]); return runtime.PgFunc("oid", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSizePretty(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("pg_size_pretty", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toBin(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_bin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toHex(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_hex", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toOct(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("to_oct", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   txidVisibleInSnapshot<M0 extends types.TxidSnapshot<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.TxidSnapshot, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("txid_visible_in_snapshot", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitAnd(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("bit_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitOr(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("bit_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitXor(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("bit_xor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Int8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
   generateSeries<M0 extends types.Int8<any> | string, M1 extends types.Int8<any> | string>(arg0: M0, arg1: M1): runtime.PgSrf<{ generate_series: types.Int8<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "generate_series">;
   generateSeries<M0 extends types.Int8<any> | string>(arg0: M0): runtime.PgSrf<{ generate_series: types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> }, "generate_series">;
-  @tool.unchecked()
+  @expose.unchecked()
   generateSeries(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int8, allowPrimitive: true }, { type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return new runtime.PgSrf("generate_series", [this, ...__rest], [["generate_series", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['#']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`#`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['%']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`%`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['*']<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money }], types.Money], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2 }], types.Int8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Money<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money }], types.Money], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int2 }], types.Int8]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Inet<any>>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet }], types.Inet], [[{ type: types.Int2 }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Inet<any>>(arg0: M0): types.Inet<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Inet }], types.Inet], [[{ type: types.Int2 }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int2 }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int2 }], types.Int8]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Int2<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int4<any>>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Int8], [[{ type: types.Int4 }], types.Int8], [[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int2 }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool], [[{ type: types.Int4 }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Int2<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int4<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Int8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int2 }], types.Bool], [[{ type: types.Int4 }], types.Bool], [[{ type: types.Int8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Int8<any> | string>(arg0: M0): types.Int8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Int8]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/interval.ts b/src/types/generated/interval.ts
index 7b1c05a..171756d 100644
--- a/src/types/generated/interval.ts
+++ b/src/types/generated/interval.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -19,42 +19,42 @@ export class Interval<in out N extends number> extends Anynonarray<N> {
   declare deserialize: (raw: string) => string;
   dateBin<M0 extends types.Timestamp<any>, M1 extends types.Timestamp<any>>(arg0: M0, arg1: M1): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   dateBin<M0 extends types.Timestamptz<any>, M1 extends types.Timestamptz<any>>(arg0: M0, arg1: M1): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   dateBin(arg0: unknown, arg1: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Timestamp }, { type: types.Timestamp }], types.Timestamp], [[{ type: types.Timestamptz }, { type: types.Timestamptz }], types.Timestamptz]]); return runtime.PgFunc("date_bin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   interval<M0 extends types.Int4<any> | number>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("interval", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   intervalLarger<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("interval_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   intervalSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("interval_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   intervalSmaller<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("interval_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isfinite(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isfinite", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   justifyDays(): types.Interval<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("justify_days", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   justifyHours(): types.Interval<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("justify_hours", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   justifyInterval(): types.Interval<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("justify_interval", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   time(): types.Time<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Time]]); return runtime.PgFunc("time", [this, ...__rest], __rt) as any; }
   timezone<M0 extends types.Timestamptz<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   timezone<M0 extends types.Timestamp<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   timezone<M0 extends types.Timetz<any>>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   timezone(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz }], types.Timestamp], [[{ type: types.Timestamp }], types.Timestamptz], [[{ type: types.Timetz }], types.Timetz]]); return runtime.PgFunc("timezone", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Interval<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Interval<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Interval<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Interval<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*']<M0 extends types.Float8<any> | number>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   times<M0 extends types.Float8<any> | number>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Date<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Timetz<any>>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
@@ -62,7 +62,7 @@ export class Interval<in out N extends number> extends Anynonarray<N> {
   ['+']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Time<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Timestamp], [[{ type: types.Timetz }], types.Timetz], [[{ type: types.Timestamp }], types.Timestamp], [[{ type: types.Timestamptz }], types.Timestamptz], [[{ type: types.Time }], types.Time], [[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Date<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Timetz<any>>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
@@ -70,38 +70,38 @@ export class Interval<in out N extends number> extends Anynonarray<N> {
   plus<M0 extends types.Timestamptz<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Time<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Timestamp], [[{ type: types.Timetz }], types.Timetz], [[{ type: types.Timestamp }], types.Timestamp], [[{ type: types.Timestamptz }], types.Timestamptz], [[{ type: types.Time }], types.Time], [[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Interval<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['/']<M0 extends types.Float8<any> | number>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   divide<M0 extends types.Float8<any> | number>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float8, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Interval<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/json.ts b/src/types/generated/json.ts
index 584c7fe..845bedf 100644
--- a/src/types/generated/json.ts
+++ b/src/types/generated/json.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,38 +17,38 @@ export class Json<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`json`;
   static __typnameText = "json";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   jsonArrayElement<M0 extends types.Int4<any> | number>(arg0: M0): types.Json<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_array_element", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonArrayElementText<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("json_array_element_text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonArrayLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("json_array_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectField<M0 extends types.Text<any> | string>(arg0: M0): types.Json<runtime.MaybeNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Json]]); return runtime.PgFunc("json_object_field", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectFieldText<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("json_object_field_text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("json_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonStripNulls(): types.Json<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Json]]); return runtime.PgFunc("json_strip_nulls", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonTypeof(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("json_typeof", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonArrayElements(): runtime.PgSrf<{ value: types.Json<1> }, "json_array_elements"> { return new runtime.PgSrf("json_array_elements", [this], [["value", types.Json]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonArrayElementsText(): runtime.PgSrf<{ value: types.Text<1> }, "json_array_elements_text"> { return new runtime.PgSrf("json_array_elements_text", [this], [["value", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonEach(): runtime.PgSrf<{ key: types.Text<1>; value: types.Json<1> }, "json_each"> { return new runtime.PgSrf("json_each", [this], [["key", types.Text], ["value", types.Json]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonEachText(): runtime.PgSrf<{ key: types.Text<1>; value: types.Text<1> }, "json_each_text"> { return new runtime.PgSrf("json_each_text", [this], [["key", types.Text], ["value", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonObjectKeys(): runtime.PgSrf<{ json_object_keys: types.Text<N> }, "json_object_keys"> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return new runtime.PgSrf("json_object_keys", [this, ...__rest], [["json_object_keys", __rt]]) as any; }
   ['->']<M0 extends types.Text<any> | string>(arg0: M0): types.Json<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
   ['->']<M0 extends types.Int4<any> | number>(arg0: M0): types.Json<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['->'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Json], [[{ type: types.Int4, allowPrimitive: true }], types.Json]]); return runtime.PgOp(runtime.sql`->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['->>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
   ['->>']<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['->>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgOp(runtime.sql`->>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/jsonb.ts b/src/types/generated/jsonb.ts
index 4c201e9..c134c68 100644
--- a/src/types/generated/jsonb.ts
+++ b/src/types/generated/jsonb.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,120 +17,120 @@ export class Jsonb<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`jsonb`;
   static __typnameText = "jsonb";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bool(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("bool", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbArrayElement<M0 extends types.Int4<any> | number>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_array_element", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbArrayElementText<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("jsonb_array_element_text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbArrayLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("jsonb_array_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbConcat<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_concat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbContained<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_contained", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbContains<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_contains", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbExists<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_exists", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectField<M0 extends types.Text<any> | string>(arg0: M0): types.Jsonb<runtime.MaybeNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_object_field", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectFieldText<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("jsonb_object_field_text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathExists<M0 extends types.Jsonpath<any> | string, M1 extends types.Jsonb<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Jsonpath, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_path_exists", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathExistsOpr<M0 extends types.Jsonpath<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonpath, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_path_exists_opr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathMatch<M0 extends types.Jsonpath<any> | string, M1 extends types.Jsonb<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Jsonpath, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_path_match", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathMatchOpr<M0 extends types.Jsonpath<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonpath, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("jsonb_path_match_opr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathQueryArray<M0 extends types.Jsonpath<any> | string, M1 extends types.Jsonb<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Jsonpath, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_path_query_array", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathQueryFirst<M0 extends types.Jsonpath<any> | string, M1 extends types.Jsonb<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Jsonpath, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Jsonb]]); return runtime.PgFunc("jsonb_path_query_first", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPretty(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("jsonb_pretty", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("jsonb_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbStripNulls(): types.Jsonb<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Jsonb]]); return runtime.PgFunc("jsonb_strip_nulls", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbTypeof(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("jsonb_typeof", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbArrayElements(): runtime.PgSrf<{ value: types.Jsonb<1> }, "jsonb_array_elements"> { return new runtime.PgSrf("jsonb_array_elements", [this], [["value", types.Jsonb]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbArrayElementsText(): runtime.PgSrf<{ value: types.Text<1> }, "jsonb_array_elements_text"> { return new runtime.PgSrf("jsonb_array_elements_text", [this], [["value", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbEach(): runtime.PgSrf<{ key: types.Text<1>; value: types.Jsonb<1> }, "jsonb_each"> { return new runtime.PgSrf("jsonb_each", [this], [["key", types.Text], ["value", types.Jsonb]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbEachText(): runtime.PgSrf<{ key: types.Text<1>; value: types.Text<1> }, "jsonb_each_text"> { return new runtime.PgSrf("jsonb_each_text", [this], [["key", types.Text], ["value", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbObjectKeys(): runtime.PgSrf<{ jsonb_object_keys: types.Text<N> }, "jsonb_object_keys"> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return new runtime.PgSrf("jsonb_object_keys", [this, ...__rest], [["jsonb_object_keys", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbPathQuery<M0 extends types.Jsonpath<any> | string, M1 extends types.Jsonb<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): runtime.PgSrf<{ jsonb_path_query: types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> }, "jsonb_path_query"> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Jsonpath, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Jsonb]]); return new runtime.PgSrf("jsonb_path_query", [this, ...__rest], [["jsonb_path_query", __rt]]) as any; }
   ['-']<M0 extends types.Int4<any> | number>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Text<any> | string>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Jsonb], [[{ type: types.Text, allowPrimitive: true }], types.Jsonb]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Int4<any> | number>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Text<any> | string>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Jsonb], [[{ type: types.Text, allowPrimitive: true }], types.Jsonb]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['->']<M0 extends types.Int4<any> | number>(arg0: M0): types.Jsonb<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
   ['->']<M0 extends types.Text<any> | string>(arg0: M0): types.Jsonb<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['->'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Jsonb], [[{ type: types.Text, allowPrimitive: true }], types.Jsonb]]); return runtime.PgOp(runtime.sql`->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['->>']<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
   ['->>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.MaybeNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['->>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgOp(runtime.sql`->>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['?']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`?`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@?']<M0 extends types.Jsonpath<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonpath, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@?`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@']<M0 extends types.Jsonpath<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonpath, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['||']<M0 extends types.Jsonb<any> | string>(arg0: M0): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Jsonb, allowPrimitive: true }], types.Jsonb]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/jsonpath.ts b/src/types/generated/jsonpath.ts
index 5423508..df39a7b 100644
--- a/src/types/generated/jsonpath.ts
+++ b/src/types/generated/jsonpath.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Jsonpath<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`jsonpath`;
   static __typnameText = "jsonpath";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   jsonpathSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("jsonpath_send", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/macaddr.ts b/src/types/generated/macaddr.ts
index 35c42ff..fcbda16 100644
--- a/src/types/generated/macaddr.ts
+++ b/src/types/generated/macaddr.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,44 +17,44 @@ export class Macaddr<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`macaddr`;
   static __typnameText = "macaddr";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8(): types.Macaddr8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr8]]); return runtime.PgFunc("macaddr8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddrAnd<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Macaddr<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Macaddr]]); return runtime.PgFunc("macaddr_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddrNot(): types.Macaddr<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr]]); return runtime.PgFunc("macaddr_not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddrOr<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Macaddr<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Macaddr]]); return runtime.PgFunc("macaddr_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddrSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("macaddr_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   trunc(): types.Macaddr<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr]]); return runtime.PgFunc("trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Macaddr<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Macaddr]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Macaddr<any> | string>(arg0: M0): types.Macaddr<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr, allowPrimitive: true }], types.Macaddr]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/macaddr8.ts b/src/types/generated/macaddr8.ts
index be5e6c0..fee2e17 100644
--- a/src/types/generated/macaddr8.ts
+++ b/src/types/generated/macaddr8.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,46 +17,46 @@ export class Macaddr8<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`macaddr8`;
   static __typnameText = "macaddr8";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr(): types.Macaddr<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr]]); return runtime.PgFunc("macaddr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8And<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Macaddr8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Macaddr8]]); return runtime.PgFunc("macaddr8_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8Not(): types.Macaddr8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr8]]); return runtime.PgFunc("macaddr8_not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8Or<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Macaddr8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Macaddr8]]); return runtime.PgFunc("macaddr8_or", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("macaddr8_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   macaddr8Set7Bit(): types.Macaddr8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr8]]); return runtime.PgFunc("macaddr8_set7bit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   trunc(): types.Macaddr8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Macaddr8]]); return runtime.PgFunc("trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Macaddr8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Macaddr8]]); return runtime.PgOp(runtime.sql`&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|']<M0 extends types.Macaddr8<any> | string>(arg0: M0): types.Macaddr8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Macaddr8, allowPrimitive: true }], types.Macaddr8]]); return runtime.PgOp(runtime.sql`|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/money.ts b/src/types/generated/money.ts
index 9c50e04..e7ec15f 100644
--- a/src/types/generated/money.ts
+++ b/src/types/generated/money.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,41 +17,41 @@ export class Money<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`money`;
   static __typnameText = "money";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   cashSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("cash_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cashWords(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("cash_words", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cashlarger<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgFunc("cashlarger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   cashsmaller<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgFunc("cashsmaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Money<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Money]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Money<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Money]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Money<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Money]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
   ['*']<M0 extends types.Float4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int2<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Int8<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['*']<M0 extends types.Float8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['*'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Money], [[{ type: types.Int2 }], types.Money], [[{ type: types.Int4 }], types.Money], [[{ type: types.Int8, allowPrimitive: true }], types.Money], [[{ type: types.Float8 }], types.Money]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   times<M0 extends types.Float4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int2<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Int8<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   times<M0 extends types.Float8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   times(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Float4 }], types.Money], [[{ type: types.Int2 }], types.Money], [[{ type: types.Int4 }], types.Money], [[{ type: types.Int8, allowPrimitive: true }], types.Money], [[{ type: types.Float8 }], types.Money]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Money<any> | string>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Money]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['/']<M0 extends types.Int8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Int4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
@@ -59,7 +59,7 @@ export class Money<in out N extends number> extends Anynonarray<N> {
   ['/']<M0 extends types.Money<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Float4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['/']<M0 extends types.Float8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['/'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Money], [[{ type: types.Int4 }], types.Money], [[{ type: types.Int2 }], types.Money], [[{ type: types.Money, allowPrimitive: true }], types.Float8], [[{ type: types.Float4 }], types.Money], [[{ type: types.Float8 }], types.Money]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   divide<M0 extends types.Int8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Int4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
@@ -67,30 +67,30 @@ export class Money<in out N extends number> extends Anynonarray<N> {
   divide<M0 extends types.Money<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Float4<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   divide<M0 extends types.Float8<any>>(arg0: M0): types.Money<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   divide(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8 }], types.Money], [[{ type: types.Int4 }], types.Money], [[{ type: types.Int2 }], types.Money], [[{ type: types.Money, allowPrimitive: true }], types.Float8], [[{ type: types.Float4 }], types.Money], [[{ type: types.Float8 }], types.Money]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Money<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Money, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/numeric.ts b/src/types/generated/numeric.ts
index fb9d5f8..e54d619 100644
--- a/src/types/generated/numeric.ts
+++ b/src/types/generated/numeric.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,166 +17,166 @@ export class Numeric<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`numeric`;
   static __typnameText = "numeric";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   abs(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ceil(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("ceil", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ceiling(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("ceiling", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   div<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("div", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   exp(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("exp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float4(): types.Float4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float4]]); return runtime.PgFunc("float4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   float8(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("float8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   floor(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("floor", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gcd<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("gcd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int2(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("int2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int4(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("int4", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   int8Sum<M0 extends types.Int8<any> | string>(arg0: M0): types.Numeric<1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("int8_sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lcm<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("lcm", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ln(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("ln", [this, ...__rest], __rt) as any; }
   log(): types.Numeric<N>;
   log<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   log(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[], types.Numeric], [[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("log", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   log10(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("log10", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minScale(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("min_scale", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   mod<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("mod", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numeric<M0 extends types.Int4<any> | number>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("numeric", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericAbs(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric_abs", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericDivTrunc<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("numeric_div_trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericExp(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric_exp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericInc(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric_inc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericLarger<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("numeric_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericLn(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric_ln", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericLog<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("numeric_log", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("numeric_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericSmaller<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("numeric_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numericSqrt(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("numeric_sqrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   numrangeSubdiff<M0 extends types.Numeric<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("numrange_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgLsn(): types.PgLsn<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.PgLsn]]); return runtime.PgFunc("pg_lsn", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSizePretty(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("pg_size_pretty", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pow<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("pow", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   power<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("power", [this, ...__rest], __rt) as any; }
   round<M0 extends types.Int4<any> | number>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   round(): types.Numeric<N>;
-  @tool.unchecked()
+  @expose.unchecked()
   round(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Numeric], [[], types.Numeric]]); return runtime.PgFunc("round", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   scale(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("scale", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sign(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("sign", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sqrt(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("sqrt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   trimScale(): types.Numeric<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("trim_scale", [this, ...__rest], __rt) as any; }
   trunc(): types.Numeric<N>;
   trunc<M0 extends types.Int4<any> | number>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   trunc(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[], types.Numeric], [[{ type: types.Int4, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   widthBucket<M0 extends types.Numeric<any> | string, M1 extends types.Numeric<any> | string, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Numeric, allowPrimitive: true }, { type: types.Numeric, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("width_bucket", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   avg(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("avg", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddev(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stddevSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("stddev_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   sum(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("sum", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varPop(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_pop", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varSamp(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("var_samp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   variance(): types.Numeric<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Numeric]]); return runtime.PgFunc("variance", [this, ...__rest], __rt) as any; }
   generateSeries<M0 extends types.Numeric<any> | string, M1 extends types.Numeric<any> | string>(arg0: M0, arg1: M1): runtime.PgSrf<{ generate_series: types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "generate_series">;
   generateSeries<M0 extends types.Numeric<any> | string>(arg0: M0): runtime.PgSrf<{ generate_series: types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> }, "generate_series">;
-  @tool.unchecked()
+  @expose.unchecked()
   generateSeries(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Numeric, allowPrimitive: true }, { type: types.Numeric, allowPrimitive: true }], types.Numeric], [[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return new runtime.PgSrf("generate_series", [this, ...__rest], [["generate_series", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['%']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`%`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   times<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['+']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.PgLsn<any>>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric], [[{ type: types.PgLsn }], types.PgLsn]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.PgLsn<any>>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric], [[{ type: types.PgLsn }], types.PgLsn]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['/']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   divide<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`/`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Numeric<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['^']<M0 extends types.Numeric<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`^`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/oid.ts b/src/types/generated/oid.ts
index 673e53c..b1f7b94 100644
--- a/src/types/generated/oid.ts
+++ b/src/types/generated/oid.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,50 +17,50 @@ export class Oid<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`oid`;
   static __typnameText = "oid";
   declare deserialize: (raw: string) => number;
-  @tool.unchecked()
+  @expose.unchecked()
   int8(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("int8", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   makeaclitem<M0 extends types.Oid<any> | number, M1 extends types.Text<any> | string, M2 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1, arg2: M2): types.Aclitem<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Oid, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Aclitem]]); return runtime.PgFunc("makeaclitem", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   oidlarger<M0 extends types.Oid<any> | number>(arg0: M0): types.Oid<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Oid]]); return runtime.PgFunc("oidlarger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   oidsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("oidsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   oidsmaller<M0 extends types.Oid<any> | number>(arg0: M0): types.Oid<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Oid]]); return runtime.PgFunc("oidsmaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgIndexamProgressPhasename<M0 extends types.Int8<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int8, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("pg_indexam_progress_phasename", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   satisfiesHashPartition<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number, M2 extends types.Any<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Any, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("satisfies_hash_partition", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Oid<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Oid]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Oid<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Oid]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsParse<M0 extends types.Text<any> | string>(arg0: M0): runtime.PgSrf<{ tokid: types.Int4<1>; token: types.Text<1> }, "ts_parse"> { return new runtime.PgSrf("ts_parse", [this, arg0], [["tokid", types.Int4], ["token", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsTokenType(): runtime.PgSrf<{ tokid: types.Int4<1>; alias: types.Text<1>; description: types.Text<1> }, "ts_token_type"> { return new runtime.PgSrf("ts_token_type", [this], [["tokid", types.Int4], ["alias", types.Text], ["description", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Oid<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Oid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/path.ts b/src/types/generated/path.ts
index bb272f0..fee8ebe 100644
--- a/src/types/generated/path.ts
+++ b/src/types/generated/path.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,58 +17,58 @@ export class Path<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`path`;
   static __typnameText = "path";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   area(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("area", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isclosed(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isclosed", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isopen(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isopen", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   npoints(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("npoints", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pathDistance<M0 extends types.Path<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("path_distance", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pathInter<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("path_inter", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pathLength(): types.Float8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Float8]]); return runtime.PgFunc("path_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pathNpoints(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("path_npoints", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pathSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("path_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pclose(): types.Path<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Path]]); return runtime.PgFunc("pclose", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polygon(): types.Polygon<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Polygon]]); return runtime.PgFunc("polygon", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   popen(): types.Path<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Path]]); return runtime.PgFunc("popen", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Path<any> | string>(arg0: M0): types.Path<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Path]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Path<any> | string>(arg0: M0): types.Path<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Path]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<->']<M0 extends types.Path<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`<->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['?#']<M0 extends types.Path<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Path, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`?#`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/pg_brin_bloom_summary.ts b/src/types/generated/pg_brin_bloom_summary.ts
index e33ea75..a2a2e96 100644
--- a/src/types/generated/pg_brin_bloom_summary.ts
+++ b/src/types/generated/pg_brin_bloom_summary.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_brin_minmax_multi_summary.ts b/src/types/generated/pg_brin_minmax_multi_summary.ts
index da1f9de..9ef28ff 100644
--- a/src/types/generated/pg_brin_minmax_multi_summary.ts
+++ b/src/types/generated/pg_brin_minmax_multi_summary.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_dependencies.ts b/src/types/generated/pg_dependencies.ts
index 36e8a4d..d3500e4 100644
--- a/src/types/generated/pg_dependencies.ts
+++ b/src/types/generated/pg_dependencies.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_lsn.ts b/src/types/generated/pg_lsn.ts
index 160234a..ced07c9 100644
--- a/src/types/generated/pg_lsn.ts
+++ b/src/types/generated/pg_lsn.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,56 +17,56 @@ export class PgLsn<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`pg_lsn`;
   static __typnameText = "pg_lsn";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   pgLsnLarger<M0 extends types.PgLsn<any> | string>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.PgLsn]]); return runtime.PgFunc("pg_lsn_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgLsnSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("pg_lsn_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgLsnSmaller<M0 extends types.PgLsn<any> | string>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.PgLsn]]); return runtime.PgFunc("pg_lsn_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgWalLsnDiff<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Numeric]]); return runtime.PgFunc("pg_wal_lsn_diff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgWalfileName(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("pg_walfile_name", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgWalfileNameOffset(): types.Record<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Record]]); return runtime.PgFunc("pg_walfile_name_offset", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.PgLsn<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.PgLsn]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.PgLsn<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.PgLsn]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Numeric<any> | string>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.PgLsn]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Numeric<any> | string>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric, allowPrimitive: true }], types.PgLsn]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Numeric<any>>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric }], types.PgLsn], [[{ type: types.PgLsn, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Numeric<any>>(arg0: M0): types.PgLsn<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Numeric }], types.PgLsn], [[{ type: types.PgLsn, allowPrimitive: true }], types.Numeric]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.PgLsn<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgLsn, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/pg_mcv_list.ts b/src/types/generated/pg_mcv_list.ts
index da55789..3698733 100644
--- a/src/types/generated/pg_mcv_list.ts
+++ b/src/types/generated/pg_mcv_list.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_ndistinct.ts b/src/types/generated/pg_ndistinct.ts
index 7e4a834..47eaf4f 100644
--- a/src/types/generated/pg_ndistinct.ts
+++ b/src/types/generated/pg_ndistinct.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_node_tree.ts b/src/types/generated/pg_node_tree.ts
index 2a02b15..5cee325 100644
--- a/src/types/generated/pg_node_tree.ts
+++ b/src/types/generated/pg_node_tree.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/pg_snapshot.ts b/src/types/generated/pg_snapshot.ts
index 8927de1..8128a3b 100644
--- a/src/types/generated/pg_snapshot.ts
+++ b/src/types/generated/pg_snapshot.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,12 +17,12 @@ export class PgSnapshot<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`pg_snapshot`;
   static __typnameText = "pg_snapshot";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   pgSnapshotSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("pg_snapshot_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSnapshotXmax(): types.Xid8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid8]]); return runtime.PgFunc("pg_snapshot_xmax", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSnapshotXmin(): types.Xid8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid8]]); return runtime.PgFunc("pg_snapshot_xmin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSnapshotXip(): runtime.PgSrf<{ pg_snapshot_xip: types.Xid8<N> }, "pg_snapshot_xip"> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid8]]); return new runtime.PgSrf("pg_snapshot_xip", [this, ...__rest], [["pg_snapshot_xip", __rt]]) as any; }
 }
diff --git a/src/types/generated/polygon.ts b/src/types/generated/polygon.ts
index 9ee8501..8a97947 100644
--- a/src/types/generated/polygon.ts
+++ b/src/types/generated/polygon.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,70 +17,70 @@ export class Polygon<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`polygon`;
   static __typnameText = "polygon";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   circle(): types.Circle<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Circle]]); return runtime.PgFunc("circle", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   distPolyc<M0 extends types.Circle<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("dist_polyc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   npoints(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("npoints", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   path(): types.Path<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Path]]); return runtime.PgFunc("path", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyAbove<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_above", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyBelow<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_below", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyContain<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_contain", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyContained<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_contained", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyDistance<M0 extends types.Polygon<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("poly_distance", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyLeft<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_left", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyNpoints(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("poly_npoints", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyOverabove<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_overabove", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyOverbelow<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_overbelow", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyOverlap<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_overlap", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyOverleft<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_overleft", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyOverright<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_overright", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polyRight<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_right", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polySame<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("poly_same", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   polySend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("poly_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&<|']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&<|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&>']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<->']<M0 extends types.Circle<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<->']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<->'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Circle }], types.Float8], [[{ type: types.Polygon, allowPrimitive: true }], types.Float8]]); return runtime.PgOp(runtime.sql`<->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<<|']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<<|`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>>']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|&>']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`|&>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['|>>']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`|>>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~=']<M0 extends types.Polygon<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Polygon, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/record.ts b/src/types/generated/record.ts
index 11b4363..b011d96 100644
--- a/src/types/generated/record.ts
+++ b/src/types/generated/record.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -16,52 +16,52 @@ export class Record<in out N extends number> extends Anynonarray<N> {
   };
   static __typname = runtime.sql`record`;
   static __typnameText = "record";
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageEq<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_eq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageGe<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_ge", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageGt<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_gt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageLe<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_le", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageLt<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_lt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   recordImageNe<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("record_image_ne", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*<']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*<=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*<>']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*>']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['*>=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`*>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Record<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Record, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/refcursor.ts b/src/types/generated/refcursor.ts
index cef4e29..c3f1787 100644
--- a/src/types/generated/refcursor.ts
+++ b/src/types/generated/refcursor.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
diff --git a/src/types/generated/regclass.ts b/src/types/generated/regclass.ts
index b7997d1..bf9aac2 100644
--- a/src/types/generated/regclass.ts
+++ b/src/types/generated/regclass.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,8 +17,8 @@ export class Regclass<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regclass`;
   static __typnameText = "regclass";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   pgPartitionRoot(): types.Regclass<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Regclass]]); return runtime.PgFunc("pg_partition_root", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regclasssend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regclasssend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regcollation.ts b/src/types/generated/regcollation.ts
index da96ec8..0e95132 100644
--- a/src/types/generated/regcollation.ts
+++ b/src/types/generated/regcollation.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regcollation<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regcollation`;
   static __typnameText = "regcollation";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regcollationsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regcollationsend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regconfig.ts b/src/types/generated/regconfig.ts
index 00e076d..a668e7c 100644
--- a/src/types/generated/regconfig.ts
+++ b/src/types/generated/regconfig.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,22 +17,22 @@ export class Regconfig<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regconfig`;
   static __typnameText = "regconfig";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   jsonToTsvector<M0 extends types.Json<any> | string, M1 extends types.Jsonb<any> | string>(arg0: M0, arg1: M1): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Json, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }], types.Tsvector]]); return runtime.PgFunc("json_to_tsvector", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   jsonbToTsvector<M0 extends types.Jsonb<any> | string, M1 extends types.Jsonb<any> | string>(arg0: M0, arg1: M1): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Jsonb, allowPrimitive: true }, { type: types.Jsonb, allowPrimitive: true }], types.Tsvector]]); return runtime.PgFunc("jsonb_to_tsvector", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   phrasetoTsquery<M0 extends types.Text<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("phraseto_tsquery", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plaintoTsquery<M0 extends types.Text<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("plainto_tsquery", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   regconfigsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regconfigsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   toTsquery<M0 extends types.Text<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("to_tsquery", [this, ...__rest], __rt) as any; }
   toTsvector<M0 extends types.Text<any>>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   toTsvector<M0 extends types.Jsonb<any>>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   toTsvector<M0 extends types.Json<any>>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   toTsvector(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text }], types.Tsvector], [[{ type: types.Jsonb }], types.Tsvector], [[{ type: types.Json }], types.Tsvector]]); return runtime.PgFunc("to_tsvector", [this, ...__rest], __rt) as any; }
   tsHeadline<M0 extends types.Json<any>, M1 extends types.Tsquery<any>>(arg0: M0, arg1: M1): types.Json<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   tsHeadline<M0 extends types.Text<any>, M1 extends types.Tsquery<any>, M2 extends types.Text<any>>(arg0: M0, arg1: M1, arg2: M2): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
@@ -40,8 +40,8 @@ export class Regconfig<in out N extends number> extends Anynonarray<N> {
   tsHeadline<M0 extends types.Json<any>, M1 extends types.Tsquery<any>, M2 extends types.Text<any>>(arg0: M0, arg1: M1, arg2: M2): types.Json<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   tsHeadline<M0 extends types.Jsonb<any>, M1 extends types.Tsquery<any>>(arg0: M0, arg1: M1): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   tsHeadline<M0 extends types.Jsonb<any>, M1 extends types.Tsquery<any>, M2 extends types.Text<any>>(arg0: M0, arg1: M1, arg2: M2): types.Jsonb<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   tsHeadline(arg0: unknown, arg1: unknown, arg2?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Json }, { type: types.Tsquery }], types.Json], [[{ type: types.Text }, { type: types.Tsquery }, { type: types.Text }], types.Text], [[{ type: types.Text }, { type: types.Tsquery }], types.Text], [[{ type: types.Json }, { type: types.Tsquery }, { type: types.Text }], types.Json], [[{ type: types.Jsonb }, { type: types.Tsquery }], types.Jsonb], [[{ type: types.Jsonb }, { type: types.Tsquery }, { type: types.Text }], types.Jsonb]]); return runtime.PgFunc("ts_headline", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   websearchToTsquery<M0 extends types.Text<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("websearch_to_tsquery", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regdictionary.ts b/src/types/generated/regdictionary.ts
index 46e3ad6..e705604 100644
--- a/src/types/generated/regdictionary.ts
+++ b/src/types/generated/regdictionary.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regdictionary<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regdictionary`;
   static __typnameText = "regdictionary";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regdictionarysend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regdictionarysend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regnamespace.ts b/src/types/generated/regnamespace.ts
index 7e1836b..f53141b 100644
--- a/src/types/generated/regnamespace.ts
+++ b/src/types/generated/regnamespace.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regnamespace<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regnamespace`;
   static __typnameText = "regnamespace";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regnamespacesend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regnamespacesend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regoper.ts b/src/types/generated/regoper.ts
index 426421c..ab4d776 100644
--- a/src/types/generated/regoper.ts
+++ b/src/types/generated/regoper.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regoper<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regoper`;
   static __typnameText = "regoper";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regopersend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regopersend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regoperator.ts b/src/types/generated/regoperator.ts
index 8c4687b..9479684 100644
--- a/src/types/generated/regoperator.ts
+++ b/src/types/generated/regoperator.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regoperator<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regoperator`;
   static __typnameText = "regoperator";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regoperatorsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regoperatorsend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regproc.ts b/src/types/generated/regproc.ts
index 9dd5b97..32405f3 100644
--- a/src/types/generated/regproc.ts
+++ b/src/types/generated/regproc.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regproc<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regproc`;
   static __typnameText = "regproc";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regprocsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regprocsend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regprocedure.ts b/src/types/generated/regprocedure.ts
index f977507..b33e279 100644
--- a/src/types/generated/regprocedure.ts
+++ b/src/types/generated/regprocedure.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regprocedure<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regprocedure`;
   static __typnameText = "regprocedure";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regproceduresend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regproceduresend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regrole.ts b/src/types/generated/regrole.ts
index 9c84750..58b2a09 100644
--- a/src/types/generated/regrole.ts
+++ b/src/types/generated/regrole.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regrole<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regrole`;
   static __typnameText = "regrole";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regrolesend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regrolesend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/regtype.ts b/src/types/generated/regtype.ts
index 01c3b8f..beabd3b 100644
--- a/src/types/generated/regtype.ts
+++ b/src/types/generated/regtype.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Regtype<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`regtype`;
   static __typnameText = "regtype";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   regtypesend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("regtypesend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/text.ts b/src/types/generated/text.ts
index 6898091..443f510 100644
--- a/src/types/generated/text.ts
+++ b/src/types/generated/text.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,89 +17,89 @@ export class Text<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`text`;
   static __typnameText = "text";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   ascii(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("ascii", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   bitLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("bit_length", [this, ...__rest], __rt) as any; }
   btrim(): types.Text<N>;
   btrim<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   btrim(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[], types.Text], [[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("btrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   char(): types.Char<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Char]]); return runtime.PgFunc("char", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   charLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("char_length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   characterLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("character_length", [this, ...__rest], __rt) as any; }
   datePart<M0 extends types.Timestamp<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   datePart<M0 extends types.Date<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   datePart<M0 extends types.Time<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   datePart<M0 extends types.Timetz<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   datePart<M0 extends types.Interval<any>>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   datePart(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Float8], [[{ type: types.Date }], types.Float8], [[{ type: types.Time }], types.Float8], [[{ type: types.Timetz }], types.Float8], [[{ type: types.Interval }], types.Float8]]); return runtime.PgFunc("date_part", [this, ...__rest], __rt) as any; }
   dateTrunc<M0 extends types.Interval<any>>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   dateTrunc<M0 extends types.Timestamptz<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   dateTrunc<M0 extends types.Timestamp<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   dateTrunc(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Interval }], types.Interval], [[{ type: types.Timestamptz, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Timestamptz], [[{ type: types.Timestamp }], types.Timestamp]]); return runtime.PgFunc("date_trunc", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   decode<M0 extends types.Text<any> | string>(arg0: M0): types.Bytea<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bytea]]); return runtime.PgFunc("decode", [this, ...__rest], __rt) as any; }
   extract<M0 extends types.Interval<any>>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   extract<M0 extends types.Timestamp<any>>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   extract<M0 extends types.Timetz<any>>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   extract<M0 extends types.Time<any>>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   extract<M0 extends types.Date<any>>(arg0: M0): types.Numeric<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   extract(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Numeric], [[{ type: types.Timestamp }], types.Numeric], [[{ type: types.Timetz }], types.Numeric], [[{ type: types.Time }], types.Numeric], [[{ type: types.Date }], types.Numeric]]); return runtime.PgFunc("extract", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   initcap(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("initcap", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isNormalized<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("is_normalized", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   left<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("left", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   like<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("like", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   likeEscape<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("like_escape", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lower(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("lower", [this, ...__rest], __rt) as any; }
   lpad<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lpad<M0 extends types.Int4<any> | number, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lpad(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("lpad", [this, ...__rest], __rt) as any; }
   ltrim<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ltrim(): types.Text<N>;
-  @tool.unchecked()
+  @expose.unchecked()
   ltrim(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[], types.Text]]); return runtime.PgFunc("ltrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   md5(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("md5", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   normalize<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("normalize", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   notlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("notlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   octetLength(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("octet_length", [this, ...__rest], __rt) as any; }
   overlay<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   overlay<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   overlay(arg0: unknown, arg1: unknown, arg2?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("overlay", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   pgSizeBytes(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("pg_size_bytes", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   position<M0 extends types.Text<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("position", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   quoteIdent(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("quote_ident", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   quoteLiteral(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("quote_literal", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   quoteNullable(): types.Text<1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("quote_nullable", [this, ...__rest], __rt) as any; }
   regexpCount<M0 extends types.Text<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   regexpCount<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   regexpCount<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Text<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpCount(arg0: unknown, arg1?: unknown, arg2?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Text, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("regexp_count", [this, ...__rest], __rt) as any; }
   regexpInstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   regexpInstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number, M4 extends types.Text<any> | string, M5 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3, arg4: M4, arg5: M5): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3> | runtime.NullOf<M4> | runtime.NullOf<M5>>>;
@@ -107,194 +107,194 @@ export class Text<in out N extends number> extends Anynonarray<N> {
   regexpInstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3>>>;
   regexpInstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   regexpInstr<M0 extends types.Text<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpInstr(arg0: unknown, arg1?: unknown, arg2?: unknown, arg3?: unknown, arg4?: unknown, arg5?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2, arg3, arg4, arg5], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Int4], [[{ type: types.Text, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("regexp_instr", [this, ...__rest], __rt) as any; }
   regexpLike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   regexpLike<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpLike(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }], types.Bool], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("regexp_like", [this, ...__rest], __rt) as any; }
   regexpReplace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3>>>;
   regexpReplace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   regexpReplace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   regexpReplace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string, M2 extends types.Text<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   regexpReplace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string, M2 extends types.Int4<any> | number, M3 extends types.Int4<any> | number, M4 extends types.Text<any> | string>(arg0: M0, arg1: M1, arg2: M2, arg3: M3, arg4: M4): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3> | runtime.NullOf<M4>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpReplace(arg0: unknown, arg1: unknown, arg2?: unknown, arg3?: unknown, arg4?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2, arg3, arg4], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("regexp_replace", [this, ...__rest], __rt) as any; }
   regexpSubstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Text<any> | string, M4 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2, arg3: M3, arg4: M4): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3> | runtime.NullOf<M4>>>;
   regexpSubstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number>(arg0: M0, arg1: M1, arg2: M2): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>>;
   regexpSubstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   regexpSubstr<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number, M2 extends types.Int4<any> | number, M3 extends types.Text<any> | string>(arg0: M0, arg1: M1, arg2: M2, arg3: M3): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2> | runtime.NullOf<M3>>>;
   regexpSubstr<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpSubstr(arg0: unknown, arg1?: unknown, arg2?: unknown, arg3?: unknown, arg4?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2, arg3, arg4], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("regexp_substr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   repeat<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("repeat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   replace<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("replace", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   reverse(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("reverse", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   right<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("right", [this, ...__rest], __rt) as any; }
   rpad<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   rpad<M0 extends types.Int4<any> | number, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   rpad(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("rpad", [this, ...__rest], __rt) as any; }
   rtrim<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   rtrim(): types.Text<N>;
-  @tool.unchecked()
+  @expose.unchecked()
   rtrim(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[], types.Text]]); return runtime.PgFunc("rtrim", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   similarEscape<M0 extends types.Text<any> | string>(arg0: M0): types.Text<1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("similar_escape", [this, ...__rest], __rt) as any; }
   similarToEscape<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   similarToEscape(): types.Text<N>;
-  @tool.unchecked()
+  @expose.unchecked()
   similarToEscape(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[], types.Text]]); return runtime.PgFunc("similar_to_escape", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   splitPart<M0 extends types.Text<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("split_part", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   startsWith<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("starts_with", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   strpos<M0 extends types.Text<any> | string>(arg0: M0): types.Int4<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Int4]]); return runtime.PgFunc("strpos", [this, ...__rest], __rt) as any; }
   substr<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   substr<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   substr(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("substr", [this, ...__rest], __rt) as any; }
   substring<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   substring<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   substring<M0 extends types.Int4<any> | number, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   substring<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   substring(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Text], [[{ type: types.Int4, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("substring", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textLarger<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("text_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textPatternGe<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("text_pattern_ge", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textPatternGt<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("text_pattern_gt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textPatternLe<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("text_pattern_le", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textPatternLt<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("text_pattern_lt", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textSmaller<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("text_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textcat<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("textcat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   texticlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("texticlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   texticnlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("texticnlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   texticregexeq<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("texticregexeq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   texticregexne<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("texticregexne", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textlen(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("textlen", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("textlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textnlike<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("textnlike", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textregexeq<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("textregexeq", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   textregexne<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("textregexne", [this, ...__rest], __rt) as any; }
   timezone<M0 extends types.Timestamp<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   timezone<M0 extends types.Timestamptz<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   timezone(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Timestamptz], [[{ type: types.Timestamptz }], types.Timestamp]]); return runtime.PgFunc("timezone", [this, ...__rest], __rt) as any; }
   toAscii<M0 extends types.Int4<any> | number>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   toAscii(): types.Text<N>;
-  @tool.unchecked()
+  @expose.unchecked()
   toAscii(arg0?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Text], [[], types.Text]]); return runtime.PgFunc("to_ascii", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   translate<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("translate", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   unicodeAssigned(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("unicode_assigned", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   unistr(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("unistr", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   upper(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("upper", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlIsWellFormedContent(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("xml_is_well_formed_content", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlIsWellFormedDocument(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("xml_is_well_formed_document", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlcomment(): types.Xml<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xml]]); return runtime.PgFunc("xmlcomment", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlexists<M0 extends types.Xml<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xml, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("xmlexists", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmltext(): types.Xml<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xml]]); return runtime.PgFunc("xmltext", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xpathExists<M0 extends types.Xml<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xml, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("xpath_exists", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Text<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Text<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   stringAgg<M0 extends types.Text<any> | string>(arg0: M0): types.Text<0 | 1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgFunc("string_agg", [this, ...__rest], __rt) as any; }
   regexpSplitToTable<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): runtime.PgSrf<{ regexp_split_to_table: types.Text<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "regexp_split_to_table">;
   regexpSplitToTable<M0 extends types.Text<any> | string>(arg0: M0): runtime.PgSrf<{ regexp_split_to_table: types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>> }, "regexp_split_to_table">;
-  @tool.unchecked()
+  @expose.unchecked()
   regexpSplitToTable(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }], types.Text]]); return new runtime.PgSrf("regexp_split_to_table", [this, ...__rest], [["regexp_split_to_table", __rt]]) as any; }
   stringToTable<M0 extends types.Text<any> | string>(arg0: M0): runtime.PgSrf<{ string_to_table: types.Text<1> }, "string_to_table">;
   stringToTable<M0 extends types.Text<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): runtime.PgSrf<{ string_to_table: types.Text<1> }, "string_to_table">;
-  @tool.unchecked()
+  @expose.unchecked()
   stringToTable(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Text, allowPrimitive: true }], types.Text], [[{ type: types.Text, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Text]]); return new runtime.PgSrf("string_to_table", [this, ...__rest], [["string_to_table", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['!~~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`!~~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['@@']<M0 extends types.Tsquery<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['@@']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery }], types.Bool], [[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['^@']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`^@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['||']<M0 extends types.Anynonarray<any>>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['||']<M0 extends types.Text<any> | string>(arg0: M0): types.Text<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['||'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Anynonarray }], types.Text], [[{ type: types.Text, allowPrimitive: true }], types.Text]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~<=~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~<=~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~<~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~<~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~>=~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~>=~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~>~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~>~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~~']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~~`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['~~*']<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`~~*`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/tid.ts b/src/types/generated/tid.ts
index eac556c..c997fdf 100644
--- a/src/types/generated/tid.ts
+++ b/src/types/generated/tid.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,38 +17,38 @@ export class Tid<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`tid`;
   static __typnameText = "tid";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   tidlarger<M0 extends types.Tid<any> | string>(arg0: M0): types.Tid<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Tid]]); return runtime.PgFunc("tidlarger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tidsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("tidsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tidsmaller<M0 extends types.Tid<any> | string>(arg0: M0): types.Tid<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Tid]]); return runtime.PgFunc("tidsmaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Tid<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Tid]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Tid<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Tid]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Tid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/time.ts b/src/types/generated/time.ts
index 8bcba64..8660319 100644
--- a/src/types/generated/time.ts
+++ b/src/types/generated/time.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,64 +17,64 @@ export class Time<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`time`;
   static __typnameText = "time";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   interval(): types.Interval<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Interval]]); return runtime.PgFunc("interval", [this, ...__rest], __rt) as any; }
   overlaps<M0 extends types.Time<any>, M1 extends types.Time<any>, M2 extends types.Interval<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Time<any> | string, M1 extends types.Time<any> | string, M2 extends types.Time<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Interval<any>, M1 extends types.Time<any>, M2 extends types.Interval<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Interval<any>, M1 extends types.Time<any>, M2 extends types.Time<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
-  @tool.unchecked()
+  @expose.unchecked()
   overlaps(arg0: unknown, arg1: unknown, arg2: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Time }, { type: types.Time }, { type: types.Interval }], types.Bool], [[{ type: types.Time, allowPrimitive: true }, { type: types.Time, allowPrimitive: true }, { type: types.Time, allowPrimitive: true }], types.Bool], [[{ type: types.Interval }, { type: types.Time }, { type: types.Interval }], types.Bool], [[{ type: types.Interval }, { type: types.Time }, { type: types.Time }], types.Bool]]); return runtime.PgFunc("overlaps", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   time<M0 extends types.Int4<any> | number>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Time]]); return runtime.PgFunc("time", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timeLarger<M0 extends types.Time<any> | string>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Time]]); return runtime.PgFunc("time_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timeSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("time_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timeSmaller<M0 extends types.Time<any> | string>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Time]]); return runtime.PgFunc("time_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Time<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Time]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Time<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Time]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
   ['+']<M0 extends types.Interval<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Date<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Time], [[{ type: types.Date }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Interval<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Date<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Time], [[{ type: types.Date }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Time<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Interval<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Interval], [[{ type: types.Interval }], types.Time]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Time<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Interval<any>>(arg0: M0): types.Time<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Interval], [[{ type: types.Interval }], types.Time]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Time<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Time, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/timestamp.ts b/src/types/generated/timestamp.ts
index 9212183..ccf1f85 100644
--- a/src/types/generated/timestamp.ts
+++ b/src/types/generated/timestamp.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,106 +17,106 @@ export class Timestamp<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`timestamp`;
   static __typnameText = "timestamp";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   age<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("age", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   date(): types.Date<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Date]]); return runtime.PgFunc("date", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isfinite(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isfinite", [this, ...__rest], __rt) as any; }
   overlaps<M0 extends types.Interval<any>, M1 extends types.Timestamp<any>, M2 extends types.Interval<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Interval<any>, M1 extends types.Timestamp<any>, M2 extends types.Timestamp<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Timestamp<any>, M1 extends types.Timestamp<any>, M2 extends types.Interval<any>>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
   overlaps<M0 extends types.Timestamp<any> | string, M1 extends types.Timestamp<any> | string, M2 extends types.Timestamp<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1>;
-  @tool.unchecked()
+  @expose.unchecked()
   overlaps(arg0: unknown, arg1: unknown, arg2: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Interval }, { type: types.Timestamp }, { type: types.Interval }], types.Bool], [[{ type: types.Interval }, { type: types.Timestamp }, { type: types.Timestamp }], types.Bool], [[{ type: types.Timestamp }, { type: types.Timestamp }, { type: types.Interval }], types.Bool], [[{ type: types.Timestamp, allowPrimitive: true }, { type: types.Timestamp, allowPrimitive: true }, { type: types.Timestamp, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("overlaps", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   time(): types.Time<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Time]]); return runtime.PgFunc("time", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamp<M0 extends types.Int4<any> | number>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Timestamp]]); return runtime.PgFunc("timestamp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestampLarger<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Timestamp]]); return runtime.PgFunc("timestamp_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestampSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("timestamp_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestampSmaller<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Timestamp]]); return runtime.PgFunc("timestamp_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsrangeSubdiff<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("tsrange_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Timestamp<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamp]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Timestamp<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamp]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   generateSeries<M0 extends types.Timestamp<any> | string, M1 extends types.Interval<any> | string>(arg0: M0, arg1: M1): runtime.PgSrf<{ generate_series: types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> }, "generate_series"> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Timestamp, allowPrimitive: true }, { type: types.Interval, allowPrimitive: true }], types.Timestamp]]); return new runtime.PgSrf("generate_series", [this, ...__rest], [["generate_series", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Interval<any> | string>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Interval<any> | string>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timestamp]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamp], [[{ type: types.Timestamp, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Interval<any>>(arg0: M0): types.Timestamp<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamp], [[{ type: types.Timestamp, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz }], types.Bool], [[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Timestamp<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Timestamptz<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamptz }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/timestamptz.ts b/src/types/generated/timestamptz.ts
index a5dbaa7..839a4cc 100644
--- a/src/types/generated/timestamptz.ts
+++ b/src/types/generated/timestamptz.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,102 +17,102 @@ export class Timestamptz<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`timestamptz`;
   static __typnameText = "timestamptz";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   age<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Interval]]); return runtime.PgFunc("age", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dateAdd<M0 extends types.Interval<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Interval, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("date_add", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   dateSubtract<M0 extends types.Interval<any> | string, M1 extends types.Text<any> | string>(arg0: M0, arg1: M1): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Interval, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("date_subtract", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   isfinite(): types.Bool<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bool]]); return runtime.PgFunc("isfinite", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   overlaps<M0 extends types.Timestamptz<any> | string, M1 extends types.Timestamptz<any> | string, M2 extends types.Timestamptz<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Timestamptz, allowPrimitive: true }, { type: types.Timestamptz, allowPrimitive: true }, { type: types.Timestamptz, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("overlaps", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamptz<M0 extends types.Int4<any> | number>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("timestamptz", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamptzLarger<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("timestamptz_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamptzSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("timestamptz_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timestamptzSmaller<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgFunc("timestamptz_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tstzrangeSubdiff<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Float8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Float8]]); return runtime.PgFunc("tstzrange_subdiff", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Timestamptz<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamptz]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Timestamptz<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamptz]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   generateSeries<M0 extends types.Timestamptz<any> | string, M1 extends types.Interval<any> | string, M2 extends types.Text<any> | string>(arg0: M0, arg1: M1, arg2: M2): runtime.PgSrf<{ generate_series: types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1> | runtime.NullOf<M2>>> }, "generate_series"> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Timestamptz, allowPrimitive: true }, { type: types.Interval, allowPrimitive: true }, { type: types.Text, allowPrimitive: true }], types.Timestamptz]]); return new runtime.PgSrf("generate_series", [this, ...__rest], [["generate_series", __rt]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['+']<M0 extends types.Interval<any> | string>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   plus<M0 extends types.Interval<any> | string>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timestamptz]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['-']<M0 extends types.Interval<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['-']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['-'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamptz], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   minus<M0 extends types.Interval<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   minus<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Interval<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   minus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timestamptz], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Interval]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lt<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lt<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<=']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   lte<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   lte<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   lte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['<>']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gt<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gt<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gt(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool], [[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['>=']<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['>=']<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['>='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   gte<M0 extends types.Timestamptz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Date<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   gte<M0 extends types.Timestamp<any>>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   gte(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timestamptz, allowPrimitive: true }], types.Bool], [[{ type: types.Date }], types.Bool], [[{ type: types.Timestamp }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/timetz.ts b/src/types/generated/timetz.ts
index 937df45..351ac0e 100644
--- a/src/types/generated/timetz.ts
+++ b/src/types/generated/timetz.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,56 +17,56 @@ export class Timetz<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`timetz`;
   static __typnameText = "timetz";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   overlaps<M0 extends types.Timetz<any> | string, M1 extends types.Timetz<any> | string, M2 extends types.Timetz<any> | string>(arg0: M0, arg1: M1, arg2: M2): types.Bool<1> { const [__rt, ...__rest] = runtime.match([arg0, arg1, arg2], [[[{ type: types.Timetz, allowPrimitive: true }, { type: types.Timetz, allowPrimitive: true }, { type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("overlaps", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   time(): types.Time<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Time]]); return runtime.PgFunc("time", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timetz<M0 extends types.Int4<any> | number>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Int4, allowPrimitive: true }], types.Timetz]]); return runtime.PgFunc("timetz", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timetzLarger<M0 extends types.Timetz<any> | string>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Timetz]]); return runtime.PgFunc("timetz_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timetzSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("timetz_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   timetzSmaller<M0 extends types.Timetz<any> | string>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Timetz]]); return runtime.PgFunc("timetz_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Timetz<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timetz]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Timetz<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timetz]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
   ['+']<M0 extends types.Interval<any>>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['+']<M0 extends types.Date<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['+'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timetz], [[{ type: types.Date }], types.Timestamptz]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   plus<M0 extends types.Interval<any>>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   plus<M0 extends types.Date<any>>(arg0: M0): types.Timestamptz<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   plus(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval }], types.Timetz], [[{ type: types.Date }], types.Timestamptz]]); return runtime.PgOp(runtime.sql`+`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['-']<M0 extends types.Interval<any> | string>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timetz]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   minus<M0 extends types.Interval<any> | string>(arg0: M0): types.Timetz<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Interval, allowPrimitive: true }], types.Timetz]]); return runtime.PgOp(runtime.sql`-`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Timetz<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Timetz, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/tsquery.ts b/src/types/generated/tsquery.ts
index 6ce196d..c26b237 100644
--- a/src/types/generated/tsquery.ts
+++ b/src/types/generated/tsquery.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,66 +17,66 @@ export class Tsquery<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`tsquery`;
   static __typnameText = "tsquery";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   numnode(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("numnode", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   querytree(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("querytree", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsMatchQv<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("ts_match_qv", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsRewrite<M0 extends types.Tsquery<any> | string, M1 extends types.Tsquery<any> | string>(arg0: M0, arg1: M1): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Tsquery, allowPrimitive: true }, { type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("ts_rewrite", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsqMcontained<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("tsq_mcontained", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsqMcontains<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("tsq_mcontains", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsqueryAnd<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("tsquery_and", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsqueryNot(): types.Tsquery<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Tsquery]]); return runtime.PgFunc("tsquery_not", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsqueryOr<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("tsquery_or", [this, ...__rest], __rt) as any; }
   tsqueryPhrase<M0 extends types.Tsquery<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   tsqueryPhrase<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   tsqueryPhrase(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Tsquery, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Tsquery], [[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgFunc("tsquery_phrase", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsquerysend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("tsquerysend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['&&']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgOp(runtime.sql`&&`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<->']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgOp(runtime.sql`<->`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<@']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@>']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@@']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['||']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Tsquery<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Tsquery]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/tsvector.ts b/src/types/generated/tsvector.ts
index 4763f6f..6ec9cfa 100644
--- a/src/types/generated/tsvector.ts
+++ b/src/types/generated/tsvector.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,58 +17,58 @@ export class Tsvector<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`tsvector`;
   static __typnameText = "tsvector";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   length(): types.Int4<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int4]]); return runtime.PgFunc("length", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   setweight<M0 extends types.Char<any> | string>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Char, allowPrimitive: true }], types.Tsvector]]); return runtime.PgFunc("setweight", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   strip(): types.Tsvector<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Tsvector]]); return runtime.PgFunc("strip", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsDelete<M0 extends types.Text<any> | string>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Tsvector]]); return runtime.PgFunc("ts_delete", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsMatchVq<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("ts_match_vq", [this, ...__rest], __rt) as any; }
   tsRank<M0 extends types.Tsquery<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
   tsRank<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   tsRank(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Tsquery, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Float4], [[{ type: types.Tsquery, allowPrimitive: true }], types.Float4]]); return runtime.PgFunc("ts_rank", [this, ...__rest], __rt) as any; }
   tsRankCd<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   tsRankCd<M0 extends types.Tsquery<any> | string, M1 extends types.Int4<any> | number>(arg0: M0, arg1: M1): types.Float4<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   tsRankCd(arg0: unknown, arg1?: unknown): any { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Float4], [[{ type: types.Tsquery, allowPrimitive: true }, { type: types.Int4, allowPrimitive: true }], types.Float4]]); return runtime.PgFunc("ts_rank_cd", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsvectorConcat<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Tsvector]]); return runtime.PgFunc("tsvector_concat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   tsvectorsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("tsvectorsend", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   unnest(): runtime.PgSrf<{ lexeme: types.Text<1> }, "unnest"> { return new runtime.PgSrf("unnest", [this], [["lexeme", types.Text]]) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['@@@']<M0 extends types.Tsquery<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsquery, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`@@@`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['||']<M0 extends types.Tsvector<any> | string>(arg0: M0): types.Tsvector<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Tsvector, allowPrimitive: true }], types.Tsvector]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/txid_snapshot.ts b/src/types/generated/txid_snapshot.ts
index 9512f87..02953d6 100644
--- a/src/types/generated/txid_snapshot.ts
+++ b/src/types/generated/txid_snapshot.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,12 +17,12 @@ export class TxidSnapshot<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`txid_snapshot`;
   static __typnameText = "txid_snapshot";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   txidSnapshotSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("txid_snapshot_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   txidSnapshotXmax(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("txid_snapshot_xmax", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   txidSnapshotXmin(): types.Int8<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return runtime.PgFunc("txid_snapshot_xmin", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   txidSnapshotXip(): runtime.PgSrf<{ txid_snapshot_xip: types.Int8<N> }, "txid_snapshot_xip"> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int8]]); return new runtime.PgSrf("txid_snapshot_xip", [this, ...__rest], [["txid_snapshot_xip", __rt]]) as any; }
 }
diff --git a/src/types/generated/unknown.ts b/src/types/generated/unknown.ts
index 4be1364..506fd08 100644
--- a/src/types/generated/unknown.ts
+++ b/src/types/generated/unknown.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Unknown<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`unknown`;
   static __typnameText = "unknown";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   unknownsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("unknownsend", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/uuid.ts b/src/types/generated/uuid.ts
index 96afe90..f7a1807 100644
--- a/src/types/generated/uuid.ts
+++ b/src/types/generated/uuid.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,34 +17,34 @@ export class Uuid<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`uuid`;
   static __typnameText = "uuid";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   uuidExtractTimestamp(): types.Timestamptz<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Timestamptz]]); return runtime.PgFunc("uuid_extract_timestamp", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   uuidExtractVersion(): types.Int2<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Int2]]); return runtime.PgFunc("uuid_extract_version", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   uuidSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("uuid_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Uuid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Uuid, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/varbit.ts b/src/types/generated/varbit.ts
index 35cb5bd..c1bd7ca 100644
--- a/src/types/generated/varbit.ts
+++ b/src/types/generated/varbit.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,36 +17,36 @@ export class Varbit<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`varbit`;
   static __typnameText = "varbit";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   bitcat<M0 extends types.Varbit<any> | string>(arg0: M0): types.Varbit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Varbit]]); return runtime.PgFunc("bitcat", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varbit<M0 extends types.Int4<any> | number, M1 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1): types.Varbit<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Varbit]]); return runtime.PgFunc("varbit", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   varbitSend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("varbit_send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Varbit<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['||']<M0 extends types.Varbit<any> | string>(arg0: M0): types.Varbit<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Varbit, allowPrimitive: true }], types.Varbit]]); return runtime.PgOp(runtime.sql`||`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/varchar.ts b/src/types/generated/varchar.ts
index 08c4cd7..5e78452 100644
--- a/src/types/generated/varchar.ts
+++ b/src/types/generated/varchar.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,6 +17,6 @@ export class Varchar<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`varchar`;
   static __typnameText = "varchar";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   varchar<M0 extends types.Int4<any> | number, M1 extends types.Bool<any> | boolean>(arg0: M0, arg1: M1): types.Varchar<runtime.StrictNull<N | runtime.NullOf<M0> | runtime.NullOf<M1>>> { const [__rt, ...__rest] = runtime.match([arg0, arg1], [[[{ type: types.Int4, allowPrimitive: true }, { type: types.Bool, allowPrimitive: true }], types.Varchar]]); return runtime.PgFunc("varchar", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/generated/xid.ts b/src/types/generated/xid.ts
index e962f2c..e88e6f3 100644
--- a/src/types/generated/xid.ts
+++ b/src/types/generated/xid.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,22 +17,22 @@ export class Xid<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`xid`;
   static __typnameText = "xid";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   xidsend(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("xidsend", [this, ...__rest], __rt) as any; }
   ['<>']<M0 extends types.Xid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['<>']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>'](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ne<M0 extends types.Xid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ne<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ne(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   ['=']<M0 extends types.Xid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   ['=']<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   ['='](arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
   eq<M0 extends types.Xid<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
   eq<M0 extends types.Int4<any> | number>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>>;
-  @tool.unchecked()
+  @expose.unchecked()
   eq(arg0: unknown): any { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid, allowPrimitive: true }], types.Bool], [[{ type: types.Int4, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/xid8.ts b/src/types/generated/xid8.ts
index 712a908..4e64136 100644
--- a/src/types/generated/xid8.ts
+++ b/src/types/generated/xid8.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,42 +17,42 @@ export class Xid8<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`xid8`;
   static __typnameText = "xid8";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   pgVisibleInSnapshot<M0 extends types.PgSnapshot<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.PgSnapshot, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("pg_visible_in_snapshot", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xid(): types.Xid<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid]]); return runtime.PgFunc("xid", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xid8Larger<M0 extends types.Xid8<any> | string>(arg0: M0): types.Xid8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Xid8]]); return runtime.PgFunc("xid8_larger", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xid8Smaller<M0 extends types.Xid8<any> | string>(arg0: M0): types.Xid8<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Xid8]]); return runtime.PgFunc("xid8_smaller", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xid8Send(): types.Bytea<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Bytea]]); return runtime.PgFunc("xid8send", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   max(): types.Xid8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid8]]); return runtime.PgFunc("max", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   min(): types.Xid8<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xid8]]); return runtime.PgFunc("min", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lt<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<=']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   lte<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['<>']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ne<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`<>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['=']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   eq<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gt<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   ['>=']<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   gte<M0 extends types.Xid8<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xid8, allowPrimitive: true }], types.Bool]]); return runtime.PgOp(runtime.sql`>=`, [this, ...__rest] as [unknown, unknown], __rt) as any; }
 }
diff --git a/src/types/generated/xml.ts b/src/types/generated/xml.ts
index 2976848..98142e2 100644
--- a/src/types/generated/xml.ts
+++ b/src/types/generated/xml.ts
@@ -1,6 +1,6 @@
 // Auto-generated — do not edit
 import * as runtime from "../runtime";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { Anynonarray } from "../generated/anynonarray";
 import * as types from "../index";
 
@@ -17,12 +17,12 @@ export class Xml<in out N extends number> extends Anynonarray<N> {
   static __typname = runtime.sql`xml`;
   static __typnameText = "xml";
   declare deserialize: (raw: string) => string;
-  @tool.unchecked()
+  @expose.unchecked()
   text(): types.Text<N> { const [__rt, ...__rest] = runtime.match([], [[[], types.Text]]); return runtime.PgFunc("text", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlconcat2<M0 extends types.Xml<any> | string>(arg0: M0): types.Xml<1> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Xml, allowPrimitive: true }], types.Xml]]); return runtime.PgFunc("xmlconcat2", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlvalidate<M0 extends types.Text<any> | string>(arg0: M0): types.Bool<runtime.StrictNull<N | runtime.NullOf<M0>>> { const [__rt, ...__rest] = runtime.match([arg0], [[[{ type: types.Text, allowPrimitive: true }], types.Bool]]); return runtime.PgFunc("xmlvalidate", [this, ...__rest], __rt) as any; }
-  @tool.unchecked()
+  @expose.unchecked()
   xmlagg(): types.Xml<0 | 1> { const [__rt, ...__rest] = runtime.match([], [[[], types.Xml]]); return runtime.PgFunc("xmlagg", [this, ...__rest], __rt) as any; }
 }
diff --git a/src/types/overrides/any.ts b/src/types/overrides/any.ts
index a5c2ac8..4fcc4af 100644
--- a/src/types/overrides/any.ts
+++ b/src/types/overrides/any.ts
@@ -3,7 +3,7 @@ import { getTypeDef } from "../deserialize";
 import { meta } from "../runtime";
 import type { NullOf, StrictNull, TsTypeOf } from "../runtime";
 import { Column, Param, sql, Sql, TypedParam, Unbound } from "../../builder/sql";
-import { tool } from "../../exoeval/tool";
+import { expose } from "../../exoeval/tool";
 import { isPlainData } from "../../util";
 import * as types from "../index";
 
@@ -70,7 +70,7 @@ export class Any<in out N extends number> extends Generated<N> {
   // and either `this` or any list element is NULL.
   //
   // eslint-disable-next-line no-restricted-syntax -- generic vararg signature with `this`-bound type narrowing isn't expressible in zod
-  @tool.unchecked()
+  @expose.unchecked()
   in<
     T extends Any<any>,
     Vs extends [
diff --git a/tsdown.config.ts b/tsdown.config.ts
index 72878e0..d1a816e 100644
--- a/tsdown.config.ts
+++ b/tsdown.config.ts
@@ -1,7 +1,7 @@
 import { defineConfig } from "tsdown";
 import swc from "unplugin-swc";
 
-// SWC handles TC39 stage-3 decorators (`@tool()`, `@tool.unchecked()`).
+// SWC handles TC39 stage-3 decorators (`@expose()`, `@expose.unchecked()`).
 // tsdown's underlying rolldown/oxc transform leaves them as-is, which
 // trips Node at runtime with a SyntaxError. SWC lowers them to ES2022.
 const swcPlugin = () =>
diff --git a/vitest.config.ts b/vitest.config.ts
index e8de325..45655a5 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -13,7 +13,7 @@ export default defineConfig({
       typegres: `${src}/index.ts`,
     },
   },
-  // SWC handles TC39 stage-3 decorators (`@tool()`, `@tool.unchecked()` on
+  // SWC handles TC39 stage-3 decorators (`@expose()`, `@expose.unchecked()` on
   // codegen'd methods). Vite 8's default Oxc transform leaves them as-is,
   // which trips the Node runtime with a SyntaxError. SWC lowers them.
   // `oxc: false` disables the default; SWC owns the TS pipeline.