@rhizomes/rhizomatic 0.1.0

package/src/set.ts

@@ -0,0 +1,98 @@
+// The delta set and its algebra (SPEC-1 §8): a mathematical set of deltas, deduplicated by id.
+// merge is union (grow-only set CRDT), fork is filter, federate is merge of a filtered fork.
+// There is no conflict at this layer — contradiction lives in superposition until evaluation.
+
+import { array, encode, tstr } from "./cbor.js";
+import { computeId } from "./delta.js";
+import { contentAddress } from "./hash.js";
+import type { Claims, Delta, Pointer } from "./types.js";
+
+// Build a complete delta from claims (id computed, optional detached sig attached).
+export function makeDelta(claims: Claims, sig?: string): Delta {
+  const id = computeId(claims);
+  return sig === undefined ? { id, claims } : { id, claims, sig };
+}
+
+// The negation vocabulary convention (SPEC-1 §7): an ordinary delta whose pointer targets the
+// negated delta by content address under role "negates". Meaning is given at evaluation (mask).
+export function makeNegationClaims(
+  author: string,
+  timestamp: number,
+  targetDeltaId: string,
+  reason?: string,
+): Claims {
+  const pointers: Pointer[] = [
+    { role: "negates", target: { kind: "delta", deltaRef: { delta: targetDeltaId } } },
+  ];
+  if (reason !== undefined) {
+    pointers.push({ role: "reason", target: { kind: "primitive", value: reason } });
+  }
+  return { timestamp, author, pointers };
+}
+
+export class DeltaSet implements Iterable<Delta> {
+  private readonly byId = new Map<string, Delta>();
+
+  static from(deltas: Iterable<Delta>): DeltaSet {
+    const s = new DeltaSet();
+    for (const d of deltas) s.add(d);
+    return s;
+  }
+
+  // Idempotent insert; returns false when the id was already present. Verifies content
+  // addressing on the way in (P6): a delta whose id does not recompute is rejected, never
+  // repaired (SPEC-4 §2) — set semantics depend on true ids.
+  add(delta: Delta): boolean {
+    if (this.byId.has(delta.id)) return false;
+    if (computeId(delta.claims) !== delta.id) {
+      throw new Error(`delta id ${delta.id} does not match its claims (content addressing, P6)`);
+    }
+    this.byId.set(delta.id, delta);
+    return true;
+  }
+
+  has(id: string): boolean {
+    return this.byId.has(id);
+  }
+
+  get(id: string): Delta | undefined {
+    return this.byId.get(id);
+  }
+
+  get size(): number {
+    return this.byId.size;
+  }
+
+  [Symbol.iterator](): Iterator<Delta> {
+    return this.byId.values();
+  }
+
+  // Sorted lexicographically — the canonical enumeration order.
+  ids(): string[] {
+    return [...this.byId.keys()].sort();
+  }
+
+  // Canonical membership fingerprint (ERRATA D10, provisional helper — not the SPEC-6 digest).
+  digest(): string {
+    return contentAddress(encode(array(this.ids().map(tstr))));
+  }
+}
+
+// merge(A, B) = A ∪ B — commutative, associative, idempotent (SPEC-1 §8).
+export function merge(a: DeltaSet, b: DeltaSet): DeltaSet {
+  const s = DeltaSet.from(a);
+  for (const d of b) s.add(d);
+  return s;
+}
+
+// fork(A, p) = { d ∈ A : p(d) } — any filter yields a valid delta set (SPEC-1 §8).
+export function fork(a: DeltaSet, p: (d: Delta) => boolean): DeltaSet {
+  const s = new DeltaSet();
+  for (const d of a) if (p(d)) s.add(d);
+  return s;
+}
+
+// federate(A, B, p) = A ∪ fork(B, p) — merge of a filtered fork (SPEC-1 §8).
+export function federate(a: DeltaSet, b: DeltaSet, p: (d: Delta) => boolean): DeltaSet {
+  return merge(a, fork(b, p));
+}

package/src/sign.ts

@@ -0,0 +1,48 @@
+// Ed25519 signing & verification (SPEC-1 §5, ERRATA D8-D9). Deterministic (RFC 8032), so
+// signatures are reproducible across implementations and pinned in vectors.
+
+import { ed25519 } from "@noble/curves/ed25519";
+import { bytesToHex, hexToBytes } from "@noble/hashes/utils";
+import { computeId } from "./delta.js";
+import type { Claims, Delta } from "./types.js";
+
+export const AUTHOR_PREFIX = "ed25519:";
+
+export function publicKeyFromSeed(seedHex: string): string {
+  return bytesToHex(ed25519.getPublicKey(hexToBytes(seedHex)));
+}
+
+// The author string a signed delta MUST carry for this seed (ERRATA D8).
+export function authorForSeed(seedHex: string): string {
+  return AUTHOR_PREFIX + publicKeyFromSeed(seedHex);
+}
+
+// Sign claims, producing a complete delta. Refuses to sign claims whose author does not match
+// the signing key — a signature contradicting its own author field is born broken (ERRATA D8).
+export function signClaims(claims: Claims, seedHex: string): Delta {
+  const expected = authorForSeed(seedHex);
+  if (claims.author !== expected) {
+    throw new Error(`author must be ${expected} for this signing key, got ${claims.author}`);
+  }
+  const id = computeId(claims);
+  const sig = bytesToHex(ed25519.sign(hexToBytes(id), hexToBytes(seedHex)));
+  return { id, claims, sig };
+}
+
+export type Verification = "verified" | "unsigned" | "invalid";
+
+// Full verification per ERRATA D9: content addressing must hold, then the signature must verify
+// over the raw id bytes against the key named in `author`.
+export function verifyDelta(delta: Delta): Verification {
+  if (computeId(delta.claims) !== delta.id) return "invalid";
+  if (delta.sig === undefined) return "unsigned";
+  if (!delta.claims.author.startsWith(AUTHOR_PREFIX)) return "invalid";
+  const pubHex = delta.claims.author.slice(AUTHOR_PREFIX.length);
+  try {
+    return ed25519.verify(hexToBytes(delta.sig), hexToBytes(delta.id), hexToBytes(pubHex))
+      ? "verified"
+      : "invalid";
+  } catch {
+    return "invalid";
+  }
+}

package/src/term-io.ts

@@ -0,0 +1,228 @@
+// Term serialization back to the JSON profile, the generic JSON<->CBOR bridge, and term hashing
+// (ERRATA-2 E12). parse(termToJson(t)) is identity on the AST, so semantically identical terms
+// hash identically regardless of authored spelling.
+
+import { type CborValue, array, bool, encode, float, map, tstr } from "./cbor.js";
+import type { Term } from "./eval.js";
+import { bytesToHex, contentAddress } from "./hash.js";
+import type { Order, Policy, PropPolicy } from "./policy.js";
+import type { Hole, Pred, PPred, StrMatch, ValMatch } from "./pred.js";
+import type { Primitive } from "./types.js";
+
+// --- AST -> JSON profile ---------------------------------------------------------------------------
+
+// Holes serialize to their profile spelling (E15); primitives pass through.
+function paramToJson(v: Primitive | Hole): unknown {
+  return typeof v === "object" ? { hole: v.name } : v;
+}
+
+function strMatchToJson(m: StrMatch): unknown {
+  switch (m.kind) {
+    case "exact":
+      return { exact: m.value };
+    case "prefix":
+      return { prefix: m.value };
+    case "inSet":
+      return { inSet: [...m.values] };
+    case "aliased": {
+      // Optional fields omitted when absent (SPEC-2 §7); the closure never enters the hash.
+      const a: Record<string, unknown> = { name: m.name };
+      if (m.via !== undefined) a["via"] = m.via;
+      if (m.trust !== undefined) a["trust"] = predToJson(m.trust);
+      return { aliased: a };
+    }
+  }
+}
+
+function valMatchToJson(m: ValMatch): unknown {
+  switch (m.kind) {
+    case "vcmp":
+      return { vcmp: { cmp: m.cmp, value: paramToJson(m.value) } };
+    case "between":
+      return { between: [m.lo, m.hi] };
+    case "inSet":
+      return { inSet: [...m.values] };
+  }
+}
+
+function ppredToJson(p: PPred): unknown {
+  const out: Record<string, unknown> = {};
+  if (p.role !== undefined) out["role"] = strMatchToJson(p.role);
+  if (p.targetEntity !== undefined) {
+    out["targetEntity"] =
+      p.targetEntity.kind === "const"
+        ? p.targetEntity.id
+        : p.targetEntity.kind === "hole"
+          ? { hole: p.targetEntity.name }
+          : { var: "root" };
+  }
+  if (p.targetDelta !== undefined) out["targetDelta"] = p.targetDelta;
+  if (p.context !== undefined) out["context"] = strMatchToJson(p.context);
+  if (p.targetIsPrimitive !== undefined) out["targetIsPrimitive"] = p.targetIsPrimitive;
+  if (p.targetValue !== undefined) out["targetValue"] = valMatchToJson(p.targetValue);
+  return out;
+}
+
+export function predToJson(pred: Pred): unknown {
+  switch (pred.kind) {
+    case "true":
+      return "true";
+    case "false":
+      return "false";
+    case "match":
+      return {
+        match: {
+          field: pred.field,
+          cmp: pred.cmp,
+          const: Array.isArray(pred.constant)
+            ? [...pred.constant]
+            : paramToJson(pred.constant as Primitive | Hole),
+        },
+      };
+    case "hasPointer":
+      return { hasPointer: ppredToJson(pred.ppred) };
+    case "and":
+      return { and: [predToJson(pred.left), predToJson(pred.right)] };
+    case "or":
+      return { or: [predToJson(pred.left), predToJson(pred.right)] };
+    case "not":
+      return { not: predToJson(pred.pred) };
+  }
+}
+
+function orderToJson(o: Order): unknown {
+  switch (o.kind) {
+    case "byTimestamp":
+      return { byTimestamp: o.dir };
+    case "byAuthorRank":
+      return { byAuthorRank: [...o.authors] };
+    case "byPred":
+      return { byPred: { pred: predToJson(o.pred), then: orderToJson(o.then) } };
+    case "lexById":
+      return "lexById";
+  }
+}
+
+function propPolicyToJson(pp: PropPolicy): unknown {
+  switch (pp.kind) {
+    case "pick":
+      return { pick: { order: orderToJson(pp.order) } };
+    case "all":
+      return { all: { order: orderToJson(pp.order) } };
+    case "merge":
+      return { merge: pp.fn };
+    case "conflicts":
+      return { conflicts: { order: orderToJson(pp.order) } };
+    case "absentAs":
+      return { absentAs: { const: pp.constant, then: propPolicyToJson(pp.then) } };
+  }
+}
+
+export function policyToJson(p: Policy): unknown {
+  const props: Record<string, unknown> = {};
+  for (const [k, v] of p.props) props[k] = propPolicyToJson(v);
+  return { props, default: propPolicyToJson(p.default) };
+}
+
+export function termToJson(term: Term): unknown {
+  switch (term.kind) {
+    case "input":
+      return "input";
+    case "select":
+      return { op: "select", pred: predToJson(term.pred), in: termToJson(term.of) };
+    case "union":
+      return { op: "union", left: termToJson(term.left), right: termToJson(term.right) };
+    case "mask": {
+      const policy =
+        term.policy.kind === "trust" ? { trust: predToJson(term.policy.pred) } : term.policy.kind;
+      return { op: "mask", policy, in: termToJson(term.of) };
+    }
+    case "group": {
+      const key = term.key.kind === "const" ? { const: term.key.prop } : term.key.kind;
+      return { op: "group", key, in: termToJson(term.of) };
+    }
+    case "prune":
+      return {
+        op: "prune",
+        keep: term.keep === "all" ? "all" : strMatchToJson(term.keep),
+        in: termToJson(term.of),
+      };
+    case "expand":
+      return {
+        op: "expand",
+        role: strMatchToJson(term.role),
+        schema: schemaRefToJson(term.schema),
+        in: termToJson(term.of),
+      };
+    case "fix": {
+      const out: Record<string, unknown> = {
+        op: "fix",
+        schema: schemaRefToJson(term.schema),
+        entity: term.entity,
+      };
+      if (term.bindings !== undefined && term.bindings.size > 0) {
+        const bindings: Record<string, Primitive> = {};
+        for (const key of [...term.bindings.keys()].sort()) {
+          bindings[key] = term.bindings.get(key)!;
+        }
+        out["bindings"] = bindings;
+      }
+      return out;
+    }
+    case "resolve":
+      return { op: "resolve", policy: policyToJson(term.policy), in: termToJson(term.of) };
+  }
+}
+
+function schemaRefToJson(ref: import("./eval.js").SchemaRefT): unknown {
+  return ref.kind === "name" ? ref.name : { pinned: ref.hash };
+}
+
+// --- generic JSON <-> CBOR bridge ------------------------------------------------------------------
+
+export function jsonToCbor(v: unknown): CborValue {
+  if (typeof v === "string") return tstr(v);
+  if (typeof v === "number") return float(v);
+  if (typeof v === "boolean") return bool(v);
+  if (Array.isArray(v)) return array(v.map(jsonToCbor));
+  if (typeof v === "object" && v !== null) {
+    return map(
+      Object.entries(v as Record<string, unknown>).map(([k, x]): readonly [string, CborValue] => [
+        k,
+        jsonToCbor(x),
+      ]),
+    );
+  }
+  throw new Error("json value outside the CBOR profile (null/undefined are not representable)");
+}
+
+export function cborToJson(v: CborValue): unknown {
+  switch (v.t) {
+    case "tstr":
+    case "float":
+    case "bool":
+      return v.v;
+    case "array":
+      return v.v.map(cborToJson);
+    case "map": {
+      const out: Record<string, unknown> = {};
+      for (const [k, x] of v.v) out[k] = cborToJson(x);
+      return out;
+    }
+  }
+}
+
+// --- term hashing (E12) ----------------------------------------------------------------------------
+
+export function termCanonicalBytes(term: Term): Uint8Array {
+  return encode(jsonToCbor(termToJson(term)));
+}
+
+export function termCanonicalHex(term: Term): string {
+  return bytesToHex(termCanonicalBytes(term));
+}
+
+// A term's content address: same multihash as deltas (E12).
+export function termHash(term: Term): string {
+  return contentAddress(termCanonicalBytes(term));
+}