constructa-core 0.5.0 → 0.7.0

package/README.md

@@ -19,7 +19,13 @@ Current APIs define trusted generator implementations, portable typed definition
 
 Use `defineGenerator()` for developer-authored executable implementations. An implementation declares a stable lowercase `type`, positive integer `version`, definition validator, optional dependency analysis hook, and `generate({ definition, context })` function. Validation returns schema `ValidationIssue` objects without imposing a validation-library dependency.
 
-`GeneratorDefinition<Output>` carries output information only at compile time; emitted definitions remain plain JSON data. Factories should use `createGeneratorDefinition()` so literal fields are preserved and the resulting definition is portable. Implementations receive randomness and child generation through `GenerationContext`; they must not use global randomness or built-in-specific execution switches.
+`GeneratorDefinition<Output>` carries output information only at compile time; emitted definitions remain plain JSON data. Factories should use `createGeneratorDefinition()` so literal fields are preserved and the resulting definition is portable. Implementations receive a frozen `GenerationContext` capability view: validated random draws, the current definition path, and typed `executeChild(definition, pathSegment)`. Child dispatch uses the executor's registry snapshot, inherits the root random source, and appends exactly one path segment; implementations must not use global randomness or built-in-specific execution switches.
+
+## Runtime parsing
+
+Use `parseDefinition(value, { registry, limits? })` for untrusted runtime definition data, or `parseDocument(value, { registry, limits? })` for a versioned document. Both validate portable JSON, registered generator IDs, each implementation's configuration, and nested typed definitions without invoking `generate`. `safeParseDefinition()` and `safeParseDocument()` return all bounded, deterministic structured issues; the throwing forms return the first issue. Definitions parsed from dynamic data intentionally have broad `GeneratorDefinition` output typing.
+
+`parseTemplateTokens(source, { path? })` parses the MVP `{field}` and `{sibling.nested}` reference syntax into literal and reference tokens without resolving a value. Use `{{` and `}}` for literal braces. Empty paths, whitespace, braces inside a reference, and empty dot segments fail with `INVALID_TEMPLATE_TOKEN` at the supplied definition path.
 
 ## Random sources
 
@@ -31,6 +37,10 @@ Use `defineGenerator()` for developer-authored executable implementations. An im
 
 `createRegistry()` is advanced infrastructure. Register trusted implementations explicitly with `register()`. Duplicate type IDs fail without changing registry state; `replace()` is the deliberate replacement path and requires the type to already be registered. `lookup(type, path?)` resolves a registered implementation without a central built-in switch. Unknown IDs throw a dependency `UNKNOWN_GENERATOR` error at the supplied definition path plus `type`, with safe registered-type diagnostics. `snapshot()` returns an immutable, type-sorted registry view with the same lookup behavior; later registry changes do not affect it. Dispatch remains a separate concern.
 
+## Single-value execution
+
+`createExecutor(registry)` is advanced infrastructure for executing one root definition. It snapshots the supplied registry, parses untrusted definitions, runs dependency analysis, and dispatches the resolved implementation. Its `generate(definition, options?)` method returns the definition's inferred output type. Supply either `{ seed }` for a fresh reproducible source or `{ random }` for a caller-owned injected source; supplying both is invalid. Definitions returned by `parseDefinition()` are recognized by the executor and are not validated again, while ordinary definitions are parsed once before dispatch. `maxDepth` bounds recursive child execution (default: 64). Bulk output is intentionally not part of this boundary.
+
 ## Dependency Boundary
 
 `constructa-schema` is the only Constructa runtime dependency that `constructa-core` may depend on.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GeneratorDefinition, GeneratorDefinition as GeneratorDefinition$1, Infer, ValidationIssue, ValidationIssue as ValidationIssue$1, ValidationPath, ValidationPath as ValidationPath$1 } from "constructa-schema";
+import { ConstructaError, GeneratorDefinition, GeneratorDefinition as GeneratorDefinition$1, Infer, ValidationIssue, ValidationIssue as ValidationIssue$1, ValidationPath, ValidationPath as ValidationPath$1, ValidationPathSegment, ValidationPathSegment as ValidationPathSegment$1 } from "constructa-schema";
 //#region src/index.d.ts
 /**
  * Random values are always half-open: `float()` returns [0, 1), while
@@ -11,6 +11,20 @@ type RandomSource = {
 };
 type RandomSourceAdapter = RandomSource;
 type Seed = number | string;
+type ExecutionOptions = {
+  /** Uses a fresh deterministic source for this root execution. */
+  readonly seed?: Seed;
+  /**
+   * A caller-owned source consumed by this execution. The executor does not
+   * reset, clone, or otherwise retain it after the call returns.
+   */
+  readonly random?: RandomSource;
+  /** Maximum child-definition nesting below the root. Defaults to 64. */
+  readonly maxDepth?: number;
+};
+type Executor = {
+  generate: <Definition extends GeneratorDefinition$1>(definition: Definition, options?: ExecutionOptions) => import("constructa-schema").Infer<Definition>;
+};
 declare const SEEDED_RANDOM_ALGORITHM = "mulberry32";
 declare const SEEDED_RANDOM_ALGORITHM_VERSION = 1;
 type SeededRandomMetadata = {
@@ -44,17 +58,132 @@ declare function getSeededRandomMetadata(): SeededRandomMetadata;
 /** Services supplied by the engine. Implementations must not use global randomness. */
 type GenerationContext = {
   readonly random: RandomSource;
-  readonly generateChild: <Output>(definition: GeneratorDefinition$1<Output>) => Output;
+  /** The definition path currently being generated. */
+  readonly path: ValidationPath$1;
+  /** Delegates a typed child definition to the engine. */
+  readonly executeChild: <Output>(definition: GeneratorDefinition$1<Output>, pathSegment: ValidationPathSegment$1) => Output;
+  /**
+   * Read-only values from the object currently being generated. Values are
+   * available only after their field has completed.
+   */
+  readonly references: ReferenceResolver;
+  /** Creates an isolated scope for the fields of one composite object. */
+  readonly createObjectScope: () => ObjectGenerationScope;
+  /** Returns value dependencies declared by one direct child definition. */
+  readonly analyzeChildValueDependencies: (definition: GeneratorDefinition$1, pathSegment: ValidationPathSegment$1) => readonly ValueDependency[];
+};
+/** A property path relative to the object containing a reference. */
+type ReferencePath = readonly string[];
+/** A parsed template fragment. Braces are escaped with `{{` and `}}`. */
+type TemplateToken = {
+  readonly type: "literal";
+  readonly value: string;
+} | {
+  readonly type: "reference";
+  readonly path: ReferencePath;
+};
+type ParseTemplateTokensOptions = {
+  /** Definition-relative path reported for malformed template syntax. */
+  readonly path?: ValidationPath$1;
+};
+/**
+ * Parses MVP template syntax without executing or resolving references.
+ *
+ * `{field}` addresses a sibling and `{field.nested}` addresses a value below
+ * that sibling. `{{` and `}}` emit literal braces. Whitespace, empty path
+ * segments, and brace characters inside a reference are unsupported.
+ */
+declare function parseTemplateTokens(source: string, options?: ParseTemplateTokensOptions): readonly TemplateToken[];
+/** Parses one dot-separated object-local reference path. */
+declare function parseReferencePath(source: string, path?: ValidationPath$1): ReferencePath;
+/** A portable value dependency declared by a generator definition. */
+type ValueDependency = {
+  readonly path: ReferencePath;
+};
+/** Dependencies for a direct field in a composite definition. */
+type CompositeDependencyNode = {
+  readonly fieldPath: readonly [string];
+  readonly dependencies: readonly ValueDependency[];
+};
+/** Portable dependency data used to schedule one composite object. */
+type CompositeDependencyAnalysis = {
+  readonly nodes: readonly CompositeDependencyNode[];
 };
+/** The read-only capability supplied to generators that resolve references. */
+type ReferenceResolver = {
+  resolve: (path: ReferencePath) => unknown;
+};
+/** Executes and records completed fields within one isolated object scope. */
+type ObjectGenerationScope = {
+  executeChild: <Output>(definition: GeneratorDefinition$1<Output>, pathSegment: string) => Output;
+};
+type GenerationContextOptions = {
+  readonly random: RandomSource;
+  readonly path?: ValidationPath$1;
+  readonly executeChild?: GenerationContext["executeChild"];
+  readonly references?: ReferenceResolver;
+  readonly createObjectScope?: GenerationContext["createObjectScope"];
+  readonly analyzeChildValueDependencies?: GenerationContext["analyzeChildValueDependencies"];
+};
+/**
+ * Creates the engine-owned capability view supplied to implementations.
+ * Application code normally receives this through `generate`, rather than
+ * constructing one directly.
+ */
+declare function createGenerationContext(options: GenerationContextOptions): GenerationContext;
+/** Freezes direct-field dependency declarations into portable analysis data. */
+declare function createCompositeDependencyAnalysis(nodes: readonly CompositeDependencyNode[]): CompositeDependencyAnalysis;
+/**
+ * Returns a deterministic execution order for direct object fields. A
+ * dependency path may target a nested value below another direct field.
+ */
+declare function scheduleCompositeDependencies(analysis: CompositeDependencyAnalysis): readonly string[];
+type ParseLimits = {
+  readonly maxDepth?: number;
+  readonly maxIssues?: number;
+  readonly maxNodes?: number;
+};
+type ParseDefinitionOptions = {
+  readonly registry: Pick<GeneratorRegistry | GeneratorRegistrySnapshot, "lookup">;
+  readonly limits?: ParseLimits;
+};
+type ParseDocumentOptions = ParseDefinitionOptions;
+type DefinitionParseResult = {
+  readonly success: true;
+  readonly value: ParsedGeneratorDefinition;
+} | {
+  readonly success: false;
+  readonly issues: readonly ConstructaError[];
+};
+type DocumentParseResult = {
+  readonly success: true;
+  readonly value: import("constructa-schema").GeneratorDocumentV1;
+} | {
+  readonly success: false;
+  readonly issues: readonly ConstructaError[];
+};
+/** Parses untrusted runtime definition data without executing generator code. */
+declare function parseDefinition(value: unknown, options: ParseDefinitionOptions): ParsedGeneratorDefinition;
+declare function safeParseDefinition(value: unknown, options: ParseDefinitionOptions): DefinitionParseResult;
+/** Parses a versioned document and its root definition through the same pipeline. */
+declare function parseDocument(value: unknown, options: ParseDocumentOptions): import("constructa-schema").GeneratorDocumentV1;
+declare function safeParseDocument(value: unknown, options: ParseDocumentOptions): DocumentParseResult;
 type GeneratorDependency = {
   readonly typeId: string;
   readonly path: ValidationPath$1;
 };
+declare const parsedGeneratorDefinition: unique symbol;
+/** A runtime-validated definition accepted by an executor without revalidation. */
+type ParsedGeneratorDefinition = GeneratorDefinition$1 & {
+  readonly [parsedGeneratorDefinition]: true;
+};
 type GeneratorImplementation<Definition extends GeneratorDefinition$1<Output>, Output> = {
   readonly type: string;
   readonly version: number;
   readonly validateDefinition: (definition: unknown) => readonly ValidationIssue$1[];
   readonly analyzeDependencies?: (definition: Definition) => readonly GeneratorDependency[];
+  /** Declares object-local value references used by this definition. */
+  readonly analyzeValueDependencies?: (definition: Definition) => readonly ValueDependency[];
   readonly generate: (input: {
     readonly definition: Definition;
     readonly context: GenerationContext;
@@ -76,6 +205,11 @@ type GeneratorRegistry = {
 };
 /** Creates advanced registry infrastructure. Normal factories do not require it. */
 declare function createRegistry(): GeneratorRegistry;
+/**
+ * Creates an advanced single-value executor over an immutable registry
+ * snapshot. Normal applications will receive this behavior through the SDK.
+ */
+declare function createExecutor(registry: GeneratorRegistry | GeneratorRegistrySnapshot): Executor;
 /**
  * Defines a trusted, developer-authored generator implementation. This API has
  * no dependency on a particular validation library.
@@ -94,5 +228,5 @@ declare function invokeGeneratorImplementation<Definition extends GeneratorDefin
   readonly path?: ValidationPath$1;
 }): Output;
 //#endregion
-export { DeterminismCompatibility, GenerationContext, type GeneratorDefinition, GeneratorDependency, GeneratorImplementation, GeneratorRegistry, GeneratorRegistrySnapshot, type Infer, RandomSource, RandomSourceAdapter, RegisteredGenerator, SEEDED_RANDOM_ALGORITHM, SEEDED_RANDOM_ALGORITHM_VERSION, Seed, SeededRandomMetadata, type ValidationIssue, type ValidationPath, createDefaultRandomSource, createGeneratorDefinition, createRandomSource, createRegistry, createSeededRandom, defineGenerator, getSeededRandomMetadata, invokeGeneratorImplementation, normalizeSeed };
+export { CompositeDependencyAnalysis, CompositeDependencyNode, DefinitionParseResult, DeterminismCompatibility, DocumentParseResult, ExecutionOptions, Executor, GenerationContext, GenerationContextOptions, type GeneratorDefinition, GeneratorDependency, GeneratorImplementation, GeneratorRegistry, GeneratorRegistrySnapshot, type Infer, ObjectGenerationScope, ParseDefinitionOptions, ParseDocumentOptions, ParseLimits, ParseTemplateTokensOptions, ParsedGeneratorDefinition, RandomSource, RandomSourceAdapter, ReferencePath, ReferenceResolver, RegisteredGenerator, SEEDED_RANDOM_ALGORITHM, SEEDED_RANDOM_ALGORITHM_VERSION, Seed, SeededRandomMetadata, TemplateToken, type ValidationIssue, type ValidationPath, type ValidationPathSegment, ValueDependency, createCompositeDependencyAnalysis, createDefaultRandomSource, createExecutor, createGenerationContext, createGeneratorDefinition, createRandomSource, createRegistry, createSeededRandom, defineGenerator, getSeededRandomMetadata, invokeGeneratorImplementation, normalizeSeed, parseDefinition, parseDocument, parseReferencePath, parseTemplateTokens, safeParseDefinition, safeParseDocument, scheduleCompositeDependencies };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KAoBY;EACV;EACA,QAAQ;EACR,MAAM,iBAAiB;;KAGb,sBAAsB;KAEtB;cAEC;cACA;KAED;WACD,kBAAkB;WAClB,gBAAgB;;KAGf;WACD;WACA;WACA,QAAQ;WACR,YAAY;WACZ,MAAM;WACN;;;;;;iBAYK,mBAAmB,SAAS,sBAAsB;;iBA0ClD,6BAA6B;;;;;iBAwC7B,cAAc,MAAM;;iBAcpB,mBAAmB,MAAM,OAAO;;iBAuChC,2BAA2B;;KAK/B;WACD,QAAQ;WACR,gBAAgB,QACvB,YAAY,sBAAoB,YAC7B;;KAGK;WACD;WACA,MAAM;;KAGL,wBACV,mBAAmB,sBAAoB,SACvC;WAES;WACA;WACA,qBACP,iCACY;WACL,uBACP,YAAY,wBACA;WACL,WAAW;aACT,YAAY;aACZ,SAAS;QACd;;KAGI;WACD;WACA;;KAGC;WACD,qBAAqB;WACrB,SACP,cACA,OAAO,qBACJ,wBAAwB;;KAGnB;EACV,WAAW,mBAAmB,sBAAoB,SAAS,QACzD,gBAAgB,wBAAwB,YAAY;EAEtD,UAAU,mBAAmB,sBAAoB,SAAS,QACxD,gBAAgB,wBAAwB,YAAY;EAEtD,SACE,cACA,OAAO,qBACJ,wBAAwB;EAC7B,gBAAgB;;;iBAUF,kBAAkB;;;;;iBAoDlB,sBACR,mBAAmB,sBAAoB,SAC7C,QAEA,gBAAgB,wBAAwB,YAAY,UACnD,wBAAwB,YAAY;;iBAMvB,0BACd,cACM,mBAAmB,sBAAoB,SAC7C,YAAY,aAAa;;;;;;iBAUX,8BACd,mBAAmB,sBAAoB,SACvC,QAEA,gBAAgB,wBAAwB,YAAY,SACpD;WACW,YAAY;WACZ,SAAS;WACT,OAAO;IAEjB"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;KAyBY;EACV;EACA,QAAQ;EACR,MAAM,iBAAiB;;KAGb,sBAAsB;KAItB;KAEA;;WAED,OAAO;;;;;WAKP,SAAS;;WAET;;KAGC;EACV,WAAW,mBAAmB,uBAC5B,YAAY,YACZ,UAAU,iDACqB,MAAM;;cAG5B;cACA;KAED;WACD,kBAAkB;WAClB,gBAAgB;;KAGf;WACD;WACA;WACA,QAAQ;WACR,YAAY;WACZ,MAAM;WACN;;;;;;iBAYK,mBAAmB,SAAS,sBAAsB;;iBA4ClD,6BAA6B;;;;;iBAwC7B,cAAc,MAAM;;iBAcpB,mBAAmB,MAAM,OAAO;;iBAuChC,2BAA2B;;KAK/B;WACD,QAAQ;;WAER,MAAM;;WAEN,eAAe,QACtB,YAAY,sBAAoB,SAChC,aAAa,4BACV;;;;;WAKI,YAAY;;WAEZ,yBAAyB;;WAEzB,gCACP,YAAY,uBACZ,aAAa,qCACD;;;KAIJ;;KAGA;WACG;WAA0B;;WAC1B;WAA4B,MAAM;;KAErC;;WAED,OAAO;;;;;;;;;iBAUF,oBACd,gBACA,UAAS,sCACC;;iBA0DI,mBACd,gBACA,OAAM,mBACL;;KA8BS;WACD,MAAM;;;KAIL;WACD;WACA,uBAAuB;;;KAItB;WACD,gBAAgB;;;KAIf;EACV,UAAU,MAAM;;;KAIN;EACV,eAAe,QACb,YAAY,sBAAoB,SAChC,wBACG;;KAGK;WACD,QAAQ;WACR,OAAO;WACP,eAAe;WACf,aAAa;WACb,oBAAoB;WACpB,gCAAgC;;;;;;;iBAQ3B,wBACd,SAAS,2BACR;;iBAyFa,kCACd,gBAAgB,4BACf;;;;;iBAkCa,8BACd,UAAU;KAqDA;WACD;WACA;WACA;;KAGC;WACD,UAAU,KACjB,oBAAoB;WAGb,SAAS;;KAGR,uBAAuB;KAEvB;WACG;WAAwB,OAAO;;WAC/B;WAAyB,iBAAiB;;KAE7C;WAEG;WACA,mCAAmC;;WAEnC;WAAyB,iBAAiB;;;iBAGzC,gBACd,gBACA,SAAS,yBACR;iBAea,oBACd,gBACA,SAAS,yBACR;;iBAKa,cACd,gBACA,SAAS,mDACoB;iBAMf,kBACd,gBACA,SAAS,uBACR;KAsBS;WACD;WACA,MAAM;;cAGH;;KAGF,4BAA4B;YAC5B;;KAKA,wBACV,mBAAmB,sBAAoB,SACvC;WAES;WACA;WACA,qBACP,iCACY;WACL,uBACP,YAAY,wBACA;;WAEL,4BACP,YAAY,wBACA;WACL,WAAW;aACT,YAAY;aACZ,SAAS;QACd;;KAGI;WACD;WACA;;KAGC;WACD,qBAAqB;WACrB,SACP,cACA,OAAO,qBACJ,wBAAwB;;KAGnB;EACV,WAAW,mBAAmB,sBAAoB,SAAS,QACzD,gBAAgB,wBAAwB,YAAY;EAEtD,UAAU,mBAAmB,sBAAoB,SAAS,QACxD,gBAAgB,wBAAwB,YAAY;EAEtD,SACE,cACA,OAAO,qBACJ,wBAAwB;EAC7B,gBAAgB;;;iBAUF,kBAAkB;;;;;iBAoDlB,eACd,UAAU,oBAAoB,4BAC7B;;;;;iBA6Za,sBACR,mBAAmB,sBAAoB,SAC7C,QAEA,gBAAgB,wBAAwB,YAAY,UACnD,wBAAwB,YAAY;;iBAMvB,0BACd,cACM,mBAAmB,sBAAoB,SAC7C,YAAY,aAAa;;;;;;iBAUX,8BACd,mBAAmB,sBAAoB,SACvC,QAEA,gBAAgB,wBAAwB,YAAY,SACpD;WACW,YAAY;WACZ,SAAS;WACT,OAAO;IAEjB"}

package/dist/index.js

@@ -1,5 +1,6 @@
-import { ConstructaError, assertGeneratorDefinition, normalizeConstructaError } from "constructa-schema";
+import { ConstructaError, assertGeneratorDefinition, normalizeConstructaError, parseDocument as parseDocument$1, validateDocument, validateGeneratorDefinition } from "constructa-schema";
 //#region src/index.ts
+const validatedRandomSources = /* @__PURE__ */ new WeakSet();
 const SEEDED_RANDOM_ALGORITHM = "mulberry32";
 const SEEDED_RANDOM_ALGORITHM_VERSION = 1;
 const SEEDED_RANDOM_METADATA = Object.freeze({
@@ -12,7 +13,7 @@ const SEEDED_RANDOM_METADATA = Object.freeze({
 */
 function createRandomSource(adapter) {
 	assertRandomSourceAdapter(adapter);
-	return Object.freeze({
+	const source = Object.freeze({
 		float() {
 			const value = adapter.float();
 			if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value >= 1) throw invalidRandomSource("float() must return a finite number in [0, 1).");
@@ -31,6 +32,8 @@ function createRandomSource(adapter) {
 			return value;
 		}
 	});
+	validatedRandomSources.add(source);
+	return source;
 }
 /** Creates the default platform-backed random source. It makes no security claim. */
 function createDefaultRandomSource() {
@@ -115,6 +118,218 @@ function createSeededRandom(seed) {
 function getSeededRandomMetadata() {
 	return SEEDED_RANDOM_METADATA;
 }
+/**
+* Parses MVP template syntax without executing or resolving references.
+*
+* `{field}` addresses a sibling and `{field.nested}` addresses a value below
+* that sibling. `{{` and `}}` emit literal braces. Whitespace, empty path
+* segments, and brace characters inside a reference are unsupported.
+*/
+function parseTemplateTokens(source, options = {}) {
+	const path = options.path ?? [];
+	if (typeof source !== "string") throw templateTokenError(path, "Template source must be a string.");
+	assertContextPath(path);
+	const tokens = [];
+	let literal = "";
+	const appendLiteral = (value) => {
+		literal += value;
+	};
+	const flushLiteral = () => {
+		if (literal.length === 0) return;
+		tokens.push(Object.freeze({
+			type: "literal",
+			value: literal
+		}));
+		literal = "";
+	};
+	for (let index = 0; index < source.length; index += 1) {
+		const character = source[index];
+		if (character === "{") {
+			if (source[index + 1] === "{") {
+				appendLiteral("{");
+				index += 1;
+				continue;
+			}
+			const closingIndex = source.indexOf("}", index + 1);
+			if (closingIndex === -1) throw templateTokenError(path, "Template reference is missing a closing brace.");
+			const referencePath = parseReferencePath(source.slice(index + 1, closingIndex), path);
+			flushLiteral();
+			tokens.push(Object.freeze({
+				type: "reference",
+				path: referencePath
+			}));
+			index = closingIndex;
+			continue;
+		}
+		if (character === "}") {
+			if (source[index + 1] === "}") {
+				appendLiteral("}");
+				index += 1;
+				continue;
+			}
+			throw templateTokenError(path, "Template contains an unmatched closing brace.");
+		}
+		appendLiteral(character ?? "");
+	}
+	flushLiteral();
+	return Object.freeze(tokens);
+}
+/** Parses one dot-separated object-local reference path. */
+function parseReferencePath(source, path = []) {
+	if (typeof source !== "string" || source.length === 0) throw templateTokenError(path, "Template reference must not be empty.");
+	assertContextPath(path);
+	const segments = source.split(".");
+	if (segments.some((segment) => segment.length === 0 || /[{}\s]/u.test(segment))) throw templateTokenError(path, "Template reference segments must be non-empty and cannot contain whitespace or braces.");
+	return Object.freeze(segments);
+}
+function templateTokenError(path, message) {
+	return new ConstructaError({
+		kind: "configuration",
+		code: "INVALID_TEMPLATE_TOKEN",
+		path,
+		message
+	});
+}
+/**
+* Creates the engine-owned capability view supplied to implementations.
+* Application code normally receives this through `generate`, rather than
+* constructing one directly.
+*/
+function createGenerationContext(options) {
+	if (typeof options !== "object" || options === null) throw contextError("INVALID_GENERATION_CONTEXT", [], "Context options must be an object.");
+	assertContextPath(options.path ?? []);
+	if (typeof options.executeChild !== "undefined" && typeof options.executeChild !== "function") throw contextError("INVALID_GENERATION_CONTEXT", [], "executeChild must be a function when present.");
+	const random = validatedRandomSources.has(options.random) ? options.random : createRandomSource(options.random);
+	const path = Object.freeze([...options.path ?? []]);
+	const executeChild = options.executeChild ?? ((definition, pathSegment) => {
+		assertGeneratorDefinition(definition, [...path, pathSegment]);
+		assertContextPathSegment(pathSegment);
+		throw new ConstructaError({
+			kind: "execution",
+			code: "CHILD_EXECUTION_UNAVAILABLE",
+			path: [...path, pathSegment],
+			message: "Child execution is not available in this generation context."
+		});
+	});
+	const references = options.references ?? unavailableReferenceResolver(path);
+	if (typeof references !== "object" || references === null || typeof references.resolve !== "function") throw contextError("INVALID_GENERATION_CONTEXT", [], "references must provide a resolve function when present.");
+	const createObjectScope = options.createObjectScope ?? (() => Object.freeze({ executeChild(definition, pathSegment) {
+		return executeChild(definition, pathSegment);
+	} }));
+	if (typeof createObjectScope !== "function") throw contextError("INVALID_GENERATION_CONTEXT", [], "createObjectScope must be a function when present.");
+	const analyzeChildValueDependencies = options.analyzeChildValueDependencies ?? (() => []);
+	if (typeof analyzeChildValueDependencies !== "function") throw contextError("INVALID_GENERATION_CONTEXT", [], "analyzeChildValueDependencies must be a function when present.");
+	return Object.freeze({
+		random,
+		path,
+		executeChild,
+		references: Object.freeze({ resolve: references.resolve }),
+		createObjectScope,
+		analyzeChildValueDependencies
+	});
+}
+/** Freezes direct-field dependency declarations into portable analysis data. */
+function createCompositeDependencyAnalysis(nodes) {
+	if (!Array.isArray(nodes)) throw contextError("INVALID_COMPOSITE_DEPENDENCIES", [], "Composite dependency nodes must be an array.");
+	const names = /* @__PURE__ */ new Set();
+	const normalized = nodes.map((node, index) => {
+		if (!isCompositeDependencyNode(node) || names.has(node.fieldPath[0])) throw contextError("INVALID_COMPOSITE_DEPENDENCIES", ["nodes", index], "Each composite dependency node must name one unique field.");
+		names.add(node.fieldPath[0]);
+		return Object.freeze({
+			fieldPath: Object.freeze([...node.fieldPath]),
+			dependencies: Object.freeze(node.dependencies.map((dependency) => Object.freeze({ path: Object.freeze([...dependency.path]) })))
+		});
+	});
+	return Object.freeze({ nodes: Object.freeze(normalized) });
+}
+/**
+* Returns a deterministic execution order for direct object fields. A
+* dependency path may target a nested value below another direct field.
+*/
+function scheduleCompositeDependencies(analysis) {
+	const nodes = analysis.nodes;
+	const byName = new Map(nodes.map((node) => [node.fieldPath[0], node]));
+	const remaining = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const dependencies = /* @__PURE__ */ new Set();
+		for (const dependency of node.dependencies) {
+			const target = dependency.path[0];
+			if (target === void 0 || !byName.has(target)) throw new ConstructaError({
+				kind: "dependency",
+				code: "REFERENCE_NOT_FOUND",
+				path: [...node.fieldPath],
+				message: "A referenced object field could not be found."
+			});
+			dependencies.add(target);
+			const targets = dependents.get(target) ?? [];
+			targets.push(node.fieldPath[0]);
+			dependents.set(target, targets);
+		}
+		remaining.set(node.fieldPath[0], dependencies);
+	}
+	const ready = nodes.filter((node) => (remaining.get(node.fieldPath[0])?.size ?? 0) === 0).map((node) => node.fieldPath[0]);
+	const ordered = [];
+	while (ready.length > 0) {
+		const field = ready.shift();
+		if (field === void 0) continue;
+		ordered.push(field);
+		for (const dependent of dependents.get(field) ?? []) {
+			const dependencies = remaining.get(dependent);
+			dependencies?.delete(field);
+			if (dependencies?.size === 0) ready.push(dependent);
+		}
+	}
+	if (ordered.length !== nodes.length) {
+		const field = nodes.find((node) => !ordered.includes(node.fieldPath[0]));
+		throw new ConstructaError({
+			kind: "dependency",
+			code: "CIRCULAR_REFERENCE",
+			path: field?.fieldPath ?? [],
+			message: "Circular object value references were detected."
+		});
+	}
+	return Object.freeze(ordered);
+}
+/** Parses untrusted runtime definition data without executing generator code. */
+function parseDefinition(value, options) {
+	return parseDefinitionAtPath(value, [], options.registry, options.limits);
+}
+function parseDefinitionAtPath(value, path, registry, limits) {
+	const result = parseRuntimeDefinition(value, path, {
+		registry,
+		limits
+	});
+	if (result.success) return result.value;
+	throw result.issues[0];
+}
+function safeParseDefinition(value, options) {
+	return parseRuntimeDefinition(value, [], options);
+}
+/** Parses a versioned document and its root definition through the same pipeline. */
+function parseDocument(value, options) {
+	const result = safeParseDocument(value, options);
+	if (result.success) return result.value;
+	throw result.issues[0];
+}
+function safeParseDocument(value, options) {
+	const limits = resolveParseLimits(options);
+	const documentIssues = validationIssuesToErrors(validateDocumentSafely(value), [], limits.maxIssues);
+	if (documentIssues.length > 0) return {
+		success: false,
+		issues: documentIssues
+	};
+	const document = parseDocument$1(value);
+	const definition = parseRuntimeDefinition(document.definition, ["definition"], options);
+	return definition.success ? {
+		success: true,
+		value: document
+	} : {
+		success: false,
+		issues: definition.issues
+	};
+}
+const parsedDefinitions = /* @__PURE__ */ new WeakSet();
 const RESERVED_GENERATOR_TYPE_IDS = /* @__PURE__ */ new Set([
 	"__proto__",
 	"constructor",
@@ -143,6 +358,209 @@ function createRegistry() {
 	};
 }
 /**
+* Creates an advanced single-value executor over an immutable registry
+* snapshot. Normal applications will receive this behavior through the SDK.
+*/
+function createExecutor(registry) {
+	const snapshot = createExecutionSnapshot(registry);
+	return Object.freeze({ generate(definition, options) {
+		const execution = resolveExecutionOptions(options);
+		return executeParsedDefinition(parsedDefinitions.has(definition) ? definition : parseDefinition(definition, { registry: snapshot }), [], 0, {
+			snapshot,
+			...execution
+		});
+	} });
+}
+function executeParsedDefinition(definition, path, depth, state, references = unavailableReferenceResolver(path)) {
+	const implementation = state.snapshot.lookup(definition.type, path);
+	analyzeGeneratorDependencies(implementation, definition, state.snapshot, path);
+	return invokeValidatedGeneratorImplementation(implementation, definition, createGenerationContext({
+		random: state.random,
+		path,
+		references,
+		createObjectScope() {
+			return createObjectGenerationScope(path, (child, pathSegment, scopeReferences) => {
+				assertChildPathSegment(pathSegment, path);
+				const childPath = [...path, pathSegment];
+				if (depth >= state.maxDepth) throw new ConstructaError({
+					kind: "execution",
+					code: "MAX_EXECUTION_DEPTH",
+					path: childPath,
+					message: "Child execution exceeds the configured maximum depth."
+				});
+				return executeParsedDefinition(parseDefinitionAtPath(child, childPath, state.snapshot), childPath, depth + 1, state, scopeReferences);
+			});
+		},
+		analyzeChildValueDependencies(child, pathSegment) {
+			assertChildPathSegment(pathSegment, path);
+			const childPath = [...path, pathSegment];
+			const parsed = parseDefinitionAtPath(child, childPath, state.snapshot);
+			return analyzeValueDependencies(state.snapshot.lookup(parsed.type, childPath), parsed, childPath);
+		},
+		executeChild(child, pathSegment) {
+			assertChildPathSegment(pathSegment, path);
+			const childPath = [...path, pathSegment];
+			if (depth >= state.maxDepth) throw new ConstructaError({
+				kind: "execution",
+				code: "MAX_EXECUTION_DEPTH",
+				path: childPath,
+				message: "Child execution exceeds the configured maximum depth."
+			});
+			return executeParsedDefinition(parseDefinitionAtPath(child, childPath, state.snapshot), childPath, depth + 1, state, references);
+		}
+	}), path);
+}
+function createObjectGenerationScope(path, executeChild) {
+	const completed = /* @__PURE__ */ new Map();
+	const resolver = Object.freeze({ resolve(referencePath) {
+		assertReferencePath(referencePath, path);
+		const key = referencePathKey(referencePath);
+		if (!completed.has(key)) throw new ConstructaError({
+			kind: "dependency",
+			code: "REFERENCE_NOT_AVAILABLE",
+			path,
+			message: "The referenced object value has not completed."
+		});
+		return completed.get(key);
+	} });
+	return Object.freeze({ executeChild(definition, pathSegment) {
+		const value = executeChild(definition, pathSegment, resolver);
+		recordCompletedValue(completed, [pathSegment], value);
+		return value;
+	} });
+}
+function recordCompletedValue(completed, referencePath, value, visited = /* @__PURE__ */ new WeakSet()) {
+	completed.set(referencePathKey(referencePath), value);
+	if (typeof value !== "object" || value === null || visited.has(value)) return;
+	visited.add(value);
+	for (const [key, child] of Object.entries(value)) recordCompletedValue(completed, [...referencePath, key], child, visited);
+}
+function unavailableReferenceResolver(path) {
+	return Object.freeze({ resolve(referencePath) {
+		assertReferencePath(referencePath, path);
+		throw new ConstructaError({
+			kind: "dependency",
+			code: "REFERENCE_RESOLUTION_UNAVAILABLE",
+			path,
+			message: "Reference resolution is available only inside an object field."
+		});
+	} });
+}
+function assertReferencePath(referencePath, contextPath) {
+	if (!Array.isArray(referencePath) || referencePath.length === 0 || referencePath.some((segment) => typeof segment !== "string" || segment.length === 0)) throw contextError("INVALID_REFERENCE_PATH", contextPath, "Reference paths must contain one or more non-empty string segments.");
+}
+function referencePathKey(path) {
+	return JSON.stringify(path);
+}
+function createExecutionSnapshot(registry) {
+	if (typeof registry !== "object" || registry === null) throw contextError("INVALID_EXECUTOR_REGISTRY", ["registry"], "Executor requires a generator registry.");
+	if (typeof registry.snapshot === "function") return registry.snapshot();
+	if (typeof registry.lookup === "function") return registry;
+	throw contextError("INVALID_EXECUTOR_REGISTRY", ["registry"], "Executor requires a generator registry.");
+}
+function resolveExecutionOptions(options) {
+	if (options === void 0) return {
+		random: createDefaultRandomSource(),
+		maxDepth: 64
+	};
+	if (typeof options !== "object" || options === null) throw contextError("INVALID_EXECUTION_OPTIONS", [], "Execution options must be an object.");
+	if (options.seed !== void 0 && options.random !== void 0) throw contextError("CONFLICTING_RANDOM_OPTIONS", ["seed"], "seed and random cannot be supplied together.");
+	const maxDepth = options.maxDepth ?? 64;
+	if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) throw contextError("INVALID_EXECUTION_OPTIONS", ["maxDepth"], "maxDepth must be a non-negative safe integer.");
+	return {
+		random: options.seed !== void 0 ? createSeededRandom(options.seed) : options.random !== void 0 ? createRandomSource(options.random) : createDefaultRandomSource(),
+		maxDepth
+	};
+}
+function analyzeGeneratorDependencies(implementation, definition, registry, path) {
+	if (implementation.analyzeDependencies === void 0) return;
+	let dependencies;
+	try {
+		dependencies = implementation.analyzeDependencies(definition);
+	} catch (cause) {
+		throw normalizeConstructaError(cause, {
+			kind: "dependency",
+			code: "DEPENDENCY_ANALYSIS_FAILED",
+			path,
+			message: "Generator dependency analysis failed."
+		});
+	}
+	if (!Array.isArray(dependencies)) throw new ConstructaError({
+		kind: "system",
+		code: "DEPENDENCY_ANALYSIS_FAILED",
+		path,
+		message: "Generator dependency analysis returned an invalid result."
+	});
+	for (const dependency of dependencies) {
+		if (!isGeneratorDependency(dependency)) throw new ConstructaError({
+			kind: "system",
+			code: "DEPENDENCY_ANALYSIS_FAILED",
+			path,
+			message: "Generator dependency analysis returned an invalid dependency."
+		});
+		registry.lookup(dependency.typeId, [...path, ...dependency.path]);
+	}
+}
+function analyzeValueDependencies(implementation, definition, path) {
+	if (implementation.analyzeValueDependencies === void 0) return [];
+	let dependencies;
+	try {
+		dependencies = implementation.analyzeValueDependencies(definition);
+	} catch (cause) {
+		throw normalizeConstructaError(cause, {
+			kind: "dependency",
+			code: "DEPENDENCY_ANALYSIS_FAILED",
+			path,
+			message: "Value dependency analysis failed."
+		});
+	}
+	if (!Array.isArray(dependencies) || !dependencies.every(isValueDependency)) throw new ConstructaError({
+		kind: "system",
+		code: "DEPENDENCY_ANALYSIS_FAILED",
+		path,
+		message: "Value dependency analysis returned an invalid result."
+	});
+	return Object.freeze(dependencies.map((dependency) => Object.freeze({ path: Object.freeze([...dependency.path]) })));
+}
+function isGeneratorDependency(value) {
+	return typeof value === "object" && value !== null && typeof value.typeId === "string" && Array.isArray(value.path) && value.path.every((segment) => typeof segment === "string" || Number.isSafeInteger(segment));
+}
+function isValueDependency(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.path) && value.path.length > 0 && value.path.every((segment) => typeof segment === "string" && segment.length > 0);
+}
+function isCompositeDependencyNode(value) {
+	return typeof value === "object" && value !== null && Array.isArray(value.fieldPath) && value.fieldPath.length === 1 && typeof value.fieldPath[0] === "string" && Array.isArray(value.dependencies) && value.dependencies.every(isValueDependency);
+}
+function invokeValidatedGeneratorImplementation(implementation, definition, context, path) {
+	try {
+		return implementation.generate({
+			definition,
+			context
+		});
+	} catch (cause) {
+		if (cause instanceof ConstructaError) return throwWithExecutionPath(cause, path);
+		throw normalizeConstructaError(cause, {
+			kind: "execution",
+			code: "EXECUTION_FAILED",
+			path,
+			message: "Generator execution failed."
+		});
+	}
+}
+function throwWithExecutionPath(error, path) {
+	if (path.length === 0 || startsWithPath(error.path, path)) throw error;
+	throw new ConstructaError({
+		kind: error.kind,
+		code: error.code,
+		path: [...path, ...error.path],
+		message: error.message,
+		details: error.details
+	});
+}
+function startsWithPath(path, prefix) {
+	return prefix.every((segment, index) => path[index] === segment);
+}
+/**
 * Defines a trusted, developer-authored generator implementation. This API has
 * no dependency on a particular validation library.
 */
@@ -177,7 +595,7 @@ function invokeGeneratorImplementation(implementation, input) {
 		const [issue] = issues;
 		if (issue !== void 0) throw new ConstructaError({
 			kind: "configuration",
-			code: "INVALID_CONFIGURATION",
+			code: errorCodeForValidationIssue(issue.code),
 			path: [...path, ...issue.path],
 			message: issue.message,
 			details: { issueCode: issue.code }
@@ -203,6 +621,165 @@ function invokeGeneratorImplementation(implementation, input) {
 		});
 	}
 }
+const DEFAULT_PARSE_LIMITS = Object.freeze({
+	maxDepth: 64,
+	maxIssues: 100,
+	maxNodes: 1e4
+});
+function parseRuntimeDefinition(value, path, options) {
+	const limits = resolveParseLimits(options);
+	const schemaIssues = validationIssuesToErrors(validateDefinitionSafely(value, path), path, limits.maxIssues);
+	if (schemaIssues.length > 0) return {
+		success: false,
+		issues: schemaIssues
+	};
+	const issues = [];
+	const visited = /* @__PURE__ */ new Set();
+	visitRuntimeDefinition(value, path, 0, options.registry, limits, visited, issues);
+	return issues.length === 0 ? {
+		success: true,
+		value: markParsedDefinitions(visited, value)
+	} : {
+		success: false,
+		issues: Object.freeze(issues)
+	};
+}
+function markParsedDefinitions(definitions, definition) {
+	for (const parsed of definitions) parsedDefinitions.add(parsed);
+	return definition;
+}
+function visitRuntimeDefinition(definition, path, depth, registry, limits, visited, issues) {
+	if (issues.length >= limits.maxIssues) return;
+	if (depth > limits.maxDepth) {
+		addParseIssue(issues, limits, "PARSE_DEPTH_LIMIT", path, "Generator definition exceeds the maximum nesting depth.");
+		return;
+	}
+	if (visited.size >= limits.maxNodes) {
+		addParseIssue(issues, limits, "PARSE_NODE_LIMIT", path, "Generator definition exceeds the maximum node count.");
+		return;
+	}
+	visited.add(definition);
+	let implementation;
+	try {
+		implementation = registry.lookup(definition.type, path);
+	} catch (cause) {
+		addExistingParseIssue(issues, limits, normalizeConstructaError(cause, {
+			kind: "dependency",
+			code: "UNKNOWN_GENERATOR",
+			path: [...path, "type"],
+			message: "Generator type could not be resolved."
+		}));
+		return;
+	}
+	let validationIssues;
+	try {
+		validationIssues = implementation.validateDefinition(definition);
+	} catch (cause) {
+		addExistingParseIssue(issues, limits, normalizeConstructaError(cause, {
+			kind: "configuration",
+			code: "INVALID_CONFIGURATION",
+			path,
+			message: "Generator definition validation failed."
+		}));
+		return;
+	}
+	if (!Array.isArray(validationIssues)) {
+		addParseIssue(issues, limits, "INVALID_CONFIGURATION", path, "Generator definition validation returned an invalid result.", "system");
+		return;
+	}
+	for (const issue of validationIssues) {
+		if (!isValidationIssue(issue)) {
+			addParseIssue(issues, limits, "INVALID_CONFIGURATION", path, "Generator definition validation returned an invalid issue.", "system");
+			return;
+		}
+		addParseIssue(issues, limits, errorCodeForValidationIssue(issue.code), [...path, ...issue.path], issue.message);
+	}
+	for (const [key, child] of Object.entries(definition)) {
+		if (key !== "type") visitEmbeddedDefinitions(child, [...path, key], depth + 1, registry, limits, visited, issues);
+		if (issues.length >= limits.maxIssues) return;
+	}
+}
+function visitEmbeddedDefinitions(value, path, depth, registry, limits, visited, issues) {
+	if (issues.length >= limits.maxIssues || value === null || typeof value !== "object") return;
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index += 1) {
+			visitEmbeddedDefinitions(value[index], [...path, index], depth, registry, limits, visited, issues);
+			if (issues.length >= limits.maxIssues) return;
+		}
+		return;
+	}
+	if (Object.hasOwn(value, "type")) {
+		visitRuntimeDefinition(value, path, depth, registry, limits, visited, issues);
+		return;
+	}
+	for (const [key, child] of Object.entries(value)) {
+		visitEmbeddedDefinitions(child, [...path, key], depth, registry, limits, visited, issues);
+		if (issues.length >= limits.maxIssues) return;
+	}
+}
+function resolveParseLimits(options) {
+	if (typeof options !== "object" || options === null || typeof options.registry !== "object" || options.registry === null || typeof options.registry.lookup !== "function") throw contextError("INVALID_PARSE_OPTIONS", [], "Parsing requires a registry with a lookup function.");
+	const supplied = options.limits ?? {};
+	const resolved = {
+		maxDepth: supplied.maxDepth ?? DEFAULT_PARSE_LIMITS.maxDepth,
+		maxIssues: supplied.maxIssues ?? DEFAULT_PARSE_LIMITS.maxIssues,
+		maxNodes: supplied.maxNodes ?? DEFAULT_PARSE_LIMITS.maxNodes
+	};
+	for (const [name, value] of Object.entries(resolved)) if (!Number.isSafeInteger(value) || value < 1) throw contextError("INVALID_PARSE_LIMITS", ["limits", name], `${name} must be a positive safe integer.`);
+	return resolved;
+}
+function validateDefinitionSafely(value, path) {
+	try {
+		return validateGeneratorDefinition(value, path);
+	} catch (_cause) {
+		return [{
+			code: "invalid_json_value",
+			path,
+			message: "Definition could not be safely inspected."
+		}];
+	}
+}
+function validateDocumentSafely(value) {
+	try {
+		return validateDocument(value);
+	} catch {
+		return [{
+			code: "invalid_json_value",
+			path: [],
+			message: "Document could not be safely inspected."
+		}];
+	}
+}
+function validationIssuesToErrors(issues, fallbackPath, maxIssues = Number.POSITIVE_INFINITY) {
+	return issues.slice(0, maxIssues).map((issue) => new ConstructaError({
+		kind: "configuration",
+		code: isValidationIssue(issue) ? errorCodeForValidationIssue(issue.code) : "INVALID_CONFIGURATION",
+		path: isValidationIssue(issue) ? issue.path : fallbackPath,
+		message: isValidationIssue(issue) ? issue.message : "Validation returned an invalid issue.",
+		details: isValidationIssue(issue) ? { issueCode: issue.code } : void 0
+	}));
+}
+function errorCodeForValidationIssue(code) {
+	return {
+		empty_choice: "EMPTY_CHOICE",
+		invalid_length: "INVALID_LENGTH",
+		invalid_range: "INVALID_RANGE"
+	}[code] ?? "INVALID_CONFIGURATION";
+}
+function isValidationIssue(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string" && typeof value.message === "string" && Array.isArray(value.path);
+}
+function addParseIssue(issues, limits, code, path, message, kind = "configuration") {
+	if (issues.length < limits.maxIssues) issues.push(new ConstructaError({
+		kind,
+		code,
+		path,
+		message
+	}));
+}
+function addExistingParseIssue(issues, limits, error) {
+	if (issues.length < limits.maxIssues) issues.push(error);
+}
 function assertGeneratorImplementation(implementation) {
 	if (!isStableTypeId(implementation.type)) throw new TypeError("generator type must be a stable lowercase identifier");
 	if (!Number.isSafeInteger(implementation.version) || implementation.version < 1) throw new TypeError("generator version must be a positive safe integer");
@@ -271,6 +848,23 @@ function invalidRandomSource(message) {
 		message
 	});
 }
+function assertContextPath(path) {
+	for (const segment of path) assertContextPathSegment(segment);
+}
+function assertContextPathSegment(segment) {
+	if (typeof segment !== "string" && (!Number.isSafeInteger(segment) || typeof segment !== "number")) throw contextError("INVALID_GENERATION_CONTEXT", ["path"], "Context path segments must be strings or safe integers.");
+}
+function assertChildPathSegment(segment, path) {
+	if (typeof segment !== "string" && (typeof segment !== "number" || !Number.isSafeInteger(segment))) throw contextError("INVALID_CHILD_PATH", path, "Child path segments must be strings or safe integers.");
+}
+function contextError(code, path, message) {
+	return new ConstructaError({
+		kind: "configuration",
+		code,
+		path,
+		message
+	});
+}
 function hashSeed(seed) {
 	let hash = 2166136261;
 	for (const byte of new TextEncoder().encode(seed)) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
@@ -280,6 +874,6 @@ function isStableTypeId(value) {
 	return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u.test(value);
 }
 //#endregion
-export { SEEDED_RANDOM_ALGORITHM, SEEDED_RANDOM_ALGORITHM_VERSION, createDefaultRandomSource, createGeneratorDefinition, createRandomSource, createRegistry, createSeededRandom, defineGenerator, getSeededRandomMetadata, invokeGeneratorImplementation, normalizeSeed };
+export { SEEDED_RANDOM_ALGORITHM, SEEDED_RANDOM_ALGORITHM_VERSION, createCompositeDependencyAnalysis, createDefaultRandomSource, createExecutor, createGenerationContext, createGeneratorDefinition, createRandomSource, createRegistry, createSeededRandom, defineGenerator, getSeededRandomMetadata, invokeGeneratorImplementation, normalizeSeed, parseDefinition, parseDocument, parseReferencePath, parseTemplateTokens, safeParseDefinition, safeParseDocument, scheduleCompositeDependencies };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import {\n  assertGeneratorDefinition,\n  ConstructaError,\n  type GeneratorDefinition,\n  normalizeConstructaError,\n  type ValidationIssue,\n  type ValidationPath,\n} from \"constructa-schema\";\n\nexport type {\n  GeneratorDefinition,\n  Infer,\n  ValidationIssue,\n  ValidationPath,\n} from \"constructa-schema\";\n\n/**\n * Random values are always half-open: `float()` returns [0, 1), while\n * `integer(maxExclusive)` returns an integer in [0, maxExclusive).\n */\nexport type RandomSource = {\n  float(): number;\n  integer(maxExclusive: number): number;\n  bytes(length: number): Uint8Array;\n};\n\nexport type RandomSourceAdapter = RandomSource;\n\nexport type Seed = number | string;\n\nexport const SEEDED_RANDOM_ALGORITHM = \"mulberry32\";\nexport const SEEDED_RANDOM_ALGORITHM_VERSION = 1;\n\nexport type SeededRandomMetadata = {\n  readonly algorithm: typeof SEEDED_RANDOM_ALGORITHM;\n  readonly version: typeof SEEDED_RANDOM_ALGORITHM_VERSION;\n};\n\nexport type DeterminismCompatibility = {\n  readonly engineVersion: string;\n  readonly generatorImplementationVersion: number;\n  readonly random: SeededRandomMetadata;\n  readonly definition: GeneratorDefinition;\n  readonly seed: Seed;\n  readonly executionMode: string;\n};\n\nconst SEEDED_RANDOM_METADATA: SeededRandomMetadata = Object.freeze({\n  algorithm: SEEDED_RANDOM_ALGORITHM,\n  version: SEEDED_RANDOM_ALGORITHM_VERSION,\n});\n\n/**\n * Validates an injected source and guards every produced value. No fallback\n * randomness is used when an adapter violates its contract.\n */\nexport function createRandomSource(adapter: RandomSourceAdapter): RandomSource {\n  assertRandomSourceAdapter(adapter);\n\n  return Object.freeze({\n    float() {\n      const value = adapter.float();\n      if (\n        typeof value !== \"number\" ||\n        !Number.isFinite(value) ||\n        value < 0 ||\n        value >= 1\n      ) {\n        throw invalidRandomSource(\n          \"float() must return a finite number in [0, 1).\",\n        );\n      }\n      return value;\n    },\n    integer(maxExclusive: number) {\n      assertRandomLength(maxExclusive, \"maxExclusive\");\n      const value = adapter.integer(maxExclusive);\n      if (!Number.isSafeInteger(value) || value < 0 || value >= maxExclusive) {\n        throw invalidRandomSource(\n          \"integer(maxExclusive) must return a safe integer in [0, maxExclusive).\",\n        );\n      }\n      return value;\n    },\n    bytes(length: number) {\n      assertByteLength(length);\n      const value = adapter.bytes(length);\n      if (!(value instanceof Uint8Array) || value.length !== length) {\n        throw invalidRandomSource(\n          \"bytes(length) must return a Uint8Array with exactly length bytes.\",\n        );\n      }\n      return value;\n    },\n  });\n}\n\n/** Creates the default platform-backed random source. It makes no security claim. */\nexport function createDefaultRandomSource(): RandomSource {\n  const crypto = globalThis.crypto;\n  if (crypto?.getRandomValues === undefined) {\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"SYSTEM_RANDOM_UNAVAILABLE\",\n      path: [],\n      message: \"Platform cryptographic random values are unavailable.\",\n    });\n  }\n\n  const randomBytes = (length: number) => {\n    const bytes = new Uint8Array(length);\n    for (let offset = 0; offset < length; offset += 65_536) {\n      crypto.getRandomValues(bytes.subarray(offset, offset + 65_536));\n    }\n    return bytes;\n  };\n  const uint32 = () => new DataView(randomBytes(4).buffer).getUint32(0);\n  const uint53 = () => (uint32() & 0x1f_ffff) * 2 ** 32 + uint32();\n\n  return createRandomSource({\n    float() {\n      return uint53() / 2 ** 53;\n    },\n    integer(maxExclusive: number) {\n      const range = 2 ** 53;\n      const upperLimit = range - (range % maxExclusive);\n      let value = uint53();\n      while (value >= upperLimit) value = uint53();\n      return value % maxExclusive;\n    },\n    bytes: randomBytes,\n  });\n}\n\n/**\n * Returns a canonical seed representation. Strings use UTF-8 exactly; finite\n * numbers use their JavaScript numeric representation, with -0 normalized to 0.\n */\nexport function normalizeSeed(seed: Seed): string {\n  if (typeof seed === \"string\") return `string:${seed}`;\n  if (typeof seed === \"number\" && Number.isFinite(seed)) {\n    return `number:${Object.is(seed, -0) ? \"0\" : String(seed)}`;\n  }\n  throw new ConstructaError({\n    kind: \"configuration\",\n    code: \"INVALID_SEED\",\n    path: [\"seed\"],\n    message: \"seed must be a string or finite number.\",\n  });\n}\n\n/** Creates an isolated deterministic random source for the current algorithm version. */\nexport function createSeededRandom(seed: Seed): RandomSource {\n  let state = hashSeed(normalizeSeed(seed));\n  const uint32 = () => {\n    state = (state + 0x6d2b_79f5) >>> 0;\n    let value = state;\n    value = Math.imul(value ^ (value >>> 15), value | 1);\n    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);\n    return (value ^ (value >>> 14)) >>> 0;\n  };\n  const uint53 = () => (uint32() & 0x1f_ffff) * 2 ** 32 + uint32();\n\n  return createRandomSource({\n    float() {\n      return uint53() / 2 ** 53;\n    },\n    integer(maxExclusive: number) {\n      const range = 2 ** 53;\n      const upperLimit = range - (range % maxExclusive);\n      let value = uint53();\n      while (value >= upperLimit) value = uint53();\n      return value % maxExclusive;\n    },\n    bytes(length: number) {\n      const bytes = new Uint8Array(length);\n      for (let index = 0; index < length; index += 1) {\n        if (index % 4 === 0) {\n          const value = uint32();\n          bytes[index] = value & 0xff;\n          if (index + 1 < length) bytes[index + 1] = (value >>> 8) & 0xff;\n          if (index + 2 < length) bytes[index + 2] = (value >>> 16) & 0xff;\n          if (index + 3 < length) bytes[index + 3] = value >>> 24;\n        }\n      }\n      return bytes;\n    },\n  });\n}\n\n/** Metadata for reproducibility diagnostics. It intentionally contains no seed. */\nexport function getSeededRandomMetadata(): SeededRandomMetadata {\n  return SEEDED_RANDOM_METADATA;\n}\n\n/** Services supplied by the engine. Implementations must not use global randomness. */\nexport type GenerationContext = {\n  readonly random: RandomSource;\n  readonly generateChild: <Output>(\n    definition: GeneratorDefinition<Output>,\n  ) => Output;\n};\n\nexport type GeneratorDependency = {\n  readonly typeId: string;\n  readonly path: ValidationPath;\n};\n\nexport type GeneratorImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n> = {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: (\n    definition: unknown,\n  ) => readonly ValidationIssue[];\n  readonly analyzeDependencies?: (\n    definition: Definition,\n  ) => readonly GeneratorDependency[];\n  readonly generate: (input: {\n    readonly definition: Definition;\n    readonly context: GenerationContext;\n  }) => Output;\n};\n\nexport type RegisteredGenerator = {\n  readonly type: string;\n  readonly version: number;\n};\n\nexport type GeneratorRegistrySnapshot = {\n  readonly generators: readonly RegisteredGenerator[];\n  readonly lookup: (\n    type: string,\n    path?: ValidationPath,\n  ) => GeneratorImplementation<GeneratorDefinition, unknown>;\n};\n\nexport type GeneratorRegistry = {\n  register: <Definition extends GeneratorDefinition<Output>, Output>(\n    implementation: GeneratorImplementation<Definition, Output>,\n  ) => void;\n  replace: <Definition extends GeneratorDefinition<Output>, Output>(\n    implementation: GeneratorImplementation<Definition, Output>,\n  ) => void;\n  lookup: (\n    type: string,\n    path?: ValidationPath,\n  ) => GeneratorImplementation<GeneratorDefinition, unknown>;\n  snapshot: () => GeneratorRegistrySnapshot;\n};\n\nconst RESERVED_GENERATOR_TYPE_IDS = new Set([\n  \"__proto__\",\n  \"constructor\",\n  \"prototype\",\n]);\n\n/** Creates advanced registry infrastructure. Normal factories do not require it. */\nexport function createRegistry(): GeneratorRegistry {\n  const implementations = new Map<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >();\n\n  return {\n    register(implementation) {\n      assertRegistryImplementation(implementation);\n      if (implementations.has(implementation.type)) {\n        throw registryError(\n          \"DUPLICATE_GENERATOR\",\n          [\"type\"],\n          `A generator with type \"${implementation.type}\" is already registered.`,\n        );\n      }\n      implementations.set(\n        implementation.type,\n        freezeImplementation(\n          implementation,\n        ) as unknown as GeneratorImplementation<GeneratorDefinition, unknown>,\n      );\n    },\n    replace(implementation) {\n      assertRegistryImplementation(implementation);\n      if (!implementations.has(implementation.type)) {\n        throw registryError(\n          \"UNKNOWN_GENERATOR\",\n          [\"type\"],\n          `No generator with type \"${implementation.type}\" is registered.`,\n        );\n      }\n      implementations.set(\n        implementation.type,\n        freezeImplementation(\n          implementation,\n        ) as unknown as GeneratorImplementation<GeneratorDefinition, unknown>,\n      );\n    },\n    lookup(type, path = []) {\n      return lookupImplementation(implementations, type, path);\n    },\n    snapshot() {\n      return createRegistrySnapshot(implementations);\n    },\n  };\n}\n\n/**\n * Defines a trusted, developer-authored generator implementation. This API has\n * no dependency on a particular validation library.\n */\nexport function defineGenerator<\n  const Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n): GeneratorImplementation<Definition, Output> {\n  assertGeneratorImplementation(implementation);\n  return implementation;\n}\n\n/** Builds a portable definition while preserving literal fields and output inference. */\nexport function createGeneratorDefinition<\n  Output,\n  const Definition extends GeneratorDefinition<Output>,\n>(definition: Definition): Definition {\n  assertGeneratorDefinition(definition);\n  return definition;\n}\n\n/**\n * Invokes one validated implementation. Registry lookup and dispatch are added\n * later; this function keeps validation and execution failure normalization in\n * the same shared contract today.\n */\nexport function invokeGeneratorImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n  input: {\n    readonly definition: Definition;\n    readonly context: GenerationContext;\n    readonly path?: ValidationPath;\n  },\n): Output {\n  const path = input.path ?? [];\n  let issues: readonly ValidationIssue[];\n\n  try {\n    issues = implementation.validateDefinition(input.definition);\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"configuration\",\n      code: \"INVALID_CONFIGURATION\",\n      path,\n      message: \"Generator definition validation failed.\",\n    });\n  }\n\n  if (issues.length > 0) {\n    const [issue] = issues;\n    if (issue !== undefined) {\n      throw new ConstructaError({\n        kind: \"configuration\",\n        code: \"INVALID_CONFIGURATION\",\n        path: [...path, ...issue.path],\n        message: issue.message,\n        details: { issueCode: issue.code },\n      });\n    }\n\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"EXECUTION_FAILED\",\n      path,\n      message: \"Generator validation returned an invalid result.\",\n    });\n  }\n\n  try {\n    return implementation.generate({\n      definition: input.definition,\n      context: input.context,\n    });\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"execution\",\n      code: \"EXECUTION_FAILED\",\n      path,\n      message: \"Generator execution failed.\",\n    });\n  }\n}\n\nfunction assertGeneratorImplementation(implementation: {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: unknown;\n  readonly analyzeDependencies?: unknown;\n  readonly generate: unknown;\n}): void {\n  if (!isStableTypeId(implementation.type)) {\n    throw new TypeError(\"generator type must be a stable lowercase identifier\");\n  }\n  if (\n    !Number.isSafeInteger(implementation.version) ||\n    implementation.version < 1\n  ) {\n    throw new TypeError(\"generator version must be a positive safe integer\");\n  }\n  if (typeof implementation.validateDefinition !== \"function\") {\n    throw new TypeError(\"validateDefinition must be a function\");\n  }\n  if (typeof implementation.generate !== \"function\") {\n    throw new TypeError(\"generate must be a function\");\n  }\n  if (\n    implementation.analyzeDependencies !== undefined &&\n    typeof implementation.analyzeDependencies !== \"function\"\n  ) {\n    throw new TypeError(\"analyzeDependencies must be a function when present\");\n  }\n}\n\nfunction assertRegistryImplementation(implementation: {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: unknown;\n  readonly analyzeDependencies?: unknown;\n  readonly generate: unknown;\n}): void {\n  try {\n    assertGeneratorImplementation(implementation);\n  } catch {\n    throw registryError(\n      \"INVALID_CONFIGURATION\",\n      [\"implementation\"],\n      \"Generator implementation is invalid.\",\n    );\n  }\n  if (RESERVED_GENERATOR_TYPE_IDS.has(implementation.type)) {\n    throw registryError(\n      \"INVALID_CONFIGURATION\",\n      [\"type\"],\n      `Generator type \"${implementation.type}\" is reserved.`,\n    );\n  }\n}\n\nfunction freezeImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n): GeneratorImplementation<Definition, Output> {\n  return Object.freeze({ ...implementation });\n}\n\nfunction createRegistrySnapshot(\n  implementations: ReadonlyMap<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >,\n): GeneratorRegistrySnapshot {\n  const snapshotImplementations = new Map(implementations);\n  const generators = [...snapshotImplementations.values()]\n    .map(({ type, version }) => Object.freeze({ type, version }))\n    .sort((left, right) => left.type.localeCompare(right.type));\n\n  return Object.freeze({\n    generators: Object.freeze(generators),\n    lookup(type: string, path: ValidationPath = []) {\n      return lookupImplementation(snapshotImplementations, type, path);\n    },\n  });\n}\n\nfunction lookupImplementation(\n  implementations: ReadonlyMap<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >,\n  type: string,\n  path: ValidationPath,\n): GeneratorImplementation<GeneratorDefinition, unknown> {\n  const implementation = implementations.get(type);\n  if (implementation !== undefined) return implementation;\n\n  const registeredTypes = [...implementations.keys()].sort((left, right) =>\n    left.localeCompare(right),\n  );\n  throw new ConstructaError({\n    kind: \"dependency\",\n    code: \"UNKNOWN_GENERATOR\",\n    path: [...path, \"type\"],\n    message: `No generator with type \"${type}\" is registered.`,\n    details: { registeredTypes },\n  });\n}\n\nfunction registryError(\n  code: \"DUPLICATE_GENERATOR\" | \"INVALID_CONFIGURATION\" | \"UNKNOWN_GENERATOR\",\n  path: ValidationPath,\n  message: string,\n): ConstructaError {\n  return new ConstructaError({ kind: \"configuration\", code, path, message });\n}\n\nfunction assertRandomSourceAdapter(adapter: RandomSourceAdapter): void {\n  if (\n    typeof adapter !== \"object\" ||\n    adapter === null ||\n    typeof adapter.float !== \"function\" ||\n    typeof adapter.integer !== \"function\" ||\n    typeof adapter.bytes !== \"function\"\n  ) {\n    throw invalidRandomSource(\n      \"A random source must provide float(), integer(), and bytes() methods.\",\n    );\n  }\n}\n\nfunction assertRandomLength(value: number, name: string): void {\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw invalidRandomSource(`${name} must be a positive safe integer.`);\n  }\n}\n\nfunction assertByteLength(length: number): void {\n  if (!Number.isSafeInteger(length) || length < 0) {\n    throw invalidRandomSource(\"length must be a non-negative safe integer.\");\n  }\n}\n\nfunction invalidRandomSource(message: string): ConstructaError {\n  return new ConstructaError({\n    kind: \"system\",\n    code: \"INVALID_RANDOM_SOURCE\",\n    path: [\"random\"],\n    message,\n  });\n}\n\nfunction hashSeed(seed: string): number {\n  let hash = 0x811c_9dc5;\n  for (const byte of new TextEncoder().encode(seed)) {\n    hash = Math.imul(hash ^ byte, 0x0100_0193) >>> 0;\n  }\n  return hash;\n}\n\nfunction isStableTypeId(value: string): boolean {\n  return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u.test(value);\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":["parseSchemaDocument"],"sources":["../src/index.ts"],"sourcesContent":["import {\n  assertGeneratorDefinition,\n  ConstructaError,\n  type GeneratorDefinition,\n  normalizeConstructaError,\n  parseDocument as parseSchemaDocument,\n  type ValidationIssue,\n  type ValidationPath,\n  type ValidationPathSegment,\n  validateDocument,\n  validateGeneratorDefinition,\n} from \"constructa-schema\";\n\nexport type {\n  GeneratorDefinition,\n  Infer,\n  ValidationIssue,\n  ValidationPath,\n  ValidationPathSegment,\n} from \"constructa-schema\";\n\n/**\n * Random values are always half-open: `float()` returns [0, 1), while\n * `integer(maxExclusive)` returns an integer in [0, maxExclusive).\n */\nexport type RandomSource = {\n  float(): number;\n  integer(maxExclusive: number): number;\n  bytes(length: number): Uint8Array;\n};\n\nexport type RandomSourceAdapter = RandomSource;\n\nconst validatedRandomSources = new WeakSet<object>();\n\nexport type Seed = number | string;\n\nexport type ExecutionOptions = {\n  /** Uses a fresh deterministic source for this root execution. */\n  readonly seed?: Seed;\n  /**\n   * A caller-owned source consumed by this execution. The executor does not\n   * reset, clone, or otherwise retain it after the call returns.\n   */\n  readonly random?: RandomSource;\n  /** Maximum child-definition nesting below the root. Defaults to 64. */\n  readonly maxDepth?: number;\n};\n\nexport type Executor = {\n  generate: <Definition extends GeneratorDefinition>(\n    definition: Definition,\n    options?: ExecutionOptions,\n  ) => import(\"constructa-schema\").Infer<Definition>;\n};\n\nexport const SEEDED_RANDOM_ALGORITHM = \"mulberry32\";\nexport const SEEDED_RANDOM_ALGORITHM_VERSION = 1;\n\nexport type SeededRandomMetadata = {\n  readonly algorithm: typeof SEEDED_RANDOM_ALGORITHM;\n  readonly version: typeof SEEDED_RANDOM_ALGORITHM_VERSION;\n};\n\nexport type DeterminismCompatibility = {\n  readonly engineVersion: string;\n  readonly generatorImplementationVersion: number;\n  readonly random: SeededRandomMetadata;\n  readonly definition: GeneratorDefinition;\n  readonly seed: Seed;\n  readonly executionMode: string;\n};\n\nconst SEEDED_RANDOM_METADATA: SeededRandomMetadata = Object.freeze({\n  algorithm: SEEDED_RANDOM_ALGORITHM,\n  version: SEEDED_RANDOM_ALGORITHM_VERSION,\n});\n\n/**\n * Validates an injected source and guards every produced value. No fallback\n * randomness is used when an adapter violates its contract.\n */\nexport function createRandomSource(adapter: RandomSourceAdapter): RandomSource {\n  assertRandomSourceAdapter(adapter);\n\n  const source = Object.freeze({\n    float() {\n      const value = adapter.float();\n      if (\n        typeof value !== \"number\" ||\n        !Number.isFinite(value) ||\n        value < 0 ||\n        value >= 1\n      ) {\n        throw invalidRandomSource(\n          \"float() must return a finite number in [0, 1).\",\n        );\n      }\n      return value;\n    },\n    integer(maxExclusive: number) {\n      assertRandomLength(maxExclusive, \"maxExclusive\");\n      const value = adapter.integer(maxExclusive);\n      if (!Number.isSafeInteger(value) || value < 0 || value >= maxExclusive) {\n        throw invalidRandomSource(\n          \"integer(maxExclusive) must return a safe integer in [0, maxExclusive).\",\n        );\n      }\n      return value;\n    },\n    bytes(length: number) {\n      assertByteLength(length);\n      const value = adapter.bytes(length);\n      if (!(value instanceof Uint8Array) || value.length !== length) {\n        throw invalidRandomSource(\n          \"bytes(length) must return a Uint8Array with exactly length bytes.\",\n        );\n      }\n      return value;\n    },\n  });\n  validatedRandomSources.add(source);\n  return source;\n}\n\n/** Creates the default platform-backed random source. It makes no security claim. */\nexport function createDefaultRandomSource(): RandomSource {\n  const crypto = globalThis.crypto;\n  if (crypto?.getRandomValues === undefined) {\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"SYSTEM_RANDOM_UNAVAILABLE\",\n      path: [],\n      message: \"Platform cryptographic random values are unavailable.\",\n    });\n  }\n\n  const randomBytes = (length: number) => {\n    const bytes = new Uint8Array(length);\n    for (let offset = 0; offset < length; offset += 65_536) {\n      crypto.getRandomValues(bytes.subarray(offset, offset + 65_536));\n    }\n    return bytes;\n  };\n  const uint32 = () => new DataView(randomBytes(4).buffer).getUint32(0);\n  const uint53 = () => (uint32() & 0x1f_ffff) * 2 ** 32 + uint32();\n\n  return createRandomSource({\n    float() {\n      return uint53() / 2 ** 53;\n    },\n    integer(maxExclusive: number) {\n      const range = 2 ** 53;\n      const upperLimit = range - (range % maxExclusive);\n      let value = uint53();\n      while (value >= upperLimit) value = uint53();\n      return value % maxExclusive;\n    },\n    bytes: randomBytes,\n  });\n}\n\n/**\n * Returns a canonical seed representation. Strings use UTF-8 exactly; finite\n * numbers use their JavaScript numeric representation, with -0 normalized to 0.\n */\nexport function normalizeSeed(seed: Seed): string {\n  if (typeof seed === \"string\") return `string:${seed}`;\n  if (typeof seed === \"number\" && Number.isFinite(seed)) {\n    return `number:${Object.is(seed, -0) ? \"0\" : String(seed)}`;\n  }\n  throw new ConstructaError({\n    kind: \"configuration\",\n    code: \"INVALID_SEED\",\n    path: [\"seed\"],\n    message: \"seed must be a string or finite number.\",\n  });\n}\n\n/** Creates an isolated deterministic random source for the current algorithm version. */\nexport function createSeededRandom(seed: Seed): RandomSource {\n  let state = hashSeed(normalizeSeed(seed));\n  const uint32 = () => {\n    state = (state + 0x6d2b_79f5) >>> 0;\n    let value = state;\n    value = Math.imul(value ^ (value >>> 15), value | 1);\n    value ^= value + Math.imul(value ^ (value >>> 7), value | 61);\n    return (value ^ (value >>> 14)) >>> 0;\n  };\n  const uint53 = () => (uint32() & 0x1f_ffff) * 2 ** 32 + uint32();\n\n  return createRandomSource({\n    float() {\n      return uint53() / 2 ** 53;\n    },\n    integer(maxExclusive: number) {\n      const range = 2 ** 53;\n      const upperLimit = range - (range % maxExclusive);\n      let value = uint53();\n      while (value >= upperLimit) value = uint53();\n      return value % maxExclusive;\n    },\n    bytes(length: number) {\n      const bytes = new Uint8Array(length);\n      for (let index = 0; index < length; index += 1) {\n        if (index % 4 === 0) {\n          const value = uint32();\n          bytes[index] = value & 0xff;\n          if (index + 1 < length) bytes[index + 1] = (value >>> 8) & 0xff;\n          if (index + 2 < length) bytes[index + 2] = (value >>> 16) & 0xff;\n          if (index + 3 < length) bytes[index + 3] = value >>> 24;\n        }\n      }\n      return bytes;\n    },\n  });\n}\n\n/** Metadata for reproducibility diagnostics. It intentionally contains no seed. */\nexport function getSeededRandomMetadata(): SeededRandomMetadata {\n  return SEEDED_RANDOM_METADATA;\n}\n\n/** Services supplied by the engine. Implementations must not use global randomness. */\nexport type GenerationContext = {\n  readonly random: RandomSource;\n  /** The definition path currently being generated. */\n  readonly path: ValidationPath;\n  /** Delegates a typed child definition to the engine. */\n  readonly executeChild: <Output>(\n    definition: GeneratorDefinition<Output>,\n    pathSegment: ValidationPathSegment,\n  ) => Output;\n  /**\n   * Read-only values from the object currently being generated. Values are\n   * available only after their field has completed.\n   */\n  readonly references: ReferenceResolver;\n  /** Creates an isolated scope for the fields of one composite object. */\n  readonly createObjectScope: () => ObjectGenerationScope;\n  /** Returns value dependencies declared by one direct child definition. */\n  readonly analyzeChildValueDependencies: (\n    definition: GeneratorDefinition,\n    pathSegment: ValidationPathSegment,\n  ) => readonly ValueDependency[];\n};\n\n/** A property path relative to the object containing a reference. */\nexport type ReferencePath = readonly string[];\n\n/** A parsed template fragment. Braces are escaped with `{{` and `}}`. */\nexport type TemplateToken =\n  | { readonly type: \"literal\"; readonly value: string }\n  | { readonly type: \"reference\"; readonly path: ReferencePath };\n\nexport type ParseTemplateTokensOptions = {\n  /** Definition-relative path reported for malformed template syntax. */\n  readonly path?: ValidationPath;\n};\n\n/**\n * Parses MVP template syntax without executing or resolving references.\n *\n * `{field}` addresses a sibling and `{field.nested}` addresses a value below\n * that sibling. `{{` and `}}` emit literal braces. Whitespace, empty path\n * segments, and brace characters inside a reference are unsupported.\n */\nexport function parseTemplateTokens(\n  source: string,\n  options: ParseTemplateTokensOptions = {},\n): readonly TemplateToken[] {\n  const path = options.path ?? [];\n  if (typeof source !== \"string\") {\n    throw templateTokenError(path, \"Template source must be a string.\");\n  }\n  assertContextPath(path);\n\n  const tokens: TemplateToken[] = [];\n  let literal = \"\";\n  const appendLiteral = (value: string) => {\n    literal += value;\n  };\n  const flushLiteral = () => {\n    if (literal.length === 0) return;\n    tokens.push(Object.freeze({ type: \"literal\", value: literal }));\n    literal = \"\";\n  };\n\n  for (let index = 0; index < source.length; index += 1) {\n    const character = source[index];\n    if (character === \"{\") {\n      if (source[index + 1] === \"{\") {\n        appendLiteral(\"{\");\n        index += 1;\n        continue;\n      }\n      const closingIndex = source.indexOf(\"}\", index + 1);\n      if (closingIndex === -1) {\n        throw templateTokenError(\n          path,\n          \"Template reference is missing a closing brace.\",\n        );\n      }\n      const reference = source.slice(index + 1, closingIndex);\n      const referencePath = parseReferencePath(reference, path);\n      flushLiteral();\n      tokens.push(Object.freeze({ type: \"reference\", path: referencePath }));\n      index = closingIndex;\n      continue;\n    }\n    if (character === \"}\") {\n      if (source[index + 1] === \"}\") {\n        appendLiteral(\"}\");\n        index += 1;\n        continue;\n      }\n      throw templateTokenError(\n        path,\n        \"Template contains an unmatched closing brace.\",\n      );\n    }\n    appendLiteral(character ?? \"\");\n  }\n  flushLiteral();\n  return Object.freeze(tokens);\n}\n\n/** Parses one dot-separated object-local reference path. */\nexport function parseReferencePath(\n  source: string,\n  path: ValidationPath = [],\n): ReferencePath {\n  if (typeof source !== \"string\" || source.length === 0) {\n    throw templateTokenError(path, \"Template reference must not be empty.\");\n  }\n  assertContextPath(path);\n  const segments = source.split(\".\");\n  if (\n    segments.some((segment) => segment.length === 0 || /[{}\\s]/u.test(segment))\n  ) {\n    throw templateTokenError(\n      path,\n      \"Template reference segments must be non-empty and cannot contain whitespace or braces.\",\n    );\n  }\n  return Object.freeze(segments);\n}\n\nfunction templateTokenError(\n  path: ValidationPath,\n  message: string,\n): ConstructaError {\n  return new ConstructaError({\n    kind: \"configuration\",\n    code: \"INVALID_TEMPLATE_TOKEN\",\n    path,\n    message,\n  });\n}\n\n/** A portable value dependency declared by a generator definition. */\nexport type ValueDependency = {\n  readonly path: ReferencePath;\n};\n\n/** Dependencies for a direct field in a composite definition. */\nexport type CompositeDependencyNode = {\n  readonly fieldPath: readonly [string];\n  readonly dependencies: readonly ValueDependency[];\n};\n\n/** Portable dependency data used to schedule one composite object. */\nexport type CompositeDependencyAnalysis = {\n  readonly nodes: readonly CompositeDependencyNode[];\n};\n\n/** The read-only capability supplied to generators that resolve references. */\nexport type ReferenceResolver = {\n  resolve: (path: ReferencePath) => unknown;\n};\n\n/** Executes and records completed fields within one isolated object scope. */\nexport type ObjectGenerationScope = {\n  executeChild: <Output>(\n    definition: GeneratorDefinition<Output>,\n    pathSegment: string,\n  ) => Output;\n};\n\nexport type GenerationContextOptions = {\n  readonly random: RandomSource;\n  readonly path?: ValidationPath;\n  readonly executeChild?: GenerationContext[\"executeChild\"];\n  readonly references?: ReferenceResolver;\n  readonly createObjectScope?: GenerationContext[\"createObjectScope\"];\n  readonly analyzeChildValueDependencies?: GenerationContext[\"analyzeChildValueDependencies\"];\n};\n\n/**\n * Creates the engine-owned capability view supplied to implementations.\n * Application code normally receives this through `generate`, rather than\n * constructing one directly.\n */\nexport function createGenerationContext(\n  options: GenerationContextOptions,\n): GenerationContext {\n  if (typeof options !== \"object\" || options === null) {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [],\n      \"Context options must be an object.\",\n    );\n  }\n  assertContextPath(options.path ?? []);\n  if (\n    typeof options.executeChild !== \"undefined\" &&\n    typeof options.executeChild !== \"function\"\n  ) {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [],\n      \"executeChild must be a function when present.\",\n    );\n  }\n\n  // This validates the Phase 012 source contract without drawing from it.\n  const random = validatedRandomSources.has(options.random)\n    ? options.random\n    : createRandomSource(options.random);\n  const path = Object.freeze([...(options.path ?? [])]);\n  const executeChild =\n    options.executeChild ??\n    ((definition, pathSegment) => {\n      assertGeneratorDefinition(definition, [...path, pathSegment]);\n      assertContextPathSegment(pathSegment);\n      throw new ConstructaError({\n        kind: \"execution\",\n        code: \"CHILD_EXECUTION_UNAVAILABLE\",\n        path: [...path, pathSegment],\n        message: \"Child execution is not available in this generation context.\",\n      });\n    });\n\n  const references = options.references ?? unavailableReferenceResolver(path);\n  if (\n    typeof references !== \"object\" ||\n    references === null ||\n    typeof references.resolve !== \"function\"\n  ) {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [],\n      \"references must provide a resolve function when present.\",\n    );\n  }\n  const createObjectScope =\n    options.createObjectScope ??\n    (() =>\n      Object.freeze({\n        executeChild<Output>(\n          definition: GeneratorDefinition<Output>,\n          pathSegment: string,\n        ): Output {\n          return executeChild(definition, pathSegment);\n        },\n      }));\n  if (typeof createObjectScope !== \"function\") {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [],\n      \"createObjectScope must be a function when present.\",\n    );\n  }\n  const analyzeChildValueDependencies =\n    options.analyzeChildValueDependencies ?? (() => []);\n  if (typeof analyzeChildValueDependencies !== \"function\") {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [],\n      \"analyzeChildValueDependencies must be a function when present.\",\n    );\n  }\n\n  return Object.freeze({\n    random,\n    path,\n    executeChild,\n    references: Object.freeze({ resolve: references.resolve }),\n    createObjectScope,\n    analyzeChildValueDependencies,\n  });\n}\n\n/** Freezes direct-field dependency declarations into portable analysis data. */\nexport function createCompositeDependencyAnalysis(\n  nodes: readonly CompositeDependencyNode[],\n): CompositeDependencyAnalysis {\n  if (!Array.isArray(nodes)) {\n    throw contextError(\n      \"INVALID_COMPOSITE_DEPENDENCIES\",\n      [],\n      \"Composite dependency nodes must be an array.\",\n    );\n  }\n  const names = new Set<string>();\n  const normalized = nodes.map((node, index) => {\n    if (!isCompositeDependencyNode(node) || names.has(node.fieldPath[0])) {\n      throw contextError(\n        \"INVALID_COMPOSITE_DEPENDENCIES\",\n        [\"nodes\", index],\n        \"Each composite dependency node must name one unique field.\",\n      );\n    }\n    names.add(node.fieldPath[0]);\n    return Object.freeze({\n      fieldPath: Object.freeze([...node.fieldPath]) as readonly [string],\n      dependencies: Object.freeze(\n        node.dependencies.map((dependency) =>\n          Object.freeze({ path: Object.freeze([...dependency.path]) }),\n        ),\n      ),\n    });\n  });\n  return Object.freeze({ nodes: Object.freeze(normalized) });\n}\n\n/**\n * Returns a deterministic execution order for direct object fields. A\n * dependency path may target a nested value below another direct field.\n */\nexport function scheduleCompositeDependencies(\n  analysis: CompositeDependencyAnalysis,\n): readonly string[] {\n  const nodes = analysis.nodes;\n  const byName = new Map(nodes.map((node) => [node.fieldPath[0], node]));\n  const remaining = new Map<string, Set<string>>();\n  const dependents = new Map<string, string[]>();\n\n  for (const node of nodes) {\n    const dependencies = new Set<string>();\n    for (const dependency of node.dependencies) {\n      const target = dependency.path[0];\n      if (target === undefined || !byName.has(target)) {\n        throw new ConstructaError({\n          kind: \"dependency\",\n          code: \"REFERENCE_NOT_FOUND\",\n          path: [...node.fieldPath],\n          message: \"A referenced object field could not be found.\",\n        });\n      }\n      dependencies.add(target);\n      const targets = dependents.get(target) ?? [];\n      targets.push(node.fieldPath[0]);\n      dependents.set(target, targets);\n    }\n    remaining.set(node.fieldPath[0], dependencies);\n  }\n\n  const ready = nodes\n    .filter((node) => (remaining.get(node.fieldPath[0])?.size ?? 0) === 0)\n    .map((node) => node.fieldPath[0]);\n  const ordered: string[] = [];\n  while (ready.length > 0) {\n    const field = ready.shift();\n    if (field === undefined) continue;\n    ordered.push(field);\n    for (const dependent of dependents.get(field) ?? []) {\n      const dependencies = remaining.get(dependent);\n      dependencies?.delete(field);\n      if (dependencies?.size === 0) ready.push(dependent);\n    }\n  }\n  if (ordered.length !== nodes.length) {\n    const field = nodes.find((node) => !ordered.includes(node.fieldPath[0]));\n    throw new ConstructaError({\n      kind: \"dependency\",\n      code: \"CIRCULAR_REFERENCE\",\n      path: field?.fieldPath ?? [],\n      message: \"Circular object value references were detected.\",\n    });\n  }\n  return Object.freeze(ordered);\n}\n\nexport type ParseLimits = {\n  readonly maxDepth?: number;\n  readonly maxIssues?: number;\n  readonly maxNodes?: number;\n};\n\nexport type ParseDefinitionOptions = {\n  readonly registry: Pick<\n    GeneratorRegistry | GeneratorRegistrySnapshot,\n    \"lookup\"\n  >;\n  readonly limits?: ParseLimits;\n};\n\nexport type ParseDocumentOptions = ParseDefinitionOptions;\n\nexport type DefinitionParseResult =\n  | { readonly success: true; readonly value: ParsedGeneratorDefinition }\n  | { readonly success: false; readonly issues: readonly ConstructaError[] };\n\nexport type DocumentParseResult =\n  | {\n      readonly success: true;\n      readonly value: import(\"constructa-schema\").GeneratorDocumentV1;\n    }\n  | { readonly success: false; readonly issues: readonly ConstructaError[] };\n\n/** Parses untrusted runtime definition data without executing generator code. */\nexport function parseDefinition(\n  value: unknown,\n  options: ParseDefinitionOptions,\n): ParsedGeneratorDefinition {\n  return parseDefinitionAtPath(value, [], options.registry, options.limits);\n}\n\nfunction parseDefinitionAtPath(\n  value: unknown,\n  path: ValidationPath,\n  registry: ParseDefinitionOptions[\"registry\"],\n  limits?: ParseLimits,\n): ParsedGeneratorDefinition {\n  const result = parseRuntimeDefinition(value, path, { registry, limits });\n  if (result.success) return result.value;\n  throw result.issues[0];\n}\n\nexport function safeParseDefinition(\n  value: unknown,\n  options: ParseDefinitionOptions,\n): DefinitionParseResult {\n  return parseRuntimeDefinition(value, [], options);\n}\n\n/** Parses a versioned document and its root definition through the same pipeline. */\nexport function parseDocument(\n  value: unknown,\n  options: ParseDocumentOptions,\n): import(\"constructa-schema\").GeneratorDocumentV1 {\n  const result = safeParseDocument(value, options);\n  if (result.success) return result.value;\n  throw result.issues[0];\n}\n\nexport function safeParseDocument(\n  value: unknown,\n  options: ParseDocumentOptions,\n): DocumentParseResult {\n  const limits = resolveParseLimits(options);\n  const documentIssues = validationIssuesToErrors(\n    validateDocumentSafely(value),\n    [],\n    limits.maxIssues,\n  );\n  if (documentIssues.length > 0)\n    return { success: false, issues: documentIssues };\n\n  // Schema parsing is now safe because validation has rejected hostile shapes.\n  const document = parseSchemaDocument(value);\n  const definition = parseRuntimeDefinition(\n    document.definition,\n    [\"definition\"],\n    options,\n  );\n  return definition.success\n    ? { success: true, value: document }\n    : { success: false, issues: definition.issues };\n}\n\nexport type GeneratorDependency = {\n  readonly typeId: string;\n  readonly path: ValidationPath;\n};\n\ndeclare const parsedGeneratorDefinition: unique symbol;\n\n/** A runtime-validated definition accepted by an executor without revalidation. */\nexport type ParsedGeneratorDefinition = GeneratorDefinition & {\n  readonly [parsedGeneratorDefinition]: true;\n};\n\nconst parsedDefinitions = new WeakSet<object>();\n\nexport type GeneratorImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n> = {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: (\n    definition: unknown,\n  ) => readonly ValidationIssue[];\n  readonly analyzeDependencies?: (\n    definition: Definition,\n  ) => readonly GeneratorDependency[];\n  /** Declares object-local value references used by this definition. */\n  readonly analyzeValueDependencies?: (\n    definition: Definition,\n  ) => readonly ValueDependency[];\n  readonly generate: (input: {\n    readonly definition: Definition;\n    readonly context: GenerationContext;\n  }) => Output;\n};\n\nexport type RegisteredGenerator = {\n  readonly type: string;\n  readonly version: number;\n};\n\nexport type GeneratorRegistrySnapshot = {\n  readonly generators: readonly RegisteredGenerator[];\n  readonly lookup: (\n    type: string,\n    path?: ValidationPath,\n  ) => GeneratorImplementation<GeneratorDefinition, unknown>;\n};\n\nexport type GeneratorRegistry = {\n  register: <Definition extends GeneratorDefinition<Output>, Output>(\n    implementation: GeneratorImplementation<Definition, Output>,\n  ) => void;\n  replace: <Definition extends GeneratorDefinition<Output>, Output>(\n    implementation: GeneratorImplementation<Definition, Output>,\n  ) => void;\n  lookup: (\n    type: string,\n    path?: ValidationPath,\n  ) => GeneratorImplementation<GeneratorDefinition, unknown>;\n  snapshot: () => GeneratorRegistrySnapshot;\n};\n\nconst RESERVED_GENERATOR_TYPE_IDS = new Set([\n  \"__proto__\",\n  \"constructor\",\n  \"prototype\",\n]);\n\n/** Creates advanced registry infrastructure. Normal factories do not require it. */\nexport function createRegistry(): GeneratorRegistry {\n  const implementations = new Map<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >();\n\n  return {\n    register(implementation) {\n      assertRegistryImplementation(implementation);\n      if (implementations.has(implementation.type)) {\n        throw registryError(\n          \"DUPLICATE_GENERATOR\",\n          [\"type\"],\n          `A generator with type \"${implementation.type}\" is already registered.`,\n        );\n      }\n      implementations.set(\n        implementation.type,\n        freezeImplementation(\n          implementation,\n        ) as unknown as GeneratorImplementation<GeneratorDefinition, unknown>,\n      );\n    },\n    replace(implementation) {\n      assertRegistryImplementation(implementation);\n      if (!implementations.has(implementation.type)) {\n        throw registryError(\n          \"UNKNOWN_GENERATOR\",\n          [\"type\"],\n          `No generator with type \"${implementation.type}\" is registered.`,\n        );\n      }\n      implementations.set(\n        implementation.type,\n        freezeImplementation(\n          implementation,\n        ) as unknown as GeneratorImplementation<GeneratorDefinition, unknown>,\n      );\n    },\n    lookup(type, path = []) {\n      return lookupImplementation(implementations, type, path);\n    },\n    snapshot() {\n      return createRegistrySnapshot(implementations);\n    },\n  };\n}\n\n/**\n * Creates an advanced single-value executor over an immutable registry\n * snapshot. Normal applications will receive this behavior through the SDK.\n */\nexport function createExecutor(\n  registry: GeneratorRegistry | GeneratorRegistrySnapshot,\n): Executor {\n  const snapshot = createExecutionSnapshot(registry);\n\n  return Object.freeze({\n    generate<Definition extends GeneratorDefinition>(\n      definition: Definition,\n      options?: ExecutionOptions,\n    ): import(\"constructa-schema\").Infer<Definition> {\n      const execution = resolveExecutionOptions(options);\n      const parsed = parsedDefinitions.has(definition)\n        ? definition\n        : parseDefinition(definition, { registry: snapshot });\n      return executeParsedDefinition(parsed, [], 0, {\n        snapshot,\n        ...execution,\n      }) as import(\"constructa-schema\").Infer<Definition>;\n    },\n  });\n}\n\ntype ExecutionState = {\n  readonly snapshot: GeneratorRegistrySnapshot;\n  readonly random: RandomSource;\n  readonly maxDepth: number;\n};\n\nfunction executeParsedDefinition(\n  definition: GeneratorDefinition,\n  path: ValidationPath,\n  depth: number,\n  state: ExecutionState,\n  references: ReferenceResolver = unavailableReferenceResolver(path),\n): unknown {\n  const implementation = state.snapshot.lookup(definition.type, path);\n  analyzeGeneratorDependencies(\n    implementation,\n    definition,\n    state.snapshot,\n    path,\n  );\n  const context = createGenerationContext({\n    random: state.random,\n    path,\n    references,\n    createObjectScope() {\n      return createObjectGenerationScope(\n        path,\n        (child, pathSegment, scopeReferences) => {\n          assertChildPathSegment(pathSegment, path);\n          const childPath = [...path, pathSegment];\n          if (depth >= state.maxDepth) {\n            throw new ConstructaError({\n              kind: \"execution\",\n              code: \"MAX_EXECUTION_DEPTH\",\n              path: childPath,\n              message: \"Child execution exceeds the configured maximum depth.\",\n            });\n          }\n          const parsed = parseDefinitionAtPath(\n            child,\n            childPath,\n            state.snapshot,\n          );\n          return executeParsedDefinition(\n            parsed,\n            childPath,\n            depth + 1,\n            state,\n            scopeReferences,\n          );\n        },\n      );\n    },\n    analyzeChildValueDependencies(child, pathSegment) {\n      assertChildPathSegment(pathSegment, path);\n      const childPath = [...path, pathSegment];\n      const parsed = parseDefinitionAtPath(child, childPath, state.snapshot);\n      const childImplementation = state.snapshot.lookup(parsed.type, childPath);\n      return analyzeValueDependencies(childImplementation, parsed, childPath);\n    },\n    executeChild<Output>(\n      child: GeneratorDefinition<Output>,\n      pathSegment: ValidationPathSegment,\n    ): Output {\n      assertChildPathSegment(pathSegment, path);\n      const childPath = [...path, pathSegment];\n      if (depth >= state.maxDepth) {\n        throw new ConstructaError({\n          kind: \"execution\",\n          code: \"MAX_EXECUTION_DEPTH\",\n          path: childPath,\n          message: \"Child execution exceeds the configured maximum depth.\",\n        });\n      }\n      const parsed = parseDefinitionAtPath(child, childPath, state.snapshot);\n      return executeParsedDefinition(\n        parsed,\n        childPath,\n        depth + 1,\n        state,\n        references,\n      ) as Output;\n    },\n  });\n  return invokeValidatedGeneratorImplementation(\n    implementation,\n    definition,\n    context,\n    path,\n  );\n}\n\nfunction createObjectGenerationScope(\n  path: ValidationPath,\n  executeChild: (\n    definition: GeneratorDefinition,\n    pathSegment: string,\n    references: ReferenceResolver,\n  ) => unknown,\n): ObjectGenerationScope {\n  const completed = new Map<string, unknown>();\n  const resolver: ReferenceResolver = Object.freeze({\n    resolve(referencePath: ReferencePath): unknown {\n      assertReferencePath(referencePath, path);\n      const key = referencePathKey(referencePath);\n      if (!completed.has(key)) {\n        throw new ConstructaError({\n          kind: \"dependency\",\n          code: \"REFERENCE_NOT_AVAILABLE\",\n          path,\n          message: \"The referenced object value has not completed.\",\n        });\n      }\n      return completed.get(key);\n    },\n  });\n  return Object.freeze({\n    executeChild<Output>(\n      definition: GeneratorDefinition<Output>,\n      pathSegment: string,\n    ): Output {\n      const value = executeChild(definition, pathSegment, resolver) as Output;\n      recordCompletedValue(completed, [pathSegment], value);\n      return value;\n    },\n  });\n}\n\nfunction recordCompletedValue(\n  completed: Map<string, unknown>,\n  referencePath: readonly string[],\n  value: unknown,\n  visited = new WeakSet<object>(),\n): void {\n  completed.set(referencePathKey(referencePath), value);\n  if (typeof value !== \"object\" || value === null || visited.has(value)) return;\n  visited.add(value);\n  for (const [key, child] of Object.entries(value)) {\n    recordCompletedValue(completed, [...referencePath, key], child, visited);\n  }\n}\n\nfunction unavailableReferenceResolver(path: ValidationPath): ReferenceResolver {\n  return Object.freeze({\n    resolve(referencePath: ReferencePath): never {\n      assertReferencePath(referencePath, path);\n      throw new ConstructaError({\n        kind: \"dependency\",\n        code: \"REFERENCE_RESOLUTION_UNAVAILABLE\",\n        path,\n        message:\n          \"Reference resolution is available only inside an object field.\",\n      });\n    },\n  });\n}\n\nfunction assertReferencePath(\n  referencePath: ReferencePath,\n  contextPath: ValidationPath,\n): void {\n  if (\n    !Array.isArray(referencePath) ||\n    referencePath.length === 0 ||\n    referencePath.some(\n      (segment) => typeof segment !== \"string\" || segment.length === 0,\n    )\n  ) {\n    throw contextError(\n      \"INVALID_REFERENCE_PATH\",\n      contextPath,\n      \"Reference paths must contain one or more non-empty string segments.\",\n    );\n  }\n}\n\nfunction referencePathKey(path: readonly string[]): string {\n  return JSON.stringify(path);\n}\n\nfunction createExecutionSnapshot(\n  registry: GeneratorRegistry | GeneratorRegistrySnapshot,\n): GeneratorRegistrySnapshot {\n  if (typeof registry !== \"object\" || registry === null) {\n    throw contextError(\n      \"INVALID_EXECUTOR_REGISTRY\",\n      [\"registry\"],\n      \"Executor requires a generator registry.\",\n    );\n  }\n  if (typeof (registry as GeneratorRegistry).snapshot === \"function\") {\n    return (registry as GeneratorRegistry).snapshot();\n  }\n  if (typeof (registry as GeneratorRegistrySnapshot).lookup === \"function\") {\n    return registry as GeneratorRegistrySnapshot;\n  }\n  throw contextError(\n    \"INVALID_EXECUTOR_REGISTRY\",\n    [\"registry\"],\n    \"Executor requires a generator registry.\",\n  );\n}\n\nfunction resolveExecutionOptions(\n  options: ExecutionOptions | undefined,\n): Omit<ExecutionState, \"snapshot\"> {\n  if (options === undefined) {\n    return { random: createDefaultRandomSource(), maxDepth: 64 };\n  }\n  if (typeof options !== \"object\" || options === null) {\n    throw contextError(\n      \"INVALID_EXECUTION_OPTIONS\",\n      [],\n      \"Execution options must be an object.\",\n    );\n  }\n  if (options.seed !== undefined && options.random !== undefined) {\n    throw contextError(\n      \"CONFLICTING_RANDOM_OPTIONS\",\n      [\"seed\"],\n      \"seed and random cannot be supplied together.\",\n    );\n  }\n  const maxDepth = options.maxDepth ?? 64;\n  if (!Number.isSafeInteger(maxDepth) || maxDepth < 0) {\n    throw contextError(\n      \"INVALID_EXECUTION_OPTIONS\",\n      [\"maxDepth\"],\n      \"maxDepth must be a non-negative safe integer.\",\n    );\n  }\n  const random =\n    options.seed !== undefined\n      ? createSeededRandom(options.seed)\n      : options.random !== undefined\n        ? createRandomSource(options.random)\n        : createDefaultRandomSource();\n  return { random, maxDepth };\n}\n\nfunction analyzeGeneratorDependencies(\n  implementation: GeneratorImplementation<GeneratorDefinition, unknown>,\n  definition: GeneratorDefinition,\n  registry: GeneratorRegistrySnapshot,\n  path: ValidationPath,\n): void {\n  if (implementation.analyzeDependencies === undefined) return;\n  let dependencies: readonly GeneratorDependency[];\n  try {\n    dependencies = implementation.analyzeDependencies(definition);\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"dependency\",\n      code: \"DEPENDENCY_ANALYSIS_FAILED\",\n      path,\n      message: \"Generator dependency analysis failed.\",\n    });\n  }\n  if (!Array.isArray(dependencies)) {\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"DEPENDENCY_ANALYSIS_FAILED\",\n      path,\n      message: \"Generator dependency analysis returned an invalid result.\",\n    });\n  }\n  for (const dependency of dependencies) {\n    if (!isGeneratorDependency(dependency)) {\n      throw new ConstructaError({\n        kind: \"system\",\n        code: \"DEPENDENCY_ANALYSIS_FAILED\",\n        path,\n        message:\n          \"Generator dependency analysis returned an invalid dependency.\",\n      });\n    }\n    registry.lookup(dependency.typeId, [...path, ...dependency.path]);\n  }\n}\n\nfunction analyzeValueDependencies(\n  implementation: GeneratorImplementation<GeneratorDefinition, unknown>,\n  definition: GeneratorDefinition,\n  path: ValidationPath,\n): readonly ValueDependency[] {\n  if (implementation.analyzeValueDependencies === undefined) return [];\n  let dependencies: readonly ValueDependency[];\n  try {\n    dependencies = implementation.analyzeValueDependencies(definition);\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"dependency\",\n      code: \"DEPENDENCY_ANALYSIS_FAILED\",\n      path,\n      message: \"Value dependency analysis failed.\",\n    });\n  }\n  if (!Array.isArray(dependencies) || !dependencies.every(isValueDependency)) {\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"DEPENDENCY_ANALYSIS_FAILED\",\n      path,\n      message: \"Value dependency analysis returned an invalid result.\",\n    });\n  }\n  return Object.freeze(\n    dependencies.map((dependency) =>\n      Object.freeze({ path: Object.freeze([...dependency.path]) }),\n    ),\n  );\n}\n\nfunction isGeneratorDependency(value: unknown): value is GeneratorDependency {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as GeneratorDependency).typeId === \"string\" &&\n    Array.isArray((value as GeneratorDependency).path) &&\n    (value as GeneratorDependency).path.every(\n      (segment) => typeof segment === \"string\" || Number.isSafeInteger(segment),\n    )\n  );\n}\n\nfunction isValueDependency(value: unknown): value is ValueDependency {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    Array.isArray((value as ValueDependency).path) &&\n    (value as ValueDependency).path.length > 0 &&\n    (value as ValueDependency).path.every(\n      (segment) => typeof segment === \"string\" && segment.length > 0,\n    )\n  );\n}\n\nfunction isCompositeDependencyNode(\n  value: unknown,\n): value is CompositeDependencyNode {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    Array.isArray((value as CompositeDependencyNode).fieldPath) &&\n    (value as CompositeDependencyNode).fieldPath.length === 1 &&\n    typeof (value as CompositeDependencyNode).fieldPath[0] === \"string\" &&\n    Array.isArray((value as CompositeDependencyNode).dependencies) &&\n    (value as CompositeDependencyNode).dependencies.every(isValueDependency)\n  );\n}\n\nfunction invokeValidatedGeneratorImplementation(\n  implementation: GeneratorImplementation<GeneratorDefinition, unknown>,\n  definition: GeneratorDefinition,\n  context: GenerationContext,\n  path: ValidationPath,\n): unknown {\n  try {\n    return implementation.generate({ definition, context });\n  } catch (cause) {\n    if (cause instanceof ConstructaError) {\n      return throwWithExecutionPath(cause, path);\n    }\n    throw normalizeConstructaError(cause, {\n      kind: \"execution\",\n      code: \"EXECUTION_FAILED\",\n      path,\n      message: \"Generator execution failed.\",\n    });\n  }\n}\n\nfunction throwWithExecutionPath(\n  error: ConstructaError,\n  path: ValidationPath,\n): never {\n  if (path.length === 0 || startsWithPath(error.path, path)) throw error;\n  throw new ConstructaError({\n    kind: error.kind,\n    code: error.code,\n    path: [...path, ...error.path],\n    message: error.message,\n    details: error.details,\n  });\n}\n\nfunction startsWithPath(path: ValidationPath, prefix: ValidationPath): boolean {\n  return prefix.every((segment, index) => path[index] === segment);\n}\n\n/**\n * Defines a trusted, developer-authored generator implementation. This API has\n * no dependency on a particular validation library.\n */\nexport function defineGenerator<\n  const Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n): GeneratorImplementation<Definition, Output> {\n  assertGeneratorImplementation(implementation);\n  return implementation;\n}\n\n/** Builds a portable definition while preserving literal fields and output inference. */\nexport function createGeneratorDefinition<\n  Output,\n  const Definition extends GeneratorDefinition<Output>,\n>(definition: Definition): Definition {\n  assertGeneratorDefinition(definition);\n  return definition;\n}\n\n/**\n * Invokes one validated implementation. Registry lookup and dispatch are added\n * later; this function keeps validation and execution failure normalization in\n * the same shared contract today.\n */\nexport function invokeGeneratorImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n  input: {\n    readonly definition: Definition;\n    readonly context: GenerationContext;\n    readonly path?: ValidationPath;\n  },\n): Output {\n  const path = input.path ?? [];\n  let issues: readonly ValidationIssue[];\n\n  try {\n    issues = implementation.validateDefinition(input.definition);\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"configuration\",\n      code: \"INVALID_CONFIGURATION\",\n      path,\n      message: \"Generator definition validation failed.\",\n    });\n  }\n\n  if (issues.length > 0) {\n    const [issue] = issues;\n    if (issue !== undefined) {\n      throw new ConstructaError({\n        kind: \"configuration\",\n        code: errorCodeForValidationIssue(issue.code),\n        path: [...path, ...issue.path],\n        message: issue.message,\n        details: { issueCode: issue.code },\n      });\n    }\n\n    throw new ConstructaError({\n      kind: \"system\",\n      code: \"EXECUTION_FAILED\",\n      path,\n      message: \"Generator validation returned an invalid result.\",\n    });\n  }\n\n  try {\n    return implementation.generate({\n      definition: input.definition,\n      context: input.context,\n    });\n  } catch (cause) {\n    throw normalizeConstructaError(cause, {\n      kind: \"execution\",\n      code: \"EXECUTION_FAILED\",\n      path,\n      message: \"Generator execution failed.\",\n    });\n  }\n}\n\nconst DEFAULT_PARSE_LIMITS = Object.freeze({\n  maxDepth: 64,\n  maxIssues: 100,\n  maxNodes: 10_000,\n});\n\ntype ResolvedParseLimits = {\n  readonly maxDepth: number;\n  readonly maxIssues: number;\n  readonly maxNodes: number;\n};\n\nfunction parseRuntimeDefinition(\n  value: unknown,\n  path: ValidationPath,\n  options: ParseDefinitionOptions,\n): DefinitionParseResult {\n  const limits = resolveParseLimits(options);\n  const schemaIssues = validationIssuesToErrors(\n    validateDefinitionSafely(value, path),\n    path,\n    limits.maxIssues,\n  );\n  if (schemaIssues.length > 0) return { success: false, issues: schemaIssues };\n\n  const issues: ConstructaError[] = [];\n  const visited = new Set<object>();\n  visitRuntimeDefinition(\n    value as GeneratorDefinition,\n    path,\n    0,\n    options.registry,\n    limits,\n    visited,\n    issues,\n  );\n  return issues.length === 0\n    ? {\n        success: true,\n        value: markParsedDefinitions(visited, value as GeneratorDefinition),\n      }\n    : { success: false, issues: Object.freeze(issues) };\n}\n\nfunction markParsedDefinitions(\n  definitions: ReadonlySet<object>,\n  definition: GeneratorDefinition,\n): ParsedGeneratorDefinition {\n  for (const parsed of definitions) parsedDefinitions.add(parsed);\n  return definition as ParsedGeneratorDefinition;\n}\n\nfunction visitRuntimeDefinition(\n  definition: GeneratorDefinition,\n  path: ValidationPath,\n  depth: number,\n  registry: ParseDefinitionOptions[\"registry\"],\n  limits: ResolvedParseLimits,\n  visited: Set<object>,\n  issues: ConstructaError[],\n): void {\n  if (issues.length >= limits.maxIssues) return;\n  if (depth > limits.maxDepth) {\n    addParseIssue(\n      issues,\n      limits,\n      \"PARSE_DEPTH_LIMIT\",\n      path,\n      \"Generator definition exceeds the maximum nesting depth.\",\n    );\n    return;\n  }\n  if (visited.size >= limits.maxNodes) {\n    addParseIssue(\n      issues,\n      limits,\n      \"PARSE_NODE_LIMIT\",\n      path,\n      \"Generator definition exceeds the maximum node count.\",\n    );\n    return;\n  }\n  visited.add(definition);\n\n  let implementation: GeneratorImplementation<GeneratorDefinition, unknown>;\n  try {\n    implementation = registry.lookup(definition.type, path);\n  } catch (cause) {\n    const error = normalizeConstructaError(cause, {\n      kind: \"dependency\",\n      code: \"UNKNOWN_GENERATOR\",\n      path: [...path, \"type\"],\n      message: \"Generator type could not be resolved.\",\n    });\n    addExistingParseIssue(issues, limits, error);\n    return;\n  }\n\n  let validationIssues: readonly ValidationIssue[];\n  try {\n    validationIssues = implementation.validateDefinition(definition);\n  } catch (cause) {\n    addExistingParseIssue(\n      issues,\n      limits,\n      normalizeConstructaError(cause, {\n        kind: \"configuration\",\n        code: \"INVALID_CONFIGURATION\",\n        path,\n        message: \"Generator definition validation failed.\",\n      }),\n    );\n    return;\n  }\n  if (!Array.isArray(validationIssues)) {\n    addParseIssue(\n      issues,\n      limits,\n      \"INVALID_CONFIGURATION\",\n      path,\n      \"Generator definition validation returned an invalid result.\",\n      \"system\",\n    );\n    return;\n  }\n  for (const issue of validationIssues) {\n    if (!isValidationIssue(issue)) {\n      addParseIssue(\n        issues,\n        limits,\n        \"INVALID_CONFIGURATION\",\n        path,\n        \"Generator definition validation returned an invalid issue.\",\n        \"system\",\n      );\n      return;\n    }\n    addParseIssue(\n      issues,\n      limits,\n      errorCodeForValidationIssue(issue.code),\n      [...path, ...issue.path],\n      issue.message,\n    );\n  }\n\n  // Configurations are portable JSON. Every embedded object with a generator\n  // discriminator is another definition and must pass the same pipeline.\n  for (const [key, child] of Object.entries(definition)) {\n    if (key !== \"type\")\n      visitEmbeddedDefinitions(\n        child,\n        [...path, key],\n        depth + 1,\n        registry,\n        limits,\n        visited,\n        issues,\n      );\n    if (issues.length >= limits.maxIssues) return;\n  }\n}\n\nfunction visitEmbeddedDefinitions(\n  value: unknown,\n  path: ValidationPath,\n  depth: number,\n  registry: ParseDefinitionOptions[\"registry\"],\n  limits: ResolvedParseLimits,\n  visited: Set<object>,\n  issues: ConstructaError[],\n): void {\n  if (\n    issues.length >= limits.maxIssues ||\n    value === null ||\n    typeof value !== \"object\"\n  )\n    return;\n  if (Array.isArray(value)) {\n    for (let index = 0; index < value.length; index += 1) {\n      visitEmbeddedDefinitions(\n        value[index],\n        [...path, index],\n        depth,\n        registry,\n        limits,\n        visited,\n        issues,\n      );\n      if (issues.length >= limits.maxIssues) return;\n    }\n    return;\n  }\n  if (Object.hasOwn(value, \"type\")) {\n    visitRuntimeDefinition(\n      value as GeneratorDefinition,\n      path,\n      depth,\n      registry,\n      limits,\n      visited,\n      issues,\n    );\n    return;\n  }\n  for (const [key, child] of Object.entries(value)) {\n    visitEmbeddedDefinitions(\n      child,\n      [...path, key],\n      depth,\n      registry,\n      limits,\n      visited,\n      issues,\n    );\n    if (issues.length >= limits.maxIssues) return;\n  }\n}\n\nfunction resolveParseLimits(\n  options: ParseDefinitionOptions,\n): ResolvedParseLimits {\n  if (\n    typeof options !== \"object\" ||\n    options === null ||\n    typeof options.registry !== \"object\" ||\n    options.registry === null ||\n    typeof options.registry.lookup !== \"function\"\n  ) {\n    throw contextError(\n      \"INVALID_PARSE_OPTIONS\",\n      [],\n      \"Parsing requires a registry with a lookup function.\",\n    );\n  }\n  const supplied = options.limits ?? {};\n  const resolved = {\n    maxDepth: supplied.maxDepth ?? DEFAULT_PARSE_LIMITS.maxDepth,\n    maxIssues: supplied.maxIssues ?? DEFAULT_PARSE_LIMITS.maxIssues,\n    maxNodes: supplied.maxNodes ?? DEFAULT_PARSE_LIMITS.maxNodes,\n  };\n  for (const [name, value] of Object.entries(resolved)) {\n    if (!Number.isSafeInteger(value) || value < 1) {\n      throw contextError(\n        \"INVALID_PARSE_LIMITS\",\n        [\"limits\", name],\n        `${name} must be a positive safe integer.`,\n      );\n    }\n  }\n  return resolved;\n}\n\nfunction validateDefinitionSafely(\n  value: unknown,\n  path: ValidationPath,\n): readonly ValidationIssue[] {\n  try {\n    return validateGeneratorDefinition(value, path);\n  } catch (_cause) {\n    return [\n      {\n        code: \"invalid_json_value\",\n        path,\n        message: \"Definition could not be safely inspected.\",\n      },\n    ];\n  }\n}\n\nfunction validateDocumentSafely(value: unknown): readonly ValidationIssue[] {\n  try {\n    return validateDocument(value);\n  } catch {\n    return [\n      {\n        code: \"invalid_json_value\",\n        path: [],\n        message: \"Document could not be safely inspected.\",\n      },\n    ];\n  }\n}\n\nfunction validationIssuesToErrors(\n  issues: readonly ValidationIssue[],\n  fallbackPath: ValidationPath,\n  maxIssues = Number.POSITIVE_INFINITY,\n): ConstructaError[] {\n  return issues.slice(0, maxIssues).map(\n    (issue) =>\n      new ConstructaError({\n        kind: \"configuration\",\n        code: isValidationIssue(issue)\n          ? errorCodeForValidationIssue(issue.code)\n          : \"INVALID_CONFIGURATION\",\n        path: isValidationIssue(issue) ? issue.path : fallbackPath,\n        message: isValidationIssue(issue)\n          ? issue.message\n          : \"Validation returned an invalid issue.\",\n        details: isValidationIssue(issue)\n          ? { issueCode: issue.code }\n          : undefined,\n      }),\n  );\n}\n\nfunction errorCodeForValidationIssue(code: string): Uppercase<string> {\n  const reservedCodes: Record<string, Uppercase<string>> = {\n    empty_choice: \"EMPTY_CHOICE\",\n    invalid_length: \"INVALID_LENGTH\",\n    invalid_range: \"INVALID_RANGE\",\n  };\n  return reservedCodes[code] ?? \"INVALID_CONFIGURATION\";\n}\n\nfunction isValidationIssue(value: unknown): value is ValidationIssue {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as ValidationIssue).code === \"string\" &&\n    typeof (value as ValidationIssue).message === \"string\" &&\n    Array.isArray((value as ValidationIssue).path)\n  );\n}\n\nfunction addParseIssue(\n  issues: ConstructaError[],\n  limits: ResolvedParseLimits,\n  code: string,\n  path: ValidationPath,\n  message: string,\n  kind: \"configuration\" | \"system\" = \"configuration\",\n): void {\n  if (issues.length < limits.maxIssues)\n    issues.push(\n      new ConstructaError({\n        kind,\n        code: code as Uppercase<string>,\n        path,\n        message,\n      }),\n    );\n}\n\nfunction addExistingParseIssue(\n  issues: ConstructaError[],\n  limits: ResolvedParseLimits,\n  error: ConstructaError,\n): void {\n  if (issues.length < limits.maxIssues) issues.push(error);\n}\n\nfunction assertGeneratorImplementation(implementation: {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: unknown;\n  readonly analyzeDependencies?: unknown;\n  readonly generate: unknown;\n}): void {\n  if (!isStableTypeId(implementation.type)) {\n    throw new TypeError(\"generator type must be a stable lowercase identifier\");\n  }\n  if (\n    !Number.isSafeInteger(implementation.version) ||\n    implementation.version < 1\n  ) {\n    throw new TypeError(\"generator version must be a positive safe integer\");\n  }\n  if (typeof implementation.validateDefinition !== \"function\") {\n    throw new TypeError(\"validateDefinition must be a function\");\n  }\n  if (typeof implementation.generate !== \"function\") {\n    throw new TypeError(\"generate must be a function\");\n  }\n  if (\n    implementation.analyzeDependencies !== undefined &&\n    typeof implementation.analyzeDependencies !== \"function\"\n  ) {\n    throw new TypeError(\"analyzeDependencies must be a function when present\");\n  }\n}\n\nfunction assertRegistryImplementation(implementation: {\n  readonly type: string;\n  readonly version: number;\n  readonly validateDefinition: unknown;\n  readonly analyzeDependencies?: unknown;\n  readonly generate: unknown;\n}): void {\n  try {\n    assertGeneratorImplementation(implementation);\n  } catch {\n    throw registryError(\n      \"INVALID_CONFIGURATION\",\n      [\"implementation\"],\n      \"Generator implementation is invalid.\",\n    );\n  }\n  if (RESERVED_GENERATOR_TYPE_IDS.has(implementation.type)) {\n    throw registryError(\n      \"INVALID_CONFIGURATION\",\n      [\"type\"],\n      `Generator type \"${implementation.type}\" is reserved.`,\n    );\n  }\n}\n\nfunction freezeImplementation<\n  Definition extends GeneratorDefinition<Output>,\n  Output,\n>(\n  implementation: GeneratorImplementation<Definition, Output>,\n): GeneratorImplementation<Definition, Output> {\n  return Object.freeze({ ...implementation });\n}\n\nfunction createRegistrySnapshot(\n  implementations: ReadonlyMap<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >,\n): GeneratorRegistrySnapshot {\n  const snapshotImplementations = new Map(implementations);\n  const generators = [...snapshotImplementations.values()]\n    .map(({ type, version }) => Object.freeze({ type, version }))\n    .sort((left, right) => left.type.localeCompare(right.type));\n\n  return Object.freeze({\n    generators: Object.freeze(generators),\n    lookup(type: string, path: ValidationPath = []) {\n      return lookupImplementation(snapshotImplementations, type, path);\n    },\n  });\n}\n\nfunction lookupImplementation(\n  implementations: ReadonlyMap<\n    string,\n    GeneratorImplementation<GeneratorDefinition, unknown>\n  >,\n  type: string,\n  path: ValidationPath,\n): GeneratorImplementation<GeneratorDefinition, unknown> {\n  const implementation = implementations.get(type);\n  if (implementation !== undefined) return implementation;\n\n  const registeredTypes = [...implementations.keys()].sort((left, right) =>\n    left.localeCompare(right),\n  );\n  throw new ConstructaError({\n    kind: \"dependency\",\n    code: \"UNKNOWN_GENERATOR\",\n    path: [...path, \"type\"],\n    message: `No generator with type \"${type}\" is registered.`,\n    details: { registeredTypes },\n  });\n}\n\nfunction registryError(\n  code: \"DUPLICATE_GENERATOR\" | \"INVALID_CONFIGURATION\" | \"UNKNOWN_GENERATOR\",\n  path: ValidationPath,\n  message: string,\n): ConstructaError {\n  return new ConstructaError({ kind: \"configuration\", code, path, message });\n}\n\nfunction assertRandomSourceAdapter(adapter: RandomSourceAdapter): void {\n  if (\n    typeof adapter !== \"object\" ||\n    adapter === null ||\n    typeof adapter.float !== \"function\" ||\n    typeof adapter.integer !== \"function\" ||\n    typeof adapter.bytes !== \"function\"\n  ) {\n    throw invalidRandomSource(\n      \"A random source must provide float(), integer(), and bytes() methods.\",\n    );\n  }\n}\n\nfunction assertRandomLength(value: number, name: string): void {\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw invalidRandomSource(`${name} must be a positive safe integer.`);\n  }\n}\n\nfunction assertByteLength(length: number): void {\n  if (!Number.isSafeInteger(length) || length < 0) {\n    throw invalidRandomSource(\"length must be a non-negative safe integer.\");\n  }\n}\n\nfunction invalidRandomSource(message: string): ConstructaError {\n  return new ConstructaError({\n    kind: \"system\",\n    code: \"INVALID_RANDOM_SOURCE\",\n    path: [\"random\"],\n    message,\n  });\n}\n\nfunction assertContextPath(path: ValidationPath): void {\n  for (const segment of path) assertContextPathSegment(segment);\n}\n\nfunction assertContextPathSegment(\n  segment: unknown,\n): asserts segment is ValidationPathSegment {\n  if (\n    typeof segment !== \"string\" &&\n    (!Number.isSafeInteger(segment) || typeof segment !== \"number\")\n  ) {\n    throw contextError(\n      \"INVALID_GENERATION_CONTEXT\",\n      [\"path\"],\n      \"Context path segments must be strings or safe integers.\",\n    );\n  }\n}\n\nfunction assertChildPathSegment(\n  segment: unknown,\n  path: ValidationPath,\n): asserts segment is ValidationPathSegment {\n  if (\n    typeof segment !== \"string\" &&\n    (typeof segment !== \"number\" || !Number.isSafeInteger(segment))\n  ) {\n    throw contextError(\n      \"INVALID_CHILD_PATH\",\n      path,\n      \"Child path segments must be strings or safe integers.\",\n    );\n  }\n}\n\nfunction contextError(\n  code: string,\n  path: ValidationPath,\n  message: string,\n): ConstructaError {\n  return new ConstructaError({\n    kind: \"configuration\",\n    code: code as Uppercase<string>,\n    path,\n    message,\n  });\n}\n\nfunction hashSeed(seed: string): number {\n  let hash = 0x811c_9dc5;\n  for (const byte of new TextEncoder().encode(seed)) {\n    hash = Math.imul(hash ^ byte, 0x0100_0193) >>> 0;\n  }\n  return hash;\n}\n\nfunction isStableTypeId(value: string): boolean {\n  return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u.test(value);\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "constructa-core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "The UI-agnostic Constructa generator execution engine.",
   "private": false,
   "license": "MIT",