@prisma/orm-family-sql 8.0.0-rc.18-dev.16 → 8.0.0-rc.18-dev.18

package/dist/{control-CPg4LwJV.d.mts → control-mpACqp72.d.mts}

@@ -1,24 +1,24 @@
-import { r as StorageTable, t as StorageColumn } from "./storage-table-DC9afJhr-CmRU56OS.mjs";
+import { r as StorageTable } from "./storage-table-DC9afJhr-CmRU56OS.mjs";
 import { l as SqlStorage } from "./sql-storage-tZhB8nS5-8NSWT0TW.mjs";
 import { j as SqlControlDriverInstance } from "./types-Dqf87mfA-BOElvimQ.mjs";
 import "./types-DMfBh16_.mjs";
 import { r as SqlOperationDescriptors } from "./index-BXFiad5j.mjs";
-import { h as AnyQueryAst } from "./types-Sh5HuaZE-BwZNUDEi.mjs";
+import { h as AnyQueryAst } from "./types-DVaVM20q-B-QcMIOa.mjs";
 import { o as SqlExecuteRequest } from "./driver-types-DRsYeq3j-X_D6hNMZ.mjs";
-import { a as DdlNode } from "./ddl-types-DtKZjNtN-DWQeO79o.mjs";
-import { p as LowererContext } from "./ast-BoM9T1b2.mjs";
-import { a as ParsedNullLiteral, i as EnumMemberListDefault, n as DefaultFunctionCall, r as EnumMemberDefault } from "./attribute-specs-D7EhHD08.mjs";
-import { b as SqlSchemaIRNode, v as SqlSchemaIR } from "./types-C-z8HyiZ-1Nhw0pHj.mjs";
-import "./types-CJK7FBdw.mjs";
-import { o as SqlTypeLookups } from "./data-type-CYsho6Yd.mjs";
-import "./validators-R-Wsy5Rr.mjs";
-import { r as SqlControlAdapter } from "./control-adapter-CkFfBVei-DGf1LihO.mjs";
-import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-Cl5erH9X.mjs";
-import { D as SqlPlannerFailureResult, S as SqlMigrationRunnerSuccessValue, _ as SqlMigrationRunnerErrorCode, b as SqlMigrationRunnerFailure, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, w as SqlPlannerConflict } from "./types-CzxOObSY-Cq3t_HCe.mjs";
-import { t as SqlSchemaDiffFn } from "./schema-differ-CqWOkoW9-uVU2SdFf.mjs";
+import { a as DdlNode } from "./ddl-types-CoP6yAw9-BDp3W_5g.mjs";
+import { p as LowererContext } from "./ast-Dzsat0Zb.mjs";
+import { a as ParsedNullLiteral, i as EnumMemberListDefault, n as DefaultFunctionCall, r as EnumMemberDefault } from "./attribute-specs-2I2xuKEa.mjs";
+import { b as SqlSchemaIRNode, f as SqlDefaultValue, v as SqlSchemaIR } from "./types-c1iIhJep-DdMj6TNl.mjs";
+import "./types-BLyhYk6B.mjs";
+import { o as SqlTypeLookups } from "./data-type-B8N33s-_.mjs";
+import "./validators-CTZ-hU2l.mjs";
+import { r as SqlControlAdapter } from "./control-adapter-BCopdpsT-DIHCWbq_.mjs";
+import { t as sqlFamilyEnumSpec } from "./authoring-entity-types-CZ-vdwYS-BpyuSxbj.mjs";
+import { D as SqlPlannerFailureResult, S as SqlMigrationRunnerSuccessValue, _ as SqlMigrationRunnerErrorCode, b as SqlMigrationRunnerFailure, f as SqlMigrationPlanOperationStep, g as SqlMigrationRunner, k as SqlPlannerSuccessResult, l as SqlMigrationPlan, m as SqlMigrationPlanner, n as CodecControlHooks, r as CreateSqlMigrationPlanOptions, t as AnyRecord, w as SqlPlannerConflict } from "./types-DaYtBAYT-B22gkh5z.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DmP74bB8-BGA6fzOv.mjs";
 import { StructuredError } from "@prisma/orm-framework/utils/structured-error";
 import { DataTypeSupport, PresetStorageTemplate, TIMESTAMP_NOW_GENERATOR_ID } from "@prisma/orm-framework/components/authoring";
-import { CodecLookupWithDescriptors, DataType } from "@prisma/orm-framework/components/codec";
+import { Codec, CodecLookupWithDescriptors, CodecRef, DataType, DataTypeLookup } from "@prisma/orm-framework/components/codec";
 import { ColumnDefault, Contract, ContractWithDomain, ControlPolicy } from "@prisma/orm-framework/contract/types";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
 import { NotOk, Ok, Result } from "@prisma/orm-framework/utils/result";
@@ -85,7 +85,7 @@ interface SqlControlFamilyInstance extends ControlFamilyInstance<'sql', SqlSchem
     readonly driver: SqlControlDriverInstance<string>;
     readonly contract?: unknown;
   }): Promise<SqlSchemaIRNode>;
-  inferPslContract(schemaIR: SqlSchemaIRNode): PslDocumentAst;
+  inferPslContract(schemaIR: SqlSchemaIRNode): Promise<PslDocumentAst>;
   lowerAst(ast: AnyQueryAst | DdlNode, context: LowererContext<unknown>): Promise<SqlExecuteRequest>;
   /**
    * Inserts the initial marker row for `space` (upsert on `space`).
@@ -499,7 +499,7 @@ interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails, T
    * can omit elements they already describe, and can qualify a cross-space
    * relation with the owning pack's space id.
    */
-  readonly inferPslContract?: (schema: SqlSchemaIRNode, context: SqlPslBuildContext, describedContracts?: readonly SqlDescribedContractSpace[]) => PslDocumentAst;
+  readonly inferPslContract?: (schema: SqlSchemaIRNode, context: SqlPslBuildContext, describedContracts?: readonly SqlDescribedContractSpace[]) => Promise<PslDocumentAst>;
   /**
    * Builds the PSL document of a contract, which `contract print` renders as text. `contract` must be one `contractSerializer.deserializeContract` accepted; the hook does not check its structure again. Like {@link inferPslContract} it produces a PSL document, but from an assembled contract and the stack parts in `context`. The document reads back as the same contract; the hook throws `CONTRACT.PRINT_UNSUPPORTED` for a contract PSL cannot express. The implementation sits in the target, though most of it inverts this family's PSL reader; only its column types, defaults, native enums, derived checks and row-level security are dialect logic. Optional: targets without `contract print` omit it, and the family instance throws when it is absent.
    */
@@ -541,26 +541,7 @@ interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails, T
 //#endregion
 //#region src/core/migrations/contract-to-schema-ir.d.ts
 /**
- * Target-specific callback that renders a `ColumnDefault` into the raw SQL literal
- * string stored in `SqlColumnIR.default`.
- *
- * Default value serialization is target-specific (quoting, casting, type syntax vary
- * between Postgres, MySQL, SQLite, …). The target provides its renderer when calling
- * `contractToSchemaIR`, keeping the family layer target-agnostic. `type.dataType` is the id of
- * the data type the column's codec represents, and `type.baseTypeName` its base name.
- */
-type DefaultRenderer = (def: ColumnDefault, column: StorageColumn, type: {
-  readonly dataType: string;
-  readonly baseTypeName: string;
-}) => string;
-/**
- * Target-supplied hook (same IoC seam as `DefaultRenderer`)
- * that normalizes a contract-declared `ColumnDefault` into the resolved shape
- * the target's introspection parses from the live database — e.g. a
- * sql`'{}'::jsonb` raw default and the literal Postgres reports
- * are the same value in different shapes, and `resolvedDefaultsEqual`
- * compares `kind` before content. When omitted, the contract's raw default
- * is the resolved default unchanged.
+ * Target-supplied hook that names a contract's expression default the way the target's introspection names the same database function, such as `now()` for `CURRENT_TIMESTAMP`, so the two compare equal. When omitted, the contract's default is the resolved default unchanged.
  */
 type DefaultResolver = (def: ColumnDefault, resolvedNativeType: string) => ColumnDefault;
 /**
@@ -576,7 +557,6 @@ declare function detectDestructiveChanges(from: SqlStorage | null, to: SqlStorag
 /** Each column's type is written from the data type its codec represents, found through the lookups. */
 interface ContractToSchemaIROptions extends SqlTypeLookups {
   readonly annotationNamespace: string;
-  readonly renderDefault?: DefaultRenderer;
   readonly resolveDefault?: DefaultResolver;
 }
 /**
@@ -840,6 +820,8 @@ interface PlanFieldEventOperationsOptions {
    * `RawSqlCall`.
    */
   readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+  /** The stack's data types, which say what each column is stored as. */
+  readonly dataTypes: Pick<DataTypeLookup, 'get'>;
   /**
    * The table renames the plan applies. A column under a renamed table's old name is the same
    * column under its new name, so a rename alone fires no event.
@@ -1279,6 +1261,57 @@ declare function convertedColumnOf(step: SqlMigrationPlanOperationStep): Convert
  */
 declare function unconvertedFieldOf(step: SqlMigrationPlanOperationStep, contract: ContractWithDomain): MigrationSubject | undefined;
 //#endregion
+//#region src/core/reported-defaults.d.ts
+/**
+ * A reported literal default with the target's quoting, casts and escapes taken off: one body, or a list's element bodies with `null` for SQL NULL. A body is what the target's driver hands `fromWire` for a row of the column: text, a number where the driver returns one, or bytes.
+ */
+type ReportedLiteralDefault = {
+  readonly kind: 'value';
+  readonly body: ReportedBody;
+} | {
+  readonly kind: 'list';
+  readonly elements: readonly (ReportedBody | null)[];
+};
+/** One literal's body, as the driver would hand it over for a row: text, a number, or the bytes of a blob. */
+type ReportedBody = string | number | Uint8Array;
+/** What the column's codec made of a reported literal default: the value, or the codec's reason it could not read it. */
+type ReadReportedDefault = {
+  readonly resolvedDefault: ColumnDefault;
+  readonly defaultValue: SqlDefaultValue;
+} | {
+  readonly defaultUnreadable: string;
+};
+/** Reads a reported literal default with the column's codec. `raw` is the reported text, which a refusal quotes. */
+declare function readReportedDefault(codec: Codec, literal: ReportedLiteralDefault, raw: string): Promise<ReadReportedDefault>;
+/** What introspection holds of a reported literal default: the codec's reading, and the value of the literal the contract's expression default writes, when it writes one the codec reads. */
+type ReadColumnDefault = ReadReportedDefault & {
+  readonly defaultExpressionValue?: SqlDefaultValue;
+};
+/**
+ * Reads a reported literal default with the column's codec, and, when the contract's default is an expression that writes a literal, that literal too, so the diff compares the two as values.
+ */
+declare function readColumnDefault(codec: Codec, reported: {
+  readonly literal: ReportedLiteralDefault;
+  readonly raw: string;
+}, written: {
+  readonly literal: ReportedLiteralDefault;
+  readonly expression: string;
+} | undefined): Promise<ReadColumnDefault>;
+/** What introspection needs of a column the contract declares: its codec, and its default when that is an expression. */
+interface ContractColumn {
+  readonly codecRef: CodecRef;
+  readonly defaultExpression: string | undefined;
+}
+/** The columns a contract declares, for introspection to read each column's reported default with the column's codec. */
+interface ContractColumns {
+  /** `table.column` in one of `namespaceIds`, or in any namespace when `undefined`. */
+  columnOf(namespaceIds: readonly string[] | undefined, table: string, column: string): ContractColumn | undefined;
+}
+/**
+ * The columns `contract` declares. `contract` is a contract, or the namespaces of several contract spaces merged with each space's contract under `contracts`, as multi-space introspection receives them; a table's named types are then those of the space that declares it.
+ */
+declare function contractColumns(contract: unknown): ContractColumns;
+//#endregion
 //#region src/core/timestamp-now-generator.d.ts
 declare function temporalStringAuthoringPresets<const Storage extends PresetStorageTemplate, const GeneratorId extends string = typeof TIMESTAMP_NOW_GENERATOR_ID>(input: Storage & {
   readonly generatorId?: GeneratorId;
@@ -1380,5 +1413,5 @@ declare function temporalCodecPresetWithPrecision<const CodecId extends string,
 //#region src/exports/control.d.ts
 declare const _default: SqlFamilyDescriptor;
 //#endregion
-export { backfillOfDefaultedField as $, SchemaTables as A, rowsWithoutValueFailure as At, StatementColumn as B, temporalStringAuthoringPresets as Bt, ModelStorageEffect as C, plannerFailure as Ct, PlannedStatements as D, requiredColumnsOfMigration as Dt, PlanFieldEventOperationsOptions as E, requiredColumnOf as Et, SqlPslBuildContext as F, sqlOfSlot as Ft, TableNameCaseGuardTable as G, SubjectStorage as H, unknownCallNames as Ht, SqlQuote as I, sqlTypeLookupsOf as It, TableRenameRequest as J, TableRename as K, SqlQuotingRules as L, storageNameOfOperation as Lt, SqlControlFamilyInstance as M, runnerFailure as Mt, SqlControlTargetDescriptor as N, runnerSuccess as Nt, RequiredColumn as O, resolveColumnRenameAgainst as Ot, SqlDescribedContractSpace as P, slotSource as Pt, assembleAuthoringContributions as Q, SqlSlot as R, subjectsOfCalls as Rt, MigrationPlannerResult as S, planStatements as St, NoTable as T, requiredColumnMeta as Tt, SuppressionRecord as U, unmatchedColumnRename as Ut, StatementPlanningTarget as V, unconvertedFieldOf as Vt, TABLE_NAME_CASE_CHANGED_CODE as W, unmatchedTableRename as Wt, _default as X, TargetMigrationsCapability as Y, appliedStatementsInOrder as Z, MigrationOperationPolicy$1 as _, modelRenameStorageEffect as _t, ColumnRename as a, convertedColumnMeta as at, MigrationPlanner as b, planFieldEventCalls as bt, ControlPolicySubject as c, createSqlTextSources as ct, DefaultResolver as d, extractCodecControlHooks as dt, checkSqlExpressionText as et, FieldEventCall as f, fieldEventStorage as ft, MigrationOperationClass$1 as g, isUnfilledSlot as gt, INIT_ADDITIVE_POLICY as h, fieldStatementColumns as ht, ColumnOnOneSide as i, controlPolicyForCall as it, SingleOperationCall as j, rowsWithoutValueSummary as jt, RequiredColumnMark as k, resolveTableRenameAgainst as kt, ConvertedColumn as l, detectDestructiveChanges as lt, FieldStorageEffect as m, fieldRenameStorageEffect as mt, CallSubjects as n, contractNamespaceToSchemaIR as nt, ColumnRenameRequest as o, convertedColumnOf as ot, FieldStatementColumns as p, fieldOfColumn as pt, TableRenameByHand as q, CallWithCompanions as r, contractToSchemaIR as rt, ContractToSchemaIROptions as s, createMigrationPlan as st, COLUMN_RENAME_UNMATCHED_CODE as t, columnTakesTemporaryValue as tt, DefaultRenderer as u, detectTableNameCaseChanges as ut, MigrationPlan$1 as v, partitionCallsByControlPolicy as vt, ModelTable as w, plannerSuccess as wt, MigrationPlannerConflict$1 as x, planFieldEventOperations as xt, MigrationPlanOperation$1 as y, partitionIssuesByControlPolicy as yt, SqlTextSources as z, temporalCodecPresetWithPrecision as zt };
-//# sourceMappingURL=control-CPg4LwJV.d.mts.map
+export { TableRenameRequest as $, ReadReportedDefault as A, plannerSuccess as At, SqlPslBuildContext as B, runnerFailure as Bt, MigrationPlannerResult as C, modelRenameStorageEffect as Ct, PlanFieldEventOperationsOptions as D, planFieldEventOperations as Dt, NoTable as E, planFieldEventCalls as Et, SchemaTables as F, requiredColumnsOfMigration as Ft, StatementColumn as G, storageNameOfOperation as Gt, SqlQuotingRules as H, slotSource as Ht, SingleOperationCall as I, resolveColumnRenameAgainst as It, SuppressionRecord as J, temporalStringAuthoringPresets as Jt, StatementPlanningTarget as K, subjectsOfCalls as Kt, SqlControlFamilyInstance as L, resolveTableRenameAgainst as Lt, ReportedLiteralDefault as M, readReportedDefault as Mt, RequiredColumn as N, requiredColumnMeta as Nt, PlannedStatements as O, planStatements as Ot, RequiredColumnMark as P, requiredColumnOf as Pt, TableRenameByHand as Q, unmatchedTableRename as Qt, SqlControlTargetDescriptor as R, rowsWithoutValueFailure as Rt, MigrationPlannerConflict$1 as S, isUnfilledSlot as St, ModelTable as T, partitionIssuesByControlPolicy as Tt, SqlSlot as U, sqlOfSlot as Ut, SqlQuote as V, runnerSuccess as Vt, SqlTextSources as W, sqlTypeLookupsOf as Wt, TableNameCaseGuardTable as X, unknownCallNames as Xt, TABLE_NAME_CASE_CHANGED_CODE as Y, unconvertedFieldOf as Yt, TableRename as Z, unmatchedColumnRename as Zt, MigrationOperationClass$1 as _, extractCodecControlHooks as _t, ColumnRename as a, checkSqlExpressionText as at, MigrationPlanOperation$1 as b, fieldRenameStorageEffect as bt, ContractColumns as c, contractNamespaceToSchemaIR as ct, ConvertedColumn as d, convertedColumnMeta as dt, TargetMigrationsCapability as et, DefaultResolver as f, convertedColumnOf as ft, INIT_ADDITIVE_POLICY as g, detectTableNameCaseChanges as gt, FieldStorageEffect as h, detectDestructiveChanges as ht, ColumnOnOneSide as i, backfillOfDefaultedField as it, ReportedBody as j, readColumnDefault as jt, ReadColumnDefault as k, plannerFailure as kt, ContractToSchemaIROptions as l, contractToSchemaIR as lt, FieldStatementColumns as m, createSqlTextSources as mt, CallSubjects as n, appliedStatementsInOrder as nt, ColumnRenameRequest as o, columnTakesTemporaryValue as ot, FieldEventCall as p, createMigrationPlan as pt, SubjectStorage as q, temporalCodecPresetWithPrecision as qt, CallWithCompanions as r, assembleAuthoringContributions as rt, ContractColumn as s, contractColumns as st, COLUMN_RENAME_UNMATCHED_CODE as t, _default as tt, ControlPolicySubject as u, controlPolicyForCall as ut, MigrationOperationPolicy$1 as v, fieldEventStorage as vt, ModelStorageEffect as w, partitionCallsByControlPolicy as wt, MigrationPlanner as x, fieldStatementColumns as xt, MigrationPlan$1 as y, fieldOfColumn as yt, SqlDescribedContractSpace as z, rowsWithoutValueSummary as zt };
+//# sourceMappingURL=control-mpACqp72.d.mts.map

package/dist/control-mpACqp72.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-mpACqp72.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/control.d.mts"],"mappings":"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"}

package/dist/{data-type-CYsho6Yd.d.mts → data-type-B8N33s-_.d.mts}

@@ -1,5 +1,5 @@
-import { a as ReportedSqlType } from "./types-C-z8HyiZ-1Nhw0pHj.mjs";
-import "./types-CJK7FBdw.mjs";
+import { i as ReportedSqlType } from "./types-c1iIhJep-DdMj6TNl.mjs";
+import "./types-BLyhYk6B.mjs";
 import { CodecLookupWithDescriptors, DataType, DataTypeId, DataTypeLookup, DataTypeSpec } from "@prisma/orm-framework/components/codec";
 import { Type } from "arktype";
 //#region ../../../2-sql/1-core/contract/dist/data-type.d.mts
@@ -28,6 +28,8 @@ interface SqlDataTypeSpec<Params extends SqlTypeParams = SqlTypeParams> extends
   readonly texts?: readonly SqlTypeText[];
   /** The kind of reported type this data type claims, instead of any text. */
   readonly claimsKind?: string;
+  /** The id of the type a column of this type is stored as, with the same parameters. A type stored as another declares no texts. */
+  readonly storedAs?: DataTypeId;
   readonly normalize?: (params: Params) => Params;
   readonly render?: (params: Params) => string;
   readonly fromReported?: (reported: ReportedSqlType) => Params;
@@ -35,6 +37,7 @@ interface SqlDataTypeSpec<Params extends SqlTypeParams = SqlTypeParams> extends
 interface SqlDataTypeFacts<Params extends SqlTypeParams = SqlTypeParams> {
   readonly texts: readonly SqlTypeText[];
   readonly claimsKind: string | undefined;
+  readonly storedAs: DataTypeId | undefined;
   readonly normalize: (params: Params) => Params;
   readonly render: ((params: Params) => string) | undefined;
   readonly fromReported: ((reported: ReportedSqlType) => Params) | undefined;
@@ -51,8 +54,6 @@ interface ResolvedSqlType {
 declare function sqlDataType<Params extends SqlTypeParams = SqlTypeParams>(id: string, spec: SqlDataTypeSpec<Params>): SqlDataType<Params>;
 /** Whether `type` is a data type a SQL column can have. `sql/expression` is the one data type no column has. */
 declare function isSqlDataType(type: DataType): type is SqlDataType;
-/** The parameters of `typeParams` that `type` declares; codec-owned keys are dropped. */
-declare function dataTypeParams(type: DataType, typeParams: SqlTypeParams | undefined): SqlTypeParams;
 /** The parameters, when `type` accepts them; otherwise `CONTRACT.TYPE_PARAMS_INVALID` naming each parameter at fault. */
 declare function validateSqlTypeParams<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): Params;
 /** The name of `type` with no parameters, for places where parameters must not appear. */
@@ -70,7 +71,13 @@ interface SqlTypeLookups {
 }
 /** The SQL data type the codec `codecId` represents. */
 declare function sqlDataTypeOfCodec(codecId: string, lookups: SqlTypeLookups): SqlDataType;
-/** {@link unquotedSqlBaseName} of the data type the codec `codecId` represents. */
+/** The type a column of `type` is stored as, whose name DDL writes and the database reports: `type` itself unless it names another. */
+declare function sqlStorageType(type: SqlDataType, lookup: Pick<DataTypeLookup, 'get'>): SqlDataType;
+/** The id of the type a column of the data type `dataTypeId` is stored as: {@link sqlStorageType} of it, which refuses a storage type the lookup does not register, or `dataTypeId` itself when the lookup does not know it as a SQL data type. */
+declare function sqlStorageTypeId(dataTypeId: string, lookup: Pick<DataTypeLookup, 'get'>): string;
+/** The type a column of the codec `codecId` is stored as: {@link sqlStorageType} of the data type it represents. */
+declare function sqlStorageTypeOfCodec(codecId: string, lookups: SqlTypeLookups): SqlDataType;
+/** {@link unquotedSqlBaseName} of the type a column of the codec `codecId` is stored as. */
 declare function unquotedSqlBaseNameOfCodec(codecId: string, typeParams: SqlTypeParams | undefined, lookups: SqlTypeLookups): string;
 /** The text a migration writes for `type` with the raw `params`. */
 declare function renderSqlTypeName<Params extends SqlTypeParams>(type: SqlDataType<Params>, params: SqlTypeParams): string;
@@ -108,5 +115,5 @@ declare function resolveReportedSqlType(reported: ReportedSqlType, dataTypes: re
  */
 declare function resolveWrittenSqlTypes(text: string, dataTypes: readonly DataType[]): readonly ResolvedSqlType[];
 //#endregion
-export { validateSqlTypeParams as S, sqlBaseName as _, SqlDataTypeSpec as a, unquotedSqlBaseName as b, SqlTypeText as c, isSqlDataType as d, numeralText as f, resolveWrittenSqlTypes as g, resolveReportedSqlType as h, SqlDataTypeFacts as i, dataTypeParams as l, renderSqlTypeName as m, SqlDataType as n, SqlTypeLookups as o, renderSqlCatalogText as p, SqlDataTypeCollision as r, SqlTypeParams as s, ResolvedSqlType as t, findSqlDataTypeCollision as u, sqlDataType as v, unquotedSqlBaseNameOfCodec as x, sqlDataTypeOfCodec as y };
-//# sourceMappingURL=data-type-CYsho6Yd.d.mts.map
+export { unquotedSqlBaseNameOfCodec as C, unquotedSqlBaseName as S, sqlDataType as _, SqlDataTypeSpec as a, sqlStorageTypeId as b, SqlTypeText as c, numeralText as d, renderSqlCatalogText as f, sqlBaseName as g, resolveWrittenSqlTypes as h, SqlDataTypeFacts as i, findSqlDataTypeCollision as l, resolveReportedSqlType as m, SqlDataType as n, SqlTypeLookups as o, renderSqlTypeName as p, SqlDataTypeCollision as r, SqlTypeParams as s, ResolvedSqlType as t, isSqlDataType as u, sqlDataTypeOfCodec as v, validateSqlTypeParams as w, sqlStorageTypeOfCodec as x, sqlStorageType as y };
+//# sourceMappingURL=data-type-B8N33s-_.d.mts.map

package/dist/data-type-B8N33s-_.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-B8N33s-_.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type.d.mts"],"mappings":";;;;;;;;;;iBAQiB,YAAY;;;;UAInB;;WAEC;;WAEA;;WAEA;;WAEA;;KAEN,gBAAgB,SAAS;UACpB,gBAAgB,eAAe,gBAAgB,uBAAuB;WACrE,SAAS,KAAK;WACd,iBAAiB;;WAEjB;;WAEA,WAAW;WACX,aAAa,QAAQ,WAAW;WAChC,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;UAE/C,iBAAiB,eAAe,gBAAgB;WAC/C,gBAAgB;WAChB;WACA,UAAU;WACV,YAAY,QAAQ,WAAW;WAC/B,UAAU,QAAQ;WAClB,gBAAgB,UAAU,oBAAoB;;UAE/C,YAAY,eAAe,gBAAgB,uBAAuB;WACjE,SAAS,KAAK;WACd,KAAK,iBAAiB;;UAEvB;WACC,UAAU;WACV,YAAY;;;iBAGN,YAAY,eAAe,gBAAgB,eAAe,YAAY,MAAM,gBAAgB,UAAU,YAAY;;iBAElH,cAAc,MAAM,WAAW,QAAQ;;iBAEvC,sBAAsB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ,gBAAgB;;iBAEvG,YAAY,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;;;;;iBAM7E,oBAAoB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE5F;WACC,aAAa,KAAK;WAClB,gBAAgB,KAAK;;;iBAGf,mBAAmB,iBAAiB,SAAS,iBAAiB;;iBAE9D,eAAe,MAAM,aAAa,QAAQ,KAAK,yBAAyB;;iBAExE,iBAAiB,oBAAoB,QAAQ,KAAK;;iBAElD,sBAAsB,iBAAiB,SAAS,iBAAiB;;iBAEjE,2BAA2B,iBAAiB,YAAY,2BAA2B,SAAS;;iBAE5F,kBAAkB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;iBAEnF,qBAAqB,eAAe,eAAe,MAAM,YAAY,SAAS,QAAQ;;UAE7F;WACC,OAAO;WACP,QAAQ;WACR;aACE;aACA;aACA;;aAEA;aACA;;;;;;;;iBAQI,yBAAyB,gBAAgB,aAAa;;;;;iBAKtD,uBAAuB,UAAU,iBAAiB,oBAAoB,aAAa;;;;;;;iBAOnF,uBAAuB,cAAc,oBAAoB,sBAAsB"}

package/dist/{numeral-text-Cqu87pVe-DJCqBaSC.mjs → data-type-DKk8Unnz.mjs}

@@ -1,4 +1,4 @@
-//#region ../../../2-sql/1-core/contract/dist/numeral-text-Cqu87pVe.mjs
+//#region ../../../2-sql/1-core/contract/dist/data-type.mjs
 /**
 * A number as a contract source writes it: no exponent, because no schema language has that syntax,
 * so the decimal point moves to where the exponent puts it. A non-finite number is its own word.
@@ -17,4 +17,4 @@ function numeralText(value) {
 //#endregion
 export { numeralText as t };
 
-//# sourceMappingURL=numeral-text-Cqu87pVe-DJCqBaSC.mjs.map
+//# sourceMappingURL=data-type-DKk8Unnz.mjs.map

package/dist/data-type-DKk8Unnz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-DKk8Unnz.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type.mjs"],"sourcesContent":["import { a as resolveReportedSqlType, c as sqlDataType, d as sqlStorageTypeId, f as sqlStorageTypeOfCodec, h as validateSqlTypeParams, i as renderSqlTypeName, l as sqlDataTypeOfCodec, m as unquotedSqlBaseNameOfCodec, n as isSqlDataType, o as resolveWrittenSqlTypes, p as unquotedSqlBaseName, r as renderSqlCatalogText, s as sqlBaseName, t as findSqlDataTypeCollision, u as sqlStorageType } from \"./sql-data-type-Dabuwxet.mjs\";\n//#region src/numeral-text.ts\n/**\n* A number as a contract source writes it: no exponent, because no schema language has that syntax,\n* so the decimal point moves to where the exponent puts it. A non-finite number is its own word.\n*/\nfunction numeralText(value) {\n\tconst [coefficient = \"\", exponent] = String(value).split(\"e\");\n\tif (exponent === void 0) return coefficient;\n\tconst sign = coefficient.startsWith(\"-\") ? \"-\" : \"\";\n\tconst [whole = \"\", fraction = \"\"] = coefficient.slice(sign.length).split(\".\");\n\tconst digits = `${whole}${fraction}`;\n\tconst point = whole.length + Number(exponent);\n\tif (point <= 0) return `${sign}0.${\"0\".repeat(-point)}${digits}`;\n\tif (point >= digits.length) return `${sign}${digits}${\"0\".repeat(point - digits.length)}`;\n\treturn `${sign}${digits.slice(0, point)}.${digits.slice(point)}`;\n}\n//#endregion\nexport { findSqlDataTypeCollision, isSqlDataType, numeralText, renderSqlCatalogText, renderSqlTypeName, resolveReportedSqlType, resolveWrittenSqlTypes, sqlBaseName, sqlDataType, sqlDataTypeOfCodec, sqlStorageType, sqlStorageTypeId, sqlStorageTypeOfCodec, unquotedSqlBaseName, unquotedSqlBaseNameOfCodec, validateSqlTypeParams };\n\n//# sourceMappingURL=data-type.mjs.map"],"mappings":";;;;;AAMA,SAAS,YAAY,OAAO;CAC3B,MAAM,CAAC,cAAc,IAAI,YAAY,OAAO,KAAK,CAAC,CAAC,MAAM,GAAG;CAC5D,IAAI,aAAa,KAAK,GAAG,OAAO;CAChC,MAAM,OAAO,YAAY,WAAW,GAAG,IAAI,MAAM;CACjD,MAAM,CAAC,QAAQ,IAAI,WAAW,MAAM,YAAY,MAAM,KAAK,MAAM,CAAC,CAAC,MAAM,GAAG;CAC5E,MAAM,SAAS,GAAG,QAAQ;CAC1B,MAAM,QAAQ,MAAM,SAAS,OAAO,QAAQ;CAC5C,IAAI,SAAS,GAAG,OAAO,GAAG,KAAK,IAAI,IAAI,OAAO,CAAC,KAAK,IAAI;CACxD,IAAI,SAAS,OAAO,QAAQ,OAAO,GAAG,OAAO,SAAS,IAAI,OAAO,QAAQ,OAAO,MAAM;CACtF,OAAO,GAAG,OAAO,OAAO,MAAM,GAAG,KAAK,EAAE,GAAG,OAAO,MAAM,KAAK;AAC9D"}

package/dist/{data-type-support-CfhpAKLX.mjs → data-type-support-C5-XxxeB.mjs}

@@ -1,9 +1,7 @@
-import { t as numeralText } from "./numeral-text-Cqu87pVe-DJCqBaSC.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { isNonFiniteText } from "@prisma/orm-framework/components/codec";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 //#region ../../../2-sql/1-core/contract/dist/data-type-support.mjs
-const INTEGER_TEXT = /^-?\d+$/;
 const WRITTEN_INTEGER_TEXT = /^[+-]?\d+$/;
 const WRITTEN_DECIMAL_TEXT = /^[+-]?\d+\.\d+$/;
 const DECIMAL_NUMERAL = /^([+-]?)0*(\d+)(\.\d+)?$/;
@@ -15,24 +13,13 @@ function isNumeralText(text) {
 * A written numeral as the contract stores it. Leading zeros and the sign of zero never change a
 * number, so they go; trailing zeros stay, because a type without a scale keeps them.
 */
-function canonicalNumeralText(text) {
+function storedNumeralText(text) {
 	const numeral = DECIMAL_NUMERAL.exec(text);
 	if (numeral === null) return text;
 	const [, sign = "", whole = "", fraction = ""] = numeral;
 	const digits = `${whole}${fraction}`;
 	return sign !== "-" || /^[0.]+$/.test(digits) ? digits : `-${digits}`;
 }
-/**
-* The canonical form of a 64-bit integer type: digit text. A database reads an integer default back as a number when it is a safe integer, so a safe integer reads as its digit text too; any other number may already have lost digits and is refused.
-*/
-const integerTextCanonicalForm = (value) => {
-	if (typeof value === "number" && Number.isSafeInteger(value)) return numeralText(value);
-	if (typeof value === "string" && INTEGER_TEXT.test(value)) return BigInt(value).toString();
-	throw structuredError("CONTRACT.CAST_REFUSED", `Expected digit text or a safe integer, got ${JSON.stringify(value)}.`, {
-		why: "A 64-bit integer type stores its value as digit text, and a number past the safe integer range may already have lost digits.",
-		fix: "Write the value as digit text."
-	});
-};
 /** A string as a contract source writes it, with the escapes its string reader resolves. */
 function escapePslString(value) {
 	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
@@ -47,7 +34,7 @@ function signedRange(bits) {
 }
 /**
 * The classifier one target's plain-number authoring entry carries: it reads the digits and says
-* which of the target's types the value is, in that type's canonical form. `undefined` means no
+* which of the target's types the value is, in that type's stored form. `undefined` means no
 * type of this target holds the number.
 */
 function createNumberClassifier(spec) {
@@ -58,7 +45,7 @@ function createNumberClassifier(spec) {
 	return (text) => {
 		if (isNonFiniteText(text)) return as(spec.words, spec.words?.form === "number" ? Number(text) : text);
 		if (WRITTEN_DECIMAL_TEXT.test(text)) {
-			const canonical = canonicalNumeralText(text);
+			const canonical = storedNumeralText(text);
 			return as(spec.fraction, spec.fraction?.form === "number" ? Number(canonical) : canonical);
 		}
 		if (!WRITTEN_INTEGER_TEXT.test(text)) return void 0;
@@ -113,7 +100,7 @@ function nonFiniteNumberIn(value, path) {
 	}
 }
 /**
-* The reader the SQL targets build the canonical form of each date and time type with; ADR 254
+* The reader the SQL targets build the stored form of each date and time type with; ADR 254
 * states the forms and the text it reads.
 */
 const SHAPES = {
@@ -175,7 +162,7 @@ const MIDNIGHT = {
 };
 function refused(message) {
 	throw structuredError("CONTRACT.CAST_REFUSED", message, {
-		why: "A date or time type stores one canonical form for each value (ADR 254).",
+		why: "A date or time type stores one form for each value (ADR 254).",
 		fix: "Write text the type holds, as the message shows."
 	});
 }
@@ -334,18 +321,18 @@ function printed(value, shape) {
 	if (shape === "dateTime") return `${dateText(date)}T${timeText(time)}`;
 	return `${dateText(date)}T${timeText(time)}Z`;
 }
-/** The position of a range bound, which the data type declares in canonical form. */
+/** The position of a range bound, which the data type declares in stored form. */
 function boundPosition(text, shape) {
 	const written = readWritten(text);
-	if (written === void 0) throw new InternalError(`The range bound "${text}" is not in canonical form.`);
+	if (written === void 0) throw new InternalError(`The range bound "${text}" is not in its stored form.`);
 	return position(normalized(written, shape));
 }
 /**
-* The canonical form of written date or time text, or a refusal with a message that says what is
+* The stored form of written date or time text, or a refusal with a message that says what is
 * wrong and shows text the type holds. `written` is the text as its author wrote it, which the
 * message shows, when a target rewrote it into ISO 8601 before calling this.
 */
-function canonicalDateTime(text, options, written = text) {
+function dateTimeStoredText(text, options, written = text) {
 	const shape = SHAPES[options.shape];
 	const { ownerId: id } = options;
 	const parts = readWritten(text);
@@ -372,6 +359,6 @@ function canonicalDateTime(text, options, written = text) {
 	return printed(value, options.shape);
 }
 //#endregion
-export { integerTextCanonicalForm as a, printJsonText as c, escapePslString as i, signedRange as l, canonicalNumeralText as n, isNumeralText as o, createNumberClassifier as r, parseJsonText as s, canonicalDateTime as t };
+export { parseJsonText as a, storedNumeralText as c, isNumeralText as i, dateTimeStoredText as n, printJsonText as o, escapePslString as r, signedRange as s, createNumberClassifier as t };
 
-//# sourceMappingURL=data-type-support-CfhpAKLX.mjs.map
+//# sourceMappingURL=data-type-support-C5-XxxeB.mjs.map

package/dist/data-type-support-C5-XxxeB.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-support-C5-XxxeB.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type-support.mjs"],"sourcesContent":["import { structuredError } from \"@internal/utils/structured-error\";\nimport { isNonFiniteText } from \"@internal/framework-components/codec\";\nimport { InternalError } from \"@internal/utils/internal-error\";\n//#region src/data-type-support.ts\nconst WRITTEN_INTEGER_TEXT = /^[+-]?\\d+$/;\nconst WRITTEN_DECIMAL_TEXT = /^[+-]?\\d+\\.\\d+$/;\nconst DECIMAL_NUMERAL = /^([+-]?)0*(\\d+)(\\.\\d+)?$/;\n/** Whether `text` is a whole number or a decimal as a contract source writes one. */\nfunction isNumeralText(text) {\n\treturn WRITTEN_INTEGER_TEXT.test(text) || WRITTEN_DECIMAL_TEXT.test(text);\n}\n/**\n* A written numeral as the contract stores it. Leading zeros and the sign of zero never change a\n* number, so they go; trailing zeros stay, because a type without a scale keeps them.\n*/\nfunction storedNumeralText(text) {\n\tconst numeral = DECIMAL_NUMERAL.exec(text);\n\tif (numeral === null) return text;\n\tconst [, sign = \"\", whole = \"\", fraction = \"\"] = numeral;\n\tconst digits = `${whole}${fraction}`;\n\treturn sign !== \"-\" || /^[0.]+$/.test(digits) ? digits : `-${digits}`;\n}\n/** A string as a contract source writes it, with the escapes its string reader resolves. */\nfunction escapePslString(value) {\n\treturn value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\").replace(/\\n/g, \"\\\\n\").replace(/\\r/g, \"\\\\r\");\n}\n/** The range of a signed integer of `bits` bits. */\nfunction signedRange(bits) {\n\tconst half = 2n ** (BigInt(bits) - 1n);\n\treturn {\n\t\tmin: -half,\n\t\tmax: half - 1n\n\t};\n}\n/**\n* The classifier one target's plain-number authoring entry carries: it reads the digits and says\n* which of the target's types the value is, in that type's stored form. `undefined` means no\n* type of this target holds the number.\n*/\nfunction createNumberClassifier(spec) {\n\tconst as = (classification, value) => classification === void 0 ? void 0 : {\n\t\ttype: classification.type,\n\t\tvalue\n\t};\n\treturn (text) => {\n\t\tif (isNonFiniteText(text)) return as(spec.words, spec.words?.form === \"number\" ? Number(text) : text);\n\t\tif (WRITTEN_DECIMAL_TEXT.test(text)) {\n\t\t\tconst canonical = storedNumeralText(text);\n\t\t\treturn as(spec.fraction, spec.fraction?.form === \"number\" ? Number(canonical) : canonical);\n\t\t}\n\t\tif (!WRITTEN_INTEGER_TEXT.test(text)) return void 0;\n\t\tconst digits = BigInt(text);\n\t\tconst classification = spec.integers.find(({ min, max }) => digits >= min && digits <= max) ?? spec.largerWhole;\n\t\treturn as(classification, classification?.form === \"number\" ? Number(digits) : digits.toString());\n\t};\n}\n/**\n* Read JSON text into the document it holds.\n*\n* `JSON.parse` reads a numeral too large for a double as `Infinity`, and `JSON.stringify` writes\n* that back as `null`, so a document holding one would not be the document stored; it is refused\n* here instead, naming where the number is.\n*/\nfunction parseJsonText(text) {\n\tlet value;\n\ttry {\n\t\tvalue = JSON.parse(text);\n\t} catch (error) {\n\t\tthrow structuredError(\"CONTRACT.INVALID_JSON_LITERAL\", error instanceof Error ? error.message : String(error), {\n\t\t\twhy: \"The text is not a JSON document.\",\n\t\t\tfix: \"Write a JSON document.\"\n\t\t});\n\t}\n\tconst overflowed = nonFiniteNumberIn(value, \"\");\n\tif (overflowed !== void 0) throw structuredError(\"CONTRACT.INVALID_JSON_LITERAL\", `${overflowed.path} is ${overflowed.value}, which JSON cannot write back: the number in the text is outside the range a JSON number holds.`, {\n\t\twhy: \"JSON.parse reads a numeral too large for a double as Infinity, which JSON.stringify writes back as null.\",\n\t\tfix: \"Write a number JSON can hold, or write it as text.\"\n\t});\n\treturn value;\n}\n/** Write a document as the text of a JSON literal. */\nfunction printJsonText(value) {\n\treturn JSON.stringify(value);\n}\nfunction nonFiniteNumberIn(value, path) {\n\tif (typeof value === \"number\") return Number.isFinite(value) ? void 0 : {\n\t\tpath: path === \"\" ? \"The value\" : path,\n\t\tvalue\n\t};\n\tif (Array.isArray(value)) {\n\t\tfor (const [index, element] of value.entries()) {\n\t\t\tconst found = nonFiniteNumberIn(element, `${path}[${index}]`);\n\t\t\tif (found !== void 0) return found;\n\t\t}\n\t\treturn;\n\t}\n\tif (typeof value === \"object\" && value !== null) for (const [key, member] of Object.entries(value)) {\n\t\tconst found = nonFiniteNumberIn(member, path === \"\" ? key : `${path}.${key}`);\n\t\tif (found !== void 0) return found;\n\t}\n}\n//#endregion\n//#region src/date-time-stored-form.ts\n/**\n* The reader the SQL targets build the stored form of each date and time type with; ADR 254\n* states the forms and the text it reads.\n*/\nconst SHAPES = {\n\tdate: {\n\t\tdescription: \"a date\",\n\t\tplural: \"dates\",\n\t\texample: \"2024-01-01\",\n\t\tdate: true,\n\t\ttime: false,\n\t\toffset: false\n\t},\n\ttime: {\n\t\tdescription: \"a time of day\",\n\t\tplural: \"times of day\",\n\t\texample: \"12:34:56\",\n\t\tdate: false,\n\t\ttime: true,\n\t\toffset: false\n\t},\n\ttimeWithOffset: {\n\t\tdescription: \"a time of day with a UTC offset\",\n\t\tplural: \"times of day with a UTC offset\",\n\t\texample: \"12:34:56+02:00\",\n\t\tdate: false,\n\t\ttime: true,\n\t\toffset: true\n\t},\n\tdateTime: {\n\t\tdescription: \"a date and time\",\n\t\tplural: \"dates and times\",\n\t\texample: \"2024-01-01T12:34:56\",\n\t\tdate: true,\n\t\ttime: true,\n\t\toffset: false\n\t},\n\tinstant: {\n\t\tdescription: \"a date and time with a UTC offset\",\n\t\tplural: \"instants\",\n\t\texample: \"2024-01-01T12:34:56Z\",\n\t\tdate: true,\n\t\ttime: true,\n\t\toffset: true\n\t}\n};\nconst DATE_PREFIX = /^([+-]\\d{6}|\\d{4})-(\\d{2})-(\\d{2})/;\nconst TIME_PREFIX = /^(\\d{2}):(\\d{2})(?::(\\d{2})(?:\\.(\\d+))?)?/;\nconst OFFSET = /^([+-])(\\d{2})(?::(\\d{2})(?::(\\d{2}))?)?$/;\nconst MAX_FRACTION_DIGITS = 6;\nconst FRACTION_UNITS = {\n\t3: \"milliseconds\",\n\t6: \"microseconds\"\n};\nconst SECONDS_PER_DAY = 86400;\nconst MIDNIGHT = {\n\thour: 0,\n\tminute: 0,\n\tsecond: 0,\n\tfraction: \"\"\n};\nfunction refused(message) {\n\tthrow structuredError(\"CONTRACT.CAST_REFUSED\", message, {\n\t\twhy: \"A date or time type stores one form for each value (ADR 254).\",\n\t\tfix: \"Write text the type holds, as the message shows.\"\n\t});\n}\nfunction isLeapYear(year) {\n\treturn year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n}\nfunction daysInMonth(year, month) {\n\tif (month === 2) return isLeapYear(year) ? 29 : 28;\n\treturn [\n\t\t4,\n\t\t6,\n\t\t9,\n\t\t11\n\t].includes(month) ? 30 : 31;\n}\n/** Days from 1970-01-01 to a date of the proleptic Gregorian calendar, with year 0 as 1 BC. */\nfunction daysFromCivil({ year, month, day }) {\n\tconst shifted = month <= 2 ? year - 1 : year;\n\tconst era = Math.floor(shifted / 400);\n\tconst yearOfEra = shifted - era * 400;\n\tconst dayOfYear = Math.floor((153 * (month + (month > 2 ? -3 : 9)) + 2) / 5) + day - 1;\n\tconst dayOfEra = yearOfEra * 365 + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100) + dayOfYear;\n\treturn era * 146097 + dayOfEra - 719468;\n}\nfunction civilFromDays(days) {\n\tconst shifted = days + 719468;\n\tconst era = Math.floor(shifted / 146097);\n\tconst dayOfEra = shifted - era * 146097;\n\tconst yearOfEra = Math.floor((dayOfEra - Math.floor(dayOfEra / 1460) + Math.floor(dayOfEra / 36524) - Math.floor(dayOfEra / 146096)) / 365);\n\tconst dayOfYear = dayOfEra - (365 * yearOfEra + Math.floor(yearOfEra / 4) - Math.floor(yearOfEra / 100));\n\tconst monthIndex = Math.floor((5 * dayOfYear + 2) / 153);\n\tconst day = dayOfYear - Math.floor((153 * monthIndex + 2) / 5) + 1;\n\tconst month = monthIndex < 10 ? monthIndex + 3 : monthIndex - 9;\n\treturn {\n\t\tyear: yearOfEra + era * 400 + (month <= 2 ? 1 : 0),\n\t\tmonth,\n\t\tday\n\t};\n}\nfunction pad(value, width = 2) {\n\treturn String(value).padStart(width, \"0\");\n}\nfunction yearText(year) {\n\tif (year >= 0 && year <= 9999) return pad(year, 4);\n\treturn `${year < 0 ? \"-\" : \"+\"}${pad(Math.abs(year), 6)}`;\n}\nfunction dateText(date) {\n\treturn `${yearText(date.year)}-${pad(date.month)}-${pad(date.day)}`;\n}\nfunction timeText(time) {\n\tconst fraction = time.fraction.replace(/0+$/, \"\");\n\treturn `${pad(time.hour)}:${pad(time.minute)}:${pad(time.second)}${fraction === \"\" ? \"\" : `.${fraction}`}`;\n}\nfunction offsetText(seconds) {\n\tif (seconds === 0) return \"Z\";\n\tconst magnitude = Math.abs(seconds);\n\tconst rest = magnitude % 60;\n\treturn `${seconds < 0 ? \"-\" : \"+\"}${pad(Math.floor(magnitude / 3600))}:${pad(Math.floor(magnitude / 60) % 60)}${rest === 0 ? \"\" : `:${pad(rest)}`}`;\n}\n/**\n* The fields of an ISO 8601 date, time, or date and time, or `undefined` when the text is not one.\n* Ranges are checked by the caller, which words the refusal.\n*/\nfunction readWritten(text) {\n\tlet rest = text;\n\tlet date;\n\tlet timeFollows = true;\n\tconst dateMatch = DATE_PREFIX.exec(rest);\n\tif (dateMatch !== null) {\n\t\tconst [whole, yearDigits = \"\", month = \"\", day = \"\"] = dateMatch;\n\t\tif (yearDigits === \"-000000\") return void 0;\n\t\tdate = {\n\t\t\tyear: Number(yearDigits),\n\t\t\tmonth: Number(month),\n\t\t\tday: Number(day)\n\t\t};\n\t\trest = rest.slice(whole.length);\n\t\ttimeFollows = /^[Tt ]/.test(rest);\n\t\tif (timeFollows) rest = rest.slice(1);\n\t}\n\tlet time;\n\tlet fractionDigits = 0;\n\tif (timeFollows) {\n\t\tconst timeMatch = TIME_PREFIX.exec(rest);\n\t\tif (timeMatch === null) return void 0;\n\t\tconst [whole, hour = \"\", minute = \"\", second = \"00\", fraction = \"\"] = timeMatch;\n\t\ttime = {\n\t\t\thour: Number(hour),\n\t\t\tminute: Number(minute),\n\t\t\tsecond: Number(second),\n\t\t\tfraction\n\t\t};\n\t\tfractionDigits = fraction.length;\n\t\trest = rest.slice(whole.length);\n\t}\n\tlet offsetSeconds;\n\tif (rest === \"Z\" || rest === \"z\") offsetSeconds = 0;\n\telse if (rest !== \"\") {\n\t\tconst offset = OFFSET.exec(rest);\n\t\tif (offset === null) return void 0;\n\t\tconst [, sign, hours = \"\", minutes = \"00\", seconds = \"00\"] = offset;\n\t\tif (Number(minutes) > 59 || Number(seconds) > 59) return void 0;\n\t\tconst magnitude = Number(hours) * 3600 + Number(minutes) * 60 + Number(seconds);\n\t\toffsetSeconds = sign === \"-\" ? -magnitude : magnitude;\n\t}\n\treturn {\n\t\tdate,\n\t\ttime,\n\t\toffsetSeconds,\n\t\tfractionDigits\n\t};\n}\nfunction withFraction(example, digits) {\n\treturn example.replace(/(\\d{2}:\\d{2}:\\d{2})/, `$1.${\"123456\".slice(0, digits)}`);\n}\n/** The value with an instant moved to UTC. */\nfunction normalized(written, shape) {\n\tconst clock = written.time ?? MIDNIGHT;\n\tconst offsetSeconds = written.offsetSeconds ?? 0;\n\tif (written.date === void 0 || shape !== \"instant\") return {\n\t\tdate: written.date,\n\t\ttime: clock,\n\t\toffsetSeconds\n\t};\n\tconst utc = daysFromCivil(written.date) * SECONDS_PER_DAY + clock.hour * 3600 + clock.minute * 60 + clock.second - offsetSeconds;\n\tconst days = Math.floor(utc / SECONDS_PER_DAY);\n\tconst secondOfDay = utc - days * SECONDS_PER_DAY;\n\treturn {\n\t\tdate: civilFromDays(days),\n\t\ttime: {\n\t\t\thour: Math.floor(secondOfDay / 3600),\n\t\t\tminute: Math.floor(secondOfDay / 60) % 60,\n\t\t\tsecond: secondOfDay % 60,\n\t\t\tfraction: clock.fraction\n\t\t},\n\t\toffsetSeconds: 0\n\t};\n}\nfunction position(value) {\n\tconst { time } = value;\n\treturn [\n\t\tvalue.date === void 0 ? 0 : daysFromCivil(value.date),\n\t\ttime.hour * 3600 + time.minute * 60 + time.second,\n\t\ttime.fraction.padEnd(MAX_FRACTION_DIGITS, \"0\")\n\t];\n}\nfunction isBefore(left, right) {\n\tif (left[0] !== right[0]) return left[0] < right[0];\n\tif (left[1] !== right[1]) return left[1] < right[1];\n\treturn left[2] < right[2];\n}\nfunction printed(value, shape) {\n\tconst { date, time, offsetSeconds } = value;\n\tif (date === void 0) return shape === \"timeWithOffset\" ? `${timeText(time)}${offsetText(offsetSeconds)}` : timeText(time);\n\tif (shape === \"date\") return dateText(date);\n\tif (shape === \"dateTime\") return `${dateText(date)}T${timeText(time)}`;\n\treturn `${dateText(date)}T${timeText(time)}Z`;\n}\n/** The position of a range bound, which the data type declares in stored form. */\nfunction boundPosition(text, shape) {\n\tconst written = readWritten(text);\n\tif (written === void 0) throw new InternalError(`The range bound \"${text}\" is not in its stored form.`);\n\treturn position(normalized(written, shape));\n}\n/**\n* The stored form of written date or time text, or a refusal with a message that says what is\n* wrong and shows text the type holds. `written` is the text as its author wrote it, which the\n* message shows, when a target rewrote it into ISO 8601 before calling this.\n*/\nfunction dateTimeStoredText(text, options, written = text) {\n\tconst shape = SHAPES[options.shape];\n\tconst { ownerId: id } = options;\n\tconst parts = readWritten(text);\n\tif (parts === void 0) refused(`${id} cannot read \"${written}\". Write ${shape.description}, as in \"${shape.example}\".`);\n\tif (parts.date !== void 0 && !shape.date) refused(`${id} holds a time of day without a date, but \"${written}\" has a date. Write the time alone, as in \"${shape.example}\".`);\n\tif (parts.date === void 0 && shape.date) refused(shape.time ? `${id} holds ${shape.description}, but \"${written}\" has no date. Write the date too, as in \"${shape.example}\".` : `${id} holds a date, and \"${written}\" is a time of day. Write a date, as in \"${shape.example}\".`);\n\tif (parts.time !== void 0 && !shape.time) refused(`${id} holds a date without a time of day, but \"${written}\" has a time. Write the date alone, as in \"${shape.example}\".`);\n\tif (parts.time === void 0 && shape.offset) refused(`${id} holds ${shape.description}, but \"${written}\" has no time of day. Write the time too, as in \"${shape.example}\".`);\n\tif (parts.offsetSeconds !== void 0 && !shape.offset) refused(`${id} holds no UTC offset, but \"${written}\" has one. Leave it out, as in \"${shape.example}\".`);\n\tif (parts.offsetSeconds === void 0 && shape.offset) refused(`${id} needs a UTC offset, but \"${written}\" has none. Add Z for UTC or an offset such as +02:00, as in \"${shape.example}\".`);\n\tconst maxFractionDigits = options.maxFractionDigits ?? MAX_FRACTION_DIGITS;\n\tif (parts.fractionDigits > maxFractionDigits) refused(`\"${written}\" has ${parts.fractionDigits} digits after the decimal point, but ${id} holds ${FRACTION_UNITS[maxFractionDigits]}, so at most ${maxFractionDigits}. Round it, as in \"${withFraction(shape.example, maxFractionDigits)}\".`);\n\tconst { date, time } = parts;\n\tif (date !== void 0 && (date.month < 1 || date.month > 12 || date.day < 1 || date.day > daysInMonth(date.year, date.month))) refused(`\"${written}\" is not a date that exists. Write a real date, as in \"${shape.example}\".`);\n\tif (time !== void 0 && (time.hour > 23 || time.minute > 59 || time.second > 59)) refused(`\"${written}\" is not a time of day that exists: hours run from 00 to 23, and minutes and seconds from 00 to 59. Write one, as in \"${shape.example}\".`);\n\tconst offsetLimit = options.maxOffsetHours ?? 23;\n\tif (parts.offsetSeconds !== void 0 && Math.abs(parts.offsetSeconds) >= (offsetLimit + 1) * 3600) refused(`\"${written}\" has a UTC offset outside -${pad(offsetLimit)}:59 to +${pad(offsetLimit)}:59, which ${id} does not hold. Write a smaller offset, as in \"${shape.example}\".`);\n\tconst value = normalized(parts, options.shape);\n\tconst { range } = options;\n\tif (range !== void 0) {\n\t\tconst at = position(value);\n\t\tif (isBefore(at, boundPosition(range.earliest, options.shape)) || isBefore(boundPosition(range.latest, options.shape), at)) refused(`${id} holds ${shape.plural} from ${range.earliest} to ${range.latest}, and \"${written}\" is outside them.`);\n\t}\n\treturn printed(value, options.shape);\n}\n//#endregion\nexport { createNumberClassifier, dateTimeStoredText, escapePslString, isNumeralText, parseJsonText, printJsonText, signedRange, storedNumeralText };\n\n//# sourceMappingURL=data-type-support.mjs.map"],"mappings":";;;;AAIA,MAAM,uBAAuB;AAC7B,MAAM,uBAAuB;AAC7B,MAAM,kBAAkB;;AAExB,SAAS,cAAc,MAAM;CAC5B,OAAO,qBAAqB,KAAK,IAAI,KAAK,qBAAqB,KAAK,IAAI;AACzE;;;;;AAKA,SAAS,kBAAkB,MAAM;CAChC,MAAM,UAAU,gBAAgB,KAAK,IAAI;CACzC,IAAI,YAAY,MAAM,OAAO;CAC7B,MAAM,GAAG,OAAO,IAAI,QAAQ,IAAI,WAAW,MAAM;CACjD,MAAM,SAAS,GAAG,QAAQ;CAC1B,OAAO,SAAS,OAAO,UAAU,KAAK,MAAM,IAAI,SAAS,IAAI;AAC9D;;AAEA,SAAS,gBAAgB,OAAO;CAC/B,OAAO,MAAM,QAAQ,OAAO,MAAM,CAAC,CAAC,QAAQ,MAAM,MAAM,CAAC,CAAC,QAAQ,OAAO,KAAK,CAAC,CAAC,QAAQ,OAAO,KAAK;AACrG;;AAEA,SAAS,YAAY,MAAM;CAC1B,MAAM,OAAO,OAAO,OAAO,IAAI,IAAI;CACnC,OAAO;EACN,KAAK,CAAC;EACN,KAAK,OAAO;CACb;AACD;;;;;;AAMA,SAAS,uBAAuB,MAAM;CACrC,MAAM,MAAM,gBAAgB,UAAU,mBAAmB,KAAK,IAAI,KAAK,IAAI;EAC1E,MAAM,eAAe;EACrB;CACD;CACA,QAAQ,SAAS;EAChB,IAAI,gBAAgB,IAAI,GAAG,OAAO,GAAG,KAAK,OAAO,KAAK,OAAO,SAAS,WAAW,OAAO,IAAI,IAAI,IAAI;EACpG,IAAI,qBAAqB,KAAK,IAAI,GAAG;GACpC,MAAM,YAAY,kBAAkB,IAAI;GACxC,OAAO,GAAG,KAAK,UAAU,KAAK,UAAU,SAAS,WAAW,OAAO,SAAS,IAAI,SAAS;EAC1F;EACA,IAAI,CAAC,qBAAqB,KAAK,IAAI,GAAG,OAAO,KAAK;EAClD,MAAM,SAAS,OAAO,IAAI;EAC1B,MAAM,iBAAiB,KAAK,SAAS,MAAM,EAAE,KAAK,UAAU,UAAU,OAAO,UAAU,GAAG,KAAK,KAAK;EACpG,OAAO,GAAG,gBAAgB,gBAAgB,SAAS,WAAW,OAAO,MAAM,IAAI,OAAO,SAAS,CAAC;CACjG;AACD;;;;;;;;AAQA,SAAS,cAAc,MAAM;CAC5B,IAAI;CACJ,IAAI;EACH,QAAQ,KAAK,MAAM,IAAI;CACxB,SAAS,OAAO;EACf,MAAM,gBAAgB,iCAAiC,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,GAAG;GAC9G,KAAK;GACL,KAAK;EACN,CAAC;CACF;CACA,MAAM,aAAa,kBAAkB,OAAO,EAAE;CAC9C,IAAI,eAAe,KAAK,GAAG,MAAM,gBAAgB,iCAAiC,GAAG,WAAW,KAAK,MAAM,WAAW,MAAM,mGAAmG;EAC9N,KAAK;EACL,KAAK;CACN,CAAC;CACD,OAAO;AACR;;AAEA,SAAS,cAAc,OAAO;CAC7B,OAAO,KAAK,UAAU,KAAK;AAC5B;AACA,SAAS,kBAAkB,OAAO,MAAM;CACvC,IAAI,OAAO,UAAU,UAAU,OAAO,OAAO,SAAS,KAAK,IAAI,KAAK,IAAI;EACvE,MAAM,SAAS,KAAK,cAAc;EAClC;CACD;CACA,IAAI,MAAM,QAAQ,KAAK,GAAG;EACzB,KAAK,MAAM,CAAC,OAAO,YAAY,MAAM,QAAQ,GAAG;GAC/C,MAAM,QAAQ,kBAAkB,SAAS,GAAG,KAAK,GAAG,MAAM,EAAE;GAC5D,IAAI,UAAU,KAAK,GAAG,OAAO;EAC9B;EACA;CACD;CACA,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG;EACnG,MAAM,QAAQ,kBAAkB,QAAQ,SAAS,KAAK,MAAM,GAAG,KAAK,GAAG,KAAK;EAC5E,IAAI,UAAU,KAAK,GAAG,OAAO;CAC9B;AACD;;;;;AAOA,MAAM,SAAS;CACd,MAAM;EACL,aAAa;EACb,QAAQ;EACR,SAAS;EACT,MAAM;EACN,MAAM;EACN,QAAQ;CACT;CACA,MAAM;EACL,aAAa;EACb,QAAQ;EACR,SAAS;EACT,MAAM;EACN,MAAM;EACN,QAAQ;CACT;CACA,gBAAgB;EACf,aAAa;EACb,QAAQ;EACR,SAAS;EACT,MAAM;EACN,MAAM;EACN,QAAQ;CACT;CACA,UAAU;EACT,aAAa;EACb,QAAQ;EACR,SAAS;EACT,MAAM;EACN,MAAM;EACN,QAAQ;CACT;CACA,SAAS;EACR,aAAa;EACb,QAAQ;EACR,SAAS;EACT,MAAM;EACN,MAAM;EACN,QAAQ;CACT;AACD;AACA,MAAM,cAAc;AACpB,MAAM,cAAc;AACpB,MAAM,SAAS;AACf,MAAM,sBAAsB;AAC5B,MAAM,iBAAiB;CACtB,GAAG;CACH,GAAG;AACJ;AACA,MAAM,kBAAkB;AACxB,MAAM,WAAW;CAChB,MAAM;CACN,QAAQ;CACR,QAAQ;CACR,UAAU;AACX;AACA,SAAS,QAAQ,SAAS;CACzB,MAAM,gBAAgB,yBAAyB,SAAS;EACvD,KAAK;EACL,KAAK;CACN,CAAC;AACF;AACA,SAAS,WAAW,MAAM;CACzB,OAAO,OAAO,MAAM,KAAK,OAAO,QAAQ,KAAK,OAAO,QAAQ;AAC7D;AACA,SAAS,YAAY,MAAM,OAAO;CACjC,IAAI,UAAU,GAAG,OAAO,WAAW,IAAI,IAAI,KAAK;CAChD,OAAO;EACN;EACA;EACA;EACA;CACD,CAAC,CAAC,SAAS,KAAK,IAAI,KAAK;AAC1B;;AAEA,SAAS,cAAc,EAAE,MAAM,OAAO,OAAO;CAC5C,MAAM,UAAU,SAAS,IAAI,OAAO,IAAI;CACxC,MAAM,MAAM,KAAK,MAAM,UAAU,GAAG;CACpC,MAAM,YAAY,UAAU,MAAM;CAClC,MAAM,YAAY,KAAK,OAAO,OAAO,SAAS,QAAQ,IAAI,KAAK,MAAM,KAAK,CAAC,IAAI,MAAM;CACrF,MAAM,WAAW,YAAY,MAAM,KAAK,MAAM,YAAY,CAAC,IAAI,KAAK,MAAM,YAAY,GAAG,IAAI;CAC7F,OAAO,MAAM,SAAS,WAAW;AAClC;AACA,SAAS,cAAc,MAAM;CAC5B,MAAM,UAAU,OAAO;CACvB,MAAM,MAAM,KAAK,MAAM,UAAU,MAAM;CACvC,MAAM,WAAW,UAAU,MAAM;CACjC,MAAM,YAAY,KAAK,OAAO,WAAW,KAAK,MAAM,WAAW,IAAI,IAAI,KAAK,MAAM,WAAW,KAAK,IAAI,KAAK,MAAM,WAAW,MAAM,KAAK,GAAG;CAC1I,MAAM,YAAY,YAAY,MAAM,YAAY,KAAK,MAAM,YAAY,CAAC,IAAI,KAAK,MAAM,YAAY,GAAG;CACtG,MAAM,aAAa,KAAK,OAAO,IAAI,YAAY,KAAK,GAAG;CACvD,MAAM,MAAM,YAAY,KAAK,OAAO,MAAM,aAAa,KAAK,CAAC,IAAI;CACjE,MAAM,QAAQ,aAAa,KAAK,aAAa,IAAI,aAAa;CAC9D,OAAO;EACN,MAAM,YAAY,MAAM,OAAO,SAAS,IAAI,IAAI;EAChD;EACA;CACD;AACD;AACA,SAAS,IAAI,OAAO,QAAQ,GAAG;CAC9B,OAAO,OAAO,KAAK,CAAC,CAAC,SAAS,OAAO,GAAG;AACzC;AACA,SAAS,SAAS,MAAM;CACvB,IAAI,QAAQ,KAAK,QAAQ,MAAM,OAAO,IAAI,MAAM,CAAC;CACjD,OAAO,GAAG,OAAO,IAAI,MAAM,MAAM,IAAI,KAAK,IAAI,IAAI,GAAG,CAAC;AACvD;AACA,SAAS,SAAS,MAAM;CACvB,OAAO,GAAG,SAAS,KAAK,IAAI,EAAE,GAAG,IAAI,KAAK,KAAK,EAAE,GAAG,IAAI,KAAK,GAAG;AACjE;AACA,SAAS,SAAS,MAAM;CACvB,MAAM,WAAW,KAAK,SAAS,QAAQ,OAAO,EAAE;CAChD,OAAO,GAAG,IAAI,KAAK,IAAI,EAAE,GAAG,IAAI,KAAK,MAAM,EAAE,GAAG,IAAI,KAAK,MAAM,IAAI,aAAa,KAAK,KAAK,IAAI;AAC/F;AACA,SAAS,WAAW,SAAS;CAC5B,IAAI,YAAY,GAAG,OAAO;CAC1B,MAAM,YAAY,KAAK,IAAI,OAAO;CAClC,MAAM,OAAO,YAAY;CACzB,OAAO,GAAG,UAAU,IAAI,MAAM,MAAM,IAAI,KAAK,MAAM,YAAY,IAAI,CAAC,EAAE,GAAG,IAAI,KAAK,MAAM,YAAY,EAAE,IAAI,EAAE,IAAI,SAAS,IAAI,KAAK,IAAI,IAAI,IAAI;AAC/I;;;;;AAKA,SAAS,YAAY,MAAM;CAC1B,IAAI,OAAO;CACX,IAAI;CACJ,IAAI,cAAc;CAClB,MAAM,YAAY,YAAY,KAAK,IAAI;CACvC,IAAI,cAAc,MAAM;EACvB,MAAM,CAAC,OAAO,aAAa,IAAI,QAAQ,IAAI,MAAM,MAAM;EACvD,IAAI,eAAe,WAAW,OAAO,KAAK;EAC1C,OAAO;GACN,MAAM,OAAO,UAAU;GACvB,OAAO,OAAO,KAAK;GACnB,KAAK,OAAO,GAAG;EAChB;EACA,OAAO,KAAK,MAAM,MAAM,MAAM;EAC9B,cAAc,SAAS,KAAK,IAAI;EAChC,IAAI,aAAa,OAAO,KAAK,MAAM,CAAC;CACrC;CACA,IAAI;CACJ,IAAI,iBAAiB;CACrB,IAAI,aAAa;EAChB,MAAM,YAAY,YAAY,KAAK,IAAI;EACvC,IAAI,cAAc,MAAM,OAAO,KAAK;EACpC,MAAM,CAAC,OAAO,OAAO,IAAI,SAAS,IAAI,SAAS,MAAM,WAAW,MAAM;EACtE,OAAO;GACN,MAAM,OAAO,IAAI;GACjB,QAAQ,OAAO,MAAM;GACrB,QAAQ,OAAO,MAAM;GACrB;EACD;EACA,iBAAiB,SAAS;EAC1B,OAAO,KAAK,MAAM,MAAM,MAAM;CAC/B;CACA,IAAI;CACJ,IAAI,SAAS,OAAO,SAAS,KAAK,gBAAgB;MAC7C,IAAI,SAAS,IAAI;EACrB,MAAM,SAAS,OAAO,KAAK,IAAI;EAC/B,IAAI,WAAW,MAAM,OAAO,KAAK;EACjC,MAAM,GAAG,MAAM,QAAQ,IAAI,UAAU,MAAM,UAAU,QAAQ;EAC7D,IAAI,OAAO,OAAO,IAAI,MAAM,OAAO,OAAO,IAAI,IAAI,OAAO,KAAK;EAC9D,MAAM,YAAY,OAAO,KAAK,IAAI,OAAO,OAAO,OAAO,IAAI,KAAK,OAAO,OAAO;EAC9E,gBAAgB,SAAS,MAAM,CAAC,YAAY;CAC7C;CACA,OAAO;EACN;EACA;EACA;EACA;CACD;AACD;AACA,SAAS,aAAa,SAAS,QAAQ;CACtC,OAAO,QAAQ,QAAQ,uBAAuB,MAAM,SAAS,MAAM,GAAG,MAAM,GAAG;AAChF;;AAEA,SAAS,WAAW,SAAS,OAAO;CACnC,MAAM,QAAQ,QAAQ,QAAQ;CAC9B,MAAM,gBAAgB,QAAQ,iBAAiB;CAC/C,IAAI,QAAQ,SAAS,KAAK,KAAK,UAAU,WAAW,OAAO;EAC1D,MAAM,QAAQ;EACd,MAAM;EACN;CACD;CACA,MAAM,MAAM,cAAc,QAAQ,IAAI,IAAI,kBAAkB,MAAM,OAAO,OAAO,MAAM,SAAS,KAAK,MAAM,SAAS;CACnH,MAAM,OAAO,KAAK,MAAM,MAAM,eAAe;CAC7C,MAAM,cAAc,MAAM,OAAO;CACjC,OAAO;EACN,MAAM,cAAc,IAAI;EACxB,MAAM;GACL,MAAM,KAAK,MAAM,cAAc,IAAI;GACnC,QAAQ,KAAK,MAAM,cAAc,EAAE,IAAI;GACvC,QAAQ,cAAc;GACtB,UAAU,MAAM;EACjB;EACA,eAAe;CAChB;AACD;AACA,SAAS,SAAS,OAAO;CACxB,MAAM,EAAE,SAAS;CACjB,OAAO;EACN,MAAM,SAAS,KAAK,IAAI,IAAI,cAAc,MAAM,IAAI;EACpD,KAAK,OAAO,OAAO,KAAK,SAAS,KAAK,KAAK;EAC3C,KAAK,SAAS,OAAO,qBAAqB,GAAG;CAC9C;AACD;AACA,SAAS,SAAS,MAAM,OAAO;CAC9B,IAAI,KAAK,OAAO,MAAM,IAAI,OAAO,KAAK,KAAK,MAAM;CACjD,IAAI,KAAK,OAAO,MAAM,IAAI,OAAO,KAAK,KAAK,MAAM;CACjD,OAAO,KAAK,KAAK,MAAM;AACxB;AACA,SAAS,QAAQ,OAAO,OAAO;CAC9B,MAAM,EAAE,MAAM,MAAM,kBAAkB;CACtC,IAAI,SAAS,KAAK,GAAG,OAAO,UAAU,mBAAmB,GAAG,SAAS,IAAI,IAAI,WAAW,aAAa,MAAM,SAAS,IAAI;CACxH,IAAI,UAAU,QAAQ,OAAO,SAAS,IAAI;CAC1C,IAAI,UAAU,YAAY,OAAO,GAAG,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI;CACnE,OAAO,GAAG,SAAS,IAAI,EAAE,GAAG,SAAS,IAAI,EAAE;AAC5C;;AAEA,SAAS,cAAc,MAAM,OAAO;CACnC,MAAM,UAAU,YAAY,IAAI;CAChC,IAAI,YAAY,KAAK,GAAG,MAAM,IAAI,cAAc,oBAAoB,KAAK,6BAA6B;CACtG,OAAO,SAAS,WAAW,SAAS,KAAK,CAAC;AAC3C;;;;;;AAMA,SAAS,mBAAmB,MAAM,SAAS,UAAU,MAAM;CAC1D,MAAM,QAAQ,OAAO,QAAQ;CAC7B,MAAM,EAAE,SAAS,OAAO;CACxB,MAAM,QAAQ,YAAY,IAAI;CAC9B,IAAI,UAAU,KAAK,GAAG,QAAQ,GAAG,GAAG,gBAAgB,QAAQ,WAAW,MAAM,YAAY,WAAW,MAAM,QAAQ,GAAG;CACrH,IAAI,MAAM,SAAS,KAAK,KAAK,CAAC,MAAM,MAAM,QAAQ,GAAG,GAAG,4CAA4C,QAAQ,6CAA6C,MAAM,QAAQ,GAAG;CAC1K,IAAI,MAAM,SAAS,KAAK,KAAK,MAAM,MAAM,QAAQ,MAAM,OAAO,GAAG,GAAG,SAAS,MAAM,YAAY,SAAS,QAAQ,4CAA4C,MAAM,QAAQ,MAAM,GAAG,GAAG,sBAAsB,QAAQ,2CAA2C,MAAM,QAAQ,GAAG;CAChR,IAAI,MAAM,SAAS,KAAK,KAAK,CAAC,MAAM,MAAM,QAAQ,GAAG,GAAG,4CAA4C,QAAQ,6CAA6C,MAAM,QAAQ,GAAG;CAC1K,IAAI,MAAM,SAAS,KAAK,KAAK,MAAM,QAAQ,QAAQ,GAAG,GAAG,SAAS,MAAM,YAAY,SAAS,QAAQ,mDAAmD,MAAM,QAAQ,GAAG;CACzK,IAAI,MAAM,kBAAkB,KAAK,KAAK,CAAC,MAAM,QAAQ,QAAQ,GAAG,GAAG,6BAA6B,QAAQ,kCAAkC,MAAM,QAAQ,GAAG;CAC3J,IAAI,MAAM,kBAAkB,KAAK,KAAK,MAAM,QAAQ,QAAQ,GAAG,GAAG,4BAA4B,QAAQ,gEAAgE,MAAM,QAAQ,GAAG;CACvL,MAAM,oBAAoB,QAAQ,qBAAqB;CACvD,IAAI,MAAM,iBAAiB,mBAAmB,QAAQ,IAAI,QAAQ,QAAQ,MAAM,eAAe,uCAAuC,GAAG,SAAS,eAAe,mBAAmB,eAAe,kBAAkB,qBAAqB,aAAa,MAAM,SAAS,iBAAiB,EAAE,GAAG;CAC5R,MAAM,EAAE,MAAM,SAAS;CACvB,IAAI,SAAS,KAAK,MAAM,KAAK,QAAQ,KAAK,KAAK,QAAQ,MAAM,KAAK,MAAM,KAAK,KAAK,MAAM,YAAY,KAAK,MAAM,KAAK,KAAK,IAAI,QAAQ,IAAI,QAAQ,yDAAyD,MAAM,QAAQ,GAAG;CAC3N,IAAI,SAAS,KAAK,MAAM,KAAK,OAAO,MAAM,KAAK,SAAS,MAAM,KAAK,SAAS,KAAK,QAAQ,IAAI,QAAQ,wHAAwH,MAAM,QAAQ,GAAG;CAC9O,MAAM,cAAc,QAAQ,kBAAkB;CAC9C,IAAI,MAAM,kBAAkB,KAAK,KAAK,KAAK,IAAI,MAAM,aAAa,MAAM,cAAc,KAAK,MAAM,QAAQ,IAAI,QAAQ,8BAA8B,IAAI,WAAW,EAAE,UAAU,IAAI,WAAW,EAAE,aAAa,GAAG,iDAAiD,MAAM,QAAQ,GAAG;CACjR,MAAM,QAAQ,WAAW,OAAO,QAAQ,KAAK;CAC7C,MAAM,EAAE,UAAU;CAClB,IAAI,UAAU,KAAK,GAAG;EACrB,MAAM,KAAK,SAAS,KAAK;EACzB,IAAI,SAAS,IAAI,cAAc,MAAM,UAAU,QAAQ,KAAK,CAAC,KAAK,SAAS,cAAc,MAAM,QAAQ,QAAQ,KAAK,GAAG,EAAE,GAAG,QAAQ,GAAG,GAAG,SAAS,MAAM,OAAO,QAAQ,MAAM,SAAS,MAAM,MAAM,OAAO,SAAS,QAAQ,mBAAmB;CAC/O;CACA,OAAO,QAAQ,OAAO,QAAQ,KAAK;AACpC"}

package/dist/{data-type-support-4TcZuD7d.d.mts → data-type-support-CBcYhSkD.d.mts}

@@ -1,4 +1,4 @@
-import { DataTypeId, ToCanonicalForm } from "@prisma/orm-framework/components/codec";
+import { DataTypeId } from "@prisma/orm-framework/components/codec";
 import { JsonValue } from "@prisma/orm-framework/contract/types";
 //#region ../../../2-sql/1-core/contract/dist/data-type-support.d.mts
 //#region src/data-type-support.d.ts
@@ -8,11 +8,7 @@ declare function isNumeralText(text: string): boolean;
  * A written numeral as the contract stores it. Leading zeros and the sign of zero never change a
  * number, so they go; trailing zeros stay, because a type without a scale keeps them.
  */
-declare function canonicalNumeralText(text: string): string;
-/**
- * The canonical form of a 64-bit integer type: digit text. A database reads an integer default back as a number when it is a safe integer, so a safe integer reads as its digit text too; any other number may already have lost digits and is refused.
- */
-declare const integerTextCanonicalForm: ToCanonicalForm;
+declare function storedNumeralText(text: string): string;
 /** A string as a contract source writes it, with the escapes its string reader resolves. */
 declare function escapePslString(value: string): string;
 /** Which data type a written number is, and whether that type stores it as a number or as text. */
@@ -42,7 +38,7 @@ interface NumberClassifierSpec {
 }
 /**
  * The classifier one target's plain-number authoring entry carries: it reads the digits and says
- * which of the target's types the value is, in that type's canonical form. `undefined` means no
+ * which of the target's types the value is, in that type's stored form. `undefined` means no
  * type of this target holds the number.
  */
 declare function createNumberClassifier(spec: NumberClassifierSpec): (text: string) => {
@@ -60,33 +56,33 @@ declare function parseJsonText(text: string): JsonValue;
 /** Write a document as the text of a JSON literal. */
 declare function printJsonText(value: JsonValue): string;
 //#endregion
-//#region src/date-time-canonical-form.d.ts
+//#region src/date-time-stored-form.d.ts
 /**
- * The reader the SQL targets build the canonical form of each date and time type with; ADR 254
+ * The reader the SQL targets build the stored form of each date and time type with; ADR 254
  * states the forms and the text it reads.
  */
 /** What a date or time type holds, which decides the text it reads and writes. */
 type DateTimeShape = 'date' | 'time' | 'timeWithOffset' | 'dateTime' | 'instant';
-interface CanonicalDateTimeOptions {
+interface DateTimeStoredTextOptions {
   readonly shape: DateTimeShape;
-  /** The id of the data type or codec that declares this canonical form, which messages name. */
+  /** The id of the data type or codec that declares this stored form, which messages name. */
   readonly ownerId: string;
   /** The largest UTC offset the type holds, in hours. Defaults to 23. */
   readonly maxOffsetHours?: number;
   /** The most digits after the decimal point the type holds. Defaults to 6, microseconds. */
   readonly maxFractionDigits?: 3 | 6;
-  /** The earliest and latest values the type holds, each in canonical form. */
+  /** The earliest and latest values the type holds, each in stored form. */
   readonly range?: {
     readonly earliest: string;
     readonly latest: string;
   };
 }
 /**
- * The canonical form of written date or time text, or a refusal with a message that says what is
+ * The stored form of written date or time text, or a refusal with a message that says what is
  * wrong and shows text the type holds. `written` is the text as its author wrote it, which the
  * message shows, when a target rewrote it into ISO 8601 before calling this.
  */
-declare function canonicalDateTime(text: string, options: CanonicalDateTimeOptions, written?: string): string;
+declare function dateTimeStoredText(text: string, options: DateTimeStoredTextOptions, written?: string): string;
 //#endregion
-export { NumberClassifierSpec as a, createNumberClassifier as c, isNumeralText as d, parseJsonText as f, NumberClassification as i, escapePslString as l, signedRange as m, DateTimeShape as n, canonicalDateTime as o, printJsonText as p, IntegerStep as r, canonicalNumeralText as s, CanonicalDateTimeOptions as t, integerTextCanonicalForm as u };
-//# sourceMappingURL=data-type-support-4TcZuD7d.d.mts.map
+export { NumberClassifierSpec as a, escapePslString as c, printJsonText as d, signedRange as f, NumberClassification as i, isNumeralText as l, DateTimeStoredTextOptions as n, createNumberClassifier as o, storedNumeralText as p, IntegerStep as r, dateTimeStoredText as s, DateTimeShape as t, parseJsonText as u };
+//# sourceMappingURL=data-type-support-CBcYhSkD.d.mts.map

package/dist/data-type-support-CBcYhSkD.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-type-support-CBcYhSkD.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/data-type-support.d.mts"],"mappings":";;;;;iBAIiB,cAAc;;;;;iBAKd,kBAAkB;;iBAElB,gBAAgB;;UAEvB;WACC,MAAM;WACN;;;UAGD,oBAAoB;WACnB;WACA;;;iBAGM,YAAY;WAClB;WACA;;UAED;;WAEC,mBAAmB;;WAEnB,cAAc;;WAEd,WAAW;;WAEX,QAAQ;;;;;;;iBAOF,uBAAuB,MAAM,wBAAwB;WAC3D,MAAM;WACN,OAAO;;;;;;;;;iBASD,cAAc,eAAe;;iBAE7B,cAAc,OAAO;;;;;;;;KAQjC;UACK;WACC,OAAO;;WAEP;;WAEA;;WAEA;;WAEA;aACE;aACA;;;;;;;;iBAQI,mBAAmB,cAAc,SAAS,2BAA2B"}

package/dist/{db-BmrN9nRS-CzyybGKR.d.mts → db-BmrN9nRS-xynLbnAy.d.mts}

@@ -1,15 +1,15 @@
 import { r as StorageTable } from "./storage-table-DC9afJhr-CmRU56OS.mjs";
 import { D as QueryOperationTypesBase, _ as ExtractStorageColumnTypes, d as ExtractAggregateTypes, f as ExtractCodecTypes, g as ExtractStorageColumnInputTypes, h as ExtractQueryOperationTypes, r as AggregateTypesBase } from "./types-Dqf87mfA-BOElvimQ.mjs";
 import { c as StorageColumnMapAt } from "./types-DMfBh16_.mjs";
-import { St as OrderByNulls, l as AnyFromSource } from "./types-Sh5HuaZE-BwZNUDEi.mjs";
-import { n as SqlQueryPlan } from "./plan-cGEaSXHv-yuz43WrR.mjs";
-import { C as TraitExpression, S as StorageColumnScopeField, c as RawAffectedCountQuery, f as RawRowQuery, g as RawSqlInterpolation, h as RawSqlBuilder, i as CodecTypesBase, o as Expression, s as NoReservedRowColumn, x as ScopeField } from "./expression-Ck1wys3N-Cdc7eUQS.mjs";
-import "./expression-DUYovBa6.mjs";
-import { a as Subquery, r as Functions, t as BooleanCodecType } from "./functions-DSwXxsTg.mjs";
-import { c as LockOptionCapabilities, l as LockStrengthCapabilities, u as LockWaitOptions } from "./ast-BoM9T1b2.mjs";
-import { r as TableIndexReferences } from "./index-reference-DJX-CNsb-D5uoBnH_.mjs";
-import "./index-reference-DGQdSRjQ.mjs";
-import "./plan-DdpaNNu1.mjs";
+import { St as OrderByNulls, l as AnyFromSource } from "./types-DVaVM20q-B-QcMIOa.mjs";
+import { n as SqlQueryPlan } from "./plan-Cbed2eDu-BZM3geSm.mjs";
+import { C as TraitExpression, S as StorageColumnScopeField, c as RawAffectedCountQuery, f as RawRowQuery, g as RawSqlInterpolation, h as RawSqlBuilder, i as CodecTypesBase, o as Expression, s as NoReservedRowColumn, x as ScopeField } from "./expression-BzrfOiPC-3NqR8UzK.mjs";
+import "./expression-CeerCjQG.mjs";
+import { a as Subquery, r as Functions, t as BooleanCodecType } from "./functions-Cp8soSAv.mjs";
+import { c as LockOptionCapabilities, l as LockStrengthCapabilities, u as LockWaitOptions } from "./ast-Dzsat0Zb.mjs";
+import { r as TableIndexReferences } from "./index-reference-DJaQLZA3-DxmYkkX-.mjs";
+import "./index-reference-CWppFpUV.mjs";
+import "./plan-BZpZafiQ.mjs";
 import { AnnotationValue, OperationKind, ValidAnnotations } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/4-lanes/sql-builder/dist/db-BmrN9nRS.d.mts
 //#region src/scope.d.ts
@@ -531,4 +531,4 @@ type Namespace<C extends TableProxyContract, NsId extends string & keyof C['stor
 type Db<C extends TableProxyContract> = { readonly [Ns in keyof C['storage']['namespaces'] & string]: Namespace<C, Ns>; };
 //#endregion
 export { WhereFilter as C, UpdateQuery as S, TableInAnyNamespace as _, FieldProxy as a, TableProxyContract as b, IndexReferences as c, QueryContext as d, RawLane as f, SelectQuery as g, Scope as h, DeleteQuery as i, InsertQuery as l, ResolveRow as m, ContractRawTag as n, GatedMethod as o, RawTagFor as p, Db as r, GroupedQuery as s, AggregateFunctions as t, Namespace as u, TableNamesAcrossNamespaces as v, UnboundTables as x, TableProxy as y };
-//# sourceMappingURL=db-BmrN9nRS-CzyybGKR.d.mts.map
+//# sourceMappingURL=db-BmrN9nRS-xynLbnAy.d.mts.map