@voce-engine/core 0.1.0-rc.1

package/dist/m4.d.ts

@@ -0,0 +1,157 @@
+import type { Budget, Cleanup, CompilationContext, Compensation, Constraint, ConstraintCompilationInput, ConstraintConflict, ConstraintDependency, ConstraintIR, ConstraintWaiver, DataTransfer, Degradation, DispatchPreflightResult, DispatchSnapshot, ExecutionAuthorization, ExplainResult, Goal, OutputContract, PipelinePlan, PipelinePlanningInput, PipelinePlanningResult, PipelineStep, ProviderCapabilityProfile, ReferenceCandidate, ReferenceDependency, ReferenceOmission, ReferencePlan, ReferencePlanningInput, RemoteCallAuthorization, ResourceClaim, ReviewRequirement, RuleTrace, SemanticDiff } from '@voce-engine/contracts';
+export declare const CONSTRAINT_COMPILER_VERSION = "voce.constraint-compiler/v1alpha1";
+export declare const REFERENCE_OPTIMIZER_VERSION = "voce.reference-budget-optimizer/v1alpha1";
+export declare const PIPELINE_PLANNER_VERSION = "voce.pipeline-planner/v1alpha1";
+export declare const REMOTE_AUTHORIZATION_VERSION = "voce.authorization-preflight/v1alpha1";
+export declare const FIXED_M4_TIME = "2026-01-01T00:00:00.000Z";
+export declare function computeOntologyInstanceHash(instance: ConstraintCompilationInput['ontologyInstance']): string;
+export declare function computeCompilationContextHash(context: CompilationContext): string;
+export declare function computeOutputContractHash(contract: OutputContract): string;
+export declare function computeConstraintHash(constraint: Constraint): string;
+export declare function computeGoalHash(goal: Goal): string;
+export declare function computeConstraintDependencyHash(dependency: ConstraintDependency): string;
+export declare function computeResourceClaimHash(claim: ResourceClaim): string;
+export declare function computeConstraintConflictHash(conflict: ConstraintConflict): string;
+export declare function computeDegradationHash(degradation: Degradation): string;
+export declare function computeRuleTraceHash(trace: RuleTrace): string;
+export declare function computeReviewRequirementHash(requirement: ReviewRequirement): string;
+export declare function computeConstraintIRSignature(ir: ConstraintIR): string;
+export declare function computeReferenceCandidateHash(candidate: ReferenceCandidate): string;
+export declare function computeReferenceDependencyHash(dependency: ReferenceDependency): string;
+export declare function computeReferenceOmissionHash(omission: ReferenceOmission): string;
+export declare function createReferenceCandidate(input: Omit<ReferenceCandidate, 'candidateHash'>): ReferenceCandidate;
+export declare function createReferenceDependency(input: Omit<ReferenceDependency, 'dependencyHash'>): ReferenceDependency;
+type ProviderCapabilityProfileForHash = Omit<ProviderCapabilityProfile, 'profileHash'>;
+export declare function computeProviderCapabilityProfileHash(profile: ProviderCapabilityProfileForHash): string;
+export declare function computeBudgetHash(budget: Budget): string;
+export declare function computeDataTransferHash(transfer: DataTransfer): string;
+export declare function computeCleanupHash(cleanup: Cleanup): string;
+export declare function computeCompensationHash(compensation: Compensation): string;
+export declare function computePipelineStepHash(step: PipelineStep): string;
+export declare function computePipelinePlanHash(plan: PipelinePlan): string;
+export declare function computeRemoteCallAuthorizationHash(authorization: RemoteCallAuthorization): string;
+export declare function computeExecutionAuthorizationHash(authorization: ExecutionAuthorization): string;
+export declare function computeConstraintWaiverHash(waiver: ConstraintWaiver): string;
+export declare function createConstraint(input: Omit<Constraint, 'constraintHash'>): Constraint;
+export declare function createGoal(input: Omit<Goal, 'goalHash'>): Goal;
+export declare function createConstraintDependency(input: Omit<ConstraintDependency, 'dependencyHash'>): ConstraintDependency;
+export declare function createResourceClaim(input: Omit<ResourceClaim, 'resourceHash'>): ResourceClaim;
+export declare function createConstraintConflict(input: Omit<ConstraintConflict, 'conflictHash'>): ConstraintConflict;
+export declare function createDegradation(input: Omit<Degradation, 'degradationHash'>): Degradation;
+export declare function createRuleTrace(input: Omit<RuleTrace, 'traceHash'>): RuleTrace;
+export declare function createReviewRequirement(input: Omit<ReviewRequirement, 'reviewHash'>): ReviewRequirement;
+export declare function createBudget(input: Omit<Budget, 'budgetHash'>): Budget;
+export declare function createDataTransfer(input: Omit<DataTransfer, 'transferHash'>): DataTransfer;
+export declare function createRemoteCallAuthorization(input: Omit<RemoteCallAuthorization, 'authorizationHash'>): RemoteCallAuthorization;
+export declare function createExecutionAuthorization(input: Omit<ExecutionAuthorization, 'authorizationHash'>): ExecutionAuthorization;
+export declare function createConstraintWaiver(input: Omit<ConstraintWaiver, 'waiverHash'>): ConstraintWaiver;
+/**
+ * These are plain declarative records. They are deliberately not keyed to a
+ * scenario name; a ScenarioPack may copy, extend, or replace them through its
+ * `rulePacks` contribution.
+ */
+export declare const M4_RULE_FIXTURES: {
+    readonly maskIdentity: {
+        readonly id: "rule.mask-identity-visibility";
+        readonly ruleType: "occlusion";
+        readonly leftPaths: readonly ["person.identity", "person.face"];
+        readonly rightPaths: readonly ["accessories.mask", "mask", "person.faceMask"];
+        readonly rightTokens: readonly ["full_face", "full-face", "fullface", "opaque_face"];
+        readonly importance: "preferred";
+        readonly code: "MASK_IDENTITY_VISIBILITY_CONFLICT";
+        readonly reasonCode: "MASK_OCCLUDES_REQUIRED_IDENTITY";
+        readonly message: "A full-face mask occludes a required identity-visibility constraint.";
+    };
+    readonly sleeveBracelet: {
+        readonly id: "rule.sleeve-bracelet-occlusion";
+        readonly ruleType: "occlusion";
+        readonly leftPaths: readonly ["accessories.bracelet", "jewelry.bracelet", "wrist.accessory"];
+        readonly rightPaths: readonly ["wardrobe.sleeve", "wardrobe.sleeves", "garment.sleeve"];
+        readonly rightTokens: readonly ["wrist_cover", "full_length", "long", "long_sleeve", "covers_wrist"];
+        readonly importance: "required";
+        readonly code: "SLEEVE_BRACELET_OCCLUSION";
+        readonly reasonCode: "SLEEVE_COVERS_REQUIRED_BRACELET";
+        readonly message: "A sleeve coverage requirement occludes a required bracelet detail.";
+    };
+    readonly handProp: {
+        readonly id: "rule.hand-prop-resource";
+        readonly ruleType: "resource";
+        readonly leftPaths: readonly ["accessories.bracelet", "jewelry", "accessories.hand"];
+        readonly rightPaths: readonly ["prop", "props", "pose.hand", "hand"];
+        readonly rightTokens: readonly ["held", "left", "right", "two_hands", "both_hands"];
+        readonly importance: "required";
+        readonly code: "HAND_PROP_RESOURCE_CONFLICT";
+        readonly reasonCode: "HAND_RESOURCE_OVERLAP";
+        readonly message: "A hand-worn or hand-held requirement claims the same exclusive hand resource as a prop.";
+        readonly resourceId: "hand";
+    };
+};
+export declare const M4_DECLARATIVE_RULE_FIXTURES: ({
+    readonly id: "rule.mask-identity-visibility";
+    readonly ruleType: "occlusion";
+    readonly leftPaths: readonly ["person.identity", "person.face"];
+    readonly rightPaths: readonly ["accessories.mask", "mask", "person.faceMask"];
+    readonly rightTokens: readonly ["full_face", "full-face", "fullface", "opaque_face"];
+    readonly importance: "preferred";
+    readonly code: "MASK_IDENTITY_VISIBILITY_CONFLICT";
+    readonly reasonCode: "MASK_OCCLUDES_REQUIRED_IDENTITY";
+    readonly message: "A full-face mask occludes a required identity-visibility constraint.";
+} | {
+    readonly id: "rule.sleeve-bracelet-occlusion";
+    readonly ruleType: "occlusion";
+    readonly leftPaths: readonly ["accessories.bracelet", "jewelry.bracelet", "wrist.accessory"];
+    readonly rightPaths: readonly ["wardrobe.sleeve", "wardrobe.sleeves", "garment.sleeve"];
+    readonly rightTokens: readonly ["wrist_cover", "full_length", "long", "long_sleeve", "covers_wrist"];
+    readonly importance: "required";
+    readonly code: "SLEEVE_BRACELET_OCCLUSION";
+    readonly reasonCode: "SLEEVE_COVERS_REQUIRED_BRACELET";
+    readonly message: "A sleeve coverage requirement occludes a required bracelet detail.";
+} | {
+    readonly id: "rule.hand-prop-resource";
+    readonly ruleType: "resource";
+    readonly leftPaths: readonly ["accessories.bracelet", "jewelry", "accessories.hand"];
+    readonly rightPaths: readonly ["prop", "props", "pose.hand", "hand"];
+    readonly rightTokens: readonly ["held", "left", "right", "two_hands", "both_hands"];
+    readonly importance: "required";
+    readonly code: "HAND_PROP_RESOURCE_CONFLICT";
+    readonly reasonCode: "HAND_RESOURCE_OVERLAP";
+    readonly message: "A hand-worn or hand-held requirement claims the same exclusive hand resource as a prop.";
+    readonly resourceId: "hand";
+})[];
+export declare class ConstraintGraphCompiler {
+    compile(input: ConstraintCompilationInput): ConstraintIR;
+    private compileSafe;
+}
+export declare const DeterministicConstraintGraphCompiler: typeof ConstraintGraphCompiler;
+export declare function compileConstraints(input: ConstraintCompilationInput): ConstraintIR;
+export declare function compileConstraintIR(input: ConstraintCompilationInput): ConstraintIR;
+export declare function computeReferencePlanHash(plan: ReferencePlan): string;
+export declare class ReferenceBudgetOptimizer {
+    plan(input: ReferencePlanningInput): ReferencePlan;
+    private planSafe;
+}
+export declare const DeterministicReferenceBudgetOptimizer: typeof ReferenceBudgetOptimizer;
+export declare function planReferences(input: ReferencePlanningInput): ReferencePlan;
+export declare function optimizeReferenceBudget(input: ReferencePlanningInput): ReferencePlan;
+export declare const MOCK_IMAGE_PROFILE: ProviderCapabilityProfile;
+export declare const MOCK_JPEG_PROFILE: ProviderCapabilityProfile;
+export declare const MOCK_LIMITED_REFERENCE_PROFILE: ProviderCapabilityProfile;
+export declare const MOCK_PROVIDER_CAPABILITY_PROFILES: ProviderCapabilityProfile[];
+export declare class CapabilityAwarePipelinePlanner {
+    plan(input: PipelinePlanningInput): PipelinePlanningResult;
+    private planSafe;
+}
+export declare const DeterministicCapabilityAwarePipelinePlanner: typeof CapabilityAwarePipelinePlanner;
+export declare function planPipeline(input: PipelinePlanningInput): PipelinePlanningResult;
+export declare function planCapabilityAwarePipeline(input: PipelinePlanningInput): PipelinePlanningResult;
+export declare function dispatchPreflight(authorization: RemoteCallAuthorization | ExecutionAuthorization, snapshot: DispatchSnapshot, now?: string): DispatchPreflightResult;
+export declare const preflightDispatch: typeof dispatchPreflight;
+export declare const dispatchPreflightPure: typeof dispatchPreflight;
+export declare function explainConstraintIR(ir: ConstraintIR): ExplainResult;
+export declare function explainReferencePlan(plan: ReferencePlan): ExplainResult;
+export declare function explainPipelinePlan(plan: PipelinePlan): ExplainResult;
+export declare function semanticDiff(kind: SemanticDiff['artifactKind'], before: ConstraintIR | ReferencePlan | PipelinePlan, after: ConstraintIR | ReferencePlan | PipelinePlan): SemanticDiff;
+export declare function diffConstraintIR(before: ConstraintIR, after: ConstraintIR): SemanticDiff;
+export declare function diffReferencePlan(before: ReferencePlan, after: ReferencePlan): SemanticDiff;
+export declare function diffPipelinePlan(before: PipelinePlan, after: PipelinePlan): SemanticDiff;
+export {};