@prisma/orm-framework 8.0.0-rc.14-dev.16 → 8.0.0-rc.14-dev.17

package/dist/{authoring-Bn_5zI9q.mjs → authoring-C8hxYYQI.mjs}

@@ -1,7 +1,7 @@
 import { r as isInternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
 import { t as canonicalStringify } from "./canonical-stringify-DY4NaAJi.mjs";
 import { t as canonicalizeJson } from "./canonicalize-json-ZPawceQR-Dua1VNEB.mjs";
-import { C as isAuthoringTypeConstructorDescriptor, _ as instantiateAuthoringTypeConstructor, b as isAuthoringFieldPresetDescriptor, m as hasRegisteredFieldNamespace, v as isAuthoringArgRef } from "./temporal-presets-DsGuaFyT-DWzKyja_.mjs";
+import { S as isAuthoringTypeConstructorDescriptor, _ as isAuthoringArgRef, g as instantiateAuthoringTypeConstructor, y as isAuthoringFieldPresetDescriptor } from "./temporal-presets-DzBBD4St-BaL1QaZ7.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/authoring.mjs
 function* typeConstructors(namespace, path = []) {
 	for (const [name, value] of Object.entries(namespace)) if (isAuthoringTypeConstructorDescriptor(value)) yield {
@@ -141,25 +141,7 @@ function getAuthoringFieldPreset(contributions, path) {
 	}
 	return current !== void 0 && isAuthoringFieldPresetDescriptor(current) ? current : void 0;
 }
-/**
-* Returns the namespace prefix of `attributeName` when it names an extension namespace that is not composed, otherwise `undefined`. A namespace is recognized when it is:
-*
-* - `db` (native-type spec, always allowed),
-* - the active family id,
-* - the active target id,
-* - a registered field-preset namespace (e.g. `temporal`),
-* - present in `composedExtensions`.
-*
-* Family, target, and field-preset namespaces are exempt so an attribute that does not exist under them surfaces as an unsupported attribute rather than as an uncomposed extension namespace.
-*/
-function checkUncomposedNamespace(attributeName, composedExtensions, context) {
-	const dotIndex = attributeName.indexOf(".");
-	if (dotIndex <= 0 || dotIndex === attributeName.length - 1) return;
-	const namespace = attributeName.slice(0, dotIndex);
-	if (namespace === "db" || namespace === context?.familyId || namespace === context?.targetId || hasRegisteredFieldNamespace(context?.authoringContributions, namespace) || composedExtensions.has(namespace)) return;
-	return namespace;
-}
 //#endregion
-export { readEnumBlockMembers as a, getAuthoringFieldPreset as i, fieldPresetSpellings as n, findAuthoringTypeConstructorCall as r, checkUncomposedNamespace as t };
+export { readEnumBlockMembers as i, findAuthoringTypeConstructorCall as n, getAuthoringFieldPreset as r, fieldPresetSpellings as t };
 
-//# sourceMappingURL=authoring-Bn_5zI9q.mjs.map
+//# sourceMappingURL=authoring-C8hxYYQI.mjs.map

package/dist/authoring-C8hxYYQI.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"authoring-C8hxYYQI.mjs","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/authoring.mjs"],"sourcesContent":["import { t as canonicalizeJson } from \"./canonicalize-json-ZPawceQR.mjs\";\nimport { C as instantiateAuthoringTypeConstructor, D as isAuthoringModelAttributeDescriptor, E as isAuthoringFieldPresetDescriptor, M as resolveAuthoringTemplateValue, N as resolveEnumCodecId, O as isAuthoringPslBlockDescriptor, P as validateAuthoringHelperArguments, S as instantiateAuthoringFieldPreset, T as isAuthoringEntityTypeDescriptor, a as temporalCodecPreset, b as getAuthoringTypeConstructor, d as printTaggedLiteral, g as classifyEnumMemberType, h as assertResolvableTypeConstructorTemplates, i as temporalAuthoringPresets, j as mergeAuthoringNamespaces, k as isAuthoringTypeConstructorDescriptor, m as assertNoCrossRegistryCollisions, n as TEMPORAL_ON_UPDATE_ARG, o as temporalPhaseTemplate, r as TIMESTAMP_NOW_GENERATOR_ID, t as TEMPORAL_ON_CREATE_ARG, v as collectScalarTypeConstructors, w as isAuthoringArgRef, x as instantiateAuthoringEntityType, y as flushAuthoringWarnings } from \"./temporal-presets-DzBBD4St.mjs\";\nimport { isInternalError } from \"@internal/utils/internal-error\";\nimport { canonicalStringify } from \"@internal/utils/canonical-stringify\";\n//#region src/shared/authoring-type-constructor-call.ts\nfunction* typeConstructors(namespace, path = []) {\n\tfor (const [name, value] of Object.entries(namespace)) if (isAuthoringTypeConstructorDescriptor(value)) yield {\n\t\tpath: [...path, name],\n\t\tdescriptor: value\n\t};\n\telse yield* typeConstructors(value, [...path, name]);\n}\nfunction produces(produced, wanted) {\n\tconst wantedFields = {\n\t\t...wanted,\n\t\ttypeParams: wanted.typeParams ?? {}\n\t};\n\treturn Object.entries({\n\t\t...produced,\n\t\ttypeParams: produced.typeParams ?? {}\n\t}).every(([key, value]) => canonicalizeJson(value) === canonicalizeJson(wantedFields[key]));\n}\n/**\n* The arguments that make `descriptor` produce exactly `output`, when each of its type parameters\n* comes straight from one argument; `undefined` when it cannot produce `output`, including when\n* `output` has no value for an argument the constructor requires.\n*/\nfunction argumentsFor(descriptor, output) {\n\tif (descriptor.entityRefArg !== void 0 || descriptor.output.codecId !== output.codecId) return;\n\tconst args = [];\n\tfor (const [key, template] of Object.entries(descriptor.output.typeParams ?? {})) {\n\t\tconst value = output.typeParams?.[key];\n\t\tif (value !== void 0 && isAuthoringArgRef(template) && template.path === void 0) args[template.index] = value;\n\t}\n\tconst requiredArgs = (descriptor.args ?? []).filter((arg) => arg.optional !== true).length;\n\tif (args.length < requiredArgs || Array.from(args).includes(void 0)) return void 0;\n\ttry {\n\t\treturn produces(instantiateAuthoringTypeConstructor(descriptor, args), output) ? args : void 0;\n\t} catch {\n\t\treturn;\n\t}\n}\n/**\n* The first call, in namespace order, to a type constructor in `namespace` that produces exactly\n* `output`. The inverse of {@link instantiateAuthoringTypeConstructor} for constructors whose type\n* parameters each come straight from one argument. A constructor whose argument names another\n* entity is never chosen. `undefined` when no call produces `output`.\n*/\nfunction findAuthoringTypeConstructorCall(namespace, output) {\n\tfor (const { path, descriptor } of typeConstructors(namespace)) {\n\t\tconst args = argumentsFor(descriptor, output);\n\t\tif (args !== void 0) return {\n\t\t\tpath,\n\t\t\targs\n\t\t};\n\t}\n}\n//#endregion\n//#region src/shared/enum-block-members.ts\n/**\n* Reads the members of an `enum` block through its codec. A bare member is read from its own name.\n* Pushes a diagnostic and returns `undefined` when the codec refuses a member, when two members\n* store the same value, or when the block has no members. Shared by every family's enum factory.\n*/\nfunction readEnumBlockMembers(block, codecId, codec, ctx) {\n\tconst sourceId = ctx.sourceId ?? \"unknown\";\n\tconst diagnostics = ctx.diagnostics;\n\tconst memberByStoredValue = /* @__PURE__ */ new Map();\n\tconst members = [];\n\tlet memberError = false;\n\tfor (const [memberName, memberValue] of Object.entries(block.values)) {\n\t\tconst span = block.parameterSpans[memberName] ?? block.span;\n\t\tconst written = memberValue === void 0 ? memberName : memberValue;\n\t\tlet read;\n\t\ttry {\n\t\t\tread = codec.decodeJson(written);\n\t\t} catch (err) {\n\t\t\tif (isInternalError(err)) throw err;\n\t\t\tdiagnostics?.push(memberValue === void 0 ? {\n\t\t\t\tcode: \"PSL_ENUM_BARE_MEMBER_NON_STRING_CODEC\",\n\t\t\t\tmessage: `enum \"${block.name}\" member \"${memberName}\" has no value and codec \"${codecId}\" does not accept a bare name as input`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t} : {\n\t\t\t\tcode: \"PSL_EXTENSION_INVALID_VALUE\",\n\t\t\t\tmessage: `enum \"${block.name}\" member \"${memberName}\" was rejected by codec \"${codecId}\": ${err instanceof Error ? err.message : String(err)}`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t});\n\t\t\tmemberError = true;\n\t\t\tcontinue;\n\t\t}\n\t\tconst stored = codec.encodeJson(read);\n\t\tconst storedKey = canonicalStringify(stored);\n\t\tconst earlier = memberByStoredValue.get(storedKey);\n\t\tif (earlier !== void 0) {\n\t\t\tdiagnostics?.push({\n\t\t\t\tcode: \"PSL_ENUM_DUPLICATE_MEMBER_VALUE\",\n\t\t\t\tmessage: `enum \"${block.name}\": members \"${earlier}\" and \"${memberName}\" both store ${JSON.stringify(stored)}`,\n\t\t\t\tsourceId,\n\t\t\t\tspan\n\t\t\t});\n\t\t\tmemberError = true;\n\t\t\tcontinue;\n\t\t}\n\t\tmemberByStoredValue.set(storedKey, memberName);\n\t\tmembers.push({\n\t\t\tname: memberName,\n\t\t\tvalue: read\n\t\t});\n\t}\n\tif (memberError) return void 0;\n\tif (members.length === 0) {\n\t\tdiagnostics?.push({\n\t\t\tcode: \"PSL_ENUM_MISSING_TYPE\",\n\t\t\tmessage: `enum \"${block.name}\" must have at least one member`,\n\t\t\tsourceId,\n\t\t\tspan: block.span\n\t\t});\n\t\treturn;\n\t}\n\treturn members;\n}\n//#endregion\n//#region src/shared/field-preset-resolution.ts\nfunction presetSpellingsUnder(members, prefix) {\n\treturn Object.entries(members).flatMap(([name, member]) => isAuthoringFieldPresetDescriptor(member) ? [`${prefix}.${name}(${(member.args ?? []).map((arg, index) => arg.name ?? `argument${index + 1}`).join(\", \")})`] : presetSpellingsUnder(member, `${prefix}.${name}`));\n}\n/**\n* How each field preset registered under `namespace`, at any depth, is written, with the names of its arguments: `temporal.timestamp(onCreate, onUpdate)`.\n*/\nfunction fieldPresetSpellings(contributions, namespace) {\n\tconst members = contributions?.field?.[namespace];\n\tif (members === void 0 || isAuthoringFieldPresetDescriptor(members)) return [];\n\treturn presetSpellingsUnder(members, namespace);\n}\n/**\n* Walks `authoringContributions.field` segment by segment and returns the field-preset descriptor at the path, or `undefined` when none is registered there.\n*/\nfunction getAuthoringFieldPreset(contributions, path) {\n\tlet current = contributions?.field;\n\tfor (const segment of path) {\n\t\tif (typeof current !== \"object\" || current === null || \"kind\" in current) return;\n\t\tcurrent = current[segment];\n\t}\n\treturn current !== void 0 && isAuthoringFieldPresetDescriptor(current) ? current : void 0;\n}\n//#endregion\nexport { TEMPORAL_ON_CREATE_ARG, TEMPORAL_ON_UPDATE_ARG, TIMESTAMP_NOW_GENERATOR_ID, assertNoCrossRegistryCollisions, assertResolvableTypeConstructorTemplates, classifyEnumMemberType, collectScalarTypeConstructors, fieldPresetSpellings, findAuthoringTypeConstructorCall, flushAuthoringWarnings, getAuthoringFieldPreset, getAuthoringTypeConstructor, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringArgRef, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, mergeAuthoringNamespaces, printTaggedLiteral, readEnumBlockMembers, resolveAuthoringTemplateValue, resolveEnumCodecId, temporalAuthoringPresets, temporalCodecPreset, temporalPhaseTemplate, validateAuthoringHelperArguments };\n\n//# sourceMappingURL=authoring.mjs.map"],"mappings":";;;;;AAKA,UAAU,iBAAiB,WAAW,OAAO,CAAC,GAAG;CAChD,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,SAAS,GAAG,IAAI,qCAAqC,KAAK,GAAG,MAAM;EAC7G,MAAM,CAAC,GAAG,MAAM,IAAI;EACpB,YAAY;CACb;MACK,OAAO,iBAAiB,OAAO,CAAC,GAAG,MAAM,IAAI,CAAC;AACpD;AACA,SAAS,SAAS,UAAU,QAAQ;CACnC,MAAM,eAAe;EACpB,GAAG;EACH,YAAY,OAAO,cAAc,CAAC;CACnC;CACA,OAAO,OAAO,QAAQ;EACrB,GAAG;EACH,YAAY,SAAS,cAAc,CAAC;CACrC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,WAAW,iBAAiB,KAAK,MAAM,iBAAiB,aAAa,IAAI,CAAC;AAC3F;;;;;;AAMA,SAAS,aAAa,YAAY,QAAQ;CACzC,IAAI,WAAW,iBAAiB,KAAK,KAAK,WAAW,OAAO,YAAY,OAAO,SAAS;CACxF,MAAM,OAAO,CAAC;CACd,KAAK,MAAM,CAAC,KAAK,aAAa,OAAO,QAAQ,WAAW,OAAO,cAAc,CAAC,CAAC,GAAG;EACjF,MAAM,QAAQ,OAAO,aAAa;EAClC,IAAI,UAAU,KAAK,KAAK,kBAAkB,QAAQ,KAAK,SAAS,SAAS,KAAK,GAAG,KAAK,SAAS,SAAS;CACzG;CACA,MAAM,gBAAgB,WAAW,QAAQ,CAAC,EAAA,CAAG,QAAQ,QAAQ,IAAI,aAAa,IAAI,CAAC,CAAC;CACpF,IAAI,KAAK,SAAS,gBAAgB,MAAM,KAAK,IAAI,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,OAAO,KAAK;CACjF,IAAI;EACH,OAAO,SAAS,oCAAoC,YAAY,IAAI,GAAG,MAAM,IAAI,OAAO,KAAK;CAC9F,QAAQ;EACP;CACD;AACD;;;;;;;AAOA,SAAS,iCAAiC,WAAW,QAAQ;CAC5D,KAAK,MAAM,EAAE,MAAM,gBAAgB,iBAAiB,SAAS,GAAG;EAC/D,MAAM,OAAO,aAAa,YAAY,MAAM;EAC5C,IAAI,SAAS,KAAK,GAAG,OAAO;GAC3B;GACA;EACD;CACD;AACD;;;;;;AAQA,SAAS,qBAAqB,OAAO,SAAS,OAAO,KAAK;CACzD,MAAM,WAAW,IAAI,YAAY;CACjC,MAAM,cAAc,IAAI;CACxB,MAAM,sCAAsC,IAAI,IAAI;CACpD,MAAM,UAAU,CAAC;CACjB,IAAI,cAAc;CAClB,KAAK,MAAM,CAAC,YAAY,gBAAgB,OAAO,QAAQ,MAAM,MAAM,GAAG;EACrE,MAAM,OAAO,MAAM,eAAe,eAAe,MAAM;EACvD,MAAM,UAAU,gBAAgB,KAAK,IAAI,aAAa;EACtD,IAAI;EACJ,IAAI;GACH,OAAO,MAAM,WAAW,OAAO;EAChC,SAAS,KAAK;GACb,IAAI,gBAAgB,GAAG,GAAG,MAAM;GAChC,aAAa,KAAK,gBAAgB,KAAK,IAAI;IAC1C,MAAM;IACN,SAAS,SAAS,MAAM,KAAK,YAAY,WAAW,4BAA4B,QAAQ;IACxF;IACA;GACD,IAAI;IACH,MAAM;IACN,SAAS,SAAS,MAAM,KAAK,YAAY,WAAW,2BAA2B,QAAQ,KAAK,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;IAC3I;IACA;GACD,CAAC;GACD,cAAc;GACd;EACD;EACA,MAAM,SAAS,MAAM,WAAW,IAAI;EACpC,MAAM,YAAY,mBAAmB,MAAM;EAC3C,MAAM,UAAU,oBAAoB,IAAI,SAAS;EACjD,IAAI,YAAY,KAAK,GAAG;GACvB,aAAa,KAAK;IACjB,MAAM;IACN,SAAS,SAAS,MAAM,KAAK,cAAc,QAAQ,SAAS,WAAW,eAAe,KAAK,UAAU,MAAM;IAC3G;IACA;GACD,CAAC;GACD,cAAc;GACd;EACD;EACA,oBAAoB,IAAI,WAAW,UAAU;EAC7C,QAAQ,KAAK;GACZ,MAAM;GACN,OAAO;EACR,CAAC;CACF;CACA,IAAI,aAAa,OAAO,KAAK;CAC7B,IAAI,QAAQ,WAAW,GAAG;EACzB,aAAa,KAAK;GACjB,MAAM;GACN,SAAS,SAAS,MAAM,KAAK;GAC7B;GACA,MAAM,MAAM;EACb,CAAC;EACD;CACD;CACA,OAAO;AACR;AAGA,SAAS,qBAAqB,SAAS,QAAQ;CAC9C,OAAO,OAAO,QAAQ,OAAO,CAAC,CAAC,SAAS,CAAC,MAAM,YAAY,iCAAiC,MAAM,IAAI,CAAC,GAAG,OAAO,GAAG,KAAK,IAAI,OAAO,QAAQ,CAAC,EAAA,CAAG,KAAK,KAAK,UAAU,IAAI,QAAQ,WAAW,QAAQ,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,EAAE,IAAI,qBAAqB,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAC3Q;;;;AAIA,SAAS,qBAAqB,eAAe,WAAW;CACvD,MAAM,UAAU,eAAe,QAAQ;CACvC,IAAI,YAAY,KAAK,KAAK,iCAAiC,OAAO,GAAG,OAAO,CAAC;CAC7E,OAAO,qBAAqB,SAAS,SAAS;AAC/C;;;;AAIA,SAAS,wBAAwB,eAAe,MAAM;CACrD,IAAI,UAAU,eAAe;CAC7B,KAAK,MAAM,WAAW,MAAM;EAC3B,IAAI,OAAO,YAAY,YAAY,YAAY,QAAQ,UAAU,SAAS;EAC1E,UAAU,QAAQ;CACnB;CACA,OAAO,YAAY,KAAK,KAAK,iCAAiC,OAAO,IAAI,UAAU,KAAK;AACzF"}

package/dist/{authoring-DTZsvKV7.d.mts → authoring-CQOFIHhF.d.mts}

@@ -1,7 +1,7 @@
 import { V as JsonValue } from "./domain-envelope-C2vVIWGK-C5x7cBpU.mjs";
 import { i as Codec } from "./codec-types-DrcxdLlC-CAfu8HRL.mjs";
-import { F as ParsedPslExtensionBlock, a as AuthoringContributions, et as instantiateAuthoringTypeConstructor, k as AuthoringTypeNamespace, p as AuthoringFieldPresetDescriptor, s as AuthoringEntityContext } from "./framework-authoring-CsVwBOxP-saf7NH7p.mjs";
-import "./temporal-presets-UGhnJIuo-DCoJ3HJj.mjs";
+import { $ as instantiateAuthoringTypeConstructor, F as ParsedPslExtensionBlock, a as AuthoringContributions, k as AuthoringTypeNamespace, p as AuthoringFieldPresetDescriptor, s as AuthoringEntityContext } from "./framework-authoring-BLXTNi9g-CcRc8u9I.mjs";
+import "./temporal-presets-DKHiZVPP-DLAr--Pb.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/authoring.d.mts
 //#region src/shared/authoring-type-constructor-call.d.ts
 /** What a type constructor call produces for a column. */
@@ -40,22 +40,6 @@ declare function fieldPresetSpellings(contributions: AuthoringContributions | un
  * Walks `authoringContributions.field` segment by segment and returns the field-preset descriptor at the path, or `undefined` when none is registered there.
  */
 declare function getAuthoringFieldPreset(contributions: AuthoringContributions | undefined, path: readonly string[]): AuthoringFieldPresetDescriptor | undefined;
-/**
- * Returns the namespace prefix of `attributeName` when it names an extension namespace that is not composed, otherwise `undefined`. A namespace is recognized when it is:
- *
- * - `db` (native-type spec, always allowed),
- * - the active family id,
- * - the active target id,
- * - a registered field-preset namespace (e.g. `temporal`),
- * - present in `composedExtensions`.
- *
- * Family, target, and field-preset namespaces are exempt so an attribute that does not exist under them surfaces as an unsupported attribute rather than as an uncomposed extension namespace.
- */
-declare function checkUncomposedNamespace(attributeName: string, composedExtensions: ReadonlySet<string>, context?: {
-  readonly familyId?: string;
-  readonly targetId?: string;
-  readonly authoringContributions?: AuthoringContributions | undefined;
-}): string | undefined;
 //#endregion
-export { fieldPresetSpellings as a, readEnumBlockMembers as c, checkUncomposedNamespace as i, AuthoringTypeConstructorOutput as n, findAuthoringTypeConstructorCall as o, EnumBlockMember as r, getAuthoringFieldPreset as s, AuthoringTypeConstructorCall as t };
-//# sourceMappingURL=authoring-DTZsvKV7.d.mts.map
+export { findAuthoringTypeConstructorCall as a, fieldPresetSpellings as i, AuthoringTypeConstructorOutput as n, getAuthoringFieldPreset as o, EnumBlockMember as r, readEnumBlockMembers as s, AuthoringTypeConstructorCall as t };
+//# sourceMappingURL=authoring-CQOFIHhF.d.mts.map

package/dist/{authoring-DTZsvKV7.d.mts.map → authoring-CQOFIHhF.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"authoring-DTZsvKV7.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/authoring.d.mts"],"mappings":";;;;;;;KAMK,iCAAiC,kBAAkB;;UAE9C;WACC;WACA;;;;;;;;iBAQM,iCAAiC,WAAW,wBAAwB,QAAQ,iCAAiC;;;UAGpH;WACC;WACA;;;;;;;iBAOM,qBAAqB,OAAO,wBAAwB,SAAS,eAAe,0BAA0B,iBAAiB,OAAO,OAAO,KAAK,kCAAkC;;;;;;iBAM5K,qBAAqB,eAAe,oCAAoC;;;;iBAIxE,wBAAwB,eAAe,oCAAoC,0BAA0B;;;;;;;;;;;;iBAYrG,yBAAyB,uBAAuB,oBAAoB,qBAAqB;WAC/F;WACA;WACA,yBAAyB"}
+{"version":3,"file":"authoring-CQOFIHhF.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/authoring.d.mts"],"mappings":";;;;;;;KAMK,iCAAiC,kBAAkB;;UAE9C;WACC;WACA;;;;;;;;iBAQM,iCAAiC,WAAW,wBAAwB,QAAQ,iCAAiC;;;UAGpH;WACC;WACA;;;;;;;iBAOM,qBAAqB,OAAO,wBAAwB,SAAS,eAAe,0BAA0B,iBAAiB,OAAO,OAAO,KAAK,kCAAkC;;;;;;iBAM5K,qBAAqB,eAAe,oCAAoC;;;;iBAIxE,wBAAwB,eAAe,oCAAoC,0BAA0B"}

package/dist/binder-CQGFQCuK-DrdVszQh.d.mts

@@ -0,0 +1,452 @@
+import { V as JsonValue } from "./domain-envelope-C2vVIWGK-C5x7cBpU.mjs";
+import { D as AuthoringTypeConstructorDescriptor, U as PslSpan, p as AuthoringFieldPresetDescriptor } from "./framework-authoring-BLXTNi9g-CcRc8u9I.mjs";
+import { i as ControlMutationDefaults } from "./mutation-default-types-ZfKqVdmf-DATmLFpQ.mjs";
+import { o as TaggedLiteralCanonicalization } from "./temporal-presets-DKHiZVPP-DLAr--Pb.mjs";
+import "./authoring-CQOFIHhF.mjs";
+import { r as Result } from "./result-BYCOANWy.mjs";
+import "./control-B059zyD4.mjs";
+import "./psl-ast-DA_tKWiL.mjs";
+import { n as ContractSourceContext } from "./config-types-DDNiQ3jk.mjs";
+import { D as NamespaceDeclarationAst, E as NamedTypeDeclarationAst, I as PslDiagnostic, K as SyntaxNode, M as ParseDiagnostic, R as PslSources, T as ModelDeclarationAst, X as TypeAnnotationAst, _ as GenericBlockDeclarationAst, f as DocumentAst, h as FieldDeclarationAst, l as CompositeTypeDeclarationAst, m as FieldAttributeAst, n as AstNode, p as ExpressionAst, w as ModelAttributeAst } from "./parse-DqMTVHCw-DqqgVEUq.mjs";
+import { n as UnionToIntersection, t as Simplify } from "./types-DGxlljKG.mjs";
+//#region ../../../1-framework/2-authoring/psl-parser/dist/binder-CQGFQCuK.d.mts
+//#region src/resolve.d.ts
+interface ResolvedAttributeArg {
+  readonly kind: 'positional' | 'named';
+  readonly name?: string;
+  readonly value: string;
+  readonly expression?: ExpressionAst;
+  readonly span: PslSpan;
+}
+interface ResolvedAttribute<TNode extends FieldAttributeAst | ModelAttributeAst = FieldAttributeAst | ModelAttributeAst> {
+  readonly name: string;
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+  readonly node: TNode;
+}
+interface ResolvedTypeConstructorCall {
+  readonly path: readonly string[];
+  readonly args: readonly ResolvedAttributeArg[];
+  readonly span: PslSpan;
+}
+declare function readResolvedAttribute<TNode extends FieldAttributeAst | ModelAttributeAst>(attribute: TNode, sources: PslSources): ResolvedAttribute<TNode>;
+declare function readResolvedAttributes<TNode extends FieldAttributeAst | ModelAttributeAst>(attributes: Iterable<TNode>, sources: PslSources): readonly ResolvedAttribute<TNode>[];
+declare function readResolvedConstructorCall(annotation: TypeAnnotationAst | undefined, sources: PslSources): ResolvedTypeConstructorCall | undefined;
+declare function nodePslSpan(node: SyntaxNode, sources: PslSources): PslSpan;
+/** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
+declare function keywordPslSpan(node: SyntaxNode, keyword: string, sources: PslSources): PslSpan;
+//#endregion
+//#region src/symbol-table.d.ts
+interface SymbolTable {
+  readonly topLevel: TopLevelScope;
+}
+interface TopLevelScope {
+  readonly namespaces: Record<string, NamespaceSymbol>;
+  readonly namedTypes: Record<string, NamedTypeSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+}
+interface NamespaceDeclaration {
+  readonly node: NamespaceDeclarationAst;
+  readonly span: PslSpan;
+}
+interface NamespaceSymbol {
+  readonly kind: 'namespace';
+  readonly name: string;
+  readonly declarations: [NamespaceDeclaration, ...NamespaceDeclaration[]];
+  readonly models: Record<string, ModelSymbol>;
+  readonly compositeTypes: Record<string, CompositeTypeSymbol>;
+  readonly blocks: Record<string, BlockSymbol>;
+}
+interface ModelSymbol {
+  readonly kind: 'model';
+  readonly name: string;
+  readonly node: ModelDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface CompositeTypeSymbol {
+  readonly kind: 'compositeType';
+  readonly name: string;
+  readonly node: CompositeTypeDeclarationAst;
+  readonly span: PslSpan;
+  readonly fields: Record<string, FieldSymbol>;
+  readonly attributes: readonly ResolvedAttribute<ModelAttributeAst>[];
+}
+interface BlockSymbol {
+  readonly kind: 'block';
+  readonly name: string;
+  readonly keyword: string;
+  readonly node: GenericBlockDeclarationAst;
+  readonly span: PslSpan;
+}
+interface ResolvedNamedTypeBinding {
+  readonly baseType?: string;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly isConstructor: boolean;
+  readonly attributes: readonly ResolvedAttribute<FieldAttributeAst>[];
+}
+/**
+ * A `types {}` binding, collected without classification: whether the binding
+ * refines a target scalar is pronounced by the interpreter
+ * (`resolveNamedTypeDeclarations`), not by the family-blind symbol table.
+ */
+interface NamedTypeSymbol extends ResolvedNamedTypeBinding {
+  readonly kind: 'namedType';
+  readonly name: string;
+  readonly node: NamedTypeDeclarationAst;
+  readonly span: PslSpan;
+}
+interface FieldSymbol {
+  readonly kind: 'field';
+  readonly name: string;
+  readonly node: FieldDeclarationAst;
+  readonly span: PslSpan;
+  readonly typeName: string;
+  readonly typeNamespaceId?: string;
+  readonly typeContractSpaceId?: string;
+  readonly optional: boolean;
+  readonly list: boolean;
+  /** Element-nullability axis (`Foo?[]`); meaningful only when {@link list}. */
+  readonly elementOptional: boolean;
+  readonly typeConstructor?: ResolvedTypeConstructorCall;
+  readonly attributes: readonly ResolvedAttribute<FieldAttributeAst>[];
+  /** Prevents cascading unsupported-type diagnostics after invalid qualification. */
+  readonly malformedType?: boolean;
+}
+interface BuildSymbolTableOptions {
+  readonly documents: readonly DocumentAst[];
+  readonly sources: PslSources;
+}
+interface SymbolTableResult {
+  readonly symbolTable: SymbolTable;
+  readonly diagnostics: readonly ParseDiagnostic[];
+}
+/**
+ * Owns duplicate-declaration detection for all PSL scopes; downstream consumers
+ * should consume first-wins symbols rather than re-emitting duplicate diagnostics.
+ */
+declare function buildSymbolTable(options: BuildSymbolTableOptions): SymbolTableResult;
+//#endregion
+//#region src/entity-reference.d.ts
+type EntitySelector = {
+  readonly kind: 'model';
+} | {
+  readonly kind: 'compositeType';
+} | {
+  readonly kind: 'namedType';
+} | {
+  readonly kind: 'block';
+  readonly keyword: string;
+};
+type EntityDeclaration = ModelSymbol | CompositeTypeSymbol | NamedTypeSymbol | BlockSymbol;
+type DeclarationFor<S extends EntitySelector> = Extract<EntityDeclaration, {
+  kind: S['kind'];
+}>;
+interface ResolvedEntityReference<D extends EntityDeclaration = EntityDeclaration> {
+  readonly declaration: D;
+  readonly namespace: NamespaceSymbol | undefined;
+}
+declare function entityReference(resolution: Resolution): ResolvedEntityReference | undefined;
+declare function matchesSelector<S extends EntitySelector>(reference: ResolvedEntityReference, expected: S): reference is ResolvedEntityReference<DeclarationFor<S>>;
+//#endregion
+//#region src/attribute-spec/types.d.ts
+type AttributeLevel = 'field' | 'model' | 'block';
+interface AttributeCtx {
+  readonly sources: PslSources;
+  readonly symbols: SymbolTable;
+  readonly binder: Binder;
+}
+interface ModelAttributeCtx extends AttributeCtx {
+  readonly selfModel: ModelSymbol;
+}
+interface FieldAttributeCtx extends ModelAttributeCtx {
+  readonly field: FieldSymbol;
+}
+type ArgTypeKind = 'bool' | 'entityRef' | 'fieldRef' | 'funcCall' | 'identifier' | 'int' | 'json' | 'null' | 'list' | 'num' | 'oneOf' | 'record' | 'referencedFieldRef' | 'rejecting' | 'str' | 'taggedLiteral';
+type ArgTypeContext = 'attribute' | 'field' | 'model';
+interface ArgTypeOutput<T, Ctx extends AttributeCtx> {
+  readonly label: string;
+  readonly _out?: T;
+  readonly parse: (arg: ExpressionAst, ctx: Ctx) => Result<T, readonly PslDiagnostic[]>;
+}
+interface BoolArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<boolean, Ctx> {
+  readonly kind: 'bool';
+}
+interface EntityRefArgType<D extends EntityDeclaration = EntityDeclaration, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<ResolvedEntityReference<D>, Ctx> {
+  readonly kind: 'entityRef';
+  readonly expected: EntitySelector;
+}
+interface FieldRefArgType<Ctx extends ModelAttributeCtx = ModelAttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'fieldRef';
+}
+interface ReferencedFieldRefArgType<Ctx extends FieldAttributeCtx = FieldAttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'referencedFieldRef';
+}
+interface FuncCallSig {
+  readonly documentation: string;
+  readonly positional?: readonly PositionalParam<unknown, AttributeCtx>[];
+  readonly named?: Readonly<Record<string, Param<unknown, AttributeCtx>>>;
+}
+interface TypedFuncCall {
+  readonly fn: string;
+  readonly span: PslSpan;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+interface FuncCallArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx, Signature extends FuncCallSig = FuncCallSig> extends ArgTypeOutput<TypedFuncCall, Ctx> {
+  readonly kind: 'funcCall';
+  readonly name: Name;
+  readonly signature: Signature;
+}
+interface FixedIdentifierArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Name, Ctx> {
+  readonly kind: 'identifier';
+  readonly name: Name;
+  readonly documentation: string;
+}
+interface UnrestrictedIdentifierArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'identifier';
+  readonly name: undefined;
+}
+type IdentifierArgType<Name extends string = string, Ctx extends AttributeCtx = AttributeCtx> = FixedIdentifierArgType<Name, Ctx> | UnrestrictedIdentifierArgType<Ctx>;
+interface IntArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<number, Ctx> {
+  readonly kind: 'int';
+  readonly min?: number;
+  readonly max?: number;
+}
+interface JsonArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Record<string, unknown>, Ctx> {
+  readonly kind: 'json';
+}
+interface JsonValueArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<JsonValue, Ctx> {
+  readonly kind: 'oneOf';
+  readonly alternatives: readonly [UnrestrictedStrArgType<Ctx>, UnrestrictedNumArgType<Ctx>, BoolArgType<Ctx>, NullArgType<Ctx>, ListArgType<JsonValue, Ctx>, RecordArgType<JsonValue, Ctx>];
+}
+interface NullArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<null, Ctx> {
+  readonly kind: 'null';
+}
+interface ListArgType<T = unknown, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T[], Ctx> {
+  readonly kind: 'list';
+  readonly of: ArgType<T, Ctx>;
+  readonly allowEmpty: boolean;
+  readonly unique: boolean;
+}
+interface UnrestrictedNumArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<number, Ctx> {
+  readonly kind: 'num';
+  readonly value: undefined;
+}
+interface FixedNumArgType<T extends number = number, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'num';
+  readonly value: T;
+}
+interface NumLiteral {
+  readonly text: string;
+}
+interface NumLiteralArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<NumLiteral, Ctx> {
+  readonly kind: 'num';
+  readonly value: undefined;
+}
+interface OneOfArgType<Alts extends readonly [AnyArgType, ...AnyArgType[]], Ctx extends AttributeCtx = ContextForRequirement<RequiredContextFor<CtxOf<Alts[number]>>>> extends ArgTypeOutput<OutOf<Alts[number]>, Ctx>, OneOfMetadata {
+  readonly alternatives: Alts;
+}
+interface OneOfMetadata {
+  readonly kind: 'oneOf';
+  readonly alternatives: readonly [AnyArgType, ...AnyArgType[]];
+}
+interface RecordArgType<T = unknown, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<Record<string, T>, Ctx> {
+  readonly kind: 'record';
+  readonly of: ArgType<T, Ctx>;
+}
+interface RejectingArgType<T = never, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'rejecting';
+  readonly message: string;
+}
+interface UnrestrictedStrArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<string, Ctx> {
+  readonly kind: 'str';
+  readonly value: undefined;
+}
+interface FixedStrArgType<T extends string = string, Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<T, Ctx> {
+  readonly kind: 'str';
+  readonly value: T;
+}
+/**
+ * A tagged literal argument as parsed: its tag, the canonicalization of its string literal, and its
+ * span. Neither the tag nor the canonicalization has been checked; lowering does both.
+ */
+interface ParsedTaggedLiteral {
+  readonly tag: string;
+  readonly canonicalization: TaggedLiteralCanonicalization;
+  readonly span: PslSpan;
+}
+interface TaggedLiteralArgType<Ctx extends AttributeCtx = AttributeCtx> extends ArgTypeOutput<ParsedTaggedLiteral, Ctx> {
+  readonly kind: 'taggedLiteral';
+  readonly tags: readonly string[];
+  readonly documentation: string;
+}
+type ArgTypeMetadata<Type> = Type extends object ? Omit<Type, keyof ArgTypeOutput<unknown, never>> : never;
+type ArgType<T, Ctx extends AttributeCtx> = ArgTypeOutput<T, Ctx> & ArgTypeMetadata<ArgTypeVariant<Ctx>>;
+type AnyArgType = ArgType<unknown, AttributeCtx> | ArgType<unknown, ModelAttributeCtx> | ArgType<unknown, FieldAttributeCtx>;
+type CtxOf<P> = P extends ArgTypeOutput<unknown, infer Ctx> ? Ctx : never;
+type RequiredContextFor<Ctx extends AttributeCtx> = [Extract<Ctx, FieldAttributeCtx>] extends [never] ? [Extract<Ctx, ModelAttributeCtx>] extends [never] ? 'attribute' : 'model' : 'field';
+type ContextForRequirement<Req extends ArgTypeContext> = Req extends 'field' ? FieldAttributeCtx : Req extends 'model' ? ModelAttributeCtx : AttributeCtx;
+type InspectableArgType<Ctx extends AttributeCtx> = ArgType<unknown, Ctx>;
+type ArgTypeVariant<Ctx extends AttributeCtx> = BoolArgType<Ctx> | EntityRefArgType<EntityDeclaration, Ctx> | FieldRefArgType<ModelAttributeCtx & Ctx> | FuncCallArgType<string, Ctx> | IdentifierArgType<string, Ctx> | IntArgType<Ctx> | JsonArgType<Ctx> | NullArgType<Ctx> | ListArgType<unknown, Ctx> | FixedNumArgType<number, Ctx> | UnrestrictedNumArgType<Ctx> | NumLiteralArgType<Ctx> | OneOfMetadata | RecordArgType<unknown, Ctx> | ReferencedFieldRefArgType<FieldAttributeCtx & Ctx> | RejectingArgType<never, Ctx> | FixedStrArgType<string, Ctx> | UnrestrictedStrArgType<Ctx> | TaggedLiteralArgType<Ctx>;
+type OptionalArgType<T, Ctx extends AttributeCtx, Type extends object = ArgType<T, Ctx>, HasDefault extends boolean = boolean> = Type & {
+  readonly optional: true;
+  readonly hasDefault: HasDefault;
+  readonly defaultValue?: T | undefined;
+};
+interface Param<T, Ctx extends AttributeCtx> {
+  readonly type: ArgType<T, Ctx>;
+  readonly documentation: string;
+}
+interface PositionalParam<T, Ctx extends AttributeCtx> extends Param<T, Ctx> {
+  readonly key: string;
+}
+interface AttributeSpec<Out, Ctx extends AttributeCtx> {
+  readonly documentation: string;
+  readonly level: AttributeLevel;
+  readonly name: string;
+  readonly positional: readonly PositionalParam<unknown, Ctx>[];
+  readonly named: Readonly<Record<string, Param<unknown, Ctx>>>;
+  /**
+   * Cross-argument validation after all arguments parse. `attributeNode` is
+   * the attribute's own AST node so refines can span-anchor their
+   * diagnostics at the attribute rather than the enclosing model.
+   */
+  readonly refine?: (parsed: Out, ctx: Ctx, attributeNode: AstNode) => readonly PslDiagnostic[];
+}
+type OutOf<P> = P extends {
+  readonly _out?: infer T;
+} ? T : never;
+type OptionalMarker = {
+  readonly optional: true;
+};
+type NamedOut<N extends Record<string, Param<unknown, never>>> = Simplify<{ [K in keyof N as N[K]['type'] extends OptionalMarker ? never : K]: OutOf<N[K]['type']>; } & { [K in keyof N as N[K]['type'] extends OptionalMarker ? K : never]?: OutOf<N[K]['type']>; }>;
+type PosEntryObject<E extends PositionalParam<unknown, never>> = E['type'] extends OptionalMarker ? { [K in E['key']]?: OutOf<E['type']>; } : { [K in E['key']]: OutOf<E['type']>; };
+type PosOut<Pos extends readonly PositionalParam<unknown, never>[]> = Simplify<UnionToIntersection<{ [I in keyof Pos]: PosEntryObject<Pos[I]>; }[number]>>;
+type AttributeOut<Pos extends readonly PositionalParam<unknown, never>[], Named extends Record<string, Param<unknown, never>>> = Simplify<PosOut<Pos> & NamedOut<Named>>;
+type InferAttr<S> = S extends AttributeSpec<infer Out, never> ? Out : never;
+//#endregion
+//#region src/contributed-type-scope.d.ts
+type ContributedTypeDescriptor = AuthoringTypeConstructorDescriptor | AuthoringFieldPresetDescriptor;
+type ContributedTypeNamespace = {
+  readonly [name: string]: ContributedTypeDescriptor | ContributedTypeNamespace;
+};
+interface ContributedTypeSymbol {
+  readonly kind: 'contributedType';
+  readonly name: string;
+  readonly path: readonly string[];
+  readonly descriptor: ContributedTypeDescriptor;
+}
+interface ContributedNamespaceSymbol {
+  readonly kind: 'contributedNamespace';
+  readonly name: string;
+  readonly path: readonly string[];
+  readonly members: ReadonlyMap<string, ContributedMember>;
+}
+type ContributedMember = ContributedTypeSymbol | ContributedNamespaceSymbol;
+interface ContributedTypeScope {
+  lookup(name: string): ContributedMember | undefined;
+  entries(): Iterable<readonly [string, ContributedMember]>;
+}
+//#endregion
+//#region src/scope.d.ts
+type ScopeResolution = {
+  readonly kind: 'model';
+  readonly symbol: ModelSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'compositeType';
+  readonly symbol: CompositeTypeSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'namedType';
+  readonly symbol: NamedTypeSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'block';
+  readonly symbol: BlockSymbol;
+  readonly namespace?: NamespaceSymbol;
+} | {
+  readonly kind: 'namespace';
+  readonly symbol: NamespaceSymbol;
+} | {
+  readonly kind: 'contributedNamespace';
+  readonly symbol: ContributedNamespaceSymbol;
+} | {
+  readonly kind: 'contributedType';
+  readonly symbol: ContributedTypeSymbol;
+};
+declare abstract class Scope {
+  protected readonly parent: Scope | undefined;
+  constructor(parent: Scope | undefined);
+  abstract lookup(name: string): ScopeResolution | undefined;
+  protected abstract ownNames(): Iterable<string>;
+  entries(): Iterable<readonly [string, ScopeResolution]>;
+}
+declare function isNamespaceLike(resolution: ScopeResolution): resolution is Extract<ScopeResolution, {
+  kind: 'namespace' | 'contributedNamespace';
+}>;
+declare function memberEntries(qualifier: Extract<ScopeResolution, {
+  kind: 'namespace' | 'contributedNamespace';
+}>): Iterable<readonly [string, ScopeResolution]>;
+//#endregion
+//#region src/binder.d.ts
+declare const PSL_UNRESOLVED_REFERENCE = "PSL_UNRESOLVED_REFERENCE";
+type BoundSpec = AttributeSpec<never, ModelAttributeCtx> | AttributeSpec<never, FieldAttributeCtx>;
+interface AttributeSymbol {
+  readonly kind: 'attribute';
+  readonly name: string;
+  readonly level: 'model' | 'field';
+  readonly spec: BoundSpec;
+}
+type PslSymbol = ModelSymbol | CompositeTypeSymbol | NamedTypeSymbol | BlockSymbol | NamespaceSymbol | FieldSymbol;
+type Resolution = ScopeResolution | {
+  readonly kind: 'field';
+  readonly symbol: FieldSymbol;
+} | {
+  readonly kind: 'attribute';
+  readonly symbol: AttributeSymbol;
+} | {
+  readonly kind: 'crossSpace';
+} | {
+  readonly kind: 'unresolved';
+  readonly name: string;
+};
+interface Binder {
+  declaredSymbol(node: SyntaxNode): PslSymbol | undefined;
+  symbolForNode(node: SyntaxNode): Resolution | undefined;
+  scopeAt(node: SyntaxNode): Scope;
+}
+interface UnsupportedAttribute {
+  readonly attribute: ResolvedAttribute;
+  readonly level: 'model' | 'field';
+  readonly owner: ModelSymbol | CompositeTypeSymbol;
+  readonly field: FieldSymbol | undefined;
+}
+type DescribeUnsupportedAttribute = (unsupported: UnsupportedAttribute) => ParseDiagnostic | undefined;
+interface UnresolvedTypeReference {
+  readonly field: FieldSymbol;
+  readonly owner: ModelSymbol | CompositeTypeSymbol;
+  readonly written: string;
+}
+type DescribeUnresolvedType = (unresolved: UnresolvedTypeReference) => string | undefined;
+interface BinderContext extends Pick<ContractSourceContext, 'authoringContributions' | 'pslDiagnostics'> {
+  readonly controlMutationDefaults: Pick<ControlMutationDefaults, 'defaultFunctionRegistry'>;
+}
+interface CreateBinderInput {
+  readonly sources: PslSources;
+  readonly symbolTable: SymbolTable;
+  readonly context: BinderContext;
+}
+interface BinderResult {
+  readonly binder: Binder;
+  readonly diagnostics: readonly ParseDiagnostic[];
+}
+declare function typeReferenceNode(symbol: FieldSymbol | NamedTypeSymbol): SyntaxNode | undefined;
+declare function contributedTypeOf(resolution: Resolution | undefined, binder: Binder): ContributedTypeSymbol | undefined;
+declare function createBinder(input: CreateBinderInput): BinderResult;
+//#endregion
+export { NumLiteral as $, EntityRefArgType as A, UnrestrictedStrArgType as At, IdentifierArgType as B, nodePslSpan as Bt, ContributedTypeSymbol as C, SymbolTableResult as Ct, DescribeUnresolvedType as D, UnresolvedTypeReference as Dt, DeclarationFor as E, TypedFuncCall as Et, FixedIdentifierArgType as F, entityReference as Ft, JsonValueArgType as G, InspectableArgType as H, readResolvedAttributes as Ht, FixedNumArgType as I, isNamespaceLike as It, ModelSymbol as J, ListArgType as K, FixedStrArgType as L, keywordPslSpan as Lt, FieldAttributeCtx as M, buildSymbolTable as Mt, FieldRefArgType as N, contributedTypeOf as Nt, DescribeUnsupportedAttribute as O, UnrestrictedIdentifierArgType as Ot, FieldSymbol as P, createBinder as Pt, NullArgType as Q, FuncCallArgType as R, matchesSelector as Rt, ContributedTypeScope as S, SymbolTable as St, CtxOf as T, TopLevelScope as Tt, IntArgType as U, readResolvedConstructorCall as Ut, InferAttr as V, readResolvedAttribute as Vt, JsonArgType as W, typeReferenceNode as Wt, NamedTypeSymbol as X, NamedOut as Y, NamespaceSymbol as Z, ContextForRequirement as _, ResolvedEntityReference as _t, AttributeLevel as a, Param as at, ContributedTypeDescriptor as b, Scope as bt, AttributeSymbol as c, PositionalParam as ct, BinderResult as d, ReferencedFieldRefArgType as dt, NumLiteralArgType as et, BlockSymbol as f, RejectingArgType as ft, CompositeTypeSymbol as g, ResolvedAttributeArg as gt, BuildSymbolTableOptions as h, ResolvedAttribute as ht, AttributeCtx as i, PSL_UNRESOLVED_REFERENCE as it, EntitySelector as j, UnsupportedAttribute as jt, EntityDeclaration as k, UnrestrictedNumArgType as kt, Binder as l, PslSymbol as lt, BoundSpec as m, Resolution as mt, ArgType as n, OptionalArgType as nt, AttributeOut as o, ParsedTaggedLiteral as ot, BoolArgType as p, RequiredContextFor as pt, ModelAttributeCtx as q, ArgTypeKind as r, OutOf as rt, AttributeSpec as s, PosOut as st, AnyArgType as t, OneOfArgType as tt, BinderContext as u, RecordArgType as ut, ContributedMember as v, ResolvedNamedTypeBinding as vt, CreateBinderInput as w, TaggedLiteralArgType as wt, ContributedTypeNamespace as x, ScopeResolution as xt, ContributedNamespaceSymbol as y, ResolvedTypeConstructorCall as yt, FuncCallSig as z, memberEntries as zt };
+//# sourceMappingURL=binder-CQGFQCuK-DrdVszQh.d.mts.map

package/dist/binder-CQGFQCuK-DrdVszQh.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binder-CQGFQCuK-DrdVszQh.d.mts","names":[],"sources":["../../../../1-framework/2-authoring/psl-parser/dist/binder-CQGFQCuK.d.mts"],"mappings":"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"}

package/dist/{components-DgQX4ccF.d.mts → components-DFA65tWf.d.mts}

@@ -1,6 +1,6 @@
 import { g as CodecTrait } from "./codec-types-DrcxdLlC-CAfu8HRL.mjs";
 import { t as AggregateDescriptor } from "./types-import-spec-D-EPunhV-B3y6hGP5.mjs";
-import "./framework-components-DNtoaHTX-DWt4JeHF.mjs";
+import "./framework-components-CwclBqDh-CBGrY3Ry.mjs";
 //#region ../../../1-framework/1-core/framework-components/dist/components.d.mts
 //#region src/shared/aggregate-overloads.d.ts
 /** What settling needs to know about a codec: its id, and the traits an overload can claim it by. */
@@ -47,4 +47,4 @@ interface SettledAggregateOverloads<TDescriptor extends AggregateDescriptor> {
 declare function settleAggregateOverloads<TDescriptor extends AggregateDescriptor>(descriptors: readonly TDescriptor[], codecs: Iterable<AggregateCodecTraits>): SettledAggregateOverloads<TDescriptor>;
 //#endregion
 export { SettledAggregateOverloads as a, SettledAggregateOperation as i, AggregateOverloadAmbiguity as n, settleAggregateOverloads as o, AggregateOverloadDuplicate as r, AggregateCodecTraits as t };
-//# sourceMappingURL=components-DgQX4ccF.d.mts.map
+//# sourceMappingURL=components-DFA65tWf.d.mts.map

package/dist/{components-DgQX4ccF.d.mts.map → components-DFA65tWf.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"components-DgQX4ccF.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/components.d.mts"],"mappings":";;;;;;UAOU;WACC;WACA,iBAAiB;;;UAGlB,0BAA0B,oBAAoB;;WAE7C,WAAW,oBAAoB;;WAE/B,SAAS;;WAET,UAAU;;;UAGX;WACC;WACA;WACA,iBAAiB;;;UAGlB,2BAA2B,oBAAoB;WAC9C;WACA;WACA,OAAO;WACP,QAAQ;;UAET,0BAA0B,oBAAoB;WAC7C,YAAY,oBAAoB,0BAA0B;WAC1D,sBAAsB;WACtB,qBAAqB,2BAA2B;;;;;;;;;;;iBAW1C,yBAAyB,oBAAoB,qBAAqB,sBAAsB,eAAe,QAAQ,SAAS,wBAAwB,0BAA0B"}
+{"version":3,"file":"components-DFA65tWf.d.mts","names":[],"sources":["../../../../1-framework/1-core/framework-components/dist/components.d.mts"],"mappings":";;;;;;UAOU;WACC;WACA,iBAAiB;;;UAGlB,0BAA0B,oBAAoB;;WAE7C,WAAW,oBAAoB;;WAE/B,SAAS;;WAET,UAAU;;;UAGX;WACC;WACA;WACA,iBAAiB;;;UAGlB,2BAA2B,oBAAoB;WAC9C;WACA;WACA,OAAO;WACP,QAAQ;;UAET,0BAA0B,oBAAoB;WAC7C,YAAY,oBAAoB,0BAA0B;WAC1D,sBAAsB;WACtB,qBAAqB,2BAA2B;;;;;;;;;;;iBAW1C,yBAAyB,oBAAoB,qBAAqB,sBAAsB,eAAe,QAAQ,SAAS,wBAAwB,0BAA0B"}