joist-core 2.3.0 → 2.4.0

package/build/serde/TypeInfo.cjs

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/serde/TypeInfo.ts
+/**
+* Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+* The output compatibility checks compare these names, so normalize only spellings of the same type.
+*
+* I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+* Keeping these spellings distinct would reject compatible outputs just because their serdes use
+* different names for the same representation.
+*
+* I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+* and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+* cannot handle the common SQL type. This function does not choose or apply a conversion.
+*
+* I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+* which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+* also impose constraints that text does not. Unknown names remain unchanged, including their schema
+* and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+*/
+function canonicalDbType(dbType) {
+	if (dbType.endsWith("[]")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;
+	switch (dbType) {
+		case "smallint": return "int2";
+		case "int":
+		case "integer": return "int4";
+		case "bigint": return "int8";
+		case "decimal": return "numeric";
+		case "real": return "float4";
+		case "double precision": return "float8";
+		case "boolean": return "bool";
+		case "character varying": return "varchar";
+		case "character": return "bpchar";
+		case "timestamp without time zone": return "timestamp";
+		case "timestamp with time zone": return "timestamptz";
+		case "time without time zone": return "time";
+		case "time with time zone": return "timetz";
+		default: return dbType;
+	}
+}
+const arrayDomains = /* @__PURE__ */ new Map();
+const arrayElementDbTypes = /* @__PURE__ */ new Set([
+	"bool",
+	"bytea",
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"text",
+	"varchar",
+	"bpchar",
+	"uuid",
+	"json",
+	"jsonb"
+]);
+/**
+* Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+*
+* I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+* `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+* Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+* in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+*/
+function arrayOutputType(outputType) {
+	if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return void 0;
+	let domains = arrayDomains.get(outputType.domain);
+	if (!domains) arrayDomains.set(outputType.domain, domains = /* @__PURE__ */ new Map());
+	let domain = domains.get(outputType.idMeta);
+	if (!domain) domains.set(outputType.idMeta, domain = Symbol("joist.arrayOutput"));
+	return {
+		dbType: `${outputType.dbType}[]`,
+		domain
+	};
+}
+//#endregion
+exports.arrayOutputType = arrayOutputType;
+exports.canonicalDbType = canonicalDbType;
+
+//# sourceMappingURL=TypeInfo.cjs.map

package/build/serde/TypeInfo.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.cjs","names":[],"sources":["../../src/serde/TypeInfo.ts"],"sourcesContent":["// Keep compatibility metadata a runtime leaf in both CJS and ESM builds.\nimport type { EntityMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Runtime proof that values can share scalar conversions.\n *\n * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.\n * A compound uses one decoder per output column and retains an encoder for later comparisons and\n * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply\n * equal logical domains.\n *\n * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while\n * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()\n * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and\n * JSON-schema domain tokens also prevent unrelated conversions from mixing.\n *\n * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent\n * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain\n * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`\n * annotations supply no runtime evidence. This descriptor does not implement conversions.\n */\nexport interface TypeInfo {\n  dbType: string;\n  domain: unknown;\n  idMeta?: EntityMetadata;\n  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */\n  arrayElementSafe?: boolean;\n}\n\n/**\n * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.\n * The output compatibility checks compare these names, so normalize only spellings of the same type.\n *\n * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.\n * Keeping these spellings distinct would reject compatible outputs just because their serdes use\n * different names for the same representation.\n *\n * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number\n * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder\n * cannot handle the common SQL type. This function does not choose or apply a conversion.\n *\n * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,\n * which matters when a set operation compares rows. A user-defined `app.email` domain over text can\n * also impose constraints that text does not. Unknown names remain unchanged, including their schema\n * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.\n */\nexport function canonicalDbType(dbType: string): string {\n  if (dbType.endsWith(\"[]\")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;\n  switch (dbType) {\n    case \"smallint\":\n      return \"int2\";\n    case \"int\":\n    case \"integer\":\n      return \"int4\";\n    case \"bigint\":\n      return \"int8\";\n    case \"decimal\":\n      return \"numeric\";\n    case \"real\":\n      return \"float4\";\n    case \"double precision\":\n      return \"float8\";\n    case \"boolean\":\n      return \"bool\";\n    case \"character varying\":\n      return \"varchar\";\n    case \"character\":\n      return \"bpchar\";\n    case \"timestamp without time zone\":\n      return \"timestamp\";\n    case \"timestamp with time zone\":\n      return \"timestamptz\";\n    case \"time without time zone\":\n      return \"time\";\n    case \"time with time zone\":\n      return \"timetz\";\n    default:\n      return dbType;\n  }\n}\n\nconst arrayDomains = new Map<unknown, Map<EntityMetadata | undefined, symbol>>();\n\n// Both classic pg and lazy binary reads decode these physical arrays, not an unparsed array string.\nconst arrayElementDbTypes = new Set([\n  \"bool\",\n  \"bytea\",\n  \"int2\",\n  \"int4\",\n  \"int8\",\n  \"float4\",\n  \"float8\",\n  \"numeric\",\n  \"text\",\n  \"varchar\",\n  \"bpchar\",\n  \"uuid\",\n  \"json\",\n  \"jsonb\",\n]);\n\n/**\n * Describes elementwise conversion only for known physical array parsers and stable domain conversion.\n *\n * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar\n * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.\n * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers\n * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.\n */\nexport function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return undefined;\n  let domains = arrayDomains.get(outputType.domain);\n  if (!domains) arrayDomains.set(outputType.domain, (domains = new Map()));\n  let domain = domains.get(outputType.idMeta);\n  if (!domain) domains.set(outputType.idMeta, (domain = Symbol(\"joist.arrayOutput\")));\n  return { dbType: `${outputType.dbType}[]`, domain };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,QAAwB;CACtD,IAAI,OAAO,SAAS,IAAI,GAAG,OAAO,GAAG,gBAAgB,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE;CAC1E,QAAQ,QAAR;EACE,KAAK,YACH,OAAO;EACT,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,oBACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,qBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,+BACH,OAAO;EACT,KAAK,4BACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,uBACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAEA,MAAM,+BAAe,IAAI,IAAsD;AAG/E,MAAM,sCAAsB,IAAI,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;AAUD,SAAgB,gBAAgB,YAAwD;CACtF,IAAI,CAAC,YAAY,oBAAoB,CAAC,oBAAoB,IAAI,WAAW,MAAM,GAAG,OAAO,KAAA;CACzF,IAAI,UAAU,aAAa,IAAI,WAAW,MAAM;CAChD,IAAI,CAAC,SAAS,aAAa,IAAI,WAAW,QAAS,0BAAU,IAAI,IAAI,CAAE;CACvE,IAAI,SAAS,QAAQ,IAAI,WAAW,MAAM;CAC1C,IAAI,CAAC,QAAQ,QAAQ,IAAI,WAAW,QAAS,SAAS,OAAO,mBAAmB,CAAE;CAClF,OAAO;EAAE,QAAQ,GAAG,WAAW,OAAO;EAAK;CAAO;AACpD"}

package/build/serde/TypeInfo.d.cts

@@ -0,0 +1,57 @@
+import { EntityMetadata } from "../EntityMetadata.cjs";
+//#region src/serde/TypeInfo.d.ts
+/**
+ * Runtime proof that values can share scalar conversions.
+ *
+ * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.
+ * A compound uses one decoder per output column and retains an encoder for later comparisons and
+ * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply
+ * equal logical domains.
+ *
+ * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while
+ * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()
+ * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and
+ * JSON-schema domain tokens also prevent unrelated conversions from mixing.
+ *
+ * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent
+ * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain
+ * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`
+ * annotations supply no runtime evidence. This descriptor does not implement conversions.
+ */
+interface TypeInfo {
+  dbType: string;
+  domain: unknown;
+  idMeta?: EntityMetadata;
+  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */
+  arrayElementSafe?: boolean;
+}
+/**
+ * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+ * The output compatibility checks compare these names, so normalize only spellings of the same type.
+ *
+ * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+ * Keeping these spellings distinct would reject compatible outputs just because their serdes use
+ * different names for the same representation.
+ *
+ * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+ * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+ * cannot handle the common SQL type. This function does not choose or apply a conversion.
+ *
+ * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+ * which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+ * also impose constraints that text does not. Unknown names remain unchanged, including their schema
+ * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+ */
+declare function canonicalDbType(dbType: string): string;
+/**
+ * Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+ *
+ * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+ * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+ * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+ * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+ */
+declare function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined;
+//#endregion
+export { TypeInfo, arrayOutputType, canonicalDbType };
+//# sourceMappingURL=TypeInfo.d.cts.map

package/build/serde/TypeInfo.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.d.cts","names":[],"sources":["../../src/serde/TypeInfo.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAqBiB;EACf;EACA;EACA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;iBAoBc,gBAAgB;;;;;;;;;iBA+DhB,gBAAgB,YAAY,uBAAuB"}

package/build/serde/TypeInfo.d.mts

@@ -0,0 +1,57 @@
+import { EntityMetadata } from "../EntityMetadata.mjs";
+//#region src/serde/TypeInfo.d.ts
+/**
+ * Runtime proof that values can share scalar conversions.
+ *
+ * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.
+ * A compound uses one decoder per output column and retains an encoder for later comparisons and
+ * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply
+ * equal logical domains.
+ *
+ * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while
+ * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()
+ * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and
+ * JSON-schema domain tokens also prevent unrelated conversions from mixing.
+ *
+ * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent
+ * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain
+ * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`
+ * annotations supply no runtime evidence. This descriptor does not implement conversions.
+ */
+interface TypeInfo {
+  dbType: string;
+  domain: unknown;
+  idMeta?: EntityMetadata;
+  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */
+  arrayElementSafe?: boolean;
+}
+/**
+ * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+ * The output compatibility checks compare these names, so normalize only spellings of the same type.
+ *
+ * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+ * Keeping these spellings distinct would reject compatible outputs just because their serdes use
+ * different names for the same representation.
+ *
+ * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+ * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+ * cannot handle the common SQL type. This function does not choose or apply a conversion.
+ *
+ * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+ * which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+ * also impose constraints that text does not. Unknown names remain unchanged, including their schema
+ * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+ */
+declare function canonicalDbType(dbType: string): string;
+/**
+ * Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+ *
+ * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+ * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+ * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+ * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+ */
+declare function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined;
+//#endregion
+export { TypeInfo, arrayOutputType, canonicalDbType };
+//# sourceMappingURL=TypeInfo.d.mts.map

package/build/serde/TypeInfo.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.d.mts","names":[],"sources":["../../src/serde/TypeInfo.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;UAqBiB;EACf;EACA;EACA,SAAS;;EAET;;;;;;;;;;;;;;;;;;;iBAoBc,gBAAgB;;;;;;;;;iBA+DhB,gBAAgB,YAAY,uBAAuB"}

package/build/serde/TypeInfo.js

@@ -0,0 +1,78 @@
+//#region src/serde/TypeInfo.ts
+/**
+* Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.
+* The output compatibility checks compare these names, so normalize only spellings of the same type.
+*
+* I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.
+* Keeping these spellings distinct would reject compatible outputs just because their serdes use
+* different names for the same representation.
+*
+* I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number
+* and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder
+* cannot handle the common SQL type. This function does not choose or apply a conversion.
+*
+* I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,
+* which matters when a set operation compares rows. A user-defined `app.email` domain over text can
+* also impose constraints that text does not. Unknown names remain unchanged, including their schema
+* and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.
+*/
+function canonicalDbType(dbType) {
+	if (dbType.endsWith("[]")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;
+	switch (dbType) {
+		case "smallint": return "int2";
+		case "int":
+		case "integer": return "int4";
+		case "bigint": return "int8";
+		case "decimal": return "numeric";
+		case "real": return "float4";
+		case "double precision": return "float8";
+		case "boolean": return "bool";
+		case "character varying": return "varchar";
+		case "character": return "bpchar";
+		case "timestamp without time zone": return "timestamp";
+		case "timestamp with time zone": return "timestamptz";
+		case "time without time zone": return "time";
+		case "time with time zone": return "timetz";
+		default: return dbType;
+	}
+}
+const arrayDomains = /* @__PURE__ */ new Map();
+const arrayElementDbTypes = /* @__PURE__ */ new Set([
+	"bool",
+	"bytea",
+	"int2",
+	"int4",
+	"int8",
+	"float4",
+	"float8",
+	"numeric",
+	"text",
+	"varchar",
+	"bpchar",
+	"uuid",
+	"json",
+	"jsonb"
+]);
+/**
+* Describes elementwise conversion only for known physical array parsers and stable domain conversion.
+*
+* I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar
+* `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.
+* Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers
+* in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.
+*/
+function arrayOutputType(outputType) {
+	if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return void 0;
+	let domains = arrayDomains.get(outputType.domain);
+	if (!domains) arrayDomains.set(outputType.domain, domains = /* @__PURE__ */ new Map());
+	let domain = domains.get(outputType.idMeta);
+	if (!domain) domains.set(outputType.idMeta, domain = Symbol("joist.arrayOutput"));
+	return {
+		dbType: `${outputType.dbType}[]`,
+		domain
+	};
+}
+//#endregion
+export { arrayOutputType, canonicalDbType };
+
+//# sourceMappingURL=TypeInfo.js.map

package/build/serde/TypeInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeInfo.js","names":[],"sources":["../../src/serde/TypeInfo.ts"],"sourcesContent":["// Keep compatibility metadata a runtime leaf in both CJS and ESM builds.\nimport type { EntityMetadata } from \"src/EntityMetadata.ts\";\n\n/**\n * Runtime proof that values can share scalar conversions.\n *\n * PostgreSQL compares projected SQL rows and chooses a common SQL type before Joist decodes them.\n * A compound uses one decoder per output column and retains an encoder for later comparisons and\n * coalesce fallbacks. TypeScript result types are erased, and equal SQL storage types do not imply\n * equal logical domains.\n *\n * I.e. Author.id and Book.author_id are compatible Author IDs despite having separate serdes, while\n * Book.id must not decode as an Author ID just because both use int4. Author.age and Author.age.sum()\n * both expose TypeScript numbers but produce int4 and int8 driver values. Enum, custom-mapper, and\n * JSON-schema domain tokens also prevent unrelated conversions from mixing.\n *\n * Compatibility requires exact equality of canonical `dbType`, `domain`, and `idMeta`. An absent\n * descriptor is unknown, not an identity codec. `idMeta` identifies scalar IDs only; arrays retain\n * their element domain separately so they cannot select a polymorphic IN component. Raw `sql<R>`\n * annotations supply no runtime evidence. This descriptor does not implement conversions.\n */\nexport interface TypeInfo {\n  dbType: string;\n  domain: unknown;\n  idMeta?: EntityMetadata;\n  /** Internal conversion proof, consistent for equal dbType/domain/idMeta; not another compatibility key. */\n  arrayElementSafe?: boolean;\n}\n\n/**\n * Normalizes known PostgreSQL type synonyms without treating coercible types or user types as equal.\n * The output compatibility checks compare these names, so normalize only spellings of the same type.\n *\n * I.e. `integer` and `int` both mean `int4`; `integer[]` and `int4[]` also describe the same SQL type.\n * Keeping these spellings distinct would reject compatible outputs just because their serdes use\n * different names for the same representation.\n *\n * I.e. `int4` can be promoted to `int8`, but they are not synonyms: classic pg returns int4 as a number\n * and int8 as a string. Treating them as equal could admit a compound whose first operand's decoder\n * cannot handle the common SQL type. This function does not choose or apply a conversion.\n *\n * I.e. `citext` must stay distinct from `text`: they disagree on whether 'Alice' and 'alice' are equal,\n * which matters when a set operation compares rows. A user-defined `app.email` domain over text can\n * also impose constraints that text does not. Unknown names remain unchanged, including their schema\n * and quoting; neither coercibility nor a shared base type proves that their outputs are compatible.\n */\nexport function canonicalDbType(dbType: string): string {\n  if (dbType.endsWith(\"[]\")) return `${canonicalDbType(dbType.slice(0, -2))}[]`;\n  switch (dbType) {\n    case \"smallint\":\n      return \"int2\";\n    case \"int\":\n    case \"integer\":\n      return \"int4\";\n    case \"bigint\":\n      return \"int8\";\n    case \"decimal\":\n      return \"numeric\";\n    case \"real\":\n      return \"float4\";\n    case \"double precision\":\n      return \"float8\";\n    case \"boolean\":\n      return \"bool\";\n    case \"character varying\":\n      return \"varchar\";\n    case \"character\":\n      return \"bpchar\";\n    case \"timestamp without time zone\":\n      return \"timestamp\";\n    case \"timestamp with time zone\":\n      return \"timestamptz\";\n    case \"time without time zone\":\n      return \"time\";\n    case \"time with time zone\":\n      return \"timetz\";\n    default:\n      return dbType;\n  }\n}\n\nconst arrayDomains = new Map<unknown, Map<EntityMetadata | undefined, symbol>>();\n\n// Both classic pg and lazy binary reads decode these physical arrays, not an unparsed array string.\nconst arrayElementDbTypes = new Set([\n  \"bool\",\n  \"bytea\",\n  \"int2\",\n  \"int4\",\n  \"int8\",\n  \"float4\",\n  \"float8\",\n  \"numeric\",\n  \"text\",\n  \"varchar\",\n  \"bpchar\",\n  \"uuid\",\n  \"json\",\n  \"jsonb\",\n]);\n\n/**\n * Describes elementwise conversion only for known physical array parsers and stable domain conversion.\n *\n * I.e. `a.id.arrayAgg()` wraps Author's tag and `idMeta` in its domain token, but has no scalar\n * `idMeta` of its own. Repeated expressions share the token; IDs of subtypes with a shared tag do not.\n * Native enum/citext, date/time, and nested SQL arrays remain unknown. Numeric elements can be numbers\n * in classic pg and strings in lazy binary reads, so a scalar string-only mapper is not sufficient.\n */\nexport function arrayOutputType(outputType: TypeInfo | undefined): TypeInfo | undefined {\n  if (!outputType?.arrayElementSafe || !arrayElementDbTypes.has(outputType.dbType)) return undefined;\n  let domains = arrayDomains.get(outputType.domain);\n  if (!domains) arrayDomains.set(outputType.domain, (domains = new Map()));\n  let domain = domains.get(outputType.idMeta);\n  if (!domain) domains.set(outputType.idMeta, (domain = Symbol(\"joist.arrayOutput\")));\n  return { dbType: `${outputType.dbType}[]`, domain };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8CA,SAAgB,gBAAgB,QAAwB;CACtD,IAAI,OAAO,SAAS,IAAI,GAAG,OAAO,GAAG,gBAAgB,OAAO,MAAM,GAAG,EAAE,CAAC,EAAE;CAC1E,QAAQ,QAAR;EACE,KAAK,YACH,OAAO;EACT,KAAK;EACL,KAAK,WACH,OAAO;EACT,KAAK,UACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,QACH,OAAO;EACT,KAAK,oBACH,OAAO;EACT,KAAK,WACH,OAAO;EACT,KAAK,qBACH,OAAO;EACT,KAAK,aACH,OAAO;EACT,KAAK,+BACH,OAAO;EACT,KAAK,4BACH,OAAO;EACT,KAAK,0BACH,OAAO;EACT,KAAK,uBACH,OAAO;EACT,SACE,OAAO;CACX;AACF;AAEA,MAAM,+BAAe,IAAI,IAAsD;AAG/E,MAAM,sCAAsB,IAAI,IAAI;CAClC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;;;;;;;;;AAUD,SAAgB,gBAAgB,YAAwD;CACtF,IAAI,CAAC,YAAY,oBAAoB,CAAC,oBAAoB,IAAI,WAAW,MAAM,GAAG,OAAO,KAAA;CACzF,IAAI,UAAU,aAAa,IAAI,WAAW,MAAM;CAChD,IAAI,CAAC,SAAS,aAAa,IAAI,WAAW,QAAS,0BAAU,IAAI,IAAI,CAAE;CACvE,IAAI,SAAS,QAAQ,IAAI,WAAW,MAAM;CAC1C,IAAI,CAAC,QAAQ,QAAQ,IAAI,WAAW,QAAS,SAAS,OAAO,mBAAmB,CAAE;CAClF,OAAO;EAAE,QAAQ,GAAG,WAAW,OAAO;EAAK;CAAO;AACpD"}

package/build/serde/columns.cjs

@@ -0,0 +1,63 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/serde/columns.ts
+/** A physical column owns one scalar codec, shared with every field binding for that column. */
+var Column = class {
+	columnName;
+	sqlNullable;
+	hasDefault;
+	isGenerated;
+	insertOptional;
+	writable;
+	idMetadata;
+	codec;
+	insert;
+	update;
+	/** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */
+	constructor(columnName, sqlNullable, hasDefault, isGenerated, insertOptional, writable, idMetadata, codec) {
+		this.columnName = columnName;
+		this.sqlNullable = sqlNullable;
+		this.hasDefault = hasDefault;
+		this.isGenerated = isGenerated;
+		this.insertOptional = insertOptional;
+		this.writable = writable;
+		this.idMetadata = idMetadata;
+		this.codec = codec;
+		const primaryKey = columnName === "id";
+		this.insert = isGenerated || writable === false ? "never" : sqlNullable || hasDefault || insertOptional || primaryKey && ["int", "bigint"].includes(codec.dbType) ? "optional" : "required";
+		this.update = !primaryKey && !isGenerated && writable !== false;
+	}
+	get dbType() {
+		return this.codec.dbType;
+	}
+	get isArray() {
+		return this.codec.isArray;
+	}
+	get isNullableArray() {
+		return this.codec.isArray && this.sqlNullable;
+	}
+	/** Resolve ID metadata only after all generated entity modules have initialized. */
+	get outputType() {
+		const output = this.codec.outputType;
+		if (!this.idMetadata) return output;
+		return output && !this.codec.isArray && !output.dbType.endsWith("[]") ? {
+			...output,
+			idMeta: this.idMetadata()
+		} : void 0;
+	}
+	mapToDb(value) {
+		return this.codec.mapToDb(value);
+	}
+	mapToDbValue(value) {
+		return this.codec.mapToDbValue(value);
+	}
+	mapFromDb(value) {
+		return this.codec.mapFromDb(value);
+	}
+	mapFromJsonAgg(value) {
+		return this.codec.mapFromJsonAgg(value);
+	}
+};
+//#endregion
+exports.Column = Column;
+
+//# sourceMappingURL=columns.cjs.map

package/build/serde/columns.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.cjs","names":[],"sources":["../../src/serde/columns.ts"],"sourcesContent":["// These must be erased imports: descriptors are loaded before entity metadata and relation classes.\nimport type { EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { ScalarCodec } from \"src/serde/serde.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\n\n/** A physical column owns one scalar codec, shared with every field binding for that column. */\nexport class Column {\n  readonly insert: \"required\" | \"optional\" | \"never\";\n  readonly update: boolean;\n  /** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */\n  constructor(\n    readonly columnName: string,\n    readonly sqlNullable: boolean,\n    readonly hasDefault: boolean,\n    readonly isGenerated: boolean,\n    /** ORM-maintained timestamps can be omitted by the SQL API as well. */\n    readonly insertOptional: boolean,\n    /** Polymorphic components are readable, but direct mutations remain unsupported. */\n    readonly writable: boolean,\n    readonly idMetadata: (() => EntityMetadata) | undefined,\n    readonly codec: ScalarCodec,\n  ) {\n    const primaryKey = columnName === \"id\";\n    this.insert =\n      isGenerated || writable === false\n        ? \"never\"\n        : sqlNullable || hasDefault || insertOptional || (primaryKey && [\"int\", \"bigint\"].includes(codec.dbType))\n          ? \"optional\"\n          : \"required\";\n    this.update = !primaryKey && !isGenerated && writable !== false;\n  }\n\n  get dbType(): string {\n    return this.codec.dbType;\n  }\n  get isArray(): boolean {\n    return this.codec.isArray;\n  }\n  get isNullableArray(): boolean {\n    return this.codec.isArray && this.sqlNullable;\n  }\n\n  /** Resolve ID metadata only after all generated entity modules have initialized. */\n  get outputType(): TypeInfo | undefined {\n    const output = this.codec.outputType;\n    if (!this.idMetadata) return output;\n    // Scalar ID evidence must never be attached to an array domain or an unknown replacement codec.\n    return output && !this.codec.isArray && !output.dbType.endsWith(\"[]\")\n      ? { ...output, idMeta: this.idMetadata() }\n      : undefined;\n  }\n\n  mapToDb(value: any): any {\n    return this.codec.mapToDb(value);\n  }\n  mapToDbValue(value: unknown): unknown {\n    return this.codec.mapToDbValue!(value);\n  }\n  mapFromDb(value: unknown): unknown {\n    return this.codec.mapFromDb(value);\n  }\n  mapFromJsonAgg(value: any): any {\n    return this.codec.mapFromJsonAgg(value);\n  }\n}\n\nexport type ColumnDescriptors = Record<string, Column>;\n"],"mappings":";;;AAMA,IAAa,SAAb,MAAoB;CAKP;CACA;CACA;CACA;CAEA;CAEA;CACA;CACA;CAbX;CACA;;CAEA,YACE,YACA,aACA,YACA,aAEA,gBAEA,UACA,YACA,OACA;EAVS,KAAA,aAAA;EACA,KAAA,cAAA;EACA,KAAA,aAAA;EACA,KAAA,cAAA;EAEA,KAAA,iBAAA;EAEA,KAAA,WAAA;EACA,KAAA,aAAA;EACA,KAAA,QAAA;EAET,MAAM,aAAa,eAAe;EAClC,KAAK,SACH,eAAe,aAAa,QACxB,UACA,eAAe,cAAc,kBAAmB,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC,SAAS,MAAM,MAAM,IACnG,aACA;EACR,KAAK,SAAS,CAAC,cAAc,CAAC,eAAe,aAAa;CAC5D;CAEA,IAAI,SAAiB;EACnB,OAAO,KAAK,MAAM;CACpB;CACA,IAAI,UAAmB;EACrB,OAAO,KAAK,MAAM;CACpB;CACA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,MAAM,WAAW,KAAK;CACpC;;CAGA,IAAI,aAAmC;EACrC,MAAM,SAAS,KAAK,MAAM;EAC1B,IAAI,CAAC,KAAK,YAAY,OAAO;EAE7B,OAAO,UAAU,CAAC,KAAK,MAAM,WAAW,CAAC,OAAO,OAAO,SAAS,IAAI,IAChE;GAAE,GAAG;GAAQ,QAAQ,KAAK,WAAW;EAAE,IACvC,KAAA;CACN;CAEA,QAAQ,OAAiB;EACvB,OAAO,KAAK,MAAM,QAAQ,KAAK;CACjC;CACA,aAAa,OAAyB;EACpC,OAAO,KAAK,MAAM,aAAc,KAAK;CACvC;CACA,UAAU,OAAyB;EACjC,OAAO,KAAK,MAAM,UAAU,KAAK;CACnC;CACA,eAAe,OAAiB;EAC9B,OAAO,KAAK,MAAM,eAAe,KAAK;CACxC;AACF"}

package/build/serde/columns.d.cts

@@ -0,0 +1,38 @@
+import { TypeInfo } from "./TypeInfo.cjs";
+import { ScalarCodec } from "./serde.cjs";
+import { EntityMetadata } from "../EntityMetadata.cjs";
+//#region src/serde/columns.d.ts
+/** A physical column owns one scalar codec, shared with every field binding for that column. */
+declare class Column {
+  readonly columnName: string;
+  readonly sqlNullable: boolean;
+  readonly hasDefault: boolean;
+  readonly isGenerated: boolean;
+  /** ORM-maintained timestamps can be omitted by the SQL API as well. */
+  readonly insertOptional: boolean;
+  /** Polymorphic components are readable, but direct mutations remain unsupported. */
+  readonly writable: boolean;
+  readonly idMetadata: (() => EntityMetadata) | undefined;
+  readonly codec: ScalarCodec;
+  readonly insert: "required" | "optional" | "never";
+  readonly update: boolean;
+  /** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */
+  constructor(columnName: string, sqlNullable: boolean, hasDefault: boolean, isGenerated: boolean,
+  /** ORM-maintained timestamps can be omitted by the SQL API as well. */
+  insertOptional: boolean,
+  /** Polymorphic components are readable, but direct mutations remain unsupported. */
+  writable: boolean, idMetadata: (() => EntityMetadata) | undefined, codec: ScalarCodec);
+  get dbType(): string;
+  get isArray(): boolean;
+  get isNullableArray(): boolean;
+  /** Resolve ID metadata only after all generated entity modules have initialized. */
+  get outputType(): TypeInfo | undefined;
+  mapToDb(value: any): any;
+  mapToDbValue(value: unknown): unknown;
+  mapFromDb(value: unknown): unknown;
+  mapFromJsonAgg(value: any): any;
+}
+type ColumnDescriptors = Record<string, Column>;
+//#endregion
+export { Column, ColumnDescriptors };
+//# sourceMappingURL=columns.d.cts.map

package/build/serde/columns.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.cts","names":[],"sources":["../../src/serde/columns.ts"],"mappings":";;;;;cAMa;WAKA;WACA;WACA;WACA;;WAEA;;WAEA;WACA,mBAAmB;WACnB,OAAO;WAbT;WACA;;EAET,YACW,oBACA,sBACA,qBACA,sBAEA;;EAAA,yBAEA;;EAAA,mBACA,mBAAmB,6BACnB,OAAO;MAYd;MAGA;MAGA;;MAKA,cAAc;EASlB,QAAQ;EAGR,aAAa;EAGb,UAAU;EAGV,eAAe;;KAKL,oBAAoB,eAAe"}

package/build/serde/columns.d.mts

@@ -0,0 +1,38 @@
+import { TypeInfo } from "./TypeInfo.mjs";
+import { ScalarCodec } from "./serde.mjs";
+import { EntityMetadata } from "../EntityMetadata.mjs";
+//#region src/serde/columns.d.ts
+/** A physical column owns one scalar codec, shared with every field binding for that column. */
+declare class Column {
+  readonly columnName: string;
+  readonly sqlNullable: boolean;
+  readonly hasDefault: boolean;
+  readonly isGenerated: boolean;
+  /** ORM-maintained timestamps can be omitted by the SQL API as well. */
+  readonly insertOptional: boolean;
+  /** Polymorphic components are readable, but direct mutations remain unsupported. */
+  readonly writable: boolean;
+  readonly idMetadata: (() => EntityMetadata) | undefined;
+  readonly codec: ScalarCodec;
+  readonly insert: "required" | "optional" | "never";
+  readonly update: boolean;
+  /** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */
+  constructor(columnName: string, sqlNullable: boolean, hasDefault: boolean, isGenerated: boolean,
+  /** ORM-maintained timestamps can be omitted by the SQL API as well. */
+  insertOptional: boolean,
+  /** Polymorphic components are readable, but direct mutations remain unsupported. */
+  writable: boolean, idMetadata: (() => EntityMetadata) | undefined, codec: ScalarCodec);
+  get dbType(): string;
+  get isArray(): boolean;
+  get isNullableArray(): boolean;
+  /** Resolve ID metadata only after all generated entity modules have initialized. */
+  get outputType(): TypeInfo | undefined;
+  mapToDb(value: any): any;
+  mapToDbValue(value: unknown): unknown;
+  mapFromDb(value: unknown): unknown;
+  mapFromJsonAgg(value: any): any;
+}
+type ColumnDescriptors = Record<string, Column>;
+//#endregion
+export { Column, ColumnDescriptors };
+//# sourceMappingURL=columns.d.mts.map

package/build/serde/columns.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.d.mts","names":[],"sources":["../../src/serde/columns.ts"],"mappings":";;;;;cAMa;WAKA;WACA;WACA;WACA;;WAEA;;WAEA;WACA,mBAAmB;WACnB,OAAO;WAbT;WACA;;EAET,YACW,oBACA,sBACA,qBACA,sBAEA;;EAAA,yBAEA;;EAAA,mBACA,mBAAmB,6BACnB,OAAO;MAYd;MAGA;MAGA;;MAKA,cAAc;EASlB,QAAQ;EAGR,aAAa;EAGb,UAAU;EAGV,eAAe;;KAKL,oBAAoB,eAAe"}

package/build/serde/columns.js

@@ -0,0 +1,62 @@
+//#region src/serde/columns.ts
+/** A physical column owns one scalar codec, shared with every field binding for that column. */
+var Column = class {
+	columnName;
+	sqlNullable;
+	hasDefault;
+	isGenerated;
+	insertOptional;
+	writable;
+	idMetadata;
+	codec;
+	insert;
+	update;
+	/** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */
+	constructor(columnName, sqlNullable, hasDefault, isGenerated, insertOptional, writable, idMetadata, codec) {
+		this.columnName = columnName;
+		this.sqlNullable = sqlNullable;
+		this.hasDefault = hasDefault;
+		this.isGenerated = isGenerated;
+		this.insertOptional = insertOptional;
+		this.writable = writable;
+		this.idMetadata = idMetadata;
+		this.codec = codec;
+		const primaryKey = columnName === "id";
+		this.insert = isGenerated || writable === false ? "never" : sqlNullable || hasDefault || insertOptional || primaryKey && ["int", "bigint"].includes(codec.dbType) ? "optional" : "required";
+		this.update = !primaryKey && !isGenerated && writable !== false;
+	}
+	get dbType() {
+		return this.codec.dbType;
+	}
+	get isArray() {
+		return this.codec.isArray;
+	}
+	get isNullableArray() {
+		return this.codec.isArray && this.sqlNullable;
+	}
+	/** Resolve ID metadata only after all generated entity modules have initialized. */
+	get outputType() {
+		const output = this.codec.outputType;
+		if (!this.idMetadata) return output;
+		return output && !this.codec.isArray && !output.dbType.endsWith("[]") ? {
+			...output,
+			idMeta: this.idMetadata()
+		} : void 0;
+	}
+	mapToDb(value) {
+		return this.codec.mapToDb(value);
+	}
+	mapToDbValue(value) {
+		return this.codec.mapToDbValue(value);
+	}
+	mapFromDb(value) {
+		return this.codec.mapFromDb(value);
+	}
+	mapFromJsonAgg(value) {
+		return this.codec.mapFromJsonAgg(value);
+	}
+};
+//#endregion
+export { Column };
+
+//# sourceMappingURL=columns.js.map

package/build/serde/columns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"columns.js","names":[],"sources":["../../src/serde/columns.ts"],"sourcesContent":["// These must be erased imports: descriptors are loaded before entity metadata and relation classes.\nimport type { EntityMetadata } from \"src/EntityMetadata.ts\";\nimport type { ScalarCodec } from \"src/serde/serde.ts\";\nimport type { TypeInfo } from \"src/serde/TypeInfo.ts\";\n\n/** A physical column owns one scalar codec, shared with every field binding for that column. */\nexport class Column {\n  readonly insert: \"required\" | \"optional\" | \"never\";\n  readonly update: boolean;\n  /** Physical storage and SQL write policy, independent of domain field requiredness and defaults. */\n  constructor(\n    readonly columnName: string,\n    readonly sqlNullable: boolean,\n    readonly hasDefault: boolean,\n    readonly isGenerated: boolean,\n    /** ORM-maintained timestamps can be omitted by the SQL API as well. */\n    readonly insertOptional: boolean,\n    /** Polymorphic components are readable, but direct mutations remain unsupported. */\n    readonly writable: boolean,\n    readonly idMetadata: (() => EntityMetadata) | undefined,\n    readonly codec: ScalarCodec,\n  ) {\n    const primaryKey = columnName === \"id\";\n    this.insert =\n      isGenerated || writable === false\n        ? \"never\"\n        : sqlNullable || hasDefault || insertOptional || (primaryKey && [\"int\", \"bigint\"].includes(codec.dbType))\n          ? \"optional\"\n          : \"required\";\n    this.update = !primaryKey && !isGenerated && writable !== false;\n  }\n\n  get dbType(): string {\n    return this.codec.dbType;\n  }\n  get isArray(): boolean {\n    return this.codec.isArray;\n  }\n  get isNullableArray(): boolean {\n    return this.codec.isArray && this.sqlNullable;\n  }\n\n  /** Resolve ID metadata only after all generated entity modules have initialized. */\n  get outputType(): TypeInfo | undefined {\n    const output = this.codec.outputType;\n    if (!this.idMetadata) return output;\n    // Scalar ID evidence must never be attached to an array domain or an unknown replacement codec.\n    return output && !this.codec.isArray && !output.dbType.endsWith(\"[]\")\n      ? { ...output, idMeta: this.idMetadata() }\n      : undefined;\n  }\n\n  mapToDb(value: any): any {\n    return this.codec.mapToDb(value);\n  }\n  mapToDbValue(value: unknown): unknown {\n    return this.codec.mapToDbValue!(value);\n  }\n  mapFromDb(value: unknown): unknown {\n    return this.codec.mapFromDb(value);\n  }\n  mapFromJsonAgg(value: any): any {\n    return this.codec.mapFromJsonAgg(value);\n  }\n}\n\nexport type ColumnDescriptors = Record<string, Column>;\n"],"mappings":";;AAMA,IAAa,SAAb,MAAoB;CAKP;CACA;CACA;CACA;CAEA;CAEA;CACA;CACA;CAbX;CACA;;CAEA,YACE,YACA,aACA,YACA,aAEA,gBAEA,UACA,YACA,OACA;EAVS,KAAA,aAAA;EACA,KAAA,cAAA;EACA,KAAA,aAAA;EACA,KAAA,cAAA;EAEA,KAAA,iBAAA;EAEA,KAAA,WAAA;EACA,KAAA,aAAA;EACA,KAAA,QAAA;EAET,MAAM,aAAa,eAAe;EAClC,KAAK,SACH,eAAe,aAAa,QACxB,UACA,eAAe,cAAc,kBAAmB,cAAc,CAAC,OAAO,QAAQ,CAAC,CAAC,SAAS,MAAM,MAAM,IACnG,aACA;EACR,KAAK,SAAS,CAAC,cAAc,CAAC,eAAe,aAAa;CAC5D;CAEA,IAAI,SAAiB;EACnB,OAAO,KAAK,MAAM;CACpB;CACA,IAAI,UAAmB;EACrB,OAAO,KAAK,MAAM;CACpB;CACA,IAAI,kBAA2B;EAC7B,OAAO,KAAK,MAAM,WAAW,KAAK;CACpC;;CAGA,IAAI,aAAmC;EACrC,MAAM,SAAS,KAAK,MAAM;EAC1B,IAAI,CAAC,KAAK,YAAY,OAAO;EAE7B,OAAO,UAAU,CAAC,KAAK,MAAM,WAAW,CAAC,OAAO,OAAO,SAAS,IAAI,IAChE;GAAE,GAAG;GAAQ,QAAQ,KAAK,WAAW;EAAE,IACvC,KAAA;CACN;CAEA,QAAQ,OAAiB;EACvB,OAAO,KAAK,MAAM,QAAQ,KAAK;CACjC;CACA,aAAa,OAAyB;EACpC,OAAO,KAAK,MAAM,aAAc,KAAK;CACvC;CACA,UAAU,OAAyB;EACjC,OAAO,KAAK,MAAM,UAAU,KAAK;CACnC;CACA,eAAe,OAAiB;EAC9B,OAAO,KAAK,MAAM,eAAe,KAAK;CACxC;AACF"}