@obversa/api 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonny Neill
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# @obversa/api
+
+`@obversa/api` defines the shared contracts and validation used by Obversa
+runtimes and plugins. It includes the engine, memory, and workspace ports
+and their conformance kits. The runtime still runs graphs and writes records.
+
+## Requirements
+
+- Node.js 22.12 or later
+
+## Build from the workspace
+
+From the workspace root, run:
+
+```bash
+corepack enable
+pnpm install --frozen-lockfile
+pnpm --filter @obversa/api build
+```
+
+## Contract
+
+An engine runs one fresh agent attempt:
+
+```ts
+import type { Engine } from '@obversa/api';
+
+declare const engine: Engine;
+
+const result = await engine.run(
+  { prompt: 'Review this change.' },
+  () => {},
+  new AbortController().signal,
+);
+```
+
+## Adapter conformance
+
+Import the framework-free conformance runner from `@obversa/api/testing`
+and the offline mock from `@obversa/core/testing`.
+
+## Command adapters
+
+Import owned-process execution and inspection from `@obversa/core/command`.
+The command runner bounds time, retained output, and process-tree memory.
+
+## License
+
+[MIT](LICENSE)

package/dist/accepted-result-support.d.ts

@@ -0,0 +1 @@
+export { acceptedResultSupport } from './proof/acceptance.js';

package/dist/accepted-result-support.js

@@ -0,0 +1,5 @@
+export { acceptedResultSupport } from './chunk-6NA4RDQ4.js';
+import './chunk-WGLWWKF3.js';
+import './chunk-AJ353QD5.js';
+//# sourceMappingURL=accepted-result-support.js.map
+//# sourceMappingURL=accepted-result-support.js.map

package/dist/accepted-result-support.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"accepted-result-support.js"}

package/dist/action-decision.d.ts

@@ -0,0 +1,15 @@
+import { type JsonObject, type JsonValue } from './json.js';
+export interface AllowActionDecision extends JsonObject {
+    readonly kind: 'allow';
+}
+export interface WaitActionDecision extends JsonObject {
+    readonly kind: 'wait';
+    readonly reason: string;
+    readonly request: JsonValue;
+}
+export interface DenyActionDecision extends JsonObject {
+    readonly kind: 'deny';
+    readonly reason: string;
+}
+export type ActionDecision = AllowActionDecision | WaitActionDecision | DenyActionDecision;
+export declare function validateActionDecision(value: ActionDecision): ActionDecision;

package/dist/approval-support.d.ts

@@ -0,0 +1 @@
+export { bindingFromSubject, hasExactFields, isObject } from './callback/approval.js';

package/dist/approval-support.js

@@ -0,0 +1,5 @@
+export { bindingFromSubject, hasExactFields, isObject } from './chunk-6NAMCSPJ.js';
+import './chunk-WGLWWKF3.js';
+import './chunk-AJ353QD5.js';
+//# sourceMappingURL=approval-support.js.map
+//# sourceMappingURL=approval-support.js.map

package/dist/approval-support.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"approval-support.js"}

package/dist/artifacts/conformance.d.ts

@@ -0,0 +1,20 @@
+import type { ArtifactStore } from './store.js';
+export interface ArtifactStoreConformanceOptions {
+    readonly maxArtifactBytes: number;
+    readonly maxTotalArtifactBytesPerRun: number;
+    readonly knownSecrets: readonly string[];
+}
+export type ArtifactStoreConformanceFactory = (options: ArtifactStoreConformanceOptions) => ArtifactStore | Promise<ArtifactStore>;
+export interface ArtifactStoreConformanceFailure {
+    readonly case: string;
+    readonly message: string;
+}
+export interface ArtifactStoreConformanceReport {
+    readonly ok: boolean;
+    readonly cases: number;
+    readonly failures: readonly ArtifactStoreConformanceFailure[];
+}
+/** Run the framework-free behavioral checks for an ArtifactStore provider. */
+export declare function runArtifactStoreConformance(factory: ArtifactStoreConformanceFactory): Promise<ArtifactStoreConformanceReport>;
+/** Throw one readable error when an ArtifactStore provider breaks the contract. */
+export declare function assertArtifactStoreConformance(factory: ArtifactStoreConformanceFactory): Promise<void>;

package/dist/artifacts/store.d.ts

@@ -0,0 +1,30 @@
+import type { JsonObject, Sha256Digest } from '../json.js';
+export type ArtifactContentMode = 'exact' | 'state' | 'free-text';
+export interface ArtifactScope {
+    readonly namespace: string;
+    readonly runId: string;
+}
+export interface NewArtifact {
+    readonly bytes: Uint8Array;
+    readonly mediaType: string;
+    readonly purpose: string;
+    readonly contentMode: ArtifactContentMode;
+    readonly sensitive?: boolean;
+}
+export type ArtifactBatch = readonly [NewArtifact, ...NewArtifact[]];
+export interface ArtifactReference<Purpose extends string = string> extends JsonObject {
+    readonly schemaVersion: 1;
+    readonly digest: Sha256Digest;
+    readonly byteLength: number;
+    readonly mediaType: string;
+    readonly purpose: Purpose;
+}
+export interface ArtifactStore {
+    preflightWrite(scope: ArtifactScope, artifacts: ArtifactBatch): Promise<readonly ArtifactReference[]>;
+    write(scope: ArtifactScope, artifact: NewArtifact): Promise<ArtifactReference>;
+    read(scope: ArtifactScope, reference: ArtifactReference): Promise<Uint8Array>;
+    deleteRun(scope: ArtifactScope): Promise<void>;
+}
+export declare function validateArtifactScope(value: unknown): ArtifactScope;
+export declare function validateNewArtifact(value: unknown): NewArtifact;
+export declare function validateArtifactReference(value: unknown): ArtifactReference;

package/dist/budget.d.ts

@@ -0,0 +1,36 @@
+import type { UsageReceipt } from './contracts.js';
+import type { JsonObject, Sha256Digest } from './json.js';
+export type TokenLimitMode = 'hard' | 'observed';
+export interface TokenAllowance extends JsonObject {
+    readonly mode: TokenLimitMode;
+    readonly tokens: number;
+}
+export interface AttemptBudgetPolicy extends JsonObject {
+    readonly inputBytes: number;
+    readonly outputBytes: number;
+    readonly timeoutMs: number;
+    readonly teardownGraceMs: number;
+    readonly memoryBytes: number;
+    readonly filesChanged: number;
+    readonly linesChanged: number;
+    readonly callTokens: TokenAllowance | null;
+}
+export interface TokenBudgetSnapshot {
+    readonly limit: number;
+    readonly spent: number;
+    readonly reserved: number;
+    readonly unknownUsageCalls: number;
+}
+export interface BudgetReservation {
+    readonly reservationId: Sha256Digest;
+    readonly amount: number;
+    commit(usage: UsageReceipt): void;
+    release(): void;
+}
+export interface TokenBudget {
+    child(limit: number): TokenBudget;
+    reserve(allowance: TokenAllowance, capabilities: {
+        readonly hardLimitEnforceable: boolean;
+    }): BudgetReservation;
+    snapshot(): TokenBudgetSnapshot;
+}

package/dist/callback/approval.d.ts

@@ -0,0 +1,80 @@
+import type { NewDomainEvent } from '../events/envelope.js';
+import type { PermissionDescriptor } from '../graph-plan.js';
+import { type JsonObject, type Sha256Digest } from '../json.js';
+import { type ActionDecision } from '../action-decision.js';
+import type { WorkspaceAnchor } from '../workspace/provider.js';
+import type { AcceptedResultGraph } from '../proof/acceptance.js';
+import type { ProofArtifactReference } from '../proof/artifact.js';
+import type { CallbackEvent } from './client-contract.js';
+import { type CallbackGateDefinition, type CallbackRequest } from './gate.js';
+export type ApprovalSubmission = Extract<CallbackEvent, {
+    readonly kind: 'callback-submitted';
+}>;
+export interface ApprovalSubjectInput {
+    readonly workspaceAnchor: WorkspaceAnchor | null;
+    readonly inputArtifactHashes: Readonly<Record<string, Sha256Digest>>;
+    readonly proofScope: JsonObject;
+    readonly proofArtifact: ProofArtifactReference;
+    readonly proposedOutput: Uint8Array;
+    readonly effectivePermissions: readonly PermissionDescriptor[];
+}
+export interface ApprovalResolutionInput extends ApprovalSubjectInput {
+    readonly request: CallbackRequest;
+}
+export interface ApprovalSubject extends JsonObject {
+    readonly workspaceAnchor: WorkspaceAnchor | null;
+    readonly inputArtifactHashes: Readonly<Record<string, Sha256Digest>>;
+    readonly proofScope: JsonObject;
+    readonly proofArtifact: ProofArtifactReference;
+    readonly proposedOutputDigest: Sha256Digest;
+    readonly effectivePermissions: readonly JsonObject[];
+}
+export interface ApprovalBinding extends JsonObject {
+    readonly requestId: string;
+    readonly requestDigest: string;
+    readonly planDigest: Sha256Digest;
+    readonly graph: AcceptedResultGraph;
+    readonly workspaceAnchor: WorkspaceAnchor | null;
+    readonly inputArtifactHashes: Readonly<Record<string, Sha256Digest>>;
+    readonly proofScope: JsonObject;
+    readonly proofArtifact: ProofArtifactReference;
+    readonly proposedOutputDigest: Sha256Digest;
+    readonly actor: JsonObject;
+    readonly responsePath: string;
+    readonly decision: ActionDecision;
+    readonly effectivePermissions: readonly JsonObject[];
+}
+export interface ApprovalRecord extends JsonObject {
+    readonly schemaVersion: 1;
+    readonly binding: ApprovalBinding;
+    readonly bindingDigest: Sha256Digest;
+}
+export interface ApprovalEventPayload extends JsonObject {
+    readonly requestId: string;
+    readonly record: ApprovalRecord;
+}
+export type NewApprovalEvent = NewDomainEvent<'callback:approval-recorded', 1, ApprovalEventPayload>;
+export declare class ApprovalSubjectError extends Error {
+    readonly code: 'SUBJECT_MISMATCH';
+    constructor(message: string);
+}
+export declare function isObject(value: unknown): value is JsonObject;
+export declare function hasExactFields(value: JsonObject, fields: readonly string[]): boolean;
+export declare function snapshotApprovalSubject(input: ApprovalSubjectInput): ApprovalSubject;
+export declare function approvalSubjectDigest(input: ApprovalSubjectInput): Sha256Digest;
+export declare function createApprovalCallbackGate(definition: CallbackGateDefinition, subject: ApprovalSubjectInput): CallbackRequest;
+export declare function validateApprovalSubject(value: unknown): ApprovalSubject;
+export declare function assertApprovalPermissionsAdmitted(subject: ApprovalSubject, admitted: readonly PermissionDescriptor[]): void;
+export interface StoredApprovalBindingInput {
+    readonly request: CallbackRequest;
+    readonly planDigest: Sha256Digest;
+    readonly graph: AcceptedResultGraph;
+    readonly subject: ApprovalSubject;
+    readonly actor: JsonObject;
+    readonly responsePath: string;
+}
+export declare function bindingFromSubject(input: StoredApprovalBindingInput, decision: ActionDecision): ApprovalBinding;
+export declare function validateApprovalRecord(value: unknown): ApprovalRecord;
+export interface PrepareApprovalRecordInput extends StoredApprovalBindingInput {
+    readonly submission: ApprovalSubmission;
+}

package/dist/callback/client-contract.d.ts

@@ -0,0 +1,81 @@
+import { type CallbackRequest } from './gate.js';
+import { type JsonObject, type JsonValue } from '../json.js';
+export type CallbackEvent = {
+    readonly kind: 'callback-requested';
+    readonly request: CallbackRequest;
+} | {
+    readonly kind: 'callback-claimed';
+    readonly requestId: string;
+    readonly routerId: string;
+    readonly claimToken: string;
+} | {
+    readonly kind: 'callback-released';
+    readonly requestId: string;
+    readonly routerId: string;
+} | {
+    readonly kind: 'callback-submitted';
+    readonly requestId: string;
+    readonly requestDigest: string;
+    readonly routerId: string;
+    readonly response: JsonValue;
+} | {
+    readonly kind: 'callback-rejected';
+    readonly requestId: string;
+    readonly routerId: string;
+    readonly reason: string;
+} | {
+    readonly kind: 'callback-superseded';
+    readonly requestId: string;
+    readonly supersededBy: string;
+};
+/** Validate one callback event before it can affect replayed state. */
+export declare function validateCallbackEvent(value: unknown): CallbackEvent;
+export interface ClaimOk {
+    readonly ok: true;
+    readonly claimToken: string;
+}
+export interface ClaimRefused {
+    readonly ok: false;
+    readonly kind: 'missing' | 'claimed' | 'answered' | 'superseded';
+    readonly routerId: string | null;
+}
+export type ClaimResult = ClaimOk | ClaimRefused;
+export interface SubmitOk {
+    readonly ok: true;
+    readonly response: JsonValue;
+}
+export interface SubmitRefused {
+    readonly ok: false;
+    readonly kind: 'missing' | 'not-claimed' | 'not-owner' | 'stale' | 'invalid';
+    readonly reason: string;
+}
+export type SubmitResult = SubmitOk | SubmitRefused;
+export interface ReleaseOk {
+    readonly ok: true;
+}
+export interface ReleaseRefused {
+    readonly ok: false;
+    readonly kind: 'missing' | 'not-owner';
+}
+export type ReleaseResult = ReleaseOk | ReleaseRefused;
+export interface CallbackClient {
+    /** Record a gate's request and make it pending. Observation only. */
+    post(request: CallbackRequest): void;
+    /** The pending requests, without starting any effect. */
+    listPending(): readonly CallbackRequest[];
+    /** Atomically assign a request to one router. */
+    claim(requestId: string, routerId: string): ClaimResult;
+    /**
+     * Validate and record a structured response. The assignment binds the
+     * response schema and the request digest: a submit whose digest does
+     * not match the posted request is stale.
+     */
+    submit(requestId: string, claimToken: string, routerId: string, requestDigest: string, response: JsonValue): SubmitResult;
+    /** Give a claimed request back so another router can take it. */
+    release(requestId: string, claimToken: string): ReleaseResult;
+    /** Mark a request superseded by a newer one from the same gate. */
+    supersede(requestId: string, supersededBy: string): void;
+    /** The full history, optionally for one request. */
+    history(requestId?: string): readonly CallbackEvent[];
+}
+export type Responder = (request: CallbackRequest) => Promise<JsonObject> | JsonObject;

package/dist/callback/gate.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The Callback Gate (roadmap D7): a question the run asks and waits for,
+ * answered through a replaceable router. The runtime stores the durable
+ * request and its assignment; an external router claims the request,
+ * submits a structured response, and the runtime validates and records it.
+ *
+ * The request digest covers the gate version, the decision text, the
+ * response schema, and the referenced input bytes. Display-only data —
+ * placement, layout, theme, and other presentation or routing hints — is
+ * stored in the request payload but excluded from the digest, so
+ * restyling a question never invalidates a pending answer, and changing
+ * what is asked always does.
+ */
+import { type JsonObject, type JsonValue } from '../json.js';
+export interface CallbackGateDefinition {
+    readonly gateId: string;
+    readonly gateVersion: number;
+    /** The question the run is asking, in plain text. */
+    readonly decisionText: string;
+    /** The shape a valid answer takes. */
+    readonly responseSchema: JsonObject;
+    /** The input bytes the decision refers to. */
+    readonly input: JsonValue;
+    /** Presentation and routing hints: stored, never digested. */
+    readonly presentation?: JsonObject;
+}
+export interface CallbackRequest extends JsonObject {
+    readonly requestId: string;
+    readonly gateId: string;
+    readonly gateVersion: number;
+    readonly digest: string;
+    readonly decisionText: string;
+    readonly responseSchema: JsonObject;
+    readonly input: JsonValue;
+    readonly presentation: JsonObject;
+}
+/** Create the gate's request. Same definition bytes, same digest. */
+export declare function createCallbackGate(definition: CallbackGateDefinition): CallbackRequest;
+/** The digest a gate definition produces, without creating a request. */
+export declare function callbackRequestDigest(definition: Omit<CallbackGateDefinition, 'presentation'>): string;
+/** Validate stored request bytes and their content-derived identity. */
+export declare function validateCallbackRequest(value: unknown): CallbackRequest;
+/** Validate a response object against a response schema's plain shape. */
+export declare function validateCallbackResponse(response: JsonValue, schema: JsonObject): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};

package/dist/callback/stored-client.d.ts

@@ -0,0 +1,22 @@
+import type { NewDomainEvent } from '../events/envelope.js';
+import type { JsonObject, JsonValue } from '../json.js';
+import type { ApprovalSubject, ApprovalSubjectInput } from './approval.js';
+import type { CallbackEvent, ClaimResult, ReleaseResult, SubmitResult } from './client-contract.js';
+import type { CallbackRequest } from './gate.js';
+type CallbackHistoryPayload = Readonly<{
+    readonly event: JsonObject;
+}> | Readonly<{
+    readonly event: JsonObject;
+    readonly approvalSubject: ApprovalSubject;
+}>;
+export type NewCallbackHistoryEvent = NewDomainEvent<'callback:history-recorded', 1, CallbackHistoryPayload>;
+export interface StoredCallbackClient {
+    post(request: CallbackRequest, approvalSubject?: ApprovalSubjectInput): Promise<void>;
+    listPending(): Promise<readonly CallbackRequest[]>;
+    claim(requestId: string, routerId: string): Promise<ClaimResult>;
+    submit(requestId: string, claimToken: string, routerId: string, requestDigest: string, response: JsonValue, actor?: JsonObject): Promise<SubmitResult>;
+    release(requestId: string, claimToken: string): Promise<ReleaseResult>;
+    supersede(requestId: string, supersededBy: string): Promise<void>;
+    history(requestId?: string): Promise<readonly CallbackEvent[]>;
+}
+export {};

package/dist/chunk-6NA4RDQ4.js

@@ -0,0 +1,81 @@
+import { validateArtifactReference } from './chunk-WGLWWKF3.js';
+import { cloneFrozenJson, digestJson } from './chunk-AJ353QD5.js';
+
+// src/proof/acceptance.ts
+var SHA256_DIGEST = /^sha256:[0-9a-f]{64}$/u;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasExactFields(value, fields) {
+  const actual = Object.keys(value).sort();
+  const expected = [...fields].sort();
+  return actual.length === expected.length && actual.every((field, index) => field === expected[index]);
+}
+function isDigest(value) {
+  return typeof value === "string" && SHA256_DIGEST.test(value);
+}
+function bindingFrom(input) {
+  const reviewerIdentity = cloneFrozenJson(input.reviewerIdentity);
+  return cloneFrozenJson({
+    inputHashes: input.inputHashes,
+    proofScope: input.proofScope,
+    proofArtifact: input.proofArtifact,
+    graph: input.graph,
+    workspaceAnchor: input.workspaceAnchor,
+    reviewerIdentity,
+    reviewerFingerprint: digestJson(reviewerIdentity)
+  });
+}
+function validateAcceptedResultRecord(value) {
+  const record = cloneFrozenJson(value);
+  if (!isObject(record)) {
+    throw new TypeError("invalid accepted-result record");
+  }
+  const { binding } = record;
+  if (!hasExactFields(record, [
+    "schemaVersion",
+    "result",
+    "resultDigest",
+    "binding",
+    "bindingDigest"
+  ]) || record.schemaVersion !== 1 || record.result === void 0 || !isDigest(record.resultDigest) || record.resultDigest !== digestJson(record.result) || !isObject(binding) || !isDigest(record.bindingDigest)) {
+    throw new TypeError("invalid accepted-result record");
+  }
+  if (!hasExactFields(binding, [
+    "inputHashes",
+    "proofScope",
+    "proofArtifact",
+    "graph",
+    "workspaceAnchor",
+    "reviewerIdentity",
+    "reviewerFingerprint"
+  ]) || !isObject(binding.inputHashes) || Object.values(binding.inputHashes).some((hash) => !isDigest(hash)) || !isObject(binding.proofScope) || !isObject(binding.proofArtifact) || !isObject(binding.graph) || !hasExactFields(binding.graph, ["definitionDigest", "typeVersion"]) || !isDigest(binding.graph.definitionDigest) || typeof binding.graph.typeVersion !== "number" || !Number.isSafeInteger(binding.graph.typeVersion) || binding.graph.typeVersion < 1 || !isObject(binding.workspaceAnchor) || !isObject(binding.reviewerIdentity) || !isDigest(binding.reviewerFingerprint) || binding.reviewerFingerprint !== digestJson(binding.reviewerIdentity) || record.bindingDigest !== digestJson(binding)) {
+    throw new TypeError("invalid accepted-result binding");
+  }
+  const proofArtifact = validateArtifactReference(binding.proofArtifact);
+  if (proofArtifact.purpose !== "proof-packet") {
+    throw new TypeError("accepted result needs a proof-packet artifact");
+  }
+  return record;
+}
+function acceptedResultMatches(record, current) {
+  return acceptedResultMatchesBinding(record, bindingFrom(current));
+}
+function acceptedResultMatchesBinding(record, current) {
+  try {
+    const stored = validateAcceptedResultRecord(record);
+    return stored.bindingDigest === digestJson(current);
+  } catch {
+    return false;
+  }
+}
+var acceptedResultSupport = Object.freeze({
+  isObject,
+  hasExactFields,
+  bindingFrom,
+  acceptedResultMatchesBinding
+});
+
+export { acceptedResultMatches, acceptedResultSupport, validateAcceptedResultRecord };
+//# sourceMappingURL=chunk-6NA4RDQ4.js.map
+//# sourceMappingURL=chunk-6NA4RDQ4.js.map

package/dist/chunk-6NA4RDQ4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/proof/acceptance.ts"],"names":[],"mappings":"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","file":"chunk-6NA4RDQ4.js","sourcesContent":["import { validateArtifactReference } from '../artifacts/store.js';\nimport type { NewDomainEvent } from '../events/envelope.js';\nimport { cloneFrozenJson, digestJson, type JsonObject, type JsonValue, type Sha256Digest } from '../json.js';\nimport type { WorkspaceAnchor } from '../workspace/provider.js';\nimport type { ProofArtifactReference } from './artifact.js';\n\nexport interface AcceptedResultGraph extends JsonObject {\n  readonly definitionDigest: Sha256Digest;\n  readonly typeVersion: number;\n}\n\nexport interface AcceptedResultBindingInput {\n  readonly inputHashes: Readonly<Record<string, Sha256Digest>>;\n  readonly proofScope: JsonObject;\n  readonly proofArtifact: ProofArtifactReference;\n  readonly graph: AcceptedResultGraph;\n  readonly workspaceAnchor: WorkspaceAnchor;\n  readonly reviewerIdentity: JsonObject;\n}\n\nexport interface AcceptedResultBinding extends JsonObject {\n  readonly inputHashes: Readonly<Record<string, Sha256Digest>>;\n  readonly proofScope: JsonObject;\n  readonly proofArtifact: ProofArtifactReference;\n  readonly graph: AcceptedResultGraph;\n  readonly workspaceAnchor: WorkspaceAnchor;\n  readonly reviewerIdentity: JsonObject;\n  readonly reviewerFingerprint: Sha256Digest;\n}\n\nexport interface AcceptedResultRecord extends JsonObject {\n  readonly schemaVersion: 1;\n  readonly result: JsonValue;\n  readonly resultDigest: Sha256Digest;\n  readonly binding: AcceptedResultBinding;\n  readonly bindingDigest: Sha256Digest;\n}\n\nexport interface AcceptedResultEventPayload extends JsonObject {\n  readonly position: string;\n  readonly record: AcceptedResultRecord;\n}\n\nexport type NewAcceptedResultEvent = NewDomainEvent<\n  'proof:result-accepted',\n  1,\n  AcceptedResultEventPayload\n>;\n\nexport interface CreateAcceptedResultRecordInput extends AcceptedResultBindingInput {\n  readonly result: JsonValue;\n}\n\nexport type AcceptedResultResolution =\n  | Readonly<{ readonly kind: 'accepted'; readonly record: AcceptedResultRecord }>\n  | Readonly<{ readonly kind: 'wait'; readonly reason: string }>;\n\nconst SHA256_DIGEST = /^sha256:[0-9a-f]{64}$/u;\n\nfunction isObject(value: unknown): value is JsonObject {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction hasExactFields(value: JsonObject, fields: readonly string[]): boolean {\n  const actual = Object.keys(value).sort();\n  const expected = [...fields].sort();\n  return actual.length === expected.length\n    && actual.every((field, index) => field === expected[index]);\n}\n\nfunction isDigest(value: JsonValue | undefined): value is Sha256Digest {\n  return typeof value === 'string' && SHA256_DIGEST.test(value);\n}\n\nfunction bindingFrom(input: AcceptedResultBindingInput): AcceptedResultBinding {\n  const reviewerIdentity = cloneFrozenJson(input.reviewerIdentity) as JsonObject;\n  return cloneFrozenJson({\n    inputHashes: input.inputHashes,\n    proofScope: input.proofScope,\n    proofArtifact: input.proofArtifact,\n    graph: input.graph,\n    workspaceAnchor: input.workspaceAnchor,\n    reviewerIdentity,\n    reviewerFingerprint: digestJson(reviewerIdentity),\n  }) as AcceptedResultBinding;\n}\n\nexport function validateAcceptedResultRecord(value: unknown): AcceptedResultRecord {\n  const record = cloneFrozenJson(value as JsonValue);\n  if (!isObject(record)) {\n    throw new TypeError('invalid accepted-result record');\n  }\n  const { binding } = record;\n  if (!hasExactFields(record, [\n      'schemaVersion',\n      'result',\n      'resultDigest',\n      'binding',\n      'bindingDigest',\n    ])\n    || record.schemaVersion !== 1\n    || record.result === undefined\n    || !isDigest(record.resultDigest)\n    || record.resultDigest !== digestJson(record.result)\n    || !isObject(binding)\n    || !isDigest(record.bindingDigest)) {\n    throw new TypeError('invalid accepted-result record');\n  }\n\n  if (!hasExactFields(binding, [\n    'inputHashes',\n    'proofScope',\n    'proofArtifact',\n    'graph',\n    'workspaceAnchor',\n    'reviewerIdentity',\n    'reviewerFingerprint',\n  ])\n    || !isObject(binding.inputHashes)\n    || Object.values(binding.inputHashes).some((hash) => !isDigest(hash))\n    || !isObject(binding.proofScope)\n    || !isObject(binding.proofArtifact)\n    || !isObject(binding.graph)\n    || !hasExactFields(binding.graph, ['definitionDigest', 'typeVersion'])\n    || !isDigest(binding.graph.definitionDigest)\n    || typeof binding.graph.typeVersion !== 'number'\n    || !Number.isSafeInteger(binding.graph.typeVersion)\n    || binding.graph.typeVersion < 1\n    || !isObject(binding.workspaceAnchor)\n    || !isObject(binding.reviewerIdentity)\n    || !isDigest(binding.reviewerFingerprint)\n    || binding.reviewerFingerprint !== digestJson(binding.reviewerIdentity)\n    || record.bindingDigest !== digestJson(binding)) {\n    throw new TypeError('invalid accepted-result binding');\n  }\n  const proofArtifact = validateArtifactReference(binding.proofArtifact);\n  if (proofArtifact.purpose !== 'proof-packet') {\n    throw new TypeError('accepted result needs a proof-packet artifact');\n  }\n\n  return record as AcceptedResultRecord;\n}\n\nexport function acceptedResultMatches(\n  record: AcceptedResultRecord,\n  current: AcceptedResultBindingInput,\n): boolean {\n  return acceptedResultMatchesBinding(record, bindingFrom(current));\n}\n\nfunction acceptedResultMatchesBinding(\n  record: AcceptedResultRecord,\n  current: AcceptedResultBinding,\n): boolean {\n  try {\n    const stored = validateAcceptedResultRecord(record);\n    return stored.bindingDigest === digestJson(current);\n  } catch {\n    return false;\n  }\n}\n\nexport const acceptedResultSupport = Object.freeze({\n  isObject,\n  hasExactFields,\n  bindingFrom,\n  acceptedResultMatchesBinding,\n});\n"]}