@prisma-next/contract 0.3.0-dev.134 → 0.3.0-dev.135

package/dist/framework-components.d.mts

@@ -1,7 +1,103 @@
 import { O as RenderTypeContext, z as TypesImportSpec } from "./types-BwcW0HFt.mjs";
 
+//#region src/framework-authoring.d.ts
+type AuthoringArgRef = {
+  readonly kind: 'arg';
+  readonly index: number;
+  readonly path?: readonly string[];
+  readonly default?: AuthoringTemplateValue;
+};
+type AuthoringTemplateValue = string | number | boolean | null | AuthoringArgRef | readonly AuthoringTemplateValue[] | {
+  readonly [key: string]: AuthoringTemplateValue;
+};
+type AuthoringArgumentDescriptor = {
+  readonly kind: 'string';
+  readonly optional?: boolean;
+} | {
+  readonly kind: 'number';
+  readonly optional?: boolean;
+  readonly integer?: boolean;
+  readonly minimum?: number;
+  readonly maximum?: number;
+} | {
+  readonly kind: 'stringArray';
+  readonly optional?: boolean;
+} | {
+  readonly kind: 'object';
+  readonly optional?: boolean;
+  readonly properties: Record<string, AuthoringArgumentDescriptor>;
+};
+interface AuthoringStorageTypeTemplate {
+  readonly codecId: string;
+  readonly nativeType: AuthoringTemplateValue;
+  readonly typeParams?: Record<string, AuthoringTemplateValue>;
+}
+interface AuthoringTypeConstructorDescriptor {
+  readonly kind: 'typeConstructor';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringStorageTypeTemplate;
+}
+interface AuthoringColumnDefaultTemplateLiteral {
+  readonly kind: 'literal';
+  readonly value: AuthoringTemplateValue;
+}
+interface AuthoringColumnDefaultTemplateFunction {
+  readonly kind: 'function';
+  readonly expression: AuthoringTemplateValue;
+}
+type AuthoringColumnDefaultTemplate = AuthoringColumnDefaultTemplateLiteral | AuthoringColumnDefaultTemplateFunction;
+interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {
+  readonly nullable?: boolean;
+  readonly default?: AuthoringColumnDefaultTemplate;
+  readonly executionDefault?: AuthoringTemplateValue;
+  readonly id?: boolean;
+  readonly unique?: boolean;
+}
+interface AuthoringFieldPresetDescriptor {
+  readonly kind: 'fieldPreset';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringFieldPresetOutput;
+}
+type AuthoringTypeNamespace = {
+  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;
+};
+type AuthoringFieldNamespace = {
+  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;
+};
+interface AuthoringContributions {
+  readonly type?: AuthoringTypeNamespace;
+  readonly field?: AuthoringFieldNamespace;
+}
+declare function isAuthoringArgRef(value: unknown): value is AuthoringArgRef;
+declare function isAuthoringTypeConstructorDescriptor(value: unknown): value is AuthoringTypeConstructorDescriptor;
+declare function isAuthoringFieldPresetDescriptor(value: unknown): value is AuthoringFieldPresetDescriptor;
+declare function resolveAuthoringTemplateValue(template: AuthoringTemplateValue, args: readonly unknown[]): unknown;
+declare function validateAuthoringHelperArguments(helperPath: string, descriptors: readonly AuthoringArgumentDescriptor[] | undefined, args: readonly unknown[]): void;
+declare function instantiateAuthoringTypeConstructor(descriptor: AuthoringTypeConstructorDescriptor, args: readonly unknown[]): {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+};
+declare function instantiateAuthoringFieldPreset(descriptor: AuthoringFieldPresetDescriptor, args: readonly unknown[]): {
+  readonly descriptor: {
+    readonly codecId: string;
+    readonly nativeType: string;
+    readonly typeParams?: Record<string, unknown>;
+  };
+  readonly nullable: boolean;
+  readonly default?: {
+    readonly kind: 'literal';
+    readonly value: unknown;
+  } | {
+    readonly kind: 'function';
+    readonly expression: string;
+  };
+  readonly executionDefault?: unknown;
+  readonly id: boolean;
+  readonly unique: boolean;
+};
+//#endregion
 //#region src/framework-components.d.ts
-
 /**
  * A template-based type renderer (structured form).
  * Uses mustache-style placeholders (e.g., `Vector<{{length}}>`) that are
@@ -151,6 +247,14 @@ interface ComponentMetadata {
       readonly nativeType?: string;
     }>;
   };
+  /**
+   * Optional pure-data authoring contributions exposed by this component.
+   *
+   * These contributions are safe to include on pack refs and descriptors because
+   * they contain only declarative metadata. Higher-level authoring packages may
+   * project them into concrete helper functions for TS-first workflows.
+   */
+  readonly authoring?: AuthoringContributions;
 }
 /**
  * Base descriptor for any framework component.
@@ -272,7 +376,9 @@ interface PackRefBase<Kind extends string, TFamilyId extends string> extends Com
   readonly id: string;
   readonly familyId: TFamilyId;
   readonly targetId?: string;
+  readonly authoring?: AuthoringContributions;
 }
+type FamilyPackRef<TFamilyId extends string = string> = PackRefBase<'family', TFamilyId>;
 type TargetPackRef<TFamilyId extends string = string, TTargetId extends string = string> = PackRefBase<'target', TFamilyId> & {
   readonly targetId: TTargetId;
 };
@@ -388,142 +494,27 @@ interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends string
   /** The target this extension is designed for */
   readonly targetId: TTargetId;
 }
-/**
- * Union type for target-bound component descriptors.
- *
- * Target-bound components are those that must be compatible with a specific
- * family+target combination. This includes targets, adapters, drivers, and
- * extensions. Families are not target-bound.
- *
- * This type is used in migration and verification interfaces to enforce
- * type-level compatibility between components.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * // All these components must have matching familyId and targetId
- * const components: TargetBoundComponentDescriptor<'sql', 'postgres'>[] = [
- *   postgresTarget,
- *   postgresAdapter,
- *   postgresDriver,
- *   pgvectorExtension,
- * ];
- * ```
- */
+/** Components bound to a specific family+target combination. */
 type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> = TargetDescriptor<TFamilyId, TTargetId> | AdapterDescriptor<TFamilyId, TTargetId> | DriverDescriptor<TFamilyId, TTargetId> | ExtensionDescriptor<TFamilyId, TTargetId>;
-/**
- * Base interface for family instances.
- *
- * A family instance is created by a family descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add domain actions (e.g., `emitContract`, `verify` on ControlFamilyInstance).
- *
- * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')
- *
- * @example
- * ```ts
- * const instance = sql.create({ target, adapter, driver, extensions });
- * instance.familyId // 'sql'
- * ```
- */
 interface FamilyInstance<TFamilyId extends string> {
-  /** The family identifier (e.g., 'sql', 'document') */
   readonly familyId: TFamilyId;
 }
-/**
- * Base interface for target instances.
- *
- * A target instance is created by a target descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add target-specific behavior.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')
- *
- * @example
- * ```ts
- * const instance = postgres.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 interface TargetInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this target belongs to */
   readonly familyId: TFamilyId;
-  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */
   readonly targetId: TTargetId;
 }
-/**
- * Base interface for adapter instances.
- *
- * An adapter instance is created by an adapter descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add adapter-specific behavior (e.g., codec registration, query lowering).
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = postgresAdapter.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this adapter belongs to */
   readonly familyId: TFamilyId;
-  /** The target this adapter is designed for */
   readonly targetId: TTargetId;
 }
-/**
- * Base interface for driver instances.
- *
- * A driver instance is created by a driver descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add driver-specific behavior (e.g., `query`, `close` on ControlDriverInstance).
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = postgresDriver.create({ databaseUrl });
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 interface DriverInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this driver belongs to */
   readonly familyId: TFamilyId;
-  /** The target this driver connects to */
   readonly targetId: TTargetId;
 }
-/**
- * Base interface for extension instances.
- *
- * An extension instance is created by an extension descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add extension-specific behavior.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = pgvector.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this extension belongs to */
   readonly familyId: TFamilyId;
-  /** The target this extension is designed for */
   readonly targetId: TTargetId;
 }
 //#endregion
-export { type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type DriverDescriptor, type DriverInstance, type DriverPackRef, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type NormalizedTypeRenderer, type PackRefBase, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetPackRef, type TypeRenderer, type TypeRendererFunction, type TypeRendererTemplate, checkContractComponentRequirements, interpolateTypeTemplate, normalizeRenderer };
+export { type AdapterDescriptor, type AdapterInstance, type AdapterPackRef, type AuthoringArgRef, type AuthoringArgumentDescriptor, type AuthoringColumnDefaultTemplate, type AuthoringContributions, type AuthoringFieldNamespace, type AuthoringFieldPresetDescriptor, type AuthoringFieldPresetOutput, type AuthoringStorageTypeTemplate, type AuthoringTemplateValue, type AuthoringTypeConstructorDescriptor, type AuthoringTypeNamespace, type ComponentDescriptor, type ComponentMetadata, type ContractComponentRequirementsCheckInput, type ContractComponentRequirementsCheckResult, type DriverDescriptor, type DriverInstance, type DriverPackRef, type ExtensionDescriptor, type ExtensionInstance, type ExtensionPackRef, type FamilyDescriptor, type FamilyInstance, type FamilyPackRef, type NormalizedTypeRenderer, type PackRefBase, type TargetBoundComponentDescriptor, type TargetDescriptor, type TargetInstance, type TargetPackRef, type TypeRenderer, type TypeRendererFunction, type TypeRendererTemplate, checkContractComponentRequirements, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, interpolateTypeTemplate, isAuthoringArgRef, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, normalizeRenderer, resolveAuthoringTemplateValue, validateAuthoringHelperArguments };
 //# sourceMappingURL=framework-components.d.mts.map

package/dist/framework-components.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"framework-components.d.mts","names":[],"sources":["../src/framework-components.ts"],"sourcesContent":[],"mappings":";;;;;;AAaA;AAiBA;AAgBA;AAYA;AAiBA;;;;;AAIwB,UAlEP,oBAAA,CAkEO;EAMP,SAAA,IAAA,EAAA,UAAsB;EAWvB;EA4BA,SAAA,QAAA,EAAA,MAAiB;AA8BjC;;;;;;;;;;;AA0EA;AAQiB,UA9MA,oBAAA,CA8MA;EAWA,SAAA,IAAA,EAAA,UAAA;EAMD;EA+DC,SAAA,MAAA,EAAA,CAAA,MAAgB,EA3RL,MA2RK,CAAA,MAAA,EAEZ,OAAA,CAAA,EAF+C,GAAA,EA3RV,iBA2R6B,EAAA,GAAA,MAAA;AAgCvF;;;;;AAaA;;;;;AAQA;AAG0B,KAtUd,kBAAA,GAsUc,MAAA;;;;AAI1B;;;;;AAOA;;AAGI,KAxUQ,uBAAA,GAwUR,CAAA,MAAA,EAvUM,MAuUN,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,EAtUG,iBAsUH,EAAA,GAAA,MAAA;;;AAIJ;;;;;AAmCA;;;;;AAuCiB,KArYL,YAAA,GACR,kBAoY6B,GAnY7B,uBAmY6B,GAlY7B,oBAkY6B,GAjY7B,oBAiY6B;;;;;AAoChB,UA/ZA,sBAAA,CA+ZmB;EAGf,SAAA,OAAA,EAAA,MAAA;EAGA,SAAA,MAAA,EAAA,CAAA,MAAA,EAnaO,MAmaP,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,EAnaqC,iBAmarC,EAAA,GAAA,MAAA;;;AA2BrB;;;;;AAEiC,iBAvbjB,uBAAA,CAubiB,QAAA,EAAA,MAAA,EAAA,MAAA,EArbvB,MAqbuB,CAAA,MAAA,EAAA,OAAA,CAAA,EAAA,GAAA,EApb1B,iBAob0B,CAAA,EAAA,MAAA;;;;;;;;;AAmBjC;AAsBA;AAyBiB,iBA7dD,iBAAA,CA6dgB,OAAA,EAAA,MAEX,EAAA,QAGA,EAlewC,YAke/B,CAAA,EAle8C,sBAke9C;AAoB9B;AAyBA;;UAjfiB,iBAAA;;;;;;;;;;;0BAYS;;;;;;;;wBASF;;;;;;;;+BAQO,eAAe;;;;;;;;;6BASjB,cAAc;;;;;mCAKR;;;uBAEc;;uBAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4BN,iDAAiD;;iBAEjD;;;;UAMA,uCAAA;;;;8BAIa;;;;iCAIG;;UAGhB,wCAAA;;;;;;;;;;;iBAMD,kCAAA,QACP,0CACN;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA6Dc,mDAAmD;;qBAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BJ,6EACP;;qBAEW;;qBAGA;;;;;;UAOJ,mEACP;iBACO;;qBAEI;;;KAIT,sFAGR,sBAAsB;qBACL;;KAGT,uFAGR,uBAAuB;qBACN;;KAGT,yFAGR,yBAAyB;qBACR;;KAGT,sFAGR,sBAAsB;qBACL;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BJ,8EACP;;qBAEW;;qBAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAiCJ,6EACP;;qBAEW;;qBAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA8BJ,gFACP;;qBAEW;;qBAGA;;;;;;;;;;;;;;;;;;;;;;;;;;KA2BT,qFACR,iBAAiB,WAAW,aAC5B,kBAAkB,WAAW,aAC7B,iBAAiB,WAAW,aAC5B,oBAAoB,WAAW;;;;;;;;;;;;;;;;UAiBlB;;qBAEI;;;;;;;;;;;;;;;;;;;UAoBJ;;qBAEI;;qBAGA;;;;;;;;;;;;;;;;;;;UAoBJ;;qBAEI;;qBAGA;;;;;;;;;;;;;;;;;;;UAoBJ;;qBAEI;;qBAGA;;;;;;;;;;;;;;;;;;;UAoBJ;;qBAEI;;qBAGA"}
+{"version":3,"file":"framework-components.d.mts","names":[],"sources":["../src/framework-authoring.ts","../src/framework-components.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/framework-components.mjs

@@ -1,3 +1,123 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/framework-authoring.ts
+function isAuthoringArgRef(value) {
+	if (typeof value !== "object" || value === null || value.kind !== "arg") return false;
+	const { index, path } = value;
+	if (typeof index !== "number" || !Number.isInteger(index) || index < 0) return false;
+	if (path !== void 0 && (!Array.isArray(path) || path.some((s) => typeof s !== "string"))) return false;
+	return true;
+}
+function isAuthoringTemplateRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAuthoringTypeConstructorDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "typeConstructor" && typeof value.output === "object" && value.output !== null;
+}
+function isAuthoringFieldPresetDescriptor(value) {
+	return typeof value === "object" && value !== null && value.kind === "fieldPreset" && typeof value.output === "object" && value.output !== null;
+}
+function resolveAuthoringTemplateValue(template, args) {
+	if (isAuthoringArgRef(template)) {
+		let value = args[template.index];
+		for (const segment of template.path ?? []) {
+			if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {
+				value = void 0;
+				break;
+			}
+			value = value[segment];
+		}
+		if (value === void 0 && template.default !== void 0) return resolveAuthoringTemplateValue(template.default, args);
+		return value;
+	}
+	if (Array.isArray(template)) return template.map((value) => resolveAuthoringTemplateValue(value, args));
+	if (typeof template === "object" && template !== null) {
+		const resolved = {};
+		for (const [key, value] of Object.entries(template)) {
+			const resolvedValue = resolveAuthoringTemplateValue(value, args);
+			if (resolvedValue !== void 0) resolved[key] = resolvedValue;
+		}
+		return resolved;
+	}
+	return template;
+}
+function validateAuthoringArgument(descriptor, value, path) {
+	if (value === void 0) {
+		if (descriptor.optional) return;
+		throw new Error(`Missing required authoring helper argument at ${path}`);
+	}
+	if (descriptor.kind === "string") {
+		if (typeof value !== "string") throw new Error(`Authoring helper argument at ${path} must be a string`);
+		return;
+	}
+	if (descriptor.kind === "stringArray") {
+		if (!Array.isArray(value)) throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+		for (const entry of value) if (typeof entry !== "string") throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+		return;
+	}
+	if (descriptor.kind === "object") {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`Authoring helper argument at ${path} must be an object`);
+		const input = value;
+		const expectedKeys = new Set(Object.keys(descriptor.properties));
+		for (const key of Object.keys(input)) if (!expectedKeys.has(key)) throw new Error(`Authoring helper argument at ${path} contains unknown property "${key}"`);
+		for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);
+		return;
+	}
+	if (typeof value !== "number" || Number.isNaN(value)) throw new Error(`Authoring helper argument at ${path} must be a number`);
+	if (descriptor.integer && !Number.isInteger(value)) throw new Error(`Authoring helper argument at ${path} must be an integer`);
+	if (descriptor.minimum !== void 0 && value < descriptor.minimum) throw new Error(`Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`);
+	if (descriptor.maximum !== void 0 && value > descriptor.maximum) throw new Error(`Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`);
+}
+function validateAuthoringHelperArguments(helperPath, descriptors, args) {
+	const expected = descriptors ?? [];
+	const minimumArgs = expected.reduce((count, descriptor, index) => descriptor.optional ? count : index + 1, 0);
+	if (args.length < minimumArgs || args.length > expected.length) throw new Error(`${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`);
+	expected.forEach((descriptor, index) => {
+		validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);
+	});
+}
+function resolveAuthoringStorageTypeTemplate(template, args) {
+	const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);
+	if (typeof nativeType !== "string") throw new Error(`Resolved authoring nativeType must be a string for codec "${template.codecId}", received ${String(nativeType)}`);
+	const typeParams = template.typeParams === void 0 ? void 0 : resolveAuthoringTemplateValue(template.typeParams, args);
+	if (typeParams !== void 0 && !isAuthoringTemplateRecord(typeParams)) throw new Error(`Resolved authoring typeParams must be an object for codec "${template.codecId}", received ${String(typeParams)}`);
+	return {
+		codecId: template.codecId,
+		nativeType,
+		...typeParams === void 0 ? {} : { typeParams }
+	};
+}
+function resolveAuthoringColumnDefaultTemplate(template, args) {
+	if (template.kind === "literal") {
+		const value = resolveAuthoringTemplateValue(template.value, args);
+		if (value === void 0) throw new Error("Resolved authoring literal default must not be undefined");
+		return {
+			kind: "literal",
+			value
+		};
+	}
+	const expression = resolveAuthoringTemplateValue(template.expression, args);
+	if (expression === void 0 || typeof expression === "object" && expression !== null) throw new Error(`Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`);
+	return {
+		kind: "function",
+		expression: String(expression)
+	};
+}
+function instantiateAuthoringTypeConstructor(descriptor, args) {
+	return resolveAuthoringStorageTypeTemplate(descriptor.output, args);
+}
+function instantiateAuthoringFieldPreset(descriptor, args) {
+	return {
+		descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),
+		nullable: descriptor.output.nullable ?? false,
+		...ifDefined("default", descriptor.output.default !== void 0 ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args) : void 0),
+		...ifDefined("executionDefault", descriptor.output.executionDefault !== void 0 ? resolveAuthoringTemplateValue(descriptor.output.executionDefault, args) : void 0),
+		id: descriptor.output.id ?? false,
+		unique: descriptor.output.unique ?? false
+	};
+}
+
+//#endregion
 //#region src/framework-components.ts
 /**
 * Interpolates a template string with params values.
@@ -66,5 +186,5 @@ function checkContractComponentRequirements(input) {
 }
 
 //#endregion
-export { checkContractComponentRequirements, interpolateTypeTemplate, normalizeRenderer };
+export { checkContractComponentRequirements, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, interpolateTypeTemplate, isAuthoringArgRef, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, normalizeRenderer, resolveAuthoringTemplateValue, validateAuthoringHelperArguments };
 //# sourceMappingURL=framework-components.mjs.map

package/dist/framework-components.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"framework-components.mjs","names":[],"sources":["../src/framework-components.ts"],"sourcesContent":["import type { RenderTypeContext, TypesImportSpec } from './types';\n\n/**\n * A template-based type renderer (structured form).\n * Uses mustache-style placeholders (e.g., `Vector<{{length}}>`) that are\n * replaced with typeParams values during rendering.\n *\n * @example\n * ```ts\n * { kind: 'template', template: 'Vector<{{length}}>' }\n * // With typeParams { length: 1536 }, renders: 'Vector<1536>'\n * ```\n */\nexport interface TypeRendererTemplate {\n  readonly kind: 'template';\n  /** Template string with `{{key}}` placeholders for typeParams values */\n  readonly template: string;\n}\n\n/**\n * A function-based type renderer for full control over type expression generation.\n *\n * @example\n * ```ts\n * {\n *   kind: 'function',\n *   render: (params, ctx) => `Vector<${params.length}>`\n * }\n * ```\n */\nexport interface TypeRendererFunction {\n  readonly kind: 'function';\n  /** Render function that produces a TypeScript type expression */\n  readonly render: (params: Record<string, unknown>, ctx: RenderTypeContext) => string;\n}\n\n/**\n * A raw template string type renderer (convenience form).\n * Shorthand for TypeRendererTemplate - just the template string without wrapper.\n *\n * @example\n * ```ts\n * 'Vector<{{length}}>'\n * // Equivalent to: { kind: 'template', template: 'Vector<{{length}}>' }\n * ```\n */\nexport type TypeRendererString = string;\n\n/**\n * A raw function type renderer (convenience form).\n * Shorthand for TypeRendererFunction - just the function without wrapper.\n *\n * @example\n * ```ts\n * (params, ctx) => `Vector<${params.length}>`\n * // Equivalent to: { kind: 'function', render: ... }\n * ```\n */\nexport type TypeRendererRawFunction = (\n  params: Record<string, unknown>,\n  ctx: RenderTypeContext,\n) => string;\n\n/**\n * Union of type renderer formats.\n *\n * Supports both structured forms (with `kind` discriminator) and convenience forms:\n * - `string` - Template string with `{{key}}` placeholders (manifest-safe, JSON-serializable)\n * - `function` - Render function for full control (requires runtime execution)\n * - `{ kind: 'template', template: string }` - Structured template form\n * - `{ kind: 'function', render: fn }` - Structured function form\n *\n * Templates are normalized to functions during pack assembly.\n * **Prefer template strings** for most cases - they are JSON-serializable.\n */\nexport type TypeRenderer =\n  | TypeRendererString\n  | TypeRendererRawFunction\n  | TypeRendererTemplate\n  | TypeRendererFunction;\n\n/**\n * Normalized type renderer - always a function after assembly.\n * This is the form received by the emitter.\n */\nexport interface NormalizedTypeRenderer {\n  readonly codecId: string;\n  readonly render: (params: Record<string, unknown>, ctx: RenderTypeContext) => string;\n}\n\n/**\n * Interpolates a template string with params values.\n * Used internally by normalizeRenderer to compile templates to functions.\n *\n * @throws Error if a placeholder key is not found in params (except 'CodecTypes')\n */\nexport function interpolateTypeTemplate(\n  template: string,\n  params: Record<string, unknown>,\n  ctx: RenderTypeContext,\n): string {\n  return template.replace(/\\{\\{(\\w+)\\}\\}/g, (_, key: string) => {\n    if (key === 'CodecTypes') return ctx.codecTypesName;\n    const value = params[key];\n    if (value === undefined) {\n      throw new Error(\n        `Missing template parameter \"${key}\" in template \"${template}\". ` +\n          `Available params: ${Object.keys(params).join(', ') || '(none)'}`,\n      );\n    }\n    return String(value);\n  });\n}\n\n/**\n * Normalizes a TypeRenderer to function form.\n * Called during pack assembly, not at emission time.\n *\n * Handles all TypeRenderer forms:\n * - Raw string template: `'Vector<{{length}}>'`\n * - Raw function: `(params, ctx) => ...`\n * - Structured template: `{ kind: 'template', template: '...' }`\n * - Structured function: `{ kind: 'function', render: fn }`\n */\nexport function normalizeRenderer(codecId: string, renderer: TypeRenderer): NormalizedTypeRenderer {\n  // Handle raw string (template shorthand)\n  if (typeof renderer === 'string') {\n    return {\n      codecId,\n      render: (params, ctx) => interpolateTypeTemplate(renderer, params, ctx),\n    };\n  }\n\n  // Handle raw function (function shorthand)\n  if (typeof renderer === 'function') {\n    return { codecId, render: renderer };\n  }\n\n  // Handle structured function form\n  if (renderer.kind === 'function') {\n    return { codecId, render: renderer.render };\n  }\n\n  // Handle structured template form\n  const { template } = renderer;\n  return {\n    codecId,\n    render: (params, ctx) => interpolateTypeTemplate(template, params, ctx),\n  };\n}\n\n/**\n * Declarative fields that describe component metadata.\n */\nexport interface ComponentMetadata {\n  /** Component version (semver) */\n  readonly version: string;\n\n  /**\n   * Capabilities this component provides.\n   *\n   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into\n   * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);\n   * keep these declarations in sync. Targets are identifiers/descriptors and typically do not\n   * declare capabilities.\n   */\n  readonly capabilities?: Record<string, unknown>;\n\n  /** Type imports for contract.d.ts generation */\n  readonly types?: {\n    readonly codecTypes?: {\n      /**\n       * Base codec types import spec.\n       * Optional: adapters typically provide this, extensions usually don't.\n       */\n      readonly import?: TypesImportSpec;\n      /**\n       * Optional renderers for parameterized codecs owned by this component.\n       * Key is codecId (e.g., 'pg/vector@1'), value is the type renderer.\n       *\n       * Templates are normalized to functions during pack assembly.\n       * Duplicate codecId across descriptors is a hard error.\n       */\n      readonly parameterized?: Record<string, TypeRenderer>;\n      /**\n       * Optional additional type-only imports required by parameterized renderers.\n       *\n       * These imports are included in generated `contract.d.ts` but are NOT treated as\n       * codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).\n       *\n       * Example: `Vector<N>` for pgvector renderers that emit `Vector<{{length}}>`\n       */\n      readonly typeImports?: ReadonlyArray<TypesImportSpec>;\n      /**\n       * Optional control-plane hooks keyed by codecId.\n       * Used by family-specific planners/verifiers to handle storage types.\n       */\n      readonly controlPlaneHooks?: Record<string, unknown>;\n    };\n    readonly operationTypes?: { readonly import: TypesImportSpec };\n    readonly storage?: ReadonlyArray<{\n      readonly typeId: string;\n      readonly familyId: string;\n      readonly targetId: string;\n      readonly nativeType?: string;\n    }>;\n  };\n}\n\n/**\n * Base descriptor for any framework component.\n *\n * All component descriptors share these fundamental properties that identify\n * the component and provide its metadata. This interface is extended by\n * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).\n *\n * @template Kind - Discriminator literal identifying the component type.\n *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',\n *   but the type accepts any string to allow ecosystem extensions.\n *\n * @example\n * ```ts\n * // All descriptors have these properties\n * descriptor.kind     // The Kind type parameter (e.g., 'family', 'target', or custom kinds)\n * descriptor.id       // Unique string identifier (e.g., 'sql', 'postgres')\n * descriptor.version  // Component version (semver)\n * ```\n */\nexport interface ComponentDescriptor<Kind extends string> extends ComponentMetadata {\n  /** Discriminator identifying the component type */\n  readonly kind: Kind;\n\n  /** Unique identifier for this component (e.g., 'sql', 'postgres', 'pgvector') */\n  readonly id: string;\n}\n\nexport interface ContractComponentRequirementsCheckInput {\n  readonly contract: {\n    readonly target: string;\n    readonly targetFamily?: string | undefined;\n    readonly extensionPacks?: Record<string, unknown> | undefined;\n  };\n  readonly expectedTargetFamily?: string | undefined;\n  readonly expectedTargetId?: string | undefined;\n  readonly providedComponentIds: Iterable<string>;\n}\n\nexport interface ContractComponentRequirementsCheckResult {\n  readonly familyMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly targetMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly missingExtensionPackIds: readonly string[];\n}\n\nexport function checkContractComponentRequirements(\n  input: ContractComponentRequirementsCheckInput,\n): ContractComponentRequirementsCheckResult {\n  const providedIds = new Set<string>();\n  for (const id of input.providedComponentIds) {\n    providedIds.add(id);\n  }\n\n  const requiredExtensionPackIds = input.contract.extensionPacks\n    ? Object.keys(input.contract.extensionPacks)\n    : [];\n  const missingExtensionPackIds = requiredExtensionPackIds.filter((id) => !providedIds.has(id));\n\n  const expectedTargetFamily = input.expectedTargetFamily;\n  const contractTargetFamily = input.contract.targetFamily;\n  const familyMismatch =\n    expectedTargetFamily !== undefined &&\n    contractTargetFamily !== undefined &&\n    contractTargetFamily !== expectedTargetFamily\n      ? { expected: expectedTargetFamily, actual: contractTargetFamily }\n      : undefined;\n\n  const expectedTargetId = input.expectedTargetId;\n  const contractTargetId = input.contract.target;\n  const targetMismatch =\n    expectedTargetId !== undefined && contractTargetId !== expectedTargetId\n      ? { expected: expectedTargetId, actual: contractTargetId }\n      : undefined;\n\n  return {\n    ...(familyMismatch ? { familyMismatch } : {}),\n    ...(targetMismatch ? { targetMismatch } : {}),\n    missingExtensionPackIds,\n  };\n}\n\n/**\n * Descriptor for a family component.\n *\n * A \"family\" represents a category of data sources with shared semantics\n * (e.g., SQL databases, document stores). Families define:\n * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)\n * - Contract structure (tables vs collections, columns vs fields)\n * - Type system and codecs\n *\n * Families are the top-level grouping. Each family contains multiple targets\n * (e.g., SQL family contains Postgres, MySQL, SQLite targets).\n *\n * Extended by plane-specific descriptors:\n * - `ControlFamilyDescriptor` - adds `hook` for CLI/tooling operations\n * - `RuntimeFamilyDescriptor` - adds runtime-specific factory methods\n *\n * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')\n *\n * @example\n * ```ts\n * import sql from '@prisma-next/family-sql/control';\n *\n * sql.kind     // 'family'\n * sql.familyId // 'sql'\n * sql.id       // 'sql'\n * ```\n */\nexport interface FamilyDescriptor<TFamilyId extends string> extends ComponentDescriptor<'family'> {\n  /** The family identifier (e.g., 'sql', 'document') */\n  readonly familyId: TFamilyId;\n}\n\n/**\n * Descriptor for a target component.\n *\n * A \"target\" represents a specific database or data store within a family\n * (e.g., Postgres, MySQL, MongoDB). Targets define:\n * - Native type mappings (e.g., Postgres int4 → TypeScript number)\n * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)\n *\n * Targets are bound to a family and provide the target-specific implementation\n * details that adapters and drivers use.\n *\n * Extended by plane-specific descriptors:\n * - `ControlTargetDescriptor` - adds optional `migrations` capability\n * - `RuntimeTargetDescriptor` - adds runtime factory method\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')\n *\n * @example\n * ```ts\n * import postgres from '@prisma-next/target-postgres/control';\n *\n * postgres.kind     // 'target'\n * postgres.familyId // 'sql'\n * postgres.targetId // 'postgres'\n * ```\n */\nexport interface TargetDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'target'> {\n  /** The family this target belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base shape for any pack reference.\n * Pack refs are pure JSON-friendly objects safe to import in authoring flows.\n */\nexport interface PackRefBase<Kind extends string, TFamilyId extends string>\n  extends ComponentMetadata {\n  readonly kind: Kind;\n  readonly id: string;\n  readonly familyId: TFamilyId;\n  readonly targetId?: string;\n}\n\nexport type TargetPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'target', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type AdapterPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'adapter', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type ExtensionPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'extension', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type DriverPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'driver', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\n/**\n * Descriptor for an adapter component.\n *\n * An \"adapter\" provides the protocol and dialect implementation for a target.\n * Adapters handle:\n * - SQL/query generation (lowering AST to target-specific syntax)\n * - Codec registration (encoding/decoding between JS and wire types)\n * - Type mappings and coercions\n *\n * Adapters are bound to a specific family+target combination and work with\n * any compatible driver for that target.\n *\n * Extended by plane-specific descriptors:\n * - `ControlAdapterDescriptor` - control-plane factory\n * - `RuntimeAdapterDescriptor` - runtime factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresAdapter from '@prisma-next/adapter-postgres/control';\n *\n * postgresAdapter.kind     // 'adapter'\n * postgresAdapter.familyId // 'sql'\n * postgresAdapter.targetId // 'postgres'\n * ```\n */\nexport interface AdapterDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'adapter'> {\n  /** The family this adapter belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this adapter is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for a driver component.\n *\n * A \"driver\" provides the connection and execution layer for a target.\n * Drivers handle:\n * - Connection management (pooling, timeouts, retries)\n * - Query execution (sending SQL/commands, receiving results)\n * - Transaction management\n * - Wire protocol communication\n *\n * Drivers are bound to a specific family+target and work with any compatible\n * adapter. Multiple drivers can exist for the same target (e.g., node-postgres\n * vs postgres.js for Postgres).\n *\n * Extended by plane-specific descriptors:\n * - `ControlDriverDescriptor` - creates driver from connection URL\n * - `RuntimeDriverDescriptor` - creates driver with runtime options\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresDriver from '@prisma-next/driver-postgres/control';\n *\n * postgresDriver.kind     // 'driver'\n * postgresDriver.familyId // 'sql'\n * postgresDriver.targetId // 'postgres'\n * ```\n */\nexport interface DriverDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'driver'> {\n  /** The family this driver belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this driver connects to */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for an extension component.\n *\n * An \"extension\" adds optional capabilities to a target. Extensions can provide:\n * - Additional operations (e.g., vector similarity search with pgvector)\n * - Custom types and codecs (e.g., vector type)\n * - Extended query capabilities\n *\n * Extensions are bound to a specific family+target and are registered in the\n * config alongside the core components. Multiple extensions can be used together.\n *\n * Extended by plane-specific descriptors:\n * - `ControlExtensionDescriptor` - control-plane extension factory\n * - `RuntimeExtensionDescriptor` - runtime extension factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import pgvector from '@prisma-next/extension-pgvector/control';\n *\n * pgvector.kind     // 'extension'\n * pgvector.familyId // 'sql'\n * pgvector.targetId // 'postgres'\n * ```\n */\nexport interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'extension'> {\n  /** The family this extension belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this extension is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Union type for target-bound component descriptors.\n *\n * Target-bound components are those that must be compatible with a specific\n * family+target combination. This includes targets, adapters, drivers, and\n * extensions. Families are not target-bound.\n *\n * This type is used in migration and verification interfaces to enforce\n * type-level compatibility between components.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * // All these components must have matching familyId and targetId\n * const components: TargetBoundComponentDescriptor<'sql', 'postgres'>[] = [\n *   postgresTarget,\n *   postgresAdapter,\n *   postgresDriver,\n *   pgvectorExtension,\n * ];\n * ```\n */\nexport type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> =\n  | TargetDescriptor<TFamilyId, TTargetId>\n  | AdapterDescriptor<TFamilyId, TTargetId>\n  | DriverDescriptor<TFamilyId, TTargetId>\n  | ExtensionDescriptor<TFamilyId, TTargetId>;\n\n/**\n * Base interface for family instances.\n *\n * A family instance is created by a family descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add domain actions (e.g., `emitContract`, `verify` on ControlFamilyInstance).\n *\n * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')\n *\n * @example\n * ```ts\n * const instance = sql.create({ target, adapter, driver, extensions });\n * instance.familyId // 'sql'\n * ```\n */\nexport interface FamilyInstance<TFamilyId extends string> {\n  /** The family identifier (e.g., 'sql', 'document') */\n  readonly familyId: TFamilyId;\n}\n\n/**\n * Base interface for target instances.\n *\n * A target instance is created by a target descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add target-specific behavior.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')\n *\n * @example\n * ```ts\n * const instance = postgres.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface TargetInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this target belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for adapter instances.\n *\n * An adapter instance is created by an adapter descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add adapter-specific behavior (e.g., codec registration, query lowering).\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = postgresAdapter.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this adapter belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this adapter is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for driver instances.\n *\n * A driver instance is created by a driver descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add driver-specific behavior (e.g., `query`, `close` on ControlDriverInstance).\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = postgresDriver.create({ databaseUrl });\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface DriverInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this driver belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this driver connects to */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base interface for extension instances.\n *\n * An extension instance is created by an extension descriptor's `create()` method.\n * This base interface carries only the identity; plane-specific interfaces\n * add extension-specific behavior.\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * const instance = pgvector.create();\n * instance.familyId // 'sql'\n * instance.targetId // 'postgres'\n * ```\n */\nexport interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {\n  /** The family this extension belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this extension is designed for */\n  readonly targetId: TTargetId;\n}\n"],"mappings":";;;;;;;AAgGA,SAAgB,wBACd,UACA,QACA,KACQ;AACR,QAAO,SAAS,QAAQ,mBAAmB,GAAG,QAAgB;AAC5D,MAAI,QAAQ,aAAc,QAAO,IAAI;EACrC,MAAM,QAAQ,OAAO;AACrB,MAAI,UAAU,OACZ,OAAM,IAAI,MACR,+BAA+B,IAAI,iBAAiB,SAAS,uBACtC,OAAO,KAAK,OAAO,CAAC,KAAK,KAAK,IAAI,WAC1D;AAEH,SAAO,OAAO,MAAM;GACpB;;;;;;;;;;;;AAaJ,SAAgB,kBAAkB,SAAiB,UAAgD;AAEjG,KAAI,OAAO,aAAa,SACtB,QAAO;EACL;EACA,SAAS,QAAQ,QAAQ,wBAAwB,UAAU,QAAQ,IAAI;EACxE;AAIH,KAAI,OAAO,aAAa,WACtB,QAAO;EAAE;EAAS,QAAQ;EAAU;AAItC,KAAI,SAAS,SAAS,WACpB,QAAO;EAAE;EAAS,QAAQ,SAAS;EAAQ;CAI7C,MAAM,EAAE,aAAa;AACrB,QAAO;EACL;EACA,SAAS,QAAQ,QAAQ,wBAAwB,UAAU,QAAQ,IAAI;EACxE;;AAyGH,SAAgB,mCACd,OAC0C;CAC1C,MAAM,8BAAc,IAAI,KAAa;AACrC,MAAK,MAAM,MAAM,MAAM,qBACrB,aAAY,IAAI,GAAG;CAMrB,MAAM,2BAH2B,MAAM,SAAS,iBAC5C,OAAO,KAAK,MAAM,SAAS,eAAe,GAC1C,EAAE,EACmD,QAAQ,OAAO,CAAC,YAAY,IAAI,GAAG,CAAC;CAE7F,MAAM,uBAAuB,MAAM;CACnC,MAAM,uBAAuB,MAAM,SAAS;CAC5C,MAAM,iBACJ,yBAAyB,UACzB,yBAAyB,UACzB,yBAAyB,uBACrB;EAAE,UAAU;EAAsB,QAAQ;EAAsB,GAChE;CAEN,MAAM,mBAAmB,MAAM;CAC/B,MAAM,mBAAmB,MAAM,SAAS;CACxC,MAAM,iBACJ,qBAAqB,UAAa,qBAAqB,mBACnD;EAAE,UAAU;EAAkB,QAAQ;EAAkB,GACxD;AAEN,QAAO;EACL,GAAI,iBAAiB,EAAE,gBAAgB,GAAG,EAAE;EAC5C,GAAI,iBAAiB,EAAE,gBAAgB,GAAG,EAAE;EAC5C;EACD"}
+{"version":3,"file":"framework-components.mjs","names":["resolved: Record<string, unknown>"],"sources":["../src/framework-authoring.ts","../src/framework-components.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\n\nexport type AuthoringArgRef = {\n  readonly kind: 'arg';\n  readonly index: number;\n  readonly path?: readonly string[];\n  readonly default?: AuthoringTemplateValue;\n};\n\nexport type AuthoringTemplateValue =\n  | string\n  | number\n  | boolean\n  | null\n  | AuthoringArgRef\n  | readonly AuthoringTemplateValue[]\n  | { readonly [key: string]: AuthoringTemplateValue };\n\nexport type AuthoringArgumentDescriptor =\n  | {\n      readonly kind: 'string';\n      readonly optional?: boolean;\n    }\n  | {\n      readonly kind: 'number';\n      readonly optional?: boolean;\n      readonly integer?: boolean;\n      readonly minimum?: number;\n      readonly maximum?: number;\n    }\n  | {\n      readonly kind: 'stringArray';\n      readonly optional?: boolean;\n    }\n  | {\n      readonly kind: 'object';\n      readonly optional?: boolean;\n      readonly properties: Record<string, AuthoringArgumentDescriptor>;\n    };\n\nexport interface AuthoringStorageTypeTemplate {\n  readonly codecId: string;\n  readonly nativeType: AuthoringTemplateValue;\n  readonly typeParams?: Record<string, AuthoringTemplateValue>;\n}\n\nexport interface AuthoringTypeConstructorDescriptor {\n  readonly kind: 'typeConstructor';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringStorageTypeTemplate;\n}\n\nexport interface AuthoringColumnDefaultTemplateLiteral {\n  readonly kind: 'literal';\n  readonly value: AuthoringTemplateValue;\n}\n\nexport interface AuthoringColumnDefaultTemplateFunction {\n  readonly kind: 'function';\n  readonly expression: AuthoringTemplateValue;\n}\n\nexport type AuthoringColumnDefaultTemplate =\n  | AuthoringColumnDefaultTemplateLiteral\n  | AuthoringColumnDefaultTemplateFunction;\n\nexport interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {\n  readonly nullable?: boolean;\n  readonly default?: AuthoringColumnDefaultTemplate;\n  readonly executionDefault?: AuthoringTemplateValue;\n  readonly id?: boolean;\n  readonly unique?: boolean;\n}\n\nexport interface AuthoringFieldPresetDescriptor {\n  readonly kind: 'fieldPreset';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringFieldPresetOutput;\n}\n\nexport type AuthoringTypeNamespace = {\n  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;\n};\n\nexport type AuthoringFieldNamespace = {\n  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;\n};\n\nexport interface AuthoringContributions {\n  readonly type?: AuthoringTypeNamespace;\n  readonly field?: AuthoringFieldNamespace;\n}\n\nexport function isAuthoringArgRef(value: unknown): value is AuthoringArgRef {\n  if (typeof value !== 'object' || value === null || (value as { kind?: unknown }).kind !== 'arg') {\n    return false;\n  }\n  const { index, path } = value as { index?: unknown; path?: unknown };\n  if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {\n    return false;\n  }\n  if (path !== undefined && (!Array.isArray(path) || path.some((s) => typeof s !== 'string'))) {\n    return false;\n  }\n  return true;\n}\n\nfunction isAuthoringTemplateRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport function isAuthoringTypeConstructorDescriptor(\n  value: unknown,\n): value is AuthoringTypeConstructorDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'typeConstructor' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\nexport function isAuthoringFieldPresetDescriptor(\n  value: unknown,\n): value is AuthoringFieldPresetDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'fieldPreset' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\nexport function resolveAuthoringTemplateValue(\n  template: AuthoringTemplateValue,\n  args: readonly unknown[],\n): unknown {\n  if (isAuthoringArgRef(template)) {\n    let value = args[template.index];\n\n    for (const segment of template.path ?? []) {\n      if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {\n        value = undefined;\n        break;\n      }\n      value = (value as Record<string, unknown>)[segment];\n    }\n\n    if (value === undefined && template.default !== undefined) {\n      return resolveAuthoringTemplateValue(template.default, args);\n    }\n\n    return value;\n  }\n  if (Array.isArray(template)) {\n    return template.map((value) => resolveAuthoringTemplateValue(value, args));\n  }\n  if (typeof template === 'object' && template !== null) {\n    const resolved: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(template)) {\n      const resolvedValue = resolveAuthoringTemplateValue(value, args);\n      if (resolvedValue !== undefined) {\n        resolved[key] = resolvedValue;\n      }\n    }\n    return resolved;\n  }\n  return template;\n}\n\nfunction validateAuthoringArgument(\n  descriptor: AuthoringArgumentDescriptor,\n  value: unknown,\n  path: string,\n): void {\n  if (value === undefined) {\n    if (descriptor.optional) {\n      return;\n    }\n    throw new Error(`Missing required authoring helper argument at ${path}`);\n  }\n\n  if (descriptor.kind === 'string') {\n    if (typeof value !== 'string') {\n      throw new Error(`Authoring helper argument at ${path} must be a string`);\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'stringArray') {\n    if (!Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n    }\n    for (const entry of value) {\n      if (typeof entry !== 'string') {\n        throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n      }\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'object') {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an object`);\n    }\n\n    const input = value as Record<string, unknown>;\n    const expectedKeys = new Set(Object.keys(descriptor.properties));\n\n    for (const key of Object.keys(input)) {\n      if (!expectedKeys.has(key)) {\n        throw new Error(`Authoring helper argument at ${path} contains unknown property \"${key}\"`);\n      }\n    }\n\n    for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) {\n      validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);\n    }\n\n    return;\n  }\n\n  if (typeof value !== 'number' || Number.isNaN(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be a number`);\n  }\n\n  if (descriptor.integer && !Number.isInteger(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be an integer`);\n  }\n  if (descriptor.minimum !== undefined && value < descriptor.minimum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`,\n    );\n  }\n  if (descriptor.maximum !== undefined && value > descriptor.maximum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`,\n    );\n  }\n}\n\nexport function validateAuthoringHelperArguments(\n  helperPath: string,\n  descriptors: readonly AuthoringArgumentDescriptor[] | undefined,\n  args: readonly unknown[],\n): void {\n  const expected = descriptors ?? [];\n  const minimumArgs = expected.reduce(\n    (count, descriptor, index) => (descriptor.optional ? count : index + 1),\n    0,\n  );\n  if (args.length < minimumArgs || args.length > expected.length) {\n    throw new Error(\n      `${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`,\n    );\n  }\n\n  expected.forEach((descriptor, index) => {\n    validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);\n  });\n}\n\nfunction resolveAuthoringStorageTypeTemplate(\n  template: AuthoringStorageTypeTemplate,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);\n  if (typeof nativeType !== 'string') {\n    throw new Error(\n      `Resolved authoring nativeType must be a string for codec \"${template.codecId}\", received ${String(nativeType)}`,\n    );\n  }\n  const typeParams =\n    template.typeParams === undefined\n      ? undefined\n      : resolveAuthoringTemplateValue(template.typeParams, args);\n  if (typeParams !== undefined && !isAuthoringTemplateRecord(typeParams)) {\n    throw new Error(\n      `Resolved authoring typeParams must be an object for codec \"${template.codecId}\", received ${String(typeParams)}`,\n    );\n  }\n\n  return {\n    codecId: template.codecId,\n    nativeType,\n    ...(typeParams === undefined ? {} : { typeParams }),\n  };\n}\n\nfunction resolveAuthoringColumnDefaultTemplate(\n  template: AuthoringColumnDefaultTemplate,\n  args: readonly unknown[],\n):\n  | {\n      readonly kind: 'literal';\n      readonly value: unknown;\n    }\n  | {\n      readonly kind: 'function';\n      readonly expression: string;\n    } {\n  if (template.kind === 'literal') {\n    const value = resolveAuthoringTemplateValue(template.value, args);\n    if (value === undefined) {\n      throw new Error('Resolved authoring literal default must not be undefined');\n    }\n    return {\n      kind: 'literal',\n      value,\n    };\n  }\n\n  const expression = resolveAuthoringTemplateValue(template.expression, args);\n  if (expression === undefined || (typeof expression === 'object' && expression !== null)) {\n    throw new Error(\n      `Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`,\n    );\n  }\n  return {\n    kind: 'function',\n    expression: String(expression),\n  };\n}\n\nexport function instantiateAuthoringTypeConstructor(\n  descriptor: AuthoringTypeConstructorDescriptor,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  return resolveAuthoringStorageTypeTemplate(descriptor.output, args);\n}\n\nexport function instantiateAuthoringFieldPreset(\n  descriptor: AuthoringFieldPresetDescriptor,\n  args: readonly unknown[],\n): {\n  readonly descriptor: {\n    readonly codecId: string;\n    readonly nativeType: string;\n    readonly typeParams?: Record<string, unknown>;\n  };\n  readonly nullable: boolean;\n  readonly default?:\n    | {\n        readonly kind: 'literal';\n        readonly value: unknown;\n      }\n    | {\n        readonly kind: 'function';\n        readonly expression: string;\n      };\n  readonly executionDefault?: unknown;\n  readonly id: boolean;\n  readonly unique: boolean;\n} {\n  return {\n    descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),\n    nullable: descriptor.output.nullable ?? false,\n    ...ifDefined(\n      'default',\n      descriptor.output.default !== undefined\n        ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args)\n        : undefined,\n    ),\n    ...ifDefined(\n      'executionDefault',\n      descriptor.output.executionDefault !== undefined\n        ? resolveAuthoringTemplateValue(descriptor.output.executionDefault, args)\n        : undefined,\n    ),\n    id: descriptor.output.id ?? false,\n    unique: descriptor.output.unique ?? false,\n  };\n}\n","import type { AuthoringContributions } from './framework-authoring';\nimport type { RenderTypeContext, TypesImportSpec } from './types';\n\n/**\n * A template-based type renderer (structured form).\n * Uses mustache-style placeholders (e.g., `Vector<{{length}}>`) that are\n * replaced with typeParams values during rendering.\n *\n * @example\n * ```ts\n * { kind: 'template', template: 'Vector<{{length}}>' }\n * // With typeParams { length: 1536 }, renders: 'Vector<1536>'\n * ```\n */\nexport interface TypeRendererTemplate {\n  readonly kind: 'template';\n  /** Template string with `{{key}}` placeholders for typeParams values */\n  readonly template: string;\n}\n\n/**\n * A function-based type renderer for full control over type expression generation.\n *\n * @example\n * ```ts\n * {\n *   kind: 'function',\n *   render: (params, ctx) => `Vector<${params.length}>`\n * }\n * ```\n */\nexport interface TypeRendererFunction {\n  readonly kind: 'function';\n  /** Render function that produces a TypeScript type expression */\n  readonly render: (params: Record<string, unknown>, ctx: RenderTypeContext) => string;\n}\n\n/**\n * A raw template string type renderer (convenience form).\n * Shorthand for TypeRendererTemplate - just the template string without wrapper.\n *\n * @example\n * ```ts\n * 'Vector<{{length}}>'\n * // Equivalent to: { kind: 'template', template: 'Vector<{{length}}>' }\n * ```\n */\nexport type TypeRendererString = string;\n\n/**\n * A raw function type renderer (convenience form).\n * Shorthand for TypeRendererFunction - just the function without wrapper.\n *\n * @example\n * ```ts\n * (params, ctx) => `Vector<${params.length}>`\n * // Equivalent to: { kind: 'function', render: ... }\n * ```\n */\nexport type TypeRendererRawFunction = (\n  params: Record<string, unknown>,\n  ctx: RenderTypeContext,\n) => string;\n\n/**\n * Union of type renderer formats.\n *\n * Supports both structured forms (with `kind` discriminator) and convenience forms:\n * - `string` - Template string with `{{key}}` placeholders (manifest-safe, JSON-serializable)\n * - `function` - Render function for full control (requires runtime execution)\n * - `{ kind: 'template', template: string }` - Structured template form\n * - `{ kind: 'function', render: fn }` - Structured function form\n *\n * Templates are normalized to functions during pack assembly.\n * **Prefer template strings** for most cases - they are JSON-serializable.\n */\nexport type TypeRenderer =\n  | TypeRendererString\n  | TypeRendererRawFunction\n  | TypeRendererTemplate\n  | TypeRendererFunction;\n\n/**\n * Normalized type renderer - always a function after assembly.\n * This is the form received by the emitter.\n */\nexport interface NormalizedTypeRenderer {\n  readonly codecId: string;\n  readonly render: (params: Record<string, unknown>, ctx: RenderTypeContext) => string;\n}\n\n/**\n * Interpolates a template string with params values.\n * Used internally by normalizeRenderer to compile templates to functions.\n *\n * @throws Error if a placeholder key is not found in params (except 'CodecTypes')\n */\nexport function interpolateTypeTemplate(\n  template: string,\n  params: Record<string, unknown>,\n  ctx: RenderTypeContext,\n): string {\n  return template.replace(/\\{\\{(\\w+)\\}\\}/g, (_, key: string) => {\n    if (key === 'CodecTypes') return ctx.codecTypesName;\n    const value = params[key];\n    if (value === undefined) {\n      throw new Error(\n        `Missing template parameter \"${key}\" in template \"${template}\". ` +\n          `Available params: ${Object.keys(params).join(', ') || '(none)'}`,\n      );\n    }\n    return String(value);\n  });\n}\n\n/**\n * Normalizes a TypeRenderer to function form.\n * Called during pack assembly, not at emission time.\n *\n * Handles all TypeRenderer forms:\n * - Raw string template: `'Vector<{{length}}>'`\n * - Raw function: `(params, ctx) => ...`\n * - Structured template: `{ kind: 'template', template: '...' }`\n * - Structured function: `{ kind: 'function', render: fn }`\n */\nexport function normalizeRenderer(codecId: string, renderer: TypeRenderer): NormalizedTypeRenderer {\n  // Handle raw string (template shorthand)\n  if (typeof renderer === 'string') {\n    return {\n      codecId,\n      render: (params, ctx) => interpolateTypeTemplate(renderer, params, ctx),\n    };\n  }\n\n  // Handle raw function (function shorthand)\n  if (typeof renderer === 'function') {\n    return { codecId, render: renderer };\n  }\n\n  // Handle structured function form\n  if (renderer.kind === 'function') {\n    return { codecId, render: renderer.render };\n  }\n\n  // Handle structured template form\n  const { template } = renderer;\n  return {\n    codecId,\n    render: (params, ctx) => interpolateTypeTemplate(template, params, ctx),\n  };\n}\n\n/**\n * Declarative fields that describe component metadata.\n */\nexport interface ComponentMetadata {\n  /** Component version (semver) */\n  readonly version: string;\n\n  /**\n   * Capabilities this component provides.\n   *\n   * For adapters, capabilities must be declared on the adapter descriptor (so they are emitted into\n   * the contract) and also exposed in runtime adapter code (e.g. `adapter.profile.capabilities`);\n   * keep these declarations in sync. Targets are identifiers/descriptors and typically do not\n   * declare capabilities.\n   */\n  readonly capabilities?: Record<string, unknown>;\n\n  /** Type imports for contract.d.ts generation */\n  readonly types?: {\n    readonly codecTypes?: {\n      /**\n       * Base codec types import spec.\n       * Optional: adapters typically provide this, extensions usually don't.\n       */\n      readonly import?: TypesImportSpec;\n      /**\n       * Optional renderers for parameterized codecs owned by this component.\n       * Key is codecId (e.g., 'pg/vector@1'), value is the type renderer.\n       *\n       * Templates are normalized to functions during pack assembly.\n       * Duplicate codecId across descriptors is a hard error.\n       */\n      readonly parameterized?: Record<string, TypeRenderer>;\n      /**\n       * Optional additional type-only imports required by parameterized renderers.\n       *\n       * These imports are included in generated `contract.d.ts` but are NOT treated as\n       * codec type maps (i.e., they should not be intersected into `export type CodecTypes = ...`).\n       *\n       * Example: `Vector<N>` for pgvector renderers that emit `Vector<{{length}}>`\n       */\n      readonly typeImports?: ReadonlyArray<TypesImportSpec>;\n      /**\n       * Optional control-plane hooks keyed by codecId.\n       * Used by family-specific planners/verifiers to handle storage types.\n       */\n      readonly controlPlaneHooks?: Record<string, unknown>;\n    };\n    readonly operationTypes?: { readonly import: TypesImportSpec };\n    readonly storage?: ReadonlyArray<{\n      readonly typeId: string;\n      readonly familyId: string;\n      readonly targetId: string;\n      readonly nativeType?: string;\n    }>;\n  };\n\n  /**\n   * Optional pure-data authoring contributions exposed by this component.\n   *\n   * These contributions are safe to include on pack refs and descriptors because\n   * they contain only declarative metadata. Higher-level authoring packages may\n   * project them into concrete helper functions for TS-first workflows.\n   */\n  readonly authoring?: AuthoringContributions;\n}\n\n/**\n * Base descriptor for any framework component.\n *\n * All component descriptors share these fundamental properties that identify\n * the component and provide its metadata. This interface is extended by\n * specific descriptor types (FamilyDescriptor, TargetDescriptor, etc.).\n *\n * @template Kind - Discriminator literal identifying the component type.\n *   Built-in kinds are 'family', 'target', 'adapter', 'driver', 'extension',\n *   but the type accepts any string to allow ecosystem extensions.\n *\n * @example\n * ```ts\n * // All descriptors have these properties\n * descriptor.kind     // The Kind type parameter (e.g., 'family', 'target', or custom kinds)\n * descriptor.id       // Unique string identifier (e.g., 'sql', 'postgres')\n * descriptor.version  // Component version (semver)\n * ```\n */\nexport interface ComponentDescriptor<Kind extends string> extends ComponentMetadata {\n  /** Discriminator identifying the component type */\n  readonly kind: Kind;\n\n  /** Unique identifier for this component (e.g., 'sql', 'postgres', 'pgvector') */\n  readonly id: string;\n}\n\nexport interface ContractComponentRequirementsCheckInput {\n  readonly contract: {\n    readonly target: string;\n    readonly targetFamily?: string | undefined;\n    readonly extensionPacks?: Record<string, unknown> | undefined;\n  };\n  readonly expectedTargetFamily?: string | undefined;\n  readonly expectedTargetId?: string | undefined;\n  readonly providedComponentIds: Iterable<string>;\n}\n\nexport interface ContractComponentRequirementsCheckResult {\n  readonly familyMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly targetMismatch?: { readonly expected: string; readonly actual: string } | undefined;\n  readonly missingExtensionPackIds: readonly string[];\n}\n\nexport function checkContractComponentRequirements(\n  input: ContractComponentRequirementsCheckInput,\n): ContractComponentRequirementsCheckResult {\n  const providedIds = new Set<string>();\n  for (const id of input.providedComponentIds) {\n    providedIds.add(id);\n  }\n\n  const requiredExtensionPackIds = input.contract.extensionPacks\n    ? Object.keys(input.contract.extensionPacks)\n    : [];\n  const missingExtensionPackIds = requiredExtensionPackIds.filter((id) => !providedIds.has(id));\n\n  const expectedTargetFamily = input.expectedTargetFamily;\n  const contractTargetFamily = input.contract.targetFamily;\n  const familyMismatch =\n    expectedTargetFamily !== undefined &&\n    contractTargetFamily !== undefined &&\n    contractTargetFamily !== expectedTargetFamily\n      ? { expected: expectedTargetFamily, actual: contractTargetFamily }\n      : undefined;\n\n  const expectedTargetId = input.expectedTargetId;\n  const contractTargetId = input.contract.target;\n  const targetMismatch =\n    expectedTargetId !== undefined && contractTargetId !== expectedTargetId\n      ? { expected: expectedTargetId, actual: contractTargetId }\n      : undefined;\n\n  return {\n    ...(familyMismatch ? { familyMismatch } : {}),\n    ...(targetMismatch ? { targetMismatch } : {}),\n    missingExtensionPackIds,\n  };\n}\n\n/**\n * Descriptor for a family component.\n *\n * A \"family\" represents a category of data sources with shared semantics\n * (e.g., SQL databases, document stores). Families define:\n * - Query semantics and operations (SELECT, INSERT, find, aggregate, etc.)\n * - Contract structure (tables vs collections, columns vs fields)\n * - Type system and codecs\n *\n * Families are the top-level grouping. Each family contains multiple targets\n * (e.g., SQL family contains Postgres, MySQL, SQLite targets).\n *\n * Extended by plane-specific descriptors:\n * - `ControlFamilyDescriptor` - adds `hook` for CLI/tooling operations\n * - `RuntimeFamilyDescriptor` - adds runtime-specific factory methods\n *\n * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')\n *\n * @example\n * ```ts\n * import sql from '@prisma-next/family-sql/control';\n *\n * sql.kind     // 'family'\n * sql.familyId // 'sql'\n * sql.id       // 'sql'\n * ```\n */\nexport interface FamilyDescriptor<TFamilyId extends string> extends ComponentDescriptor<'family'> {\n  /** The family identifier (e.g., 'sql', 'document') */\n  readonly familyId: TFamilyId;\n}\n\n/**\n * Descriptor for a target component.\n *\n * A \"target\" represents a specific database or data store within a family\n * (e.g., Postgres, MySQL, MongoDB). Targets define:\n * - Native type mappings (e.g., Postgres int4 → TypeScript number)\n * - Target-specific capabilities (e.g., RETURNING, LATERAL joins)\n *\n * Targets are bound to a family and provide the target-specific implementation\n * details that adapters and drivers use.\n *\n * Extended by plane-specific descriptors:\n * - `ControlTargetDescriptor` - adds optional `migrations` capability\n * - `RuntimeTargetDescriptor` - adds runtime factory method\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')\n *\n * @example\n * ```ts\n * import postgres from '@prisma-next/target-postgres/control';\n *\n * postgres.kind     // 'target'\n * postgres.familyId // 'sql'\n * postgres.targetId // 'postgres'\n * ```\n */\nexport interface TargetDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'target'> {\n  /** The family this target belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Base shape for any pack reference.\n * Pack refs are pure JSON-friendly objects safe to import in authoring flows.\n */\nexport interface PackRefBase<Kind extends string, TFamilyId extends string>\n  extends ComponentMetadata {\n  readonly kind: Kind;\n  readonly id: string;\n  readonly familyId: TFamilyId;\n  readonly targetId?: string;\n  readonly authoring?: AuthoringContributions;\n}\n\nexport type FamilyPackRef<TFamilyId extends string = string> = PackRefBase<'family', TFamilyId>;\n\nexport type TargetPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'target', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type AdapterPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'adapter', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type ExtensionPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'extension', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\nexport type DriverPackRef<\n  TFamilyId extends string = string,\n  TTargetId extends string = string,\n> = PackRefBase<'driver', TFamilyId> & {\n  readonly targetId: TTargetId;\n};\n\n/**\n * Descriptor for an adapter component.\n *\n * An \"adapter\" provides the protocol and dialect implementation for a target.\n * Adapters handle:\n * - SQL/query generation (lowering AST to target-specific syntax)\n * - Codec registration (encoding/decoding between JS and wire types)\n * - Type mappings and coercions\n *\n * Adapters are bound to a specific family+target combination and work with\n * any compatible driver for that target.\n *\n * Extended by plane-specific descriptors:\n * - `ControlAdapterDescriptor` - control-plane factory\n * - `RuntimeAdapterDescriptor` - runtime factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresAdapter from '@prisma-next/adapter-postgres/control';\n *\n * postgresAdapter.kind     // 'adapter'\n * postgresAdapter.familyId // 'sql'\n * postgresAdapter.targetId // 'postgres'\n * ```\n */\nexport interface AdapterDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'adapter'> {\n  /** The family this adapter belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this adapter is designed for */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for a driver component.\n *\n * A \"driver\" provides the connection and execution layer for a target.\n * Drivers handle:\n * - Connection management (pooling, timeouts, retries)\n * - Query execution (sending SQL/commands, receiving results)\n * - Transaction management\n * - Wire protocol communication\n *\n * Drivers are bound to a specific family+target and work with any compatible\n * adapter. Multiple drivers can exist for the same target (e.g., node-postgres\n * vs postgres.js for Postgres).\n *\n * Extended by plane-specific descriptors:\n * - `ControlDriverDescriptor` - creates driver from connection URL\n * - `RuntimeDriverDescriptor` - creates driver with runtime options\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import postgresDriver from '@prisma-next/driver-postgres/control';\n *\n * postgresDriver.kind     // 'driver'\n * postgresDriver.familyId // 'sql'\n * postgresDriver.targetId // 'postgres'\n * ```\n */\nexport interface DriverDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'driver'> {\n  /** The family this driver belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this driver connects to */\n  readonly targetId: TTargetId;\n}\n\n/**\n * Descriptor for an extension component.\n *\n * An \"extension\" adds optional capabilities to a target. Extensions can provide:\n * - Additional operations (e.g., vector similarity search with pgvector)\n * - Custom types and codecs (e.g., vector type)\n * - Extended query capabilities\n *\n * Extensions are bound to a specific family+target and are registered in the\n * config alongside the core components. Multiple extensions can be used together.\n *\n * Extended by plane-specific descriptors:\n * - `ControlExtensionDescriptor` - control-plane extension factory\n * - `RuntimeExtensionDescriptor` - runtime extension factory\n *\n * @template TFamilyId - Literal type for the family identifier\n * @template TTargetId - Literal type for the target identifier\n *\n * @example\n * ```ts\n * import pgvector from '@prisma-next/extension-pgvector/control';\n *\n * pgvector.kind     // 'extension'\n * pgvector.familyId // 'sql'\n * pgvector.targetId // 'postgres'\n * ```\n */\nexport interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends string>\n  extends ComponentDescriptor<'extension'> {\n  /** The family this extension belongs to */\n  readonly familyId: TFamilyId;\n\n  /** The target this extension is designed for */\n  readonly targetId: TTargetId;\n}\n\n/** Components bound to a specific family+target combination. */\nexport type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> =\n  | TargetDescriptor<TFamilyId, TTargetId>\n  | AdapterDescriptor<TFamilyId, TTargetId>\n  | DriverDescriptor<TFamilyId, TTargetId>\n  | ExtensionDescriptor<TFamilyId, TTargetId>;\n\nexport interface FamilyInstance<TFamilyId extends string> {\n  readonly familyId: TFamilyId;\n}\n\nexport interface TargetInstance<TFamilyId extends string, TTargetId extends string> {\n  readonly familyId: TFamilyId;\n  readonly targetId: TTargetId;\n}\n\nexport interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {\n  readonly familyId: TFamilyId;\n  readonly targetId: TTargetId;\n}\n\nexport interface DriverInstance<TFamilyId extends string, TTargetId extends string> {\n  readonly familyId: TFamilyId;\n  readonly targetId: TTargetId;\n}\n\nexport interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {\n  readonly familyId: TFamilyId;\n  readonly targetId: TTargetId;\n}\n"],"mappings":"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"}

package/dist/types-BwcW0HFt.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types-BwcW0HFt.d.mts","names":[],"sources":["../src/domain-types.ts","../src/types.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"types-BwcW0HFt.d.mts","names":[],"sources":["../src/domain-types.ts","../src/types.ts"],"sourcesContent":[],"mappings":"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"}

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "@prisma-next/contract",
-  "version": "0.3.0-dev.134",
+  "version": "0.3.0-dev.135",
   "type": "module",
   "sideEffects": false,
   "description": "Data contract type definitions and JSON schema for Prisma Next",
   "dependencies": {
-    "@prisma-next/operations": "0.3.0-dev.134"
+    "@prisma-next/operations": "0.3.0-dev.135",
+    "@prisma-next/utils": "0.3.0-dev.135"
   },
   "devDependencies": {
     "tsdown": "0.18.4",
     "typescript": "5.9.3",
     "vitest": "4.0.17",
+    "@prisma-next/test-utils": "0.0.1",
     "@prisma-next/tsconfig": "0.0.0",
-    "@prisma-next/tsdown": "0.0.0",
-    "@prisma-next/test-utils": "0.0.1"
+    "@prisma-next/tsdown": "0.0.0"
   },
   "files": [
     "dist",

package/src/exports/framework-components.ts

@@ -1,7 +1,27 @@
 export type {
-  // Descriptors
+  AuthoringArgRef,
+  AuthoringArgumentDescriptor,
+  AuthoringColumnDefaultTemplate,
+  AuthoringContributions,
+  AuthoringFieldNamespace,
+  AuthoringFieldPresetDescriptor,
+  AuthoringFieldPresetOutput,
+  AuthoringStorageTypeTemplate,
+  AuthoringTemplateValue,
+  AuthoringTypeConstructorDescriptor,
+  AuthoringTypeNamespace,
+} from '../framework-authoring';
+export {
+  instantiateAuthoringFieldPreset,
+  instantiateAuthoringTypeConstructor,
+  isAuthoringArgRef,
+  isAuthoringFieldPresetDescriptor,
+  isAuthoringTypeConstructorDescriptor,
+  resolveAuthoringTemplateValue,
+  validateAuthoringHelperArguments,
+} from '../framework-authoring';
+export type {
   AdapterDescriptor,
-  // Instances
   AdapterInstance,
   AdapterPackRef,
   ComponentDescriptor,
@@ -16,7 +36,7 @@ export type {
   ExtensionPackRef,
   FamilyDescriptor,
   FamilyInstance,
-  // Type renderers for parameterized codec emission
+  FamilyPackRef,
   NormalizedTypeRenderer,
   PackRefBase,
   TargetBoundComponentDescriptor,
@@ -27,7 +47,6 @@ export type {
   TypeRendererFunction,
   TypeRendererTemplate,
 } from '../framework-components';
-
 export {
   checkContractComponentRequirements,
   interpolateTypeTemplate,

package/src/framework-authoring.ts

@@ -0,0 +1,383 @@
+import { ifDefined } from '@prisma-next/utils/defined';
+
+export type AuthoringArgRef = {
+  readonly kind: 'arg';
+  readonly index: number;
+  readonly path?: readonly string[];
+  readonly default?: AuthoringTemplateValue;
+};
+
+export type AuthoringTemplateValue =
+  | string
+  | number
+  | boolean
+  | null
+  | AuthoringArgRef
+  | readonly AuthoringTemplateValue[]
+  | { readonly [key: string]: AuthoringTemplateValue };
+
+export type AuthoringArgumentDescriptor =
+  | {
+      readonly kind: 'string';
+      readonly optional?: boolean;
+    }
+  | {
+      readonly kind: 'number';
+      readonly optional?: boolean;
+      readonly integer?: boolean;
+      readonly minimum?: number;
+      readonly maximum?: number;
+    }
+  | {
+      readonly kind: 'stringArray';
+      readonly optional?: boolean;
+    }
+  | {
+      readonly kind: 'object';
+      readonly optional?: boolean;
+      readonly properties: Record<string, AuthoringArgumentDescriptor>;
+    };
+
+export interface AuthoringStorageTypeTemplate {
+  readonly codecId: string;
+  readonly nativeType: AuthoringTemplateValue;
+  readonly typeParams?: Record<string, AuthoringTemplateValue>;
+}
+
+export interface AuthoringTypeConstructorDescriptor {
+  readonly kind: 'typeConstructor';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringStorageTypeTemplate;
+}
+
+export interface AuthoringColumnDefaultTemplateLiteral {
+  readonly kind: 'literal';
+  readonly value: AuthoringTemplateValue;
+}
+
+export interface AuthoringColumnDefaultTemplateFunction {
+  readonly kind: 'function';
+  readonly expression: AuthoringTemplateValue;
+}
+
+export type AuthoringColumnDefaultTemplate =
+  | AuthoringColumnDefaultTemplateLiteral
+  | AuthoringColumnDefaultTemplateFunction;
+
+export interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {
+  readonly nullable?: boolean;
+  readonly default?: AuthoringColumnDefaultTemplate;
+  readonly executionDefault?: AuthoringTemplateValue;
+  readonly id?: boolean;
+  readonly unique?: boolean;
+}
+
+export interface AuthoringFieldPresetDescriptor {
+  readonly kind: 'fieldPreset';
+  readonly args?: readonly AuthoringArgumentDescriptor[];
+  readonly output: AuthoringFieldPresetOutput;
+}
+
+export type AuthoringTypeNamespace = {
+  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;
+};
+
+export type AuthoringFieldNamespace = {
+  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;
+};
+
+export interface AuthoringContributions {
+  readonly type?: AuthoringTypeNamespace;
+  readonly field?: AuthoringFieldNamespace;
+}
+
+export function isAuthoringArgRef(value: unknown): value is AuthoringArgRef {
+  if (typeof value !== 'object' || value === null || (value as { kind?: unknown }).kind !== 'arg') {
+    return false;
+  }
+  const { index, path } = value as { index?: unknown; path?: unknown };
+  if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {
+    return false;
+  }
+  if (path !== undefined && (!Array.isArray(path) || path.some((s) => typeof s !== 'string'))) {
+    return false;
+  }
+  return true;
+}
+
+function isAuthoringTemplateRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+export function isAuthoringTypeConstructorDescriptor(
+  value: unknown,
+): value is AuthoringTypeConstructorDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { kind?: unknown }).kind === 'typeConstructor' &&
+    typeof (value as { output?: unknown }).output === 'object' &&
+    (value as { output?: unknown }).output !== null
+  );
+}
+
+export function isAuthoringFieldPresetDescriptor(
+  value: unknown,
+): value is AuthoringFieldPresetDescriptor {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { kind?: unknown }).kind === 'fieldPreset' &&
+    typeof (value as { output?: unknown }).output === 'object' &&
+    (value as { output?: unknown }).output !== null
+  );
+}
+
+export function resolveAuthoringTemplateValue(
+  template: AuthoringTemplateValue,
+  args: readonly unknown[],
+): unknown {
+  if (isAuthoringArgRef(template)) {
+    let value = args[template.index];
+
+    for (const segment of template.path ?? []) {
+      if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {
+        value = undefined;
+        break;
+      }
+      value = (value as Record<string, unknown>)[segment];
+    }
+
+    if (value === undefined && template.default !== undefined) {
+      return resolveAuthoringTemplateValue(template.default, args);
+    }
+
+    return value;
+  }
+  if (Array.isArray(template)) {
+    return template.map((value) => resolveAuthoringTemplateValue(value, args));
+  }
+  if (typeof template === 'object' && template !== null) {
+    const resolved: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(template)) {
+      const resolvedValue = resolveAuthoringTemplateValue(value, args);
+      if (resolvedValue !== undefined) {
+        resolved[key] = resolvedValue;
+      }
+    }
+    return resolved;
+  }
+  return template;
+}
+
+function validateAuthoringArgument(
+  descriptor: AuthoringArgumentDescriptor,
+  value: unknown,
+  path: string,
+): void {
+  if (value === undefined) {
+    if (descriptor.optional) {
+      return;
+    }
+    throw new Error(`Missing required authoring helper argument at ${path}`);
+  }
+
+  if (descriptor.kind === 'string') {
+    if (typeof value !== 'string') {
+      throw new Error(`Authoring helper argument at ${path} must be a string`);
+    }
+    return;
+  }
+
+  if (descriptor.kind === 'stringArray') {
+    if (!Array.isArray(value)) {
+      throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+    }
+    for (const entry of value) {
+      if (typeof entry !== 'string') {
+        throw new Error(`Authoring helper argument at ${path} must be an array of strings`);
+      }
+    }
+    return;
+  }
+
+  if (descriptor.kind === 'object') {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+      throw new Error(`Authoring helper argument at ${path} must be an object`);
+    }
+
+    const input = value as Record<string, unknown>;
+    const expectedKeys = new Set(Object.keys(descriptor.properties));
+
+    for (const key of Object.keys(input)) {
+      if (!expectedKeys.has(key)) {
+        throw new Error(`Authoring helper argument at ${path} contains unknown property "${key}"`);
+      }
+    }
+
+    for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) {
+      validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);
+    }
+
+    return;
+  }
+
+  if (typeof value !== 'number' || Number.isNaN(value)) {
+    throw new Error(`Authoring helper argument at ${path} must be a number`);
+  }
+
+  if (descriptor.integer && !Number.isInteger(value)) {
+    throw new Error(`Authoring helper argument at ${path} must be an integer`);
+  }
+  if (descriptor.minimum !== undefined && value < descriptor.minimum) {
+    throw new Error(
+      `Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`,
+    );
+  }
+  if (descriptor.maximum !== undefined && value > descriptor.maximum) {
+    throw new Error(
+      `Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`,
+    );
+  }
+}
+
+export function validateAuthoringHelperArguments(
+  helperPath: string,
+  descriptors: readonly AuthoringArgumentDescriptor[] | undefined,
+  args: readonly unknown[],
+): void {
+  const expected = descriptors ?? [];
+  const minimumArgs = expected.reduce(
+    (count, descriptor, index) => (descriptor.optional ? count : index + 1),
+    0,
+  );
+  if (args.length < minimumArgs || args.length > expected.length) {
+    throw new Error(
+      `${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`,
+    );
+  }
+
+  expected.forEach((descriptor, index) => {
+    validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);
+  });
+}
+
+function resolveAuthoringStorageTypeTemplate(
+  template: AuthoringStorageTypeTemplate,
+  args: readonly unknown[],
+): {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+} {
+  const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);
+  if (typeof nativeType !== 'string') {
+    throw new Error(
+      `Resolved authoring nativeType must be a string for codec "${template.codecId}", received ${String(nativeType)}`,
+    );
+  }
+  const typeParams =
+    template.typeParams === undefined
+      ? undefined
+      : resolveAuthoringTemplateValue(template.typeParams, args);
+  if (typeParams !== undefined && !isAuthoringTemplateRecord(typeParams)) {
+    throw new Error(
+      `Resolved authoring typeParams must be an object for codec "${template.codecId}", received ${String(typeParams)}`,
+    );
+  }
+
+  return {
+    codecId: template.codecId,
+    nativeType,
+    ...(typeParams === undefined ? {} : { typeParams }),
+  };
+}
+
+function resolveAuthoringColumnDefaultTemplate(
+  template: AuthoringColumnDefaultTemplate,
+  args: readonly unknown[],
+):
+  | {
+      readonly kind: 'literal';
+      readonly value: unknown;
+    }
+  | {
+      readonly kind: 'function';
+      readonly expression: string;
+    } {
+  if (template.kind === 'literal') {
+    const value = resolveAuthoringTemplateValue(template.value, args);
+    if (value === undefined) {
+      throw new Error('Resolved authoring literal default must not be undefined');
+    }
+    return {
+      kind: 'literal',
+      value,
+    };
+  }
+
+  const expression = resolveAuthoringTemplateValue(template.expression, args);
+  if (expression === undefined || (typeof expression === 'object' && expression !== null)) {
+    throw new Error(
+      `Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`,
+    );
+  }
+  return {
+    kind: 'function',
+    expression: String(expression),
+  };
+}
+
+export function instantiateAuthoringTypeConstructor(
+  descriptor: AuthoringTypeConstructorDescriptor,
+  args: readonly unknown[],
+): {
+  readonly codecId: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+} {
+  return resolveAuthoringStorageTypeTemplate(descriptor.output, args);
+}
+
+export function instantiateAuthoringFieldPreset(
+  descriptor: AuthoringFieldPresetDescriptor,
+  args: readonly unknown[],
+): {
+  readonly descriptor: {
+    readonly codecId: string;
+    readonly nativeType: string;
+    readonly typeParams?: Record<string, unknown>;
+  };
+  readonly nullable: boolean;
+  readonly default?:
+    | {
+        readonly kind: 'literal';
+        readonly value: unknown;
+      }
+    | {
+        readonly kind: 'function';
+        readonly expression: string;
+      };
+  readonly executionDefault?: unknown;
+  readonly id: boolean;
+  readonly unique: boolean;
+} {
+  return {
+    descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),
+    nullable: descriptor.output.nullable ?? false,
+    ...ifDefined(
+      'default',
+      descriptor.output.default !== undefined
+        ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args)
+        : undefined,
+    ),
+    ...ifDefined(
+      'executionDefault',
+      descriptor.output.executionDefault !== undefined
+        ? resolveAuthoringTemplateValue(descriptor.output.executionDefault, args)
+        : undefined,
+    ),
+    id: descriptor.output.id ?? false,
+    unique: descriptor.output.unique ?? false,
+  };
+}

package/src/framework-components.ts

@@ -1,3 +1,4 @@
+import type { AuthoringContributions } from './framework-authoring';
 import type { RenderTypeContext, TypesImportSpec } from './types';
 
 /**
@@ -205,6 +206,15 @@ export interface ComponentMetadata {
       readonly nativeType?: string;
     }>;
   };
+
+  /**
+   * Optional pure-data authoring contributions exposed by this component.
+   *
+   * These contributions are safe to include on pack refs and descriptors because
+   * they contain only declarative metadata. Higher-level authoring packages may
+   * project them into concrete helper functions for TS-first workflows.
+   */
+  readonly authoring?: AuthoringContributions;
 }
 
 /**
@@ -365,8 +375,11 @@ export interface PackRefBase<Kind extends string, TFamilyId extends string>
   readonly id: string;
   readonly familyId: TFamilyId;
   readonly targetId?: string;
+  readonly authoring?: AuthoringContributions;
 }
 
+export type FamilyPackRef<TFamilyId extends string = string> = PackRefBase<'family', TFamilyId>;
+
 export type TargetPackRef<
   TFamilyId extends string = string,
   TTargetId extends string = string,
@@ -507,152 +520,33 @@ export interface ExtensionDescriptor<TFamilyId extends string, TTargetId extends
   readonly targetId: TTargetId;
 }
 
-/**
- * Union type for target-bound component descriptors.
- *
- * Target-bound components are those that must be compatible with a specific
- * family+target combination. This includes targets, adapters, drivers, and
- * extensions. Families are not target-bound.
- *
- * This type is used in migration and verification interfaces to enforce
- * type-level compatibility between components.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * // All these components must have matching familyId and targetId
- * const components: TargetBoundComponentDescriptor<'sql', 'postgres'>[] = [
- *   postgresTarget,
- *   postgresAdapter,
- *   postgresDriver,
- *   pgvectorExtension,
- * ];
- * ```
- */
+/** Components bound to a specific family+target combination. */
 export type TargetBoundComponentDescriptor<TFamilyId extends string, TTargetId extends string> =
   | TargetDescriptor<TFamilyId, TTargetId>
   | AdapterDescriptor<TFamilyId, TTargetId>
   | DriverDescriptor<TFamilyId, TTargetId>
   | ExtensionDescriptor<TFamilyId, TTargetId>;
 
-/**
- * Base interface for family instances.
- *
- * A family instance is created by a family descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add domain actions (e.g., `emitContract`, `verify` on ControlFamilyInstance).
- *
- * @template TFamilyId - Literal type for the family identifier (e.g., 'sql', 'document')
- *
- * @example
- * ```ts
- * const instance = sql.create({ target, adapter, driver, extensions });
- * instance.familyId // 'sql'
- * ```
- */
 export interface FamilyInstance<TFamilyId extends string> {
-  /** The family identifier (e.g., 'sql', 'document') */
   readonly familyId: TFamilyId;
 }
 
-/**
- * Base interface for target instances.
- *
- * A target instance is created by a target descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add target-specific behavior.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier (e.g., 'postgres', 'mysql')
- *
- * @example
- * ```ts
- * const instance = postgres.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 export interface TargetInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this target belongs to */
   readonly familyId: TFamilyId;
-
-  /** The target identifier (e.g., 'postgres', 'mysql', 'mongodb') */
   readonly targetId: TTargetId;
 }
 
-/**
- * Base interface for adapter instances.
- *
- * An adapter instance is created by an adapter descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add adapter-specific behavior (e.g., codec registration, query lowering).
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = postgresAdapter.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 export interface AdapterInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this adapter belongs to */
   readonly familyId: TFamilyId;
-
-  /** The target this adapter is designed for */
   readonly targetId: TTargetId;
 }
 
-/**
- * Base interface for driver instances.
- *
- * A driver instance is created by a driver descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add driver-specific behavior (e.g., `query`, `close` on ControlDriverInstance).
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = postgresDriver.create({ databaseUrl });
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 export interface DriverInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this driver belongs to */
   readonly familyId: TFamilyId;
-
-  /** The target this driver connects to */
   readonly targetId: TTargetId;
 }
 
-/**
- * Base interface for extension instances.
- *
- * An extension instance is created by an extension descriptor's `create()` method.
- * This base interface carries only the identity; plane-specific interfaces
- * add extension-specific behavior.
- *
- * @template TFamilyId - Literal type for the family identifier
- * @template TTargetId - Literal type for the target identifier
- *
- * @example
- * ```ts
- * const instance = pgvector.create();
- * instance.familyId // 'sql'
- * instance.targetId // 'postgres'
- * ```
- */
 export interface ExtensionInstance<TFamilyId extends string, TTargetId extends string> {
-  /** The family this extension belongs to */
   readonly familyId: TFamilyId;
-
-  /** The target this extension is designed for */
   readonly targetId: TTargetId;
 }