constructa-schema 0.0.4 → 2.0.0

package/README.md

@@ -1,46 +1,48 @@
 # `constructa-schema`
 
-Portable generator definitions, validation schemas, and related types shared by every Constructa interface.
-
-Planned areas include definition versioning, primitive and composite definitions, validation results, and safe serialization. This package must remain independent of execution, UI, network, and persistence concerns.
+Portable generator definitions, versioned generator documents, validation schemas, and related types shared by every Constructa interface.
 
 ## Portable data constraint
 
-Portable generator definitions are JSON-only data. Supported values are strings, booleans, `null`, finite numbers other than negative zero, arrays, and plain object records whose properties are all JSON values.
-
-Omit optional data by leaving the property out. `undefined` is not a portable value, including in object properties or array items. Values that JSON would coerce, execute, or silently omit are rejected, including functions, symbols, bigints, `NaN`, infinities, cyclic objects, sparse arrays, custom `toJSON` behavior, class instances, maps, sets, dates, accessors, symbol keys, and non-enumerable properties.
-
-Use `isJsonValue`, `assertJsonValue`, or `findJsonValueError` to enforce this constraint before later schema-specific validation.
+Documents and definitions are JSON-only data. Supported values are strings, booleans, `null`, finite numbers other than negative zero, arrays, and plain object records whose properties are all JSON values. Functions, symbols, bigints, `NaN`, infinities, cyclic objects, sparse arrays, custom `toJSON` behavior, class instances, maps, sets, dates, accessors, symbol keys, and non-enumerable properties are rejected.
 
-## Schema version
+## Definitions and documents
 
-Complete portable definitions must include `schemaVersion: 1`. `CURRENT_SCHEMA_VERSION` identifies the version emitted by current Constructa tooling, and `SUPPORTED_SCHEMA_VERSIONS` lists the versions accepted by this package.
+A `GeneratorDefinition` is executable generator data. It has a stable, non-empty `type` discriminator, with generator-specific fields at the same level:
 
-Use `isSchemaVersion`, `assertSchemaVersion`, `isVersionedDefinition`, `assertVersionedDefinition`, `findSchemaVersionValueFailure`, or `findSchemaVersionFailure` to reject missing or unsupported version markers with structured failures.
-
-## Definition envelope
+```json
+{ "type": "integer", "min": 1, "max": 100 }
+```
 
-The canonical top-level generator definition document is:
+A `GeneratorDocumentV1` wraps exactly one root definition and carries versioning and optional display metadata:
 
 ```json
 {
   "schemaVersion": 1,
-  "type": "integer",
-  "configuration": {
-    "min": 1,
-    "max": 100
-  },
   "name": "Small integer",
-  "description": "An integer in a bounded range."
+  "description": "An integer in a bounded range.",
+  "definition": { "type": "integer", "min": 1, "max": 100 }
 }
 ```
 
-`schemaVersion`, `type`, and `configuration` are required. `type` must be a non-empty string, and `configuration` must be a JSON object. `name` and `description` are optional strings.
+`name` and `description` are optional strings; empty strings are preserved rather than normalized. Unknown document keys are rejected. Document metadata, ownership, visibility, and timestamps do not belong in generator definitions. The former `{ type, configuration }` envelope is rejected; move its generator fields directly into `definition`.
+
+Use `parseDocument` to validate and obtain a `GeneratorDocumentV1`, or `safeParseDocument` for a non-throwing parse result. Use `isGeneratorDefinition` or `assertGeneratorDefinition` when validating an unwrapped definition.
+
+## Validation issues
+
+Validation APIs expose stable issues with a `code`, human-readable `message`, segment-based `path`, and optional JSON-safe `details`. A path is a `readonly (string | number)[]`: a property named `profile.age` remains the single segment `"profile.age"`, while an array item uses a numeric segment such as `0`.
+
+Use `validateDocument` to receive every independent document issue in deterministic order, or `validateGeneratorDefinition` for a definition and its nested typed definitions. `parseDocument` and `safeParseDocument` use the first issue when a single parse result is required. Path rendering is intentionally left to the consuming interface.
+
+## Semantic generator metadata
+
+`GeneratorMetadata` describes a generator without influencing execution. All fields are optional so third-party generators can provide only what they know: `typeId`, `displayName`, `description`, `category`, `outputCategory`, `documentationUrl`, and JSON-only `examples`.
 
-Unknown top-level properties are rejected so all surfaces exchange one canonical document shape. Generator-specific data belongs inside `configuration`, where each generator can validate its own fields in later phases.
+Metadata IDs use lowercase stable identifiers (for example, `integer`, `numeric`, or `date-time`). `outputCategory` is a coarse preview hint only; it does not replace runtime validation or future TypeScript output inference. Presentation details—including React components, icons, CSS classes, controls, routes, and layout—are deliberately not part of this contract.
 
-Use `isDefinitionEnvelope`, `assertDefinitionEnvelope`, `parseDefinitionEnvelope`, `safeParseDefinitionEnvelope`, or `findDefinitionEnvelopeFailure` to validate the complete envelope.
+Use `isGeneratorMetadata`, `assertGeneratorMetadata`, or `validateGeneratorMetadata` to validate metadata.
 
 ## Dependency boundary
 
-This is the bottom of the domain dependency graph and has no Constructa runtime dependencies. In particular, it must not import core, generators, exporters, the SDK, applications, UI, environment, persistence, or transport code.
+This is the bottom of the domain dependency graph and has no Constructa runtime dependencies.

package/dist/index.d.ts

@@ -5,72 +5,124 @@ type JsonArray = readonly JsonValue[];
 type JsonObject = {
   readonly [key: string]: JsonValue;
 };
+type ValidationPathSegment = string | number;
+type ValidationPath = readonly ValidationPathSegment[];
+type ValidationIssue = {
+  readonly code: string;
+  readonly path: ValidationPath;
+  readonly message: string;
+  readonly details?: JsonObject;
+};
 declare const CURRENT_SCHEMA_VERSION = 1;
 declare const SUPPORTED_SCHEMA_VERSIONS: readonly [1];
 type SchemaVersion = (typeof SUPPORTED_SCHEMA_VERSIONS)[number];
-type VersionedDefinition = JsonObject & {
-  readonly schemaVersion: SchemaVersion;
-};
-type DefinitionEnvelope = {
-  readonly schemaVersion: SchemaVersion;
+/** Portable executable generator data. Generator fields live beside `type`. */
+type GeneratorDefinition = JsonObject & {
   readonly type: string;
-  readonly configuration: JsonObject;
+};
+/** Versioned document containing exactly one root generator definition. */
+type GeneratorDocumentV1 = {
+  readonly schemaVersion: 1;
+  readonly definition: GeneratorDefinition;
   readonly name?: string;
   readonly description?: string;
 };
-declare const DEFINITION_ENVELOPE_TOP_LEVEL_KEYS: readonly ["schemaVersion", "type", "configuration", "name", "description"];
+type GeneratorDocument = GeneratorDocumentV1;
+/** A stable, lowercase identifier used to classify portable metadata. */
+type SemanticMetadataId = string;
+/** A coarse output-preview classification, not an execution or inference type. */
+type GeneratorOutputCategory = SemanticMetadataId;
+/**
+ * Portable, descriptive metadata for a generator implementation.
+ * It is intentionally separate from executable generator definitions.
+ */
+type GeneratorMetadata = {
+  readonly typeId?: SemanticMetadataId;
+  readonly displayName?: string;
+  readonly description?: string;
+  readonly category?: SemanticMetadataId;
+  readonly outputCategory?: GeneratorOutputCategory;
+  readonly documentationUrl?: string;
+  readonly examples?: readonly JsonValue[];
+};
+declare const GENERATOR_DOCUMENT_TOP_LEVEL_KEYS: readonly ["schemaVersion", "name", "description", "definition"];
+declare const GENERATOR_METADATA_KEYS: readonly ["typeId", "displayName", "description", "category", "outputCategory", "documentationUrl", "examples"];
 type SchemaVersionFailureCode = "schema_version_missing" | "schema_version_unsupported";
 type SchemaVersionFailure = {
   readonly code: SchemaVersionFailureCode;
   readonly message: string;
-  readonly path: string;
+  readonly path: ValidationPath;
+  readonly severity: "error";
+  readonly details: {
+    readonly supportedVersions: readonly SchemaVersion[];
+  };
+} & ValidationIssue;
+type GeneratorDefinitionFailureCode = "generator_definition_not_json" | "generator_definition_not_object" | "generator_type_missing" | "generator_type_invalid" | "definition_document_metadata";
+type GeneratorDefinitionFailure = {
+  readonly code: GeneratorDefinitionFailureCode;
+  readonly message: string;
+  readonly path: ValidationPath;
+  readonly severity: "error";
+};
+type GeneratorMetadataFailureCode = "generator_metadata_not_json" | "generator_metadata_not_object" | "metadata_type_id_invalid" | "metadata_display_name_invalid" | "metadata_description_invalid" | "metadata_category_invalid" | "metadata_output_category_invalid" | "metadata_documentation_url_invalid" | "metadata_examples_invalid" | "metadata_property_unknown";
+type GeneratorMetadataFailure = {
+  readonly code: GeneratorMetadataFailureCode;
+  readonly message: string;
+  readonly path: ValidationPath;
   readonly severity: "error";
-  readonly supportedVersions: readonly SchemaVersion[];
 };
-type DefinitionEnvelopeFailureCode = SchemaVersionFailureCode | "definition_envelope_not_json" | "definition_envelope_not_object" | "generator_type_missing" | "generator_type_invalid" | "configuration_missing" | "configuration_invalid" | "name_invalid" | "description_invalid" | "top_level_property_unknown";
-type DefinitionEnvelopeShapeFailureCode = Exclude<DefinitionEnvelopeFailureCode, SchemaVersionFailureCode>;
-type DefinitionEnvelopeShapeFailure = {
-  readonly code: DefinitionEnvelopeShapeFailureCode;
+type GeneratorDocumentFailureCode = SchemaVersionFailureCode | GeneratorDefinitionFailureCode | "generator_document_not_json" | "generator_document_not_object" | "definition_missing" | "name_invalid" | "description_invalid" | "top_level_property_unknown" | "configuration_envelope_removed";
+type GeneratorDocumentFailure = SchemaVersionFailure | {
+  readonly code: Exclude<GeneratorDocumentFailureCode, SchemaVersionFailureCode>;
   readonly message: string;
-  readonly path: string;
+  readonly path: ValidationPath;
   readonly severity: "error";
 };
-type DefinitionEnvelopeFailure = SchemaVersionFailure | DefinitionEnvelopeShapeFailure;
-type DefinitionEnvelopeParseResult = {
+type GeneratorDocumentParseResult = {
   readonly success: true;
-  readonly value: DefinitionEnvelope;
+  readonly value: GeneratorDocumentV1;
 } | {
   readonly success: false;
-  readonly failure: DefinitionEnvelopeFailure;
+  readonly failure: GeneratorDocumentFailure;
 };
 declare class JsonValueError extends TypeError {
-  constructor(path: string, reason: string);
+  readonly issue: ValidationIssue;
+  constructor(path: ValidationPath, reason: string);
 }
 declare class SchemaVersionError extends TypeError {
   readonly failure: SchemaVersionFailure;
   constructor(failure: SchemaVersionFailure);
 }
-declare class DefinitionEnvelopeError extends TypeError {
-  readonly failure: DefinitionEnvelopeFailure;
-  constructor(failure: DefinitionEnvelopeFailure);
+declare class GeneratorDefinitionError extends TypeError {
+  readonly failure: GeneratorDefinitionFailure;
+  constructor(failure: GeneratorDefinitionFailure);
+}
+declare class GeneratorMetadataError extends TypeError {
+  readonly failure: GeneratorMetadataFailure;
+  constructor(failure: GeneratorMetadataFailure);
+}
+declare class GeneratorDocumentError extends TypeError {
+  readonly failure: GeneratorDocumentFailure;
+  constructor(failure: GeneratorDocumentFailure);
 }
 declare function isJsonValue(value: unknown): value is JsonValue;
 declare function isSchemaVersion(value: unknown): value is SchemaVersion;
-declare function isVersionedDefinition(value: unknown): value is VersionedDefinition;
-declare function isDefinitionEnvelope(value: unknown): value is DefinitionEnvelope;
-declare function assertJsonValue(value: unknown, path?: string): asserts value is JsonValue;
-declare function assertSchemaVersion(value: unknown, path?: string): asserts value is SchemaVersion;
-declare function assertVersionedDefinition(value: unknown, path?: string): asserts value is VersionedDefinition;
-declare function assertDefinitionEnvelope(value: unknown, path?: string): asserts value is DefinitionEnvelope;
-declare function parseDefinitionEnvelope(value: unknown, path?: string): DefinitionEnvelope;
-declare function safeParseDefinitionEnvelope(value: unknown, path?: string): DefinitionEnvelopeParseResult;
-declare function findJsonValueError(value: unknown, path?: string): {
-  path: string;
-  reason: string;
-} | undefined;
-declare function findDefinitionEnvelopeFailure(value: unknown, path?: string): DefinitionEnvelopeFailure | undefined;
-declare function findSchemaVersionFailure(value: unknown, path?: string): SchemaVersionFailure | undefined;
-declare function findSchemaVersionValueFailure(value: unknown, path?: string): SchemaVersionFailure | undefined;
+declare function isGeneratorDefinition(value: unknown): value is GeneratorDefinition;
+declare function isDocument(value: unknown): value is GeneratorDocumentV1;
+declare function isGeneratorMetadata(value: unknown): value is GeneratorMetadata;
+declare function assertJsonValue(value: unknown, path?: ValidationPath): asserts value is JsonValue;
+declare function assertSchemaVersion(value: unknown, path?: ValidationPath): asserts value is SchemaVersion;
+declare function assertGeneratorDefinition(value: unknown, path?: ValidationPath): asserts value is GeneratorDefinition;
+declare function assertGeneratorMetadata(value: unknown, path?: ValidationPath): asserts value is GeneratorMetadata;
+declare function assertDocument(value: unknown, path?: ValidationPath): asserts value is GeneratorDocumentV1;
+declare function parseDocument(value: unknown, path?: ValidationPath): GeneratorDocumentV1;
+declare function safeParseDocument(value: unknown, path?: ValidationPath): GeneratorDocumentParseResult;
+declare function validateJsonValue(value: unknown, path?: ValidationPath): readonly ValidationIssue[];
+/** Returns all independent document validation issues in deterministic order. */
+declare function validateDocument(value: unknown, path?: ValidationPath): readonly GeneratorDocumentFailure[];
+/** Returns definition issues. Nested typed definitions are validated recursively. */
+declare function validateGeneratorDefinition(value: unknown, path?: ValidationPath): readonly GeneratorDefinitionFailure[];
+declare function validateGeneratorMetadata(value: unknown, path?: ValidationPath): readonly GeneratorMetadataFailure[];
 //#endregion
-export { CURRENT_SCHEMA_VERSION, DEFINITION_ENVELOPE_TOP_LEVEL_KEYS, DefinitionEnvelope, DefinitionEnvelopeError, DefinitionEnvelopeFailure, DefinitionEnvelopeFailureCode, DefinitionEnvelopeParseResult, DefinitionEnvelopeShapeFailure, DefinitionEnvelopeShapeFailureCode, JsonArray, JsonObject, JsonPrimitive, JsonValue, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersion, SchemaVersionError, SchemaVersionFailure, SchemaVersionFailureCode, VersionedDefinition, assertDefinitionEnvelope, assertJsonValue, assertSchemaVersion, assertVersionedDefinition, findDefinitionEnvelopeFailure, findJsonValueError, findSchemaVersionFailure, findSchemaVersionValueFailure, isDefinitionEnvelope, isJsonValue, isSchemaVersion, isVersionedDefinition, parseDefinitionEnvelope, safeParseDefinitionEnvelope };
+export { CURRENT_SCHEMA_VERSION, GENERATOR_DOCUMENT_TOP_LEVEL_KEYS, GENERATOR_METADATA_KEYS, GeneratorDefinition, GeneratorDefinitionError, GeneratorDefinitionFailure, GeneratorDefinitionFailureCode, GeneratorDocument, GeneratorDocumentError, GeneratorDocumentFailure, GeneratorDocumentFailureCode, GeneratorDocumentParseResult, GeneratorDocumentV1, GeneratorMetadata, GeneratorMetadataError, GeneratorMetadataFailure, GeneratorMetadataFailureCode, GeneratorOutputCategory, JsonArray, JsonObject, JsonPrimitive, JsonValue, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersion, SchemaVersionError, SchemaVersionFailure, SchemaVersionFailureCode, SemanticMetadataId, ValidationIssue, ValidationPath, ValidationPathSegment, assertDocument, assertGeneratorDefinition, assertGeneratorMetadata, assertJsonValue, assertSchemaVersion, isDocument, isGeneratorDefinition, isGeneratorMetadata, isJsonValue, isSchemaVersion, parseDocument, safeParseDocument, validateDocument, validateGeneratorDefinition, validateGeneratorMetadata, validateJsonValue };
 //# 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":";KAAY;KAEA,YAAY,YAAY,aAAa;KAErC,qBAAqB;KAErB;YACA,cAAc;;cAGb;cAEA;KAED,wBAAwB;KAExB,sBAAsB;WACvB,eAAe;;KAGd;WACD,eAAe;WACf;WACA,eAAe;WACf;WACA;;cAGE;KAQD;KAIA;WACD,MAAM;WACN;WACA;WACA;WACA,4BAA4B;;KAG3B,gCACR;KAWQ,qCAAqC,QAC/C,+BACA;KAGU;WACD,MAAM;WACN;WACA;WACA;;KAGC,4BACR,uBACA;KAEQ;WAEG;WACA,OAAO;;WAGP;WACA,SAAS;;cAGX,uBAAuB;EACtB,YAAA,cAAc;;cAMf,2BAA2B;WAC7B,SAAS;EAEN,YAAA,SAAS;;cAOV,gCAAgC;WAClC,SAAS;EAEN,YAAA,SAAS;;iBAOP,YAAY,iBAAiB,SAAS;iBAItC,gBAAgB,iBAAiB,SAAS;iBAI1C,sBACd,iBACC,SAAS;iBAQI,qBACd,iBACC,SAAS;iBAII,gBACd,gBACA,wBACS,SAAS;iBAQJ,oBACd,gBACA,wBACS,SAAS;iBAQJ,0BACd,gBACA,wBACS,SAAS;iBAUJ,yBACd,gBACA,wBACS,SAAS;iBAQJ,wBACd,gBACA,gBACC;iBAKa,4BACd,gBACA,gBACC;iBAUa,mBACd,gBACA;EACG;EAAc;;iBAIH,8BACd,gBACA,gBACC;iBA8Ea,yBACd,gBACA,gBACC;iBAaa,8BACd,gBACA,gBACC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";KAAY;KACA,YAAY,YAAY,aAAa;KACrC,qBAAqB;KACrB;YAAyB,cAAc;;KAEvC;KACA,0BAA0B;KAC1B;WACD;WACA,MAAM;WACN;WACA,UAAU;;cAGR;cACA;KACD,wBAAwB;;KAGxB,sBAAsB;WAAwB;;;KAG9C;WACD;WACA,YAAY;WACZ;WACA;;KAGC,oBAAoB;;KAGpB;;KAGA,0BAA0B;;;;;KAM1B;WACD,SAAS;WACT;WACA;WACA,WAAW;WACX,iBAAiB;WACjB;WACA,oBAAoB;;cAGlB;cAOA;KAsBD;KAGA;WACD,MAAM;WACN;WACA,MAAM;WACN;WACA;aAAoB,4BAA4B;;IACvD;KAEQ;KAMA;WACD,MAAM;WACN;WACA,MAAM;WACN;;KAGC;KAWA;WACD,MAAM;WACN;WACA,MAAM;WACN;;KAGC,+BACR,2BACA;KAQQ,2BACR;WAEW,MAAM,QACb,8BACA;WAEO;WACA,MAAM;WACN;;KAEH;WACG;WAAwB,OAAO;;WAC/B;WAAyB,SAAS;;cAEpC,uBAAuB;WACzB,OAAO;EACJ,YAAA,MAAM,gBAAgB;;cAOvB,2BAA2B;WAC7B,SAAS;EACN,YAAA,SAAS;;cAOV,iCAAiC;WACnC,SAAS;EACN,YAAA,SAAS;;cAOV,+BAA+B;WACjC,SAAS;EACN,YAAA,SAAS;;cAOV,+BAA+B;WACjC,SAAS;EACN,YAAA,SAAS;;iBAOP,YAAY,iBAAiB,SAAS;iBAGtC,gBAAgB,iBAAiB,SAAS;iBAG1C,sBACd,iBACC,SAAS;iBAGI,WAAW,iBAAiB,SAAS;iBAGrC,oBACd,iBACC,SAAS;iBAGI,gBACd,gBACA,OAAM,yBACG,SAAS;iBAIJ,oBACd,gBACA,OAAM,yBACG,SAAS;iBAIJ,0BACd,gBACA,OAAM,yBACG,SAAS;iBAIJ,wBACd,gBACA,OAAM,yBACG,SAAS;iBAIJ,eACd,gBACA,OAAM,yBACG,SAAS;iBAIJ,cACd,gBACA,OAAM,iBACL;iBAIa,kBACd,gBACA,OAAM,iBACL;iBAOa,kBACd,gBACA,OAAM,0BACI;;iBAeI,iBACd,gBACA,OAAM,0BACI;;iBA8DI,4BACd,gBACA,OAAM,0BACI;iBAmBI,0BACd,gBACA,OAAM,0BACI"}

package/dist/index.js

@@ -1,117 +1,283 @@
 //#region src/index.ts
 const CURRENT_SCHEMA_VERSION = 1;
 const SUPPORTED_SCHEMA_VERSIONS = [1];
-const DEFINITION_ENVELOPE_TOP_LEVEL_KEYS = [
+const GENERATOR_DOCUMENT_TOP_LEVEL_KEYS = [
 	"schemaVersion",
-	"type",
-	"configuration",
 	"name",
-	"description"
+	"description",
+	"definition"
 ];
+const GENERATOR_METADATA_KEYS = [
+	"typeId",
+	"displayName",
+	"description",
+	"category",
+	"outputCategory",
+	"documentationUrl",
+	"examples"
+];
+const DOCUMENT_METADATA_KEYS = /* @__PURE__ */ new Set([
+	"schemaVersion",
+	"name",
+	"description",
+	"owner",
+	"ownership",
+	"visibility",
+	"createdAt",
+	"updatedAt",
+	"timestamps"
+]);
 var JsonValueError = class extends TypeError {
+	issue;
 	constructor(path, reason) {
-		super(`${path}: ${reason}`);
+		super(`${formatValidationPath(path)}: ${reason}`);
 		this.name = "JsonValueError";
+		this.issue = {
+			code: "invalid_json_value",
+			path,
+			message: reason
+		};
 	}
 };
 var SchemaVersionError = class extends TypeError {
 	failure;
 	constructor(failure) {
-		super(`${failure.path}: ${failure.message}`);
+		super(`${formatValidationPath(failure.path)}: ${failure.message}`);
 		this.name = "SchemaVersionError";
 		this.failure = failure;
 	}
 };
-var DefinitionEnvelopeError = class extends TypeError {
+var GeneratorDefinitionError = class extends TypeError {
+	failure;
+	constructor(failure) {
+		super(`${formatValidationPath(failure.path)}: ${failure.message}`);
+		this.name = "GeneratorDefinitionError";
+		this.failure = failure;
+	}
+};
+var GeneratorMetadataError = class extends TypeError {
 	failure;
 	constructor(failure) {
-		super(`${failure.path}: ${failure.message}`);
-		this.name = "DefinitionEnvelopeError";
+		super(`${formatValidationPath(failure.path)}: ${failure.message}`);
+		this.name = "GeneratorMetadataError";
+		this.failure = failure;
+	}
+};
+var GeneratorDocumentError = class extends TypeError {
+	failure;
+	constructor(failure) {
+		super(`${formatValidationPath(failure.path)}: ${failure.message}`);
+		this.name = "GeneratorDocumentError";
 		this.failure = failure;
 	}
 };
 function isJsonValue(value) {
-	return findJsonValueError(value) === void 0;
+	return validateJsonValue(value).length === 0;
 }
 function isSchemaVersion(value) {
 	return value === 1;
 }
-function isVersionedDefinition(value) {
-	return findSchemaVersionFailure(value) === void 0 && isJsonRecord(value) && isJsonValue(value);
+function isGeneratorDefinition(value) {
+	return validateGeneratorDefinition(value).length === 0;
 }
-function isDefinitionEnvelope(value) {
-	return findDefinitionEnvelopeFailure(value) === void 0;
+function isDocument(value) {
+	return validateDocument(value).length === 0;
 }
-function assertJsonValue(value, path = "$") {
-	const error = findJsonValueError(value, path);
-	if (error !== void 0) throw new JsonValueError(error.path, error.reason);
+function isGeneratorMetadata(value) {
+	return validateGeneratorMetadata(value).length === 0;
+}
+function assertJsonValue(value, path = []) {
+	const [issue] = validateJsonValue(value, path);
+	if (issue !== void 0) throw new JsonValueError(issue.path, issue.message);
 }
-function assertSchemaVersion(value, path = "$.schemaVersion") {
+function assertSchemaVersion(value, path = ["schemaVersion"]) {
 	const failure = findSchemaVersionValueFailure(value, path);
 	if (failure !== void 0) throw new SchemaVersionError(failure);
 }
-function assertVersionedDefinition(value, path = "$") {
-	const failure = findSchemaVersionFailure(value, path);
-	if (failure !== void 0) throw new SchemaVersionError(failure);
-	assertJsonValue(value, path);
+function assertGeneratorDefinition(value, path = []) {
+	const [failure] = validateGeneratorDefinition(value, path);
+	if (failure !== void 0) throw new GeneratorDefinitionError(failure);
 }
-function assertDefinitionEnvelope(value, path = "$") {
-	const failure = findDefinitionEnvelopeFailure(value, path);
-	if (failure !== void 0) throw new DefinitionEnvelopeError(failure);
+function assertGeneratorMetadata(value, path = []) {
+	const [failure] = validateGeneratorMetadata(value, path);
+	if (failure !== void 0) throw new GeneratorMetadataError(failure);
 }
-function parseDefinitionEnvelope(value, path = "$") {
-	assertDefinitionEnvelope(value, path);
+function assertDocument(value, path = []) {
+	const [issue] = validateDocument(value, path);
+	if (issue !== void 0) throw new GeneratorDocumentError(issue);
+}
+function parseDocument(value, path = []) {
+	assertDocument(value, path);
 	return value;
 }
-function safeParseDefinitionEnvelope(value, path = "$") {
-	const failure = findDefinitionEnvelopeFailure(value, path);
-	if (failure !== void 0) return {
-		failure,
-		success: false
-	};
-	return {
+function safeParseDocument(value, path = []) {
+	const [failure] = validateDocument(value, path);
+	return failure === void 0 ? {
 		success: true,
 		value
+	} : {
+		success: false,
+		failure
 	};
 }
-function findJsonValueError(value, path = "$") {
+function validateJsonValue(value, path = []) {
+	const error = findJsonValueError(value, path);
+	return error === void 0 ? [] : [{
+		code: "invalid_json_value",
+		path: error.path,
+		message: error.reason
+	}];
+}
+function findJsonValueError(value, path) {
 	return findJsonValueErrorInternal(value, path, /* @__PURE__ */ new Set());
 }
-function findDefinitionEnvelopeFailure(value, path = "$") {
+/** Returns all independent document validation issues in deterministic order. */
+function validateDocument(value, path = []) {
 	const jsonError = findJsonValueError(value, path);
-	if (jsonError !== void 0) return createDefinitionEnvelopeFailure("definition_envelope_not_json", {
-		message: jsonError.reason,
-		path: jsonError.path
-	});
-	if (!isJsonRecord(value)) return createDefinitionEnvelopeFailure("definition_envelope_not_object", { path });
+	if (jsonError !== void 0) return [documentFailure("generator_document_not_json", jsonError.path, jsonError.reason)];
+	if (!isJsonRecord(value)) return [documentFailure("generator_document_not_object", path)];
+	const issues = [];
+	if (Object.hasOwn(value, "configuration") && Object.hasOwn(value, "type")) issues.push(documentFailure("configuration_envelope_removed", path));
+	for (const key of Object.keys(value)) if (!GENERATOR_DOCUMENT_TOP_LEVEL_KEYS.includes(key)) issues.push(documentFailure("top_level_property_unknown", appendPathSegment(path, key), `Unknown top-level property: ${key}`));
 	const versionFailure = findSchemaVersionFailure(value, path);
-	if (versionFailure !== void 0) return versionFailure;
-	if (!Object.hasOwn(value, "type")) return createDefinitionEnvelopeFailure("generator_type_missing", { path: appendPathSegment(path, "type") });
-	const typeValue = value.type;
-	if (typeof typeValue !== "string" || typeValue.trim().length === 0) return createDefinitionEnvelopeFailure("generator_type_invalid", { path: appendPathSegment(path, "type") });
-	if (!Object.hasOwn(value, "configuration")) return createDefinitionEnvelopeFailure("configuration_missing", { path: appendPathSegment(path, "configuration") });
-	if (!isJsonRecord(value.configuration)) return createDefinitionEnvelopeFailure("configuration_invalid", { path: appendPathSegment(path, "configuration") });
-	for (const optionalStringField of ["name", "description"]) {
-		const fieldFailure = findDefinitionEnvelopeStringFieldFailure(value, {
-			invalidCode: optionalStringField === "name" ? "name_invalid" : "description_invalid",
-			path: appendPathSegment(path, optionalStringField),
-			property: optionalStringField
-		});
-		if (fieldFailure !== void 0) return fieldFailure;
-	}
-	const unknownKey = Object.keys(value).find((key) => !DEFINITION_ENVELOPE_TOP_LEVEL_KEYS.includes(key));
-	if (unknownKey !== void 0) return createDefinitionEnvelopeFailure("top_level_property_unknown", {
-		message: `Unknown top-level property: ${unknownKey}`,
-		path: appendPathSegment(path, unknownKey)
-	});
-}
-function findSchemaVersionFailure(value, path = "$") {
-	if (!isJsonRecord(value) || !Object.hasOwn(value, "schemaVersion")) return createSchemaVersionFailure("schema_version_missing", { path: appendPathSegment(path, "schemaVersion") });
+	if (versionFailure !== void 0) issues.push(versionFailure);
+	for (const property of ["name", "description"]) if (Object.hasOwn(value, property) && typeof value[property] !== "string") issues.push(documentFailure(property === "name" ? "name_invalid" : "description_invalid", appendPathSegment(path, property)));
+	if (!Object.hasOwn(value, "definition")) issues.push(documentFailure("definition_missing", appendPathSegment(path, "definition")));
+	else issues.push(...validateGeneratorDefinition(value.definition, appendPathSegment(path, "definition")));
+	return issues;
+}
+/** Returns definition issues. Nested typed definitions are validated recursively. */
+function validateGeneratorDefinition(value, path = []) {
+	const jsonError = findJsonValueError(value, path);
+	if (jsonError !== void 0) return [definitionFailure("generator_definition_not_json", jsonError.path, jsonError.reason)];
+	if (!isJsonRecord(value)) return [definitionFailure("generator_definition_not_object", path)];
+	const issues = [];
+	collectDefinitionMetadataIssues(value, path, issues, true);
+	return issues;
+}
+function validateGeneratorMetadata(value, path = []) {
+	const failure = findGeneratorMetadataFailure(value, path);
+	return failure === void 0 ? [] : [failure];
+}
+function findGeneratorMetadataFailure(value, path = []) {
+	const jsonError = findJsonValueError(value, path);
+	if (jsonError !== void 0) return metadataFailure("generator_metadata_not_json", jsonError.path, jsonError.reason);
+	if (!isJsonRecord(value)) return metadataFailure("generator_metadata_not_object", path);
+	const unknownKey = Object.keys(value).find((key) => !GENERATOR_METADATA_KEYS.includes(key));
+	if (unknownKey !== void 0) return metadataFailure("metadata_property_unknown", appendPathSegment(path, unknownKey), `Unknown metadata property: ${unknownKey}`);
+	for (const property of [
+		"typeId",
+		"category",
+		"outputCategory"
+	]) if (Object.hasOwn(value, property) && (typeof value[property] !== "string" || !isMetadataId(value[property]))) return metadataFailure(property === "typeId" ? "metadata_type_id_invalid" : property === "category" ? "metadata_category_invalid" : "metadata_output_category_invalid", appendPathSegment(path, property));
+	for (const property of [
+		"displayName",
+		"description",
+		"documentationUrl"
+	]) if (Object.hasOwn(value, property) && typeof value[property] !== "string") return metadataFailure(property === "displayName" ? "metadata_display_name_invalid" : property === "description" ? "metadata_description_invalid" : "metadata_documentation_url_invalid", appendPathSegment(path, property));
+	if (Object.hasOwn(value, "examples") && !Array.isArray(value.examples)) return metadataFailure("metadata_examples_invalid", appendPathSegment(path, "examples"));
+}
+function findSchemaVersionFailure(value, path = []) {
+	if (!isJsonRecord(value) || !Object.hasOwn(value, "schemaVersion")) return createSchemaVersionFailure("schema_version_missing", appendPathSegment(path, "schemaVersion"));
 	return findSchemaVersionValueFailure(value.schemaVersion, appendPathSegment(path, "schemaVersion"));
 }
-function findSchemaVersionValueFailure(value, path = "$.schemaVersion") {
-	if (isSchemaVersion(value)) return;
-	return createSchemaVersionFailure("schema_version_unsupported", { path });
+function findSchemaVersionValueFailure(value, path = ["schemaVersion"]) {
+	return isSchemaVersion(value) ? void 0 : createSchemaVersionFailure("schema_version_unsupported", path);
+}
+function createSchemaVersionFailure(code, path) {
+	return {
+		code,
+		message: code === "schema_version_missing" ? `schemaVersion is required and must be 1` : `schemaVersion must be 1`,
+		path,
+		severity: "error",
+		details: { supportedVersions: SUPPORTED_SCHEMA_VERSIONS }
+	};
+}
+function definitionFailure(code, path, message) {
+	return {
+		code,
+		message: message ?? {
+			generator_definition_not_json: "generator definition must be portable JSON data",
+			generator_definition_not_object: "generator definition must be a JSON object",
+			generator_type_missing: "type is required",
+			generator_type_invalid: "type must be a non-empty string",
+			definition_document_metadata: "document metadata is not allowed in a generator definition"
+		}[code],
+		path,
+		severity: "error"
+	};
+}
+function metadataFailure(code, path, message) {
+	return {
+		code,
+		message: message ?? {
+			generator_metadata_not_json: "generator metadata must be portable JSON data",
+			generator_metadata_not_object: "generator metadata must be a JSON object",
+			metadata_type_id_invalid: "typeId must be a stable metadata ID",
+			metadata_display_name_invalid: "displayName must be a string when present",
+			metadata_description_invalid: "description must be a string when present",
+			metadata_category_invalid: "category must be a stable metadata ID",
+			metadata_output_category_invalid: "outputCategory must be a stable metadata ID",
+			metadata_documentation_url_invalid: "documentationUrl must be a string when present",
+			metadata_examples_invalid: "examples must be an array when present",
+			metadata_property_unknown: "unknown metadata properties are not allowed"
+		}[code],
+		path,
+		severity: "error"
+	};
+}
+function documentFailure(code, path, message) {
+	return {
+		code,
+		message: message ?? {
+			generator_document_not_json: "generator document must be portable JSON data",
+			generator_document_not_object: "generator document must be a JSON object",
+			generator_definition_not_json: "generator definition must be portable JSON data",
+			generator_definition_not_object: "generator definition must be a JSON object",
+			generator_type_missing: "type is required",
+			generator_type_invalid: "type must be a non-empty string",
+			definition_document_metadata: "document metadata is not allowed in a generator definition",
+			definition_missing: "definition is required",
+			name_invalid: "name must be a string when present",
+			description_invalid: "description must be a string when present",
+			top_level_property_unknown: "unknown top-level properties are not allowed",
+			configuration_envelope_removed: "The configuration envelope was removed; put generator fields directly inside definition."
+		}[code],
+		path,
+		severity: "error"
+	};
+}
+function appendPathSegment(path, segment) {
+	return [...path, segment];
+}
+function formatValidationPath(path) {
+	return path.length === 0 ? "$" : path.map((segment) => typeof segment === "number" ? `[${segment}]` : `.${segment}`).join("").replace(/^\./u, "$");
+}
+function isMetadataId(value) {
+	return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u.test(value);
+}
+function collectDefinitionMetadataIssues(value, path, issues, isDefinition) {
+	if (isDefinition) {
+		if (!Object.hasOwn(value, "type")) issues.push(definitionFailure("generator_type_missing", appendPathSegment(path, "type")));
+		else if (typeof value.type !== "string" || value.type.trim().length === 0) issues.push(definitionFailure("generator_type_invalid", appendPathSegment(path, "type")));
+		for (const key of Object.keys(value)) if (key !== "type" && DOCUMENT_METADATA_KEYS.has(key)) issues.push(definitionFailure("definition_document_metadata", appendPathSegment(path, key)));
+	}
+	for (const [key, child] of Object.entries(value)) {
+		if (key === "type") continue;
+		collectNestedDefinitionMetadataIssues(child, appendPathSegment(path, key), issues);
+	}
+}
+function collectNestedDefinitionMetadataIssues(value, path, issues) {
+	if (Array.isArray(value)) {
+		for (let index = 0; index < value.length; index += 1) collectNestedDefinitionMetadataIssues(value[index], appendPathSegment(path, index), issues);
+		return;
+	}
+	if (!isJsonRecord(value)) return;
+	collectDefinitionMetadataIssues(value, path, issues, Object.hasOwn(value, "type"));
+}
+function isJsonRecord(value) {
+	const prototype = typeof value === "object" && value !== null ? Object.getPrototypeOf(value) : void 0;
+	return typeof value === "object" && value !== null && !Array.isArray(value) && (prototype === null || prototype === Object.prototype);
 }
 function findJsonValueErrorInternal(value, path, ancestors) {
 	switch (typeof value) {
@@ -122,14 +288,11 @@ function findJsonValueErrorInternal(value, path, ancestors) {
 				path,
 				reason: "number must be finite"
 			};
-			if (Object.is(value, -0)) return {
+			return Object.is(value, -0) ? {
 				path,
 				reason: "number must not be negative zero"
-			};
-			return;
-		case "object":
-			if (value === null) return;
-			return findJsonObjectError(value, path, ancestors);
+			} : void 0;
+		case "object": return value === null ? void 0 : findJsonObjectError(value, path, ancestors);
 		case "bigint":
 		case "function":
 		case "symbol":
@@ -139,53 +302,12 @@ function findJsonValueErrorInternal(value, path, ancestors) {
 		};
 	}
 }
-function createSchemaVersionFailure(code, options) {
-	return {
-		code,
-		message: code === "schema_version_missing" ? `schemaVersion is required and must be 1` : `schemaVersion must be 1`,
-		path: options.path,
-		severity: "error",
-		supportedVersions: SUPPORTED_SCHEMA_VERSIONS
-	};
-}
-function createDefinitionEnvelopeFailure(code, options) {
-	return {
-		code,
-		message: options.message ?? getDefinitionEnvelopeFailureMessage(code),
-		path: options.path,
-		severity: "error"
-	};
-}
-function getDefinitionEnvelopeFailureMessage(code) {
-	switch (code) {
-		case "definition_envelope_not_json": return "definition envelope must be portable JSON data";
-		case "definition_envelope_not_object": return "definition envelope must be a JSON object";
-		case "generator_type_missing": return "type is required";
-		case "generator_type_invalid": return "type must be a non-empty string";
-		case "configuration_missing": return "configuration is required";
-		case "configuration_invalid": return "configuration must be a JSON object";
-		case "name_invalid": return "name must be a string when present";
-		case "description_invalid": return "description must be a string when present";
-		case "top_level_property_unknown": return "unknown top-level properties are not allowed";
-	}
-}
-function findDefinitionEnvelopeStringFieldFailure(value, options) {
-	if (!Object.hasOwn(value, options.property)) return;
-	return typeof value[options.property] === "string" ? void 0 : createDefinitionEnvelopeFailure(options.invalidCode, { path: options.path });
-}
-function appendPathSegment(path, segment) {
-	return path === "$" ? `$.${segment}` : `${path}.${segment}`;
-}
-function isJsonRecord(value) {
-	const prototype = typeof value === "object" && value !== null ? Object.getPrototypeOf(value) : void 0;
-	return typeof value === "object" && value !== null && !Array.isArray(value) && (prototype === null || prototype === Object.prototype);
-}
 function findJsonObjectError(value, path, ancestors) {
 	if (ancestors.has(value)) return {
 		path,
 		reason: "cyclic objects are not JSON-compatible"
 	};
-	if (hasCallableToJson(value)) return {
+	if ("toJSON" in value && typeof value.toJSON === "function") return {
 		path,
 		reason: "objects with toJSON behavior are not portable"
 	};
@@ -194,23 +316,20 @@ function findJsonObjectError(value, path, ancestors) {
 	ancestors.delete(value);
 	return error;
 }
-function hasCallableToJson(value) {
-	return "toJSON" in value && typeof value.toJSON === "function";
-}
 function findJsonArrayError(value, path, ancestors) {
 	const extraProperty = Object.keys(value).find((key) => !isArrayIndexKey(key));
 	if (extraProperty !== void 0) return {
-		path: `${path}.${extraProperty}`,
+		path: appendPathSegment(path, extraProperty),
 		reason: "array object properties would be omitted from JSON"
 	};
-	const ownPropertyError = findUnsupportedOwnProperty(value, path, ["length"]);
-	if (ownPropertyError !== void 0) return ownPropertyError;
+	const propertyError = findUnsupportedOwnProperty(value, path, ["length"]);
+	if (propertyError !== void 0) return propertyError;
 	for (let index = 0; index < value.length; index += 1) {
 		if (!(index in value)) return {
-			path: `${path}[${index}]`,
+			path: appendPathSegment(path, index),
 			reason: "sparse array slots are not JSON-compatible"
 		};
-		const itemError = findJsonValueErrorInternal(value[index], `${path}[${index}]`, ancestors);
+		const itemError = findJsonValueErrorInternal(value[index], appendPathSegment(path, index), ancestors);
 		if (itemError !== void 0) return itemError;
 	}
 }
@@ -224,32 +343,35 @@ function findJsonRecordError(value, path, ancestors) {
 		path,
 		reason: "object must be a plain JSON record"
 	};
-	const ownPropertyError = findUnsupportedOwnProperty(value, path);
-	if (ownPropertyError !== void 0) return ownPropertyError;
+	const propertyError = findUnsupportedOwnProperty(value, path);
+	if (propertyError !== void 0) return propertyError;
 	for (const key of Object.keys(value)) {
-		const itemError = findJsonValueErrorInternal(value[key], `${path}.${key}`, ancestors);
+		const itemError = findJsonValueErrorInternal(value[key], appendPathSegment(path, key), ancestors);
 		if (itemError !== void 0) return itemError;
 	}
 }
 function findUnsupportedOwnProperty(value, path, allowedNonEnumerableProperties = []) {
+	if (Object.hasOwn(value, "__proto__")) return {
+		path: appendPathSegment(path, "__proto__"),
+		reason: "__proto__ keys are not portable JSON data"
+	};
 	if (Object.getOwnPropertySymbols(value).length > 0) return {
 		path,
 		reason: "symbol keys are not JSON-compatible"
 	};
-	const allowedNonEnumerable = new Set(allowedNonEnumerableProperties);
-	const descriptors = Object.getOwnPropertyDescriptors(value);
-	for (const [key, descriptor] of Object.entries(descriptors)) {
+	const allowed = new Set(allowedNonEnumerableProperties);
+	for (const [key, descriptor] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
 		if ("get" in descriptor || "set" in descriptor) return {
-			path: `${path}.${key}`,
+			path: appendPathSegment(path, key),
 			reason: "accessor properties are not portable JSON data"
 		};
-		if (!descriptor.enumerable && !allowedNonEnumerable.has(key)) return {
-			path: `${path}.${key}`,
+		if (!descriptor.enumerable && !allowed.has(key)) return {
+			path: appendPathSegment(path, key),
 			reason: "non-enumerable properties would be omitted from JSON"
 		};
 	}
 }
 //#endregion
-export { CURRENT_SCHEMA_VERSION, DEFINITION_ENVELOPE_TOP_LEVEL_KEYS, DefinitionEnvelopeError, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersionError, assertDefinitionEnvelope, assertJsonValue, assertSchemaVersion, assertVersionedDefinition, findDefinitionEnvelopeFailure, findJsonValueError, findSchemaVersionFailure, findSchemaVersionValueFailure, isDefinitionEnvelope, isJsonValue, isSchemaVersion, isVersionedDefinition, parseDefinitionEnvelope, safeParseDefinitionEnvelope };
+export { CURRENT_SCHEMA_VERSION, GENERATOR_DOCUMENT_TOP_LEVEL_KEYS, GENERATOR_METADATA_KEYS, GeneratorDefinitionError, GeneratorDocumentError, GeneratorMetadataError, JsonValueError, SUPPORTED_SCHEMA_VERSIONS, SchemaVersionError, assertDocument, assertGeneratorDefinition, assertGeneratorMetadata, assertJsonValue, assertSchemaVersion, isDocument, isGeneratorDefinition, isGeneratorMetadata, isJsonValue, isSchemaVersion, parseDocument, safeParseDocument, validateDocument, validateGeneratorDefinition, validateGeneratorMetadata, validateJsonValue };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export type JsonPrimitive = boolean | null | number | string;\n\nexport type JsonValue = JsonArray | JsonObject | JsonPrimitive;\n\nexport type JsonArray = readonly JsonValue[];\n\nexport type JsonObject = {\n  readonly [key: string]: JsonValue;\n};\n\nexport const CURRENT_SCHEMA_VERSION = 1;\n\nexport const SUPPORTED_SCHEMA_VERSIONS = [CURRENT_SCHEMA_VERSION] as const;\n\nexport type SchemaVersion = (typeof SUPPORTED_SCHEMA_VERSIONS)[number];\n\nexport type VersionedDefinition = JsonObject & {\n  readonly schemaVersion: SchemaVersion;\n};\n\nexport type DefinitionEnvelope = {\n  readonly schemaVersion: SchemaVersion;\n  readonly type: string;\n  readonly configuration: JsonObject;\n  readonly name?: string;\n  readonly description?: string;\n};\n\nexport const DEFINITION_ENVELOPE_TOP_LEVEL_KEYS = [\n  \"schemaVersion\",\n  \"type\",\n  \"configuration\",\n  \"name\",\n  \"description\",\n] as const;\n\nexport type SchemaVersionFailureCode =\n  | \"schema_version_missing\"\n  | \"schema_version_unsupported\";\n\nexport type SchemaVersionFailure = {\n  readonly code: SchemaVersionFailureCode;\n  readonly message: string;\n  readonly path: string;\n  readonly severity: \"error\";\n  readonly supportedVersions: readonly SchemaVersion[];\n};\n\nexport type DefinitionEnvelopeFailureCode =\n  | SchemaVersionFailureCode\n  | \"definition_envelope_not_json\"\n  | \"definition_envelope_not_object\"\n  | \"generator_type_missing\"\n  | \"generator_type_invalid\"\n  | \"configuration_missing\"\n  | \"configuration_invalid\"\n  | \"name_invalid\"\n  | \"description_invalid\"\n  | \"top_level_property_unknown\";\n\nexport type DefinitionEnvelopeShapeFailureCode = Exclude<\n  DefinitionEnvelopeFailureCode,\n  SchemaVersionFailureCode\n>;\n\nexport type DefinitionEnvelopeShapeFailure = {\n  readonly code: DefinitionEnvelopeShapeFailureCode;\n  readonly message: string;\n  readonly path: string;\n  readonly severity: \"error\";\n};\n\nexport type DefinitionEnvelopeFailure =\n  | SchemaVersionFailure\n  | DefinitionEnvelopeShapeFailure;\n\nexport type DefinitionEnvelopeParseResult =\n  | {\n      readonly success: true;\n      readonly value: DefinitionEnvelope;\n    }\n  | {\n      readonly success: false;\n      readonly failure: DefinitionEnvelopeFailure;\n    };\n\nexport class JsonValueError extends TypeError {\n  constructor(path: string, reason: string) {\n    super(`${path}: ${reason}`);\n    this.name = \"JsonValueError\";\n  }\n}\n\nexport class SchemaVersionError extends TypeError {\n  readonly failure: SchemaVersionFailure;\n\n  constructor(failure: SchemaVersionFailure) {\n    super(`${failure.path}: ${failure.message}`);\n    this.name = \"SchemaVersionError\";\n    this.failure = failure;\n  }\n}\n\nexport class DefinitionEnvelopeError extends TypeError {\n  readonly failure: DefinitionEnvelopeFailure;\n\n  constructor(failure: DefinitionEnvelopeFailure) {\n    super(`${failure.path}: ${failure.message}`);\n    this.name = \"DefinitionEnvelopeError\";\n    this.failure = failure;\n  }\n}\n\nexport function isJsonValue(value: unknown): value is JsonValue {\n  return findJsonValueError(value) === undefined;\n}\n\nexport function isSchemaVersion(value: unknown): value is SchemaVersion {\n  return value === CURRENT_SCHEMA_VERSION;\n}\n\nexport function isVersionedDefinition(\n  value: unknown,\n): value is VersionedDefinition {\n  return (\n    findSchemaVersionFailure(value) === undefined &&\n    isJsonRecord(value) &&\n    isJsonValue(value)\n  );\n}\n\nexport function isDefinitionEnvelope(\n  value: unknown,\n): value is DefinitionEnvelope {\n  return findDefinitionEnvelopeFailure(value) === undefined;\n}\n\nexport function assertJsonValue(\n  value: unknown,\n  path = \"$\",\n): asserts value is JsonValue {\n  const error = findJsonValueError(value, path);\n\n  if (error !== undefined) {\n    throw new JsonValueError(error.path, error.reason);\n  }\n}\n\nexport function assertSchemaVersion(\n  value: unknown,\n  path = \"$.schemaVersion\",\n): asserts value is SchemaVersion {\n  const failure = findSchemaVersionValueFailure(value, path);\n\n  if (failure !== undefined) {\n    throw new SchemaVersionError(failure);\n  }\n}\n\nexport function assertVersionedDefinition(\n  value: unknown,\n  path = \"$\",\n): asserts value is VersionedDefinition {\n  const failure = findSchemaVersionFailure(value, path);\n\n  if (failure !== undefined) {\n    throw new SchemaVersionError(failure);\n  }\n\n  assertJsonValue(value, path);\n}\n\nexport function assertDefinitionEnvelope(\n  value: unknown,\n  path = \"$\",\n): asserts value is DefinitionEnvelope {\n  const failure = findDefinitionEnvelopeFailure(value, path);\n\n  if (failure !== undefined) {\n    throw new DefinitionEnvelopeError(failure);\n  }\n}\n\nexport function parseDefinitionEnvelope(\n  value: unknown,\n  path = \"$\",\n): DefinitionEnvelope {\n  assertDefinitionEnvelope(value, path);\n  return value;\n}\n\nexport function safeParseDefinitionEnvelope(\n  value: unknown,\n  path = \"$\",\n): DefinitionEnvelopeParseResult {\n  const failure = findDefinitionEnvelopeFailure(value, path);\n\n  if (failure !== undefined) {\n    return { failure, success: false };\n  }\n\n  return { success: true, value: value as DefinitionEnvelope };\n}\n\nexport function findJsonValueError(\n  value: unknown,\n  path = \"$\",\n): { path: string; reason: string } | undefined {\n  return findJsonValueErrorInternal(value, path, new Set());\n}\n\nexport function findDefinitionEnvelopeFailure(\n  value: unknown,\n  path = \"$\",\n): DefinitionEnvelopeFailure | undefined {\n  const jsonError = findJsonValueError(value, path);\n\n  if (jsonError !== undefined) {\n    return createDefinitionEnvelopeFailure(\"definition_envelope_not_json\", {\n      message: jsonError.reason,\n      path: jsonError.path,\n    });\n  }\n\n  if (!isJsonRecord(value)) {\n    return createDefinitionEnvelopeFailure(\"definition_envelope_not_object\", {\n      path,\n    });\n  }\n\n  const versionFailure = findSchemaVersionFailure(value, path);\n\n  if (versionFailure !== undefined) {\n    return versionFailure;\n  }\n\n  if (!Object.hasOwn(value, \"type\")) {\n    return createDefinitionEnvelopeFailure(\"generator_type_missing\", {\n      path: appendPathSegment(path, \"type\"),\n    });\n  }\n\n  const typeValue = value.type;\n\n  if (typeof typeValue !== \"string\" || typeValue.trim().length === 0) {\n    return createDefinitionEnvelopeFailure(\"generator_type_invalid\", {\n      path: appendPathSegment(path, \"type\"),\n    });\n  }\n\n  if (!Object.hasOwn(value, \"configuration\")) {\n    return createDefinitionEnvelopeFailure(\"configuration_missing\", {\n      path: appendPathSegment(path, \"configuration\"),\n    });\n  }\n\n  if (!isJsonRecord(value.configuration)) {\n    return createDefinitionEnvelopeFailure(\"configuration_invalid\", {\n      path: appendPathSegment(path, \"configuration\"),\n    });\n  }\n\n  for (const optionalStringField of [\"name\", \"description\"] as const) {\n    const fieldFailure = findDefinitionEnvelopeStringFieldFailure(value, {\n      invalidCode:\n        optionalStringField === \"name\" ? \"name_invalid\" : \"description_invalid\",\n      path: appendPathSegment(path, optionalStringField),\n      property: optionalStringField,\n    });\n\n    if (fieldFailure !== undefined) {\n      return fieldFailure;\n    }\n  }\n\n  const unknownKey = Object.keys(value).find(\n    (key) =>\n      !DEFINITION_ENVELOPE_TOP_LEVEL_KEYS.includes(\n        key as (typeof DEFINITION_ENVELOPE_TOP_LEVEL_KEYS)[number],\n      ),\n  );\n\n  if (unknownKey !== undefined) {\n    return createDefinitionEnvelopeFailure(\"top_level_property_unknown\", {\n      message: `Unknown top-level property: ${unknownKey}`,\n      path: appendPathSegment(path, unknownKey),\n    });\n  }\n\n  return undefined;\n}\n\nexport function findSchemaVersionFailure(\n  value: unknown,\n  path = \"$\",\n): SchemaVersionFailure | undefined {\n  if (!isJsonRecord(value) || !Object.hasOwn(value, \"schemaVersion\")) {\n    return createSchemaVersionFailure(\"schema_version_missing\", {\n      path: appendPathSegment(path, \"schemaVersion\"),\n    });\n  }\n\n  return findSchemaVersionValueFailure(\n    value.schemaVersion,\n    appendPathSegment(path, \"schemaVersion\"),\n  );\n}\n\nexport function findSchemaVersionValueFailure(\n  value: unknown,\n  path = \"$.schemaVersion\",\n): SchemaVersionFailure | undefined {\n  if (isSchemaVersion(value)) {\n    return undefined;\n  }\n\n  return createSchemaVersionFailure(\"schema_version_unsupported\", { path });\n}\n\nfunction findJsonValueErrorInternal(\n  value: unknown,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  switch (typeof value) {\n    case \"boolean\":\n    case \"string\":\n      return undefined;\n    case \"number\":\n      if (!Number.isFinite(value)) {\n        return { path, reason: \"number must be finite\" };\n      }\n      if (Object.is(value, -0)) {\n        return { path, reason: \"number must not be negative zero\" };\n      }\n      return undefined;\n    case \"object\":\n      if (value === null) {\n        return undefined;\n      }\n      return findJsonObjectError(value, path, ancestors);\n    case \"bigint\":\n    case \"function\":\n    case \"symbol\":\n    case \"undefined\":\n      return { path, reason: `${typeof value} is not JSON-compatible` };\n  }\n}\n\nfunction createSchemaVersionFailure(\n  code: SchemaVersionFailureCode,\n  options: { readonly path: string },\n): SchemaVersionFailure {\n  return {\n    code,\n    message:\n      code === \"schema_version_missing\"\n        ? `schemaVersion is required and must be ${CURRENT_SCHEMA_VERSION}`\n        : `schemaVersion must be ${CURRENT_SCHEMA_VERSION}`,\n    path: options.path,\n    severity: \"error\",\n    supportedVersions: SUPPORTED_SCHEMA_VERSIONS,\n  };\n}\n\nfunction createDefinitionEnvelopeFailure(\n  code: DefinitionEnvelopeShapeFailureCode,\n  options: { readonly message?: string; readonly path: string },\n): DefinitionEnvelopeShapeFailure {\n  return {\n    code,\n    message: options.message ?? getDefinitionEnvelopeFailureMessage(code),\n    path: options.path,\n    severity: \"error\",\n  };\n}\n\nfunction getDefinitionEnvelopeFailureMessage(\n  code: DefinitionEnvelopeShapeFailureCode,\n) {\n  switch (code) {\n    case \"definition_envelope_not_json\":\n      return \"definition envelope must be portable JSON data\";\n    case \"definition_envelope_not_object\":\n      return \"definition envelope must be a JSON object\";\n    case \"generator_type_missing\":\n      return \"type is required\";\n    case \"generator_type_invalid\":\n      return \"type must be a non-empty string\";\n    case \"configuration_missing\":\n      return \"configuration is required\";\n    case \"configuration_invalid\":\n      return \"configuration must be a JSON object\";\n    case \"name_invalid\":\n      return \"name must be a string when present\";\n    case \"description_invalid\":\n      return \"description must be a string when present\";\n    case \"top_level_property_unknown\":\n      return \"unknown top-level properties are not allowed\";\n  }\n}\n\nfunction findDefinitionEnvelopeStringFieldFailure(\n  value: Record<string, unknown>,\n  options: {\n    readonly invalidCode: DefinitionEnvelopeShapeFailureCode;\n    readonly path: string;\n    readonly property: string;\n  },\n): DefinitionEnvelopeShapeFailure | undefined {\n  if (!Object.hasOwn(value, options.property)) {\n    return undefined;\n  }\n\n  return typeof value[options.property] === \"string\"\n    ? undefined\n    : createDefinitionEnvelopeFailure(options.invalidCode, {\n        path: options.path,\n      });\n}\n\nfunction appendPathSegment(path: string, segment: string) {\n  return path === \"$\" ? `$.${segment}` : `${path}.${segment}`;\n}\n\nfunction isJsonRecord(value: unknown): value is Record<string, unknown> {\n  const prototype =\n    typeof value === \"object\" && value !== null\n      ? Object.getPrototypeOf(value)\n      : undefined;\n\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    (prototype === null || prototype === Object.prototype)\n  );\n}\n\nfunction findJsonObjectError(\n  value: object,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  if (ancestors.has(value)) {\n    return { path, reason: \"cyclic objects are not JSON-compatible\" };\n  }\n\n  if (hasCallableToJson(value)) {\n    return { path, reason: \"objects with toJSON behavior are not portable\" };\n  }\n\n  ancestors.add(value);\n  const error = Array.isArray(value)\n    ? findJsonArrayError(value, path, ancestors)\n    : findJsonRecordError(value, path, ancestors);\n  ancestors.delete(value);\n\n  return error;\n}\n\nfunction hasCallableToJson(value: object) {\n  return (\n    \"toJSON\" in value &&\n    typeof (value as { readonly toJSON?: unknown }).toJSON === \"function\"\n  );\n}\n\nfunction findJsonArrayError(\n  value: readonly unknown[],\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  const extraProperty = Object.keys(value).find((key) => !isArrayIndexKey(key));\n\n  if (extraProperty !== undefined) {\n    return {\n      path: `${path}.${extraProperty}`,\n      reason: \"array object properties would be omitted from JSON\",\n    };\n  }\n\n  const ownPropertyError = findUnsupportedOwnProperty(value, path, [\"length\"]);\n\n  if (ownPropertyError !== undefined) {\n    return ownPropertyError;\n  }\n\n  for (let index = 0; index < value.length; index += 1) {\n    if (!(index in value)) {\n      return {\n        path: `${path}[${index}]`,\n        reason: \"sparse array slots are not JSON-compatible\",\n      };\n    }\n\n    const itemError = findJsonValueErrorInternal(\n      value[index],\n      `${path}[${index}]`,\n      ancestors,\n    );\n\n    if (itemError !== undefined) {\n      return itemError;\n    }\n  }\n\n  return undefined;\n}\n\nfunction isArrayIndexKey(key: string) {\n  const index = Number(key);\n\n  return (\n    Number.isInteger(index) &&\n    index >= 0 &&\n    index < 2 ** 32 - 1 &&\n    String(index) === key\n  );\n}\n\nfunction findJsonRecordError(\n  value: object,\n  path: string,\n  ancestors: Set<object>,\n): { path: string; reason: string } | undefined {\n  const prototype = Object.getPrototypeOf(value);\n\n  if (prototype !== null && prototype !== Object.prototype) {\n    return { path, reason: \"object must be a plain JSON record\" };\n  }\n\n  const ownPropertyError = findUnsupportedOwnProperty(value, path);\n\n  if (ownPropertyError !== undefined) {\n    return ownPropertyError;\n  }\n\n  for (const key of Object.keys(value)) {\n    const itemError = findJsonValueErrorInternal(\n      (value as Record<string, unknown>)[key],\n      `${path}.${key}`,\n      ancestors,\n    );\n\n    if (itemError !== undefined) {\n      return itemError;\n    }\n  }\n\n  return undefined;\n}\n\nfunction findUnsupportedOwnProperty(\n  value: object,\n  path: string,\n  allowedNonEnumerableProperties: readonly string[] = [],\n): { path: string; reason: string } | undefined {\n  if (Object.getOwnPropertySymbols(value).length > 0) {\n    return { path, reason: \"symbol keys are not JSON-compatible\" };\n  }\n\n  const allowedNonEnumerable = new Set(allowedNonEnumerableProperties);\n  const descriptors = Object.getOwnPropertyDescriptors(value);\n\n  for (const [key, descriptor] of Object.entries(descriptors)) {\n    if (\"get\" in descriptor || \"set\" in descriptor) {\n      return {\n        path: `${path}.${key}`,\n        reason: \"accessor properties are not portable JSON data\",\n      };\n    }\n\n    if (!descriptor.enumerable && !allowedNonEnumerable.has(key)) {\n      return {\n        path: `${path}.${key}`,\n        reason: \"non-enumerable properties would be omitted from JSON\",\n      };\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["export type JsonPrimitive = boolean | null | number | string;\nexport type JsonValue = JsonArray | JsonObject | JsonPrimitive;\nexport type JsonArray = readonly JsonValue[];\nexport type JsonObject = { readonly [key: string]: JsonValue };\n\nexport type ValidationPathSegment = string | number;\nexport type ValidationPath = readonly ValidationPathSegment[];\nexport type ValidationIssue = {\n  readonly code: string;\n  readonly path: ValidationPath;\n  readonly message: string;\n  readonly details?: JsonObject;\n};\n\nexport const CURRENT_SCHEMA_VERSION = 1;\nexport const SUPPORTED_SCHEMA_VERSIONS = [CURRENT_SCHEMA_VERSION] as const;\nexport type SchemaVersion = (typeof SUPPORTED_SCHEMA_VERSIONS)[number];\n\n/** Portable executable generator data. Generator fields live beside `type`. */\nexport type GeneratorDefinition = JsonObject & { readonly type: string };\n\n/** Versioned document containing exactly one root generator definition. */\nexport type GeneratorDocumentV1 = {\n  readonly schemaVersion: 1;\n  readonly definition: GeneratorDefinition;\n  readonly name?: string;\n  readonly description?: string;\n};\n\nexport type GeneratorDocument = GeneratorDocumentV1;\n\n/** A stable, lowercase identifier used to classify portable metadata. */\nexport type SemanticMetadataId = string;\n\n/** A coarse output-preview classification, not an execution or inference type. */\nexport type GeneratorOutputCategory = SemanticMetadataId;\n\n/**\n * Portable, descriptive metadata for a generator implementation.\n * It is intentionally separate from executable generator definitions.\n */\nexport type GeneratorMetadata = {\n  readonly typeId?: SemanticMetadataId;\n  readonly displayName?: string;\n  readonly description?: string;\n  readonly category?: SemanticMetadataId;\n  readonly outputCategory?: GeneratorOutputCategory;\n  readonly documentationUrl?: string;\n  readonly examples?: readonly JsonValue[];\n};\n\nexport const GENERATOR_DOCUMENT_TOP_LEVEL_KEYS = [\n  \"schemaVersion\",\n  \"name\",\n  \"description\",\n  \"definition\",\n] as const;\n\nexport const GENERATOR_METADATA_KEYS = [\n  \"typeId\",\n  \"displayName\",\n  \"description\",\n  \"category\",\n  \"outputCategory\",\n  \"documentationUrl\",\n  \"examples\",\n] as const;\n\nconst DOCUMENT_METADATA_KEYS = new Set([\n  \"schemaVersion\",\n  \"name\",\n  \"description\",\n  \"owner\",\n  \"ownership\",\n  \"visibility\",\n  \"createdAt\",\n  \"updatedAt\",\n  \"timestamps\",\n]);\n\nexport type SchemaVersionFailureCode =\n  | \"schema_version_missing\"\n  | \"schema_version_unsupported\";\nexport type SchemaVersionFailure = {\n  readonly code: SchemaVersionFailureCode;\n  readonly message: string;\n  readonly path: ValidationPath;\n  readonly severity: \"error\";\n  readonly details: { readonly supportedVersions: readonly SchemaVersion[] };\n} & ValidationIssue;\n\nexport type GeneratorDefinitionFailureCode =\n  | \"generator_definition_not_json\"\n  | \"generator_definition_not_object\"\n  | \"generator_type_missing\"\n  | \"generator_type_invalid\"\n  | \"definition_document_metadata\";\nexport type GeneratorDefinitionFailure = {\n  readonly code: GeneratorDefinitionFailureCode;\n  readonly message: string;\n  readonly path: ValidationPath;\n  readonly severity: \"error\";\n};\n\nexport type GeneratorMetadataFailureCode =\n  | \"generator_metadata_not_json\"\n  | \"generator_metadata_not_object\"\n  | \"metadata_type_id_invalid\"\n  | \"metadata_display_name_invalid\"\n  | \"metadata_description_invalid\"\n  | \"metadata_category_invalid\"\n  | \"metadata_output_category_invalid\"\n  | \"metadata_documentation_url_invalid\"\n  | \"metadata_examples_invalid\"\n  | \"metadata_property_unknown\";\nexport type GeneratorMetadataFailure = {\n  readonly code: GeneratorMetadataFailureCode;\n  readonly message: string;\n  readonly path: ValidationPath;\n  readonly severity: \"error\";\n};\n\nexport type GeneratorDocumentFailureCode =\n  | SchemaVersionFailureCode\n  | GeneratorDefinitionFailureCode\n  | \"generator_document_not_json\"\n  | \"generator_document_not_object\"\n  | \"definition_missing\"\n  | \"name_invalid\"\n  | \"description_invalid\"\n  | \"top_level_property_unknown\"\n  | \"configuration_envelope_removed\";\nexport type GeneratorDocumentFailure =\n  | SchemaVersionFailure\n  | {\n      readonly code: Exclude<\n        GeneratorDocumentFailureCode,\n        SchemaVersionFailureCode\n      >;\n      readonly message: string;\n      readonly path: ValidationPath;\n      readonly severity: \"error\";\n    };\nexport type GeneratorDocumentParseResult =\n  | { readonly success: true; readonly value: GeneratorDocumentV1 }\n  | { readonly success: false; readonly failure: GeneratorDocumentFailure };\n\nexport class JsonValueError extends TypeError {\n  readonly issue: ValidationIssue;\n  constructor(path: ValidationPath, reason: string) {\n    super(`${formatValidationPath(path)}: ${reason}`);\n    this.name = \"JsonValueError\";\n    this.issue = { code: \"invalid_json_value\", path, message: reason };\n  }\n}\n\nexport class SchemaVersionError extends TypeError {\n  readonly failure: SchemaVersionFailure;\n  constructor(failure: SchemaVersionFailure) {\n    super(`${formatValidationPath(failure.path)}: ${failure.message}`);\n    this.name = \"SchemaVersionError\";\n    this.failure = failure;\n  }\n}\n\nexport class GeneratorDefinitionError extends TypeError {\n  readonly failure: GeneratorDefinitionFailure;\n  constructor(failure: GeneratorDefinitionFailure) {\n    super(`${formatValidationPath(failure.path)}: ${failure.message}`);\n    this.name = \"GeneratorDefinitionError\";\n    this.failure = failure;\n  }\n}\n\nexport class GeneratorMetadataError extends TypeError {\n  readonly failure: GeneratorMetadataFailure;\n  constructor(failure: GeneratorMetadataFailure) {\n    super(`${formatValidationPath(failure.path)}: ${failure.message}`);\n    this.name = \"GeneratorMetadataError\";\n    this.failure = failure;\n  }\n}\n\nexport class GeneratorDocumentError extends TypeError {\n  readonly failure: GeneratorDocumentFailure;\n  constructor(failure: GeneratorDocumentFailure) {\n    super(`${formatValidationPath(failure.path)}: ${failure.message}`);\n    this.name = \"GeneratorDocumentError\";\n    this.failure = failure;\n  }\n}\n\nexport function isJsonValue(value: unknown): value is JsonValue {\n  return validateJsonValue(value).length === 0;\n}\nexport function isSchemaVersion(value: unknown): value is SchemaVersion {\n  return value === CURRENT_SCHEMA_VERSION;\n}\nexport function isGeneratorDefinition(\n  value: unknown,\n): value is GeneratorDefinition {\n  return validateGeneratorDefinition(value).length === 0;\n}\nexport function isDocument(value: unknown): value is GeneratorDocumentV1 {\n  return validateDocument(value).length === 0;\n}\nexport function isGeneratorMetadata(\n  value: unknown,\n): value is GeneratorMetadata {\n  return validateGeneratorMetadata(value).length === 0;\n}\nexport function assertJsonValue(\n  value: unknown,\n  path: ValidationPath = [],\n): asserts value is JsonValue {\n  const [issue] = validateJsonValue(value, path);\n  if (issue !== undefined) throw new JsonValueError(issue.path, issue.message);\n}\nexport function assertSchemaVersion(\n  value: unknown,\n  path: ValidationPath = [\"schemaVersion\"],\n): asserts value is SchemaVersion {\n  const failure = findSchemaVersionValueFailure(value, path);\n  if (failure !== undefined) throw new SchemaVersionError(failure);\n}\nexport function assertGeneratorDefinition(\n  value: unknown,\n  path: ValidationPath = [],\n): asserts value is GeneratorDefinition {\n  const [failure] = validateGeneratorDefinition(value, path);\n  if (failure !== undefined) throw new GeneratorDefinitionError(failure);\n}\nexport function assertGeneratorMetadata(\n  value: unknown,\n  path: ValidationPath = [],\n): asserts value is GeneratorMetadata {\n  const [failure] = validateGeneratorMetadata(value, path);\n  if (failure !== undefined) throw new GeneratorMetadataError(failure);\n}\nexport function assertDocument(\n  value: unknown,\n  path: ValidationPath = [],\n): asserts value is GeneratorDocumentV1 {\n  const [issue] = validateDocument(value, path);\n  if (issue !== undefined) throw new GeneratorDocumentError(issue);\n}\nexport function parseDocument(\n  value: unknown,\n  path: ValidationPath = [],\n): GeneratorDocumentV1 {\n  assertDocument(value, path);\n  return value;\n}\nexport function safeParseDocument(\n  value: unknown,\n  path: ValidationPath = [],\n): GeneratorDocumentParseResult {\n  const [failure] = validateDocument(value, path);\n  return failure === undefined\n    ? { success: true, value: value as GeneratorDocumentV1 }\n    : { success: false, failure };\n}\n\nexport function validateJsonValue(\n  value: unknown,\n  path: ValidationPath = [],\n): readonly ValidationIssue[] {\n  const error = findJsonValueError(value, path);\n  return error === undefined\n    ? []\n    : [{ code: \"invalid_json_value\", path: error.path, message: error.reason }];\n}\n\nfunction findJsonValueError(\n  value: unknown,\n  path: ValidationPath,\n): { path: ValidationPath; reason: string } | undefined {\n  return findJsonValueErrorInternal(value, path, new Set());\n}\n\n/** Returns all independent document validation issues in deterministic order. */\nexport function validateDocument(\n  value: unknown,\n  path: ValidationPath = [],\n): readonly GeneratorDocumentFailure[] {\n  const jsonError = findJsonValueError(value, path);\n  if (jsonError !== undefined) {\n    return [\n      documentFailure(\n        \"generator_document_not_json\",\n        jsonError.path,\n        jsonError.reason,\n      ),\n    ];\n  }\n  if (!isJsonRecord(value)) {\n    return [documentFailure(\"generator_document_not_object\", path)];\n  }\n\n  const issues: GeneratorDocumentFailure[] = [];\n  if (Object.hasOwn(value, \"configuration\") && Object.hasOwn(value, \"type\")) {\n    issues.push(documentFailure(\"configuration_envelope_removed\", path));\n  }\n  for (const key of Object.keys(value)) {\n    if (!GENERATOR_DOCUMENT_TOP_LEVEL_KEYS.includes(key as never)) {\n      issues.push(\n        documentFailure(\n          \"top_level_property_unknown\",\n          appendPathSegment(path, key),\n          `Unknown top-level property: ${key}`,\n        ),\n      );\n    }\n  }\n\n  const versionFailure = findSchemaVersionFailure(value, path);\n  if (versionFailure !== undefined) issues.push(versionFailure);\n  for (const property of [\"name\", \"description\"] as const) {\n    if (Object.hasOwn(value, property) && typeof value[property] !== \"string\") {\n      issues.push(\n        documentFailure(\n          property === \"name\" ? \"name_invalid\" : \"description_invalid\",\n          appendPathSegment(path, property),\n        ),\n      );\n    }\n  }\n  if (!Object.hasOwn(value, \"definition\")) {\n    issues.push(\n      documentFailure(\n        \"definition_missing\",\n        appendPathSegment(path, \"definition\"),\n      ),\n    );\n  } else {\n    issues.push(\n      ...validateGeneratorDefinition(\n        value.definition,\n        appendPathSegment(path, \"definition\"),\n      ),\n    );\n  }\n  return issues;\n}\n\n/** Returns definition issues. Nested typed definitions are validated recursively. */\nexport function validateGeneratorDefinition(\n  value: unknown,\n  path: ValidationPath = [],\n): readonly GeneratorDefinitionFailure[] {\n  const jsonError = findJsonValueError(value, path);\n  if (jsonError !== undefined) {\n    return [\n      definitionFailure(\n        \"generator_definition_not_json\",\n        jsonError.path,\n        jsonError.reason,\n      ),\n    ];\n  }\n  if (!isJsonRecord(value)) {\n    return [definitionFailure(\"generator_definition_not_object\", path)];\n  }\n\n  const issues: GeneratorDefinitionFailure[] = [];\n  collectDefinitionMetadataIssues(value as JsonObject, path, issues, true);\n  return issues;\n}\nexport function validateGeneratorMetadata(\n  value: unknown,\n  path: ValidationPath = [],\n): readonly GeneratorMetadataFailure[] {\n  const failure = findGeneratorMetadataFailure(value, path);\n  return failure === undefined ? [] : [failure];\n}\n\nfunction findGeneratorMetadataFailure(\n  value: unknown,\n  path: ValidationPath = [],\n): GeneratorMetadataFailure | undefined {\n  const jsonError = findJsonValueError(value, path);\n  if (jsonError !== undefined) {\n    return metadataFailure(\n      \"generator_metadata_not_json\",\n      jsonError.path,\n      jsonError.reason,\n    );\n  }\n  if (!isJsonRecord(value)) {\n    return metadataFailure(\"generator_metadata_not_object\", path);\n  }\n\n  const unknownKey = Object.keys(value).find(\n    (key) => !GENERATOR_METADATA_KEYS.includes(key as never),\n  );\n  if (unknownKey !== undefined) {\n    return metadataFailure(\n      \"metadata_property_unknown\",\n      appendPathSegment(path, unknownKey),\n      `Unknown metadata property: ${unknownKey}`,\n    );\n  }\n\n  for (const property of [\"typeId\", \"category\", \"outputCategory\"] as const) {\n    if (\n      Object.hasOwn(value, property) &&\n      (typeof value[property] !== \"string\" || !isMetadataId(value[property]))\n    ) {\n      const code =\n        property === \"typeId\"\n          ? \"metadata_type_id_invalid\"\n          : property === \"category\"\n            ? \"metadata_category_invalid\"\n            : \"metadata_output_category_invalid\";\n      return metadataFailure(code, appendPathSegment(path, property));\n    }\n  }\n\n  for (const property of [\n    \"displayName\",\n    \"description\",\n    \"documentationUrl\",\n  ] as const) {\n    if (Object.hasOwn(value, property) && typeof value[property] !== \"string\") {\n      const code =\n        property === \"displayName\"\n          ? \"metadata_display_name_invalid\"\n          : property === \"description\"\n            ? \"metadata_description_invalid\"\n            : \"metadata_documentation_url_invalid\";\n      return metadataFailure(code, appendPathSegment(path, property));\n    }\n  }\n\n  if (Object.hasOwn(value, \"examples\") && !Array.isArray(value.examples)) {\n    return metadataFailure(\n      \"metadata_examples_invalid\",\n      appendPathSegment(path, \"examples\"),\n    );\n  }\n\n  return undefined;\n}\nfunction findSchemaVersionFailure(\n  value: unknown,\n  path: ValidationPath = [],\n): SchemaVersionFailure | undefined {\n  if (!isJsonRecord(value) || !Object.hasOwn(value, \"schemaVersion\"))\n    return createSchemaVersionFailure(\n      \"schema_version_missing\",\n      appendPathSegment(path, \"schemaVersion\"),\n    );\n  return findSchemaVersionValueFailure(\n    value.schemaVersion,\n    appendPathSegment(path, \"schemaVersion\"),\n  );\n}\nfunction findSchemaVersionValueFailure(\n  value: unknown,\n  path: ValidationPath = [\"schemaVersion\"],\n): SchemaVersionFailure | undefined {\n  return isSchemaVersion(value)\n    ? undefined\n    : createSchemaVersionFailure(\"schema_version_unsupported\", path);\n}\n\nfunction createSchemaVersionFailure(\n  code: SchemaVersionFailureCode,\n  path: ValidationPath,\n): SchemaVersionFailure {\n  return {\n    code,\n    message:\n      code === \"schema_version_missing\"\n        ? `schemaVersion is required and must be ${CURRENT_SCHEMA_VERSION}`\n        : `schemaVersion must be ${CURRENT_SCHEMA_VERSION}`,\n    path,\n    severity: \"error\",\n    details: { supportedVersions: SUPPORTED_SCHEMA_VERSIONS },\n  };\n}\nfunction definitionFailure(\n  code: GeneratorDefinitionFailureCode,\n  path: ValidationPath,\n  message?: string,\n): GeneratorDefinitionFailure {\n  const messages: Record<GeneratorDefinitionFailureCode, string> = {\n    generator_definition_not_json:\n      \"generator definition must be portable JSON data\",\n    generator_definition_not_object:\n      \"generator definition must be a JSON object\",\n    generator_type_missing: \"type is required\",\n    generator_type_invalid: \"type must be a non-empty string\",\n    definition_document_metadata:\n      \"document metadata is not allowed in a generator definition\",\n  };\n  return { code, message: message ?? messages[code], path, severity: \"error\" };\n}\nfunction metadataFailure(\n  code: GeneratorMetadataFailureCode,\n  path: ValidationPath,\n  message?: string,\n): GeneratorMetadataFailure {\n  const messages: Record<GeneratorMetadataFailureCode, string> = {\n    generator_metadata_not_json:\n      \"generator metadata must be portable JSON data\",\n    generator_metadata_not_object: \"generator metadata must be a JSON object\",\n    metadata_type_id_invalid: \"typeId must be a stable metadata ID\",\n    metadata_display_name_invalid: \"displayName must be a string when present\",\n    metadata_description_invalid: \"description must be a string when present\",\n    metadata_category_invalid: \"category must be a stable metadata ID\",\n    metadata_output_category_invalid:\n      \"outputCategory must be a stable metadata ID\",\n    metadata_documentation_url_invalid:\n      \"documentationUrl must be a string when present\",\n    metadata_examples_invalid: \"examples must be an array when present\",\n    metadata_property_unknown: \"unknown metadata properties are not allowed\",\n  };\n  return { code, message: message ?? messages[code], path, severity: \"error\" };\n}\nfunction documentFailure(\n  code: Exclude<GeneratorDocumentFailureCode, SchemaVersionFailureCode>,\n  path: ValidationPath,\n  message?: string,\n): Exclude<GeneratorDocumentFailure, SchemaVersionFailure> {\n  const messages: Record<\n    Exclude<GeneratorDocumentFailureCode, SchemaVersionFailureCode>,\n    string\n  > = {\n    generator_document_not_json:\n      \"generator document must be portable JSON data\",\n    generator_document_not_object: \"generator document must be a JSON object\",\n    generator_definition_not_json:\n      \"generator definition must be portable JSON data\",\n    generator_definition_not_object:\n      \"generator definition must be a JSON object\",\n    generator_type_missing: \"type is required\",\n    generator_type_invalid: \"type must be a non-empty string\",\n    definition_document_metadata:\n      \"document metadata is not allowed in a generator definition\",\n    definition_missing: \"definition is required\",\n    name_invalid: \"name must be a string when present\",\n    description_invalid: \"description must be a string when present\",\n    top_level_property_unknown: \"unknown top-level properties are not allowed\",\n    configuration_envelope_removed:\n      \"The configuration envelope was removed; put generator fields directly inside definition.\",\n  };\n  return { code, message: message ?? messages[code], path, severity: \"error\" };\n}\nfunction appendPathSegment(\n  path: ValidationPath,\n  segment: ValidationPathSegment,\n): ValidationPath {\n  return [...path, segment];\n}\n\nfunction formatValidationPath(path: ValidationPath) {\n  return path.length === 0\n    ? \"$\"\n    : path\n        .map((segment) =>\n          typeof segment === \"number\" ? `[${segment}]` : `.${segment}`,\n        )\n        .join(\"\")\n        .replace(/^\\./u, \"$\");\n}\n\nfunction isMetadataId(value: string) {\n  return /^[a-z][a-z0-9]*(?:[._-][a-z0-9]+)*$/u.test(value);\n}\n\nfunction collectDefinitionMetadataIssues(\n  value: JsonObject,\n  path: ValidationPath,\n  issues: GeneratorDefinitionFailure[],\n  isDefinition: boolean,\n): void {\n  if (isDefinition) {\n    if (!Object.hasOwn(value, \"type\")) {\n      issues.push(\n        definitionFailure(\n          \"generator_type_missing\",\n          appendPathSegment(path, \"type\"),\n        ),\n      );\n    } else if (\n      typeof value.type !== \"string\" ||\n      value.type.trim().length === 0\n    ) {\n      issues.push(\n        definitionFailure(\n          \"generator_type_invalid\",\n          appendPathSegment(path, \"type\"),\n        ),\n      );\n    }\n    for (const key of Object.keys(value)) {\n      if (key !== \"type\" && DOCUMENT_METADATA_KEYS.has(key)) {\n        issues.push(\n          definitionFailure(\n            \"definition_document_metadata\",\n            appendPathSegment(path, key),\n          ),\n        );\n      }\n    }\n  }\n\n  for (const [key, child] of Object.entries(value)) {\n    if (key === \"type\") continue;\n    collectNestedDefinitionMetadataIssues(\n      child,\n      appendPathSegment(path, key),\n      issues,\n    );\n  }\n}\n\nfunction collectNestedDefinitionMetadataIssues(\n  value: JsonValue,\n  path: ValidationPath,\n  issues: GeneratorDefinitionFailure[],\n): void {\n  if (Array.isArray(value)) {\n    for (let index = 0; index < value.length; index += 1) {\n      collectNestedDefinitionMetadataIssues(\n        value[index],\n        appendPathSegment(path, index),\n        issues,\n      );\n    }\n    return;\n  }\n  if (!isJsonRecord(value)) return;\n  collectDefinitionMetadataIssues(\n    value,\n    path,\n    issues,\n    Object.hasOwn(value, \"type\"),\n  );\n}\n\nfunction isJsonRecord(value: unknown): value is Record<string, unknown> {\n  const prototype =\n    typeof value === \"object\" && value !== null\n      ? Object.getPrototypeOf(value)\n      : undefined;\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    !Array.isArray(value) &&\n    (prototype === null || prototype === Object.prototype)\n  );\n}\nfunction findJsonValueErrorInternal(\n  value: unknown,\n  path: ValidationPath,\n  ancestors: Set<object>,\n): { path: ValidationPath; reason: string } | undefined {\n  switch (typeof value) {\n    case \"boolean\":\n    case \"string\":\n      return undefined;\n    case \"number\":\n      if (!Number.isFinite(value))\n        return { path, reason: \"number must be finite\" };\n      return Object.is(value, -0)\n        ? { path, reason: \"number must not be negative zero\" }\n        : undefined;\n    case \"object\":\n      return value === null\n        ? undefined\n        : findJsonObjectError(value, path, ancestors);\n    case \"bigint\":\n    case \"function\":\n    case \"symbol\":\n    case \"undefined\":\n      return { path, reason: `${typeof value} is not JSON-compatible` };\n  }\n}\nfunction findJsonObjectError(\n  value: object,\n  path: ValidationPath,\n  ancestors: Set<object>,\n): { path: ValidationPath; reason: string } | undefined {\n  if (ancestors.has(value))\n    return { path, reason: \"cyclic objects are not JSON-compatible\" };\n  if (\n    \"toJSON\" in value &&\n    typeof (value as { readonly toJSON?: unknown }).toJSON === \"function\"\n  )\n    return { path, reason: \"objects with toJSON behavior are not portable\" };\n  ancestors.add(value);\n  const error = Array.isArray(value)\n    ? findJsonArrayError(value, path, ancestors)\n    : findJsonRecordError(value, path, ancestors);\n  ancestors.delete(value);\n  return error;\n}\nfunction findJsonArrayError(\n  value: readonly unknown[],\n  path: ValidationPath,\n  ancestors: Set<object>,\n): { path: ValidationPath; reason: string } | undefined {\n  const extraProperty = Object.keys(value).find((key) => !isArrayIndexKey(key));\n  if (extraProperty !== undefined)\n    return {\n      path: appendPathSegment(path, extraProperty),\n      reason: \"array object properties would be omitted from JSON\",\n    };\n  const propertyError = findUnsupportedOwnProperty(value, path, [\"length\"]);\n  if (propertyError !== undefined) return propertyError;\n  for (let index = 0; index < value.length; index += 1) {\n    if (!(index in value))\n      return {\n        path: appendPathSegment(path, index),\n        reason: \"sparse array slots are not JSON-compatible\",\n      };\n    const itemError = findJsonValueErrorInternal(\n      value[index],\n      appendPathSegment(path, index),\n      ancestors,\n    );\n    if (itemError !== undefined) return itemError;\n  }\n  return undefined;\n}\nfunction isArrayIndexKey(key: string) {\n  const index = Number(key);\n  return (\n    Number.isInteger(index) &&\n    index >= 0 &&\n    index < 2 ** 32 - 1 &&\n    String(index) === key\n  );\n}\nfunction findJsonRecordError(\n  value: object,\n  path: ValidationPath,\n  ancestors: Set<object>,\n): { path: ValidationPath; reason: string } | undefined {\n  const prototype = Object.getPrototypeOf(value);\n  if (prototype !== null && prototype !== Object.prototype)\n    return { path, reason: \"object must be a plain JSON record\" };\n  const propertyError = findUnsupportedOwnProperty(value, path);\n  if (propertyError !== undefined) return propertyError;\n  for (const key of Object.keys(value)) {\n    const itemError = findJsonValueErrorInternal(\n      (value as Record<string, unknown>)[key],\n      appendPathSegment(path, key),\n      ancestors,\n    );\n    if (itemError !== undefined) return itemError;\n  }\n  return undefined;\n}\nfunction findUnsupportedOwnProperty(\n  value: object,\n  path: ValidationPath,\n  allowedNonEnumerableProperties: readonly string[] = [],\n): { path: ValidationPath; reason: string } | undefined {\n  if (Object.hasOwn(value, \"__proto__\")) {\n    return {\n      path: appendPathSegment(path, \"__proto__\"),\n      reason: \"__proto__ keys are not portable JSON data\",\n    };\n  }\n  if (Object.getOwnPropertySymbols(value).length > 0)\n    return { path, reason: \"symbol keys are not JSON-compatible\" };\n  const allowed = new Set(allowedNonEnumerableProperties);\n  for (const [key, descriptor] of Object.entries(\n    Object.getOwnPropertyDescriptors(value),\n  )) {\n    if (\"get\" in descriptor || \"set\" in descriptor)\n      return {\n        path: appendPathSegment(path, key),\n        reason: \"accessor properties are not portable JSON data\",\n      };\n    if (!descriptor.enumerable && !allowed.has(key))\n      return {\n        path: appendPathSegment(path, key),\n        reason: \"non-enumerable properties would be omitted from JSON\",\n      };\n  }\n  return undefined;\n}\n"],"mappings":";AAcA,MAAa,yBAAyB;AACtC,MAAa,4BAA4B,CAAA,CAAuB;AAoChE,MAAa,oCAAoC;CAC/C;CACA;CACA;CACA;AACF;AAEA,MAAa,0BAA0B;CACrC;CACA;CACA;CACA;CACA;CACA;CACA;AACF;AAEA,MAAM,yCAAyB,IAAI,IAAI;CACrC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAqED,IAAa,iBAAb,cAAoC,UAAU;CAC5C;CACA,YAAY,MAAsB,QAAgB;EAChD,MAAM,GAAG,qBAAqB,IAAI,EAAE,IAAI,QAAQ;EAChD,KAAK,OAAO;EACZ,KAAK,QAAQ;GAAE,MAAM;GAAsB;GAAM,SAAS;EAAO;CACnE;AACF;AAEA,IAAa,qBAAb,cAAwC,UAAU;CAChD;CACA,YAAY,SAA+B;EACzC,MAAM,GAAG,qBAAqB,QAAQ,IAAI,EAAE,IAAI,QAAQ,SAAS;EACjE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,2BAAb,cAA8C,UAAU;CACtD;CACA,YAAY,SAAqC;EAC/C,MAAM,GAAG,qBAAqB,QAAQ,IAAI,EAAE,IAAI,QAAQ,SAAS;EACjE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,yBAAb,cAA4C,UAAU;CACpD;CACA,YAAY,SAAmC;EAC7C,MAAM,GAAG,qBAAqB,QAAQ,IAAI,EAAE,IAAI,QAAQ,SAAS;EACjE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,IAAa,yBAAb,cAA4C,UAAU;CACpD;CACA,YAAY,SAAmC;EAC7C,MAAM,GAAG,qBAAqB,QAAQ,IAAI,EAAE,IAAI,QAAQ,SAAS;EACjE,KAAK,OAAO;EACZ,KAAK,UAAU;CACjB;AACF;AAEA,SAAgB,YAAY,OAAoC;CAC9D,OAAO,kBAAkB,KAAK,CAAC,CAAC,WAAW;AAC7C;AACA,SAAgB,gBAAgB,OAAwC;CACtE,OAAO,UAAA;AACT;AACA,SAAgB,sBACd,OAC8B;CAC9B,OAAO,4BAA4B,KAAK,CAAC,CAAC,WAAW;AACvD;AACA,SAAgB,WAAW,OAA8C;CACvE,OAAO,iBAAiB,KAAK,CAAC,CAAC,WAAW;AAC5C;AACA,SAAgB,oBACd,OAC4B;CAC5B,OAAO,0BAA0B,KAAK,CAAC,CAAC,WAAW;AACrD;AACA,SAAgB,gBACd,OACA,OAAuB,CAAC,GACI;CAC5B,MAAM,CAAC,SAAS,kBAAkB,OAAO,IAAI;CAC7C,IAAI,UAAU,KAAA,GAAW,MAAM,IAAI,eAAe,MAAM,MAAM,MAAM,OAAO;AAC7E;AACA,SAAgB,oBACd,OACA,OAAuB,CAAC,eAAe,GACP;CAChC,MAAM,UAAU,8BAA8B,OAAO,IAAI;CACzD,IAAI,YAAY,KAAA,GAAW,MAAM,IAAI,mBAAmB,OAAO;AACjE;AACA,SAAgB,0BACd,OACA,OAAuB,CAAC,GACc;CACtC,MAAM,CAAC,WAAW,4BAA4B,OAAO,IAAI;CACzD,IAAI,YAAY,KAAA,GAAW,MAAM,IAAI,yBAAyB,OAAO;AACvE;AACA,SAAgB,wBACd,OACA,OAAuB,CAAC,GACY;CACpC,MAAM,CAAC,WAAW,0BAA0B,OAAO,IAAI;CACvD,IAAI,YAAY,KAAA,GAAW,MAAM,IAAI,uBAAuB,OAAO;AACrE;AACA,SAAgB,eACd,OACA,OAAuB,CAAC,GACc;CACtC,MAAM,CAAC,SAAS,iBAAiB,OAAO,IAAI;CAC5C,IAAI,UAAU,KAAA,GAAW,MAAM,IAAI,uBAAuB,KAAK;AACjE;AACA,SAAgB,cACd,OACA,OAAuB,CAAC,GACH;CACrB,eAAe,OAAO,IAAI;CAC1B,OAAO;AACT;AACA,SAAgB,kBACd,OACA,OAAuB,CAAC,GACM;CAC9B,MAAM,CAAC,WAAW,iBAAiB,OAAO,IAAI;CAC9C,OAAO,YAAY,KAAA,IACf;EAAE,SAAS;EAAa;CAA6B,IACrD;EAAE,SAAS;EAAO;CAAQ;AAChC;AAEA,SAAgB,kBACd,OACA,OAAuB,CAAC,GACI;CAC5B,MAAM,QAAQ,mBAAmB,OAAO,IAAI;CAC5C,OAAO,UAAU,KAAA,IACb,CAAC,IACD,CAAC;EAAE,MAAM;EAAsB,MAAM,MAAM;EAAM,SAAS,MAAM;CAAO,CAAC;AAC9E;AAEA,SAAS,mBACP,OACA,MACsD;CACtD,OAAO,2BAA2B,OAAO,sBAAM,IAAI,IAAI,CAAC;AAC1D;;AAGA,SAAgB,iBACd,OACA,OAAuB,CAAC,GACa;CACrC,MAAM,YAAY,mBAAmB,OAAO,IAAI;CAChD,IAAI,cAAc,KAAA,GAChB,OAAO,CACL,gBACE,+BACA,UAAU,MACV,UAAU,MACZ,CACF;CAEF,IAAI,CAAC,aAAa,KAAK,GACrB,OAAO,CAAC,gBAAgB,iCAAiC,IAAI,CAAC;CAGhE,MAAM,SAAqC,CAAC;CAC5C,IAAI,OAAO,OAAO,OAAO,eAAe,KAAK,OAAO,OAAO,OAAO,MAAM,GACtE,OAAO,KAAK,gBAAgB,kCAAkC,IAAI,CAAC;CAErE,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GACjC,IAAI,CAAC,kCAAkC,SAAS,GAAY,GAC1D,OAAO,KACL,gBACE,8BACA,kBAAkB,MAAM,GAAG,GAC3B,+BAA+B,KACjC,CACF;CAIJ,MAAM,iBAAiB,yBAAyB,OAAO,IAAI;CAC3D,IAAI,mBAAmB,KAAA,GAAW,OAAO,KAAK,cAAc;CAC5D,KAAK,MAAM,YAAY,CAAC,QAAQ,aAAa,GAC3C,IAAI,OAAO,OAAO,OAAO,QAAQ,KAAK,OAAO,MAAM,cAAc,UAC/D,OAAO,KACL,gBACE,aAAa,SAAS,iBAAiB,uBACvC,kBAAkB,MAAM,QAAQ,CAClC,CACF;CAGJ,IAAI,CAAC,OAAO,OAAO,OAAO,YAAY,GACpC,OAAO,KACL,gBACE,sBACA,kBAAkB,MAAM,YAAY,CACtC,CACF;MAEA,OAAO,KACL,GAAG,4BACD,MAAM,YACN,kBAAkB,MAAM,YAAY,CACtC,CACF;CAEF,OAAO;AACT;;AAGA,SAAgB,4BACd,OACA,OAAuB,CAAC,GACe;CACvC,MAAM,YAAY,mBAAmB,OAAO,IAAI;CAChD,IAAI,cAAc,KAAA,GAChB,OAAO,CACL,kBACE,iCACA,UAAU,MACV,UAAU,MACZ,CACF;CAEF,IAAI,CAAC,aAAa,KAAK,GACrB,OAAO,CAAC,kBAAkB,mCAAmC,IAAI,CAAC;CAGpE,MAAM,SAAuC,CAAC;CAC9C,gCAAgC,OAAqB,MAAM,QAAQ,IAAI;CACvE,OAAO;AACT;AACA,SAAgB,0BACd,OACA,OAAuB,CAAC,GACa;CACrC,MAAM,UAAU,6BAA6B,OAAO,IAAI;CACxD,OAAO,YAAY,KAAA,IAAY,CAAC,IAAI,CAAC,OAAO;AAC9C;AAEA,SAAS,6BACP,OACA,OAAuB,CAAC,GACc;CACtC,MAAM,YAAY,mBAAmB,OAAO,IAAI;CAChD,IAAI,cAAc,KAAA,GAChB,OAAO,gBACL,+BACA,UAAU,MACV,UAAU,MACZ;CAEF,IAAI,CAAC,aAAa,KAAK,GACrB,OAAO,gBAAgB,iCAAiC,IAAI;CAG9D,MAAM,aAAa,OAAO,KAAK,KAAK,CAAC,CAAC,MACnC,QAAQ,CAAC,wBAAwB,SAAS,GAAY,CACzD;CACA,IAAI,eAAe,KAAA,GACjB,OAAO,gBACL,6BACA,kBAAkB,MAAM,UAAU,GAClC,8BAA8B,YAChC;CAGF,KAAK,MAAM,YAAY;EAAC;EAAU;EAAY;CAAgB,GAC5D,IACE,OAAO,OAAO,OAAO,QAAQ,MAC5B,OAAO,MAAM,cAAc,YAAY,CAAC,aAAa,MAAM,SAAS,IAQrE,OAAO,gBALL,aAAa,WACT,6BACA,aAAa,aACX,8BACA,oCACqB,kBAAkB,MAAM,QAAQ,CAAC;CAIlE,KAAK,MAAM,YAAY;EACrB;EACA;EACA;CACF,GACE,IAAI,OAAO,OAAO,OAAO,QAAQ,KAAK,OAAO,MAAM,cAAc,UAO/D,OAAO,gBALL,aAAa,gBACT,kCACA,aAAa,gBACX,iCACA,sCACqB,kBAAkB,MAAM,QAAQ,CAAC;CAIlE,IAAI,OAAO,OAAO,OAAO,UAAU,KAAK,CAAC,MAAM,QAAQ,MAAM,QAAQ,GACnE,OAAO,gBACL,6BACA,kBAAkB,MAAM,UAAU,CACpC;AAIJ;AACA,SAAS,yBACP,OACA,OAAuB,CAAC,GACU;CAClC,IAAI,CAAC,aAAa,KAAK,KAAK,CAAC,OAAO,OAAO,OAAO,eAAe,GAC/D,OAAO,2BACL,0BACA,kBAAkB,MAAM,eAAe,CACzC;CACF,OAAO,8BACL,MAAM,eACN,kBAAkB,MAAM,eAAe,CACzC;AACF;AACA,SAAS,8BACP,OACA,OAAuB,CAAC,eAAe,GACL;CAClC,OAAO,gBAAgB,KAAK,IACxB,KAAA,IACA,2BAA2B,8BAA8B,IAAI;AACnE;AAEA,SAAS,2BACP,MACA,MACsB;CACtB,OAAO;EACL;EACA,SACE,SAAS,2BACL,4CACA;EACN;EACA,UAAU;EACV,SAAS,EAAE,mBAAmB,0BAA0B;CAC1D;AACF;AACA,SAAS,kBACP,MACA,MACA,SAC4B;CAW5B,OAAO;EAAE;EAAM,SAAS,WAAW;GATjC,+BACE;GACF,iCACE;GACF,wBAAwB;GACxB,wBAAwB;GACxB,8BACE;EAEsC,EAAE;EAAO;EAAM,UAAU;CAAQ;AAC7E;AACA,SAAS,gBACP,MACA,MACA,SAC0B;CAgB1B,OAAO;EAAE;EAAM,SAAS,WAAW;GAdjC,6BACE;GACF,+BAA+B;GAC/B,0BAA0B;GAC1B,+BAA+B;GAC/B,8BAA8B;GAC9B,2BAA2B;GAC3B,kCACE;GACF,oCACE;GACF,2BAA2B;GAC3B,2BAA2B;EAEa,EAAE;EAAO;EAAM,UAAU;CAAQ;AAC7E;AACA,SAAS,gBACP,MACA,MACA,SACyD;CAuBzD,OAAO;EAAE;EAAM,SAAS,WAAW;GAlBjC,6BACE;GACF,+BAA+B;GAC/B,+BACE;GACF,iCACE;GACF,wBAAwB;GACxB,wBAAwB;GACxB,8BACE;GACF,oBAAoB;GACpB,cAAc;GACd,qBAAqB;GACrB,4BAA4B;GAC5B,gCACE;EAEsC,EAAE;EAAO;EAAM,UAAU;CAAQ;AAC7E;AACA,SAAS,kBACP,MACA,SACgB;CAChB,OAAO,CAAC,GAAG,MAAM,OAAO;AAC1B;AAEA,SAAS,qBAAqB,MAAsB;CAClD,OAAO,KAAK,WAAW,IACnB,MACA,KACG,KAAK,YACJ,OAAO,YAAY,WAAW,IAAI,QAAQ,KAAK,IAAI,SACrD,CAAC,CACA,KAAK,EAAE,CAAC,CACR,QAAQ,QAAQ,GAAG;AAC5B;AAEA,SAAS,aAAa,OAAe;CACnC,OAAO,uCAAuC,KAAK,KAAK;AAC1D;AAEA,SAAS,gCACP,OACA,MACA,QACA,cACM;CACN,IAAI,cAAc;EAChB,IAAI,CAAC,OAAO,OAAO,OAAO,MAAM,GAC9B,OAAO,KACL,kBACE,0BACA,kBAAkB,MAAM,MAAM,CAChC,CACF;OACK,IACL,OAAO,MAAM,SAAS,YACtB,MAAM,KAAK,KAAK,CAAC,CAAC,WAAW,GAE7B,OAAO,KACL,kBACE,0BACA,kBAAkB,MAAM,MAAM,CAChC,CACF;EAEF,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GACjC,IAAI,QAAQ,UAAU,uBAAuB,IAAI,GAAG,GAClD,OAAO,KACL,kBACE,gCACA,kBAAkB,MAAM,GAAG,CAC7B,CACF;CAGN;CAEA,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAK,GAAG;EAChD,IAAI,QAAQ,QAAQ;EACpB,sCACE,OACA,kBAAkB,MAAM,GAAG,GAC3B,MACF;CACF;AACF;AAEA,SAAS,sCACP,OACA,MACA,QACM;CACN,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GACjD,sCACE,MAAM,QACN,kBAAkB,MAAM,KAAK,GAC7B,MACF;EAEF;CACF;CACA,IAAI,CAAC,aAAa,KAAK,GAAG;CAC1B,gCACE,OACA,MACA,QACA,OAAO,OAAO,OAAO,MAAM,CAC7B;AACF;AAEA,SAAS,aAAa,OAAkD;CACtE,MAAM,YACJ,OAAO,UAAU,YAAY,UAAU,OACnC,OAAO,eAAe,KAAK,IAC3B,KAAA;CACN,OACE,OAAO,UAAU,YACjB,UAAU,QACV,CAAC,MAAM,QAAQ,KAAK,MACnB,cAAc,QAAQ,cAAc,OAAO;AAEhD;AACA,SAAS,2BACP,OACA,MACA,WACsD;CACtD,QAAQ,OAAO,OAAf;EACE,KAAK;EACL,KAAK,UACH;EACF,KAAK;GACH,IAAI,CAAC,OAAO,SAAS,KAAK,GACxB,OAAO;IAAE;IAAM,QAAQ;GAAwB;GACjD,OAAO,OAAO,GAAG,OAAO,EAAE,IACtB;IAAE;IAAM,QAAQ;GAAmC,IACnD,KAAA;EACN,KAAK,UACH,OAAO,UAAU,OACb,KAAA,IACA,oBAAoB,OAAO,MAAM,SAAS;EAChD,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,aACH,OAAO;GAAE;GAAM,QAAQ,GAAG,OAAO,MAAM;EAAyB;CACpE;AACF;AACA,SAAS,oBACP,OACA,MACA,WACsD;CACtD,IAAI,UAAU,IAAI,KAAK,GACrB,OAAO;EAAE;EAAM,QAAQ;CAAyC;CAClE,IACE,YAAY,SACZ,OAAQ,MAAwC,WAAW,YAE3D,OAAO;EAAE;EAAM,QAAQ;CAAgD;CACzE,UAAU,IAAI,KAAK;CACnB,MAAM,QAAQ,MAAM,QAAQ,KAAK,IAC7B,mBAAmB,OAAO,MAAM,SAAS,IACzC,oBAAoB,OAAO,MAAM,SAAS;CAC9C,UAAU,OAAO,KAAK;CACtB,OAAO;AACT;AACA,SAAS,mBACP,OACA,MACA,WACsD;CACtD,MAAM,gBAAgB,OAAO,KAAK,KAAK,CAAC,CAAC,MAAM,QAAQ,CAAC,gBAAgB,GAAG,CAAC;CAC5E,IAAI,kBAAkB,KAAA,GACpB,OAAO;EACL,MAAM,kBAAkB,MAAM,aAAa;EAC3C,QAAQ;CACV;CACF,MAAM,gBAAgB,2BAA2B,OAAO,MAAM,CAAC,QAAQ,CAAC;CACxE,IAAI,kBAAkB,KAAA,GAAW,OAAO;CACxC,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS,GAAG;EACpD,IAAI,EAAE,SAAS,QACb,OAAO;GACL,MAAM,kBAAkB,MAAM,KAAK;GACnC,QAAQ;EACV;EACF,MAAM,YAAY,2BAChB,MAAM,QACN,kBAAkB,MAAM,KAAK,GAC7B,SACF;EACA,IAAI,cAAc,KAAA,GAAW,OAAO;CACtC;AAEF;AACA,SAAS,gBAAgB,KAAa;CACpC,MAAM,QAAQ,OAAO,GAAG;CACxB,OACE,OAAO,UAAU,KAAK,KACtB,SAAS,KACT,QAAQ,KAAK,KAAK,KAClB,OAAO,KAAK,MAAM;AAEtB;AACA,SAAS,oBACP,OACA,MACA,WACsD;CACtD,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,IAAI,cAAc,QAAQ,cAAc,OAAO,WAC7C,OAAO;EAAE;EAAM,QAAQ;CAAqC;CAC9D,MAAM,gBAAgB,2BAA2B,OAAO,IAAI;CAC5D,IAAI,kBAAkB,KAAA,GAAW,OAAO;CACxC,KAAK,MAAM,OAAO,OAAO,KAAK,KAAK,GAAG;EACpC,MAAM,YAAY,2BACf,MAAkC,MACnC,kBAAkB,MAAM,GAAG,GAC3B,SACF;EACA,IAAI,cAAc,KAAA,GAAW,OAAO;CACtC;AAEF;AACA,SAAS,2BACP,OACA,MACA,iCAAoD,CAAC,GACC;CACtD,IAAI,OAAO,OAAO,OAAO,WAAW,GAClC,OAAO;EACL,MAAM,kBAAkB,MAAM,WAAW;EACzC,QAAQ;CACV;CAEF,IAAI,OAAO,sBAAsB,KAAK,CAAC,CAAC,SAAS,GAC/C,OAAO;EAAE;EAAM,QAAQ;CAAsC;CAC/D,MAAM,UAAU,IAAI,IAAI,8BAA8B;CACtD,KAAK,MAAM,CAAC,KAAK,eAAe,OAAO,QACrC,OAAO,0BAA0B,KAAK,CACxC,GAAG;EACD,IAAI,SAAS,cAAc,SAAS,YAClC,OAAO;GACL,MAAM,kBAAkB,MAAM,GAAG;GACjC,QAAQ;EACV;EACF,IAAI,CAAC,WAAW,cAAc,CAAC,QAAQ,IAAI,GAAG,GAC5C,OAAO;GACL,MAAM,kBAAkB,MAAM,GAAG;GACjC,QAAQ;EACV;CACJ;AAEF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "constructa-schema",
-  "version": "0.0.4",
+  "version": "2.0.0",
   "description": "Portable schemas and types for Constructa generator definitions.",
   "private": false,
   "license": "MIT",