schemair 0.1.0 → 0.2.0

package/dist/index-4aMF0cTE.d.ts

@@ -0,0 +1,368 @@
+//#region src/spec/schema.d.ts
+/** JSON values allowed in opaque constraint arguments. */
+type JsonValue = null | boolean | number | string | JsonValue[] | {
+  [key: string]: JsonValue;
+};
+type PrimitiveName = 'string' | 'number' | 'boolean' | 'null';
+type LiteralValue = string | number | boolean;
+interface SchemaConstraint {
+  constraintPath: string[];
+  args?: JsonValue;
+}
+interface SchemaStringNode {
+  kind: 'primitive';
+  name: 'string';
+  semanticPath?: string[];
+  constraints?: SchemaConstraint[];
+}
+interface SchemaNumberNode {
+  kind: 'primitive';
+  name: 'number';
+  semanticPath?: string[];
+  constraints?: SchemaConstraint[];
+}
+interface SchemaBooleanNode {
+  kind: 'primitive';
+  name: 'boolean';
+}
+interface SchemaNullNode {
+  kind: 'primitive';
+  name: 'null';
+}
+type SchemaPrimitiveNode = SchemaStringNode | SchemaNumberNode | SchemaBooleanNode | SchemaNullNode;
+interface SchemaLiteralNode {
+  kind: 'literal';
+  literal: LiteralValue;
+}
+interface SchemaRecordField {
+  key: string;
+  schema: SchemaNode;
+  required?: boolean;
+  description?: string;
+}
+interface SchemaRecordNode {
+  kind: 'record';
+  fields: SchemaRecordField[];
+  additionalFields?: true | SchemaNode;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaArrayNode {
+  kind: 'array';
+  elementSchema: SchemaNode;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaTupleNode {
+  kind: 'tuple';
+  elementSchemas: SchemaNode[];
+}
+interface SchemaLiteralUnionNode {
+  kind: 'literalUnion';
+  values: [LiteralValue, LiteralValue, ...LiteralValue[]];
+}
+interface SchemaNullableNode {
+  kind: 'nullable';
+  value: SchemaNode;
+}
+interface SchemaTaggedUnionVariant {
+  key: string;
+  schema: SchemaRecordNode;
+  description?: string;
+}
+interface SchemaTaggedUnionNode {
+  kind: 'taggedUnion';
+  discriminator: string;
+  variants: SchemaTaggedUnionVariant[];
+}
+interface SchemaRefNode {
+  kind: 'ref';
+  refPath: string[];
+}
+interface SchemaSelfRefNode {
+  kind: 'selfRef';
+}
+/** Closed serializable SchemaIR contract model. */
+type SchemaNode = SchemaPrimitiveNode | SchemaLiteralNode | SchemaRecordNode | SchemaArrayNode | SchemaTupleNode | SchemaLiteralUnionNode | SchemaNullableNode | SchemaTaggedUnionNode | SchemaRefNode | SchemaSelfRefNode;
+//#endregion
+//#region src/spec/operation.d.ts
+type OperationBinaryMetadata = {
+  kind: 'mime';
+  value: string;
+};
+type OperationPayloadDefinition = StructuredOperationPayloadDefinition | {
+  kind: 'binary';
+  meta?: OperationBinaryMetadata;
+};
+interface OperationErrorDefinition {
+  description?: string;
+  data?: SchemaNode;
+}
+interface OperationChannelDefinition {
+  description?: string;
+  data?: OperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+}
+interface OperationDefinition {
+  description?: string;
+  input?: OperationPayloadDefinition;
+  output?: OperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+  emits?: Record<string, OperationChannelDefinition>;
+}
+/** Short model name used by migration-facing APIs. */
+type Operation = OperationDefinition;
+interface OperationContainerDefinition {
+  description?: string;
+  operations?: Record<string, OperationDefinition>;
+  containers?: Record<string, OperationContainerDefinition>;
+}
+interface StructuredOperationPayloadDefinition {
+  kind: 'structured';
+  schema: SchemaNode;
+}
+interface StructuredOperationChannelDefinition {
+  description?: string;
+  data?: StructuredOperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+}
+interface StructuredOperationDefinition {
+  description?: string;
+  input?: StructuredOperationPayloadDefinition;
+  output?: StructuredOperationPayloadDefinition;
+  errors?: Record<string, OperationErrorDefinition>;
+  emits?: Record<string, StructuredOperationChannelDefinition>;
+}
+interface StructuredOperationContainerDefinition {
+  description?: string;
+  operations?: Record<string, StructuredOperationDefinition>;
+  containers?: Record<string, StructuredOperationContainerDefinition>;
+}
+//#endregion
+//#region src/spec/expression.d.ts
+interface SchemaTypeVariableExpr {
+  kind: 'typeVar';
+  name: string;
+  extends?: SchemaTypeTerm;
+}
+interface SchemaTypeOpaqueHostExpr {
+  kind: 'opaqueHostType';
+  hostPath: string[];
+}
+interface SchemaTypeAbsentExpr {
+  kind: 'absent';
+}
+interface SchemaTypeNeverExpr {
+  kind: 'never';
+}
+interface SchemaTypeUnknownExpr {
+  kind: 'unknown';
+}
+interface SchemaTypeMaybeAbsentExpr {
+  kind: 'maybeAbsent';
+  value: SchemaTypeTerm;
+}
+interface SchemaTypeArrayExpr {
+  kind: 'arrayOf';
+  element: SchemaTypeTerm;
+  constraints?: SchemaConstraint[];
+}
+interface SchemaTypeTupleExpr {
+  kind: 'tupleOf';
+  elements: SchemaTypeTerm[];
+}
+interface SchemaTypeRecordExpr {
+  kind: 'recordOf';
+  fields: {
+    key: string;
+    value: SchemaTypeTerm;
+    required?: boolean;
+    description?: string;
+  }[];
+  additionalFields?: true | SchemaTypeTerm;
+  constraints?: SchemaConstraint[];
+}
+type SchemaFieldSelector = {
+  kind: 'all';
+} | {
+  kind: 'keys';
+  keys: string[];
+  onMissing: 'error' | 'ignore';
+};
+type SchemaVariantSelector = SchemaFieldSelector;
+interface SchemaTypeElementOfExpr {
+  kind: 'elementOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeValueOfExpr {
+  kind: 'valueOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeElementAtExpr {
+  kind: 'elementAt';
+  source: SchemaTypeTerm;
+  index: number;
+}
+interface SchemaTypeFieldOfExpr {
+  kind: 'fieldOf';
+  source: SchemaTypeTerm;
+  key: string;
+}
+interface SchemaTypeKeyOfExpr {
+  kind: 'keyOf';
+  source: SchemaTypeTerm;
+}
+interface SchemaTypeFieldsOfExpr {
+  kind: 'fieldsOf';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypePickFieldsExpr {
+  kind: 'pickFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeOmitFieldsExpr {
+  kind: 'omitFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypePartialFieldsExpr {
+  kind: 'partialFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeRequiredFieldsExpr {
+  kind: 'requiredFields';
+  source: SchemaTypeTerm;
+  fields: SchemaFieldSelector;
+}
+interface SchemaTypeMergeRecordsExpr {
+  kind: 'mergeRecords';
+  sources: SchemaTypeTerm[];
+  conflict: 'leftWins' | 'rightWins' | 'error';
+}
+interface SchemaTypeNullableExpr {
+  kind: 'nullableOf';
+  value: SchemaTypeTerm;
+}
+interface SchemaTypeTaggedUnionExpr {
+  kind: 'taggedUnionOf';
+  discriminator: string;
+  variants: {
+    key: string;
+    value: SchemaTypeTerm;
+    description?: string;
+  }[];
+}
+interface SchemaTypeIntersectExpr {
+  kind: 'intersect';
+  sources: SchemaTypeTerm[];
+}
+interface SchemaTypeRefineExpr {
+  kind: 'refine';
+  source: SchemaTypeTerm;
+  fields: {
+    key: string;
+    require?: true;
+    intersectWith?: SchemaTypeTerm;
+    addConstraints?: SchemaConstraint[];
+  }[];
+}
+interface SchemaTypeExcludeVariantsExpr {
+  kind: 'excludeVariants';
+  source: SchemaTypeTerm;
+  variants: SchemaVariantSelector;
+}
+interface SchemaTypeExtractVariantsExpr {
+  kind: 'extractVariants';
+  source: SchemaTypeTerm;
+  variants: SchemaVariantSelector;
+}
+type SchemaTypeExpr = SchemaTypeVariableExpr | SchemaTypeOpaqueHostExpr | SchemaTypeAbsentExpr | SchemaTypeNeverExpr | SchemaTypeUnknownExpr | SchemaTypeMaybeAbsentExpr | SchemaTypeArrayExpr | SchemaTypeTupleExpr | SchemaTypeRecordExpr | SchemaTypeElementOfExpr | SchemaTypeValueOfExpr | SchemaTypeElementAtExpr | SchemaTypeFieldOfExpr | SchemaTypeKeyOfExpr | SchemaTypeFieldsOfExpr | SchemaTypePickFieldsExpr | SchemaTypeOmitFieldsExpr | SchemaTypePartialFieldsExpr | SchemaTypeRequiredFieldsExpr | SchemaTypeMergeRecordsExpr | SchemaTypeNullableExpr | SchemaTypeTaggedUnionExpr | SchemaTypeIntersectExpr | SchemaTypeRefineExpr | SchemaTypeExcludeVariantsExpr | SchemaTypeExtractVariantsExpr;
+type SchemaTypeTerm = SchemaNode | SchemaTypeExpr;
+/** Short model name used by migration-facing APIs. */
+type Expression = SchemaTypeExpr;
+/** Kept here so consumers can share the JSON-compatible expression boundary. */
+type ExpressionArgument = JsonValue;
+//#endregion
+//#region src/spec/standard/paths.d.ts
+declare const STANDARD_SEMANTIC_PATHS: {
+  readonly string: {
+    readonly date: readonly ["std", "string", "date"];
+    readonly datetime: readonly ["std", "string", "datetime"];
+    readonly datetimeIso: readonly ["std", "string", "datetime", "iso"];
+    readonly email: readonly ["std", "string", "email"];
+    readonly url: readonly ["std", "string", "url"];
+    readonly ipV4: readonly ["std", "string", "ip", "v4"];
+    readonly ipV6: readonly ["std", "string", "ip", "v6"];
+    readonly uuid: readonly ["std", "string", "uuid"];
+    readonly uuidV4: readonly ["std", "string", "uuid", "v4"];
+    readonly json: readonly ["std", "string", "json"];
+    readonly base64: readonly ["std", "string", "base64"];
+    readonly base64url: readonly ["std", "string", "base64url"];
+    readonly hex: readonly ["std", "string", "hex"];
+    readonly decimal: readonly ["std", "string", "decimal"];
+    readonly bigint: readonly ["std", "string", "bigint"];
+    readonly secret: readonly ["std", "string", "secret"];
+    readonly token: readonly ["std", "string", "secret", "token"];
+    readonly password: readonly ["std", "string", "secret", "password"];
+  };
+  readonly number: {
+    readonly integer: readonly ["std", "number", "integer"];
+    readonly safeInteger: readonly ["std", "number", "safeInteger"];
+    readonly epochMillis: readonly ["std", "number", "epochMillis"];
+    readonly epochSeconds: readonly ["std", "number", "epochSeconds"];
+  };
+};
+declare const STANDARD_SEMANTIC_PATH_LIST: ReadonlyArray<readonly string[]>;
+declare const STANDARD_CONSTRAINT_PATHS: {
+  readonly string: {
+    readonly minLength: readonly ["std", "minLength"];
+    readonly maxLength: readonly ["std", "maxLength"];
+    readonly pattern: readonly ["std", "pattern"];
+  };
+  readonly number: {
+    readonly minimum: readonly ["std", "minimum"];
+    readonly maximum: readonly ["std", "maximum"];
+    readonly exclusiveMinimum: readonly ["std", "exclusiveMinimum"];
+    readonly exclusiveMaximum: readonly ["std", "exclusiveMaximum"];
+    readonly multipleOf: readonly ["std", "multipleOf"];
+  };
+  readonly array: {
+    readonly minItems: readonly ["std", "minItems"];
+    readonly maxItems: readonly ["std", "maxItems"];
+    readonly uniqueItems: readonly ["std", "uniqueItems"];
+  };
+  readonly record: {
+    readonly minProperties: readonly ["std", "minProperties"];
+    readonly maxProperties: readonly ["std", "maxProperties"];
+  };
+};
+declare const STANDARD_CONSTRAINT_PATH_LIST: ReadonlyArray<readonly string[]>;
+//#endregion
+//#region src/spec/standard/definitions.d.ts
+interface StandardSemanticDefinition {
+  path: readonly string[];
+  label: string;
+  description: string;
+  primitive: 'string' | 'number';
+  role: 'validation' | 'annotation';
+}
+interface StandardSemanticRelation {
+  source: readonly string[];
+  target: readonly string[];
+  kind: 'acceptedSetSubset';
+}
+interface StandardConstraintDefinition {
+  path: readonly string[];
+  label: string;
+  description: string;
+  target: 'string' | 'number' | 'array' | 'record';
+  argsType: 'number' | 'string' | 'boolean';
+  argsDomain: 'finiteNumber' | 'nonNegativeInteger' | 'positiveNumber' | 'regexSource' | 'boolean';
+}
+declare const STANDARD_SEMANTIC_DEFINITIONS: ReadonlyArray<StandardSemanticDefinition>;
+/** Explicit accepted-set implications; carrier types are not semantic paths. */
+declare const STANDARD_SEMANTIC_RELATIONS: ReadonlyArray<StandardSemanticRelation>;
+declare const STANDARD_CONSTRAINT_DEFINITIONS: ReadonlyArray<StandardConstraintDefinition>;
+//#endregion
+export { StructuredOperationPayloadDefinition as $, SchemaTypeOpaqueHostExpr as A, SchemaTypeValueOfExpr as B, SchemaTypeIntersectExpr as C, SchemaTypeNeverExpr as D, SchemaTypeMergeRecordsExpr as E, SchemaTypeRequiredFieldsExpr as F, OperationChannelDefinition as G, SchemaVariantSelector as H, SchemaTypeTaggedUnionExpr as I, OperationErrorDefinition as J, OperationContainerDefinition as K, SchemaTypeTerm as L, SchemaTypePickFieldsExpr as M, SchemaTypeRecordExpr as N, SchemaTypeNullableExpr as O, SchemaTypeRefineExpr as P, StructuredOperationDefinition as Q, SchemaTypeTupleExpr as R, SchemaTypeFieldsOfExpr as S, SchemaTypeMaybeAbsentExpr as T, Operation as U, SchemaTypeVariableExpr as V, OperationBinaryMetadata as W, StructuredOperationChannelDefinition as X, OperationPayloadDefinition as Y, StructuredOperationContainerDefinition as Z, SchemaTypeElementOfExpr as _, SchemaStringNode as _t, StandardSemanticDefinition as a, SchemaConstraint as at, SchemaTypeExtractVariantsExpr as b, SchemaTupleNode as bt, STANDARD_CONSTRAINT_PATH_LIST as c, SchemaNode as ct, Expression as d, SchemaNumberNode as dt, JsonValue as et, ExpressionArgument as f, SchemaPrimitiveNode as ft, SchemaTypeElementAtExpr as g, SchemaSelfRefNode as gt, SchemaTypeArrayExpr as h, SchemaRefNode as ht, StandardConstraintDefinition as i, SchemaBooleanNode as it, SchemaTypePartialFieldsExpr as j, SchemaTypeOmitFieldsExpr as k, STANDARD_SEMANTIC_PATHS as l, SchemaNullNode as lt, SchemaTypeAbsentExpr as m, SchemaRecordNode as mt, STANDARD_SEMANTIC_DEFINITIONS as n, PrimitiveName as nt, StandardSemanticRelation as o, SchemaLiteralNode as ot, SchemaFieldSelector as p, SchemaRecordField as pt, OperationDefinition as q, STANDARD_SEMANTIC_RELATIONS as r, SchemaArrayNode as rt, STANDARD_CONSTRAINT_PATHS as s, SchemaLiteralUnionNode as st, STANDARD_CONSTRAINT_DEFINITIONS as t, LiteralValue as tt, STANDARD_SEMANTIC_PATH_LIST as u, SchemaNullableNode as ut, SchemaTypeExcludeVariantsExpr as v, SchemaTaggedUnionNode as vt, SchemaTypeKeyOfExpr as w, SchemaTypeFieldOfExpr as x, SchemaTypeExpr as y, SchemaTaggedUnionVariant as yt, SchemaTypeUnknownExpr as z };

package/dist/index-BqfGAU1K.d.ts

@@ -0,0 +1,56 @@
+import { ct as SchemaNode } from "./index-4aMF0cTE.js";
+
+//#region src/payload/validator.d.ts
+type PayloadPath = readonly (string | number)[];
+interface PayloadValidationDiagnostic {
+  readonly code: string;
+  readonly path: PayloadPath;
+  readonly message: string;
+}
+type PayloadValidationResult = {
+  readonly status: 'accepted';
+  readonly issues: readonly [];
+} | {
+  readonly status: 'rejected' | 'unknown';
+  readonly issues: readonly PayloadValidationDiagnostic[];
+};
+type PayloadProviderDecision = boolean | {
+  readonly status: 'accepted' | 'rejected' | 'unknown' | 'unsupported';
+  readonly message?: string;
+};
+interface PayloadProviderContext {
+  readonly path: PayloadPath;
+  readonly schema: SchemaNode;
+  readonly rootSchema: SchemaNode;
+}
+interface PayloadResolutionContext extends PayloadProviderContext {
+  readonly refPath: readonly string[];
+}
+type PayloadResolution = SchemaNode | {
+  readonly status: 'resolved';
+  readonly schema: SchemaNode;
+} | {
+  readonly status: 'unknown' | 'unsupported';
+  readonly message?: string;
+} | undefined;
+type SemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
+type ConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | Promise<PayloadProviderDecision | undefined> | undefined;
+type SyncSemanticProvider = (semanticPath: readonly string[], value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
+type SyncConstraintProvider = (constraintPath: readonly string[], args: unknown, value: unknown, context: PayloadProviderContext) => PayloadProviderDecision | undefined;
+type SyncPayloadResolution = PayloadResolution;
+interface SyncPayloadValidationContext {
+  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => SyncPayloadResolution;
+  readonly semanticProvider?: SyncSemanticProvider;
+  readonly constraintProvider?: SyncConstraintProvider;
+}
+interface PayloadValidationContext {
+  readonly resolveRef?: (refPath: readonly string[], context: PayloadResolutionContext) => PayloadResolution | Promise<PayloadResolution>;
+  readonly semanticProvider?: SemanticProvider;
+  readonly constraintProvider?: ConstraintProvider;
+}
+/** Context accepted by the asynchronous payload validation entry point. */
+type AsyncPayloadValidationContext = PayloadValidationContext;
+declare function validatePayload(value: unknown, schema: SchemaNode, context?: SyncPayloadValidationContext): PayloadValidationResult;
+declare function validatePayloadAsync(value: unknown, schema: SchemaNode, context?: AsyncPayloadValidationContext): Promise<PayloadValidationResult>;
+//#endregion
+export { validatePayloadAsync as _, PayloadProviderDecision as a, PayloadValidationContext as c, SemanticProvider as d, SyncConstraintProvider as f, validatePayload as g, SyncSemanticProvider as h, PayloadProviderContext as i, PayloadValidationDiagnostic as l, SyncPayloadValidationContext as m, ConstraintProvider as n, PayloadResolution as o, SyncPayloadResolution as p, PayloadPath as r, PayloadResolutionContext as s, AsyncPayloadValidationContext as t, PayloadValidationResult as u };

package/dist/{index-eK2Xgrwp.d.ts → index-CBbd4hXJ.d.ts}

@@ -1,4 +1,4 @@
-import { G as SchemaConstraint, J as SchemaNode } from "./index-CEzHfht2.js";
+import { at as SchemaConstraint, ct as SchemaNode } from "./index-4aMF0cTE.js";
 
 //#region src/relations/validator.d.ts
 type RelationPath = readonly (string | number)[];
@@ -6,6 +6,7 @@ interface RelationDiagnostic {
   readonly code: string;
   readonly path: RelationPath;
   readonly message: string;
+  readonly details?: Readonly<Record<string, unknown>>;
 }
 type RelationStatus = 'assignable' | 'incompatible' | 'unknown' | 'rejected';
 interface RelationResult {
@@ -50,4 +51,14 @@ declare const checkSchemaAssignability: typeof checkSchemaRelation;
 declare function checkSchemaRelationAsync(source: unknown, target: unknown, context?: AsyncRelationContext): Promise<RelationResult>;
 declare const checkSchemaAssignabilityAsync: typeof checkSchemaRelationAsync;
 //#endregion
-export { RelationProviderContext as a, RelationResolutionContext as c, RelationStatus as d, checkSchemaAssignability as f, checkSchemaRelationAsync as h, RelationPath as i, RelationResult as l, checkSchemaRelation as m, RelationContext as n, RelationProviderDecision as o, checkSchemaAssignabilityAsync as p, RelationDiagnostic as r, RelationResolution as s, AsyncRelationContext as t, RelationSide as u };
+//#region src/relations/operation.d.ts
+type OperationRelationComponent = 'definition' | 'input' | 'output' | 'error' | 'emission';
+type OperationRelationDirection = 'source-to-target' | 'target-to-source';
+/** Can source replace target for callers using the target contract?
+ * Provider contexts describe each directed schema comparison; input reverses sides.
+ */
+declare function checkOperationRelation(source: unknown, target: unknown, context?: RelationContext): RelationResult;
+/** Async companion with the same substitution rules and schema-local providers. */
+declare function checkOperationRelationAsync(source: unknown, target: unknown, context?: AsyncRelationContext): Promise<RelationResult>;
+//#endregion
+export { checkSchemaAssignabilityAsync as _, AsyncRelationContext as a, RelationPath as c, RelationResolution as d, RelationResolutionContext as f, checkSchemaAssignability as g, RelationStatus as h, checkOperationRelationAsync as i, RelationProviderContext as l, RelationSide as m, OperationRelationDirection as n, RelationContext as o, RelationResult as p, checkOperationRelation as r, RelationDiagnostic as s, OperationRelationComponent as t, RelationProviderDecision as u, checkSchemaRelation as v, checkSchemaRelationAsync as y };

package/dist/index-CIim1dG7.d.cts

@@ -0,0 +1,92 @@
+import { K as OperationContainerDefinition, L as SchemaTypeTerm, Q as StructuredOperationDefinition, Z as StructuredOperationContainerDefinition, ct as SchemaNode, q as OperationDefinition, y as SchemaTypeExpr } from "./index-DDMwVy2I.cjs";
+
+//#region src/definition/validator.d.ts
+type SchemaNodeDefinitionPath = readonly (string | number)[];
+interface SchemaNodeDefinitionDiagnostic {
+  readonly code: string;
+  readonly path: SchemaNodeDefinitionPath;
+  readonly message: string;
+}
+type SchemaNodeDefinitionValidationResult = {
+  readonly ok: true;
+  readonly node: SchemaNode;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly SchemaNodeDefinitionDiagnostic[];
+};
+/** Validate only the serializable structural definition of one SchemaNode. */
+declare function validateSchemaNodeDefinition(value: unknown): SchemaNodeDefinitionValidationResult;
+//#endregion
+//#region src/definition/operation-validator.d.ts
+type OperationDefinitionPath = readonly (string | number)[];
+interface OperationDefinitionDiagnostic {
+  readonly code: string;
+  readonly path: OperationDefinitionPath;
+  readonly message: string;
+}
+type OperationDefinitionValidationResult = {
+  readonly ok: true;
+  readonly operation: OperationDefinition;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly OperationDefinitionDiagnostic[];
+};
+type OperationContainerDefinitionValidationResult = {
+  readonly ok: true;
+  readonly container: OperationContainerDefinition;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly OperationDefinitionDiagnostic[];
+};
+type StructuredOperationDefinitionValidationResult = {
+  readonly ok: true;
+  readonly operation: StructuredOperationDefinition;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly OperationDefinitionDiagnostic[];
+};
+type StructuredOperationContainerDefinitionValidationResult = {
+  readonly ok: true;
+  readonly container: StructuredOperationContainerDefinition;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly OperationDefinitionDiagnostic[];
+};
+declare function validateOperationDefinition(value: unknown): OperationDefinitionValidationResult;
+declare function validateOperationContainerDefinition(value: unknown): OperationContainerDefinitionValidationResult;
+declare function validateStructuredOperationDefinition(value: unknown): StructuredOperationDefinitionValidationResult;
+declare function validateStructuredOperationContainerDefinition(value: unknown): StructuredOperationContainerDefinitionValidationResult;
+declare function isStructuredOperationDefinition(value: unknown): value is StructuredOperationDefinition;
+declare function isStructuredOperationContainerDefinition(value: unknown): value is StructuredOperationContainerDefinition;
+//#endregion
+//#region src/definition/expression-validator.d.ts
+interface SchemaTypeDefinitionDiagnostic {
+  readonly code: string;
+  readonly path: readonly (string | number)[];
+  readonly message: string;
+}
+type SchemaTypeExprDefinitionValidationResult = {
+  readonly ok: true;
+  readonly expression: SchemaTypeExpr;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly SchemaTypeDefinitionDiagnostic[];
+};
+type SchemaTypeTermDefinitionValidationResult = {
+  readonly ok: true;
+  readonly term: SchemaTypeTerm;
+  readonly issues: readonly [];
+} | {
+  readonly ok: false;
+  readonly issues: readonly SchemaTypeDefinitionDiagnostic[];
+};
+declare function validateSchemaTypeExprDefinition(value: unknown): SchemaTypeExprDefinitionValidationResult;
+declare function validateSchemaTypeTermDefinition(value: unknown): SchemaTypeTermDefinitionValidationResult;
+//#endregion
+export { validateStructuredOperationDefinition as _, validateSchemaTypeTermDefinition as a, SchemaNodeDefinitionValidationResult as b, OperationDefinitionPath as c, StructuredOperationDefinitionValidationResult as d, isStructuredOperationContainerDefinition as f, validateStructuredOperationContainerDefinition as g, validateOperationDefinition as h, validateSchemaTypeExprDefinition as i, OperationDefinitionValidationResult as l, validateOperationContainerDefinition as m, SchemaTypeExprDefinitionValidationResult as n, OperationContainerDefinitionValidationResult as o, isStructuredOperationDefinition as p, SchemaTypeTermDefinitionValidationResult as r, OperationDefinitionDiagnostic as s, SchemaTypeDefinitionDiagnostic as t, StructuredOperationContainerDefinitionValidationResult as u, SchemaNodeDefinitionDiagnostic as v, validateSchemaNodeDefinition as x, SchemaNodeDefinitionPath as y };

package/dist/{index-TACcK_mi.d.cts → index-CNjYUKvu.d.cts}

@@ -1,4 +1,4 @@
-import { G as SchemaConstraint, J as SchemaNode } from "./index-rzkFjgrt.cjs";
+import { at as SchemaConstraint, ct as SchemaNode } from "./index-DDMwVy2I.cjs";
 
 //#region src/relations/validator.d.ts
 type RelationPath = readonly (string | number)[];
@@ -6,6 +6,7 @@ interface RelationDiagnostic {
   readonly code: string;
   readonly path: RelationPath;
   readonly message: string;
+  readonly details?: Readonly<Record<string, unknown>>;
 }
 type RelationStatus = 'assignable' | 'incompatible' | 'unknown' | 'rejected';
 interface RelationResult {
@@ -50,4 +51,14 @@ declare const checkSchemaAssignability: typeof checkSchemaRelation;
 declare function checkSchemaRelationAsync(source: unknown, target: unknown, context?: AsyncRelationContext): Promise<RelationResult>;
 declare const checkSchemaAssignabilityAsync: typeof checkSchemaRelationAsync;
 //#endregion
-export { RelationProviderContext as a, RelationResolutionContext as c, RelationStatus as d, checkSchemaAssignability as f, checkSchemaRelationAsync as h, RelationPath as i, RelationResult as l, checkSchemaRelation as m, RelationContext as n, RelationProviderDecision as o, checkSchemaAssignabilityAsync as p, RelationDiagnostic as r, RelationResolution as s, AsyncRelationContext as t, RelationSide as u };
+//#region src/relations/operation.d.ts
+type OperationRelationComponent = 'definition' | 'input' | 'output' | 'error' | 'emission';
+type OperationRelationDirection = 'source-to-target' | 'target-to-source';
+/** Can source replace target for callers using the target contract?
+ * Provider contexts describe each directed schema comparison; input reverses sides.
+ */
+declare function checkOperationRelation(source: unknown, target: unknown, context?: RelationContext): RelationResult;
+/** Async companion with the same substitution rules and schema-local providers. */
+declare function checkOperationRelationAsync(source: unknown, target: unknown, context?: AsyncRelationContext): Promise<RelationResult>;
+//#endregion
+export { checkSchemaAssignabilityAsync as _, AsyncRelationContext as a, RelationPath as c, RelationResolution as d, RelationResolutionContext as f, checkSchemaAssignability as g, RelationStatus as h, checkOperationRelationAsync as i, RelationProviderContext as l, RelationSide as m, OperationRelationDirection as n, RelationContext as o, RelationResult as p, checkOperationRelation as r, RelationDiagnostic as s, OperationRelationComponent as t, RelationProviderDecision as u, checkSchemaRelation as v, checkSchemaRelationAsync as y };