trellis/dist/chunk-RUMOVKR4.js

Agentic State Engine — event-sourced causal graph with branching, decision traces, and realtime sync for AI-native applications

import {
  __esm
} from "./chunk-2ESYSVXG.js";

// src/core/persist/canonical-op.ts
function canonicalFact(f) {
  const out = { e: f.e, a: f.a, v: f.v };
  if (f.meta !== void 0) out.meta = canonicalFactMeta(f.meta);
  return out;
}
function canonicalFactMeta(m) {
  const out = {};
  if (m.confidence !== void 0) out.confidence = m.confidence;
  if (m.dataTypeId !== void 0) out.dataTypeId = m.dataTypeId;
  if (m.sources !== void 0) out.sources = m.sources.map(canonicalSource);
  return out;
}
function canonicalSource(s) {
  const out = {};
  if (s.authors !== void 0) out.authors = [...s.authors];
  if (s.location !== void 0) out.location = { uri: s.location.uri };
  if (s.loadedAt !== void 0) out.loadedAt = s.loadedAt;
  if (s.firstPublished !== void 0) out.firstPublished = s.firstPublished;
  if (s.lastUpdated !== void 0) out.lastUpdated = s.lastUpdated;
  return out;
}
function canonicalLink(l) {
  return { e1: l.e1, a: l.a, e2: l.e2 };
}
function canonicalProvenance(p) {
  if (!p) return null;
  return { actorType: p.actorType, origin: p.origin };
}
function toCanonicalBody(payload, version) {
  return {
    ...version !== void 0 ? { v: version } : {},
    facts: (payload.facts ?? []).map(canonicalFact),
    links: (payload.links ?? []).map(canonicalLink),
    deleteFacts: (payload.deleteFacts ?? []).map(canonicalFact),
    deleteLinks: (payload.deleteLinks ?? []).map(canonicalLink),
    provenance: canonicalProvenance(payload.provenance)
  };
}
function canonicalOpBody(payload) {
  return JSON.stringify(toCanonicalBody(payload, OP_PREIMAGE_VERSION));
}
function canonicalOpBodyFromOp(op) {
  return JSON.stringify(
    toCanonicalBody(
      {
        facts: op.facts,
        links: op.links,
        deleteFacts: op.deleteFacts,
        deleteLinks: op.deleteLinks,
        provenance: op.provenance
      },
      op.v
    )
  );
}
function canonicalPreimage(header, payload) {
  return JSON.stringify({
    v: OP_PREIMAGE_VERSION,
    kind: header.kind,
    timestamp: header.timestamp,
    agentId: header.agentId,
    previousHash: header.previousHash ?? null,
    body: toCanonicalBody(payload, OP_PREIMAGE_VERSION)
  });
}
async function sha256Hex(data) {
  const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(data));
  return Array.from(new Uint8Array(buf)).map((b) => b.toString(16).padStart(2, "0")).join("");
}
async function hashKernelOp(header, payload) {
  return `trellis:op:${await sha256Hex(canonicalPreimage(header, payload))}`;
}
async function verifyOpHash(op) {
  const version = op.v;
  if (version !== OP_PREIMAGE_VERSION) {
    return { valid: true, legacy: true };
  }
  const expected = await hashKernelOp(
    {
      kind: op.kind,
      timestamp: op.timestamp,
      agentId: op.agentId,
      previousHash: op.previousHash
    },
    {
      facts: op.facts,
      links: op.links,
      deleteFacts: op.deleteFacts,
      deleteLinks: op.deleteLinks,
      provenance: op.provenance
    }
  );
  return { valid: expected === op.hash, legacy: false };
}
var OP_PREIMAGE_VERSION, PROVENANCE;
var init_canonical_op = __esm({
  "src/core/persist/canonical-op.ts"() {
    OP_PREIMAGE_VERSION = 2;
    PROVENANCE = {
      cli: { actorType: "user", origin: "cli" },
      http: { actorType: "machine", origin: "http" },
      mcp: { actorType: "ai", origin: "mcp" },
      sdk: { actorType: "machine", origin: "sdk" },
      agent: { actorType: "ai", origin: "sdk" },
      sync: { actorType: "machine", origin: "sync" },
      migration: { actorType: "machine", origin: "migration" },
      cron: { actorType: "machine", origin: "cron" }
    };
  }
});

export {
  OP_PREIMAGE_VERSION,
  PROVENANCE,
  canonicalOpBody,
  canonicalOpBodyFromOp,
  hashKernelOp,
  verifyOpHash,
  init_canonical_op
};