qubu 0.0.0 → 0.3.4

package/dist/complete-types-BdFqUfbb.d.mts

@@ -0,0 +1,371 @@
+import { A as SnapshotStorage, D as SnapshotLiteral, O as SnapshotNamingPolicy, T as SnapshotJsonValue, b as SnapshotGeneratedColumn, d as SnapshotDefault, f as SnapshotDiagnostic, g as SnapshotExpression, h as SnapshotDialectExtension, i as SchemaSnapshotInput, m as SnapshotDialect } from "./types-4Q076HKo.mjs";
+//#region src/snapshot/complete-types.d.ts
+/** The stable envelope tag shared by Snapshot v1 and the complete model. */
+declare const completeSchemaSnapshotFormat: "qubu-schema";
+/** The strict format version for the complete catalog/object model. */
+declare const completeSchemaSnapshotVersion: 2;
+/** Descriptive alias for consumers that select a numbered snapshot version. */
+declare const schemaSnapshotV2Version: 2;
+/** Explicit format-version aliases for generated tooling and fixtures. */
+declare const schemaSnapshotCompleteVersion: 2;
+declare const schemaSnapshotVersion2: 2;
+/** Object families that may appear in a complete canonical snapshot. */
+type CompleteSnapshotObjectKind = 'namespace' | 'table' | 'column' | 'constraint' | 'index' | 'view' | 'materialized-view' | 'sequence' | 'enum' | 'domain' | 'collation' | 'trigger' | 'routine' | 'partition' | 'policy' | 'extension' | 'comment' | 'ownership' | 'deferred-object' | 'opaque-object';
+/** A stable logical object reference used by complete snapshot relations. */
+interface CompleteSnapshotObjectReference {
+  readonly kind: Exclude<CompleteSnapshotObjectKind, 'namespace'>;
+  readonly id: string;
+}
+/** Source evidence retained without persisting a database catalog key. */
+interface CompleteSnapshotProvenance {
+  readonly kind: 'catalog' | 'decompiler' | 'create-sql';
+  readonly dialect: string;
+  readonly path?: readonly (string | number)[];
+}
+/** Physical-name evidence retained without ephemeral catalog identity keys. */
+interface CompleteSnapshotPhysicalReference {
+  readonly kind: CompleteSnapshotObjectKind;
+  readonly namespace?: string;
+  readonly table?: string;
+  readonly name: string;
+}
+/** Namespace identity and selected physical boundary for a snapshot. */
+interface CompleteSnapshotNamespace extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'postgres-schema' | 'sqlite-database' | 'mysql-database';
+  readonly name: string;
+}
+/** Capability facts reported by the adapter that produced the snapshot. */
+interface CompleteSnapshotCapabilities {
+  readonly generatedColumns: boolean;
+  readonly identityMetadata: boolean;
+  readonly checkConstraints: boolean;
+  readonly checkConstraintEnforcement: 'enforced' | 'metadata-only' | 'unknown';
+  readonly expressionDecompilation: boolean;
+  readonly indexExpressions: boolean;
+  readonly indexPredicates: boolean;
+  readonly indexIncludedColumns: boolean;
+  readonly namespaces: boolean;
+  readonly visibility: 'complete' | 'limited' | 'unknown';
+  readonly [capability: string]: boolean | string;
+}
+/** Metadata common to every complete snapshot object. */
+interface CompleteSnapshotObjectMetadata {
+  readonly provenance?: CompleteSnapshotProvenance;
+  readonly physicalReference?: CompleteSnapshotPhysicalReference;
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A complete snapshot column, including physical ordinal evidence. */
+interface CompleteSnapshotColumn extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'column';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly ordinalPosition: number;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly storage?: SnapshotStorage;
+  readonly default?: SnapshotDefault;
+  readonly generatedColumn?: SnapshotGeneratedColumn;
+  readonly identity?: CompleteSnapshotIdentity;
+  readonly onUpdate?: SnapshotExpression;
+}
+/** A richer identity declaration retained beside a column or sequence. */
+interface CompleteSnapshotIdentity extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'identity';
+  readonly generation: 'always' | 'by-default';
+  readonly options: Readonly<Record<string, CompleteSnapshotValueFact>>;
+}
+/** A literal or opaque expression value in complete object metadata. */
+type CompleteSnapshotValueFact = {
+  readonly kind: 'literal';
+  readonly value: SnapshotLiteral;
+} | {
+  readonly kind: 'expression';
+  readonly expression: SnapshotExpression;
+};
+/** An ordered column or expression term in a complete index. */
+type CompleteSnapshotIndexTerm = {
+  readonly kind: 'column';
+  readonly column: string;
+  readonly position: number;
+  readonly direction?: 'ASC' | 'DESC';
+  readonly nulls?: 'FIRST' | 'LAST';
+  readonly prefixLength?: CompleteSnapshotValueFact;
+  readonly operatorClass?: string;
+} | {
+  readonly kind: 'expression';
+  readonly expression: SnapshotExpression;
+  readonly position: number;
+  readonly direction?: 'ASC' | 'DESC';
+  readonly nulls?: 'FIRST' | 'LAST';
+  readonly operatorClass?: string;
+};
+/** A complete index with engine-specific method and included-column facts. */
+interface CompleteSnapshotIndex extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'index';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly terms: readonly CompleteSnapshotIndexTerm[];
+  readonly unique: boolean;
+  readonly candidateKey: boolean;
+  readonly predicate?: SnapshotExpression;
+  readonly includedColumns?: readonly string[];
+  readonly backingConstraint?: CompleteSnapshotObjectReference;
+  readonly method?: string;
+}
+/** A key or uniqueness constraint in a complete table. */
+interface CompleteSnapshotKeyConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'primary-key' | 'unique' | 'unique-constraint';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly nulls?: 'distinct' | 'not-distinct';
+  readonly backingIndex?: CompleteSnapshotObjectReference;
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly validated?: boolean;
+}
+/** A foreign key with explicit target object identity and actions. */
+interface CompleteSnapshotForeignKey extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'foreign-key';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly target: {
+    readonly table: CompleteSnapshotObjectReference;
+    readonly columns: readonly string[];
+  };
+  readonly onUpdate?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
+  readonly onDelete?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
+  readonly match?: 'simple' | 'full' | 'partial';
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly validated?: boolean;
+}
+/** A check constraint whose expression remains tagged data. */
+interface CompleteSnapshotCheckConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'check';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly expression: SnapshotExpression;
+  readonly deferrable?: boolean;
+  readonly initially?: 'immediate' | 'deferred';
+  readonly validated?: boolean;
+}
+/** Every constraint represented by the complete neutral snapshot model. */
+type CompleteSnapshotConstraint = CompleteSnapshotKeyConstraint | CompleteSnapshotForeignKey | CompleteSnapshotCheckConstraint;
+/** A complete table record keyed by stable logical identity. */
+interface CompleteSnapshotTable extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'table';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly constraints: readonly CompleteSnapshotConstraint[];
+  readonly indexes: readonly CompleteSnapshotIndex[];
+}
+/** A view or materialized-view declaration and its output columns. */
+interface CompleteSnapshotView extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'view' | 'materialized-view';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly definition: SnapshotExpression;
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+  readonly checkOption?: 'none' | 'local' | 'cascaded';
+  readonly securityBarrier?: boolean;
+  readonly securityInvoker?: boolean;
+}
+/** A sequence and its exact option facts. */
+interface CompleteSnapshotSequence extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'sequence';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage?: SnapshotStorage;
+  readonly start?: CompleteSnapshotValueFact;
+  readonly increment?: CompleteSnapshotValueFact;
+  readonly minimum?: CompleteSnapshotValueFact;
+  readonly maximum?: CompleteSnapshotValueFact;
+  readonly cache?: CompleteSnapshotValueFact;
+  readonly cycle?: boolean;
+  readonly ownedBy?: CompleteSnapshotObjectReference;
+  readonly identity?: CompleteSnapshotIdentity;
+}
+/** An ordered enum declaration. */
+interface CompleteSnapshotEnum extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'enum';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly values: readonly {
+    readonly value: string;
+    readonly ordinalPosition: number;
+    readonly provenance?: CompleteSnapshotProvenance;
+  }[];
+}
+/** A domain declaration and its base type constraints. */
+interface CompleteSnapshotDomain extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'domain';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage: SnapshotStorage;
+  readonly nullable?: boolean;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly constraints?: readonly CompleteSnapshotCheckConstraint[];
+}
+/** Collation behavior that can affect deterministic schema comparison. */
+interface CompleteSnapshotCollation extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'collation';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly provider?: string;
+  readonly locale?: string;
+  readonly deterministic?: boolean;
+  readonly version?: string;
+}
+/** Trigger declaration attached to a table or view. */
+interface CompleteSnapshotTrigger extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'trigger';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly timing: 'before' | 'after' | 'instead-of' | 'unknown';
+  readonly events: readonly ('insert' | 'update' | 'delete' | 'truncate')[];
+  readonly orientation?: 'row' | 'statement';
+  readonly condition?: SnapshotExpression;
+  readonly body: SnapshotExpression;
+  readonly enabled?: boolean;
+}
+/** Routine argument declaration. */
+interface CompleteSnapshotRoutineParameter {
+  readonly name?: string;
+  readonly mode?: 'in' | 'out' | 'inout' | 'variadic' | 'table';
+  readonly storage: SnapshotStorage;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly ordinalPosition: number;
+}
+/** Function, procedure, aggregate, or window routine declaration. */
+interface CompleteSnapshotRoutine extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'routine';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly routineKind: 'function' | 'procedure' | 'aggregate' | 'window' | 'unknown';
+  readonly parameters: readonly CompleteSnapshotRoutineParameter[];
+  readonly returnType?: SnapshotStorage;
+  readonly language?: string;
+  readonly body?: SnapshotExpression;
+  readonly volatility?: 'immutable' | 'stable' | 'volatile' | 'unknown';
+  readonly parallel?: 'safe' | 'restricted' | 'unsafe' | 'unknown';
+  readonly security?: 'invoker' | 'definer' | 'unknown';
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+}
+/** A partition child, its parent, and normalized bound expression. */
+interface CompleteSnapshotPartition extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'partition';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly parent: CompleteSnapshotObjectReference;
+  readonly strategy: 'range' | 'list' | 'hash' | 'reference' | 'unknown';
+  readonly keyColumns?: readonly string[];
+  readonly bound?: SnapshotExpression;
+  readonly default?: boolean;
+}
+/** A row-level security policy attached to a table. */
+interface CompleteSnapshotPolicy extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'policy';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly command: 'all' | 'select' | 'insert' | 'update' | 'delete' | 'unknown';
+  readonly roles?: readonly string[];
+  readonly permissive?: boolean;
+  readonly using?: SnapshotExpression;
+  readonly check?: SnapshotExpression;
+}
+/** An extension object with a typed, versioned payload. */
+interface CompleteSnapshotExtension extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'extension';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly extensionName: string;
+  readonly extensionVersion?: string;
+  readonly schema?: string;
+  readonly data: SnapshotJsonValue;
+  readonly configuration?: SnapshotJsonValue;
+}
+/** A deferred object retained as a reviewable, non-lossy boundary record. */
+interface CompleteSnapshotDeferredObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'deferred-object';
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly reason?: string;
+  readonly data?: SnapshotJsonValue;
+}
+/** An opaque object observed by an adapter but not yet structurally modeled. */
+interface CompleteSnapshotOpaqueObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'opaque-object';
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly data: SnapshotJsonValue;
+  readonly sql?: SnapshotExpression;
+}
+/** A comment attached to a stable logical object. */
+interface CompleteSnapshotComment extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'comment';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly text: string;
+}
+/** Ownership metadata attached to a stable logical object. */
+interface CompleteSnapshotOwnership extends CompleteSnapshotObjectMetadata {
+  readonly kind: 'ownership';
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly owner: string;
+}
+/** Every complete snapshot object family, including retained boundaries. */
+type CompleteSnapshotObject = CompleteSnapshotTable | CompleteSnapshotView | CompleteSnapshotSequence | CompleteSnapshotEnum | CompleteSnapshotDomain | CompleteSnapshotCollation | CompleteSnapshotTrigger | CompleteSnapshotRoutine | CompleteSnapshotPartition | CompleteSnapshotPolicy | CompleteSnapshotExtension | CompleteSnapshotDeferredObject | CompleteSnapshotOpaqueObject | CompleteSnapshotComment | CompleteSnapshotOwnership;
+/** The immutable strict Snapshot v2 envelope. */
+interface CompleteSchemaSnapshot {
+  readonly format: typeof completeSchemaSnapshotFormat;
+  readonly version: typeof completeSchemaSnapshotVersion;
+  readonly dialect: SnapshotDialect;
+  readonly namingPolicy: SnapshotNamingPolicy;
+  readonly namespace: CompleteSnapshotNamespace;
+  readonly capabilities: CompleteSnapshotCapabilities;
+  readonly tables: readonly CompleteSnapshotTable[];
+  readonly views: readonly CompleteSnapshotView[];
+  readonly sequences: readonly CompleteSnapshotSequence[];
+  readonly enums: readonly CompleteSnapshotEnum[];
+  readonly domains: readonly CompleteSnapshotDomain[];
+  readonly collations: readonly CompleteSnapshotCollation[];
+  readonly triggers: readonly CompleteSnapshotTrigger[];
+  readonly routines: readonly CompleteSnapshotRoutine[];
+  readonly partitions: readonly CompleteSnapshotPartition[];
+  readonly policies: readonly CompleteSnapshotPolicy[];
+  readonly extensions: readonly CompleteSnapshotExtension[];
+  readonly deferredObjects: readonly CompleteSnapshotDeferredObject[];
+  readonly opaqueObjects: readonly CompleteSnapshotOpaqueObject[];
+  readonly comments: readonly CompleteSnapshotComment[];
+  readonly ownership: readonly CompleteSnapshotOwnership[];
+}
+/** Input accepted by the strict complete snapshot encoder. */
+type CompleteSchemaSnapshotInput = CompleteSchemaSnapshot | SchemaSnapshotInput | Readonly<Record<string, unknown>>;
+/** A complete snapshot decoder result with immutable successful output. */
+type CompleteSnapshotDecodeResult = {
+  readonly ok: true;
+  readonly value: CompleteSchemaSnapshot;
+} | {
+  readonly ok: false;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+};
+/** A complete snapshot creation result with immutable successful output. */
+type CompleteSnapshotCreateResult = CompleteSnapshotDecodeResult;
+/** v2 aliases kept explicit for consumers that prefer numbered APIs. */
+type SchemaSnapshotV2 = CompleteSchemaSnapshot;
+type SchemaSnapshotV2Input = CompleteSchemaSnapshotInput;
+type SchemaSnapshotV2DecodeResult = CompleteSnapshotDecodeResult;
+//#endregion
+export { CompleteSnapshotProvenance as A, SchemaSnapshotV2Input as B, CompleteSnapshotObjectMetadata as C, CompleteSnapshotPartition as D, CompleteSnapshotOwnership as E, CompleteSnapshotTrigger as F, schemaSnapshotVersion2 as G, completeSchemaSnapshotVersion as H, CompleteSnapshotValueFact as I, CompleteSnapshotView as L, CompleteSnapshotRoutineParameter as M, CompleteSnapshotSequence as N, CompleteSnapshotPhysicalReference as O, CompleteSnapshotTable as P, SchemaSnapshotV2 as R, CompleteSnapshotObjectKind as S, CompleteSnapshotOpaqueObject as T, schemaSnapshotCompleteVersion as U, completeSchemaSnapshotFormat as V, schemaSnapshotV2Version as W, CompleteSnapshotIndex as _, CompleteSnapshotCollation as a, CompleteSnapshotNamespace as b, CompleteSnapshotConstraint as c, CompleteSnapshotDeferredObject as d, CompleteSnapshotDomain as f, CompleteSnapshotIdentity as g, CompleteSnapshotForeignKey as h, CompleteSnapshotCheckConstraint as i, CompleteSnapshotRoutine as j, CompleteSnapshotPolicy as k, CompleteSnapshotCreateResult as l, CompleteSnapshotExtension as m, CompleteSchemaSnapshotInput as n, CompleteSnapshotColumn as o, CompleteSnapshotEnum as p, CompleteSnapshotCapabilities as r, CompleteSnapshotComment as s, CompleteSchemaSnapshot as t, CompleteSnapshotDecodeResult as u, CompleteSnapshotIndexTerm as v, CompleteSnapshotObjectReference as w, CompleteSnapshotObject as x, CompleteSnapshotKeyConstraint as y, SchemaSnapshotV2DecodeResult as z };

package/dist/core.d.mts

@@ -0,0 +1,33 @@
+import { $ as PaginationKind, $l as SubqueryMeta, Al as HasSubquery, B as CastTarget, Bl as ProvidesOuterSourceMeta, Cl as ExpressionMeta, Cu as SqlTypeSatisfies, Dl as GroupingKeysOf, Do as RenderedQuery, El as GroupingDependenciesOf, Eo as RenderOptions, Fi as SelectClause, Fl as NullabilityOf, G as DialectJson, Gl as RequiresCapabilityMeta, H as DialectCapability, Hl as QueryCardinality, Il as NullableSourceMeta, J as DialectRowLocking, Jl as RequiresOuterOf, K as DialectOptions, Kl as RequiresOf, Ll as NullableSourcesOf, Ml as InheritedMetadata, Nl as InheritedMetadataOf, Ol as GroupingMeta, Oo as render, Pi as ClausePlacement, Pl as MetadataOf, Q as NamedCastTarget, Ql as SqlTypeOf, Rl as OutputOf, Sl as DependenciesOf, Su as SqlTimestamp, Tl as FragmentMeta, To as RenderCapabilityValidation, Tu as SqlUuid, U as DialectCastTypes, Ul as RenderContext, V as Dialect, Va as typedValue, Vl as ProvidesSourceMeta, W as DialectExplain, Wa as typedCast, Wl as RenderFunction, X as ExplainRenderOptions, Xl as RequiresSourceMeta, Y as ExplainFormat, Yl as RequiresOuterSourceMeta, Z as JsonScalarKind, Zl as ResultMeta, _l as AnyFragment, _u as SqlOrderCompatible, at as SchemaLiteralRenderer, au as sequence, bl as CardinalityMeta, bu as SqlText, ct as resolveCastTarget, cu as SqlBinary, dl as isExpression, du as SqlDecimal, el as expressionFragment, et as PaginationPart, eu as VisibleDependenciesOf, fl as makeExpression, fu as SqlEqualityComparable, gl as AggregateMeta, gu as SqlNumericLike, hl as AggregateDependenciesOf, hu as SqlJson, it as RowLockWaitPolicy, iu as parenthesize, jl as HasWindow, kl as HasAggregate, lu as SqlBoolean, ml as withDialectCapability, mu as SqlInteger, nt as PortableCastType, nu as fragment, ot as assertDialectCapability, ou as AnySqlType, pl as markExpressionCategory, pu as SqlEqualityCompatible, q as DialectPagination, ql as RequiresOuterMetadataOf, ra as typedCall, rl as Expression, rt as RowLockMode, ru as isFragment, st as createDialect, su as SqlBigInt, tt as PortableCastTarget, tu as WindowMeta, uu as SqlDate, vl as CapabilitiesOf, vu as SqlOrderable, wl as Fragment, wu as SqlUnknown, xl as CardinalityOf, xu as SqlTextLike, yl as CapabilityMetadataOf, yu as SqlSemanticType, zl as ProvidesOuterOf } from "./types-4Q076HKo.mjs";
+//#region src/core/primitives/compose.d.ts
+declare function commaSeparated<const TParts extends readonly AnyFragment[]>(parts: TParts): Fragment<InheritedMetadata<TParts[number]>>;
+declare function keyword<TPart extends AnyFragment | undefined>(value: string, part?: TPart): Fragment<TPart extends AnyFragment ? InheritedMetadata<TPart> : never>;
+//#endregion
+//#region src/core/primitives/identifier.d.ts
+declare function identifier(name: string): Fragment<never>;
+declare function qualifiedIdentifier(...parts: readonly string[]): Fragment<never>;
+//#endregion
+//#region src/core/primitives/parameter.d.ts
+declare function parameter<T>(_value: T): Fragment<never>;
+//#endregion
+//#region src/core/primitives/routine.d.ts
+/** Render a validated, unquoted SQL routine name such as `LOWER` or `app.fn`. */
+declare function routineName(name: string): Fragment<never>;
+//#endregion
+//#region src/core/primitives/syntax.d.ts
+/** Emit trusted SQL syntax. Never pass user data to this primitive. */
+declare function syntax(value: string): Fragment<never>;
+//#endregion
+//#region src/expressions/unsafe.d.ts
+/** Explicit escape hatch for syntax the standard primitives do not model. */
+declare function unsafeExpression<T = unknown, TSqlType extends AnySqlType = SqlUnknown>(sql: string): Expression<ResultMeta<T, never, TSqlType> | ExpressionMeta<never>, 'unsafe'>;
+//#endregion
+//#region src/query/clauses/custom.d.ts
+declare function customClause<TMetadata = never>(options: {
+  readonly name: string;
+  readonly placement?: ClausePlacement;
+  readonly order: number;
+  readonly render: (context: RenderContext) => void;
+}): SelectClause<TMetadata>;
+//#endregion
+export { AggregateDependenciesOf, AggregateMeta, AnyFragment, AnySqlType, CapabilitiesOf, CapabilityMetadataOf, CardinalityMeta, CardinalityOf, CastTarget, DependenciesOf, Dialect, DialectCapability, DialectCastTypes, DialectExplain, DialectJson, DialectOptions, DialectPagination, DialectRowLocking, ExplainFormat, ExplainRenderOptions, ExpressionMeta, Fragment, FragmentMeta, GroupingDependenciesOf, GroupingKeysOf, GroupingMeta, HasAggregate, HasSubquery, HasWindow, InheritedMetadata, InheritedMetadataOf, JsonScalarKind, MetadataOf, NamedCastTarget, NullabilityOf, NullableSourceMeta, NullableSourcesOf, OutputOf, PaginationKind, PaginationPart, PortableCastTarget, PortableCastType, ProvidesOuterOf, ProvidesOuterSourceMeta, ProvidesSourceMeta, QueryCardinality, RenderCapabilityValidation, RenderContext, RenderFunction, RenderOptions, RenderedQuery, RequiresCapabilityMeta, RequiresOf, RequiresOuterMetadataOf, RequiresOuterOf, RequiresOuterSourceMeta, RequiresSourceMeta, ResultMeta, RowLockMode, RowLockWaitPolicy, SchemaLiteralRenderer, SqlBigInt, SqlBinary, SqlBoolean, SqlDate, SqlDecimal, SqlEqualityComparable, SqlEqualityCompatible, SqlInteger, SqlJson, SqlNumericLike, SqlOrderCompatible, SqlOrderable, SqlSemanticType, SqlText, SqlTextLike, SqlTimestamp, SqlTypeOf, SqlTypeSatisfies, SqlUnknown, SqlUuid, SubqueryMeta, VisibleDependenciesOf, WindowMeta, assertDialectCapability, commaSeparated, createDialect, customClause, expressionFragment, fragment, identifier, isExpression, isFragment, keyword, makeExpression, markExpressionCategory, parameter, parenthesize, qualifiedIdentifier, render, resolveCastTarget, routineName, sequence, syntax, typedCall, typedCast, typedValue, unsafeExpression, withDialectCapability };

package/dist/core.mjs

@@ -0,0 +1,36 @@
+import { a as assertDialectCapability, o as createDialect, s as resolveCastTarget } from "./json-CUZlv4HT.mjs";
+import { a as routineName, c as render, i as typedCall, s as typedCast, t as createClause } from "./types-Cec0xzo4.mjs";
+import { a as qualifiedIdentifier, c as makeExpression, f as withDialectCapability, g as sequence, h as parenthesize, i as identifier, m as isFragment, n as expressionFragment, o as isExpression, p as fragment, u as markExpressionCategory } from "./column-CXMxx8Hq.mjs";
+import { a as parameter, r as typedValue } from "./value-BvilP0oz.mjs";
+//#region src/core/primitives/compose.ts
+function commaSeparated(parts) {
+	return sequence(parts, ", ");
+}
+function keyword(value, part) {
+	return fragment((context) => {
+		context.append(value);
+		if (part) {
+			context.append(" ");
+			context.render(part);
+		}
+	});
+}
+//#endregion
+//#region src/core/primitives/syntax.ts
+/** Emit trusted SQL syntax. Never pass user data to this primitive. */
+function syntax(value) {
+	return fragment((context) => context.append(value));
+}
+//#endregion
+//#region src/expressions/unsafe.ts
+/** Explicit escape hatch for syntax the standard primitives do not model. */
+function unsafeExpression(sql) {
+	return makeExpression("unsafe", (context) => context.render(syntax(sql)));
+}
+//#endregion
+//#region src/query/clauses/custom.ts
+function customClause(options) {
+	return createClause(options.name, options.placement ?? "after-select", options.order, options.render);
+}
+//#endregion
+export { assertDialectCapability, commaSeparated, createDialect, customClause, expressionFragment, fragment, identifier, isExpression, isFragment, keyword, makeExpression, markExpressionCategory, parameter, parenthesize, qualifiedIdentifier, render, resolveCastTarget, routineName, sequence, syntax, typedCall, typedCast, typedValue, unsafeExpression, withDialectCapability };

package/dist/ddl.d.mts

@@ -0,0 +1,118 @@
+import { Mr as SchemaDialect } from "./types-4Q076HKo.mjs";
+import { MigrationLockRequirement, MigrationOperation, MigrationPlan, MigrationTransactionRequirement } from "./migration.mjs";
+//#region src/ddl/types.d.ts
+/** Stable diagnostic categories produced before a migration is rendered. */
+type DdlDiagnosticCode = 'invalid-plan' | 'blocked-plan' | 'decision-required' | 'dialect-mismatch' | 'unsupported' | 'server-version' | 'lock-conflict' | 'transaction-conflict' | 'lossy' | 'unknown' | 'destructive' | 'review-required' | 'ambiguous' | 'malformed-operation' | 'custom-sql' | 'capability' | 'non-canonical';
+/** A path-addressed finding from DDL preflight or rendering. */
+interface DdlDiagnostic {
+  readonly code: DdlDiagnosticCode;
+  readonly severity: 'error' | 'warning';
+  readonly message: string;
+  readonly operationId?: string;
+  readonly path: readonly (string | number)[];
+  readonly kind?: MigrationOperation['kind'];
+  readonly dialect?: string;
+  readonly requiredVersion?: string;
+  readonly actualVersion?: string;
+  readonly lock?: MigrationLockRequirement;
+  readonly transaction?: MigrationTransactionRequirement;
+}
+/** One deterministic statement emitted for one plan operation. */
+interface DdlStatement {
+  readonly operationId: string;
+  readonly position: number;
+  readonly kind: MigrationOperation['kind'];
+  /** SQL text with dialect placeholders, if a dialect ever needs them. */
+  readonly sql: string;
+  /** Alias for callers that use the query renderer's terminology. */
+  readonly text: string;
+  /** DDL literals are normally in SQL; this remains explicit and ordered. */
+  readonly parameters: readonly unknown[];
+}
+/** Policy and execution-context facts used by DDL preflight. */
+interface DdlEmissionOptions {
+  /** Permit a plan whose own `ready` flag is false after reviewing diagnostics. */
+  readonly allowBlocked?: boolean;
+  /** Alias for callers that intentionally permit all review gates. */
+  readonly allowUnsafe?: boolean;
+  readonly allowDecisionRequired?: boolean;
+  readonly allowUnknown?: boolean;
+  readonly allowLossy?: boolean;
+  readonly allowUnsupported?: boolean;
+  readonly allowDestructive?: boolean;
+  readonly allowReviewRequired?: boolean;
+  /** Server version used for syntax checks, such as SQLite DROP COLUMN. */
+  readonly serverVersion?: string | number;
+  /** Whether the caller will wrap statements in one transaction. */
+  readonly transaction?: 'managed' | 'autocommit' | 'none';
+  /** Maximum lock the caller can acquire for this migration. */
+  readonly lock?: Exclude<MigrationLockRequirement, 'unknown'>;
+}
+/** Result of preflight plus deterministic statement rendering. */
+interface DdlEmission {
+  readonly ok: boolean;
+  readonly dialect: string;
+  readonly statements: readonly DdlStatement[];
+  readonly diagnostics: readonly DdlDiagnostic[];
+  /** Statements joined with a newline for simple migration-file writers. */
+  readonly sql: string;
+  /** Flattened parameters in statement order. */
+  readonly parameters: readonly unknown[];
+}
+/** Descriptive alias for callers that name rendered output as a result. */
+type DdlEmissionResult = DdlEmission;
+/** A dialect-specific DDL emitter. */
+interface DdlEmitter {
+  readonly dialect: string;
+  diagnose(plan: MigrationPlan, schemaDialect: SchemaDialect, options?: DdlEmissionOptions): readonly DdlDiagnostic[];
+  emit(plan: MigrationPlan, schemaDialect: SchemaDialect, options?: DdlEmissionOptions): DdlEmission;
+}
+//#endregion
+//#region src/ddl/emitter.d.ts
+interface DdlFeatures {
+  readonly dialect: 'postgresql' | 'sqlite' | 'mysql';
+  readonly supports: ReadonlySet<string>;
+}
+/**
+ * Build the shared strict preflight and rendering boundary for one engine.
+ * The renderer only receives a validated MigrationPlan and a SchemaDialect.
+ */
+declare function createDdlEmitter(features: DdlFeatures): DdlEmitter;
+//#endregion
+//#region src/ddl/postgres.d.ts
+/** PostgreSQL operation support used by the strict DDL preflight. */
+declare const postgresDdlEmitter: DdlEmitter;
+/** Emit a reviewed plan with PostgreSQL's schema dialect. */
+declare function emitPostgresMigrationPlan(plan: MigrationPlan, options?: DdlEmissionOptions): DdlEmission;
+/** Alias using the full PostgreSQL spelling. */
+declare const emitPostgresqlMigrationPlan: typeof emitPostgresMigrationPlan;
+declare const emitPostgresDdl: typeof emitPostgresMigrationPlan;
+declare const emitPostgresqlDdl: typeof emitPostgresMigrationPlan;
+//#endregion
+//#region src/ddl/sqlite.d.ts
+/** SQLite operation support used by the strict DDL preflight. */
+declare const sqliteDdlEmitter: DdlEmitter;
+/** Emit a reviewed plan with SQLite's schema dialect. */
+declare function emitSqliteMigrationPlan(plan: MigrationPlan, options?: DdlEmissionOptions): DdlEmission;
+declare const emitSqliteDdl: typeof emitSqliteMigrationPlan;
+//#endregion
+//#region src/ddl/mysql.d.ts
+/** MySQL operation support used by the strict DDL preflight. */
+declare const mysqlDdlEmitter: DdlEmitter;
+/** Emit a reviewed plan with MySQL's schema dialect. */
+declare function emitMysqlMigrationPlan(plan: MigrationPlan, options?: DdlEmissionOptions): DdlEmission;
+declare const emitMysqlDdl: typeof emitMysqlMigrationPlan;
+//#endregion
+//#region src/ddl/index.d.ts
+/** Select a first-party emitter by the selected schema dialect name. */
+declare function ddlEmitterForDialect(dialect: SchemaDialect): DdlEmitter;
+/** Emit a plan through the matching first-party schema dialect. */
+declare function emitMigrationPlan(plan: MigrationPlan, dialect: SchemaDialect, options?: DdlEmissionOptions): DdlEmission;
+/** Convenient defaults for callers that already selected a plan dialect. */
+declare const ddlDialects: Readonly<{
+  postgresql: SchemaDialect<"json" | "ilike" | "on-conflict" | "row-locking">;
+  sqlite: SchemaDialect<"json" | "on-conflict">;
+  mysql: SchemaDialect<"json" | "row-locking">;
+}>;
+//#endregion
+export { DdlDiagnostic, DdlDiagnosticCode, DdlEmission, DdlEmissionOptions, DdlEmissionResult, DdlEmitter, DdlFeatures, DdlStatement, createDdlEmitter, ddlDialects, ddlEmitterForDialect, emitMigrationPlan, emitMysqlDdl, emitMysqlMigrationPlan, emitPostgresDdl, emitPostgresMigrationPlan, emitPostgresqlDdl, emitPostgresqlMigrationPlan, emitSqliteDdl, emitSqliteMigrationPlan, mysqlDdlEmitter, postgresDdlEmitter, sqliteDdlEmitter };