entroly-wasm 1.0.78 → 1.0.80

package/js/work_context_snapshot_store.js

@@ -0,0 +1,280 @@
+'use strict';
+
+// Host persistence mechanics only. The v1 verified-context commitment rules
+// live in entroly-engine and are reached here through the generated WASM
+// binding. This file owns repository isolation, bounds, atomic persistence and
+// byte preservation; it does not define what makes a context snapshot valid.
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { verifiedContextSnapshotVerifyBytes } = require('../pkg/entroly_wasm');
+const { WorkGraphStateError, WorkGraphStore } = require('./work_graph_store');
+
+const CONTEXT_SNAPSHOT_TOKEN_PREFIX = 'wctx1.';
+const DEFAULT_MAX_CONTEXT_BYTES = 512 * 1024;
+const DEFAULT_MAX_SNAPSHOTS = 8192;
+const DEFAULT_MAX_TOTAL_BYTES = 256 * 1024 * 1024;
+const DIGEST_RE = /^[0-9a-f]{64}$/;
+
+class WorkContextSnapshotError extends WorkGraphStateError {}
+
+function positiveInteger(value, name, minimum = 1) {
+  if (!Number.isSafeInteger(value) || value < minimum) {
+    throw new WorkContextSnapshotError(`${name} must be a safe integer >= ${minimum}`);
+  }
+  return value;
+}
+
+function secureDirectory(target) {
+  fs.mkdirSync(target, { recursive: true, mode: 0o700 });
+  const info = fs.lstatSync(target);
+  if (info.isSymbolicLink() || !info.isDirectory()) {
+    throw new WorkContextSnapshotError(`unsafe context snapshot directory: ${target}`);
+  }
+  if (process.platform !== 'win32') fs.chmodSync(target, 0o700);
+}
+
+function fsyncDirectory(target) {
+  if (process.platform === 'win32') return;
+  let fd;
+  try {
+    fd = fs.openSync(target, fs.constants.O_RDONLY | (fs.constants.O_DIRECTORY || 0));
+    fs.fsyncSync(fd);
+  } catch (_) {
+    // Directory fsync is not supported by every filesystem/runtime. The Python
+    // store has the same best-effort boundary; file data itself is fsynced.
+  } finally {
+    if (fd !== undefined) {
+      try { fs.closeSync(fd); } catch (_) {}
+    }
+  }
+}
+
+function asBuffer(value) {
+  if (Buffer.isBuffer(value)) return Buffer.from(value);
+  if (value instanceof Uint8Array) return Buffer.from(value);
+  if (typeof value === 'string') return Buffer.from(value, 'utf8');
+  throw new WorkContextSnapshotError('context snapshot must be bytes or UTF-8 text');
+}
+
+/**
+ * Verify exact snapshot bytes through the Rust semantic kernel.
+ *
+ * The byte stream is intentionally not normalized or reserialized before
+ * verification. Python v1 commits its compact ensure-ASCII representation and
+ * valid number lexemes such as `1.0` must survive a Python -> Node -> Python
+ * handoff byte-for-byte.
+ */
+function verifyCanonicalSnapshotBytes(
+  value,
+  expectedCommitment,
+  maxBytes = DEFAULT_MAX_CONTEXT_BYTES,
+) {
+  const bytes = asBuffer(value);
+  positiveInteger(maxBytes, 'maxBytes', 1024);
+  if (bytes.length > maxBytes) {
+    throw new WorkContextSnapshotError(`context snapshot exceeds ${maxBytes} bytes`);
+  }
+  const expected = String(expectedCommitment || '');
+  try {
+    const commitment = verifiedContextSnapshotVerifyBytes(bytes, expected);
+    // Parsing is presentation only and happens after Rust has accepted the exact
+    // bytes. The parsed object is never reserialized for commitment verification.
+    const payload = JSON.parse(bytes.toString('ascii'));
+    return { payload, commitment, bytes };
+  } catch (error) {
+    if (error instanceof WorkContextSnapshotError) throw error;
+    const detail = error && error.message ? error.message : String(error);
+    throw new WorkContextSnapshotError(detail);
+  }
+}
+
+class WorkContextSnapshotStore {
+  constructor(graphStore, options = {}) {
+    if (!(graphStore instanceof WorkGraphStore)) {
+      throw new TypeError('graphStore must be a WorkGraphStore');
+    }
+    this.graphStore = graphStore;
+    this.maxContextBytes = positiveInteger(
+      options.maxContextBytes ?? DEFAULT_MAX_CONTEXT_BYTES,
+      'maxContextBytes',
+      1024,
+    );
+    this.maxSnapshots = positiveInteger(
+      options.maxSnapshots ?? DEFAULT_MAX_SNAPSHOTS,
+      'maxSnapshots',
+    );
+    if (this.maxSnapshots > 100000) {
+      throw new WorkContextSnapshotError('maxSnapshots must not exceed 100000');
+    }
+    this.maxTotalBytes = positiveInteger(
+      options.maxTotalBytes ?? DEFAULT_MAX_TOTAL_BYTES,
+      'maxTotalBytes',
+      this.maxContextBytes,
+    );
+    this.contextDir = path.join(graphStore.repoDir, 'context-snapshots');
+    secureDirectory(this.contextDir);
+  }
+
+  static tokenForCommitment(commitment) {
+    const digest = String(commitment || '');
+    if (!DIGEST_RE.test(digest)) {
+      throw new WorkContextSnapshotError('context commitment is not a sha256 digest');
+    }
+    return CONTEXT_SNAPSHOT_TOKEN_PREFIX + digest;
+  }
+
+  static digestFromToken(token) {
+    const value = String(token || '');
+    if (!value.startsWith(CONTEXT_SNAPSHOT_TOKEN_PREFIX)) {
+      throw new WorkContextSnapshotError('unsupported context snapshot token');
+    }
+    const digest = value.slice(CONTEXT_SNAPSHOT_TOKEN_PREFIX.length);
+    if (!DIGEST_RE.test(digest)) {
+      throw new WorkContextSnapshotError('context snapshot token has an invalid digest');
+    }
+    return digest;
+  }
+
+  _snapshotPath(digest) {
+    return path.join(this.contextDir, `${digest}.json`);
+  }
+
+  _readUnlocked(target, expectedDigest) {
+    let info;
+    try { info = fs.lstatSync(target); }
+    catch (error) {
+      if (error && error.code === 'ENOENT') {
+        throw new WorkContextSnapshotError('context snapshot is unavailable');
+      }
+      throw new WorkContextSnapshotError(`cannot inspect context snapshot: ${error.message}`);
+    }
+    if (info.isSymbolicLink() || !info.isFile()) {
+      throw new WorkContextSnapshotError('unsafe context snapshot path');
+    }
+    if (info.size > this.maxContextBytes) {
+      throw new WorkContextSnapshotError('context snapshot exceeds its byte bound');
+    }
+
+    const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);
+    let fd;
+    try {
+      fd = fs.openSync(target, flags);
+      const current = fs.fstatSync(fd);
+      if (!current.isFile() || current.size > this.maxContextBytes) {
+        throw new WorkContextSnapshotError('unsafe or oversized context snapshot');
+      }
+      const bytes = fs.readFileSync(fd);
+      const verified = verifyCanonicalSnapshotBytes(bytes, expectedDigest, this.maxContextBytes);
+      return verified.bytes;
+    } catch (error) {
+      if (error instanceof WorkContextSnapshotError) throw error;
+      throw new WorkContextSnapshotError(`cannot open context snapshot safely: ${error.message}`);
+    } finally {
+      if (fd !== undefined) {
+        try { fs.closeSync(fd); } catch (_) {}
+      }
+    }
+  }
+
+  _usageUnlocked() {
+    let count = 0;
+    let totalBytes = 0;
+    for (const name of fs.readdirSync(this.contextDir)) {
+      if (name.startsWith('.context-') && name.endsWith('.tmp')) continue;
+      if (!name.endsWith('.json')) continue;
+      const target = path.join(this.contextDir, name);
+      const info = fs.lstatSync(target);
+      if (info.isSymbolicLink() || !info.isFile()) {
+        throw new WorkContextSnapshotError('unsafe context snapshot entry');
+      }
+      count += 1;
+      totalBytes += info.size;
+      if (count > this.maxSnapshots || totalBytes > this.maxTotalBytes) break;
+    }
+    return { count, totalBytes };
+  }
+
+  putCanonicalBytes(value, expectedCommitment) {
+    const expected = String(expectedCommitment || '');
+    if (!DIGEST_RE.test(expected)) {
+      throw new WorkContextSnapshotError('expectedCommitment must be a sha256 digest');
+    }
+    const verified = verifyCanonicalSnapshotBytes(value, expected, this.maxContextBytes);
+    const token = WorkContextSnapshotStore.tokenForCommitment(expected);
+    const target = this._snapshotPath(expected);
+
+    return this.graphStore.withLock(() => {
+      secureDirectory(this.contextDir);
+      if (fs.existsSync(target)) {
+        const existing = this._readUnlocked(target, expected);
+        if (!existing.equals(verified.bytes)) {
+          throw new WorkContextSnapshotError(
+            'context commitment maps to conflicting stable snapshot bytes',
+          );
+        }
+        return token;
+      }
+      const usage = this._usageUnlocked();
+      if (usage.count >= this.maxSnapshots) {
+        throw new WorkContextSnapshotError('context snapshot store reached its bounded entry limit');
+      }
+      if (usage.totalBytes + verified.bytes.length > this.maxTotalBytes) {
+        throw new WorkContextSnapshotError('context snapshot store reached its bounded byte limit');
+      }
+
+      const temp = path.join(
+        this.contextDir,
+        `.context-${process.pid}-${crypto.randomUUID().replace(/-/g, '')}.tmp`,
+      );
+      let fd;
+      try {
+        fd = fs.openSync(temp, 'wx', 0o600);
+        fs.writeFileSync(fd, verified.bytes);
+        fs.fsyncSync(fd);
+        fs.closeSync(fd);
+        fd = undefined;
+        if (fs.existsSync(target)) {
+          const existing = this._readUnlocked(target, expected);
+          if (!existing.equals(verified.bytes)) {
+            throw new WorkContextSnapshotError(
+              'context commitment maps to conflicting stable snapshot bytes',
+            );
+          }
+        } else {
+          fs.renameSync(temp, target);
+          if (process.platform !== 'win32') fs.chmodSync(target, 0o600);
+          fsyncDirectory(this.contextDir);
+        }
+      } finally {
+        if (fd !== undefined) {
+          try { fs.closeSync(fd); } catch (_) {}
+        }
+        try { fs.unlinkSync(temp); } catch (_) {}
+      }
+      return token;
+    });
+  }
+
+  getCanonicalBytes(token) {
+    const digest = WorkContextSnapshotStore.digestFromToken(token);
+    return this.graphStore.withLock(() => {
+      secureDirectory(this.contextDir);
+      return this._readUnlocked(this._snapshotPath(digest), digest);
+    });
+  }
+
+  getJSON(token) {
+    return JSON.parse(this.getCanonicalBytes(token).toString('ascii'));
+  }
+}
+
+module.exports = {
+  CONTEXT_SNAPSHOT_TOKEN_PREFIX,
+  DEFAULT_MAX_CONTEXT_BYTES,
+  DEFAULT_MAX_SNAPSHOTS,
+  DEFAULT_MAX_TOTAL_BYTES,
+  WorkContextSnapshotError,
+  WorkContextSnapshotStore,
+  verifyCanonicalSnapshotBytes,
+};

package/js/work_graph.d.ts

@@ -0,0 +1,225 @@
+import type { RepositoryDiscoveryOptions } from "./work_graph_repo";
+
+export type WorkGraphTrust = "untrusted" | "inferred" | "observed" | "verified";
+export type WorkGraphStatus =
+  | "unknown"
+  | "planned"
+  | "in_progress"
+  | "blocked"
+  | "needs_verification"
+  | "completed"
+  | "abandoned";
+
+export interface WorkGraphSummary {
+  schema_version: number;
+  repo_id: string;
+  revision: number;
+  graph_commitment: string;
+  event_count: number;
+  node_count: number;
+  edge_count: number;
+  evidence_count: number;
+  unfinished_count: number;
+  blocked_count: number;
+}
+
+export interface WorkGraphWorkItem {
+  node_id: string;
+  kind: string;
+  label: string;
+  status: WorkGraphStatus;
+  trust: WorkGraphTrust;
+  updated_at_ms: number;
+  task_ids: string[];
+  agent_ids: string[];
+  changed_paths: string[];
+  symbol_ids: string[];
+  commit_ids: string[];
+  decision_ids: string[];
+  failure_ids: string[];
+  verification_ids: string[];
+  evidence_ids: string[];
+}
+
+export interface WorkGraphEvidence {
+  evidence_id: string;
+  kind: string;
+  source_ref: string;
+  digest: string;
+  locator: string;
+  trust: WorkGraphTrust;
+  observed_at_ms: number;
+  attributes: Record<string, unknown>;
+}
+
+export interface WorkGraphResumeView {
+  repo_id: string;
+  graph_revision: number;
+  graph_commitment: string;
+  selected_workstream: WorkGraphWorkItem;
+  task_labels: string[];
+  agents: string[];
+  decisions: string[];
+  failures: string[];
+  verification: string[];
+  changed_paths: string[];
+  commits: string[];
+  evidence: WorkGraphEvidence[];
+}
+
+export interface WorkGraphContextScope {
+  repo_id: string;
+  graph_revision: number;
+  graph_commitment: string;
+  workstream_id: string;
+  task_ids: string[];
+  task_ids_total: number;
+  task_ids_commitment: string;
+  agent_ids: string[];
+  agent_ids_total: number;
+  agent_ids_commitment: string;
+  changed_paths: string[];
+  changed_paths_total: number;
+  changed_paths_commitment: string;
+  symbol_ids: string[];
+  symbol_ids_total: number;
+  symbol_ids_commitment: string;
+  commit_ids: string[];
+  commit_ids_total: number;
+  commit_ids_commitment: string;
+  evidence_ids: string[];
+  evidence_ids_total: number;
+  evidence_ids_commitment: string;
+}
+
+export interface WorkGraphCoordinationConflict {
+  lease_a: string;
+  lease_b: string;
+  agent_a: string;
+  agent_b: string;
+  task_a: string;
+  task_b: string;
+  overlapping_paths: string[];
+  overlapping_symbols: string[];
+  reason: string;
+}
+
+export interface WorkGraphCoordinationReport {
+  as_of_ms: number;
+  active_leases: number;
+  conflicts: WorkGraphCoordinationConflict[];
+}
+
+export interface WorkGraphHandoffReceipt {
+  schema_version: number;
+  repo_id: string;
+  graph_revision: number;
+  graph_commitment: string;
+  workstream_id: string;
+  from_agent: string;
+  to_agent: string;
+  generated_at_ms: number;
+  node_ids: string[];
+  edge_ids: string[];
+  evidence_ids: string[];
+  payload_commitment: string;
+}
+
+export interface WorkContinuationManifest {
+  context_receipt_commitments?: string[];
+  routing_commitments?: string[];
+  execution_outcome_commitments?: string[];
+  verification_commitments?: string[];
+  memory_commitments?: string[];
+  outstanding_work_refs?: string[];
+  recovery_handle_ids?: string[];
+  created_at_ms: number;
+}
+
+export interface WorkContinuationProof {
+  schema_version: number;
+  proof_id: string;
+  repository_id: string;
+  graph_revision: number;
+  graph_commitment: string;
+  workstream_id: string;
+  from_agent: string;
+  to_agent: string;
+  handoff_commitment: string;
+  context_receipt_commitments: string[];
+  routing_commitments: string[];
+  execution_outcome_commitments: string[];
+  verification_commitments: string[];
+  memory_commitments: string[];
+  outstanding_work_refs: string[];
+  recovery_handle_ids: string[];
+  created_at_ms: number;
+  proof_commitment: string;
+}
+
+export type WorkGraphObservation = Record<string, unknown> & {
+  repo_id: string;
+  observed_at_ms: number;
+};
+
+export class WorkGraph {
+  constructor(repoId: string);
+  static fromJSON(serialized: string | Record<string, unknown>): WorkGraph;
+  static fromRepository(path?: string, options?: RepositoryDiscoveryOptions): WorkGraph;
+  static verifyHandoffIntegrity(receipt: string | WorkGraphHandoffReceipt): boolean;
+  readonly repoId: string;
+  readonly revision: number;
+  readonly graphCommitment: string;
+  readonly eventCount: number;
+  applyEvent(event: string | Record<string, unknown>): string;
+  observeRepository(observation: string | WorkGraphObservation): string;
+  refreshRepository(path?: string, options?: RepositoryDiscoveryOptions): string;
+  merge(other: WorkGraph | string | Record<string, unknown>): number;
+  exportJSON(pretty?: boolean): string;
+  exportState(): Record<string, unknown>;
+  summary(): WorkGraphSummary;
+  snapshot(pretty?: boolean): Record<string, unknown>;
+  unfinished(pretty?: boolean): WorkGraphWorkItem[];
+  resume(workstreamId?: string | null, maxEvidence?: number, pretty?: boolean): WorkGraphResumeView;
+  contextScope(workstreamId?: string | null, maxEvidence?: number, pretty?: boolean): WorkGraphContextScope;
+  recordContextReceipt(
+    receipt: string | Record<string, unknown>,
+    agentId?: string,
+    sessionId?: string,
+  ): string;
+  recordMemory(
+    memory: string | Record<string, unknown>,
+    nowMs?: number,
+    supersededIds?: string[],
+  ): string;
+  recordExecutionChain(
+    route: string | Record<string, unknown>,
+    outcome: string | Record<string, unknown>,
+    verification: string | Record<string, unknown>,
+    invalidatedCommitments?: string[],
+  ): string;
+  continuationProof(
+    handoff: string | WorkGraphHandoffReceipt,
+    manifest: WorkContinuationManifest,
+  ): WorkContinuationProof;
+  reconstructedContinuationProof(
+    workstreamId: string,
+    toAgent: string,
+    manifest: WorkContinuationManifest,
+  ): WorkContinuationProof;
+  coordination(nowMs?: number, pretty?: boolean): WorkGraphCoordinationReport;
+  handoff(
+    workstreamId: string,
+    fromAgent: string,
+    toAgent: string,
+    generatedAtMs?: number,
+    pretty?: boolean,
+  ): WorkGraphHandoffReceipt;
+  verifyHandoff(receipt: string | WorkGraphHandoffReceipt): boolean;
+}
+
+export {
+  RepositoryDiscoveryError,
+  discoverRepositoryIdentity,
+  discoverRepositoryObservation,
+} from "./work_graph_repo";

package/js/work_graph.js

@@ -0,0 +1,191 @@
+'use strict';
+
+// Thin npm orchestration over the shared Rust/WASM AI Work Graph. No task-state
+// inference, trust upgrades, coordination logic, or handoff verification lives
+// here; those semantics are single-source-of-truth in entroly-engine.
+
+const {
+  RepositoryDiscoveryError,
+  discoverRepositoryIdentity,
+  discoverRepositoryObservation,
+} = require('./work_graph_repo');
+
+function wasmWorkGraph() {
+  const { WasmWorkGraph } = require('../pkg/entroly_wasm');
+  if (!WasmWorkGraph) {
+    throw new Error('Rust Work Graph is unavailable; rebuild entroly-wasm');
+  }
+  return WasmWorkGraph;
+}
+
+function toJSONText(value) {
+  if (typeof value === 'string') return value;
+  return JSON.stringify(value);
+}
+
+function fromJSONText(value) {
+  return JSON.parse(value);
+}
+
+function requireSafeInteger(value, name, { min = Number.MIN_SAFE_INTEGER } = {}) {
+  const number = Number(value);
+  if (!Number.isSafeInteger(number) || number < min) {
+    throw new TypeError(`${name} must be a safe integer${min === 0 ? ' >= 0' : ''}`);
+  }
+  return number;
+}
+
+class WorkGraph {
+  constructor(repoId, inner = null) {
+    const Native = wasmWorkGraph();
+    this._inner = inner || new Native(String(repoId || ''));
+  }
+
+  static fromJSON(serialized) {
+    const Native = wasmWorkGraph();
+    return new WorkGraph('', Native.fromJSON(toJSONText(serialized)));
+  }
+
+  static fromRepository(repoPath = '.', options = {}) {
+    const observation = discoverRepositoryObservation(repoPath, options);
+    const graph = new WorkGraph(observation.repo_id);
+    graph.observeRepository(observation);
+    return graph;
+  }
+
+  static verifyHandoffIntegrity(receipt) {
+    return wasmWorkGraph().verifyHandoffIntegrityJSON(toJSONText(receipt));
+  }
+
+  get repoId() { return this._inner.repoId; }
+  get revision() { return Number(this._inner.revision); }
+  get graphCommitment() { return this._inner.graphCommitment; }
+  get eventCount() { return Number(this._inner.eventCount); }
+
+  applyEvent(event) {
+    return this._inner.applyEventJSON(toJSONText(event));
+  }
+
+  observeRepository(observation) {
+    return this._inner.observeRepositoryJSON(toJSONText(observation));
+  }
+
+  refreshRepository(repoPath = '.', options = {}) {
+    const observation = discoverRepositoryObservation(repoPath, options);
+    if (observation.repo_id !== this.repoId) {
+      throw new Error(
+        `repository identity changed: expected ${this.repoId}, got ${observation.repo_id}`,
+      );
+    }
+    return this.observeRepository(observation);
+  }
+
+  merge(other) {
+    const payload = other instanceof WorkGraph ? other.exportJSON(false) : toJSONText(other);
+    return Number(this._inner.mergeJSON(payload));
+  }
+
+  exportJSON(pretty = false) {
+    return this._inner.exportJSON(Boolean(pretty));
+  }
+
+  exportState() {
+    return fromJSONText(this.exportJSON(false));
+  }
+
+  summary() {
+    return fromJSONText(this._inner.summaryJSON());
+  }
+
+  snapshot(pretty = false) {
+    return fromJSONText(this._inner.snapshotJSON(Boolean(pretty)));
+  }
+
+  unfinished(pretty = false) {
+    return fromJSONText(this._inner.unfinishedJSON(Boolean(pretty)));
+  }
+
+  resume(workstreamId = null, maxEvidence = 128, pretty = false) {
+    const id = workstreamId == null ? undefined : String(workstreamId);
+    return fromJSONText(this._inner.resumeJSON(
+      id,
+      requireSafeInteger(maxEvidence, 'maxEvidence', { min: 0 }),
+      Boolean(pretty),
+    ));
+  }
+
+  contextScope(workstreamId = null, maxEvidence = 128, pretty = false) {
+    const id = workstreamId == null ? undefined : String(workstreamId);
+    return fromJSONText(this._inner.contextScopeJSON(
+      id,
+      requireSafeInteger(maxEvidence, 'maxEvidence', { min: 0 }),
+      Boolean(pretty),
+    ));
+  }
+
+  recordContextReceipt(receipt, agentId = '', sessionId = '') {
+    return this._inner.recordContextReceiptJSON(
+      toJSONText(receipt), String(agentId), String(sessionId),
+    );
+  }
+
+  recordMemory(memory, nowMs = Date.now(), supersededIds = []) {
+    return this._inner.recordMemoryJSON(
+      toJSONText(memory),
+      requireSafeInteger(nowMs, 'nowMs'),
+      toJSONText(supersededIds),
+    );
+  }
+
+  recordExecutionChain(route, outcome, verification, invalidatedCommitments = []) {
+    return this._inner.recordExecutionChainJSON(
+      toJSONText(route),
+      toJSONText(outcome),
+      toJSONText(verification),
+      toJSONText(invalidatedCommitments),
+    );
+  }
+
+  continuationProof(handoff, manifest) {
+    return fromJSONText(this._inner.continuationProofJSON(
+      toJSONText(handoff),
+      toJSONText(manifest),
+    ));
+  }
+
+  reconstructedContinuationProof(workstreamId, toAgent, manifest) {
+    return fromJSONText(this._inner.reconstructedContinuationProofJSON(
+      String(workstreamId),
+      String(toAgent),
+      toJSONText(manifest),
+    ));
+  }
+
+  coordination(nowMs = Date.now(), pretty = false) {
+    return fromJSONText(this._inner.coordinationJSON(
+      requireSafeInteger(nowMs, 'nowMs'),
+      Boolean(pretty),
+    ));
+  }
+
+  handoff(workstreamId, fromAgent, toAgent, generatedAtMs = Date.now(), pretty = false) {
+    return fromJSONText(this._inner.handoffJSON(
+      String(workstreamId),
+      String(fromAgent),
+      String(toAgent),
+      requireSafeInteger(generatedAtMs, 'generatedAtMs'),
+      Boolean(pretty),
+    ));
+  }
+
+  verifyHandoff(receipt) {
+    return this._inner.verifyHandoffJSON(toJSONText(receipt));
+  }
+}
+
+module.exports = {
+  WorkGraph,
+  RepositoryDiscoveryError,
+  discoverRepositoryIdentity,
+  discoverRepositoryObservation,
+};