@minnowdb/core 0.2.1 → 0.4.0

package/dist/engine/result-wire.d.ts

@@ -65,4 +65,3 @@ export declare function encodeQueryResult(result: QueryResult): EncodedQueryResu
 export declare function encodeQueryRows(rows: readonly QueryRow[]): EncodedQueryResult;
 export declare function decodeQueryResult(payload: unknown): QueryResult;
 export declare function isWireQueryResult(value: unknown): value is WireQueryResult;
-//# sourceMappingURL=result-wire.d.ts.map

package/dist/engine/result-wire.js

@@ -1,3 +1,4 @@
+import { dateMilliseconds } from "../date-value.js";
 export function encodeQueryResult(result) {
     return encodeRows(result.columns, result.rows);
 }
@@ -115,7 +116,7 @@ function encodeColumn(name, rows) {
                 nulls[index] = 1;
             }
             else if (value instanceof Date) {
-                values[index] = value.getTime();
+                values[index] = dateMilliseconds(value);
             }
             else {
                 return encodeMixed(name, rows);
@@ -261,4 +262,3 @@ function decodeColumnValues(column, rowCount) {
     }
     return values;
 }
-//# sourceMappingURL=result-wire.js.map

package/dist/engine/schema-wire.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnDefault } from "../storage/index.js";
-import { type AnyTable, type MigrationStep, type ReferentialAction, type SchemaColumnType, type SchemaDefinition, type TableCheck } from "./schema.js";
+import type { ColumnDefault, SqlDomain } from "../storage/types.js";
+import { type AnyTable, type MigrationStep, type ReferentialAction, type SchemaColumnType, type SchemaDefinition, type TableCheck, type TableForeignKey } from "./schema.js";
 /**
  * Structured-clone-safe mirror of the schema DSL. Column builders and table validators carry
  * methods, so a schema cannot cross a postMessage boundary as-is; these types keep only the data
@@ -9,6 +9,8 @@ export interface WireColumn {
     readonly type: SchemaColumnType;
     readonly isNullable: boolean;
     readonly isUnique: boolean;
+    readonly integer?: true;
+    readonly sqlDomain?: SqlDomain;
     readonly defaultSpec?: ColumnDefault;
     readonly renamedFromName?: string;
     readonly reference?: {
@@ -23,6 +25,8 @@ export interface WireColumn {
 export interface WireTable {
     readonly name: string;
     readonly columns: Record<string, WireColumn>;
+    readonly primaryKey?: readonly string[];
+    readonly foreignKeys?: readonly TableForeignKey[];
     /** Absent rather than empty so a frame written without the field stays readable. */
     readonly checks?: readonly TableCheck[];
 }
@@ -89,4 +93,3 @@ export type WireMigrationStep = {
 export declare function serializeSchema(definition: SchemaDefinition<readonly AnyTable[]>): WireSchema;
 export declare function serializeMigrationSteps(steps: readonly MigrationStep[]): WireMigrationStep[];
 export declare function deserializeSchema(wire: WireSchema): SchemaDefinition<readonly AnyTable[]>;
-//# sourceMappingURL=schema-wire.d.ts.map

package/dist/engine/schema-wire.js

@@ -1,22 +1,25 @@
-import { column, columnWithDefaultSpec, schema, table, view, } from "./schema.js";
-function serializeColumn(definition) {
+import { columnFromState, schema, table, view, } from "./schema.js";
+function serializeColumn(definition, frozen) {
+    const backfillValue = frozen === undefined
+        ? typeof definition.backfillValue === "function"
+            ? definition.backfillValue()
+            : definition.backfillValue
+        : frozen.backfillValue;
     return {
         type: definition.type,
         isNullable: definition.isNullable,
         isUnique: definition.isUnique,
+        ...(definition.integer ? { integer: true } : {}),
+        ...(definition.sqlDomain === undefined
+            ? {}
+            : { sqlDomain: structuredClone(definition.sqlDomain) }),
         ...(definition.defaultSpec === undefined ? {} : { defaultSpec: { ...definition.defaultSpec } }),
         ...(definition.renamedFromName === undefined
             ? {}
             : { renamedFromName: definition.renamedFromName }),
         ...(definition.reference === undefined ? {} : { reference: { ...definition.reference } }),
         ...(definition.enumValues === undefined ? {} : { enumValues: [...definition.enumValues] }),
-        ...(definition.backfillValue === undefined
-            ? {}
-            : {
-                backfillValue: typeof definition.backfillValue === "function"
-                    ? definition.backfillValue()
-                    : definition.backfillValue,
-            }),
+        ...(backfillValue === undefined ? {} : { backfillValue }),
     };
 }
 function serializeTable(definition) {
@@ -26,6 +29,10 @@ function serializeTable(definition) {
             name,
             serializeColumn(columnDefinition),
         ])),
+        ...(definition.primaryKey.length === 0 ? {} : { primaryKey: [...definition.primaryKey] }),
+        ...(definition.foreignKeys.length === 0
+            ? {}
+            : { foreignKeys: structuredClone(definition.foreignKeys) }),
         ...(definition.checks.length === 0
             ? {}
             : { checks: definition.checks.map((check) => ({ ...check })) }),
@@ -66,7 +73,7 @@ export function serializeMigrationSteps(steps) {
                     kind: "add-column",
                     tableName: step.tableName,
                     columnName: step.columnName,
-                    definition: serializeColumn(step.definition),
+                    definition: serializeColumn(step.definition, step.backfill === undefined ? {} : { backfillValue: step.backfill }),
                 };
             case "replace-view":
                 return { kind: "replace-view", view: serializeView(step.view) };
@@ -79,37 +86,36 @@ function deserializeColumn(wire) {
     if (wire.enumValues !== undefined && wire.type !== "string") {
         throw new TypeError(`Enum values require a string column, got ${wire.type}`);
     }
-    let builder = wire.enumValues === undefined
-        ? column[wire.type]()
-        : column.enum(wire.enumValues);
-    if (wire.isNullable)
-        builder = builder.nullable();
-    if (wire.isUnique)
-        builder = builder.unique();
-    if (wire.renamedFromName !== undefined)
-        builder = builder.renamedFrom(wire.renamedFromName);
-    if (wire.backfillValue !== undefined)
-        builder = builder.backfill(wire.backfillValue);
-    if (wire.reference !== undefined) {
-        builder = builder.references(wire.reference.table, wire.reference.column, {
-            onDelete: wire.reference.onDelete,
-        });
-    }
-    // Rebuilt from the spec directly rather than through .default(), which would re-interpret the
-    // reserved generator names.
-    if (wire.defaultSpec !== undefined)
-        builder = columnWithDefaultSpec(builder, wire.defaultSpec);
-    return builder;
+    // Rebuild in one step. Chaining dynamic nullable/unique builders is needlessly invariant and
+    // used to discard a backfill when a default spec was applied last.
+    return columnFromState({
+        type: wire.type,
+        isNullable: wire.isNullable,
+        isUnique: wire.isUnique,
+        integer: wire.integer === true,
+        ...(wire.sqlDomain === undefined ? {} : { sqlDomain: structuredClone(wire.sqlDomain) }),
+        ...(wire.defaultSpec === undefined ? {} : { defaultSpec: wire.defaultSpec }),
+        ...(wire.renamedFromName === undefined ? {} : { renamedFromName: wire.renamedFromName }),
+        ...(wire.reference === undefined ? {} : { reference: wire.reference }),
+        ...(wire.enumValues === undefined ? {} : { enumValues: wire.enumValues }),
+        ...(wire.backfillValue === undefined ? {} : { backfillValue: wire.backfillValue }),
+    });
 }
 function deserializeTable(wire) {
-    return table(wire.name, Object.fromEntries(Object.entries(wire.columns).map(([name, columnDefinition]) => [
+    const columns = Object.fromEntries(Object.entries(wire.columns).map(([name, columnDefinition]) => [
         name,
         deserializeColumn(columnDefinition),
-    ])), wire.checks === undefined ? {} : { checks: wire.checks.map((check) => ({ ...check })) });
+    ]));
+    const options = {
+        ...(wire.foreignKeys === undefined ? {} : { foreignKeys: structuredClone(wire.foreignKeys) }),
+        ...(wire.checks === undefined ? {} : { checks: wire.checks.map((check) => ({ ...check })) }),
+    };
+    return wire.primaryKey === undefined
+        ? table(wire.name, columns, options)
+        : table(wire.name, columns, { ...options, primaryKey: [...wire.primaryKey] });
 }
 export function deserializeSchema(wire) {
     return schema(wire.tables.map(deserializeTable), {
         views: (wire.views ?? []).map(deserializeView),
     });
 }
-//# sourceMappingURL=schema-wire.js.map

package/dist/engine/schema.d.ts

@@ -1,6 +1,6 @@
-import { type ColumnDefault, type TableColumnRecord, type TableRecord } from "../storage/index.js";
-import { type Catalog } from "./catalog.js";
-import { type BatchRow } from "./batch.js";
+import { type ColumnDefault, type SqlDomain, type TableColumnRecord, type TableRecord } from "../storage/types.js";
+import { type Catalog, type CatalogColumn, type CatalogTable } from "./catalog.js";
+import { type QueryValue } from "./query.js";
 /**
  * Typed schema DSL and catalog migration planning. Column builders carry compile-time value and
  * nullability types; `planMigration` diffs a schema against the live catalog into metadata-only
@@ -22,6 +22,16 @@ export interface TableCheck {
     readonly name: string;
     readonly sql: string;
 }
+/** A table-level relation, used when either side has a composite primary key. */
+export interface TableForeignKey<TColumnName extends string = string> {
+    readonly name: string;
+    readonly columns: readonly TColumnName[];
+    readonly references: {
+        readonly table: string;
+        readonly columns: readonly string[];
+    };
+    readonly onDelete?: ReferentialAction;
+}
 /**
  * The constraint name `migrate()` gives a declared relation. It matches the name the SQL parser
  * derives for an unnamed inline REFERENCES, so a table built either way has the same catalog.
@@ -34,43 +44,34 @@ export declare function foreignKeyName(tableName: string, columnName: string): s
 export type HasDefault<TValue> = TValue & {
     readonly __minnowHasDefault?: true;
 };
-/**
- * The public name for the flavor, for hand-declared `DB` interfaces (the Kysely convention).
- * `InferDatabase` applies it automatically from the schema; write it yourself only when you
- * declare the row types by hand and want generated columns to stay omissible on insert:
- *
- * ```ts
- * interface DB {
- *   notes: { id: Generated<number>; slug: Generated<string>; body: string };
- * }
- * ```
- */
-export type Generated<TValue> = HasDefault<TValue>;
-export interface ColumnBuilder<TValue, TNullable extends boolean, TUnique extends boolean = false, THasDefault extends boolean = false> {
+export interface ColumnBuilder<TValue extends SchemaValue, TNullable extends boolean, TUnique extends boolean = false, THasDefault extends boolean = false, TInput extends SchemaValue = TValue> {
     readonly kind: "column";
     readonly type: SchemaColumnType;
     readonly isNullable: TNullable;
     readonly isUnique: TUnique;
     readonly hasDefault: THasDefault;
+    /** Type-only metadata consumed by adapters; optional so it emits no runtime payload. */
+    readonly "~types"?: {
+        readonly select: TValue;
+        readonly input: TInput;
+    };
+    /** True for exact SQL integer columns; ordinary number columns use Float64 semantics. */
+    readonly integer: boolean;
+    /** Logical SQL semantics layered over the stable string storage encoding. */
+    readonly sqlDomain?: SqlDomain;
     readonly defaultSpec?: ColumnDefault;
-    /**
-     * A userland default generator. Never persisted and never sent to the engine — the typed
-     * facade (`insertInto`, `typedTable`) calls it for omitted-or-null slots before the batch
-     * crosses the boundary, so untyped write paths (raw batches, SQL) do not see it.
-     */
-    readonly defaultFn?: () => TValue;
     /** Present on `column.enum()` builders: the closed set of values writes must draw from. */
     readonly enumValues?: readonly string[];
     /** What rows written before this column existed read as; see `.backfill()`. */
-    readonly backfillValue?: TValue | (() => TValue);
+    readonly backfillValue?: TInput | (() => TInput);
     readonly renamedFromName?: string;
     readonly reference?: ColumnReferenceSpec;
     /** Marks the column nullable; inserts may omit it and reads may return null. */
-    nullable(): ColumnBuilder<TValue, true, TUnique, THasDefault>;
+    nullable(): ColumnBuilder<TValue, true, TUnique, THasDefault, TInput>;
     /** Marks the table's unique key; exactly one non-nullable column may carry it. */
-    unique(): ColumnBuilder<TValue, TNullable, true, THasDefault>;
+    unique(this: ColumnBuilder<TValue, false, TUnique, THasDefault, TInput>): ColumnBuilder<TValue, TNullable, true, THasDefault, TInput>;
     /** Declares this column as the rename target of an existing catalog column. */
-    renamedFrom(name: string): ColumnBuilder<TValue, TNullable, TUnique, THasDefault>;
+    renamedFrom(name: string): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
     /**
      * What rows written before this column existed read as, instead of NULL. Giving one is what
      * makes adding a non-nullable column possible: no stored byte is rewritten, and reads
@@ -80,7 +81,7 @@ export interface ColumnBuilder<TValue, TNullable extends boolean, TUnique extend
      * catalog — so it can derive a value (a timestamp, a version stamp) without readers ever
      * disagreeing. It cannot derive from other columns; that would need a value per row.
      */
-    backfill(value: TValue | (() => TValue)): ColumnBuilder<TValue, TNullable, TUnique, THasDefault>;
+    backfill(this: ColumnBuilder<TValue, false, TUnique, THasDefault, TInput>, value: TInput | (() => TInput)): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
     /**
      * Declares a FOREIGN KEY onto another table's unique key. `migrate()` creates it as a real
      * constraint, so a write naming a parent row that does not exist is rejected — the same
@@ -88,39 +89,75 @@ export interface ColumnBuilder<TValue, TNullable extends boolean, TUnique extend
      *
      * `onDelete` defaults to `"restrict"`. `"set null"` requires a nullable column.
      */
-    references(table: string, column: string, options?: {
-        onDelete?: ReferentialAction;
-    }): ColumnBuilder<TValue, TNullable, TUnique, THasDefault>;
+    references(this: ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>, table: string, column: string, options?: {
+        onDelete?: Exclude<ReferentialAction, "set null">;
+    }): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
+    references(this: ColumnBuilder<TValue, true, TUnique, THasDefault, TInput>, table: string, column: string, options: {
+        onDelete: "set null";
+    }): ColumnBuilder<TValue, TNullable, TUnique, THasDefault, TInput>;
+    /** Declares a literal SQL default. Omission or SQL `DEFAULT` invokes it; NULL does not. */
+    default(value: TInput): ColumnBuilder<TValue, TNullable, TUnique, true, TInput>;
     /**
-     * Fills null-or-absent slots at insert time. Requires a non-nullable column.
-     *
-     * A plain value persists in the catalog and fills inside the engine, so every write path
-     * gets it — raw batches, SQL statements, other tabs. Datetime columns accept only "now",
-     * which stamps one consistent timestamp per batch.
-     *
-     * A function is a userland generator (`() => ulid()`): the typed facade calls it just
-     * before the batch is sent, so it never persists and never crosses the worker boundary —
-     * and write paths that don't go through the facade don't see it.
+     * Declares a variable-free SQL default expression, such as `CURRENT_TIMESTAMP`,
+     * `gen_random_uuid()`, or `nextval('orders_id_seq')`. The engine parses and type-checks it
+     * before migration and evaluates it once per omitted row.
      */
-    default(value: (TValue extends Date ? "now" : TValue) | (() => TValue)): ColumnBuilder<TValue, TNullable, TUnique, true>;
+    defaultSql(sql: string): ColumnBuilder<TValue, TNullable, TUnique, true, TInput>;
     /**
-     * Generates monotonically increasing integers for null-or-absent slots from a persistent
+     * Generates monotonically increasing integers for omitted or SQL `DEFAULT` slots from a persistent
      * per-table counter that is atomic across tabs. Explicit values are allowed and bump the
      * counter past their maximum. Number unique-key columns only.
      */
-    autoIncrement: TValue extends number ? () => ColumnBuilder<TValue, TNullable, TUnique, true> : never;
+    autoIncrement: TValue extends number ? (this: ColumnBuilder<TValue, false, true, THasDefault, TInput>) => ColumnBuilder<TValue, TNullable, TUnique, true, TInput> : never;
+}
+type SchemaValue = boolean | number | string | Date;
+/**
+ * Metadata shared by every concrete ColumnBuilder. Schema collections need an existential
+ * column type: including fluent methods here would make TValue invariant because those methods
+ * both consume and return it. Public inference still retains each concrete builder in TColumns.
+ */
+interface AnyColumn {
+    readonly kind: "column";
+    readonly type: SchemaColumnType;
+    readonly isNullable: boolean;
+    readonly isUnique: boolean;
+    readonly hasDefault: boolean;
+    readonly integer: boolean;
+    readonly sqlDomain?: SqlDomain;
+    readonly defaultSpec?: ColumnDefault;
+    readonly enumValues?: readonly string[];
+    readonly backfillValue?: SchemaValue | (() => SchemaValue);
+    readonly renamedFromName?: string;
+    readonly reference?: ColumnReferenceSpec;
 }
-type AnyColumn = ColumnBuilder<boolean | number | string | Date, boolean, boolean, boolean>;
 /**
  * Rebuilds a column carrying an exact default spec — the wire layer's escape hatch, since the
- * public `.default()` interprets "now" on datetime columns and cannot express auto-increment.
+ * public `.default()` accepts literals and cannot express auto-increment catalog metadata.
  */
-export declare function columnWithDefaultSpec(base: Pick<AnyColumn, "type" | "isNullable" | "isUnique" | "renamedFromName" | "reference" | "enumValues">, spec: ColumnDefault): AnyColumn;
+export declare function columnWithDefaultSpec(base: Pick<AnyColumn, "type" | "isNullable" | "isUnique" | "renamedFromName" | "reference" | "enumValues"> & Partial<Pick<AnyColumn, "integer" | "sqlDomain">>, spec: ColumnDefault): AnyColumn;
+/** Rebuilds a fluent column from structured-clone-safe metadata. */
+export declare function columnFromState(state: Pick<AnyColumn, "type" | "isNullable" | "isUnique"> & Partial<Pick<AnyColumn, "integer" | "sqlDomain" | "renamedFromName" | "reference" | "defaultSpec" | "enumValues" | "backfillValue">>): AnyColumn;
 export declare const column: {
-    boolean: () => ColumnBuilder<boolean, false, false, false>;
-    number: () => ColumnBuilder<number, false, false, false>;
-    string: () => ColumnBuilder<string, false, false, false>;
-    datetime: () => ColumnBuilder<Date, false, false, false>;
+    boolean: () => ColumnBuilder<boolean, false, false, false, boolean>;
+    number: () => ColumnBuilder<number, false, false, false, number>;
+    /** Exact safe-integer semantics, matching SQL INTEGER/SMALLINT/BIGINT. */
+    integer: () => ColumnBuilder<number, false, false, false, number>;
+    string: () => ColumnBuilder<string, false, false, false, string>;
+    datetime: () => ColumnBuilder<Date, false, false, false, Date>;
+    /** Exact decimal SQL NUMERIC. Selects return strings; writes accept strings or numbers. */
+    numeric: (options?: {
+        precision?: number;
+        scale?: number;
+    }) => ColumnBuilder<string, false, false, false, string | number>;
+    json: () => ColumnBuilder<string, false, false, false, string>;
+    jsonb: () => ColumnBuilder<string, false, false, false, string>;
+    uuid: () => ColumnBuilder<string, false, false, false, string>;
+    time: () => ColumnBuilder<string, false, false, false, string>;
+    interval: () => ColumnBuilder<string, false, false, false, string>;
+    /** JSON array text at the JavaScript boundary, with the SQL element type retained in metadata. */
+    array: (element: string) => ColumnBuilder<string, false, false, false, string>;
+    /** A named SQL enum domain, distinct from the lightweight `column.enum()` restriction. */
+    sqlEnum: <const TValues extends readonly [string, ...string[]]>(name: string, values: TValues) => ColumnBuilder<TValues[number], false>;
     /**
      * A string column restricted to a closed set of values, typed as their literal union:
      *
@@ -135,11 +172,13 @@ export declare const column: {
      */
     enum: <const TValues extends readonly [string, ...string[]]>(values: TValues) => ColumnBuilder<TValues[number], false>;
 };
-export interface TableSchema<TColumns extends Record<string, AnyColumn>, TName extends string = string> {
+/** Runtime table shape accepted by schema collections without erasing concrete table inference. */
+export interface AnyTable {
     readonly kind: "table";
-    readonly name: TName;
-    readonly columns: TColumns;
-    /** Row conditions every write must satisfy; empty when none were declared. */
+    readonly name: string;
+    readonly columns: Record<string, AnyColumn>;
+    readonly primaryKey: readonly string[];
+    readonly foreignKeys: readonly TableForeignKey[];
     readonly checks: readonly TableCheck[];
     /** Standard Schema-compatible runtime validator for one insert row. */
     readonly "~standard": {
@@ -155,8 +194,21 @@ export interface TableSchema<TColumns extends Record<string, AnyColumn>, TName e
         };
     };
 }
-export type AnyTable = TableSchema<Record<string, AnyColumn>>;
-export interface TableOptions {
+export interface TableSchema<TColumns extends Record<string, AnyColumn>, TName extends string = string, TPrimaryKey extends ReadonlyArray<keyof TColumns & string> = readonly []> extends AnyTable {
+    readonly name: TName;
+    readonly columns: TColumns;
+    /** Ordered table-level primary key. Empty when `.unique()` owns the scalar identity. */
+    readonly primaryKey: TPrimaryKey;
+    /** Table-level relations, including composite FOREIGN KEY declarations. */
+    readonly foreignKeys: ReadonlyArray<TableForeignKey<keyof TColumns & string>>;
+    /** Row conditions every write must satisfy; empty when none were declared. */
+    readonly checks: readonly TableCheck[];
+}
+export interface TableOptions<TColumns extends Record<string, AnyColumn> = Record<string, AnyColumn>, TPrimaryKey extends ReadonlyArray<keyof TColumns & string> = readonly []> {
+    /** Ordered PRIMARY KEY columns. Use `.unique()` for the existing scalar shorthand. */
+    readonly primaryKey?: TPrimaryKey;
+    /** Table-level relations; required for composite FOREIGN KEYs. */
+    readonly foreignKeys?: ReadonlyArray<TableForeignKey<keyof TColumns & string>>;
     /**
      * Row conditions every write must satisfy (E141-06), each a boolean SQL expression over this
      * table's own columns — the declarative form of `CONSTRAINT name CHECK (sql)`. The engine
@@ -165,7 +217,12 @@ export interface TableOptions {
      */
     readonly checks?: readonly TableCheck[];
 }
-export declare function table<const TName extends string, TColumns extends Record<string, AnyColumn>>(name: TName, columns: TColumns, options?: TableOptions): TableSchema<TColumns, TName>;
+export declare function table<const TName extends string, TColumns extends Record<string, AnyColumn>, const TPrimaryKey extends ReadonlyArray<keyof TColumns & string>>(name: TName, columns: TColumns, options: TableOptions<TColumns, TPrimaryKey> & {
+    readonly primaryKey: TPrimaryKey;
+}): TableSchema<TColumns, TName, TPrimaryKey>;
+export declare function table<const TName extends string, TColumns extends Record<string, AnyColumn>>(name: TName, columns: TColumns, options?: Omit<TableOptions<TColumns>, "primaryKey"> & {
+    readonly primaryKey?: never;
+}): TableSchema<TColumns, TName>;
 /**
  * The FOREIGN KEY constraints a table declares, in column order. This is the single derivation
  * of "what relations does this table have" — `planMigration` diffs against it and `migrate()`
@@ -173,9 +230,9 @@ export declare function table<const TName extends string, TColumns extends Recor
  */
 export declare function declaredForeignKeys(definition: AnyTable): Array<{
     name: string;
-    column: string;
+    columns: string[];
     parentTable: string;
-    parentColumn: string;
+    parentColumns: string[];
     onDelete: ReferentialAction;
 }>;
 /**
@@ -217,7 +274,14 @@ export interface SchemaDefinition<TTables extends readonly AnyTable[], TViews ex
 export declare function schema<TTables extends readonly AnyTable[], TViews extends readonly AnyView[] = []>(tables: TTables, options?: {
     views?: TViews;
 }): SchemaDefinition<TTables, TViews>;
-type ColumnValue<TColumn> = TColumn extends ColumnBuilder<infer TValue, infer TNullable, boolean, infer THasDefault> ? THasDefault extends true ? HasDefault<TNullable extends true ? TValue | null : TValue> : TNullable extends true ? TValue | null : TValue : never;
+type ColumnTypeMetadata<TColumn> = TColumn extends {
+    readonly "~types"?: infer TMetadata extends {
+        readonly select: unknown;
+        readonly input: unknown;
+    };
+} ? NonNullable<TMetadata> : never;
+type ColumnValue<TColumn extends AnyColumn> = TColumn["isNullable"] extends true ? ColumnTypeMetadata<TColumn>["select"] | null : ColumnTypeMetadata<TColumn>["select"];
+type ColumnInputValue<TColumn extends AnyColumn> = TColumn["isNullable"] extends true ? ColumnTypeMetadata<TColumn>["input"] | null : ColumnTypeMetadata<TColumn>["input"];
 /** The complete row shape a read returns. */
 export type InferRow<TTable extends AnyTable> = {
     [K in keyof TTable["columns"]]: ColumnValue<TTable["columns"][K]>;
@@ -237,16 +301,22 @@ type DefaultKeys<TTable extends AnyTable> = {
 }[keyof TTable["columns"]];
 type OptionalInsertKeys<TTable extends AnyTable> = NullableKeys<TTable> | DefaultKeys<TTable>;
 /** Insert rows require every non-nullable column and may omit nullable or default-bearing ones. */
-export type InferInsertRow<TTable extends AnyTable> = Omit<InferRow<TTable>, OptionalInsertKeys<TTable>> & {
-    [K in OptionalInsertKeys<TTable>]?: ColumnValue<TTable["columns"][K]>;
+export type InferInsertRow<TTable extends AnyTable> = Omit<{
+    [K in keyof TTable["columns"]]: ColumnInputValue<TTable["columns"][K]>;
+}, OptionalInsertKeys<TTable>> & {
+    [K in OptionalInsertKeys<TTable>]?: ColumnInputValue<TTable["columns"][K]>;
 };
+/** Scalar `.unique()` keys plus columns named by a table-level primary key. */
+export type PrimaryKeyKeys<TTable extends AnyTable> = {
+    [K in keyof TTable["columns"]]: TTable["columns"][K]["isUnique"] extends true ? K : never;
+}[keyof TTable["columns"]] | TTable["primaryKey"][number];
 /**
  * Update changes may cover any column except the unique key. An explicit `undefined` entry is
  * allowed and means "leave this column untouched", so a spread-patch built from optional fields
  * stays assignable under `exactOptionalPropertyTypes`.
  */
 export type InferUpdateChanges<TTable extends AnyTable> = {
-    [K in keyof TTable["columns"] as TTable["columns"][K]["isUnique"] extends true ? never : K]?: ColumnValue<TTable["columns"][K]> | undefined;
+    [K in keyof TTable["columns"] as K extends PrimaryKeyKeys<TTable> ? never : K]?: ColumnInputValue<TTable["columns"][K]> | undefined;
 };
 export type MigrationStep = {
     kind: "create-table";
@@ -332,6 +402,12 @@ export interface MigrationPlan {
 export declare function isDestructiveStep(step: MigrationStep): step is Extract<MigrationStep, {
     kind: "drop-column" | "drop-table";
 }>;
+/**
+ * A column can stop being projected without rewriting anything, but not while something else in
+ * the catalog still points at it. Each of these would leave a constraint or key referring to a
+ * column no longer there, so the drop is refused rather than silently invalidating them.
+ */
+export declare function assertColumnDroppable(record: CatalogTable, column: CatalogColumn): void;
 /**
  * Diffs the live catalog against a schema into metadata-only steps, in a deterministic order.
  * Anything unprovable fails explicitly: type changes, dropped columns, unique-key changes,
@@ -351,44 +427,44 @@ export interface PlanMigrationOptions {
     readonly schemaOwnsDatabase?: boolean;
 }
 export declare function planMigration(catalog: Catalog, definition: SchemaDefinition<readonly AnyTable[]>, options?: PlanMigrationOptions): MigrationPlan;
-type UniqueKeyValue<TTable extends AnyTable> = {
+type ScalarUniqueKeyValue<TTable extends AnyTable> = {
     [K in keyof TTable["columns"]]: TTable["columns"][K]["isUnique"] extends true ? ColumnValue<TTable["columns"][K]> : never;
 }[keyof TTable["columns"]];
+type DeclaredPrimaryKeyValue<TTable extends AnyTable> = {
+    [K in TTable["primaryKey"][number]]: ColumnValue<TTable["columns"][K]>;
+};
+/** Scalar keys stay scalar; composite keys are objects keyed by their declared column names. */
+export type PrimaryKeyValue<TTable extends AnyTable> = TTable["primaryKey"] extends readonly [] ? ScalarUniqueKeyValue<TTable> : TTable["primaryKey"] extends readonly [infer TOnly extends keyof TTable["columns"]] ? ColumnValue<TTable["columns"][TOnly]> : DeclaredPrimaryKeyValue<TTable>;
 type ColumnArrays<TShape> = {
     [K in keyof TShape]: ReadonlyArray<TShape[K]>;
 };
 interface TypedTableDatabase {
-    insertBatch(tableName: string, rows: readonly BatchRow[]): Promise<unknown>;
-    upsertBatch(tableName: string, rows: readonly BatchRow[]): Promise<unknown>;
-    updateBatch(tableName: string, input: {
-        keys: readonly unknown[];
-        changes: Readonly<Record<string, readonly unknown[]>>;
-    }): Promise<unknown>;
-    deleteBatch(tableName: string, input: {
-        keys: readonly unknown[];
-    }): Promise<unknown>;
-    readTable(tableName: string, options?: {
-        columns?: readonly string[];
-    }): Promise<Array<Record<string, unknown>>>;
+    execute(sql: string, params?: readonly QueryValue[]): Promise<unknown>;
+    query(sql: string, options?: {
+        params?: readonly QueryValue[];
+    }): Promise<{
+        rows: Array<Record<string, unknown>>;
+    }>;
 }
 /**
- * A thin, fully typed handle over the existing batch APIs: inserts require every non-nullable
- * column, updates exclude the unique key, and reads return the complete inferred row shape.
+ * A thin, fully typed SQL handle: inserts require every non-nullable column, updates exclude the
+ * unique key, and reads return the complete inferred row shape. Every operation is rendered as
+ * parameterized SQL and goes through the parser/planner/executor; this helper has no private
+ * batch or table-read semantics that can drift from SQL.
  */
 export declare function typedTable<TTable extends AnyTable>(database: TypedTableDatabase, definition: TTable): {
     definition: TTable;
     insert(rows: ReadonlyArray<InferInsertRow<TTable>>): Promise<unknown>;
     upsert(rows: ReadonlyArray<InferInsertRow<TTable>>): Promise<unknown>;
     update(input: {
-        keys: ReadonlyArray<UniqueKeyValue<TTable>>;
+        keys: ReadonlyArray<PrimaryKeyValue<TTable>>;
         changes: Partial<ColumnArrays<InferUpdateChanges<TTable>>>;
     }): Promise<unknown>;
     delete(input: {
-        keys: ReadonlyArray<UniqueKeyValue<TTable>>;
+        keys: ReadonlyArray<PrimaryKeyValue<TTable>>;
     }): Promise<unknown>;
     rows(): Promise<Array<InferRow<TTable>>>;
 };
 /** Applies one table's alteration steps onto its current column records. */
 export declare function applyColumnSteps(record: TableRecord, steps: readonly MigrationStep[], createId: () => string): TableColumnRecord[];
 export {};
-//# sourceMappingURL=schema.d.ts.map