qubu 0.6.0 → 0.6.1

package/docs/guides/valtio-sync.md

@@ -0,0 +1,113 @@
+# Valtio Sync
+
+> Check Valtio Sync fields against Qubu tables and apply each client mutation
+> with its sync event in one Qubu-owned transaction.
+
+Install the optional integration beside Qubu, Valtio Sync, and Zod:
+
+```sh
+pnpm add qubu @qubu/valtio-sync valtio-sync zod
+```
+
+## Check synced fields against Qubu tables
+
+Use the integration's schema wrappers instead of `valtio-sync/schema` when a
+definition corresponds to a Qubu table. Every selected table field must appear
+in `fields`. Mark persistence-only or server-controlled fields with
+`serverOnly()` so they are excluded from Valtio Sync validation and records.
+
+```ts
+import { $type, defineCollection, serverOnly } from "@qubu/valtio-sync"
+import { boolean, integer, table, text } from "qubu"
+import { z } from "zod"
+
+const todosTable = table("todos", {
+  ownerId: integer(),
+  id: text(),
+  title: text(),
+  done: boolean(),
+})
+
+export const todos = defineCollection({
+  dbType: $type<typeof todosTable>(),
+  fields: {
+    ownerId: serverOnly(),
+    id: z.string(),
+    title: z.string().default(""),
+    done: z.boolean().default(false),
+  },
+})
+```
+
+The Zod output for each synced field must be assignable to its Qubu selected
+value. Narrow schemas are allowed, such as a Zod enum for a Qubu text field.
+Missing fields, extra fields, and wider outputs fail type checking. The same
+rules apply to `defineAccount()`.
+
+## Apply mutations in transactions
+
+`applyOpsWithQubu()` converts Qubu-aware mutation handlers into the public
+`ServerHandlers` contract accepted by `valtio-sync/server`. Supply a bound Qubu
+client whose adapter supports transactions:
+
+```ts
+import { applyOpsWithQubu } from "@qubu/valtio-sync"
+import { and, eq, insertInto, returning, update, values, where } from "qubu"
+import { valtioSync } from "valtio-sync/server"
+
+type SyncContext = { user: { id: number } }
+
+const handlers = applyOpsWithQubu<SyncContext>({
+  db,
+  syncEvents: {
+    write: async ({ tx, ctx, collection, recordId, op }) => {
+      const [event] = await tx.rows(
+        insertInto(
+          syncEvents,
+          values({ userId: ctx.user.id, collection, recordId, op }),
+          returning({ seq: syncEvents.seq }),
+        ),
+      )
+      return event.seq
+    },
+  },
+  authorize: ({ ctx, collection, op }) => assertCanSync(ctx.user, collection, op),
+  checkConflict: ({ tx, ctx, collection, op }) =>
+    assertFreshBaseVersion(tx, ctx.user.id, collection, op),
+  handlers: {
+    todos: {
+      readChanges: ({ ctx, since }) => readTodoChanges(ctx.user.id, since),
+      create: async ({ tx, ctx, record }) => {
+        const value = todos.recordSchema.parse(record)
+
+        await tx.execute(insertInto(todosTable, values({ ...value, ownerId: ctx.user.id })))
+        return {}
+      },
+      update: async ({ tx, ctx, op, patch }) => {
+        const value = todos.recordSchema.partial().parse(patch)
+
+        await tx.execute(
+          update(
+            todosTable,
+            value,
+            where(and(eq(todosTable.id, op.id), eq(todosTable.ownerId, ctx.user.id))),
+          ),
+        )
+        return {}
+      },
+    },
+  },
+})
+
+export const sync = valtioSync({ schema: { todos }, handlers })
+```
+
+Authorization, conflict checks, the application mutation, and
+`syncEvents.write()` run in that order inside one Qubu transaction. If any step
+fails, the adapter rolls the transaction back. The event sequence becomes
+`serverVersion` unless the mutation handler returns an explicit version. Read
+handlers pass through unchanged.
+
+The integration does not define persistence tables, import Drizzle, or execute
+driver APIs. The application owns table design, authorization, conflict policy,
+event retention, and every query issued through the supplied Qubu transaction.

package/docs/migrations/index.md

@@ -25,18 +25,26 @@ The `@qubu/migrate` root intentionally exports only format/version constants
 and the central plan and artifact types. Import behavior from its focused
 entrypoint:
 
-| Entrypoint                 | Use it for                                                                 |
-| -------------------------- | -------------------------------------------------------------------------- |
-| `@qubu/migrate/plan`       | Create, encode, decode, fingerprint, and validate migration plans          |
-| `@qubu/migrate/ddl`        | Preview deterministic dialect SQL without opening a database               |
-| `@qubu/migrate/artifact`   | Compile programs; canonicalize, digest, seal, encode, and decode artifacts |
-| `@qubu/migrate/repository` | Verify a complete artifact chain and its journal prefix                    |
-| `@qubu/migrate/journal`    | Implement or inspect the storage-neutral journal contract                  |
-| `@qubu/migrate/executor`   | Apply artifacts and reconcile uncertain attempts                           |
-| `@qubu/migrate/baseline`   | Verify and record the initial non-executable baseline                      |
-| `@qubu/migrate/status`     | Inspect pending work, drift, requirements, and interrupted attempts        |
-| `@qubu/migrate/bootstrap`  | Plan a fresh SQLite database through the normal compiler                   |
-| `@qubu/migrate/testing`    | Test adapter capabilities and deterministic failure boundaries             |
+| Entrypoint                         | Use it for                                                                                                                    |
+| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
+| `@qubu/migrate/plan`               | Create, encode, decode, fingerprint, and validate migration plans                                                             |
+| `@qubu/migrate/ddl`                | Preview deterministic dialect SQL without opening a database                                                                  |
+| `@qubu/migrate/ddl/postgres`       | Preview PostgreSQL SQL from an approved migration plan                                                                        |
+| `@qubu/migrate/ddl/sqlite`         | Preview SQLite SQL from an approved migration plan                                                                            |
+| `@qubu/migrate/ddl/mysql`          | Preview MySQL SQL from an approved migration plan                                                                             |
+| `@qubu/migrate/artifact`           | Compile programs with a caller-supplied `SchemaDialect`; canonicalize, digest, seal, encode, and decode artifacts             |
+| `@qubu/migrate/artifact/postgres`  | Compile reviewed plans with PostgreSQL's schema dialect                                                                       |
+| `@qubu/migrate/artifact/sqlite`    | Compile reviewed plans with SQLite's schema dialect, including table rebuilds                                                 |
+| `@qubu/migrate/artifact/mysql`     | Compile reviewed plans with MySQL's schema dialect                                                                            |
+| `@qubu/migrate/repository`         | Verify a complete artifact chain and its journal prefix                                                                       |
+| `@qubu/migrate/journal`            | Implement or inspect the storage-neutral journal contract                                                                     |
+| `@qubu/migrate/executor`           | Apply artifacts and reconcile uncertain attempts                                                                              |
+| `@qubu/migrate/baseline`           | Verify and record the initial non-executable baseline                                                                         |
+| `@qubu/migrate/status`             | Inspect pending work, drift, requirements, and interrupted attempts                                                           |
+| `@qubu/migrate/bootstrap`          | Prepare a fresh schema diff and expose shared bootstrap types; accepts a caller-supplied `SchemaDialect` for generic planning |
+| `@qubu/migrate/bootstrap/postgres` | Plan a fresh PostgreSQL schema through the normal compiler                                                                    |
+| `@qubu/migrate/bootstrap/sqlite`   | Plan a fresh SQLite schema through the normal compiler                                                                        |
+| `@qubu/migrate/testing`            | Test adapter capabilities and deterministic failure boundaries                                                                |
 
 Start with [Artifacts and approval policy](artifacts-and-policy.md) when
 reviewing a migration format. Check [Adapter capability
@@ -44,3 +52,33 @@ profiles](adapters.md), use [Command line operations](operations.md) to
 configure an application, then keep [Recovery and reconciliation](recovery.md)
 with the deployment runbook. [Lotta Games adoption](lotta-adoption.md) records
 the downstream cutover boundary and current combo-matrix blocker.
+
+Choose the dialect-specific bootstrap entrypoint when using a built-in dialect:
+
+```ts
+import { planSchemaBootstrap } from "@qubu/migrate/bootstrap/postgres"
+
+const result = planSchemaBootstrap(targetSnapshot)
+```
+
+The neutral `@qubu/migrate/bootstrap` entrypoint contains the shared preparation
+logic and generic planner. The PostgreSQL and SQLite entrypoints each import
+only their matching schema dialect.
+
+Use the same entrypoint pattern for convenience artifact compilers:
+
+```ts
+import { compileMigrationProgram } from "@qubu/migrate/artifact/postgres"
+
+const compiled = compileMigrationProgram(plan)
+```
+
+The DDL entrypoints follow the same pattern. Use the neutral entrypoint when
+the application supplies a `SchemaDialect`; use a dialect subpath when the
+built-in dialect should be selected by the module:
+
+```ts
+import { emitMigrationPlan } from "@qubu/migrate/ddl/postgres"
+
+const preview = emitMigrationPlan(plan)
+```

package/docs/migrations/operations.md

@@ -70,7 +70,7 @@ working directory.
 | `qubu migrate apply [--dry-run]`                                                                    | Applies the complete verified pending chain; dry-run performs status/preflight only                                                         | It never limits discovery to Git-added or branch-diff files                                                    |
 | `qubu migrate baseline <id> --confirm <fact>... [--dry-run]`                                        | Without dry-run, strictly compares the live managed schema, initializes an empty journal, records baseline, then writes the artifact        | Requires an empty artifact repository and all seven exact confirmations; dry-run does not inspect the database |
 | `qubu migrate reconcile <attempt-id> --outcome applied\|rolled_back --reason <text>`                | Runs application-owned verification, then records the explicit outcome                                                                      | Requires `verifyReconciliation` in config; no automatic inference                                              |
-| `qubu schema bootstrap [--approve <operation-id=reason>...] [--dry-run]`                            | Plans an empty SQLite snapshot through diff/plan/program; executes through the normal executor unless dry-run                               | Currently rejects non-SQLite targets                                                                           |
+| `qubu schema bootstrap [--approve <operation-id=reason>...] [--dry-run]`                            | Plans an empty SQLite or PostgreSQL snapshot through diff/plan/program; executes through the normal executor unless dry-run                 | Rejects other dialects; unsafe or incomplete facts still require exact approvals or custom programs            |
 
 JSON output is stable, newline-terminated, recursively key-sorted, and redacts
 credential-like keys and credentials or secrets embedded in URLs. Human output
@@ -94,11 +94,25 @@ snapshot. Logical IDs help reporting but do not prove equality. Objects not
 owned by the managed snapshot are returned separately as `unmanagedObjects`;
 Qubu journal objects are excluded by migration snapshot readers.
 
-`schema bootstrap` is for a fresh SQLite database. It produces the same
-versioned program and validation path as a migration. SQLite inline constraints
-are compiled into table creation, while table rebuilds are explicit phases with
-copy/postcondition checks. Session settings such as SQLite PRAGMAs remain in
-the application or adapter setup.
+`schema bootstrap` is for a fresh SQLite database or a fresh PostgreSQL schema.
+It produces the same reviewed plan, versioned program, sealed artifact, and
+executor path as a migration. A complete PostgreSQL snapshot retains standalone
+enums as authoritative objects; bootstrap creates each enum before a table that
+uses it as a native column type. SQLite inline constraints are compiled into
+table creation, while table rebuilds are explicit phases with copy/postcondition
+checks. Session settings such as SQLite PRAGMAs remain in the application or
+adapter setup.
+
+Use the reviewed complete snapshot directly as the PostgreSQL target:
+
+```bash
+qubu schema bootstrap --dry-run --format json --non-interactive
+```
+
+The dry run prints the ordered phases without opening the adapter. Remove
+`--dry-run` only after reviewing any operation IDs that require `--approve` or
+an application-owned custom program. Bootstrap does not import or replay
+Drizzle migration history.
 
 ## Baseline and cutover checklist
 

package/docs/reference/supported-surface.md

@@ -10,7 +10,10 @@
 | `qubu/core`                               | Runtime          | Fragment and rendering primitives, dialect construction, SQL types, and extension constructors                   |
 | `qubu/codegen`                            | Runtime          | Deterministic machine-owned TypeScript schemas from complete, non-lossy introspection                            |
 | `qubu/diff`                               | Runtime          | Canonical Snapshot v1 or v2 comparison, rename hints, suggestions, and safety diagnostics                        |
-| `qubu/introspection`                      | Runtime          | Catalog readers, normalized catalogs, and mapping to Snapshot v1 or v2                                           |
+| `qubu/introspection`                      | Runtime          | Shared catalog contracts, normalized catalog models, diagnostics, and mapping to Snapshot v1 or v2               |
+| `qubu/introspection/postgres`             | Runtime          | PostgreSQL catalog reader and catalog queries for one selected namespace                                         |
+| `qubu/introspection/sqlite`               | Runtime          | SQLite catalog reader and catalog queries for one selected namespace                                             |
+| `qubu/introspection/mysql`                | Runtime          | MySQL catalog reader and catalog queries for one selected namespace                                              |
 | `qubu/mysql`                              | Runtime          | The MySQL query dialect policy                                                                                   |
 | `qubu/postgres`                           | Runtime          | PostgreSQL query dialect helpers such as `postgresDialect()` and `ilike()`                                       |
 | `qubu/schema`                             | Runtime          | Advanced schema metadata, storage and constraint models, source models, and schema-expression extensions         |
@@ -23,14 +26,22 @@
 | `qubu/package.json`                       | JSON             | The published package manifest                                                                                   |
 | `@qubu/migrate`                           | Runtime          | Migration compiler format identity and shared plan types                                                         |
 | `@qubu/migrate/plan`                      | Runtime          | Pure migration planning with dependencies, decisions, preconditions, and explicit custom SQL                     |
-| `@qubu/migrate/ddl`                       | Runtime          | DDL preflight and deterministic PostgreSQL, SQLite, or MySQL emission from a migration plan                      |
-| `@qubu/migrate/artifact`                  | Runtime          | Versioned programs, strict artifacts and baselines, canonical encoding, and SHA-256 integrity                    |
+| `@qubu/migrate/ddl`                       | Runtime          | DDL preflight and generic emission from a migration plan and supplied schema dialect                             |
+| `@qubu/migrate/ddl/postgres`              | Runtime          | PostgreSQL DDL emission from an approved migration plan                                                          |
+| `@qubu/migrate/ddl/sqlite`                | Runtime          | SQLite DDL emission from an approved migration plan                                                              |
+| `@qubu/migrate/ddl/mysql`                 | Runtime          | MySQL DDL emission from an approved migration plan                                                               |
+| `@qubu/migrate/artifact`                  | Runtime          | Generic versioned program compilation with a caller-supplied schema dialect, plus strict artifacts and baselines |
+| `@qubu/migrate/artifact/postgres`         | Runtime          | PostgreSQL versioned program compilation                                                                         |
+| `@qubu/migrate/artifact/sqlite`           | Runtime          | SQLite versioned program compilation, including table rebuilds                                                   |
+| `@qubu/migrate/artifact/mysql`            | Runtime          | MySQL versioned program compilation                                                                              |
 | `@qubu/migrate/repository`                | Runtime          | Strict full-chain and journal-prefix verification                                                                |
 | `@qubu/migrate/journal`                   | Runtime          | Storage-neutral journal records, transitions, validation, and reference storage                                  |
 | `@qubu/migrate/executor`                  | Runtime          | Portable execution, structured errors, checkpointing, and explicit reconciliation                                |
 | `@qubu/migrate/baseline`                  | Runtime          | Strict live baseline verification and physical managed-schema comparison                                         |
 | `@qubu/migrate/status`                    | Runtime          | Pending chain, managed drift, unmanaged objects, interrupted attempts, and incompatible requirements             |
-| `@qubu/migrate/bootstrap`                 | Runtime          | Fresh SQLite schema planning through the normal diff, plan, and program compiler                                 |
+| `@qubu/migrate/bootstrap`                 | Runtime          | Shared bootstrap preparation, result types, and generic planning with a caller-supplied schema dialect           |
+| `@qubu/migrate/bootstrap/postgres`        | Runtime          | Fresh PostgreSQL schema planning through the normal diff, plan, and program compiler                             |
+| `@qubu/migrate/bootstrap/sqlite`          | Runtime          | Fresh SQLite schema planning through the normal diff, plan, and program compiler                                 |
 | `@qubu/migrate/testing`                   | Runtime          | Deterministic fake adapters, fault boundaries, and adapter conformance checks                                    |
 | `@qubu/cli`                               | Runtime and CLI  | `@alloc/cmd-ts` commands, typed config, filesystem repositories, stable output, and exit codes                   |
 | `@qubu/drizzle`                           | Runtime          | Shared Drizzle conversion errors and dialect types                                                               |
@@ -69,7 +80,7 @@ entrypoint table.
 | Read queries         | Named projections, spreadable source columns, aliases, joins, typed custom and LATERAL `FROM` sources, correlated subqueries, `WHERE`, grouping with declared-key proofs, `HAVING`, ordering, window expressions, distinctness, pagination, row locking, ordinary and recursive CTEs, subqueries, and set operations                                                                     |
 | Expressions          | Comparison, boolean, arithmetic, null, range, membership, aggregate, window, string, JSON scalar reads, definition-backed and raw casts, cases, parameterized SQL templates, custom expressions, and branded deterministic schema expressions                                                                                                                                            |
 | SQL type metadata    | Portable domains and capabilities, physical column storage descriptors, `SqlTypeOf`, projected SQL type maps, `SourceLike` and `TableLike` field constraints, contextual literals, typed extension values, calls, and casts, plus a permissive `SqlUnknown` fallback                                                                                                                     |
-| Write queries        | `INSERT` values, defaults, and selects; `UPDATE`; `DELETE`; typed assignments; `RETURNING`; and explicit unrestricted-write opt-in                                                                                                                                                                                                                                                       |
+| Write queries        | `INSERT` values, defaults, and selects; typed `UPDATE`, PostgreSQL `UPDATE ... FROM`, and `DELETE`; typed assignments; `RETURNING`; and explicit unrestricted-write opt-in                                                                                                                                                                                                               |
 | Rendering            | Standard, PostgreSQL, SQLite, MySQL, and user-created policies for identifiers, placeholders, pagination, row locking, JSON, logical cast targets, schema literals, and EXPLAIN options                                                                                                                                                                                                  |
 | Execution boundary   | `QueryAdapter`, opt-in `ExplainableQueryAdapter`, `StreamingQueryAdapter`, and `TransactionalQueryAdapter` capabilities, bound clients from `qubu()`, structured results from `execute()` or `db.execute()`, row-only results from `executeRows()` or `db.rows()`, typed read streams from `stream()` or `db.stream()`, and adapter-decoded plan rows from `explain()` or `db.explain()` |
 | Snapshots            | Pure Snapshot v1 and v2 creation, canonical encoding and strict decoding, immutable data, diagnostics, and FNV change-detection fingerprints                                                                                                                                                                                                                                             |
@@ -77,7 +88,7 @@ entrypoint table.
 | Snapshot diffing     | Pure Snapshot v1 and v2 comparison, explicit rename evidence, non-authoritative suggestions, and safety diagnostics                                                                                                                                                                                                                                                                      |
 | Migration planning   | Pure, dialect-neutral plans with stable ordering, dependency edges, preconditions, explicit review decisions, and tagged custom SQL                                                                                                                                                                                                                                                      |
 | DDL emission         | Preflight plus deterministic PostgreSQL, SQLite, and MySQL statements from an approved `MigrationPlan` and matching `SchemaDialect`                                                                                                                                                                                                                                                      |
-| Migration operations | Strict artifacts and baselines, authoritative programs, repository and journal validation, adapter capability preflight, execution, status/drift, reconciliation, and SQLite bootstrap                                                                                                                                                                                                   |
+| Migration operations | Strict artifacts and baselines, authoritative programs, repository and journal validation, adapter capability preflight, execution, status/drift, reconciliation, SQLite bootstrap, and complete PostgreSQL bootstrap with standalone enum ordering                                                                                                                                      |
 | Build tooling        | The optional Vite directive transform and its matching TypeScript ambient declarations                                                                                                                                                                                                                                                                                                   |
 | Drizzle conversion   | Optional, dialect-specific runtime conversion from Qubu schema registries to Drizzle tables                                                                                                                                                                                                                                                                                              |
 | Source generation    | Pure Snapshot v1 table source printing, deterministic camelCase IDs, exact physical metadata, controlled type mappings, and structured failure diagnostics                                                                                                                                                                                                                               |

package/docs/schema/code-generation.md

@@ -14,9 +14,10 @@ generator:
 ```ts
 import { writeFile } from "node:fs/promises"
 import { generateSchemaSource } from "qubu/codegen"
-import { mapCatalogToSnapshot, readSqliteCatalog } from "qubu/introspection"
+import { mapCatalogToSnapshot } from "qubu/introspection"
+import { readCatalog } from "qubu/introspection/sqlite"
 
-const catalog = await readSqliteCatalog(connection, { namespace: "main" })
+const catalog = await readCatalog(connection, { namespace: "main" })
 const introspection = mapCatalogToSnapshot(catalog, { namespace: "main" })
 const generated = generateSchemaSource(introspection)
 

package/docs/schema/introspection.md

@@ -59,9 +59,10 @@ catalog can later support inspection, source generation, or another snapshot
 format:
 
 ```ts
-import { mapCatalogToSnapshot, readSqliteCatalog } from "qubu/introspection"
+import { mapCatalogToSnapshot } from "qubu/introspection"
+import { readCatalog } from "qubu/introspection/sqlite"
 
-const catalog = await readSqliteCatalog(connection, { namespace: "main" })
+const catalog = await readCatalog(connection, { namespace: "main" })
 const result = mapCatalogToSnapshot(catalog, {
   namespace: "main",
   mode: "strict",

package/docs/sql-semantic-types.md

@@ -89,6 +89,14 @@ operation. This contextual typing does not relabel an expression: comparing a
 `SqlUuid` expression with a `SqlText` expression is still rejected. Cast when
 the database operation intentionally changes domains:
 
+Scalar text functions bind primitive operands automatically, and `coalesce()`
+uses its first expression to type primitive fallbacks:
+
+```ts
+upper("Ada") // UPPER(?)
+coalesce(metrics.label, "Anonymous") // COALESCE("metrics"."label", ?)
+```
+
 ```ts
 import { cast, like, text } from "qubu"
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qubu",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/aleclarson/qubu"
@@ -32,6 +32,18 @@
       "types": "./dist/introspection.d.mts",
       "import": "./dist/introspection.mjs"
     },
+    "./introspection/mysql": {
+      "types": "./dist/introspection/mysql.d.mts",
+      "import": "./dist/introspection/mysql.mjs"
+    },
+    "./introspection/postgres": {
+      "types": "./dist/introspection/postgres.d.mts",
+      "import": "./dist/introspection/postgres.mjs"
+    },
+    "./introspection/sqlite": {
+      "types": "./dist/introspection/sqlite.d.mts",
+      "import": "./dist/introspection/sqlite.mjs"
+    },
     "./mysql": {
       "types": "./dist/mysql.d.mts",
       "import": "./dist/mysql.mjs"

package/dist/registry-BRcUuazJ.mjs

@@ -1,256 +0,0 @@
-import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { _ as isSchemaExpression, h as snakeCaseIdentifier, r as isColumnReference, x as markSchemaExpression, y as makeSchemaExpression } from "./column-r1Y4ivwt.mjs";
-import { n as isValueExpression } from "./value-D14I_XgL.mjs";
-//#region src/schema/expressions.ts
-/** Error raised before a schema expression can become persisted SQL. */
-var SchemaExpressionError = class extends TypeError {
-	code;
-	mode;
-	constructor(code, message, mode) {
-		super(message);
-		this.name = "SchemaExpressionError";
-		this.code = code;
-		this.mode = mode;
-	}
-};
-/**
-* Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
-* remain under the extension author's control.
-*/
-function normalizeSchemaSql(sql) {
-	return sql.replace(/\r\n?/g, "\n");
-}
-function schemaExpression(expression) {
-	return markSchemaExpression(expression);
-}
-/**
-* Define an extension with the restricted schema context. This is the typed alternative to
-* {@link unsafeSchemaSql} for deterministic custom syntax.
-*/
-function defineSchemaExpression(kind, render) {
-	return makeSchemaExpression(kind, (context) => render(context));
-}
-function unsafeSchemaSql(dialectOrOptions, sql) {
-	const dialect = typeof dialectOrOptions === "string" ? dialectOrOptions : dialectOrOptions.dialect;
-	const source = typeof dialectOrOptions === "string" ? sql : dialectOrOptions.sql;
-	if (!dialect) throw new TypeError("unsafeSchemaSql() requires a dialect tag");
-	if (source === void 0) throw new TypeError("unsafeSchemaSql() requires SQL text");
-	const normalized = normalizeSchemaSql(source);
-	const expression = makeSchemaExpression("unsafe", (context) => context.append(normalized));
-	return Object.freeze({
-		...expression,
-		schemaSqlDialect: dialect,
-		schemaSql: normalized
-	});
-}
-/** Identify a dialect-tagged raw schema expression. */
-function isUnsafeSchemaSql(value) {
-	return isSchemaExpression(value) && value.expressionKind === "unsafe" && typeof value.schemaSqlDialect === "string" && typeof value.schemaSql === "string";
-}
-function renderSchemaExpression(expression, optionsOrMode, dialectOption) {
-	const options = typeof optionsOrMode === "string" ? {
-		mode: optionsOrMode,
-		dialect: dialectOption
-	} : optionsOrMode;
-	const dialect = options.dialect ?? standardDialect();
-	if (!isSchemaExpression(expression)) throw new SchemaExpressionError("not-deterministic", "Only branded deterministic expressions can be rendered as schema SQL", options.mode);
-	assertSupportedExpression(expression, options.mode);
-	let text = "";
-	const context = {
-		dialect,
-		projectionMode: "result",
-		schemaMode: options.mode,
-		append(value) {
-			text += value;
-		},
-		parameter() {
-			throw new SchemaExpressionError("parameter", "Schema expressions cannot render query parameters", options.mode);
-		},
-		literal(value) {
-			text += renderSchemaLiteral(dialect, value, options.mode);
-		},
-		renderColumnReference(columnName) {
-			if (options.mode === "default") throw new SchemaExpressionError("column-not-allowed", "Default expressions cannot reference table columns", options.mode);
-			text += dialect.quoteIdentifier(columnName);
-		},
-		render(part) {
-			renderSchemaPart(context, part, options.mode);
-		},
-		renderRelation() {
-			throw new SchemaExpressionError("unsupported-expression", "Schema expressions cannot contain subqueries", options.mode);
-		}
-	};
-	renderSchemaPart(context, expression, options.mode);
-	return Object.freeze({
-		text,
-		parameters: Object.freeze([])
-	});
-}
-/** Convenience form for callers that only need the SQL text. */
-function renderSchemaSql(expression, options) {
-	return renderSchemaExpression(expression, options).text;
-}
-function renderSchemaPart(context, part, mode) {
-	if (isValueExpression(part)) {
-		context.literal(part.value);
-		return;
-	}
-	if (isColumnReference(part)) {
-		context.renderColumnReference(part.columnName);
-		return;
-	}
-	if (isUnsafeSchemaSql(part)) {
-		if (part.schemaSqlDialect !== context.dialect.name) throw new SchemaExpressionError("dialect-mismatch", `Schema SQL is tagged for "${part.schemaSqlDialect}" but rendered for "${context.dialect.name}"`, mode);
-		context.append(part.schemaSql);
-		return;
-	}
-	if (!isSchemaExpression(part)) throw new SchemaExpressionError("not-deterministic", "Schema expressions may only compose branded expressions, columns, and literals", mode);
-	assertSupportedExpression(part, mode);
-	part.render(context);
-}
-function assertSupportedExpression(expression, mode) {
-	if (expression.expressionKind === "subquery" || expression.expressionCategory) throw new SchemaExpressionError("unsupported-expression", "Aggregates, windows, and subqueries are not valid schema expressions", mode);
-}
-function renderSchemaLiteral(dialect, value, mode) {
-	if (dialect.renderSchemaLiteral) {
-		const rendered = dialect.renderSchemaLiteral(value);
-		if (typeof rendered !== "string" || rendered.includes("?")) throw new SchemaExpressionError("invalid-literal", "A schema literal renderer must return parameter-free SQL text", mode);
-		return rendered;
-	}
-	if (value === null) return "NULL";
-	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
-	if (typeof value === "string") return `'${value.replaceAll("'", "''")}'`;
-	if (typeof value === "bigint") return String(value);
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw new SchemaExpressionError("unsupported-value", "Schema literals require finite numbers", mode);
-		return Object.is(value, -0) ? "0" : String(value);
-	}
-	throw new SchemaExpressionError("unsupported-value", `Unsupported schema literal type: ${value === void 0 ? "undefined" : typeof value}`, mode);
-}
-//#endregion
-//#region src/schema/registry.ts
-/** The first naming-policy version used by schema metadata. */
-const schemaNamingPolicyVersion = 1;
-/**
-* The built-in naming policy for schema-generated physical names.
-*
-* Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
-* needs a physical name for a logical table ID.
-*/
-const defaultSchemaNamingPolicy = Object.freeze({
-	version: 1,
-	tableName: snakeCaseIdentifier
-});
-/** Error thrown when a root schema fails registry or naming validation. */
-var SchemaValidationError = class extends Error {
-	name = "SchemaValidationError";
-	diagnostics;
-	/** Alias matching validation libraries that call findings "issues". */
-	issues;
-	constructor(diagnostics) {
-		const frozenDiagnostics = Object.freeze(diagnostics.map((diagnostic) => Object.freeze({
-			...diagnostic,
-			path: Object.freeze([...diagnostic.path]),
-			relatedPaths: diagnostic.relatedPaths ? Object.freeze(diagnostic.relatedPaths.map((path) => Object.freeze([...path]))) : void 0
-		})));
-		super(frozenDiagnostics.map((diagnostic) => diagnostic.message).join("\n"));
-		this.diagnostics = frozenDiagnostics;
-		this.issues = frozenDiagnostics;
-	}
-};
-function entriesOf(input) {
-	if (Array.isArray(input)) return input;
-	return Object.entries(input);
-}
-function validLogicalId(id) {
-	return id.length > 0 && id === id.trim() && !/[.\\/\u0000-\u001f\u007f]/u.test(id);
-}
-function validNamespace(namespace) {
-	return namespace.length > 0 && namespace === namespace.trim() && !/[.\\/\u0000-\u001f\u007f"']/u.test(namespace);
-}
-function validateEntries(entries, namespace, namingPolicy) {
-	const diagnostics = [];
-	const ids = /* @__PURE__ */ new Map();
-	const physicalNames = /* @__PURE__ */ new Map();
-	const generatedNames = /* @__PURE__ */ new Map();
-	for (const [index, [id, table]] of entries.entries()) {
-		const path = ["tables", id];
-		const previousId = ids.get(id);
-		if (previousId !== void 0) diagnostics.push({
-			code: "duplicate-table-id",
-			message: `Table ID "${id}" is declared more than once`,
-			path,
-			relatedPaths: [["tables", entries[previousId][0]]]
-		});
-		else ids.set(id, index);
-		if (!validLogicalId(id)) diagnostics.push({
-			code: "invalid-table-id",
-			message: `Table ID "${id}" must be a non-empty logical identifier`,
-			path
-		});
-		const physicalName = table.tableName || namingPolicy.tableName(id);
-		const previousPhysicalName = physicalNames.get(physicalName);
-		if (previousPhysicalName !== void 0) diagnostics.push({
-			code: "duplicate-physical-name",
-			message: `Tables "${entries[previousPhysicalName][0]}" and "${id}" both use physical name "${physicalName}"`,
-			path: [...path, "physicalName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousPhysicalName][0],
-				"physicalName"
-			]]
-		});
-		else physicalNames.set(physicalName, index);
-		const generatedName = namingPolicy.tableName(id);
-		const previousGeneratedName = generatedNames.get(generatedName);
-		if (previousGeneratedName !== void 0) diagnostics.push({
-			code: "generated-name-collision",
-			message: `Logical table IDs "${entries[previousGeneratedName][0]}" and "${id}" generate the same physical name "${generatedName}"`,
-			path: [...path, "generatedName"],
-			relatedPaths: [[
-				"tables",
-				entries[previousGeneratedName][0],
-				"generatedName"
-			]]
-		});
-		else generatedNames.set(generatedName, index);
-	}
-	if (namespace !== void 0 && !validNamespace(namespace)) diagnostics.push({
-		code: "invalid-namespace",
-		message: `Schema namespace "${namespace}" must be a non-empty identifier without qualification or control characters`,
-		path: ["namespace"]
-	});
-	return Object.freeze(diagnostics);
-}
-function freezeTableNames(entries, namingPolicy) {
-	return Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, table.tableName || namingPolicy.tableName(id)])));
-}
-function createSchema(entries, tables, options = {}) {
-	const namingPolicy = options.namingPolicy ?? defaultSchemaNamingPolicy;
-	const diagnostics = validateEntries(entries, options.namespace, namingPolicy);
-	if (diagnostics.length > 0) throw new SchemaValidationError(diagnostics);
-	const tableNames = freezeTableNames(entries, namingPolicy);
-	const registry = Object.freeze(Object.fromEntries(entries.map(([id, table]) => [id, Object.freeze({
-		id,
-		table,
-		physicalName: tableNames[id]
-	})])));
-	return Object.freeze({
-		schemaKind: "schema",
-		tables: Object.freeze({ ...tables }),
-		registry,
-		tableNames,
-		namespace: options.namespace,
-		namingPolicy: Object.freeze({ ...namingPolicy })
-	});
-}
-function schema(tables, options) {
-	const entries = entriesOf(tables);
-	return createSchema(entries, Object.fromEntries(entries), options);
-}
-/** Generate a v1 physical name for a logical table ID. */
-function generatedTableName(logicalId, namingPolicy = defaultSchemaNamingPolicy) {
-	return namingPolicy.tableName(logicalId);
-}
-//#endregion
-export { schemaNamingPolicyVersion as a, isUnsafeSchemaSql as c, renderSchemaSql as d, schemaExpression as f, schema as i, normalizeSchemaSql as l, defaultSchemaNamingPolicy as n, SchemaExpressionError as o, unsafeSchemaSql as p, generatedTableName as r, defineSchemaExpression as s, SchemaValidationError as t, renderSchemaExpression as u };

package/dist/standard-DfcZEVOj.mjs

@@ -1,12 +0,0 @@
-import { i as standardJson, o as createDialect } from "./json-Db7XRD91.mjs";
-//#region src/dialects/standard.ts
-/** SQL:2008-style rendering defaults used by the core builder. */
-function standardDialect() {
-	return createDialect({
-		name: "standard-sql",
-		placeholder: () => "?",
-		json: standardJson
-	});
-}
-//#endregion
-export { standardDialect as t };