@aiwg/cli 2026.9.0 → 2026.9.2

package/dist/src/dataset/conformance.js

@@ -0,0 +1,90 @@
+import { createHash } from 'node:crypto';
+import { DATASET_CONFORMANCE_CONTRACT } from './conformance-types.js';
+const SHA256 = /^sha256:[0-9a-f]{64}$/u;
+const SECRET = /(?:(?:password|passwd|api[-_]?key|authorization)\s*[:=]\s*[^\s"}]+|bearer\s+[a-z0-9._~+/-]+|-----BEGIN [A-Z ]+PRIVATE KEY-----)/iu;
+export function canonicalConformanceJson(value) {
+    if (value === null || typeof value !== 'object')
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map(canonicalConformanceJson).join(',')}]`;
+    return `{${Object.entries(value)
+        .filter(([, item]) => item !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${canonicalConformanceJson(item)}`).join(',')}}`;
+}
+export function conformanceDigest(value) {
+    return `sha256:${createHash('sha256').update(canonicalConformanceJson(value)).digest('hex')}`;
+}
+export function resultDigest(results) {
+    return conformanceDigest([...results].sort((a, b) => a.cellId.localeCompare(b.cellId)).map(result => ({
+        cellId: result.cellId,
+        status: result.status,
+        diagnostic: result.diagnostic,
+        evidence: [...result.evidence].sort((a, b) => `${a.kind}:${a.reference}`.localeCompare(`${b.kind}:${b.reference}`)),
+        observed: result.observed,
+    })));
+}
+export function validateConformanceManifest(manifest) {
+    const diagnostics = [];
+    if (manifest.contract !== DATASET_CONFORMANCE_CONTRACT || !/^1\./u.test(manifest.schemaVersion) || !manifest.corpusVersion) {
+        diagnostics.push({ code: 'CONFORMANCE_MANIFEST_INVALID', path: '/', message: 'Unsupported contract, schema version, or empty corpus version.' });
+    }
+    const seen = new Set();
+    manifest.cells.forEach((cell, index) => {
+        const path = `/cells/${index}`;
+        if (!cell.id || seen.has(cell.id))
+            diagnostics.push({ code: 'CONFORMANCE_CELL_DUPLICATE', path: `${path}/id`, message: `Cell id ${cell.id || '<empty>'} is not unique.` });
+        seen.add(cell.id);
+        if (!SHA256.test(cell.fixture.digest))
+            diagnostics.push({ code: 'CONFORMANCE_MANIFEST_INVALID', path: `${path}/fixture/digest`, message: 'Fixture digest must be sha256.' });
+        if (!cell.resourceEnvelope || cell.resourceEnvelope.maxBytes < 1 || cell.resourceEnvelope.maxRecords < 1 || cell.resourceEnvelope.maxDurationMs < 1) {
+            diagnostics.push({ code: 'CONFORMANCE_RESOURCE_ENVELOPE_MISSING', path: `${path}/resourceEnvelope`, message: 'Every cell requires positive byte, record, and duration bounds.' });
+        }
+        if (cell.maturity === 'stable' && !cell.evidence.some(kind => kind === 'real-source' || kind === 'cross-repo' || kind === 'live-qualification')) {
+            diagnostics.push({ code: 'CONFORMANCE_MOCK_ONLY_STABLE', path: `${path}/evidence`, message: 'Stable cells require non-fixture evidence.' });
+        }
+        if (cell.runtimeClass === 'fortemi-server' && cell.maturity === 'stable' && !cell.liveAuthorizationRequired) {
+            diagnostics.push({ code: 'CONFORMANCE_MANIFEST_INVALID', path: `${path}/liveAuthorizationRequired`, message: 'Stable server cells must declare the live authorization gate.' });
+        }
+    });
+    return diagnostics;
+}
+export function summarizeConformance(manifest, results) {
+    const passed = results.filter(result => result.status === 'passed').length;
+    const failed = results.filter(result => result.status === 'failed').length;
+    const pending = results.filter(result => result.status === 'pending').length;
+    const releaseIds = new Set(manifest.cells.filter(cell => cell.maturity !== 'experimental').map(cell => cell.id));
+    const stableEligible = failed === 0 && [...releaseIds].every(id => results.some(result => result.cellId === id && result.status === 'passed'));
+    return { passed, failed, pending, stableEligible };
+}
+export function verifyConformanceReceipt(manifest, receipt) {
+    const diagnostics = validateConformanceManifest(manifest);
+    if (receipt.manifestDigest !== conformanceDigest(manifest) || receipt.corpusVersion !== manifest.corpusVersion) {
+        diagnostics.push({ code: 'CONFORMANCE_RECEIPT_STALE', path: '/manifestDigest', message: 'Receipt does not bind the current manifest and corpus.' });
+    }
+    if (receipt.resultDigest !== resultDigest(receipt.results))
+        diagnostics.push({ code: 'CONFORMANCE_RESULT_DIGEST_MISMATCH', path: '/resultDigest', message: 'Result digest does not match canonical results.' });
+    if (!SHA256.test(receipt.bindings.aiwgCommit) && !/^[0-9a-f]{40}$/u.test(receipt.bindings.aiwgCommit))
+        diagnostics.push({ code: 'CONFORMANCE_RECEIPT_UNVERIFIABLE', path: '/bindings/aiwgCommit', message: 'AIWG commit binding is invalid.' });
+    if (Object.keys(receipt.bindings.packageDigests).length === 0 || Object.keys(receipt.bindings.schemaDigests).length === 0)
+        diagnostics.push({ code: 'CONFORMANCE_RECEIPT_UNVERIFIABLE', path: '/bindings', message: 'Package and schema digest bindings are required.' });
+    const resultById = new Map(receipt.results.map(result => [result.cellId, result]));
+    manifest.cells.forEach(cell => {
+        const result = resultById.get(cell.id);
+        if (!result)
+            diagnostics.push({ code: 'CONFORMANCE_REQUIRED_CELL_MISSING', path: `/results/${cell.id}`, message: `Required cell ${cell.id} is missing.` });
+        else if (result.status === 'failed')
+            diagnostics.push({ code: 'CONFORMANCE_RESULT_FAILED', path: `/results/${cell.id}`, message: `Cell ${cell.id} failed: ${result.diagnostic ?? 'no diagnostic'}.` });
+        else if (result.status === 'pending' && cell.maturity === 'stable')
+            diagnostics.push({ code: 'CONFORMANCE_PENDING_STABLE_CELL', path: `/results/${cell.id}`, message: `Stable cell ${cell.id} cannot be pending.` });
+        else if (result.status === 'passed' && cell.evidence.some(required => !result.evidence.some(item => item.kind === required)))
+            diagnostics.push({ code: 'CONFORMANCE_EVIDENCE_WEAKENED', path: `/results/${cell.id}/evidence`, message: `Cell ${cell.id} lacks a required evidence kind.` });
+    });
+    if (SECRET.test(JSON.stringify(receipt)))
+        diagnostics.push({ code: 'CONFORMANCE_SENSITIVE_VALUE', path: '/', message: 'Receipt contains a secret-like value.' });
+    const summary = summarizeConformance(manifest, receipt.results);
+    if (canonicalConformanceJson(summary) !== canonicalConformanceJson(receipt.summary))
+        diagnostics.push({ code: 'CONFORMANCE_RECEIPT_UNVERIFIABLE', path: '/summary', message: 'Receipt summary is inconsistent with results.' });
+    return diagnostics;
+}
+//# sourceMappingURL=conformance.js.map

package/dist/src/dataset/contracts.d.ts

@@ -0,0 +1,17 @@
+import { type CapabilityNegotiationReceipt, type CapabilityProfile, type Checkpoint, type AvailableDatasetCapability, type DatasetContract, type DatasetDiagnostic, type DatasetValidationResult, type Digest, type ProcessingPlan, type RunReceipt } from './types.js';
+export declare function validateDatasetContract(value: unknown): DatasetValidationResult;
+export declare function canonicalDatasetJson(value: unknown): string;
+export declare function datasetDigest(value: unknown): Digest;
+export declare function computeProcessingPlanDigest(plan: ProcessingPlan): Digest;
+export declare function verifyProcessingPlanDigest(plan: ProcessingPlan): boolean;
+export declare function computeRunReceiptDigest(receipt: RunReceipt): Digest;
+export declare function verifyRunReceiptDigest(receipt: RunReceipt): boolean;
+export declare function negotiateDatasetCapabilities(profile: CapabilityProfile, available: readonly (string | AvailableDatasetCapability)[]): CapabilityNegotiationReceipt;
+/** Validate identity references across a complete contract bundle. */
+export declare function validateDatasetContractSet(contracts: readonly DatasetContract[]): DatasetDiagnostic[];
+export declare function validateCheckpointAncestry(checkpoint: Checkpoint, prior?: RunReceipt): DatasetDiagnostic[];
+export declare class DatasetContractError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/src/dataset/contracts.js

@@ -0,0 +1,236 @@
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { DATASET_CONTRACT_VERSION, } from './types.js';
+const CONTRACT_KINDS = new Set([
+    'DatasetSource', 'Dataset', 'DatasetRevision', 'Distribution',
+    'CapabilityProfile', 'ProcessingPlan', 'ProcessingRun', 'DerivedArtifact',
+    'ProvenanceAssertion', 'Relationship', 'Checkpoint', 'RunReceipt',
+]);
+const RUN_OUTCOMES = new Set(['preview', 'attempted', 'committed', 'rejected', 'cancelled', 'failed']);
+const SECRET_KEYS = /^(?:password|passwd|secret|token|api[-_]?key|private[-_]?key|credential)s?$/i;
+function packageRoot(start) {
+    let current = resolve(start);
+    for (;;) {
+        try {
+            const packageJson = JSON.parse(readFileSync(join(current, 'package.json'), 'utf8'));
+            // The source tree is named `aiwg`; the release packager rewrites the
+            // installed distribution to `@aiwg/cli`. Both layouts contain the same
+            // governed schemas, so package discovery must recognize both identities.
+            if (packageJson.name === 'aiwg' || packageJson.name === '@aiwg/cli')
+                return current;
+        }
+        catch {
+            // Keep walking; source and compiled modules have different depths.
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            throw new Error('dataset contracts: could not locate the aiwg package root');
+        current = parent;
+    }
+}
+const contractSchemaPath = join(packageRoot(dirname(fileURLToPath(import.meta.url))), 'schemas/dataset/dataset-contracts.v1.schema.json');
+const contractSchema = JSON.parse(readFileSync(contractSchemaPath, 'utf8'));
+const contractAjv = new Ajv2020({ strict: true, allErrors: true });
+addFormats(contractAjv);
+const validateSerializedContract = contractAjv.compile(contractSchema);
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function diagnostic(code, message, path) {
+    return { code, message, ...(path === undefined ? {} : { path }) };
+}
+function detectEmbeddedSecrets(value, path = '') {
+    if (Array.isArray(value))
+        return value.flatMap((item, index) => detectEmbeddedSecrets(item, `${path}/${index}`));
+    if (!isRecord(value))
+        return [];
+    return Object.entries(value).flatMap(([key, nested]) => SECRET_KEYS.test(key)
+        ? [diagnostic('DATASET_EMBEDDED_CREDENTIAL', `credential material is forbidden in contract field ${key}`, `${path}/${key}`)]
+        : detectEmbeddedSecrets(nested, `${path}/${key}`));
+}
+function requiredString(record, key, diagnostics) {
+    if (typeof record[key] !== 'string' || record[key].length === 0)
+        diagnostics.push(diagnostic('DATASET_REQUIRED_FIELD', `${key} must be a non-empty string`, `/${key}`));
+}
+export function validateDatasetContract(value) {
+    if (!isRecord(value))
+        return { valid: false, diagnostics: [diagnostic('DATASET_CONTRACT_INVALID', 'contract must be an object')] };
+    validateSerializedContract(value);
+    const diagnostics = (validateSerializedContract.errors ?? []).map((error) => diagnostic('DATASET_SCHEMA_INVALID', error.message ?? 'schema validation failed', error.instancePath || '/'));
+    diagnostics.push(...detectEmbeddedSecrets(value));
+    requiredString(value, 'contractVersion', diagnostics);
+    requiredString(value, 'kind', diagnostics);
+    requiredString(value, 'id', diagnostics);
+    if (value.contractVersion !== DATASET_CONTRACT_VERSION)
+        diagnostics.push(diagnostic('DATASET_CONTRACT_VERSION_UNSUPPORTED', `unsupported contract version ${String(value.contractVersion)}; expected ${DATASET_CONTRACT_VERSION}`, '/contractVersion'));
+    if (typeof value.kind !== 'string' || !CONTRACT_KINDS.has(value.kind))
+        diagnostics.push(diagnostic('DATASET_CONTRACT_KIND_UNKNOWN', `unknown contract kind ${String(value.kind)}`, '/kind'));
+    if (value.kind === 'Dataset' && value.id !== value.logicalId)
+        diagnostics.push(diagnostic('DATASET_LOGICAL_ID_MISMATCH', 'Dataset id must equal its stable logicalId', '/logicalId'));
+    if (value.kind === 'DatasetRevision') {
+        if (value.id === value.datasetId)
+            diagnostics.push(diagnostic('DATASET_IDENTITY_CONFLATED', 'revision identity must differ from logical dataset identity', '/id'));
+        if (value.id !== value.revisionId)
+            diagnostics.push(diagnostic('DATASET_REVISION_ID_MISMATCH', 'DatasetRevision id must equal revisionId', '/revisionId'));
+    }
+    if (value.kind === 'ProcessingPlan') {
+        if (!Array.isArray(value.steps) || value.steps.length === 0)
+            diagnostics.push(diagnostic('DATASET_PLAN_EMPTY', 'processing plan requires at least one step', '/steps'));
+    }
+    if (value.kind === 'ProcessingRun' || value.kind === 'RunReceipt') {
+        if (!RUN_OUTCOMES.has(String(value.outcome)))
+            diagnostics.push(diagnostic('DATASET_RUN_OUTCOME_INVALID', 'run outcome is invalid', '/outcome'));
+    }
+    if (value.kind === 'RunReceipt') {
+        const committed = value.committed === true;
+        if (committed !== (value.outcome === 'committed'))
+            diagnostics.push(diagnostic('DATASET_RECEIPT_OUTCOME_CONFLICT', 'committed is true exactly when outcome is committed', '/committed'));
+        if (typeof value.committedRecords === 'number' && typeof value.attemptedRecords === 'number' && value.committedRecords > value.attemptedRecords)
+            diagnostics.push(diagnostic('DATASET_RECEIPT_COUNT_INVALID', 'committedRecords cannot exceed attemptedRecords', '/committedRecords'));
+        if (typeof value.rejectedRecords === 'number' && typeof value.attemptedRecords === 'number' && value.rejectedRecords > value.attemptedRecords)
+            diagnostics.push(diagnostic('DATASET_RECEIPT_COUNT_INVALID', 'rejectedRecords cannot exceed attemptedRecords', '/rejectedRecords'));
+    }
+    if ((value.kind === 'Relationship' || value.kind === 'ProvenanceAssertion') && value.basis === 'observed' && typeof value.runId !== 'string')
+        diagnostics.push(diagnostic('DATASET_OBSERVED_LINEAGE_RUN_REQUIRED', 'observed lineage requires runId', '/runId'));
+    return diagnostics.length ? { valid: false, diagnostics } : { valid: true, value: value, diagnostics: [] };
+}
+export function canonicalDatasetJson(value) {
+    const visit = (item) => {
+        if (Array.isArray(item))
+            return item.map(visit);
+        if (!isRecord(item))
+            return item;
+        return Object.fromEntries(Object.keys(item).sort().map((key) => [key, visit(item[key])]));
+    };
+    return JSON.stringify(visit(value));
+}
+export function datasetDigest(value) {
+    return { algorithm: 'sha256', value: createHash('sha256').update(canonicalDatasetJson(value)).digest('hex') };
+}
+function withoutDigest(plan) {
+    const { planDigest: _planDigest, ...declaration } = plan;
+    return declaration;
+}
+function receiptWithoutDigest(receipt) {
+    const { receiptDigest: _receiptDigest, ...observation } = receipt;
+    return observation;
+}
+export function computeProcessingPlanDigest(plan) {
+    return datasetDigest(withoutDigest(plan));
+}
+export function verifyProcessingPlanDigest(plan) {
+    return plan.planDigest.algorithm === 'sha256' && plan.planDigest.value === computeProcessingPlanDigest(plan).value;
+}
+export function computeRunReceiptDigest(receipt) {
+    return datasetDigest(receiptWithoutDigest(receipt));
+}
+export function verifyRunReceiptDigest(receipt) {
+    return receipt.receiptDigest.algorithm === 'sha256' && receipt.receiptDigest.value === computeRunReceiptDigest(receipt).value;
+}
+export function negotiateDatasetCapabilities(profile, available) {
+    const offered = new Map(available.map((capability) => typeof capability === 'string' ? [capability, undefined] : [capability.name, capability.version]));
+    const satisfied = [];
+    const degraded = [];
+    for (const capability of profile.capabilities) {
+        const offeredVersion = offered.get(capability.name);
+        const versionAccepted = !capability.acceptedVersions?.length || (offeredVersion !== undefined && capability.acceptedVersions.includes(offeredVersion));
+        if (offered.has(capability.name) && versionAccepted) {
+            satisfied.push(capability.name);
+            continue;
+        }
+        if (capability.requirement === 'required' || capability.degradation.action === 'fail')
+            throw new DatasetContractError('DATASET_REQUIRED_CAPABILITY_UNSUPPORTED', `required capability is unavailable: ${capability.name}`);
+        const action = capability.degradation.action;
+        if (action === 'disable')
+            degraded.push({ capability: capability.name, action });
+        else
+            degraded.push({ capability: capability.name, action, ...(capability.degradation.fallbackCapability ? { fallbackCapability: capability.degradation.fallbackCapability } : {}) });
+    }
+    return { contractVersion: DATASET_CONTRACT_VERSION, satisfied: satisfied.sort(), degraded: degraded.sort((a, b) => a.capability.localeCompare(b.capability)) };
+}
+/** Validate identity references across a complete contract bundle. */
+export function validateDatasetContractSet(contracts) {
+    const diagnostics = [];
+    const ids = new Set();
+    for (const contract of contracts) {
+        if (ids.has(contract.id))
+            diagnostics.push(diagnostic('DATASET_ID_DUPLICATE', `duplicate contract identity ${contract.id}`));
+        ids.add(contract.id);
+    }
+    const requireReference = (owner, target, field) => {
+        if (target && !ids.has(target))
+            diagnostics.push(diagnostic('DATASET_REFERENCE_DANGLING', `${owner.kind} ${owner.id} references unknown identity ${target}`, `/${field}`));
+    };
+    for (const contract of contracts) {
+        switch (contract.kind) {
+            case 'DatasetRevision':
+                requireReference(contract, contract.datasetId, 'datasetId');
+                for (const sourceId of contract.sourceIds)
+                    requireReference(contract, sourceId, 'sourceIds');
+                break;
+            case 'Distribution':
+                requireReference(contract, contract.datasetRevisionId, 'datasetRevisionId');
+                break;
+            case 'ProcessingPlan':
+                requireReference(contract, contract.datasetRevisionId, 'datasetRevisionId');
+                requireReference(contract, contract.capabilityProfileId, 'capabilityProfileId');
+                break;
+            case 'ProcessingRun':
+                requireReference(contract, contract.planId, 'planId');
+                break;
+            case 'DerivedArtifact':
+                requireReference(contract, contract.sourceRevisionId, 'sourceRevisionId');
+                requireReference(contract, contract.runId, 'runId');
+                break;
+            case 'ProvenanceAssertion':
+                requireReference(contract, contract.subjectId, 'subjectId');
+                requireReference(contract, contract.objectId, 'objectId');
+                requireReference(contract, contract.sourceRevisionId, 'sourceRevisionId');
+                requireReference(contract, contract.runId, 'runId');
+                break;
+            case 'Relationship':
+                requireReference(contract, contract.sourceId, 'sourceId');
+                requireReference(contract, contract.targetId, 'targetId');
+                requireReference(contract, contract.sourceRevisionId, 'sourceRevisionId');
+                requireReference(contract, contract.runId, 'runId');
+                break;
+            case 'Checkpoint':
+                requireReference(contract, contract.sourceId, 'sourceId');
+                requireReference(contract, contract.priorCommittedReceiptId, 'priorCommittedReceiptId');
+                break;
+            case 'RunReceipt':
+                requireReference(contract, contract.runId, 'runId');
+                requireReference(contract, contract.planId, 'planId');
+                requireReference(contract, contract.checkpointBeforeId, 'checkpointBeforeId');
+                requireReference(contract, contract.checkpointAfterId, 'checkpointAfterId');
+                requireReference(contract, contract.priorCommittedReceiptId, 'priorCommittedReceiptId');
+                break;
+            default: break;
+        }
+    }
+    return diagnostics;
+}
+export function validateCheckpointAncestry(checkpoint, prior) {
+    if (!checkpoint.priorCommittedReceiptId)
+        return [];
+    if (!prior || prior.id !== checkpoint.priorCommittedReceiptId)
+        return [diagnostic('DATASET_CHECKPOINT_ANCESTRY_MISSING', 'checkpoint prior committed receipt is unavailable', '/priorCommittedReceiptId')];
+    if (!prior.committed || prior.outcome !== 'committed')
+        return [diagnostic('DATASET_CHECKPOINT_ANCESTRY_UNCOMMITTED', 'checkpoint ancestry must reference a committed receipt', '/priorCommittedReceiptId')];
+    if (prior.planDigest.value !== checkpoint.planDigest.value)
+        return [diagnostic('DATASET_CHECKPOINT_PLAN_MISMATCH', 'checkpoint and prior receipt plan digests differ', '/planDigest')];
+    return [];
+}
+export class DatasetContractError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'DatasetContractError';
+    }
+}
+//# sourceMappingURL=contracts.js.map

package/dist/src/dataset/file-orchestration-repository.d.ts

@@ -0,0 +1,19 @@
+import type { ProcessingPlan } from "./types.js";
+import type { DatasetRunState, RegisteredSource } from "./orchestration-types.js";
+import type { DatasetOrchestrationRepository } from "./orchestration-repository.js";
+export declare class FileDatasetOrchestrationRepository implements DatasetOrchestrationRepository {
+    readonly path: string;
+    constructor(root: string);
+    private read;
+    private update;
+    getSource(id: string): Promise<RegisteredSource>;
+    putSource(v: RegisteredSource): Promise<void>;
+    getPlan(id: string): Promise<ProcessingPlan>;
+    putPlan(v: ProcessingPlan): Promise<void>;
+    getRun(id: string): Promise<DatasetRunState>;
+    getRunByIdempotency(k: string): Promise<DatasetRunState | undefined>;
+    putRun(v: DatasetRunState): Promise<void>;
+    listArtifactRecords(id: string): Promise<readonly unknown[]>;
+    putArtifactRecords(id: string, v: readonly unknown[]): Promise<void>;
+}
+//# sourceMappingURL=file-orchestration-repository.d.ts.map

package/dist/src/dataset/file-orchestration-repository.js

@@ -0,0 +1,68 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+const empty = () => ({
+    sources: {},
+    plans: {},
+    runs: {},
+    artifacts: {},
+});
+export class FileDatasetOrchestrationRepository {
+    path;
+    constructor(root) {
+        this.path = join(resolve(root), ".aiwg", "dataset", "state.v1.json");
+    }
+    async read() {
+        try {
+            return JSON.parse(await readFile(this.path, "utf8"));
+        }
+        catch (e) {
+            if (e.code === "ENOENT")
+                return empty();
+            throw e;
+        }
+    }
+    async update(fn) {
+        const s = await this.read();
+        fn(s);
+        await mkdir(dirname(this.path), { recursive: true });
+        const tmp = `${this.path}.${process.pid}.tmp`;
+        await writeFile(tmp, JSON.stringify(s, null, 2) + "\n", { mode: 0o600 });
+        await rename(tmp, this.path);
+    }
+    async getSource(id) {
+        return (await this.read()).sources[id];
+    }
+    async putSource(v) {
+        await this.update((s) => {
+            s.sources[v.id] = v;
+        });
+    }
+    async getPlan(id) {
+        return (await this.read()).plans[id];
+    }
+    async putPlan(v) {
+        await this.update((s) => {
+            s.plans[v.id] = v;
+        });
+    }
+    async getRun(id) {
+        return (await this.read()).runs[id];
+    }
+    async getRunByIdempotency(k) {
+        return Object.values((await this.read()).runs).find((v) => v.idempotencyKey === k);
+    }
+    async putRun(v) {
+        await this.update((s) => {
+            s.runs[v.runId] = v;
+        });
+    }
+    async listArtifactRecords(id) {
+        return (await this.read()).artifacts[id] ?? [];
+    }
+    async putArtifactRecords(id, v) {
+        await this.update((s) => {
+            s.artifacts[id] = v;
+        });
+    }
+}
+//# sourceMappingURL=file-orchestration-repository.js.map

package/dist/src/dataset/fortemi-execution-bridge.d.ts

@@ -0,0 +1,33 @@
+import type { DatasetExecutionBackend, ExecutionRequest, ExecutionResult } from "./orchestration-types.js";
+import type { RunReceipt } from "./types.js";
+export interface FortemiTransport {
+    capabilities(): Promise<readonly {
+        name: string;
+        version: string;
+    }[]>;
+    execute(request: {
+        plan: unknown;
+        records: readonly unknown[];
+        signal?: AbortSignal;
+    }): Promise<{
+        result: ExecutionResult;
+        receipt: RunReceipt;
+    }>;
+}
+export declare class FortemiExecutionBridge implements DatasetExecutionBackend {
+    private readonly transport?;
+    readonly id = "fortemi-core";
+    private offered;
+    constructor(transport?: FortemiTransport | undefined);
+    capabilities(): readonly {
+        name: string;
+        version: string;
+    }[];
+    negotiate(): Promise<readonly {
+        name: string;
+        version: string;
+    }[]>;
+    execute(r: ExecutionRequest): Promise<ExecutionResult>;
+}
+export declare function sealFortemiFixtureReceipt(receipt: RunReceipt): RunReceipt;
+//# sourceMappingURL=fortemi-execution-bridge.d.ts.map

package/dist/src/dataset/fortemi-execution-bridge.js

@@ -0,0 +1,35 @@
+import { computeRunReceiptDigest, verifyRunReceiptDigest, } from "./contracts.js";
+export class FortemiExecutionBridge {
+    transport;
+    id = "fortemi-core";
+    offered = [];
+    constructor(transport) {
+        this.transport = transport;
+    }
+    capabilities() {
+        return this.offered;
+    }
+    async negotiate() {
+        if (!this.transport)
+            throw new Error("DATASET_FORTEMI_UNAVAILABLE: injected Fortemi transport required");
+        this.offered = await this.transport.capabilities();
+        return this.offered;
+    }
+    async execute(r) {
+        if (!this.transport)
+            throw new Error("DATASET_FORTEMI_UNAVAILABLE: injected Fortemi transport required");
+        const response = await this.transport.execute({
+            plan: r.plan,
+            records: r.records,
+            signal: r.signal,
+        });
+        if (response.receipt.planDigest.value !== r.plan.planDigest.value ||
+            !verifyRunReceiptDigest(response.receipt))
+            throw new Error("DATASET_FORTEMI_RECEIPT_INVALID");
+        return response.result;
+    }
+}
+export function sealFortemiFixtureReceipt(receipt) {
+    return { ...receipt, receiptDigest: computeRunReceiptDigest(receipt) };
+}
+//# sourceMappingURL=fortemi-execution-bridge.js.map

package/dist/src/dataset/index.d.ts

@@ -0,0 +1,21 @@
+export * from './types.js';
+export * from './contracts.js';
+export * from './schema-governance.js';
+export * from './ledger-types.js';
+export * from './ledger.js';
+export * from './projections.js';
+export * from './standards-types.js';
+export * from './standards.js';
+export * from './adapter-types.js';
+export * from './adapter-sdk.js';
+export * from './adapters.js';
+export * from './orchestration-types.js';
+export * from './orchestration-repository.js';
+export * from './file-orchestration-repository.js';
+export * from './local-execution-backend.js';
+export * from './fortemi-execution-bridge.js';
+export * from './orchestration-service.js';
+export * from './presentation.js';
+export * from './conformance-types.js';
+export * from './conformance.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/dataset/index.js

@@ -0,0 +1,21 @@
+export * from './types.js';
+export * from './contracts.js';
+export * from './schema-governance.js';
+export * from './ledger-types.js';
+export * from './ledger.js';
+export * from './projections.js';
+export * from './standards-types.js';
+export * from './standards.js';
+export * from './adapter-types.js';
+export * from './adapter-sdk.js';
+export * from './adapters.js';
+export * from './orchestration-types.js';
+export * from './orchestration-repository.js';
+export * from './file-orchestration-repository.js';
+export * from './local-execution-backend.js';
+export * from './fortemi-execution-bridge.js';
+export * from './orchestration-service.js';
+export * from './presentation.js';
+export * from './conformance-types.js';
+export * from './conformance.js';
+//# sourceMappingURL=index.js.map