@oxy-hq/sdk 2.13.0 → 2.16.0

package/dist/testing.mjs

@@ -0,0 +1,4395 @@
+// @oxy/sdk - TypeScript SDK for Oxy data platform
+import * as nodeCryptoImport from "node:crypto";
+
+//#region src/testing/host-contract.ts
+/**
+* The host's words, gates, op names and rules, as `@oxy-hq/sdk/testing`
+* enforces them on an app's unit tests.
+*
+* ONE SOURCE OF TRUTH, AND IT IS NOT THIS FILE. Every string below is quoted
+* from the host's source — `host.rs`, `host/destinations.rs`,
+* `host/airhouse_ops.rs`, `upsert_support.rs`, `tx.rs`, `runtime.rs` under
+* `crates/app/src/server/api/custom_apps_functions/`, and the connector's
+* `transaction.rs` / `postgres_tx/convert.rs` — never paraphrased.
+* `{placeholder}`s stand for what the host formats in (`{database}`,
+* `{dialect}`, …) and use the host's own names.
+*
+* HELD TO THE HOST BY A RUST TEST. `sdk_testing_drift.rs`, beside `host.rs`,
+* `include_str!`s this file and fails when a `refusal:` here is no longer a
+* sentence its `source:` file contains, when `HOST_OPS` differs from the
+* host's closed list, when `GATES` stops naming exactly the fields of
+* `FunctionCapabilities`, when `ABSENT_GLOBALS` differs from `oxyc`'s lint
+* list, or when `FETCH_RULES` differs from `is_safe_outbound`. One direction
+* only: this file is checked against the host, the host is never checked
+* against this file (`internal-docs/sdk-testing-context.md` §7, answer 9).
+*
+* THE RUST TEST READS TEXT, NOT TYPESCRIPT: after stripping comments it takes
+* the block from `export const HOST_OPS` to `] as const;`, every object whose
+* key line ends `: {` and carries `source:` and `refusal:` lines, the
+* `hostField:` / `ops:` lines of `GATES`, the `name:` / `member:` lines of
+* `ABSENT_GLOBALS`, and every quoted string in `FETCH_RULES`. Keep those keys
+* spelled as they are, each `refusal:` a single string literal, and none of
+* them behind a comment that is not a full-line one.
+*
+* NO `contractVersion` (§7, answer 10): a reworded refusal reaches an app on
+* its next SDK bump, which is the right moment to see it; a version field
+* with no consumer is a mechanism nobody reads.
+*/
+/**
+* Every name the host pages an op under — `HOST_OPS` in `host_call_attrs.rs`,
+* "pinned by unit tests to `host_op_name` and `runtime::host_call_span`". The
+* `HostOp` type is this list, so `"warehouse.inserts"` does not compile.
+*/
+const HOST_OPS = [
+	"query",
+	"query_stream",
+	"fetch",
+	"semantic.query",
+	"airway.run",
+	"warehouse.insert",
+	"warehouse.exec",
+	"warehouse.upsert",
+	"warehouse.query",
+	"tx.begin",
+	"tx.begin_oltp",
+	"tx.query",
+	"tx.exec",
+	"tx.commit",
+	"tx.rollback",
+	"oltp.query",
+	"oltp.exec",
+	"airhouse.query",
+	"airhouse.exec",
+	"airhouse.append",
+	"storage.getUploadUrl",
+	"storage.getDownloadUrl",
+	"storage.put",
+	"storage.get",
+	"storage.head",
+	"storage.list",
+	"storage.delete",
+	"storage.copy",
+	"secrets.set",
+	"email.send",
+	"org.people",
+	"org.places",
+	"org.assignments"
+];
+/**
+* The surface `reply_json` prefixes a refusal with (`runtime.rs`): a thrown
+* `HostError`'s message is `"<surface>: <host message>"`. Every `tx.*` verb —
+* `begin_oltp` included — answers under `ctx.tx`, because one op carries all
+* six.
+*/
+const SURFACES = {
+	query: "ctx.query",
+	queryStream: "ctx.queryStream",
+	fetch: "ctx.fetch",
+	warehouse: "ctx.warehouse",
+	tx: "ctx.tx",
+	oltp: "ctx.oltp",
+	airhouse: "ctx.airhouse",
+	secretsSet: "ctx.secrets.set",
+	emailSend: "ctx.email.send",
+	storage: "ctx.storage",
+	orgPeople: "ctx.org.people",
+	orgPlaces: "ctx.org.places",
+	orgAssignments: "ctx.org.assignments",
+	semanticQuery: "ctx.semantic.query",
+	airwayRun: "ctx.airway.run"
+};
+/**
+* Every refusal the context throws, quoted from the host. The context renders
+* a template by substituting its `{placeholder}`s and prefixing the surface.
+*/
+const REFUSALS = {
+	secretsWrite: {
+		source: "host.rs",
+		refusal: "ctx.secrets.set: this function has not declared the `secrets.write` capability (add it to oxy-app.json to permit writes)"
+	},
+	emailSend: {
+		source: "host.rs",
+		refusal: "EmailCapabilityMissing: this function has not declared the `email.send` capability (add \"email\": { \"send\": true } to its oxy-app.json entry)"
+	},
+	orgPeople: {
+		source: "host.rs",
+		refusal: "OrgCapabilityMissing: this function has not declared the `org.read` capability (add \"org\": { \"read\": true } to its oxy-app.json entry)"
+	},
+	orgMember: {
+		source: "host.rs",
+		refusal: "OrgCapabilityMissing: this function has not declared the `org.read` capability (add \"org\": { \"read\": true } to its oxy-app.json entry) — ctx.org.{member}"
+	},
+	storageWrite: {
+		source: "host.rs",
+		refusal: "StorageCapabilityMissing: this function has not declared the `storage.write` capability (add \"storage\": { \"write\": true } to its oxy-app.json entry)"
+	},
+	storageRead: {
+		source: "host.rs",
+		refusal: "StorageCapabilityMissing: this function has not declared the `storage.read` capability (add \"storage\": { \"read\": true } to its oxy-app.json entry)"
+	},
+	oltp: {
+		source: "host.rs",
+		refusal: "OltpCapabilityMissing: this function has not declared the `oltp` capability (add \"oltp\": { \"enabled\": true } to its oxy-app.json entry). The schema it writes is derived from the app's own slug — the manifest only enables access."
+	},
+	airhouse: {
+		source: "host/airhouse_ops.rs",
+		refusal: "AirhouseCapabilityMissing: this function has not declared the `airhouse` capability (add \"airhouse\": { \"enabled\": true } to its oxy-app.json entry). The schema it writes is derived from the app's own slug — the manifest only enables access."
+	},
+	destinationNotDeclared: {
+		source: "host.rs",
+		refusal: "database '{database}' is not in this function's `destinations` allowlist (declare it in oxy-app.json to permit writes)"
+	},
+	databaseNotConfigured: {
+		source: "host.rs",
+		refusal: "database '{database}' is not configured for this project"
+	},
+	managedOltpWrite: {
+		source: "host/destinations.rs",
+		refusal: "database '{database}' is the org's OLTP store, which this surface reaches as the read-only analyst — write this app's own records with ctx.oltp"
+	},
+	customerWarehouseWrite: {
+		source: "host/destinations.rs",
+		refusal: "database '{database}' is a customer warehouse, and customer warehouses are read-only to apps. Facts this app records belong in Airhouse (ctx.airhouse); records it edits belong in ctx.oltp. If this write has to stay, say why on the function in oxy-app.json: \"customerWarehouseWrites\": { \"{database}\": \"<reason>\" }"
+	},
+	customerWarehouseTransaction: {
+		source: "host/destinations.rs",
+		refusal: ". A ctx.tx transaction counts as a write even when it only reads — read with ctx.warehouse.query instead"
+	},
+	upsertUnsupported: {
+		source: "upsert_support.rs",
+		refusal: "warehouse.upsert is not supported on {dialect}: it compiles to `INSERT … ON CONFLICT … DO UPDATE`, which only Postgres and DuckDB parse. Use warehouse.insert, or warehouse.exec with this warehouse's own upsert statement."
+	},
+	transactionOpen: {
+		source: "host.rs",
+		refusal: "could not open a transaction on '{database}': {e}"
+	},
+	transactionUnsupported: {
+		source: "transaction.rs",
+		refusal: "{backend} does not support multi-statement transactions — ctx.tx() requires a Postgres-backed database (`type: postgres`). Use ctx.warehouse.{insert,exec,upsert} for single-statement writes."
+	},
+	transactionsOpen: {
+		source: "tx.rs",
+		refusal: "this invocation already has {MAX_OPEN} transactions open. Commit or roll one back before opening another."
+	},
+	transactionFinished: {
+		source: "runtime.rs",
+		refusal: "{label}: this transaction is already finished — {what} was called after the callback returned"
+	},
+	transactionFnNotFunction: {
+		source: "runtime.rs",
+		refusal: "{signature}: fn must be a function"
+	},
+	btoaBytes: {
+		source: "runtime.rs",
+		refusal: "btoa: expected a string. For bytes use bytesToBase64() from @oxy-hq/sdk"
+	},
+	atobPadding: {
+		source: "runtime.rs",
+		refusal: "atob: '=' may only appear as trailing padding"
+	},
+	atobLength: {
+		source: "runtime.rs",
+		refusal: "atob: invalid base64 length"
+	},
+	fetchInvalidUrl: {
+		source: "host.rs",
+		refusal: "invalid url: {e}"
+	},
+	fetchBlocked: {
+		source: "host.rs",
+		refusal: "fetch to '{url}' blocked by SSRF allowlist"
+	},
+	fetchInvalidHeaderName: {
+		source: "host.rs",
+		refusal: "InvalidFetchHeader: `{k}` is not a header name"
+	},
+	fetchInvalidHeaderValue: {
+		source: "host.rs",
+		refusal: "InvalidFetchHeader: the value of `{k}` is not a header value"
+	},
+	fetchTooLarge: {
+		source: "host.rs",
+		refusal: "response too large ({len} bytes > {max_bytes} cap)"
+	},
+	slugCannotBackASchema: {
+		source: "host.rs",
+		refusal: "the capability is enabled, but this app's slug '{slug}' cannot back an {store} schema: to do so a slug must start with a letter, be at most {max} characters, and use only lowercase letters, digits and hyphens (a `_` is refused — it would collide with the hyphenated form). A leading digit is a legal app slug but not a legal schema name. Rename the app to one that qualifies."
+	},
+	oltpParamsNotArray: {
+		source: "host.rs",
+		refusal: "`params` must be an array of values. Pass positional arguments for $1, $2, … — e.g. [name, partySize]."
+	},
+	noDefaultDatabase: {
+		source: "host.rs",
+		refusal: "this project has no databases configured"
+	},
+	oltpUnsupportedColumn: {
+		source: "postgres_tx/convert.rs",
+		refusal: "result column `{name}` has Postgres type `{ty}`, which cannot be returned directly. Cast it to text in the SELECT list and parse it in your function — cast the whole expression, not the output name (`avg(qty)::text`, `amount::text`). Note `avg`/`sum` over any numeric type, and a bare decimal literal, are all `numeric`. (Supported as-is: bool, int2/4/8, float4/8, text/varchar/char/name, json/jsonb, uuid, timestamptz/timestamp, date, time.)"
+	}
+};
+/**
+* Every gate in `FunctionCapabilities`, in the struct's order. `storage_read`
+* and `storage_write` list `check_storage_capability`'s arms (`copy` needs
+* both); `customer_warehouse_writes` is decided per database by
+* `destination_write_policy`, after the `destinations` allowlist.
+* `storage_retention` and `fetch_max_bytes` are fields of the struct and
+* deliberately absent: they shape an allowed call, they never refuse one.
+*/
+const GATES = [
+	{
+		hostField: "secrets_write",
+		manifest: "secrets.write",
+		ops: ["secrets.set"]
+	},
+	{
+		hostField: "email_send",
+		manifest: "email.send",
+		ops: ["email.send"]
+	},
+	{
+		hostField: "org_read",
+		manifest: "org.read",
+		ops: [
+			"org.people",
+			"org.places",
+			"org.assignments"
+		]
+	},
+	{
+		hostField: "storage_read",
+		manifest: "storage.read",
+		ops: [
+			"storage.getDownloadUrl",
+			"storage.get",
+			"storage.head",
+			"storage.list",
+			"storage.copy"
+		]
+	},
+	{
+		hostField: "storage_write",
+		manifest: "storage.write",
+		ops: [
+			"storage.getUploadUrl",
+			"storage.put",
+			"storage.delete",
+			"storage.copy"
+		]
+	},
+	{
+		hostField: "oltp",
+		manifest: "oltp.enabled",
+		ops: [
+			"oltp.query",
+			"oltp.exec",
+			"tx.begin_oltp"
+		]
+	},
+	{
+		hostField: "airhouse",
+		manifest: "airhouse.enabled",
+		ops: [
+			"airhouse.query",
+			"airhouse.exec",
+			"airhouse.append"
+		]
+	},
+	{
+		hostField: "customer_warehouse_writes",
+		manifest: "customerWarehouseWrites",
+		ops: [
+			"warehouse.insert",
+			"warehouse.exec",
+			"warehouse.upsert",
+			"tx.begin"
+		]
+	}
+];
+/**
+* The globals the isolate does not define, as `oxyc`'s `isolate-global` lint
+* names them (`ABSENT_GLOBALS` in `sdk/cli/src/publish/function-lint.ts`).
+* `member` narrows an entry to `<name>.<member>`; an empty `member` is the
+* whole of `process.*`. The isolate's bootstrap defines `Response`, `btoa`,
+* `atob`, `console` and `__buildCtx` and nothing else (`runtime.rs`), so it has
+* no `crypto` global at all; the lint singles out `subtle` because that is what
+* an author reaches for, and `run()` removes the whole global as production
+* does.
+*/
+const ABSENT_GLOBALS = [
+	{ name: "Buffer" },
+	{ name: "TextEncoder" },
+	{ name: "TextDecoder" },
+	{ name: "Blob" },
+	{ name: "File" },
+	{ name: "FormData" },
+	{
+		name: "crypto",
+		member: "subtle"
+	},
+	{
+		name: "process",
+		member: ""
+	}
+];
+/**
+* `is_safe_outbound` in `host.rs`, the first-layer check every `ctx.fetch`
+* URL meets before anything is sent: the scheme, the host names refused by
+* name, and the suffixes an internal name ends with. The IP rules (loopback,
+* unspecified, private, link-local, broadcast, documentation, v4-mapped and
+* embedded v6) are code, in `fetch-rules.ts`. What no unit test can reproduce
+* is the second layer — a public name that RESOLVES to a private address is
+* caught at connect time by `PublicOnlyDnsResolver` — so the context does not
+* pretend to.
+*/
+const FETCH_RULES = {
+	scheme: "https",
+	literalHosts: [
+		"localhost",
+		"ip6-localhost",
+		"ip6-loopback"
+	],
+	internalSuffixes: [
+		".internal",
+		".local",
+		".localdomain",
+		".svc",
+		".cluster.local"
+	]
+};
+/** `FETCH_MAX_BYTES` in `host.rs`: the default `ctx.fetch` response ceiling. */
+const FETCH_MAX_BYTES = 10485760;
+/** `MAX_OPEN` in `tx.rs`: transactions one invocation may hold open at once. */
+const MAX_OPEN_TRANSACTIONS = 4;
+/**
+* How each dialect names itself in a refusal — `SqlDialect::as_str` in the
+* connector crate, which `upsert_support::check` and `transaction::unsupported`
+* format in. Only Postgres, DuckDB and SQLite parse `ON CONFLICT`
+* (`parses_on_conflict`), and only the Postgres connector opens a transaction.
+*/
+const DIALECTS = {
+	clickhouse: {
+		name: "ClickHouse",
+		parsesOnConflict: false,
+		opensTransactions: false
+	},
+	postgres: {
+		name: "PostgreSQL",
+		parsesOnConflict: true,
+		opensTransactions: true
+	},
+	duckdb: {
+		name: "DuckDB",
+		parsesOnConflict: true,
+		opensTransactions: false
+	}
+};
+
+//#endregion
+//#region src/testing/fetch-rules.ts
+/** The host's verdict on a URL: allowed, or refused before sending. */
+function isSafeOutbound(url) {
+	if (url.protocol !== `${FETCH_RULES.scheme}:`) return false;
+	const host = url.hostname;
+	if (host === "") return false;
+	const ip = parseIp(host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host);
+	if (ip) return isPublicIp(ip);
+	const lower = host.toLowerCase();
+	if (FETCH_RULES.literalHosts.includes(lower)) return false;
+	return !FETCH_RULES.internalSuffixes.some((suffix) => lower.endsWith(suffix));
+}
+/** A literal IPv4 or IPv6 address, or `null` when `s` is a name. */
+function parseIp(s) {
+	const v4 = parseV4(s);
+	if (v4) return { v4 };
+	const v6 = parseV6(s);
+	return v6 ? { v6 } : null;
+}
+function parseV4(s) {
+	const m = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(s);
+	if (!m) return null;
+	const parts = m.slice(1).map(Number);
+	if (parts.some((p) => p > 255)) return null;
+	return parts;
+}
+/** Eight 16-bit segments, or `null`. Accepts `::`, and a dotted v4 tail. */
+function parseV6(s) {
+	if (!s.includes(":")) return null;
+	const zone = s.indexOf("%");
+	const halves = (zone >= 0 ? s.slice(0, zone) : s).split("::");
+	if (halves.length > 2) return null;
+	const head = halves[0] === "" ? [] : halves[0].split(":");
+	const tail = halves.length === 2 && halves[1] !== "" ? halves[1].split(":") : [];
+	const words = (groups) => {
+		const out = [];
+		for (const [i, g] of groups.entries()) if (g.includes(".")) {
+			if (i !== groups.length - 1) return null;
+			const v4 = parseV4(g);
+			if (!v4) return null;
+			out.push(v4[0] << 8 | v4[1], v4[2] << 8 | v4[3]);
+		} else {
+			if (!/^[0-9a-fA-F]{1,4}$/.test(g)) return null;
+			out.push(Number.parseInt(g, 16));
+		}
+		return out;
+	};
+	const h = words(head);
+	const t = words(tail);
+	if (!h || !t) return null;
+	if (halves.length === 1) return h.length === 8 ? h : null;
+	const fill = 8 - h.length - t.length;
+	if (fill < 1) return null;
+	return [
+		...h,
+		...new Array(fill).fill(0),
+		...t
+	];
+}
+/** `is_public_ip` in `host.rs`. */
+function isPublicIp(ip) {
+	const canonical = "v6" in ip ? mappedV4(ip.v6) ?? ip : ip;
+	if ("v4" in canonical) return isPublicV4(canonical.v4);
+	const seg = canonical.v6;
+	if (seg.every((w) => w === 0)) return false;
+	if (seg.slice(0, 7).every((w) => w === 0) && seg[7] === 1) return false;
+	const embedded = embeddedV4(seg);
+	if (embedded) return isPublicV4(embedded);
+	const first = seg[0];
+	const linkLocal = (first & 65472) === 65152;
+	const uniqueLocal = (first & 65024) === 64512;
+	return !linkLocal && !uniqueLocal;
+}
+function isPublicV4([a, b, c, d]) {
+	if (a === 127) return false;
+	if (a === 0 && b === 0 && c === 0 && d === 0) return false;
+	return !(a === 10 || a === 172 && b >= 16 && b <= 31 || a === 192 && b === 168) && !(a === 169 && b === 254) && !(a === 255 && b === 255 && c === 255 && d === 255) && !(a === 192 && b === 0 && c === 2 || a === 198 && b === 51 && c === 100 || a === 203 && b === 0 && c === 113);
+}
+/** `to_canonical()`: an IPv4-mapped address (`::ffff:a.b.c.d`) as its v4. */
+function mappedV4(seg) {
+	if (seg.slice(0, 5).every((w) => w === 0) && seg[5] === 65535) return { v4: [
+		seg[6] >> 8,
+		seg[6] & 255,
+		seg[7] >> 8,
+		seg[7] & 255
+	] };
+	return null;
+}
+/** `embedded_ipv4`: the v4 in a `::/96` or `64:ff9b::/96` address. */
+function embeddedV4(seg) {
+	const compatible = seg.slice(0, 6).every((w) => w === 0);
+	const nat64 = seg[0] === 100 && seg[1] === 65435 && seg.slice(2, 6).every((w) => w === 0);
+	if (!compatible && !nat64) return null;
+	return [
+		seg[6] >> 8,
+		seg[6] & 255,
+		seg[7] >> 8,
+		seg[7] & 255
+	];
+}
+
+//#endregion
+//#region src/testing/host-error.ts
+/** The `name` the runtime gives every refusal it unwraps. */
+const HOST_ERROR_NAME = "HostError";
+/**
+* Render a refusal template: every `{placeholder}` replaced by `vars[name]`.
+* A placeholder the caller did not supply is a bug in the context, not in the
+* app under test, so it throws rather than leaking `{database}` into a message
+* a test might then match on.
+*/
+function render(template, vars = {}) {
+	return template.refusal.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (whole, name) => {
+		const value = vars[name];
+		if (value === void 0) throw new Error(`test context bug: refusal template leaves {${name}} unfilled: ${whole}`);
+		return String(value);
+	});
+}
+/**
+* The error a function sees when the host refuses: `name` `"HostError"`,
+* message `"<surface>: <message>"`.
+*/
+function hostError(surface, message) {
+	const err = /* @__PURE__ */ new Error(`${surface}: ${message}`);
+	err.name = HOST_ERROR_NAME;
+	return err;
+}
+/** `hostError` over a rendered template. */
+function refuse(surface, template, vars = {}) {
+	return hostError(surface, render(template, vars));
+}
+/** Whether `err` is a refusal the context (or the runtime) threw. */
+function isHostError(err) {
+	return err instanceof Error && err.name === "HostError";
+}
+/**
+* An error in the context's OWN words — never the host's. Thrown where the
+* context cannot model what the host would do (an unrecognised statement, an
+* unregistered `fetch` answer) and says so, rather than answering something
+* production would not. Its `name` is `"TestContextError"` so a test can never
+* mistake it for a refusal.
+*/
+function contextError(message) {
+	const err = /* @__PURE__ */ new Error(`@oxy-hq/sdk/testing: ${message}`);
+	err.name = "TestContextError";
+	return err;
+}
+
+//#endregion
+//#region src/testing/gates.ts
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** `spec.<a>.<b> === true` — `flag` in `capabilities.ts`. */
+function flag(spec, a, b) {
+	const block = spec[a];
+	return isObject(block) && block[b] === true;
+}
+/**
+* `MAX_NAME_LEN` in `crates/oltp/src/schema.rs`: 63 (Postgres) less `app_` and
+* the longest role suffix `_rw`.
+*/
+const MAX_SCHEMA_NAME_LEN = 56;
+/**
+* `app_writer_name` + `WriterRef::schema_name`: the schema an app's slug
+* derives, or `null` when it derives none.
+*
+* Both halves matter. `app_writer_name` refuses a slug containing `_` outright
+* — `my_app` would otherwise alias the hyphenated sibling `my-app` onto one
+* schema and role — and then runs the derived name through `validate_name`,
+* which is what rejects a leading digit, an over-long name, and any character
+* outside `[a-z0-9_]`. Skipping that second half handed back a schema for slugs
+* the host answers `None` for, which is the difference between a green test and
+* a closed `ctx.oltp` in production.
+*/
+function writerSchema(slug) {
+	if (slug.includes("_")) return null;
+	const name = slug.replace(/-/g, "_");
+	if (name === "" || name.length > 56) return null;
+	if (!/^[a-z]/.test(name)) return null;
+	if (!/^[a-z0-9_]+$/.test(name)) return null;
+	return `app_${name}`;
+}
+/** Read the gates for `functionName` from `manifest`, or throw naming what is missing. */
+function readGates(manifest, functionName) {
+	const spec = manifest.functions?.[functionName];
+	if (!isObject(spec)) {
+		const known = Object.keys(manifest.functions ?? {});
+		throw contextError(`oxy-app.json declares no function "${functionName}" (functions: ${known.length ? known.join(", ") : "none"})`);
+	}
+	const slug = typeof manifest.slug === "string" ? manifest.slug : "";
+	const destinations = Array.isArray(spec.destinations) ? spec.destinations.filter((d) => typeof d === "string") : [];
+	const customerWarehouseWrites = {};
+	if (isObject(spec.customerWarehouseWrites)) {
+		for (const [db, reason] of Object.entries(spec.customerWarehouseWrites)) if (typeof reason === "string" && reason.trim() !== "") customerWarehouseWrites[db] = reason;
+	}
+	const fetch = isObject(spec.fetch) ? spec.fetch : {};
+	return {
+		functionName,
+		slug,
+		writerSchema: writerSchema(slug),
+		secretsWrite: flag(spec, "secrets", "write"),
+		emailSend: flag(spec, "email", "send"),
+		orgRead: flag(spec, "org", "read"),
+		storageRead: flag(spec, "storage", "read"),
+		storageWrite: flag(spec, "storage", "write"),
+		oltp: flag(spec, "oltp", "enabled"),
+		airhouse: flag(spec, "airhouse", "enabled"),
+		destinations,
+		customerWarehouseWrites,
+		fetchMaxBytes: typeof fetch.maxResponseBytes === "number" ? fetch.maxResponseBytes : null
+	};
+}
+
+//#endregion
+//#region src/testing/run.ts
+const B64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const B64R = (/* @__PURE__ */ new Uint8Array(256)).fill(255);
+for (let i = 0; i < 64; i++) B64R[B64.charCodeAt(i)] = i;
+/** `globalThis.btoa` as the isolate defines it: strings only, Latin1 only. */
+function isolateBtoa(input) {
+	if (input instanceof ArrayBuffer || ArrayBuffer.isView(input)) throw new TypeError(render(REFUSALS.btoaBytes));
+	const s = String(input);
+	let out = "";
+	for (let i = 0; i < s.length; i += 3) {
+		const c0 = s.charCodeAt(i);
+		const c1 = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+		const c2 = i + 2 < s.length ? s.charCodeAt(i + 2) : 0;
+		if (c0 > 255 || c1 > 255 || c2 > 255) throw new TypeError("btoa: input contains characters outside the Latin1 range; for text pass it directly with { encoding: \"utf8\" }");
+		const n = c0 << 16 | c1 << 8 | c2;
+		out += B64[n >> 18 & 63] + B64[n >> 12 & 63] + (i + 1 < s.length ? B64[n >> 6 & 63] : "=") + (i + 2 < s.length ? B64[n & 63] : "=");
+	}
+	return out;
+}
+/** `globalThis.atob` as the isolate defines it: WHATWG forgiving-base64. */
+function isolateAtob(input) {
+	let s = String(input).replace(/[ \t\n\f\r]/g, "");
+	if (s.length % 4 === 0) {
+		let pad = 0;
+		while (pad < 2 && s.charCodeAt(s.length - 1) === 61) {
+			s = s.slice(0, -1);
+			pad++;
+		}
+	}
+	if (s.indexOf("=") >= 0) throw new TypeError(render(REFUSALS.atobPadding));
+	if (s.length % 4 === 1) throw new TypeError(render(REFUSALS.atobLength));
+	let out = "";
+	let buf = 0;
+	let bits = 0;
+	for (let i = 0; i < s.length; i++) {
+		const code = s.charCodeAt(i);
+		const v = code < 256 ? B64R[code] : 255;
+		if (v === 255) throw new TypeError(`atob: invalid base64 character '${s[i]}'`);
+		buf = buf << 6 | v;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out += String.fromCharCode(buf >> bits & 255);
+		}
+	}
+	return out;
+}
+let running = false;
+/**
+* Evaluate `fn` with every `ABSENT_GLOBALS` entry removed from `globalThis` and
+* `btoa` / `atob` replaced by the isolate's, restoring all of them afterwards
+* — whether `fn` resolves or throws.
+*/
+async function runWithoutIsolateGlobals(fn) {
+	if (running) throw contextError("t.run(fn) calls must not overlap — one at a time per test");
+	running = true;
+	const saved = [];
+	const g = globalThis;
+	const shadow = (name, value) => {
+		saved.push([name, Object.getOwnPropertyDescriptor(globalThis, name)]);
+		if (value === void 0) delete g[name];
+		else Object.defineProperty(globalThis, name, {
+			value,
+			configurable: true,
+			writable: true
+		});
+	};
+	try {
+		for (const entry of ABSENT_GLOBALS) shadow(entry.name, void 0);
+		shadow("btoa", isolateBtoa);
+		shadow("atob", isolateAtob);
+		return await fn();
+	} finally {
+		for (const [name, descriptor] of saved.reverse()) if (descriptor) Object.defineProperty(globalThis, name, descriptor);
+		else delete g[name];
+		running = false;
+	}
+}
+
+//#endregion
+//#region src/testing/sql.ts
+const STOP_WORDS = /^(DEFAULT|NOT|NULL|PRIMARY|UNIQUE|REFERENCES|CHECK|GENERATED|CODEC|COMMENT|TTL)$/i;
+const CONSTRAINT_HEAD = /^(PRIMARY|UNIQUE|CONSTRAINT|FOREIGN|CHECK|KEY|INDEX)\b/i;
+/** `sql` without its leading line and block comments and whitespace. */
+function stripLeadingComments(sql) {
+	let s = sql;
+	for (;;) {
+		const before = s;
+		s = s.replace(/^\s+/, "").replace(/^--[^\n]*\n?/, "").replace(/^\/\*[\s\S]*?\*\//, "");
+		if (s === before) return s;
+	}
+}
+/** Parse one statement, or throw in the context's own words. */
+function parse(sql) {
+	const text = stripLeadingComments(sql).replace(/;\s*$/, "");
+	switch (/^(\w+)/.exec(text)?.[1]?.toUpperCase() ?? "") {
+		case "CREATE": return parseCreate(text);
+		case "INSERT": return parseInsert(text);
+		case "SELECT":
+		case "WITH": return parseSelect(text);
+		case "DELETE": return parseDelete(text);
+		case "UPDATE": return parseUpdate(text);
+		default: throw unsupported(text);
+	}
+}
+function unsupported(sql) {
+	const head = sql.trim().slice(0, 60).replace(/\s+/g, " ");
+	return contextError(`the test context cannot evaluate this statement: "${head}…". It reads CREATE TABLE, INSERT … VALUES, SELECT <columns|count(*)|literals> FROM <table> [WHERE col = value AND …] [ORDER BY col] [LIMIT n], DELETE FROM and UPDATE … SET. Answer the call with t.override(op, …), or seed the rows it should find with t.state.<store>.raw(table, rows).`);
+}
+/** Strip the quotes an identifier was written with. */
+function ident(raw) {
+	const s = raw.trim();
+	if (s.startsWith("\"") && s.endsWith("\"") || s.startsWith("`") && s.endsWith("`")) return s.slice(1, -1);
+	return s;
+}
+/** Split `text` on top-level commas, respecting parentheses, brackets and quotes. */
+function splitTopLevel(text, separator = ",") {
+	const out = [];
+	let depth = 0;
+	let quote = null;
+	let start = 0;
+	for (let i = 0; i < text.length; i++) {
+		const c = text[i];
+		if (quote) {
+			if (c === quote) {
+				if (text[i + 1] === quote) i++;
+				else quote = null;
+			}
+			continue;
+		}
+		if (c === "'" || c === "\"" || c === "`") quote = c;
+		else if (c === "(" || c === "[") depth++;
+		else if (c === ")" || c === "]") depth--;
+		else if (depth === 0 && text.startsWith(separator, i)) {
+			out.push(text.slice(start, i).trim());
+			i += separator.length - 1;
+			start = i + 1;
+		}
+	}
+	out.push(text.slice(start).trim());
+	return out.filter((s) => s !== "");
+}
+/** The index just past the `)` matching the `(` at `open`. */
+function closeParen(text, open) {
+	let depth = 0;
+	let quote = null;
+	for (let i = open; i < text.length; i++) {
+		const c = text[i];
+		if (quote) {
+			if (c === quote) {
+				if (text[i + 1] === quote) i++;
+				else quote = null;
+			}
+			continue;
+		}
+		if (c === "'" || c === "\"") quote = c;
+		else if (c === "(") depth++;
+		else if (c === ")" && --depth === 0) return i + 1;
+	}
+	throw unsupported(text);
+}
+function parseCreate(text) {
+	const m = /^CREATE\s+TABLE\s+(IF\s+NOT\s+EXISTS\s+)?([\w."`]+)\s*\(/i.exec(text);
+	if (!m) throw unsupported(text);
+	const open = m[0].length - 1;
+	const end = closeParen(text, open);
+	const columns = [];
+	for (const def of splitTopLevel(text.slice(open + 1, end - 1))) {
+		if (CONSTRAINT_HEAD.test(def)) continue;
+		const words = splitTopLevel(def, " ");
+		const name = ident(words[0] ?? "");
+		const typeWords = splitTopLevel(def.slice(def.indexOf(words[0] ?? "") + (words[0]?.length ?? 0)).trim(), " ");
+		const stop = typeWords.findIndex((w) => STOP_WORDS.test(w));
+		const type = (stop < 0 ? typeWords : typeWords.slice(0, stop)).join(" ");
+		if (name) columns.push({
+			name,
+			type
+		});
+	}
+	return {
+		kind: "create",
+		table: ident(m[2]),
+		ifNotExists: Boolean(m[1]),
+		columns
+	};
+}
+function parseInsert(text) {
+	const m = /^INSERT\s+INTO\s+([\w."`]+)\s*(\(([^)]*)\))?\s*VALUES\s*/i.exec(text);
+	if (!m) throw unsupported(text);
+	const columns = m[3] ? splitTopLevel(m[3]).map(ident) : null;
+	const tuples = [];
+	let at = m[0].length;
+	while (at < text.length) {
+		if (text[at] !== "(") throw unsupported(text);
+		const end = closeParen(text, at);
+		tuples.push(splitTopLevel(text.slice(at + 1, end - 1)));
+		at = end;
+		const gap = /^\s*,?\s*/.exec(text.slice(at))?.[0] ?? "";
+		at += gap.length;
+	}
+	return {
+		kind: "insert",
+		table: ident(m[1]),
+		columns,
+		tuples
+	};
+}
+/** `a = 1 AND b = 'x' AND c IN (1, 2)` → predicates; anything else throws. */
+function parseWhere(text, whole) {
+	if (!text) return [];
+	return splitTopLevel(text, " AND ").map((clause) => {
+		const eq = /^([\w."`]+)\s*=\s*(.+)$/s.exec(clause);
+		if (eq) return {
+			column: ident(eq[1]),
+			values: [eq[2].trim()]
+		};
+		const inList = /^([\w."`]+)\s+IN\s*\((.*)\)$/is.exec(clause);
+		if (inList) return {
+			column: ident(inList[1]),
+			values: splitTopLevel(inList[2])
+		};
+		throw contextError(`the test context cannot evaluate this WHERE clause: "${clause}". It reads "col = value" and "col IN (…)" joined by AND. Answer the call with t.override(op, …) instead: ${whole.slice(0, 80)}`);
+	});
+}
+/**
+* Whether `literal()` will read this expression as a value rather than hand it
+* back as its own SQL text. The two must agree: a projection the parser accepts
+* as a literal but `literal()` cannot read comes back to the caller as the SQL
+* they wrote — a column named `sum(amount)` holding the string `"sum(amount)"`,
+* which is the one thing this module promises never to do.
+*/
+function isReadableLiteral(expr) {
+	const s = expr.trim();
+	return /^\$\d+$/.test(s) || /^(NULL|TRUE|FALSE)$/i.test(s) || s.startsWith("'") && s.endsWith("'") && s.length >= 2 || /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(s);
+}
+/**
+* The statement with every quoted string blanked, so a keyword scan reads the
+* SQL and not the data: `WHERE label = 'GROUP BY'` is a row, not a grouping.
+*/
+function withoutStringLiterals(text) {
+	return text.replace(/'(?:[^']|'')*'/g, "''");
+}
+function parseSelect(text) {
+	if (/\bGROUP\s+BY\b/is.test(withoutStringLiterals(text))) throw contextError(`the test context cannot evaluate GROUP BY: "${text.trim().slice(0, 60).replace(/\s+/g, " ")}…". It would have to aggregate, and a wrong aggregate reads like a right one. Answer the call with t.override(op, …) and assert on the arguments instead.`);
+	const m = /^SELECT\s+(.*?)(?:\s+FROM\s+([\w."`]+))?(?:\s+WHERE\s+(.*?))?(?:\s+ORDER\s+BY\s+([\w."`]+)(?:\s+(ASC|DESC))?)?(?:\s+LIMIT\s+(\d+))?\s*$/is.exec(text);
+	if (!m || !m[2] && /\bFROM\b/i.test(m[1])) throw unsupported(text);
+	const items = splitTopLevel(m[1]).map((item) => {
+		if (item === "*") return { kind: "all" };
+		const aliased = /^(.*?)\s+AS\s+([\w"`]+)$/is.exec(item);
+		const expr = (aliased ? aliased[1] : item).trim();
+		const alias = aliased ? ident(aliased[2]) : null;
+		if (/^count\s*\(\s*\*\s*\)$/i.test(expr)) return {
+			kind: "count",
+			alias: alias ?? "count(*)"
+		};
+		if (/^[\w."`]+$/.test(expr) && !/^\d/.test(expr) && !/^(true|false|null)$/i.test(expr)) return {
+			kind: "column",
+			column: ident(expr),
+			alias: alias ?? ident(expr)
+		};
+		if (!isReadableLiteral(expr)) throw unsupported(text);
+		return {
+			kind: "literal",
+			raw: expr,
+			alias: alias ?? expr
+		};
+	});
+	return {
+		kind: "select",
+		table: m[2] ? ident(m[2]) : null,
+		items,
+		where: parseWhere(m[3], text),
+		orderBy: m[4] ? {
+			column: ident(m[4]),
+			desc: (m[5] ?? "").toUpperCase() === "DESC"
+		} : null,
+		limit: m[6] ? Number(m[6]) : null
+	};
+}
+function parseDelete(text) {
+	const m = /^DELETE\s+FROM\s+([\w."`]+)(?:\s+WHERE\s+(.*))?\s*$/is.exec(text);
+	if (!m) throw unsupported(text);
+	return {
+		kind: "delete",
+		table: ident(m[1]),
+		where: parseWhere(m[2], text)
+	};
+}
+function parseUpdate(text) {
+	const m = /^UPDATE\s+([\w."`]+)\s+SET\s+(.*?)(?:\s+WHERE\s+(.*))?\s*$/is.exec(text);
+	if (!m) throw unsupported(text);
+	const set = splitTopLevel(m[2]).map((assignment) => {
+		const eq = /^([\w."`]+)\s*=\s*(.+)$/s.exec(assignment);
+		if (!eq) throw unsupported(text);
+		const raw = eq[2].trim();
+		if (!isReadableLiteral(raw)) throw unsupported(text);
+		return {
+			column: ident(eq[1]),
+			raw
+		};
+	});
+	return {
+		kind: "update",
+		table: ident(m[1]),
+		set,
+		where: parseWhere(m[3], text)
+	};
+}
+/**
+* A raw SQL value as a JS value, with no engine's rendering applied: a quoted
+* string, a number, NULL, TRUE/FALSE, or a `$n` bound parameter. Anything else
+* (a function call, a cast, an array literal) stays as its SQL text.
+*/
+function literal(raw, params = []) {
+	const s = raw.trim();
+	const param = /^\$(\d+)$/.exec(s);
+	if (param) return params[Number(param[1]) - 1];
+	if (/^NULL$/i.test(s)) return null;
+	if (/^TRUE$/i.test(s)) return true;
+	if (/^FALSE$/i.test(s)) return false;
+	if (s.startsWith("'") && s.endsWith("'")) return s.slice(1, -1).replace(/''/g, "'");
+	if (/^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(s)) return Number(s);
+	return s;
+}
+
+//#endregion
+//#region src/testing/shape-zoo.json
+var shape_zoo_default = {
+	version: 1,
+	engines: {
+		"clickhouse": { "cases": [
+			{
+				"key": "clickhouse/Bool/plain",
+				"native_type": "Bool",
+				"class": "plain",
+				"value_sql": "true",
+				"expect": { "warehouse": true }
+			},
+			{
+				"key": "clickhouse/Nullable(Bool)/null",
+				"native_type": "Nullable(Bool)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Boolean/plain",
+				"native_type": "Boolean",
+				"class": "plain",
+				"value_sql": "false",
+				"expect": { "warehouse": false }
+			},
+			{
+				"key": "clickhouse/Int8/plain",
+				"native_type": "Int8",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/Int8/negative",
+				"native_type": "Int8",
+				"class": "negative",
+				"value_sql": "-128",
+				"expect": { "warehouse": -128 }
+			},
+			{
+				"key": "clickhouse/Int8/zero",
+				"native_type": "Int8",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(Int8)/null",
+				"native_type": "Nullable(Int8)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Int16/plain",
+				"native_type": "Int16",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/Int16/negative",
+				"native_type": "Int16",
+				"class": "negative",
+				"value_sql": "-32768",
+				"expect": { "warehouse": -32768 }
+			},
+			{
+				"key": "clickhouse/Int16/zero",
+				"native_type": "Int16",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(Int16)/null",
+				"native_type": "Nullable(Int16)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Int32/plain",
+				"native_type": "Int32",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/Int32/negative",
+				"native_type": "Int32",
+				"class": "negative",
+				"value_sql": "-2147483648",
+				"expect": { "warehouse": -2147483648 }
+			},
+			{
+				"key": "clickhouse/Int32/zero",
+				"native_type": "Int32",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(Int32)/null",
+				"native_type": "Nullable(Int32)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Int64/plain",
+				"native_type": "Int64",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/Int64/negative",
+				"native_type": "Int64",
+				"class": "negative",
+				"value_sql": "-9007199254740991",
+				"expect": { "warehouse": -9007199254740991 }
+			},
+			{
+				"key": "clickhouse/Int64/zero",
+				"native_type": "Int64",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Int64/precision_gt_18",
+				"native_type": "Int64",
+				"class": "precision_gt_18",
+				"value_sql": "9223372036854775807",
+				"expect": { "warehouse": 0x8000000000000000 }
+			},
+			{
+				"key": "clickhouse/Nullable(Int64)/null",
+				"native_type": "Nullable(Int64)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt8/plain",
+				"native_type": "UInt8",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/UInt8/zero",
+				"native_type": "UInt8",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt8)/null",
+				"native_type": "Nullable(UInt8)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt16/plain",
+				"native_type": "UInt16",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/UInt16/zero",
+				"native_type": "UInt16",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt16)/null",
+				"native_type": "Nullable(UInt16)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt32/plain",
+				"native_type": "UInt32",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/UInt32/zero",
+				"native_type": "UInt32",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt32)/null",
+				"native_type": "Nullable(UInt32)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt64/plain",
+				"native_type": "UInt64",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "clickhouse/UInt64/zero",
+				"native_type": "UInt64",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/UInt64/precision_gt_18",
+				"native_type": "UInt64",
+				"class": "precision_gt_18",
+				"value_sql": "18446744073709551615",
+				"expect": { "warehouse": "18446744073709551615" }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt64)/null",
+				"native_type": "Nullable(UInt64)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Int128/plain",
+				"native_type": "Int128",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "clickhouse/Int128/negative",
+				"native_type": "Int128",
+				"class": "negative",
+				"value_sql": "-42",
+				"expect": { "warehouse": "-42" }
+			},
+			{
+				"key": "clickhouse/Int128/zero",
+				"native_type": "Int128",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "clickhouse/Int128/precision_gt_18",
+				"native_type": "Int128",
+				"class": "precision_gt_18",
+				"value_sql": "toInt128('-170141183460469231731687303715884105728')",
+				"expect": { "warehouse": "-170141183460469231731687303715884105728" }
+			},
+			{
+				"key": "clickhouse/Nullable(Int128)/null",
+				"native_type": "Nullable(Int128)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt128/plain",
+				"native_type": "UInt128",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "clickhouse/UInt128/zero",
+				"native_type": "UInt128",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "clickhouse/UInt128/precision_gt_18",
+				"native_type": "UInt128",
+				"class": "precision_gt_18",
+				"value_sql": "toUInt128('340282366920938463463374607431768211455')",
+				"expect": { "warehouse": "340282366920938463463374607431768211455" }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt128)/null",
+				"native_type": "Nullable(UInt128)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Int256/plain",
+				"native_type": "Int256",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "clickhouse/Int256/negative",
+				"native_type": "Int256",
+				"class": "negative",
+				"value_sql": "-42",
+				"expect": { "warehouse": "-42" }
+			},
+			{
+				"key": "clickhouse/Int256/zero",
+				"native_type": "Int256",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "clickhouse/Int256/precision_gt_18",
+				"native_type": "Int256",
+				"class": "precision_gt_18",
+				"value_sql": "toInt256('-57896044618658097711785492504343953926634992332820282019728792003956564819968')",
+				"expect": { "warehouse": "-57896044618658097711785492504343953926634992332820282019728792003956564819968" }
+			},
+			{
+				"key": "clickhouse/Nullable(Int256)/null",
+				"native_type": "Nullable(Int256)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UInt256/plain",
+				"native_type": "UInt256",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "clickhouse/UInt256/zero",
+				"native_type": "UInt256",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "clickhouse/UInt256/precision_gt_18",
+				"native_type": "UInt256",
+				"class": "precision_gt_18",
+				"value_sql": "toUInt256('115792089237316195423570985008687907853269984665640564039457584007913129639935')",
+				"expect": { "warehouse": "115792089237316195423570985008687907853269984665640564039457584007913129639935" }
+			},
+			{
+				"key": "clickhouse/Nullable(UInt256)/null",
+				"native_type": "Nullable(UInt256)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Float32/plain",
+				"native_type": "Float32",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .1 }
+			},
+			{
+				"key": "clickhouse/Float32/negative",
+				"native_type": "Float32",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": { "warehouse": -1.5 }
+			},
+			{
+				"key": "clickhouse/Float32/zero",
+				"native_type": "Float32",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Float32/nan_inf",
+				"native_type": "Float32",
+				"class": "nan_inf",
+				"value_sql": "nan",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Nullable(Float32)/null",
+				"native_type": "Nullable(Float32)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Float64/plain",
+				"native_type": "Float64",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .1 }
+			},
+			{
+				"key": "clickhouse/Float64/negative",
+				"native_type": "Float64",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": { "warehouse": -1.5 }
+			},
+			{
+				"key": "clickhouse/Float64/zero",
+				"native_type": "Float64",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "clickhouse/Float64/nan_inf",
+				"native_type": "Float64",
+				"class": "nan_inf",
+				"value_sql": "inf",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Nullable(Float64)/null",
+				"native_type": "Nullable(Float64)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Decimal(18, 4)/plain",
+				"native_type": "Decimal(18, 4)",
+				"class": "plain",
+				"value_sql": "1234.5678",
+				"expect": { "warehouse": "1234.5678" }
+			},
+			{
+				"key": "clickhouse/Decimal(18, 4)/negative",
+				"native_type": "Decimal(18, 4)",
+				"class": "negative",
+				"value_sql": "-1.25",
+				"expect": { "warehouse": "-1.25" }
+			},
+			{
+				"key": "clickhouse/Decimal(18, 4)/zero",
+				"native_type": "Decimal(18, 4)",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "clickhouse/Nullable(Decimal(18, 4))/null",
+				"native_type": "Nullable(Decimal(18, 4))",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Decimal(38, 10)/precision_gt_18",
+				"native_type": "Decimal(38, 10)",
+				"class": "precision_gt_18",
+				"value_sql": "toDecimal128('1234567890123456789.0123456789', 10)",
+				"expect": { "warehouse": "1.2345678901234568e+18" }
+			},
+			{
+				"key": "clickhouse/Decimal(38, 0)/precision_gt_18",
+				"native_type": "Decimal(38, 0)",
+				"class": "precision_gt_18",
+				"value_sql": "toDecimal128('12345678901234567890123456789012345678', 0)",
+				"expect": { "warehouse": "12345678901234567890123456789012345678" }
+			},
+			{
+				"key": "clickhouse/Decimal32(4)/plain",
+				"native_type": "Decimal32(4)",
+				"class": "plain",
+				"value_sql": "1.5",
+				"expect": { "warehouse": "1.5" }
+			},
+			{
+				"key": "clickhouse/Date/plain",
+				"native_type": "Date",
+				"class": "plain",
+				"value_sql": "'2024-03-10'",
+				"expect": { "warehouse": "2024-03-10" }
+			},
+			{
+				"key": "clickhouse/Date/date_before_1970",
+				"native_type": "Date",
+				"class": "date_before_1970",
+				"value_sql": "'1969-12-31'",
+				"expect": { "warehouse": "1970-01-01" }
+			},
+			{
+				"key": "clickhouse/Date/date_after_2100",
+				"native_type": "Date",
+				"class": "date_after_2100",
+				"value_sql": "'2149-06-06'",
+				"expect": { "warehouse": "2149-06-06" }
+			},
+			{
+				"key": "clickhouse/Nullable(Date)/null",
+				"native_type": "Nullable(Date)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Date32/plain",
+				"native_type": "Date32",
+				"class": "plain",
+				"value_sql": "'2024-03-10'",
+				"expect": { "warehouse": "2024-03-10" }
+			},
+			{
+				"key": "clickhouse/Date32/date_before_1970",
+				"native_type": "Date32",
+				"class": "date_before_1970",
+				"value_sql": "'1900-01-01'",
+				"expect": { "warehouse": "1900-01-01" }
+			},
+			{
+				"key": "clickhouse/Date32/date_after_2100",
+				"native_type": "Date32",
+				"class": "date_after_2100",
+				"value_sql": "'2299-12-31'",
+				"expect": { "warehouse": "2299-12-31" }
+			},
+			{
+				"key": "clickhouse/Nullable(Date32)/null",
+				"native_type": "Nullable(Date32)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/DateTime/plain",
+				"native_type": "DateTime",
+				"class": "plain",
+				"value_sql": "'2024-03-10 12:34:56'",
+				"expect": { "warehouse": "2024-03-10 12:34:56" }
+			},
+			{
+				"key": "clickhouse/DateTime/date_before_1970",
+				"native_type": "DateTime",
+				"class": "date_before_1970",
+				"value_sql": "'1969-12-31 23:59:59'",
+				"expect": { "warehouse": "1970-01-01 00:00:00" }
+			},
+			{
+				"key": "clickhouse/DateTime/date_after_2100",
+				"native_type": "DateTime",
+				"class": "date_after_2100",
+				"value_sql": "'2105-12-31 23:59:59'",
+				"expect": { "warehouse": "2105-12-31 23:59:59" }
+			},
+			{
+				"key": "clickhouse/Nullable(DateTime)/null",
+				"native_type": "Nullable(DateTime)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/DateTime('Asia/Kolkata')/tz_bearing",
+				"native_type": "DateTime('Asia/Kolkata')",
+				"class": "tz_bearing",
+				"value_sql": "'2024-03-10 12:34:56'",
+				"expect": { "warehouse": "2024-03-10 12:34:56" }
+			},
+			{
+				"key": "clickhouse/DateTime64(3)/plain",
+				"native_type": "DateTime64(3)",
+				"class": "plain",
+				"value_sql": "'2024-03-10 12:34:56.789'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "clickhouse/DateTime64(3)/date_before_1970",
+				"native_type": "DateTime64(3)",
+				"class": "date_before_1970",
+				"value_sql": "'1969-07-20 20:17:40.500'",
+				"expect": { "warehouse": "1969-07-20 20:17:40.500000" }
+			},
+			{
+				"key": "clickhouse/DateTime64(3)/date_after_2100",
+				"native_type": "DateTime64(3)",
+				"class": "date_after_2100",
+				"value_sql": "'2150-01-01 00:00:00.000'",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "clickhouse/Nullable(DateTime64(3))/null",
+				"native_type": "Nullable(DateTime64(3))",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/DateTime64(6, 'America/New_York')/tz_bearing",
+				"native_type": "DateTime64(6, 'America/New_York')",
+				"class": "tz_bearing",
+				"value_sql": "'2024-03-10 12:34:56.123456'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.123456" }
+			},
+			{
+				"key": "clickhouse/String/plain",
+				"native_type": "String",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "clickhouse/String/empty",
+				"native_type": "String",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": { "warehouse": "" }
+			},
+			{
+				"key": "clickhouse/String/whitespace",
+				"native_type": "String",
+				"class": "whitespace",
+				"value_sql": "' \\t\\n '",
+				"expect": { "warehouse": " 	\n " }
+			},
+			{
+				"key": "clickhouse/String/non_bmp",
+				"native_type": "String",
+				"class": "non_bmp",
+				"value_sql": "'𝔘nicode'",
+				"expect": { "warehouse": "𝔘nicode" }
+			},
+			{
+				"key": "clickhouse/String/len_gt_1k",
+				"native_type": "String",
+				"class": "len_gt_1k",
+				"value_sql": "repeat('0123456789', 101)",
+				"expect": { "warehouse": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" }
+			},
+			{
+				"key": "clickhouse/Nullable(String)/null",
+				"native_type": "Nullable(String)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/FixedString(4)/plain",
+				"native_type": "FixedString(4)",
+				"class": "plain",
+				"value_sql": "'ab'",
+				"expect": { "warehouse": "ab\0\0" }
+			},
+			{
+				"key": "clickhouse/FixedString(4)/empty",
+				"native_type": "FixedString(4)",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": { "warehouse": "\0\0\0\0" }
+			},
+			{
+				"key": "clickhouse/Nullable(FixedString(4))/null",
+				"native_type": "Nullable(FixedString(4))",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/LowCardinality(String)/plain",
+				"native_type": "LowCardinality(String)",
+				"class": "plain",
+				"value_sql": "'low cardinality'",
+				"expect": { "warehouse": "low cardinality" }
+			},
+			{
+				"key": "clickhouse/LowCardinality(Nullable(String))/null",
+				"native_type": "LowCardinality(Nullable(String))",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/Enum8('a' = 1, 'b' = 2)/plain",
+				"native_type": "Enum8('a' = 1, 'b' = 2)",
+				"class": "plain",
+				"value_sql": "'b'",
+				"expect": { "warehouse": "b" }
+			},
+			{
+				"key": "clickhouse/Nullable(Enum8('a' = 1, 'b' = 2))/null",
+				"native_type": "Nullable(Enum8('a' = 1, 'b' = 2))",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/UUID/plain",
+				"native_type": "UUID",
+				"class": "plain",
+				"value_sql": "'00000000-0000-4000-8000-000000000001'",
+				"expect": { "warehouse": "00000000-0000-4000-8000-000000000001" }
+			},
+			{
+				"key": "clickhouse/Nullable(UUID)/null",
+				"native_type": "Nullable(UUID)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/IPv4/plain",
+				"native_type": "IPv4",
+				"class": "plain",
+				"value_sql": "'10.0.0.1'",
+				"expect": { "warehouse": "10.0.0.1" }
+			},
+			{
+				"key": "clickhouse/Nullable(IPv4)/null",
+				"native_type": "Nullable(IPv4)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/IPv6/plain",
+				"native_type": "IPv6",
+				"class": "plain",
+				"value_sql": "'2001:db8::1'",
+				"expect": { "warehouse": "2001:db8::1" }
+			},
+			{
+				"key": "clickhouse/Nullable(IPv6)/null",
+				"native_type": "Nullable(IPv6)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "clickhouse/JSON/nested_json",
+				"native_type": "JSON",
+				"class": "nested_json",
+				"value_sql": "'{\"a\":{\"b\":\"x\",\"n\":1.5}}'",
+				"expect": { "warehouse": { "a": {
+					"b": "x",
+					"n": 1.5
+				} } }
+			},
+			{
+				"key": "clickhouse/JSON/empty",
+				"native_type": "JSON",
+				"class": "empty",
+				"value_sql": "'{}'",
+				"expect": { "warehouse": {} }
+			},
+			{
+				"key": "clickhouse/Array(Int32)/array",
+				"native_type": "Array(Int32)",
+				"class": "array",
+				"value_sql": "[1, -2, 3]",
+				"expect": { "warehouse": [
+					1,
+					-2,
+					3
+				] }
+			},
+			{
+				"key": "clickhouse/Array(Int32)/empty",
+				"native_type": "Array(Int32)",
+				"class": "empty",
+				"value_sql": "[]",
+				"expect": { "warehouse": [] }
+			},
+			{
+				"key": "clickhouse/Array(Nullable(String))/array",
+				"native_type": "Array(Nullable(String))",
+				"class": "array",
+				"value_sql": "['a', NULL]",
+				"expect": { "warehouse": ["a", null] }
+			},
+			{
+				"key": "clickhouse/Tuple(Int32, String)/array",
+				"native_type": "Tuple(Int32, String)",
+				"class": "array",
+				"value_sql": "(1, 'a')",
+				"expect": { "warehouse": [1, "a"] }
+			},
+			{
+				"key": "clickhouse/Map(String, Int32)/nested_json",
+				"native_type": "Map(String, Int32)",
+				"class": "nested_json",
+				"value_sql": "map('a', 1, 'b', 2)",
+				"expect": { "warehouse": {
+					"a": 1,
+					"b": 2
+				} }
+			},
+			{
+				"key": "clickhouse/Map(String, Int32)/empty",
+				"native_type": "Map(String, Int32)",
+				"class": "empty",
+				"value_sql": "map()",
+				"expect": { "warehouse": {} }
+			},
+			{
+				"key": "clickhouse/SimpleAggregateFunction(sum, UInt64)/plain",
+				"native_type": "SimpleAggregateFunction(sum, UInt64)",
+				"class": "plain",
+				"value_sql": "3",
+				"expect": { "warehouse": 3 }
+			},
+			{
+				"key": "clickhouse/AggregateFunction(sum, UInt64)/plain",
+				"native_type": "AggregateFunction(sum, UInt64)",
+				"class": "plain",
+				"value_sql": "arrayReduce('sumState', [toUInt64(3)])",
+				"expect": { "warehouse": "\0\0\0\0\0\0\0" }
+			}
+		] },
+		"postgres": { "cases": [
+			{
+				"key": "postgres/bool/plain",
+				"native_type": "bool",
+				"class": "plain",
+				"value_sql": "true",
+				"expect": {
+					"warehouse": true,
+					"oltp": true
+				}
+			},
+			{
+				"key": "postgres/bool/null",
+				"native_type": "bool",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/int2/plain",
+				"native_type": "int2",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": {
+					"warehouse": 42,
+					"oltp": 42
+				}
+			},
+			{
+				"key": "postgres/int2/negative",
+				"native_type": "int2",
+				"class": "negative",
+				"value_sql": "-32768",
+				"expect": {
+					"warehouse": -32768,
+					"oltp": -32768
+				}
+			},
+			{
+				"key": "postgres/int2/zero",
+				"native_type": "int2",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": 0,
+					"oltp": 0
+				}
+			},
+			{
+				"key": "postgres/int2/null",
+				"native_type": "int2",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/int4/plain",
+				"native_type": "int4",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": {
+					"warehouse": 42,
+					"oltp": 42
+				}
+			},
+			{
+				"key": "postgres/int4/negative",
+				"native_type": "int4",
+				"class": "negative",
+				"value_sql": "-2147483648",
+				"expect": {
+					"warehouse": -2147483648,
+					"oltp": -2147483648
+				}
+			},
+			{
+				"key": "postgres/int4/zero",
+				"native_type": "int4",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": 0,
+					"oltp": 0
+				}
+			},
+			{
+				"key": "postgres/int4/null",
+				"native_type": "int4",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/int8/plain",
+				"native_type": "int8",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": {
+					"warehouse": 42,
+					"oltp": 42
+				}
+			},
+			{
+				"key": "postgres/int8/negative",
+				"native_type": "int8",
+				"class": "negative",
+				"value_sql": "-9007199254740991",
+				"expect": {
+					"warehouse": -9007199254740991,
+					"oltp": -9007199254740991
+				}
+			},
+			{
+				"key": "postgres/int8/zero",
+				"native_type": "int8",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": 0,
+					"oltp": 0
+				}
+			},
+			{
+				"key": "postgres/int8/precision_gt_18",
+				"native_type": "int8",
+				"class": "precision_gt_18",
+				"value_sql": "9223372036854775807",
+				"expect": {
+					"warehouse": 0x8000000000000000,
+					"oltp": 0x8000000000000000
+				}
+			},
+			{
+				"key": "postgres/int8/null",
+				"native_type": "int8",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/float4/plain",
+				"native_type": "float4",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": {
+					"warehouse": .10000000149011612,
+					"oltp": .10000000149011612
+				}
+			},
+			{
+				"key": "postgres/float4/negative",
+				"native_type": "float4",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": {
+					"warehouse": -1.5,
+					"oltp": -1.5
+				}
+			},
+			{
+				"key": "postgres/float4/zero",
+				"native_type": "float4",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": 0,
+					"oltp": 0
+				}
+			},
+			{
+				"key": "postgres/float4/nan_inf",
+				"native_type": "float4",
+				"class": "nan_inf",
+				"value_sql": "'NaN'",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/float4/null",
+				"native_type": "float4",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/float8/plain",
+				"native_type": "float8",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": {
+					"warehouse": .1,
+					"oltp": .1
+				}
+			},
+			{
+				"key": "postgres/float8/negative",
+				"native_type": "float8",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": {
+					"warehouse": -1.5,
+					"oltp": -1.5
+				}
+			},
+			{
+				"key": "postgres/float8/zero",
+				"native_type": "float8",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": 0,
+					"oltp": 0
+				}
+			},
+			{
+				"key": "postgres/float8/nan_inf",
+				"native_type": "float8",
+				"class": "nan_inf",
+				"value_sql": "'Infinity'",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/float8/null",
+				"native_type": "float8",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/numeric/plain",
+				"native_type": "numeric",
+				"class": "plain",
+				"value_sql": "1234.5678",
+				"expect": {
+					"warehouse": "1234.5678",
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/numeric/negative",
+				"native_type": "numeric",
+				"class": "negative",
+				"value_sql": "-1.25",
+				"expect": {
+					"warehouse": "-1.25",
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/numeric/zero",
+				"native_type": "numeric",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": {
+					"warehouse": "0.0",
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/numeric/nan_inf",
+				"native_type": "numeric",
+				"class": "nan_inf",
+				"value_sql": "'NaN'",
+				"expect": {
+					"warehouse": "NaN",
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/numeric/precision_gt_18",
+				"native_type": "numeric",
+				"class": "precision_gt_18",
+				"value_sql": "1234567890123456789.0123456789",
+				"expect": {
+					"warehouse": "1234567890123456768.0",
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/numeric/null",
+				"native_type": "numeric",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": { "$error": "Postgres type `numeric`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/text/plain",
+				"native_type": "text",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": {
+					"warehouse": "plain text",
+					"oltp": "plain text"
+				}
+			},
+			{
+				"key": "postgres/text/empty",
+				"native_type": "text",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": {
+					"warehouse": "",
+					"oltp": ""
+				}
+			},
+			{
+				"key": "postgres/text/whitespace",
+				"native_type": "text",
+				"class": "whitespace",
+				"value_sql": "E' \\t\\n '",
+				"expect": {
+					"warehouse": " 	\n ",
+					"oltp": " 	\n "
+				}
+			},
+			{
+				"key": "postgres/text/non_bmp",
+				"native_type": "text",
+				"class": "non_bmp",
+				"value_sql": "'𝔘nicode'",
+				"expect": {
+					"warehouse": "𝔘nicode",
+					"oltp": "𝔘nicode"
+				}
+			},
+			{
+				"key": "postgres/text/len_gt_1k",
+				"native_type": "text",
+				"class": "len_gt_1k",
+				"value_sql": "repeat('0123456789', 101)",
+				"expect": {
+					"warehouse": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+					"oltp": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
+				}
+			},
+			{
+				"key": "postgres/text/null",
+				"native_type": "text",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/plain",
+				"native_type": "varchar(2000)",
+				"class": "plain",
+				"value_sql": "'plain varchar'",
+				"expect": {
+					"warehouse": "plain varchar",
+					"oltp": "plain varchar"
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/empty",
+				"native_type": "varchar(2000)",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": {
+					"warehouse": "",
+					"oltp": ""
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/whitespace",
+				"native_type": "varchar(2000)",
+				"class": "whitespace",
+				"value_sql": "E' \\t\\n '",
+				"expect": {
+					"warehouse": " 	\n ",
+					"oltp": " 	\n "
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/non_bmp",
+				"native_type": "varchar(2000)",
+				"class": "non_bmp",
+				"value_sql": "'𝔘nicode'",
+				"expect": {
+					"warehouse": "𝔘nicode",
+					"oltp": "𝔘nicode"
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/len_gt_1k",
+				"native_type": "varchar(2000)",
+				"class": "len_gt_1k",
+				"value_sql": "repeat('0123456789', 101)",
+				"expect": {
+					"warehouse": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789",
+					"oltp": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789"
+				}
+			},
+			{
+				"key": "postgres/varchar(2000)/null",
+				"native_type": "varchar(2000)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/bpchar(8)/plain",
+				"native_type": "bpchar(8)",
+				"class": "plain",
+				"value_sql": "'ab'",
+				"expect": {
+					"warehouse": "ab      ",
+					"oltp": "ab      "
+				}
+			},
+			{
+				"key": "postgres/bpchar(8)/empty",
+				"native_type": "bpchar(8)",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": {
+					"warehouse": "        ",
+					"oltp": "        "
+				}
+			},
+			{
+				"key": "postgres/bpchar(8)/whitespace",
+				"native_type": "bpchar(8)",
+				"class": "whitespace",
+				"value_sql": "E' \\t\\n '",
+				"expect": {
+					"warehouse": " 	\n     ",
+					"oltp": " 	\n     "
+				}
+			},
+			{
+				"key": "postgres/bpchar(8)/non_bmp",
+				"native_type": "bpchar(8)",
+				"class": "non_bmp",
+				"value_sql": "'𝔘'",
+				"expect": {
+					"warehouse": "𝔘       ",
+					"oltp": "𝔘       "
+				}
+			},
+			{
+				"key": "postgres/bpchar(8)/null",
+				"native_type": "bpchar(8)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/\"char\"/plain",
+				"native_type": "\"char\"",
+				"class": "plain",
+				"value_sql": "'a'",
+				"expect": {
+					"warehouse": "a",
+					"oltp": { "$error": "Postgres type `char`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/\"char\"/null",
+				"native_type": "\"char\"",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": { "$error": "Postgres type `char`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/name/plain",
+				"native_type": "name",
+				"class": "plain",
+				"value_sql": "'plain_name'",
+				"expect": {
+					"warehouse": "plain_name",
+					"oltp": "plain_name"
+				}
+			},
+			{
+				"key": "postgres/name/empty",
+				"native_type": "name",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": {
+					"warehouse": "",
+					"oltp": ""
+				}
+			},
+			{
+				"key": "postgres/name/len_gt_1k",
+				"native_type": "name",
+				"class": "len_gt_1k",
+				"value_sql": "repeat('0123456789', 101)",
+				"expect": {
+					"warehouse": "012345678901234567890123456789012345678901234567890123456789012",
+					"oltp": "012345678901234567890123456789012345678901234567890123456789012"
+				}
+			},
+			{
+				"key": "postgres/name/null",
+				"native_type": "name",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/bytea/plain",
+				"native_type": "bytea",
+				"class": "plain",
+				"value_sql": "decode('0001ff', 'hex')",
+				"expect": {
+					"warehouse": "<3 bytes>",
+					"oltp": { "$error": "Postgres type `bytea`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/bytea/empty",
+				"native_type": "bytea",
+				"class": "empty",
+				"value_sql": "decode('', 'hex')",
+				"expect": {
+					"warehouse": "<0 bytes>",
+					"oltp": { "$error": "Postgres type `bytea`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/bytea/null",
+				"native_type": "bytea",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": { "$error": "Postgres type `bytea`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/date/plain",
+				"native_type": "date",
+				"class": "plain",
+				"value_sql": "DATE '2024-03-10'",
+				"expect": {
+					"warehouse": "2024-03-10",
+					"oltp": "2024-03-10"
+				}
+			},
+			{
+				"key": "postgres/date/date_before_1970",
+				"native_type": "date",
+				"class": "date_before_1970",
+				"value_sql": "DATE '1969-12-31'",
+				"expect": {
+					"warehouse": "1969-12-31",
+					"oltp": "1969-12-31"
+				}
+			},
+			{
+				"key": "postgres/date/date_after_2100",
+				"native_type": "date",
+				"class": "date_after_2100",
+				"value_sql": "DATE '2150-06-01'",
+				"expect": {
+					"warehouse": "2150-06-01",
+					"oltp": "2150-06-01"
+				}
+			},
+			{
+				"key": "postgres/date/null",
+				"native_type": "date",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/timestamp/plain",
+				"native_type": "timestamp",
+				"class": "plain",
+				"value_sql": "TIMESTAMP '2024-03-10 12:34:56.789'",
+				"expect": {
+					"warehouse": "2024-03-10 12:34:56.789000",
+					"oltp": "2024-03-10T12:34:56.789000"
+				}
+			},
+			{
+				"key": "postgres/timestamp/date_before_1970",
+				"native_type": "timestamp",
+				"class": "date_before_1970",
+				"value_sql": "TIMESTAMP '1969-07-20 20:17:40.5'",
+				"expect": {
+					"warehouse": "1969-07-20 20:17:40.500000",
+					"oltp": "1969-07-20T20:17:40.500000"
+				}
+			},
+			{
+				"key": "postgres/timestamp/date_after_2100",
+				"native_type": "timestamp",
+				"class": "date_after_2100",
+				"value_sql": "TIMESTAMP '2150-01-01 00:00:00'",
+				"expect": {
+					"warehouse": "2150-01-01 00:00:00",
+					"oltp": "2150-01-01T00:00:00.000000"
+				}
+			},
+			{
+				"key": "postgres/timestamp/null",
+				"native_type": "timestamp",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/timestamptz/plain",
+				"native_type": "timestamptz",
+				"class": "plain",
+				"value_sql": "TIMESTAMPTZ '2024-03-10 12:34:56.789+00'",
+				"expect": {
+					"warehouse": "2024-03-10 12:34:56.789000",
+					"oltp": "2024-03-10T12:34:56.789000Z"
+				}
+			},
+			{
+				"key": "postgres/timestamptz/tz_bearing",
+				"native_type": "timestamptz",
+				"class": "tz_bearing",
+				"value_sql": "TIMESTAMPTZ '2024-03-10 12:34:56+05:30'",
+				"expect": {
+					"warehouse": "2024-03-10 07:04:56",
+					"oltp": "2024-03-10T07:04:56.000000Z"
+				}
+			},
+			{
+				"key": "postgres/timestamptz/date_before_1970",
+				"native_type": "timestamptz",
+				"class": "date_before_1970",
+				"value_sql": "TIMESTAMPTZ '1969-07-20 20:17:40.5+00'",
+				"expect": {
+					"warehouse": "1969-07-20 20:17:40.500000",
+					"oltp": "1969-07-20T20:17:40.500000Z"
+				}
+			},
+			{
+				"key": "postgres/timestamptz/date_after_2100",
+				"native_type": "timestamptz",
+				"class": "date_after_2100",
+				"value_sql": "TIMESTAMPTZ '2150-01-01 00:00:00+00'",
+				"expect": {
+					"warehouse": "2150-01-01 00:00:00",
+					"oltp": "2150-01-01T00:00:00.000000Z"
+				}
+			},
+			{
+				"key": "postgres/timestamptz/null",
+				"native_type": "timestamptz",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/time/plain",
+				"native_type": "time",
+				"class": "plain",
+				"value_sql": "TIME '12:34:56.789'",
+				"expect": {
+					"warehouse": "12:34:56.789",
+					"oltp": "12:34:56.789000"
+				}
+			},
+			{
+				"key": "postgres/time/null",
+				"native_type": "time",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/json/nested_json",
+				"native_type": "json",
+				"class": "nested_json",
+				"value_sql": "'{\"a\":{\"b\":[1,2]},\"s\":\"x\"}'",
+				"expect": {
+					"warehouse": {
+						"a": { "b": [1, 2] },
+						"s": "x"
+					},
+					"oltp": {
+						"a": { "b": [1, 2] },
+						"s": "x"
+					}
+				}
+			},
+			{
+				"key": "postgres/json/null",
+				"native_type": "json",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/jsonb/nested_json",
+				"native_type": "jsonb",
+				"class": "nested_json",
+				"value_sql": "'{\"a\":{\"b\":[1,2]},\"s\":\"x\"}'",
+				"expect": {
+					"warehouse": {
+						"a": { "b": [1, 2] },
+						"s": "x"
+					},
+					"oltp": {
+						"a": { "b": [1, 2] },
+						"s": "x"
+					}
+				}
+			},
+			{
+				"key": "postgres/jsonb/array",
+				"native_type": "jsonb",
+				"class": "array",
+				"value_sql": "'[1,\"two\",null]'",
+				"expect": {
+					"warehouse": [
+						1,
+						"two",
+						null
+					],
+					"oltp": [
+						1,
+						"two",
+						null
+					]
+				}
+			},
+			{
+				"key": "postgres/jsonb/null",
+				"native_type": "jsonb",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/uuid/plain",
+				"native_type": "uuid",
+				"class": "plain",
+				"value_sql": "'00000000-0000-4000-8000-000000000001'",
+				"expect": {
+					"warehouse": "00000000-0000-4000-8000-000000000001",
+					"oltp": "00000000-0000-4000-8000-000000000001"
+				}
+			},
+			{
+				"key": "postgres/uuid/null",
+				"native_type": "uuid",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": {
+					"warehouse": null,
+					"oltp": null
+				}
+			},
+			{
+				"key": "postgres/int4[]/array",
+				"native_type": "int4[]",
+				"class": "array",
+				"value_sql": "ARRAY[1, -2, 3]",
+				"expect": {
+					"warehouse": "{1,-2,3}",
+					"oltp": { "$error": "Postgres type `_int4`, which cannot be returned directly" }
+				}
+			},
+			{
+				"key": "postgres/int4[]/empty",
+				"native_type": "int4[]",
+				"class": "empty",
+				"value_sql": "'{}'",
+				"expect": {
+					"warehouse": "{}",
+					"oltp": { "$error": "Postgres type `_int4`, which cannot be returned directly" }
+				}
+			}
+		] },
+		"duckdb": { "cases": [
+			{
+				"key": "duckdb/BOOLEAN/plain",
+				"native_type": "BOOLEAN",
+				"class": "plain",
+				"value_sql": "true",
+				"expect": { "warehouse": true }
+			},
+			{
+				"key": "duckdb/BOOLEAN/null",
+				"native_type": "BOOLEAN",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/BOOL/plain",
+				"native_type": "BOOL",
+				"class": "plain",
+				"value_sql": "false",
+				"expect": { "warehouse": false }
+			},
+			{
+				"key": "duckdb/TINYINT/plain",
+				"native_type": "TINYINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/TINYINT/negative",
+				"native_type": "TINYINT",
+				"class": "negative",
+				"value_sql": "-128",
+				"expect": { "warehouse": -128 }
+			},
+			{
+				"key": "duckdb/TINYINT/zero",
+				"native_type": "TINYINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/TINYINT/null",
+				"native_type": "TINYINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/INT1/plain",
+				"native_type": "INT1",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/SMALLINT/plain",
+				"native_type": "SMALLINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/SMALLINT/negative",
+				"native_type": "SMALLINT",
+				"class": "negative",
+				"value_sql": "-32768",
+				"expect": { "warehouse": -32768 }
+			},
+			{
+				"key": "duckdb/SMALLINT/zero",
+				"native_type": "SMALLINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/SMALLINT/null",
+				"native_type": "SMALLINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/INT2/plain",
+				"native_type": "INT2",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/INTEGER/plain",
+				"native_type": "INTEGER",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/INTEGER/negative",
+				"native_type": "INTEGER",
+				"class": "negative",
+				"value_sql": "-2147483648",
+				"expect": { "warehouse": -2147483648 }
+			},
+			{
+				"key": "duckdb/INTEGER/zero",
+				"native_type": "INTEGER",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/INTEGER/null",
+				"native_type": "INTEGER",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/INT/plain",
+				"native_type": "INT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/INT4/plain",
+				"native_type": "INT4",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/BIGINT/plain",
+				"native_type": "BIGINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/BIGINT/negative",
+				"native_type": "BIGINT",
+				"class": "negative",
+				"value_sql": "-9007199254740991",
+				"expect": { "warehouse": -9007199254740991 }
+			},
+			{
+				"key": "duckdb/BIGINT/zero",
+				"native_type": "BIGINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/BIGINT/precision_gt_18",
+				"native_type": "BIGINT",
+				"class": "precision_gt_18",
+				"value_sql": "9223372036854775807",
+				"expect": { "warehouse": 0x8000000000000000 }
+			},
+			{
+				"key": "duckdb/BIGINT/null",
+				"native_type": "BIGINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/INT8/plain",
+				"native_type": "INT8",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/UTINYINT/plain",
+				"native_type": "UTINYINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/UTINYINT/zero",
+				"native_type": "UTINYINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/UTINYINT/null",
+				"native_type": "UTINYINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/USMALLINT/plain",
+				"native_type": "USMALLINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/USMALLINT/zero",
+				"native_type": "USMALLINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/USMALLINT/null",
+				"native_type": "USMALLINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/UINTEGER/plain",
+				"native_type": "UINTEGER",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/UINTEGER/zero",
+				"native_type": "UINTEGER",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/UINTEGER/null",
+				"native_type": "UINTEGER",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/UBIGINT/plain",
+				"native_type": "UBIGINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": 42 }
+			},
+			{
+				"key": "duckdb/UBIGINT/zero",
+				"native_type": "UBIGINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/UBIGINT/precision_gt_18",
+				"native_type": "UBIGINT",
+				"class": "precision_gt_18",
+				"value_sql": "'18446744073709551615'::UBIGINT",
+				"expect": { "warehouse": "18446744073709551615" }
+			},
+			{
+				"key": "duckdb/UBIGINT/null",
+				"native_type": "UBIGINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/HUGEINT/plain",
+				"native_type": "HUGEINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "duckdb/HUGEINT/negative",
+				"native_type": "HUGEINT",
+				"class": "negative",
+				"value_sql": "-42",
+				"expect": { "warehouse": "-42" }
+			},
+			{
+				"key": "duckdb/HUGEINT/zero",
+				"native_type": "HUGEINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "duckdb/HUGEINT/precision_gt_18",
+				"native_type": "HUGEINT",
+				"class": "precision_gt_18",
+				"value_sql": "'12345678901234567890123456789012345678'::HUGEINT",
+				"expect": { "warehouse": "12345678901234567890123456789012345678" }
+			},
+			{
+				"key": "duckdb/HUGEINT/null",
+				"native_type": "HUGEINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/UHUGEINT/plain",
+				"native_type": "UHUGEINT",
+				"class": "plain",
+				"value_sql": "42",
+				"expect": { "warehouse": "42" }
+			},
+			{
+				"key": "duckdb/UHUGEINT/zero",
+				"native_type": "UHUGEINT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0" }
+			},
+			{
+				"key": "duckdb/UHUGEINT/precision_gt_18",
+				"native_type": "UHUGEINT",
+				"class": "precision_gt_18",
+				"value_sql": "'12345678901234567890123456789012345678'::UHUGEINT",
+				"expect": { "warehouse": "12345678901234567890123456789012345678" }
+			},
+			{
+				"key": "duckdb/UHUGEINT/null",
+				"native_type": "UHUGEINT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/FLOAT/plain",
+				"native_type": "FLOAT",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .10000000149011612 }
+			},
+			{
+				"key": "duckdb/FLOAT/negative",
+				"native_type": "FLOAT",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": { "warehouse": -1.5 }
+			},
+			{
+				"key": "duckdb/FLOAT/zero",
+				"native_type": "FLOAT",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/FLOAT/nan_inf",
+				"native_type": "FLOAT",
+				"class": "nan_inf",
+				"value_sql": "'nan'::FLOAT",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/FLOAT/null",
+				"native_type": "FLOAT",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/REAL/plain",
+				"native_type": "REAL",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .10000000149011612 }
+			},
+			{
+				"key": "duckdb/FLOAT4/plain",
+				"native_type": "FLOAT4",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .10000000149011612 }
+			},
+			{
+				"key": "duckdb/DOUBLE/plain",
+				"native_type": "DOUBLE",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .1 }
+			},
+			{
+				"key": "duckdb/DOUBLE/negative",
+				"native_type": "DOUBLE",
+				"class": "negative",
+				"value_sql": "-1.5",
+				"expect": { "warehouse": -1.5 }
+			},
+			{
+				"key": "duckdb/DOUBLE/zero",
+				"native_type": "DOUBLE",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": 0 }
+			},
+			{
+				"key": "duckdb/DOUBLE/nan_inf",
+				"native_type": "DOUBLE",
+				"class": "nan_inf",
+				"value_sql": "'inf'::DOUBLE",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/DOUBLE/null",
+				"native_type": "DOUBLE",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/FLOAT8/plain",
+				"native_type": "FLOAT8",
+				"class": "plain",
+				"value_sql": "0.1",
+				"expect": { "warehouse": .1 }
+			},
+			{
+				"key": "duckdb/DECIMAL(18,4)/plain",
+				"native_type": "DECIMAL(18,4)",
+				"class": "plain",
+				"value_sql": "1234.5678",
+				"expect": { "warehouse": "1234.5678" }
+			},
+			{
+				"key": "duckdb/DECIMAL(18,4)/negative",
+				"native_type": "DECIMAL(18,4)",
+				"class": "negative",
+				"value_sql": "-1.25",
+				"expect": { "warehouse": "-1.2500" }
+			},
+			{
+				"key": "duckdb/DECIMAL(18,4)/zero",
+				"native_type": "DECIMAL(18,4)",
+				"class": "zero",
+				"value_sql": "0",
+				"expect": { "warehouse": "0.0000" }
+			},
+			{
+				"key": "duckdb/DECIMAL(18,4)/null",
+				"native_type": "DECIMAL(18,4)",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/DECIMAL(38,10)/precision_gt_18",
+				"native_type": "DECIMAL(38,10)",
+				"class": "precision_gt_18",
+				"value_sql": "'1234567890123456789.0123456789'::DECIMAL(38,10)",
+				"expect": { "warehouse": "1234567890123456789.0123456789" }
+			},
+			{
+				"key": "duckdb/VARCHAR/plain",
+				"native_type": "VARCHAR",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "duckdb/VARCHAR/empty",
+				"native_type": "VARCHAR",
+				"class": "empty",
+				"value_sql": "''",
+				"expect": { "warehouse": "" }
+			},
+			{
+				"key": "duckdb/VARCHAR/whitespace",
+				"native_type": "VARCHAR",
+				"class": "whitespace",
+				"value_sql": "chr(32) || chr(9) || chr(10) || chr(32)",
+				"expect": { "warehouse": " 	\n " }
+			},
+			{
+				"key": "duckdb/VARCHAR/non_bmp",
+				"native_type": "VARCHAR",
+				"class": "non_bmp",
+				"value_sql": "'𝔘nicode'",
+				"expect": { "warehouse": "𝔘nicode" }
+			},
+			{
+				"key": "duckdb/VARCHAR/len_gt_1k",
+				"native_type": "VARCHAR",
+				"class": "len_gt_1k",
+				"value_sql": "repeat('0123456789', 101)",
+				"expect": { "warehouse": "01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789" }
+			},
+			{
+				"key": "duckdb/VARCHAR/null",
+				"native_type": "VARCHAR",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/CHAR/plain",
+				"native_type": "CHAR",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "duckdb/BPCHAR/plain",
+				"native_type": "BPCHAR",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "duckdb/TEXT/plain",
+				"native_type": "TEXT",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "duckdb/STRING/plain",
+				"native_type": "STRING",
+				"class": "plain",
+				"value_sql": "'plain text'",
+				"expect": { "warehouse": "plain text" }
+			},
+			{
+				"key": "duckdb/UUID/plain",
+				"native_type": "UUID",
+				"class": "plain",
+				"value_sql": "'00000000-0000-4000-8000-000000000001'",
+				"expect": { "warehouse": "00000000-0000-4000-8000-000000000001" }
+			},
+			{
+				"key": "duckdb/UUID/null",
+				"native_type": "UUID",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/BLOB/plain",
+				"native_type": "BLOB",
+				"class": "plain",
+				"value_sql": "'\\x00\\x01\\xFF'::BLOB",
+				"expect": { "warehouse": "<3 bytes>" }
+			},
+			{
+				"key": "duckdb/BLOB/empty",
+				"native_type": "BLOB",
+				"class": "empty",
+				"value_sql": "''::BLOB",
+				"expect": { "warehouse": "<0 bytes>" }
+			},
+			{
+				"key": "duckdb/BLOB/null",
+				"native_type": "BLOB",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/BYTEA/plain",
+				"native_type": "BYTEA",
+				"class": "plain",
+				"value_sql": "'\\x00\\x01\\xFF'::BLOB",
+				"expect": { "warehouse": "<3 bytes>" }
+			},
+			{
+				"key": "duckdb/BINARY/plain",
+				"native_type": "BINARY",
+				"class": "plain",
+				"value_sql": "'\\x00\\x01\\xFF'::BLOB",
+				"expect": { "warehouse": "<3 bytes>" }
+			},
+			{
+				"key": "duckdb/VARBINARY/plain",
+				"native_type": "VARBINARY",
+				"class": "plain",
+				"value_sql": "'\\x00\\x01\\xFF'::BLOB",
+				"expect": { "warehouse": "<3 bytes>" }
+			},
+			{
+				"key": "duckdb/DATE/plain",
+				"native_type": "DATE",
+				"class": "plain",
+				"value_sql": "DATE '2024-03-10'",
+				"expect": { "warehouse": "2024-03-10" }
+			},
+			{
+				"key": "duckdb/DATE/date_before_1970",
+				"native_type": "DATE",
+				"class": "date_before_1970",
+				"value_sql": "DATE '1969-12-31'",
+				"expect": { "warehouse": "1969-12-31" }
+			},
+			{
+				"key": "duckdb/DATE/date_after_2100",
+				"native_type": "DATE",
+				"class": "date_after_2100",
+				"value_sql": "DATE '2150-06-01'",
+				"expect": { "warehouse": "2150-06-01" }
+			},
+			{
+				"key": "duckdb/DATE/null",
+				"native_type": "DATE",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/TIMESTAMP/plain",
+				"native_type": "TIMESTAMP",
+				"class": "plain",
+				"value_sql": "TIMESTAMP '2024-03-10 12:34:56.789'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP/date_before_1970",
+				"native_type": "TIMESTAMP",
+				"class": "date_before_1970",
+				"value_sql": "TIMESTAMP '1969-07-20 20:17:40.5'",
+				"expect": { "warehouse": "1969-07-20 20:17:40.500000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP/date_after_2100",
+				"native_type": "TIMESTAMP",
+				"class": "date_after_2100",
+				"value_sql": "TIMESTAMP '2150-01-01 00:00:00'",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP/null",
+				"native_type": "TIMESTAMP",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/DATETIME/plain",
+				"native_type": "DATETIME",
+				"class": "plain",
+				"value_sql": "TIMESTAMP '2024-03-10 12:34:56.789'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_US/plain",
+				"native_type": "TIMESTAMP_US",
+				"class": "plain",
+				"value_sql": "TIMESTAMP '2024-03-10 12:34:56.789'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_S/plain",
+				"native_type": "TIMESTAMP_S",
+				"class": "plain",
+				"value_sql": "'2024-03-10 12:34:56'::TIMESTAMP_S",
+				"expect": { "warehouse": "2024-03-10 12:34:56" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_S/date_before_1970",
+				"native_type": "TIMESTAMP_S",
+				"class": "date_before_1970",
+				"value_sql": "'1969-07-20 20:17:40'::TIMESTAMP_S",
+				"expect": { "warehouse": "1969-07-20 20:17:40" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_S/date_after_2100",
+				"native_type": "TIMESTAMP_S",
+				"class": "date_after_2100",
+				"value_sql": "'2150-01-01 00:00:00'::TIMESTAMP_S",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_S/null",
+				"native_type": "TIMESTAMP_S",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_MS/plain",
+				"native_type": "TIMESTAMP_MS",
+				"class": "plain",
+				"value_sql": "'2024-03-10 12:34:56.789'::TIMESTAMP_MS",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_MS/date_before_1970",
+				"native_type": "TIMESTAMP_MS",
+				"class": "date_before_1970",
+				"value_sql": "'1969-07-20 20:17:40.5'::TIMESTAMP_MS",
+				"expect": { "warehouse": "1969-07-20 20:17:40.500000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_MS/date_after_2100",
+				"native_type": "TIMESTAMP_MS",
+				"class": "date_after_2100",
+				"value_sql": "'2150-01-01 00:00:00'::TIMESTAMP_MS",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_MS/null",
+				"native_type": "TIMESTAMP_MS",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_NS/plain",
+				"native_type": "TIMESTAMP_NS",
+				"class": "plain",
+				"value_sql": "'2024-03-10 12:34:56.789123456'::TIMESTAMP_NS",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789123" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_NS/date_before_1970",
+				"native_type": "TIMESTAMP_NS",
+				"class": "date_before_1970",
+				"value_sql": "'1969-07-20 20:17:40.500000001'::TIMESTAMP_NS",
+				"expect": { "warehouse": "1969-07-20 20:17:40.500000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_NS/date_after_2100",
+				"native_type": "TIMESTAMP_NS",
+				"class": "date_after_2100",
+				"value_sql": "'2150-01-01 00:00:00'::TIMESTAMP_NS",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP_NS/null",
+				"native_type": "TIMESTAMP_NS",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/TIMESTAMP WITH TIME ZONE/plain",
+				"native_type": "TIMESTAMP WITH TIME ZONE",
+				"class": "plain",
+				"value_sql": "TIMESTAMPTZ '2024-03-10 12:34:56.789+00'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP WITH TIME ZONE/tz_bearing",
+				"native_type": "TIMESTAMP WITH TIME ZONE",
+				"class": "tz_bearing",
+				"value_sql": "TIMESTAMPTZ '2024-03-10 12:34:56+05:30'",
+				"expect": { "warehouse": "2024-03-10 07:04:56" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP WITH TIME ZONE/date_before_1970",
+				"native_type": "TIMESTAMP WITH TIME ZONE",
+				"class": "date_before_1970",
+				"value_sql": "TIMESTAMPTZ '1969-07-20 20:17:40.5+00'",
+				"expect": { "warehouse": "1969-07-20 20:17:40.500000" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP WITH TIME ZONE/date_after_2100",
+				"native_type": "TIMESTAMP WITH TIME ZONE",
+				"class": "date_after_2100",
+				"value_sql": "TIMESTAMPTZ '2150-01-01 00:00:00+00'",
+				"expect": { "warehouse": "2150-01-01 00:00:00" }
+			},
+			{
+				"key": "duckdb/TIMESTAMP WITH TIME ZONE/null",
+				"native_type": "TIMESTAMP WITH TIME ZONE",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/TIMESTAMPTZ/plain",
+				"native_type": "TIMESTAMPTZ",
+				"class": "plain",
+				"value_sql": "TIMESTAMPTZ '2024-03-10 12:34:56.789+00'",
+				"expect": { "warehouse": "2024-03-10 12:34:56.789000" }
+			},
+			{
+				"key": "duckdb/JSON/nested_json",
+				"native_type": "JSON",
+				"class": "nested_json",
+				"value_sql": "'{\"a\":{\"b\":[1,2]},\"s\":\"x\"}'",
+				"expect": { "warehouse": "{\"a\":{\"b\":[1,2]},\"s\":\"x\"}" }
+			},
+			{
+				"key": "duckdb/JSON/array",
+				"native_type": "JSON",
+				"class": "array",
+				"value_sql": "'[1,\"two\",null]'",
+				"expect": { "warehouse": "[1,\"two\",null]" }
+			},
+			{
+				"key": "duckdb/JSON/null",
+				"native_type": "JSON",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			},
+			{
+				"key": "duckdb/INTEGER[]/array",
+				"native_type": "INTEGER[]",
+				"class": "array",
+				"value_sql": "[1, -2, 3]",
+				"expect": { "warehouse": "List([Int(1), Int(-2), Int(3)])" }
+			},
+			{
+				"key": "duckdb/INTEGER[]/empty",
+				"native_type": "INTEGER[]",
+				"class": "empty",
+				"value_sql": "[]",
+				"expect": { "warehouse": "List([])" }
+			},
+			{
+				"key": "duckdb/INTEGER[]/null",
+				"native_type": "INTEGER[]",
+				"class": "null",
+				"value_sql": "NULL",
+				"expect": { "warehouse": null }
+			}
+		] }
+	}
+};
+
+//#endregion
+//#region src/testing/shape-zoo-sha256.ts
+const ZOO_SHA256 = "04f75f9054a46e521d8787d65f5d214440d041860971c77e66edc7bfbaf8d16a";
+
+//#endregion
+//#region src/testing/zoo.ts
+/** A value a read would REFUSE rather than return: `expect.oltp.$error`. */
+var ZooRefusal = class {
+	constructor(column, nativeType, detail) {
+		this.column = column;
+		this.nativeType = nativeType;
+		this.detail = detail;
+	}
+	/** The host's full sentence for it, from the contract. */
+	message() {
+		return render(REFUSALS.oltpUnsupportedColumn, {
+			name: this.column,
+			ty: this.nativeType
+		});
+	}
+};
+const ZOO = shape_zoo_default;
+/** The zoo table's name, from the fixture's digest — the canary's `zooTableName`. */
+function zooTableName(sha256Hex = ZOO_SHA256) {
+	return `oxy_shape_zoo_${sha256Hex.slice(0, 8)}`;
+}
+/** `c001`, `c002`, … — the zoo column for case `index`. */
+function zooColumn(index) {
+	return `c${String(index + 1).padStart(3, "0")}`;
+}
+const isError = (v) => typeof v === "object" && v !== null && "$error" in v;
+/** What a read of case `c` on `plane` returns — or refuses. */
+function expectation(c, plane, column) {
+	const value = plane === "oltp" ? c.expect.oltp : c.expect.warehouse;
+	return isError(value) ? new ZooRefusal(column, c.native_type, value.$error) : value;
+}
+/** Every case of `engine` for `nativeType`, as written in the zoo. */
+function casesFor(engine, nativeType) {
+	return ZOO.engines[engine].cases.filter((c) => c.native_type === nativeType);
+}
+/** The native types the zoo pins for `engine`, for a declaration error to list. */
+function knownTypes(engine) {
+	return [...new Set(ZOO.engines[engine].cases.map((c) => c.native_type))];
+}
+const I64_MAX = 9223372036854775807n;
+const I64_MIN = -9223372036854775808n;
+/**
+* Render one SQL-side value of a typed column through the zoo.
+*
+* - The value IS a case's `value_sql` for this type → that case's expectation
+*   (`source: "zoo"`).
+* - `NULL` → `null`.
+* - Otherwise the `plain` case's SHAPE decides: a number-shaped type parses the
+*   literal, except that an integer outside `i64` becomes its exact digits as a
+*   string where the zoo pins that (`precision_gt_18` expecting a string) — the
+*   host reads an overflowing column as `u64` rendered to text; a string-shaped
+*   type unquotes; a boolean-shaped type reads `true`/`false`/`1`/`0`; a JSON
+*   shape parses (`source: "typed"`).
+*/
+function renderValue(engine, nativeType, valueSql, plane, column) {
+	const cases = casesFor(engine, nativeType);
+	const raw = valueSql.trim();
+	const exact = cases.find((c) => c.value_sql.trim() === raw);
+	if (exact) return {
+		value: expectation(exact, plane, column),
+		source: "zoo"
+	};
+	if (/^NULL$/i.test(raw)) return {
+		value: null,
+		source: "typed"
+	};
+	const shape = expectation(cases.find((c) => c.class === "plain") ?? cases[0], plane, column);
+	if (shape instanceof ZooRefusal) return {
+		value: shape,
+		source: "zoo"
+	};
+	return {
+		value: shaped(raw, shape, cases, plane, column),
+		source: "typed"
+	};
+}
+function shaped(raw, shape, cases, plane, column) {
+	const unquoted = raw.startsWith("'") && raw.endsWith("'") ? raw.slice(1, -1).replace(/''/g, "'") : raw;
+	switch (typeof shape) {
+		case "number": {
+			if (/^-?\d+$/.test(raw)) {
+				const big = BigInt(raw);
+				if (big > I64_MAX || big < I64_MIN) {
+					const wide = cases.find((c) => c.class === "precision_gt_18");
+					if (wide && typeof expectation(wide, plane, column) === "string") return raw;
+				}
+			}
+			const n = Number(unquoted);
+			return Number.isNaN(n) ? unquoted : n;
+		}
+		case "boolean": return /^(true|1)$/i.test(unquoted);
+		case "string": return unquoted;
+		case "object":
+			if (shape === null) return null;
+			try {
+				return JSON.parse(unquoted);
+			} catch {
+				return unquoted;
+			}
+		default: return unquoted;
+	}
+}
+
+//#endregion
+//#region src/testing/stores.ts
+const RANK = {
+	zoo: 0,
+	typed: 1,
+	author: 2
+};
+const weakest = (a, b) => a === null || RANK[b] > RANK[a] ? b : a;
+/**
+* One SQL-evaluating store: a warehouse database, the OLTP schema or the
+* Airhouse schema. `engine` picks which zoo cases render typed columns;
+* `plane` picks which expectation a case yields.
+*/
+var TableStore = class {
+	constructor(engine, plane, schema = null) {
+		this.engine = engine;
+		this.plane = plane;
+		this.schema = schema;
+		this.tables = /* @__PURE__ */ new Map();
+	}
+	/** The zoo table for this engine: column `cNNN` is case NNN's expectation. */
+	zoo() {
+		const cases = ZOO.engines[this.engine].cases;
+		const columns = {};
+		const values = {};
+		cases.forEach((c, i) => {
+			const column = zooColumn(i);
+			columns[column] = c.native_type;
+			values[column] = expectation(c, this.plane, column);
+		});
+		this.tables.set(zooTableName(), {
+			name: zooTableName(),
+			columns,
+			rows: [{
+				values,
+				source: "zoo"
+			}]
+		});
+		return this;
+	}
+	/**
+	* Declare a typed table: `{ id: "UInt64", amount: "Decimal(18, 4)" }`. A
+	* type the zoo has no case for is an error here, not a guess at read time.
+	*/
+	table(name, columns) {
+		const key = this.key(name);
+		for (const [column, type] of Object.entries(columns)) if (!ZOO.engines[this.engine].cases.some((c) => c.native_type === type)) throw contextError(`the zoo has no ${this.engine} case for type "${type}" (column "${column}" of "${name}"); it pins: ${knownTypes(this.engine).join(", ")}`);
+		if (!this.tables.has(key)) this.tables.set(key, {
+			name: key,
+			columns,
+			rows: []
+		});
+		return new TypedTable(this, key);
+	}
+	/** Seed rows as JS values, unrendered — every read of them is `source: "author"`. */
+	raw(name, rows) {
+		const key = this.key(name);
+		const table = this.tables.get(key) ?? {
+			name: key,
+			columns: null,
+			rows: []
+		};
+		for (const row of rows) table.rows.push({
+			values: { ...row },
+			source: "author"
+		});
+		this.tables.set(key, table);
+		return this;
+	}
+	/** Every row of `name` as a function would read it; a `$error` cell is its refusal text. */
+	rows(name) {
+		return this.lookup(name)?.rows.map((r) => materialise(r.values)) ?? [];
+	}
+	/** The names of every table declared, seeded or created. */
+	tableNames() {
+		return [...this.tables.keys()];
+	}
+	/** Whether `name` exists. */
+	has(name) {
+		return this.lookup(name) !== void 0;
+	}
+	/** Evaluate `sql` as a read: rows, or a throw. */
+	query(sql, params = []) {
+		const statement = parse(sql);
+		if (statement.kind !== "select") throw contextError(`expected a SELECT, got ${statement.kind.toUpperCase()}: ${sql.slice(0, 80)}`);
+		return this.select(statement, params);
+	}
+	/** Evaluate `sql` as a statement: rows affected, or a throw. */
+	exec(sql, params = []) {
+		const statement = parse(sql);
+		switch (statement.kind) {
+			case "create": return this.create(statement);
+			case "insert": return this.insert(statement, params);
+			case "delete": return this.remove(statement, params);
+			case "update": return this.update(statement, params);
+			case "select": return this.select(statement, params).rows.length;
+		}
+	}
+	/** Append JS rows to `name` (`ctx.warehouse.insert`, `ctx.airhouse.append`): unrendered. */
+	append(name, rows) {
+		this.raw(name, rows);
+		return rows.length;
+	}
+	/** Snapshot every table, for `ctx.tx` rollback. */
+	snapshot() {
+		const copy = new Map([...this.tables].map(([k, t]) => [k, {
+			...t,
+			rows: t.rows.map((r) => ({
+				...r,
+				values: { ...r.values }
+			}))
+		}]));
+		return () => {
+			this.tables.clear();
+			for (const [k, t] of copy) this.tables.set(k, t);
+		};
+	}
+	key(name) {
+		return this.schema && name.startsWith(`${this.schema}.`) ? name.slice(this.schema.length + 1) : name;
+	}
+	lookup(name) {
+		return this.tables.get(this.key(name)) ?? this.tables.get(name);
+	}
+	require(name, statement) {
+		const table = this.lookup(name);
+		if (!table) throw contextError(`${statement.kind.toUpperCase()} names a table the test context does not have: "${name}". Declare it with t.state.<store>.table(name, columns), seed it with .raw(name, rows), or let the function CREATE it first. Known: ${this.tableNames().join(", ") || "none"}`);
+		return table;
+	}
+	create(statement) {
+		const key = this.key(statement.table);
+		if (this.tables.has(key)) {
+			if (statement.ifNotExists) return 0;
+			throw contextError(`CREATE TABLE "${statement.table}": the table already exists`);
+		}
+		const columns = {};
+		for (const c of statement.columns) columns[c.name] = c.type;
+		this.tables.set(key, {
+			name: key,
+			columns,
+			rows: []
+		});
+		return 0;
+	}
+	insert(statement, params) {
+		const table = this.require(statement.table, statement);
+		const names = statement.columns ?? (table.columns ? Object.keys(table.columns) : null);
+		for (const tuple of statement.tuples) {
+			if (!names || names.length !== tuple.length) throw contextError(`INSERT INTO "${statement.table}" gives ${tuple.length} value(s) for ${names?.length ?? "an unknown number of"} column(s)`);
+			const values = {};
+			let source = null;
+			names.forEach((column, i) => {
+				const type = table.columns?.[column];
+				if (type && !/^\$\d+$/.test(tuple[i].trim())) {
+					const rendered = renderValue(this.engine, type, tuple[i], this.plane, column);
+					values[column] = rendered.value;
+					source = weakest(source, rendered.source);
+				} else {
+					values[column] = literal(tuple[i], params);
+					source = weakest(source, "author");
+				}
+			});
+			table.rows.push({
+				values,
+				source: source ?? "author"
+			});
+		}
+		return statement.tuples.length;
+	}
+	matching(table, statement, params) {
+		return table.rows.filter((row) => statement.where.every((p) => {
+			const cell = row.values[p.column];
+			return p.values.some((v) => looselyEqual(cell, literal(v, params)));
+		}));
+	}
+	select(statement, params) {
+		if (statement.table === null) {
+			const row = {};
+			for (const item of statement.items) if (item.kind === "literal") row[item.alias] = literal(item.raw, params);
+			else throw contextError(`SELECT without FROM can only project literals: ${JSON.stringify(item)}`);
+			return {
+				rows: [row],
+				source: "author"
+			};
+		}
+		const table = this.require(statement.table, statement);
+		let matched = this.matching(table, statement, params);
+		if (statement.items.some((i) => i.kind === "count")) return {
+			rows: [{ [statement.items.find((i) => i.kind === "count")?.alias ?? "count(*)"]: matched.length }],
+			source: matched[0]?.source ?? null
+		};
+		if (statement.orderBy) {
+			const { column, desc } = statement.orderBy;
+			matched = [...matched].sort((a, b) => compare(a.values[column], b.values[column]) * (desc ? -1 : 1));
+		}
+		if (statement.limit !== null) matched = matched.slice(0, statement.limit);
+		let source = null;
+		return {
+			rows: matched.map((stored) => {
+				source = weakest(source, stored.source);
+				const out = {};
+				for (const item of statement.items) if (item.kind === "all") Object.assign(out, materialise(stored.values));
+				else if (item.kind === "column") out[item.alias] = materialise({ v: stored.values[item.column] }).v;
+				else if (item.kind === "literal") out[item.alias] = literal(item.raw, params);
+				return out;
+			}),
+			source
+		};
+	}
+	remove(statement, params) {
+		const table = this.require(statement.table, statement);
+		const gone = new Set(this.matching(table, statement, params));
+		table.rows = table.rows.filter((r) => !gone.has(r));
+		return gone.size;
+	}
+	update(statement, params) {
+		const table = this.require(statement.table, statement);
+		const hit = this.matching(table, statement, params);
+		for (const row of hit) for (const { column, raw } of statement.set) {
+			row.values[column] = literal(raw, params);
+			row.source = "author";
+		}
+		return hit.length;
+	}
+};
+/** A declared typed table: insert SQL-side values, rendered through the zoo. */
+var TypedTable = class {
+	constructor(store, name) {
+		this.store = store;
+		this.name = name;
+	}
+	/** Insert rows of SQL-side values (`{ id: "42", at: "'2024-03-10 12:34:56'" }`). */
+	insert(rows) {
+		for (const row of rows) {
+			const columns = Object.keys(row);
+			const values = columns.map((c) => row[c]);
+			this.store.exec(`INSERT INTO ${this.name} (${columns.join(", ")}) VALUES (${values.join(", ")})`);
+		}
+		return this;
+	}
+};
+/** A stored row as a read returns it; a refusal cell throws the host's sentence. */
+function materialise(values) {
+	const out = {};
+	for (const [k, v] of Object.entries(values)) {
+		if (v instanceof ZooRefusal) throw refusalOf(v);
+		out[k] = v;
+	}
+	return out;
+}
+/** Marker so the context can wrap a zoo refusal as the OLTP surface's `HostError`. */
+var ZooRefusalError = class extends Error {
+	constructor(refusal) {
+		super(refusal.message());
+		this.refusal = refusal;
+		this.name = "ZooRefusalError";
+	}
+};
+const refusalOf = (r) => new ZooRefusalError(r);
+function looselyEqual(a, b) {
+	if (a === b) return true;
+	if (a === null || b === null || a === void 0 || b === void 0) return false;
+	return String(a) === String(b);
+}
+function compare(a, b) {
+	if (typeof a === "number" && typeof b === "number") return a - b;
+	return String(a).localeCompare(String(b));
+}
+/** The `ctx.fetch` side: answers by URL, and what was received. */
+var FetchStore = class {
+	constructor() {
+		this.received = [];
+		this.answers = [];
+	}
+	/** Answer every URL equal to `match` (or matching the RegExp) with `answer`. */
+	on(match, answer) {
+		this.answers.push({
+			match,
+			answer
+		});
+		return this;
+	}
+	answerFor(url) {
+		return this.answers.find(({ match }) => typeof match === "string" ? match === url : match.test(url))?.answer;
+	}
+};
+
+//#endregion
+//#region src/testing/context.ts
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+const nodeBtoa = globalThis.btoa;
+const nodeAtob = globalThis.atob;
+const nodeCryptoModule = nodeCryptoImport;
+const DEFAULT_USER = {
+	id: "user-1",
+	email: "author@example.test",
+	orgId: "org-1",
+	name: "Author",
+	appRole: "member",
+	orgRole: "member",
+	teams: [],
+	kind: "user",
+	reach: {
+		everywhere: true,
+		via: "org-member",
+		locations: []
+	}
+};
+function createTestContext(manifest, options) {
+	const gates = readGates(manifest, options.function);
+	const manifestSlug = typeof manifest.slug === "string" ? manifest.slug : "";
+	const databases = options.databases ?? {};
+	const calls = [];
+	const overrides = /* @__PURE__ */ new Map();
+	const warehouses = /* @__PURE__ */ new Map();
+	let semanticAnswer = null;
+	const state = {
+		warehouse(database) {
+			const db = databases[database];
+			if (!db) throw contextError(`no database "${database}" in options.databases`);
+			let store = warehouses.get(database);
+			if (!store) {
+				store = new TableStore(db.dialect, "warehouse");
+				warehouses.set(database, store);
+			}
+			return store;
+		},
+		oltp: new TableStore("postgres", "oltp", gates.writerSchema),
+		airhouse: new TableStore("duckdb", "warehouse", gates.writerSchema),
+		storage: /* @__PURE__ */ new Map(),
+		secrets: /* @__PURE__ */ new Map(),
+		emails: [],
+		fetch: new FetchStore(),
+		org: {
+			people: [],
+			places: [],
+			assignments: []
+		},
+		semantic: { on: (answer) => {
+			semanticAnswer = answer;
+		} },
+		airway: { runs: [] }
+	};
+	/** Run one host op: the override or `impl`, recorded either way. */
+	async function op(name, args, impl) {
+		const call = {
+			op: name,
+			args,
+			outcome: "ok"
+		};
+		calls.push(call);
+		try {
+			const result = await (overrides.get(name) ?? impl)(args);
+			if (result && typeof result === "object" && "__source" in result) {
+				const { __source } = result;
+				if (__source) call.source = __source;
+				const rest = Array.isArray(result) ? [...result] : Object.fromEntries(Object.entries(result).filter(([k]) => k !== "__source"));
+				call.result = rest;
+				return rest;
+			}
+			call.result = result;
+			return result;
+		} catch (err) {
+			const thrown = err instanceof ZooRefusalError ? hostError(name.startsWith("tx.") ? SURFACES.tx : SURFACES.oltp, err.message) : err;
+			call.outcome = isHostError(thrown) ? "refused" : "threw";
+			call.message = thrown instanceof Error ? thrown.message : String(thrown);
+			throw thrown;
+		}
+	}
+	/** `check_write_destination` then `destination_write_policy` (`host.rs`, `destinations.rs`). */
+	function checkWriteDestination(surface, database, transaction) {
+		if (!gates.destinations.includes(database)) throw refuse(surface, REFUSALS.destinationNotDeclared, { database });
+		const db = databases[database];
+		if (!db) throw refuse(surface, REFUSALS.databaseNotConfigured, { database });
+		switch (db.kind) {
+			case "airhouse":
+			case "airhouse_managed": return db;
+			case "postgres_managed": throw refuse(surface, REFUSALS.managedOltpWrite, { database });
+			default: {
+				if (gates.customerWarehouseWrites[database]) return db;
+				const words = [REFUSALS.customerWarehouseWrite.refusal];
+				if (transaction) words.push(REFUSALS.customerWarehouseTransaction.refusal);
+				throw hostError(surface, words.join("").replace(/\{database\}/g, database));
+			}
+		}
+	}
+	/**
+	* The host's `WriterCapability` has three states, not two: enabled, disabled,
+	* and enabled-but-the-slug-cannot-back-a-schema. Gating on the boolean alone
+	* let an app whose slug derives no schema pass here and fail closed in
+	* production — the exact shape this module exists to catch.
+	*/
+	function requireWriterSchema(surface, store) {
+		if (gates.writerSchema === null) throw refuse(surface, REFUSALS.slugCannotBackASchema, {
+			slug: manifestSlug,
+			store,
+			max: 56
+		});
+	}
+	function requireOltp(surface) {
+		if (!gates.oltp) throw refuse(surface, REFUSALS.oltp);
+		requireWriterSchema(surface, "OLTP");
+		return state.oltp;
+	}
+	function requireAirhouse() {
+		if (!gates.airhouse) throw refuse(SURFACES.airhouse, REFUSALS.airhouse);
+		requireWriterSchema(SURFACES.airhouse, "Airhouse");
+		return state.airhouse;
+	}
+	function requireStorage(opName) {
+		const needsWrite = [
+			"getUploadUrl",
+			"put",
+			"delete",
+			"copy"
+		].includes(opName);
+		const needsRead = [
+			"getDownloadUrl",
+			"get",
+			"head",
+			"list",
+			"copy"
+		].includes(opName);
+		if (needsWrite && !gates.storageWrite) throw refuse(SURFACES.storage, REFUSALS.storageWrite);
+		if (needsRead && !gates.storageRead) throw refuse(SURFACES.storage, REFUSALS.storageRead);
+	}
+	function defaultDatabase() {
+		const name = options.defaultDatabase ?? Object.keys(databases)[0];
+		if (!name) throw refuse(SURFACES.query, REFUSALS.noDefaultDatabase);
+		return name;
+	}
+	/** `oltp_statement`: `params` absent or an array, else refused. */
+	function oltpParams(surface, params) {
+		if (params === void 0 || params === null) return [];
+		if (Array.isArray(params)) return params;
+		throw refuse(surface, REFUSALS.oltpParamsNotArray);
+	}
+	const read = (store, sql, params = []) => {
+		const { rows, source } = store.query(sql, params);
+		return {
+			rows,
+			truncated: false,
+			__source: source
+		};
+	};
+	let open = 0;
+	let nextTxId = 0;
+	async function runTx(signature, label, beginOp, beginPayload, fn) {
+		if (typeof fn !== "function") throw new TypeError(REFUSALS.transactionFnNotFunction.refusal.replace("{signature}", signature));
+		let store = null;
+		let incremented = false;
+		const { id } = await op(beginOp, beginPayload, () => {
+			if (beginOp === "tx.begin") {
+				const database = String(beginPayload.database);
+				const db = checkWriteDestination(SURFACES.tx, database, true);
+				if (!DIALECTS[db.dialect].opensTransactions) {
+					const cause = REFUSALS.transactionUnsupported.refusal.replace("{backend}", DIALECTS[db.dialect].name);
+					throw refuse(SURFACES.tx, REFUSALS.transactionOpen, {
+						database,
+						e: cause
+					});
+				}
+				store = state.warehouse(database);
+			} else store = requireOltp(SURFACES.tx);
+			if (open >= 4) throw refuse(SURFACES.tx, REFUSALS.transactionsOpen, { MAX_OPEN: 4 });
+			open++;
+			incremented = true;
+			return { id: ++nextTxId };
+		});
+		const table = store ?? (beginOp === "tx.begin_oltp" ? state.oltp : databases[String(beginPayload.database)] ? state.warehouse(String(beginPayload.database)) : new TableStore("postgres", "warehouse"));
+		const restore = table.snapshot();
+		let closed = false;
+		const live = (what) => {
+			if (closed) throw hostError(label, REFUSALS.transactionFinished.refusal.replace("{label}", label).replace("{what}", what));
+		};
+		const handle = {
+			query: async (sql, params) => {
+				live("query");
+				return (await op("tx.query", {
+					id,
+					sql: String(sql),
+					params: params ?? []
+				}, (a) => read(table, String(a.sql), oltpParams(SURFACES.tx, a.params)))).rows;
+			},
+			exec: async (sql, params) => {
+				live("exec");
+				return (await op("tx.exec", {
+					id,
+					sql: String(sql),
+					params: params ?? []
+				}, (a) => ({ rowCount: table.exec(String(a.sql), oltpParams(SURFACES.tx, a.params)) }))).rowCount;
+			}
+		};
+		let result;
+		try {
+			result = await fn(handle);
+		} catch (err) {
+			closed = true;
+			if (incremented) open--;
+			try {
+				await op("tx.rollback", { id }, () => {
+					restore();
+					return {};
+				});
+			} catch {}
+			throw err;
+		}
+		closed = true;
+		if (incremented) open--;
+		await op("tx.commit", { id }, () => ({}));
+		return result;
+	}
+	const ctx = {
+		user: {
+			...DEFAULT_USER,
+			...options.user
+		},
+		env: { ...options.env ?? {} },
+		log: () => {},
+		crypto: nodeCrypto(),
+		query: async (sql) => await op("query", { sql: String(sql) }, (a) => read(state.warehouse(defaultDatabase()), String(a.sql))),
+		queryStream: async function* (sql, opts) {
+			const batchSize = opts?.batchSize || 1e3;
+			const rows = await op("query_stream", { sql: String(sql) }, (a) => {
+				const { rows, __source } = read(state.warehouse(defaultDatabase()), String(a.sql));
+				return Object.assign(rows, { __source });
+			});
+			for (let i = 0; i < rows.length; i += batchSize) yield rows.slice(i, i + batchSize);
+		},
+		fetch: (url, init) => op("fetch", {
+			url,
+			init: init ?? {}
+		}, (a) => fetchOp(String(a.url), a.init ?? {})),
+		warehouse: {
+			insert: (database, table, rows) => op("warehouse.insert", {
+				database,
+				table,
+				rows
+			}, (a) => {
+				checkWriteDestination(SURFACES.warehouse, String(a.database), false);
+				state.warehouse(String(a.database)).append(String(a.table), a.rows);
+				return { ok: true };
+			}),
+			exec: (database, sql) => op("warehouse.exec", {
+				database,
+				sql
+			}, (a) => {
+				checkWriteDestination(SURFACES.warehouse, String(a.database), false);
+				state.warehouse(String(a.database)).exec(String(a.sql));
+				return { ok: true };
+			}),
+			upsert: (database, table, rows, conflictColumns) => op("warehouse.upsert", {
+				database,
+				table,
+				rows,
+				conflictColumns
+			}, (a) => {
+				const database = String(a.database);
+				const db = checkWriteDestination(SURFACES.warehouse, database, false);
+				if (!DIALECTS[db.dialect].parsesOnConflict) throw refuse(SURFACES.warehouse, REFUSALS.upsertUnsupported, { dialect: DIALECTS[db.dialect].name });
+				if (db.kind === "airhouse" || db.kind === "airhouse_managed") throw contextError(`@oxy-hq/sdk/testing: ctx.warehouse.upsert on "${database}" would be refused by the ENGINE, not the host. Airhouse is DuckLake, and a DuckLake table cannot carry the primary key or unique constraint that INSERT … ON CONFLICT needs, so the statement the host lets through fails at runtime. Use ctx.airhouse.append and keep one row per id on read. (These are the test context's words, not a host refusal — assert that the call was refused, not on this text, which may be reworded.)`);
+				state.warehouse(database).append(String(a.table), a.rows);
+				return { ok: true };
+			}),
+			query: (database, sql) => op("warehouse.query", {
+				database,
+				sql
+			}, (a) => {
+				const database = String(a.database);
+				if (!databases[database]) throw refuse(SURFACES.warehouse, REFUSALS.databaseNotConfigured, { database });
+				return read(state.warehouse(database), String(a.sql));
+			})
+		},
+		tx: (database, fn) => runTx("ctx.tx(database, fn)", SURFACES.tx, "tx.begin", { database: String(database) }, fn),
+		oltp: {
+			tx: (fn) => runTx("ctx.oltp.tx(fn)", "ctx.oltp.tx", "tx.begin_oltp", {}, fn),
+			query: async (sql, params) => {
+				return (await op("oltp.query", {
+					sql: String(sql),
+					params: params ?? []
+				}, (a) => read(requireOltp(SURFACES.oltp), String(a.sql), oltpParams(SURFACES.oltp, a.params)))).rows;
+			},
+			exec: async (sql, params) => {
+				return (await op("oltp.exec", {
+					sql: String(sql),
+					params: params ?? []
+				}, (a) => ({ rowCount: requireOltp(SURFACES.oltp).exec(String(a.sql), oltpParams(SURFACES.oltp, a.params)) }))).rowCount;
+			}
+		},
+		airhouse: {
+			schema: gates.airhouse ? gates.writerSchema : null,
+			query: (sql) => op("airhouse.query", { sql: String(sql) }, (a) => read(requireAirhouse(), String(a.sql))),
+			exec: async (sql) => {
+				await op("airhouse.exec", { sql: String(sql) }, (a) => {
+					requireAirhouse().exec(String(a.sql));
+					return { ok: true };
+				});
+			},
+			append: async (table, rows) => {
+				return (await op("airhouse.append", {
+					table: String(table),
+					rows
+				}, (a) => ({ rowCount: requireAirhouse().append(String(a.table), a.rows) }))).rowCount;
+			}
+		},
+		secrets: { set: async (key, value) => {
+			await op("secrets.set", {
+				key: String(key),
+				value: String(value)
+			}, (a) => {
+				if (!gates.secretsWrite) throw refuse(SURFACES.secretsSet, REFUSALS.secretsWrite);
+				state.secrets.set(String(a.key), String(a.value));
+				return null;
+			});
+		} },
+		email: { send: (input) => op("email.send", { ...input }, (a) => {
+			if (!gates.emailSend) throw refuse(SURFACES.emailSend, REFUSALS.emailSend);
+			state.emails.push(a);
+			return { messageId: `message-${state.emails.length}` };
+		}) },
+		org: {
+			people: () => op("org.people", {}, () => {
+				if (!gates.orgRead) throw refuse(SURFACES.orgPeople, REFUSALS.orgPeople);
+				return {
+					people: [...state.org.people],
+					total: state.org.people.length
+				};
+			}),
+			places: () => op("org.places", {}, () => {
+				if (!gates.orgRead) throw refuse(SURFACES.orgPlaces, REFUSALS.orgMember, { member: "places" });
+				return {
+					total: state.org.places.length,
+					places: [...state.org.places]
+				};
+			}),
+			assignments: () => op("org.assignments", {}, () => {
+				if (!gates.orgRead) throw refuse(SURFACES.orgAssignments, REFUSALS.orgMember, { member: "assignments" });
+				return {
+					total: state.org.assignments.length,
+					assignments: [...state.org.assignments]
+				};
+			})
+		},
+		storage: storageApi(),
+		semantic: { query: (spec) => op("semantic.query", { spec }, (a) => {
+			if (!semanticAnswer) throw contextError("ctx.semantic.query has no answer registered: the zoo pins no semantic payload, so supply one with t.state.semantic.on((spec) => result)");
+			return semanticAnswer(a.spec);
+		}) },
+		airway: { run: (pipelineRef, variables) => op("airway.run", {
+			pipelineRef: String(pipelineRef),
+			variables: variables ?? null
+		}, (a) => {
+			state.airway.runs.push({
+				pipelineRef: String(a.pipelineRef),
+				variables: a.variables
+			});
+			return { runId: `run-${state.airway.runs.length}` };
+		}) }
+	};
+	function fetchOp(url, init) {
+		let parsed;
+		try {
+			parsed = new URL(url);
+		} catch (e) {
+			throw refuse(SURFACES.fetch, REFUSALS.fetchInvalidUrl, { e: e instanceof Error ? e.message : String(e) });
+		}
+		if (!isSafeOutbound(parsed)) throw refuse(SURFACES.fetch, REFUSALS.fetchBlocked, { url });
+		for (const [k, v] of Object.entries(headersOf(init.headers))) {
+			if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(k)) throw refuse(SURFACES.fetch, REFUSALS.fetchInvalidHeaderName, { k });
+			if (/[\r\n\0]/.test(v)) throw refuse(SURFACES.fetch, REFUSALS.fetchInvalidHeaderValue, { k });
+		}
+		state.fetch.received.push({
+			url,
+			init
+		});
+		const answer = state.fetch.answerFor(url);
+		if (answer === void 0) throw contextError(`ctx.fetch has no answer for ${url}: register one with t.state.fetch.on(url, { status, body }) — nothing here reaches the network`);
+		const reply = typeof answer === "function" ? answer(url, init) : answer;
+		const fixture = reply.body ?? "";
+		const fixtureIsBase64 = reply.encoding === "base64";
+		const max = gates.fetchMaxBytes ?? 10485760;
+		const len = fixtureIsBase64 ? base64ByteLength(fixture) : encoder.encode(fixture).length;
+		if (len > max) throw refuse(SURFACES.fetch, REFUSALS.fetchTooLarge, {
+			len,
+			max_bytes: max
+		});
+		if (init.encoding !== void 0 && init.encoding !== "utf8" && init.encoding !== "base64") throw contextError(`ctx.fetch: unknown encoding '${String(init.encoding)}' (expected 'utf8' or 'base64')`);
+		const wantBase64 = init.encoding === "base64";
+		const body = wantBase64 ? fixtureIsBase64 ? fixture : utf8ToBase64(fixture) : fixtureIsBase64 ? base64ToUtf8(fixture) : fixture;
+		return {
+			status: reply.status ?? 200,
+			body,
+			encoding: wantBase64 ? "base64" : "utf8"
+		};
+	}
+	function storageApi() {
+		const now = () => (/* @__PURE__ */ new Date()).toISOString();
+		const put = (key, body, contentType) => {
+			const object = {
+				key,
+				body,
+				contentType,
+				size: base64ByteLength(body),
+				lastModified: now()
+			};
+			state.storage.set(key, object);
+			return object;
+		};
+		const storageOp = (name, args, impl) => op(`storage.${name}`, args, (a) => {
+			requireStorage(name);
+			return impl(a);
+		});
+		return {
+			getUploadUrl: (opts) => storageOp("getUploadUrl", { ...opts }, (a) => {
+				const key = `${String(a.pathname ?? `uploads/${String(a.filename ?? "upload")}`).replace(/(\.[^.]*)?$/, `-${randomSuffix()}$1`)}`;
+				return {
+					url: `https://storage.example.test/put/${key}`,
+					key,
+					expiresAt: now()
+				};
+			}),
+			getDownloadUrl: (key, opts) => storageOp("getDownloadUrl", {
+				key: String(key),
+				...opts
+			}, (a) => ({
+				url: `https://storage.example.test/get/${String(a.key)}`,
+				expiresAt: now()
+			})),
+			put: (pathname, body, opts) => storageOp("put", {
+				pathname: String(pathname),
+				body: String(body),
+				...opts
+			}, (a) => {
+				const key = a.addRandomSuffix ? String(a.pathname).replace(/(\.[^.]*)?$/, `-${randomSuffix()}$1`) : String(a.pathname);
+				if (state.storage.has(key) && !a.allowOverwrite) throw hostError(SURFACES.storage, `put: "${key}" already exists (pass allowOverwrite: true)`);
+				const base64 = a.encoding === "base64" ? String(a.body) : utf8ToBase64(String(a.body));
+				const stored = put(key, base64, a.contentType ?? null);
+				return {
+					key,
+					size: stored.size,
+					contentType: stored.contentType ?? "application/octet-stream"
+				};
+			}),
+			get: (key, opts) => storageOp("get", {
+				key: String(key),
+				...opts
+			}, (a) => {
+				const object = state.storage.get(String(a.key));
+				if (!object) return null;
+				const base64 = a.encoding === "base64";
+				return {
+					body: base64 ? object.body : base64ToUtf8(object.body),
+					contentType: object.contentType,
+					size: object.size,
+					encoding: base64 ? "base64" : "utf8"
+				};
+			}),
+			head: (key) => storageOp("head", { key: String(key) }, (a) => {
+				const object = state.storage.get(String(a.key));
+				return object ? {
+					key: object.key,
+					size: object.size,
+					contentType: object.contentType,
+					lastModified: object.lastModified
+				} : null;
+			}),
+			list: (opts) => storageOp("list", { ...opts }, (a) => {
+				const prefix = String(a.prefix ?? "");
+				const limit = Number(a.limit ?? 1e3);
+				const offset = a.cursor ? Number(a.cursor) : 0;
+				const keys = [...state.storage.keys()].filter((k) => k.startsWith(prefix)).sort();
+				const page = keys.slice(offset, offset + limit).map((k) => {
+					const o = state.storage.get(k);
+					return {
+						key: o.key,
+						size: o.size,
+						contentType: o.contentType,
+						lastModified: o.lastModified
+					};
+				});
+				const hasMore = offset + limit < keys.length;
+				return {
+					objects: page,
+					cursor: hasMore ? String(offset + limit) : null,
+					hasMore
+				};
+			}),
+			delete: (keyOrKeys) => storageOp("delete", Array.isArray(keyOrKeys) ? { keys: keyOrKeys.map(String) } : { key: String(keyOrKeys) }, (a) => {
+				const keys = Array.isArray(a.keys) ? a.keys : [String(a.key)];
+				for (const k of keys) state.storage.delete(k);
+				return { deleted: keys.length };
+			}),
+			copy: (fromKey, toPathname, opts) => storageOp("copy", {
+				fromKey: String(fromKey),
+				toPathname: String(toPathname),
+				...opts
+			}, (a) => {
+				const from = state.storage.get(String(a.fromKey));
+				if (!from) throw hostError(SURFACES.storage, `copy: "${String(a.fromKey)}" does not exist`);
+				const key = String(a.toPathname);
+				if (state.storage.has(key) && !a.allowOverwrite) throw hostError(SURFACES.storage, `copy: "${key}" already exists (pass allowOverwrite: true)`);
+				const stored = put(key, from.body, from.contentType);
+				return {
+					key,
+					size: stored.size,
+					contentType: stored.contentType ?? "application/octet-stream"
+				};
+			})
+		};
+	}
+	return {
+		ctx,
+		calls,
+		ops: () => [...new Set(calls.map((c) => c.op))],
+		callsTo: (name) => calls.filter((c) => c.op === name),
+		override: (name, impl) => {
+			overrides.set(name, impl);
+		},
+		run: runWithoutIsolateGlobals,
+		state,
+		gates
+	};
+}
+function headersOf(headers) {
+	if (!headers) return {};
+	if (Array.isArray(headers)) return Object.fromEntries(headers);
+	if (typeof Headers !== "undefined" && headers instanceof Headers) return Object.fromEntries(headers.entries());
+	return headers;
+}
+function randomSuffix() {
+	return Math.random().toString(36).slice(2, 8);
+}
+/**
+* Bytes a base64 string decodes to. `length * 3 / 4` overstates by the padding,
+* which made `size` wrong by up to two bytes and fired the `ctx.fetch` cap early.
+*/
+function base64ByteLength(base64) {
+	const s = base64.trim();
+	if (s === "") return 0;
+	const padding = s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0;
+	return Math.floor(s.length * 3 / 4) - padding;
+}
+function utf8ToBase64(text) {
+	const bytes = encoder.encode(text);
+	let binary = "";
+	for (const b of bytes) binary += String.fromCharCode(b);
+	return nodeBtoa(binary);
+}
+function base64ToUtf8(base64) {
+	const binary = nodeAtob(base64);
+	const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+	return decoder.decode(bytes);
+}
+/**
+* `ctx.crypto` over `node:crypto`: the same three synchronous members
+* `__buildCtx` binds, with the host's argument rules (`key` and `data`
+* required; `signature` and both sides of `timingSafeEqual` lenient). A digest
+* is ASCII, so the byte views need no `Buffer` — which `t.run` removes.
+*/
+function nodeCrypto() {
+	const lib = () => nodeCryptoModule;
+	const ascii = (s) => Uint8Array.from(s, (c) => c.charCodeAt(0));
+	const digest = (algorithm, key, data, encoding) => lib().createHmac(algorithm, key).update(data).digest(encoding);
+	const same = (a, b) => a !== "" && b !== "" && a.length === b.length && lib().timingSafeEqual(ascii(a), ascii(b));
+	return {
+		hmac: ({ algorithm, key, data, encoding }) => {
+			if (key == null) throw new TypeError("ctx.crypto.hmac: `key` is required — is the secret set?");
+			if (data == null) throw new TypeError("ctx.crypto.hmac: `data` is required");
+			return digest(algorithm ?? "sha256", String(key), String(data), encoding ?? "hex");
+		},
+		verifyHmac: ({ algorithm, key, data, signature, encoding }) => {
+			if (key == null) throw new TypeError("ctx.crypto.verifyHmac: `key` is required — is the secret set?");
+			if (data == null) throw new TypeError("ctx.crypto.verifyHmac: `data` is required");
+			const expected = digest(algorithm ?? "sha256", String(key), String(data), encoding ?? "hex");
+			return same(String(signature ?? ""), expected);
+		},
+		timingSafeEqual: (a, b) => same(a == null ? "" : String(a), b == null ? "" : String(b))
+	};
+}
+
+//#endregion
+export { ABSENT_GLOBALS, DIALECTS, FETCH_MAX_BYTES, FETCH_RULES, FetchStore, GATES, HOST_ERROR_NAME, HOST_OPS, MAX_OPEN_TRANSACTIONS, REFUSALS, SURFACES, TableStore, TypedTable, ZOO, ZOO_SHA256, ZooRefusal, casesFor, contextError, createTestContext, expectation, hostError, isHostError, isSafeOutbound, isolateAtob, isolateBtoa, knownTypes, readGates, refuse, render, renderValue, runWithoutIsolateGlobals, writerSchema, zooColumn, zooTableName };
+//# sourceMappingURL=testing.mjs.map