@voce-engine/core 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1 @@
+Apache License 2.0

package/README.md

@@ -0,0 +1,9 @@
+# @voce-engine/core
+
+Deterministic ScenarioPack resolution, constraint compilation, reference planning, Prompt IR, offline execution, and evaluation primitives.
+
+> `0.1.0-rc.1` is a release candidate, not production-ready. APIs may change before `0.1.0`.
+
+```bash
+npm install @voce-engine/core@0.1.0-rc.1
+```

package/dist/canonical.d.ts

@@ -0,0 +1,4 @@
+import type { JsonValue } from '@voce-engine/contracts';
+export declare function canonicalize(value: JsonValue): string;
+export declare function sha256(value: JsonValue): string;
+export declare function hashWithoutSelf<T extends Record<string, unknown>>(value: T, field: string): string;

package/dist/canonical.js

@@ -0,0 +1,30 @@
+import { createHash } from 'node:crypto';
+function compareCodeUnits(a, b) {
+    const length = Math.min(a.length, b.length);
+    for (let index = 0; index < length; index += 1) {
+        const difference = a.charCodeAt(index) - b.charCodeAt(index);
+        if (difference !== 0)
+            return difference;
+    }
+    return a.length - b.length;
+}
+export function canonicalize(value) {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return JSON.stringify(value);
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error('CANONICAL_JSON_NUMBER_INVALID');
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value))
+        return `[${value.map(canonicalize).join(',')}]`;
+    return `{${Object.keys(value).sort(compareCodeUnits).map((key) => `${JSON.stringify(key)}:${canonicalize(value[key])}`).join(',')}}`;
+}
+export function sha256(value) {
+    return `sha256:${createHash('sha256').update(canonicalize(value)).digest('hex')}`;
+}
+export function hashWithoutSelf(value, field) {
+    const copy = { ...value };
+    delete copy[field];
+    return sha256(copy);
+}

package/dist/evidence.d.ts

@@ -0,0 +1,31 @@
+import type { BindingDecision, EvidenceAndSourceResolver as EvidenceAndSourceResolverContract, EvidenceAndSourceResolverInput, EvidenceAndSourceResolverResult, Observation, ObservationDecision, ReferenceInterpreter as ReferenceInterpreterContract, ReferenceInterpreterInput, ReferenceInterpreterResult, RequestedScopePlan, SourceBinding } from '@voce-engine/contracts';
+export declare const EVIDENCE_RESOLVER_VERSION = "voce.evidence-source-resolver/v1alpha1";
+export declare const MANUAL_REFERENCE_INTERPRETER_VERSION = "voce.manual-reference-interpreter/v1alpha1";
+export declare const FIXTURE_REFERENCE_INTERPRETER_VERSION = "voce.fixture-reference-interpreter/v1alpha1";
+export declare const FIXED_DECISION_TIME = "1970-01-01T00:00:00.000Z";
+export declare function computeObservationContentHash(observation: Observation): string;
+export declare function createObservation(input: Omit<Observation, 'contentHash'>): Observation;
+export declare function computeSourceBindingContentHash(binding: SourceBinding): string;
+export declare const computeBindingHash: typeof computeSourceBindingContentHash;
+export declare const computeSourceBindingHash: typeof computeSourceBindingContentHash;
+export declare const computeObservationHash: typeof computeObservationContentHash;
+export declare function createSourceBinding(input: Omit<SourceBinding, 'contentHash'>): SourceBinding;
+export declare function computeObservationDecisionHash(decision: ObservationDecision): string;
+export declare function createObservationDecision(input: Omit<ObservationDecision, 'decisionHash'>): ObservationDecision;
+export declare function computeBindingDecisionHash(decision: BindingDecision): string;
+export declare function createBindingDecision(input: Omit<BindingDecision, 'decisionHash'>): BindingDecision;
+type RequestedScopePlanHashInput = Omit<RequestedScopePlan, 'planHash'>;
+export declare function computeRequestedScopePlanHash(plan: RequestedScopePlanHashInput): string;
+export declare class ManualReferenceInterpreter implements ReferenceInterpreterContract {
+    interpret(input: ReferenceInterpreterInput): ReferenceInterpreterResult;
+}
+export declare class FixtureReferenceInterpreter implements ReferenceInterpreterContract {
+    interpret(input: ReferenceInterpreterInput): ReferenceInterpreterResult;
+}
+export declare class EvidenceAndSourceResolver implements EvidenceAndSourceResolverContract {
+    resolve(input: EvidenceAndSourceResolverInput): EvidenceAndSourceResolverResult;
+}
+export declare const DeterministicEvidenceAndSourceResolver: typeof EvidenceAndSourceResolver;
+export declare function resolveEvidenceAndSource(input: EvidenceAndSourceResolverInput): EvidenceAndSourceResolverResult;
+export declare function createEvidenceAndSourceResolver(): EvidenceAndSourceResolver;
+export {};