@voce-engine/testkit 0.1.0-rc.1

package/LICENSE

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

package/README.md

@@ -0,0 +1,9 @@
+# @voce-engine/testkit
+
+Small deterministic fixtures and Mock-only helpers for offline VOCE contract tests.
+
+> `0.1.0-rc.1` is a release candidate, not production-ready. Test contracts may change before `0.1.0`.
+
+```bash
+npm install --save-dev @voce-engine/testkit@0.1.0-rc.1
+```

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import type { ArtifactHandle, CaseSpec, ChangeIntent, EvidenceAndSourceResolverInput, Observation, ObservationDecision, Provenance, RequestedScope, RequestedScopePlan } from '@voce-engine/contracts';
+import { createSourceBinding } from '@voce-engine/core';
+import type { JsonValue } from '@voce-engine/contracts';
+export declare function assert(condition: boolean, message: string): void;
+export declare const FIXTURE_CONTEXT_HASH: string;
+export declare const FIXTURE_CASE_ID = "case-m3-fixture";
+export declare const FIXTURE_CASE_REVISION = 1;
+export declare const FIXTURE_CREATED_AT = "2026-01-01T00:00:00.000Z";
+export declare function fixtureCaseSpec(assets?: ArtifactHandle[]): CaseSpec;
+export declare function fixtureProvenance(source?: Provenance['source'], sourceIds?: string[]): Provenance;
+export declare function fixtureArtifact(id?: string, contentHash?: string): ArtifactHandle;
+export declare function fixtureScope(id: string, ontologyPath: string, assetId?: string, required?: boolean): RequestedScope;
+export declare function fixtureScopePlan(paths: string[], assetId?: string, caseId?: string, caseRevision?: number): RequestedScopePlan;
+export declare function fixtureObservationDecision(observation: Observation, contextHash?: string, status?: ObservationDecision['status']): ObservationDecision;
+export declare function fixtureChangeIntent(id: string, operation: ChangeIntent['operation'], targetPath: string, requestedValue?: JsonValue): ChangeIntent;
+export declare function fixtureResolverInput(overrides?: Partial<EvidenceAndSourceResolverInput>): EvidenceAndSourceResolverInput;
+export declare function confirmBinding(binding: Parameters<typeof createSourceBinding>[0], contextHash?: string): {
+    binding: import("@voce-engine/contracts").SourceBinding;
+    decision: import("@voce-engine/contracts").BindingDecision;
+};
+export * from './m4.js';
+export * from './m5.js';
+export * from './m6.js';

package/dist/index.js

@@ -0,0 +1,110 @@
+import { createBindingDecision, createObservationDecision, createSourceBinding, computeRequestedScopePlanHash, sha256, } from '@voce-engine/core';
+export function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+export const FIXTURE_CONTEXT_HASH = sha256({ fixture: 'm3-context', revision: 1 });
+export const FIXTURE_CASE_ID = 'case-m3-fixture';
+export const FIXTURE_CASE_REVISION = 1;
+export const FIXTURE_CREATED_AT = '2026-01-01T00:00:00.000Z';
+export function fixtureCaseSpec(assets = [fixtureArtifact()]) {
+    return {
+        schemaVersion: 'voce.case-spec/v1alpha1',
+        id: FIXTURE_CASE_ID,
+        revision: FIXTURE_CASE_REVISION,
+        mode: 'manual',
+        scenario: { root: { packId: 'fixture.root', versionRange: '1.0.0' }, extensions: [] },
+        userIntent: 'Preserve the selected reference properties and create only explicitly requested target values.',
+        assets,
+        trustedMetadata: [],
+        policies: { schemaVersion: 'voce.case-policies/v1alpha1', observationConfirmation: 'explicit', bindingConfirmation: 'explicit', allowDeclaredDefaults: false },
+        requestedOutput: { artifactKind: 'image', dataType: 'image', mediaTypes: ['image/png'], cardinality: { min: 1, max: 1 } },
+    };
+}
+export function fixtureProvenance(source = 'reference_observed', sourceIds = ['ref-01']) {
+    return { source, sourceIds: [...sourceIds].sort(), createdBy: 'voce-testkit', createdAt: FIXTURE_CREATED_AT };
+}
+export function fixtureArtifact(id = 'ref-01', contentHash = sha256({ fixtureAsset: id })) {
+    return {
+        id,
+        storeId: 'fixture-store',
+        contentHash,
+        mediaType: 'image/png',
+        role: 'reference',
+        resolverId: 'fixture-resolver',
+        availability: 'available',
+        retentionClass: 'fixture',
+        redactionPolicy: 'safe-hash-only',
+    };
+}
+export function fixtureScope(id, ontologyPath, assetId = 'ref-01', required = true) {
+    return { schemaVersion: 'voce.requested-scope/v1alpha1', id, ontologyPath, assetIds: [assetId], purpose: 'find_source', required };
+}
+export function fixtureScopePlan(paths, assetId = 'ref-01', caseId = FIXTURE_CASE_ID, caseRevision = FIXTURE_CASE_REVISION) {
+    const scopes = paths.map((path, index) => fixtureScope(`scope-${index + 1}`, path, assetId));
+    const base = { schemaVersion: 'voce.requested-scope-plan/v1alpha1', id: 'scope-plan-m3-fixture', caseId, caseRevision, scopes, excludedScopes: [], questions: [] };
+    return { ...base, planHash: computeRequestedScopePlanHash(base) };
+}
+export function fixtureObservationDecision(observation, contextHash = FIXTURE_CONTEXT_HASH, status = 'confirmed') {
+    return createObservationDecision({
+        schemaVersion: 'voce.observation-decision/v1alpha1',
+        decisionId: `decision-${observation.id}`,
+        observationId: observation.id,
+        observationHash: observation.contentHash,
+        contextHash,
+        status,
+        authority: 'user',
+        decidedBy: 'fixture-reviewer',
+        decidedAt: FIXTURE_CREATED_AT,
+        reasonCode: status === 'confirmed' ? 'FIXTURE_CONFIRMED' : 'FIXTURE_NOT_CONFIRMED',
+    });
+}
+export function fixtureChangeIntent(id, operation, targetPath, requestedValue) {
+    return {
+        schemaVersion: 'voce.change-intent/v1alpha1',
+        id,
+        operation,
+        targetPath,
+        ...(requestedValue === undefined ? {} : { requestedValue }),
+        importance: 'required',
+        provenance: fixtureProvenance('user_explicit', [id]),
+    };
+}
+export function fixtureResolverInput(overrides = {}) {
+    const requestedScopePlan = fixtureScopePlan(['person.identity', 'person.hair', 'expression', 'pose', 'wardrobe.top', 'environment.background', 'camera.framing']);
+    return {
+        schemaVersion: 'voce.evidence-source-resolver-input/v1alpha1',
+        caseId: FIXTURE_CASE_ID,
+        caseRevision: FIXTURE_CASE_REVISION,
+        contextHash: FIXTURE_CONTEXT_HASH,
+        requestedScopePlan,
+        changeIntents: [],
+        observations: [],
+        observationDecisions: [],
+        sourceBindings: [],
+        bindingDecisions: [],
+        trustedMetadata: [],
+        ...overrides,
+    };
+}
+export function confirmBinding(binding, contextHash = FIXTURE_CONTEXT_HASH) {
+    const normalized = createSourceBinding(binding);
+    return {
+        binding: normalized,
+        decision: createBindingDecision({
+            schemaVersion: 'voce.binding-decision/v1alpha1',
+            decisionId: `decision-${normalized.id}`,
+            bindingId: normalized.id,
+            bindingHash: normalized.contentHash,
+            contextHash,
+            status: 'confirmed',
+            authority: 'user',
+            decidedBy: 'fixture-reviewer',
+            decidedAt: FIXTURE_CREATED_AT,
+            reasonCode: 'FIXTURE_CONFIRMED',
+        }),
+    };
+}
+export * from './m4.js';
+export * from './m5.js';
+export * from './m6.js';

package/dist/m4.d.ts

@@ -0,0 +1,15 @@
+import type { ArtifactHandle, CompilationContext, ConstraintCompilationInput, ConstraintIR, OntologyFact, OntologyInstance, OutputContract, ProviderCapabilityProfile, ReferenceCandidate, ReferenceDependency, ReferencePlanningInput } from '@voce-engine/contracts';
+export declare const M4_FIXTURE_CASE_ID = "case-m4-fixture";
+export declare const M4_FIXTURE_CASE_REVISION = 1;
+export declare const M4_FIXTURE_PLAN_HASH: string;
+export declare const M4_FIXTURE_CREATED_AT = "2026-01-01T00:00:00.000Z";
+export declare function fixtureM4Artifact(id?: string, byteLength?: number, mediaType?: string): ArtifactHandle;
+export declare function fixtureM4Context(overrides?: Partial<Omit<CompilationContext, 'contextHash'>>): CompilationContext;
+export declare function fixtureM4Ontology(facts?: OntologyFact[], contextHash?: string, requestedScopePlanHash?: string, status?: 'ok' | 'blocked'): OntologyInstance;
+export declare function fixtureM4Output(background?: OutputContract['background']): OutputContract;
+export declare function fixtureM4ConstraintInput(overrides?: Partial<ConstraintCompilationInput>): ConstraintCompilationInput;
+export declare function fixtureM4ConstraintIR(overrides?: Partial<ConstraintCompilationInput>): ConstraintIR;
+export declare function fixtureM4Candidate(id: string, importance?: ReferenceCandidate['importance'], byteLength?: number, profile?: ProviderCapabilityProfile): ReferenceCandidate;
+export declare function fixtureM4ReferenceInput(profile?: ProviderCapabilityProfile, candidates?: ReferenceCandidate[]): ReferencePlanningInput;
+export declare function fixtureM4ReferencePlan(profile?: ProviderCapabilityProfile, candidates?: ReferenceCandidate[]): import("@voce-engine/contracts").ReferencePlan;
+export declare function fixtureM4ReferenceDependency(parentCandidateId: string, childCandidateId: string, importance?: ReferenceDependency['importance']): ReferenceDependency;

package/dist/m4.js

@@ -0,0 +1,92 @@
+import { computeCompilationContextHash, computeOntologyInstanceHash, computeReferenceCandidateHash, compileConstraints, createReferenceDependency, MOCK_IMAGE_PROFILE, planReferences, sha256, } from '@voce-engine/core';
+export const M4_FIXTURE_CASE_ID = 'case-m4-fixture';
+export const M4_FIXTURE_CASE_REVISION = 1;
+export const M4_FIXTURE_PLAN_HASH = sha256({ fixture: 'm4-scope-plan' });
+export const M4_FIXTURE_CREATED_AT = '2026-01-01T00:00:00.000Z';
+export function fixtureM4Artifact(id = 'ref-01', byteLength, mediaType = 'image/png') {
+    return {
+        id,
+        storeId: 'm4-fixture-store',
+        contentHash: sha256({ fixtureAsset: id }),
+        mediaType,
+        ...(byteLength === undefined ? {} : { byteLength }),
+        role: 'reference',
+        resolverId: 'm4-fixture-resolver',
+        availability: 'available',
+        retentionClass: 'fixture',
+        redactionPolicy: 'safe-hash-only',
+    };
+}
+export function fixtureM4Context(overrides = {}) {
+    const base = {
+        caseSpecId: M4_FIXTURE_CASE_ID,
+        caseSpecRevision: M4_FIXTURE_CASE_REVISION,
+        caseSpecHash: sha256({ fixture: 'm4-case-spec' }),
+        artifactHashes: [],
+        decisionHashes: [],
+        scenarioCompositionLockHash: sha256({ fixture: 'm4-lock' }),
+        effectiveScenarioHash: sha256({ fixture: 'm4-scenario' }),
+        rulePackPlugins: [],
+        optimizer: { id: 'voce.deterministic', version: '1.0.0', digest: sha256({ fixture: 'm4-optimizer' }) },
+        ...overrides,
+    };
+    return { ...base, contextHash: computeCompilationContextHash(base) };
+}
+export function fixtureM4Ontology(facts = [], contextHash = fixtureM4Context().contextHash, requestedScopePlanHash = M4_FIXTURE_PLAN_HASH, status = 'ok') {
+    const base = {
+        schemaVersion: 'voce.ontology-instance/v1alpha1',
+        id: 'ontology-m4-fixture',
+        caseId: M4_FIXTURE_CASE_ID,
+        caseRevision: M4_FIXTURE_CASE_REVISION,
+        contextHash,
+        requestedScopePlanHash,
+        facts,
+        unknownPaths: [],
+        unspecifiedPaths: [],
+        unresolvedItems: [],
+        conflicts: [],
+        decisionTrace: [],
+    };
+    return { ...base, instanceHash: computeOntologyInstanceHash({ ...base, instanceHash: '' }), status };
+}
+export function fixtureM4Output(background = 'opaque') {
+    return { artifactKind: 'image', dataType: 'image', mediaTypes: ['image/png'], cardinality: { min: 1, max: 1 }, dimensions: { width: 1024, height: 1024 }, background, allowAlpha: false };
+}
+export function fixtureM4ConstraintInput(overrides = {}) {
+    const context = overrides.context ?? fixtureM4Context();
+    const contextHash = overrides.contextHash ?? context.contextHash;
+    const requestedScopePlanHash = overrides.requestedScopePlanHash ?? M4_FIXTURE_PLAN_HASH;
+    const ontologyInstance = overrides.ontologyInstance ?? fixtureM4Ontology([], contextHash, requestedScopePlanHash);
+    return {
+        schemaVersion: 'voce.constraint-compilation-input/v1alpha1',
+        caseId: M4_FIXTURE_CASE_ID,
+        caseRevision: M4_FIXTURE_CASE_REVISION,
+        context,
+        contextHash,
+        requestedScopePlanHash,
+        ontologyInstance,
+        changeIntents: [],
+        sourceBindings: [],
+        bindingDecisions: [],
+        outputContract: fixtureM4Output(),
+        ...overrides,
+    };
+}
+export function fixtureM4ConstraintIR(overrides = {}) {
+    return compileConstraints(fixtureM4ConstraintInput(overrides));
+}
+export function fixtureM4Candidate(id, importance = 'preferred', byteLength, profile = MOCK_IMAGE_PROFILE) {
+    const artifact = fixtureM4Artifact(id, byteLength, profile.allowedReferenceMediaTypes?.[0] ?? 'image/png');
+    const candidate = { schemaVersion: 'voce.reference-candidate/v1alpha1', id, assetId: id, artifact, contentHash: artifact.contentHash, mediaType: artifact.mediaType, ...(byteLength === undefined ? {} : { byteLength }), role: 'detail', ontologyScopes: [`scope.${id}`], importance, constraintIds: [], sourceBindingIds: [], goalIds: [] };
+    return { ...candidate, candidateHash: computeReferenceCandidateHash(candidate) };
+}
+export function fixtureM4ReferenceInput(profile = MOCK_IMAGE_PROFILE, candidates = [fixtureM4Candidate('ref-01', 'required', 100_000, profile)]) {
+    const constraintIR = fixtureM4ConstraintIR();
+    return { schemaVersion: 'voce.reference-planning-input/v1alpha1', caseId: M4_FIXTURE_CASE_ID, caseRevision: M4_FIXTURE_CASE_REVISION, contextHash: constraintIR.contextHash, constraintIR, candidates, dependencies: [], profile };
+}
+export function fixtureM4ReferencePlan(profile = MOCK_IMAGE_PROFILE, candidates) {
+    return planReferences(fixtureM4ReferenceInput(profile, candidates));
+}
+export function fixtureM4ReferenceDependency(parentCandidateId, childCandidateId, importance = 'required') {
+    return createReferenceDependency({ schemaVersion: 'voce.reference-dependency/v1alpha1', id: `dependency-${parentCandidateId}-${childCandidateId}`, parentCandidateId, childCandidateId, kind: 'parent_detail', importance, reasonCode: 'FIXTURE_PARENT_DETAIL', explanation: 'Fixture parent/detail dependency.' });
+}

package/dist/m5.d.ts

@@ -0,0 +1,9 @@
+import type { CompilationContext, OfflineExecutionInput, OutputContract, PromptCandidateIR, PromptCompilationInput, PromptGuardInput, PromptIR, PromptTransformation, ProviderCapabilityProfile, RemoteCallAuthorization } from '@voce-engine/contracts';
+export declare function fixtureM5Output(): OutputContract;
+export declare function fixtureM5Context(overrides?: Partial<Omit<CompilationContext, 'contextHash'>>): CompilationContext;
+export declare function fixtureM5CompilationInput(profile?: ProviderCapabilityProfile, overrides?: Partial<PromptCompilationInput>): PromptCompilationInput;
+export declare function fixtureM5PromptIR(profile?: ProviderCapabilityProfile, overrides?: Partial<PromptCompilationInput>): PromptIR;
+export declare function fixtureM5Candidate(prompt?: PromptIR, transformations?: PromptTransformation[]): PromptCandidateIR;
+export declare function fixtureM5GuardInput(prompt?: PromptIR, candidate?: PromptCandidateIR, policy?: PromptGuardInput['policy']): PromptGuardInput;
+export declare function fixtureM5RemoteAuthorizations(input: Omit<OfflineExecutionInput, 'executionAuthorization' | 'remoteCallAuthorizations'>, promptArtifactHash?: string): RemoteCallAuthorization[];
+export declare function fixtureM5ExecutionInput(profile?: ProviderCapabilityProfile, promptArtifact?: PromptIR | PromptCandidateIR, options?: OfflineExecutionInput['options']): OfflineExecutionInput;

package/dist/m5.js

@@ -0,0 +1,145 @@
+import { computeExecutionBudgetDigest, computeExecutionDataTransferDigest, computeExecutionStepInputHash, computeOutputContractHash, computePromptIRHash, createExecutionAuthorization, createPromptCandidateIR, createRemoteCallAuthorization, compilePromptIR, MOCK_IMAGE_PROFILE, MOCK_JPEG_PROFILE, planPipeline, } from '@voce-engine/core';
+import { fixtureM4ConstraintIR, fixtureM4Context, fixtureM4Output, fixtureM4ReferencePlan, M4_FIXTURE_CASE_ID, M4_FIXTURE_CASE_REVISION, } from './m4.js';
+const FIXED_M5_TIME = '2026-01-01T00:00:00.000Z';
+function sorted(values) {
+    return [...new Set(values)].sort();
+}
+function profileForPrompt(prompt) {
+    return prompt.targetCapabilityProfile.id === MOCK_JPEG_PROFILE.id ? MOCK_JPEG_PROFILE : MOCK_IMAGE_PROFILE;
+}
+export function fixtureM5Output() {
+    return fixtureM4Output('opaque');
+}
+export function fixtureM5Context(overrides = {}) {
+    return fixtureM4Context(overrides);
+}
+export function fixtureM5CompilationInput(profile = MOCK_IMAGE_PROFILE, overrides = {}) {
+    const context = overrides.context ?? fixtureM5Context();
+    const constraintIR = overrides.constraintIR ?? fixtureM4ConstraintIR({ context });
+    const referencePlan = overrides.referencePlan ?? fixtureM4ReferencePlan(profile);
+    const outputContract = overrides.outputContract ?? fixtureM5Output();
+    const pipelineResult = overrides.pipelinePlan ? { status: 'ok', pipelinePlan: overrides.pipelinePlan } : planPipeline({ schemaVersion: 'voce.pipeline-planning-input/v1alpha1', caseId: M4_FIXTURE_CASE_ID, caseRevision: M4_FIXTURE_CASE_REVISION, contextHash: context.contextHash, outputContract, constraintIR, referencePlan, profile });
+    if (!pipelineResult.pipelinePlan)
+        throw new Error('M5_FIXTURE_PIPELINE_BLOCKED');
+    return {
+        schemaVersion: 'voce.prompt-compilation-input/v1alpha1',
+        caseId: M4_FIXTURE_CASE_ID,
+        caseRevision: M4_FIXTURE_CASE_REVISION,
+        context,
+        contextHash: context.contextHash,
+        constraintIR,
+        referencePlan,
+        pipelinePlan: pipelineResult.pipelinePlan,
+        outputContract,
+        targetAdapter: { id: profile.adapterId, version: profile.version, digest: profile.adapterDigest },
+        targetCapabilityProfile: { id: profile.id, version: profile.version, digest: profile.profileHash },
+        ...overrides,
+    };
+}
+export function fixtureM5PromptIR(profile = MOCK_IMAGE_PROFILE, overrides = {}) {
+    return compilePromptIR(fixtureM5CompilationInput(profile, overrides));
+}
+export function fixtureM5Candidate(prompt = fixtureM5PromptIR(), transformations = []) {
+    return createPromptCandidateIR(prompt, transformations);
+}
+export function fixtureM5GuardInput(prompt = fixtureM5PromptIR(), candidate = fixtureM5Candidate(prompt), policy = 'reject') {
+    const profile = profileForPrompt(prompt);
+    const constraintIR = fixtureM4ConstraintIR();
+    const referencePlan = fixtureM4ReferencePlan(profile);
+    const pipelineResult = planPipeline({ schemaVersion: 'voce.pipeline-planning-input/v1alpha1', caseId: prompt.caseId, caseRevision: prompt.caseRevision, contextHash: prompt.contextHash, outputContract: prompt.output, constraintIR, referencePlan, profile });
+    if (!pipelineResult.pipelinePlan)
+        throw new Error('M5_FIXTURE_PIPELINE_BLOCKED');
+    return {
+        schemaVersion: 'voce.prompt-guard-input/v1alpha1',
+        promptIR: prompt,
+        candidate,
+        constraintIR,
+        referencePlan,
+        pipelinePlan: pipelineResult.pipelinePlan,
+        outputContract: prompt.output,
+        context: fixtureM5Context(),
+        policy,
+    };
+}
+function stepPurpose(type) {
+    if (type === 'generate')
+        return 'generation';
+    if (type === 'semantic_review')
+        return 'semantic_review';
+    if (type === 'publish_asset')
+        return 'asset_publication';
+    if (type === 'resolve_asset')
+        return 'reference_interpretation';
+    return 'postprocessing';
+}
+export function fixtureM5RemoteAuthorizations(input, promptArtifactHash = 'sha256:' + '0'.repeat(64)) {
+    const artifactHashes = sorted(input.referencePlan.ordered.map((reference) => reference.contentHash));
+    const scopeIds = sorted(input.referencePlan.ordered.flatMap((reference) => reference.ontologyScopes));
+    const constraintIds = sorted(input.constraintIR.constraints.map((constraint) => constraint.id));
+    return input.pipelinePlan.steps.filter((step) => step.mayCreateChargedSubmission || step.destination !== 'local').sort((left, right) => left.id.localeCompare(right.id)).map((step) => createRemoteCallAuthorization({
+        schemaVersion: 'voce.remote-call-authorization/v1alpha1',
+        id: `m5-remote-${step.id}`,
+        caseId: input.pipelinePlan.caseId,
+        caseRevision: input.pipelinePlan.caseRevision,
+        contextHash: input.contextHash,
+        stepId: step.id,
+        purpose: stepPurpose(step.type),
+        inputHash: computeExecutionStepInputHash(step, input.contextHash, input.pipelinePlan.planHash, input.referencePlan.planHash, promptArtifactHash, artifactHashes),
+        permittedArtifactHashes: artifactHashes,
+        permittedScopeIds: scopeIds,
+        constraintIds,
+        adapterId: step.adapterId,
+        adapterDigest: step.adapterVersion.digest,
+        profileDigest: step.profileVersion.digest,
+        destination: step.destination,
+        dataCategories: sorted(step.dataTransfer.dataCategories),
+        maximumCalls: step.budget.maximumCalls,
+        maximumRetries: step.budget.maximumRetries,
+        ...(step.budget.maximumBytes === undefined && step.dataTransfer.maximumBytes === undefined ? {} : { maximumBytes: step.budget.maximumBytes ?? step.dataTransfer.maximumBytes }),
+        timeoutMs: step.budget.timeoutMs,
+        ...(step.budget.maximumCost === undefined ? {} : { maximumCost: step.budget.maximumCost }),
+        ...(step.budget.currency === undefined ? {} : { currency: step.budget.currency }),
+        idempotencyKey: `m5-idempotency-${step.id}`,
+        authority: 'fixture-authority',
+        authorizedBy: 'fixture-reviewer',
+        authorizedAt: FIXED_M5_TIME,
+    }));
+}
+export function fixtureM5ExecutionInput(profile = MOCK_IMAGE_PROFILE, promptArtifact = fixtureM5PromptIR(profile), options = {}) {
+    const promptHash = 'candidateHash' in promptArtifact ? promptArtifact.candidateHash : computePromptIRHash(promptArtifact);
+    const compilation = fixtureM5CompilationInput(profile);
+    const base = {
+        schemaVersion: 'voce.offline-execution-input/v1alpha1',
+        context: compilation.context,
+        contextHash: compilation.contextHash,
+        constraintIR: compilation.constraintIR,
+        referencePlan: compilation.referencePlan,
+        pipelinePlan: compilation.pipelinePlan,
+        outputContract: compilation.outputContract,
+        promptArtifact,
+        options,
+    };
+    const remoteCallAuthorizations = fixtureM5RemoteAuthorizations(base, promptHash);
+    const executionAuthorization = createExecutionAuthorization({
+        schemaVersion: 'voce.execution-authorization/v1alpha1',
+        id: 'm5-execution-authorization',
+        caseId: compilation.pipelinePlan.caseId,
+        caseRevision: compilation.pipelinePlan.caseRevision,
+        contextHash: compilation.contextHash,
+        constraintIRHash: compilation.constraintIR.deterministicSignature,
+        compilationSignature: compilation.constraintIR.deterministicSignature,
+        referencePlanHash: compilation.referencePlan.planHash,
+        pipelinePlanHash: compilation.pipelinePlan.planHash,
+        outputContractHash: computeOutputContractHash(compilation.outputContract),
+        promptArtifactHash: promptHash,
+        adapterProfileDigests: sorted([compilation.pipelinePlan.profileDigest, ...compilation.pipelinePlan.adapterDigests, ...compilation.pipelinePlan.steps.map((step) => step.profileVersion.digest)]),
+        destinations: sorted(compilation.pipelinePlan.dataTransfers.map((transfer) => transfer.destination)),
+        dataTransferDigest: computeExecutionDataTransferDigest(compilation.pipelinePlan),
+        budgetDigest: computeExecutionBudgetDigest(compilation.pipelinePlan),
+        remoteCallAuthorizationIds: remoteCallAuthorizations.map((authorization) => authorization.id),
+        authority: 'fixture-authority',
+        authorizedBy: 'fixture-reviewer',
+        authorizedAt: FIXED_M5_TIME,
+    });
+    return { ...base, remoteCallAuthorizations, executionAuthorization };
+}

package/dist/m6.d.ts

@@ -0,0 +1,47 @@
+import type { ArtifactHandle, AssetSink, Budget, JsonObject, ProviderResponseEnvelope, RemoteCallAuthorization, StructuralValidationArtifactInput, VersionPin } from '@voce-engine/contracts';
+export declare const FIXTURE_M6_ALPHA_PNG: Uint8Array<ArrayBuffer>;
+export declare const FIXTURE_M6_OPAQUE_PNG: Uint8Array<ArrayBuffer>;
+export declare const FIXTURE_M6_JPEG: Uint8Array<ArrayBuffer>;
+export declare function fixtureM6Artifact(id: string, bytes?: Uint8Array, mediaType?: string, role?: string): ArtifactHandle;
+export declare class RecordingAssetSink implements AssetSink {
+    readonly puts: Array<{
+        artifact: ArtifactHandle;
+        bytes: Uint8Array;
+    }>;
+    readonly remoteUrls: string[];
+    private readonly remoteBytes;
+    constructor(remoteOutputs?: Record<string, Uint8Array>);
+    put(input: {
+        bytes: Uint8Array;
+        mediaType: string;
+        role: string;
+    }): Promise<ArtifactHandle>;
+    putRemote(input: {
+        url: string;
+        mediaType?: string;
+        role: string;
+    }): Promise<ArtifactHandle | undefined>;
+    resolve(handle: ArtifactHandle): Promise<Uint8Array | undefined>;
+}
+export declare function fixtureM6Authorization(input: {
+    id?: string;
+    caseId?: string;
+    caseRevision?: number;
+    contextHash?: string;
+    stepId: string;
+    purpose: RemoteCallAuthorization['purpose'];
+    inputHash: string;
+    artifactHashes?: string[];
+    scopeIds?: string[];
+    constraintIds?: string[];
+    adapter: VersionPin;
+    profileDigest: string;
+    destination: string;
+    region?: string;
+    dataCategories?: string[];
+    budget?: Budget;
+    modelId?: string;
+    modelVersion?: string;
+}): RemoteCallAuthorization;
+export declare function fixtureStructuralArtifactInput(id?: string, bytes?: Uint8Array<ArrayBuffer>, mediaType?: string): StructuralValidationArtifactInput;
+export declare function fixtureProviderResponse(requestHash: string, body: JsonObject, status?: ProviderResponseEnvelope['status']): ProviderResponseEnvelope;

package/dist/m6.js

@@ -0,0 +1,93 @@
+import { computeArtifactBytesHash, computeProviderResponseEnvelopeHash, createRemoteCallAuthorization, sha256, } from '@voce-engine/core';
+export const FIXTURE_M6_ALPHA_PNG = Uint8Array.from([
+    137, 80, 78, 71, 13, 10, 26, 10,
+    0, 0, 0, 13, 73, 72, 68, 82,
+    0, 0, 0, 1, 0, 0, 0, 1,
+    8, 6, 0, 0, 0, 31, 21, 196, 137,
+]);
+export const FIXTURE_M6_OPAQUE_PNG = Uint8Array.from([
+    137, 80, 78, 71, 13, 10, 26, 10,
+    0, 0, 0, 13, 73, 72, 68, 82,
+    0, 0, 0, 1, 0, 0, 0, 1,
+    8, 2, 0, 0, 0, 144, 119, 83, 222,
+]);
+export const FIXTURE_M6_JPEG = Uint8Array.from([255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 255, 217]);
+export function fixtureM6Artifact(id, bytes = FIXTURE_M6_OPAQUE_PNG, mediaType = 'image/png', role = 'generated-image') {
+    return {
+        id,
+        storeId: 'm6-fixture-store',
+        contentHash: computeArtifactBytesHash(bytes),
+        mediaType,
+        byteLength: bytes.byteLength,
+        role,
+        resolverId: 'm6-fixture-resolver',
+        availability: 'available',
+        retentionClass: 'fixture',
+        redactionPolicy: 'safe-hash-only',
+    };
+}
+export class RecordingAssetSink {
+    puts = [];
+    remoteUrls = [];
+    remoteBytes = new Map();
+    constructor(remoteOutputs = {}) {
+        for (const [url, bytes] of Object.entries(remoteOutputs))
+            this.remoteBytes.set(url, new Uint8Array(bytes));
+    }
+    async put(input) {
+        const bytes = new Uint8Array(input.bytes);
+        const artifact = fixtureM6Artifact(`m6-artifact-${this.puts.length + 1}`, bytes, input.mediaType, input.role);
+        this.puts.push({ artifact, bytes });
+        return { ...artifact };
+    }
+    async putRemote(input) {
+        this.remoteUrls.push(input.url);
+        const bytes = this.remoteBytes.get(input.url);
+        return bytes ? this.put({ bytes, mediaType: input.mediaType ?? 'image/png', role: input.role }) : undefined;
+    }
+    async resolve(handle) {
+        const found = this.puts.find((item) => item.artifact.id === handle.id);
+        return found ? new Uint8Array(found.bytes) : undefined;
+    }
+}
+export function fixtureM6Authorization(input) {
+    const budget = input.budget ?? { schemaVersion: 'voce.budget/v1alpha1', id: `m6-budget-${input.stepId}`, maximumCalls: 1, maximumRetries: 0, timeoutMs: 60_000 };
+    return createRemoteCallAuthorization({
+        schemaVersion: 'voce.remote-call-authorization/v1alpha1',
+        id: input.id ?? `m6-auth-${input.stepId}`,
+        caseId: input.caseId ?? 'm6-fixture-case',
+        caseRevision: input.caseRevision ?? 1,
+        contextHash: input.contextHash ?? sha256({ fixture: 'm6-context' }),
+        stepId: input.stepId,
+        purpose: input.purpose,
+        inputHash: input.inputHash,
+        permittedArtifactHashes: [...(input.artifactHashes ?? [])].sort(),
+        permittedScopeIds: [...(input.scopeIds ?? [])].sort(),
+        constraintIds: [...(input.constraintIds ?? [])].sort(),
+        ...(input.modelId === undefined ? {} : { modelId: input.modelId }),
+        ...(input.modelVersion === undefined ? {} : { modelVersion: input.modelVersion }),
+        adapterId: input.adapter.id,
+        adapterDigest: input.adapter.digest,
+        profileDigest: input.profileDigest,
+        destination: input.destination,
+        ...(input.region === undefined ? {} : { region: input.region }),
+        dataCategories: [...(input.dataCategories ?? ['image'])].sort(),
+        maximumCalls: budget.maximumCalls,
+        maximumRetries: budget.maximumRetries,
+        ...(budget.maximumBytes === undefined ? {} : { maximumBytes: budget.maximumBytes }),
+        timeoutMs: budget.timeoutMs,
+        ...(budget.maximumCost === undefined ? {} : { maximumCost: budget.maximumCost }),
+        ...(budget.currency === undefined ? {} : { currency: budget.currency }),
+        idempotencyKey: `m6-idempotency-${input.stepId}`,
+        authority: 'm6-fixture-authority',
+        authorizedBy: 'm6-fixture-reviewer',
+        authorizedAt: '2026-01-01T00:00:00.000Z',
+    });
+}
+export function fixtureStructuralArtifactInput(id = 'm6-image', bytes = FIXTURE_M6_OPAQUE_PNG, mediaType = 'image/png') {
+    return { artifact: fixtureM6Artifact(id, bytes, mediaType), bytes: new Uint8Array(bytes) };
+}
+export function fixtureProviderResponse(requestHash, body, status = 'succeeded') {
+    const base = { schemaVersion: 'voce.provider-response-envelope/v1alpha1', requestHash, status, outputArtifactIds: [], body };
+    return { ...base, responseHash: computeProviderResponseEnvelopeHash(base) };
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@voce-engine/testkit",
+  "version": "0.1.0-rc.1",
+  "description": "Deterministic fixtures and Mock-only helpers for offline VOCE contract and runtime tests.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/m4.js",
+    "dist/m4.d.ts",
+    "dist/m5.js",
+    "dist/m5.d.ts",
+    "dist/m6.js",
+    "dist/m6.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/windforce19820520-ai/visual-ontology-constraint-engine.git",
+    "directory": "packages/testkit"
+  },
+  "homepage": "https://github.com/windforce19820520-ai/visual-ontology-constraint-engine#readme",
+  "bugs": {
+    "url": "https://github.com/windforce19820520-ai/visual-ontology-constraint-engine/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "dependencies": {
+    "@voce-engine/core": "0.1.0-rc.1",
+    "@voce-engine/contracts": "0.1.0-rc.1"
+  }
+}