@shapeshift-labs/frontier-lang 0.1.0 → 0.4.0

package/dist/index.js

@@ -1,608 +1,9 @@
-export function moduleNode(input) {
-  return { ...input, kind: "module" };
-}
-
-export function entityNode(input) {
-  return { ...input, kind: "entity" };
-}
-
-export function stateNode(input) {
-  return { ...input, kind: "state" };
-}
-
-export function actionNode(input) {
-  return { ...input, kind: "action" };
-}
-
-export function viewNode(input) {
-  return { ...input, kind: "view" };
-}
-
-export function migrationNode(input) {
-  return { ...input, kind: "migration" };
-}
-
-export function effectNode(input) {
-  return { ...input, kind: "effect" };
-}
-
-export function targetNode(input) {
-  return { ...input, kind: "target" };
-}
-
-export function createPatch(input) {
-  return {
-    ...input,
-    kind: "frontier.lang.patch",
-    version: 1
-  };
-}
-
-export function createDocument(input) {
-  const nodes = {};
-  for (const node of input.nodes) {
-    if (nodes[node.id]) {
-      throw new Error(`Duplicate semantic node id: ${node.id}`);
-    }
-    nodes[node.id] = node;
-  }
-
-  return {
-    kind: "frontier.lang.document",
-    version: 1,
-    id: input.id,
-    name: input.name,
-    rootIds: input.rootIds ?? input.nodes.filter((node) => !node.parentId).map((node) => node.id),
-    nodes,
-    history: input.history,
-    metadata: input.metadata
-  };
-}
-
-export function stableStringify(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
-  }
-
-  const entries = Object.entries(value)
-    .filter(([, item]) => item !== undefined)
-    .sort(([left], [right]) => ordinalCompare(left, right));
-
-  return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
-}
-
-export function hashSemanticValue(value) {
-  const serialized = stableStringify(value);
-  let hash = 0x811c9dc5;
-  for (let index = 0; index < serialized.length; index += 1) {
-    hash ^= serialized.charCodeAt(index);
-    hash = Math.imul(hash, 0x01000193);
-  }
-  return `fnv1a32:${(hash >>> 0).toString(16).padStart(8, "0")}`;
-}
-
-export function hashDocumentBase(document) {
-  return hashSemanticValue(stripHistory(document));
-}
-
-export function validateDocument(document) {
-  const issues = [];
-  const rootSet = new Set();
-
-  for (const rootId of document.rootIds) {
-    if (rootSet.has(rootId)) {
-      issues.push(`Duplicate root node: ${rootId}`);
-    }
-    rootSet.add(rootId);
-    if (!document.nodes[rootId]) {
-      issues.push(`Missing root node: ${rootId}`);
-    }
-  }
-
-  for (const [nodeId, node] of Object.entries(document.nodes)) {
-    if (node.id !== nodeId) {
-      issues.push(`Node record key ${nodeId} does not match node id ${node.id}`);
-    }
-
-    if (node.parentId && !document.nodes[node.parentId]) {
-      issues.push(`Node ${node.id} references missing parent ${node.parentId}`);
-    }
-
-    if (node.parentId === node.id) {
-      issues.push(`Node ${node.id} cannot be its own parent`);
-    }
-
-    if (!node.parentId && !rootSet.has(node.id)) {
-      issues.push(`Parentless node ${node.id} is missing from rootIds`);
-    }
-
-    if (node.parentId && rootSet.has(node.id)) {
-      issues.push(`Node ${node.id} has a parent and cannot be a root`);
-    }
-
-    if (hasAncestorCycle(document.nodes, node.id)) {
-      issues.push(`Node ${node.id} is part of a parent cycle`);
-    }
-
-    if (node.kind === "entity") {
-      const fieldIds = new Set();
-      for (const field of node.fields) {
-        if (fieldIds.has(field.id)) {
-          issues.push(`Entity ${node.id} has duplicate field id ${field.id}`);
-        }
-        fieldIds.add(field.id);
-      }
-    }
-  }
-
-  return issues;
-}
-
-export function applySemanticPatch(document, patch, event) {
-  if (patch.baseHash && patch.baseHash !== hashDocumentBase(document)) {
-    throw new Error(`Patch ${patch.id} base hash does not match document`);
-  }
-
-  let nodes = { ...document.nodes };
-  let rootIds = [...document.rootIds];
-
-  for (const operation of patch.operations) {
-    switch (operation.op) {
-      case "upsertNode": {
-        nodes = { ...nodes, [operation.node.id]: operation.node };
-        if (!operation.node.parentId && !rootIds.includes(operation.node.id)) {
-          rootIds = [...rootIds, operation.node.id];
-        }
-        break;
-      }
-      case "removeNode": {
-        const nextNodes = { ...nodes };
-        delete nextNodes[operation.id];
-        nodes = nextNodes;
-        rootIds = rootIds.filter((id) => id !== operation.id);
-        break;
-      }
-      case "renameNode": {
-        const node = requireNode(nodes, operation.id);
-        nodes = { ...nodes, [operation.id]: { ...node, name: operation.name } };
-        break;
-      }
-      case "moveNode": {
-        const node = requireNode(nodes, operation.id);
-        nodes = { ...nodes, [operation.id]: { ...node, parentId: operation.parentId } };
-        rootIds = operation.parentId
-          ? rootIds.filter((id) => id !== operation.id)
-          : unique([...rootIds, operation.id]);
-        break;
-      }
-      case "updateNode": {
-        if (
-          Object.hasOwn(operation.set, "id") ||
-          Object.hasOwn(operation.set, "kind") ||
-          Object.hasOwn(operation.set, "parentId")
-        ) {
-          throw new Error(`Patch ${patch.id} cannot update semantic node identity, kind, or parent`);
-        }
-        const node = requireNode(nodes, operation.id);
-        nodes = { ...nodes, [operation.id]: { ...node, ...operation.set } };
-        break;
-      }
-      case "addEvidence":
-        break;
-      default:
-        throw new Error(`Unexpected operation: ${operation.op}`);
-    }
-  }
-
-  const next = {
-    ...document,
-    rootIds,
-    nodes
-  };
-
-  const issues = validateDocument(next);
-  if (issues.length > 0) {
-    throw new Error(`Invalid document after patch ${patch.id}: ${issues.join("; ")}`);
-  }
-
-  if (patch.targetHash && patch.targetHash !== hashDocumentBase(next)) {
-    throw new Error(`Patch ${patch.id} target hash does not match result`);
-  }
-
-  return {
-    ...next,
-    history: [
-      ...(document.history ?? []),
-      event ?? {
-        id: `event:${patch.id}`,
-        patch
-      }
-    ]
-  };
-}
-
-export function replayDocument(initial, events) {
-  return events.reduce((document, event) => applySemanticPatch(document, event.patch, event), initial);
-}
-
-export function classifyMerge(base, left, right) {
-  const baseHash = hashDocumentBase(base);
-  const reasons = [];
-
-  if (left.baseHash && left.baseHash !== baseHash) {
-    reasons.push(`Left patch base hash ${left.baseHash} does not match current base ${baseHash}`);
-  }
-  if (right.baseHash && right.baseHash !== baseHash) {
-    reasons.push(`Right patch base hash ${right.baseHash} does not match current base ${baseHash}`);
-  }
-
-  const leftSummary = summarizePatch(left);
-  const rightSummary = summarizePatch(right);
-  const overlappingNodeIds = intersection(leftSummary.nodeIds, rightSummary.nodeIds);
-  const overlappingRegions = intersection(leftSummary.regions, rightSummary.regions);
-  const overlappingEffects = intersection(leftSummary.effects, rightSummary.effects);
-  const evidence = [...(left.evidence ?? []), ...(right.evidence ?? [])];
-  const failedEvidence = evidence.filter((record) => record.status === "failed");
-
-  if (reasons.length > 0) {
-    return {
-      status: "unknown-needs-review",
-      autoMergeable: false,
-      reasons,
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  if (failedEvidence.length > 0) {
-    return {
-      status: "unknown-needs-review",
-      autoMergeable: false,
-      reasons: [`Failed evidence prevents auto-merge: ${failedEvidence.map((record) => record.id).join(", ")}`],
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  if (stableStringify(left.operations) === stableStringify(right.operations)) {
-    return {
-      status: "safe-by-same-change",
-      autoMergeable: true,
-      reasons: ["Both patches contain the same semantic operations."],
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  const dynamicEffects = new Set(["dynamic", "eval", "unsafeEval", "ffi", "reflection", "proxy"]);
-  const hasDynamic = [...leftSummary.effects, ...rightSummary.effects].some((effect) =>
-    dynamicEffects.has(effect)
-  );
-  if (hasDynamic) {
-    return {
-      status: "unknown-by-dynamic-effect",
-      autoMergeable: false,
-      reasons: ["At least one patch touches a dynamic or opaque effect boundary."],
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  if (overlappingEffects.length > 0) {
-    return {
-      status: "conflict-by-effect-overlap",
-      autoMergeable: false,
-      reasons: [`Both patches touch effect(s): ${overlappingEffects.join(", ")}`],
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  if (overlappingNodeIds.length > 0 || overlappingRegions.length > 0) {
-    const laws = collectMergeLaws(base, [...overlappingNodeIds, ...overlappingRegions]);
-    if (laws.length > 0 && laws.every((law) => law === "semilattice" || law === "commutative")) {
-      return withReplayGate(base, left, right, {
-        status: "safe-by-merge-law",
-        autoMergeable: true,
-        reasons: [`Overlaps are covered by merge law(s): ${unique(laws).join(", ")}`],
-        overlappingNodeIds,
-        overlappingRegions,
-        overlappingEffects,
-        evidence
-      });
-    }
-
-    return {
-      status: "conflict-by-overlap",
-      autoMergeable: false,
-      reasons: ["Patches touch the same semantic node or region without a known merge law."],
-      overlappingNodeIds,
-      overlappingRegions,
-      overlappingEffects,
-      evidence
-    };
-  }
-
-  return withReplayGate(base, left, right, {
-    status: "safe-by-disjoint-region",
-    autoMergeable: true,
-    reasons: ["Patches touch disjoint semantic nodes, regions, and effects."],
-    overlappingNodeIds,
-    overlappingRegions,
-    overlappingEffects,
-    evidence
-  });
-}
-
-export function emitTypeScript(document, options = {}) {
-  const lines = [];
-  const banner = options.banner ?? "Generated by @shapeshift-labs/frontier-lang.";
-  lines.push(`// ${banner}`);
-  lines.push("");
-
-  if (options.includeRuntimeTypes ?? true) {
-    lines.push("export type FrontierPatchOperation =");
-    lines.push("  | { op: 'set'; path: string; value: unknown }");
-    lines.push("  | { op: 'remove'; path: string }");
-    lines.push("  | { op: 'insert'; path: string; value: unknown }");
-    lines.push("  | { op: 'merge'; path: string; value: unknown };");
-    lines.push("");
-  }
-
-  for (const node of Object.values(document.nodes)) {
-    if (node.kind === "entity") {
-      lines.push(`export interface ${safeIdentifier(node.name)} {`);
-      for (const field of node.fields) {
-        lines.push(`  ${safeIdentifier(field.name)}: ${toTypeScriptType(field.type)};`);
-      }
-      lines.push("}");
-      lines.push("");
-    }
-  }
-
-  for (const node of Object.values(document.nodes)) {
-    if (node.kind === "action") {
-      const inputType = node.input ? toTypeScriptType(node.input) : "unknown";
-      const returnType = node.returns ? toTypeScriptType(node.returns) : "FrontierPatchOperation[]";
-      lines.push(`export function ${safeIdentifier(node.name)}(`);
-      lines.push("  state: unknown,");
-      lines.push(`  input: ${inputType},`);
-      lines.push("  env: Record<string, unknown> = {}");
-      lines.push(`): ${returnType} {`);
-      lines.push("  void state;");
-      lines.push("  void input;");
-      lines.push("  void env;");
-      lines.push(`  return [] as ${returnType};`);
-      lines.push("}");
-      lines.push("");
-    }
-  }
-
-  return `${lines.join("\n").trimEnd()}\n`;
-}
-
-function stripHistory(document) {
-  const { history: _history, ...rest } = document;
-  return rest;
-}
-
-function requireNode(nodes, id) {
-  const node = nodes[id];
-  if (!node) {
-    throw new Error(`Unknown semantic node id: ${id}`);
-  }
-  return node;
-}
-
-function hasAncestorCycle(nodes, startId) {
-  const seen = new Set();
-  let current = nodes[startId];
-  while (current?.parentId) {
-    if (seen.has(current.parentId)) {
-      return true;
-    }
-    seen.add(current.parentId);
-    current = nodes[current.parentId];
-  }
-  return false;
-}
-
-function summarizePatch(patch) {
-  const nodeIds = [];
-  const regions = [];
-  const effects = [];
-
-  for (const operation of patch.operations) {
-    if ("id" in operation && typeof operation.id === "string") {
-      nodeIds.push(operation.id);
-    }
-    if (operation.op === "upsertNode") {
-      nodeIds.push(operation.node.id);
-      for (const region of operation.node.regions ?? []) {
-        regions.push(region.id);
-      }
-      if (operation.node.kind === "action") {
-        effects.push(...(operation.node.uses ?? []));
-      }
-      if (operation.node.kind === "effect") {
-        effects.push(operation.node.capability);
-      }
-    }
-    if (operation.op === "updateNode") {
-      if (Array.isArray(operation.set.uses)) {
-        effects.push(...operation.set.uses.filter((value) => typeof value === "string"));
-      }
-      if (typeof operation.set.capability === "string") {
-        effects.push(operation.set.capability);
-      }
-      if (Array.isArray(operation.set.regions)) {
-        for (const region of operation.set.regions) {
-          if (region && typeof region === "object" && region.access === "effect" && typeof region.id === "string") {
-            effects.push(region.id);
-          }
-        }
-      }
-    }
-
-    for (const region of operation.touches ?? []) {
-      regions.push(region.id);
-      if (region.access === "effect") {
-        effects.push(region.id);
-      }
-    }
-  }
-
-  return {
-    nodeIds: unique(nodeIds),
-    regions: unique(regions),
-    effects: unique(effects)
-  };
-}
-
-function withReplayGate(base, left, right, admission) {
-  if (!admission.autoMergeable) {
-    return admission;
-  }
-
-  try {
-    const leftForReplay = stripPatchAdmissionHashes(left);
-    const rightForReplay = stripPatchAdmissionHashes(right);
-    const leftThenRight = applySemanticPatch(applySemanticPatch(base, leftForReplay), rightForReplay);
-    const rightThenLeft = applySemanticPatch(applySemanticPatch(base, rightForReplay), leftForReplay);
-    const leftHash = hashDocumentBase(leftThenRight);
-    const rightHash = hashDocumentBase(rightThenLeft);
-    if (leftHash !== rightHash) {
-      return {
-        ...admission,
-        status: "unknown-needs-review",
-        autoMergeable: false,
-        reasons: [
-          ...admission.reasons,
-          `Replay order is not commutative: left-right ${leftHash}, right-left ${rightHash}`
-        ]
-      };
-    }
-    return admission;
-  } catch (error) {
-    return {
-      ...admission,
-      status: "unknown-needs-review",
-      autoMergeable: false,
-      reasons: [...admission.reasons, `Replay gate failed: ${error instanceof Error ? error.message : String(error)}`]
-    };
-  }
-}
-
-function stripPatchAdmissionHashes(patch) {
-  const { baseHash: _baseHash, targetHash: _targetHash, ...rest } = patch;
-  return rest;
-}
-
-function collectMergeLaws(document, overlaps) {
-  const overlapSet = new Set(overlaps);
-  const laws = [];
-
-  for (const node of Object.values(document.nodes)) {
-    if (node.kind === "entity") {
-      for (const field of node.fields) {
-        if (overlapSet.has(field.id) || overlapSet.has(`${node.name}.${field.name}`)) {
-          if (field.merge?.law) {
-            laws.push(field.merge.law);
-          }
-        }
-      }
-    }
-    if (node.kind === "state") {
-      for (const collection of node.collections) {
-        if (overlapSet.has(collection.id) || overlapSet.has(`${node.name}.${collection.name}`)) {
-          if (collection.merge?.law) {
-            laws.push(collection.merge.law);
-          }
-        }
-      }
-    }
-  }
-
-  return laws;
-}
-
-function intersection(left, right) {
-  const rightSet = new Set(right);
-  return unique(left.filter((item) => rightSet.has(item)));
-}
-
-function unique(items) {
-  return [...new Set(items)];
-}
-
-function ordinalCompare(left, right) {
-  if (left < right) {
-    return -1;
-  }
-  if (left > right) {
-    return 1;
-  }
-  return 0;
-}
-
-function safeIdentifier(name) {
-  const identifier = name.replace(/[^A-Za-z0-9_$]/g, "_");
-  if (/^[A-Za-z_$]/.test(identifier)) {
-    return identifier;
-  }
-  return `_${identifier}`;
-}
-
-function toTypeScriptType(type) {
-  const primitive = {
-    Text: "string",
-    String: "string",
-    Bool: "boolean",
-    Boolean: "boolean",
-    Int: "number",
-    Float: "number",
-    Number: "number",
-    Instant: "string",
-    Json: "unknown",
-    Patch: "FrontierPatchOperation[]"
-  };
-
-  if (primitive[type]) {
-    return primitive[type];
-  }
-
-  const setMatch = /^Set<(.+)>$/.exec(type);
-  if (setMatch) {
-    return `ReadonlySet<${toTypeScriptType(setMatch[1].trim())}>`;
-  }
-
-  const listMatch = /^(List|MoveList)<(.+)>$/.exec(type);
-  if (listMatch) {
-    return `readonly ${toTypeScriptType(listMatch[2].trim())}[]`;
-  }
-
-  const mapMatch = /^Map<(.+),(.+)>$/.exec(type);
-  if (mapMatch) {
-    return `ReadonlyMap<${toTypeScriptType(mapMatch[1].trim())}, ${toTypeScriptType(mapMatch[2].trim())}>`;
-  }
-
-  if (/^\{.*\}$/.test(type)) {
-    return "Record<string, unknown>";
-  }
-
-  return safeIdentifier(type);
-}
+export * from "@shapeshift-labs/frontier-lang-kernel";
+export * from "@shapeshift-labs/frontier-lang-parser";
+export * from "@shapeshift-labs/frontier-lang-checker";
+export * from "@shapeshift-labs/frontier-lang-typescript";
+export * from "@shapeshift-labs/frontier-lang-javascript";
+export * from "@shapeshift-labs/frontier-lang-rust";
+export * from "@shapeshift-labs/frontier-lang-python";
+export * from "@shapeshift-labs/frontier-lang-c";
+export * from "@shapeshift-labs/frontier-lang-compiler";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@shapeshift-labs/frontier-lang",
-  "version": "0.1.0",
-  "description": "Patch-native semantic source kernel for replayable programs, merge admission, and generated TypeScript projections.",
+  "version": "0.4.0",
+  "description": "Umbrella package for Frontier Lang kernel, parser, checker, compiler, and projection packages.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,8 +21,13 @@
   "scripts": {
     "build": "node scripts/build.mjs",
     "test": "npm run build && node test/smoke.mjs",
+    "fuzz": "npm run build && node fuzz/smoke.mjs",
+    "bench": "npm run build && node bench/smoke.mjs",
     "prepare": "npm run build",
-    "prepack": "npm test"
+    "prepack": "npm test",
+    "pack:dry": "npm pack --dry-run",
+    "readme:packages": "node benchmarks/package-readme-sections.mjs",
+    "readme:packages:check": "node benchmarks/package-readme-sections.mjs --check"
   },
   "keywords": [
     "frontier",
@@ -30,7 +35,9 @@
     "patch",
     "replay",
     "compiler",
-    "typescript"
+    "typescript",
+    "parser",
+    "checker"
   ],
   "author": "ShapeShift Labs",
   "license": "MIT",
@@ -44,5 +51,16 @@
   "homepage": "https://github.com/siliconjungle/-shapeshift-labs-frontier-lang#readme",
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@shapeshift-labs/frontier-lang-kernel": "0.3.0",
+    "@shapeshift-labs/frontier-lang-parser": "0.3.0",
+    "@shapeshift-labs/frontier-lang-checker": "0.3.0",
+    "@shapeshift-labs/frontier-lang-typescript": "0.3.0",
+    "@shapeshift-labs/frontier-lang-javascript": "0.2.0",
+    "@shapeshift-labs/frontier-lang-rust": "0.2.0",
+    "@shapeshift-labs/frontier-lang-python": "0.2.0",
+    "@shapeshift-labs/frontier-lang-c": "0.2.0",
+    "@shapeshift-labs/frontier-lang-compiler": "0.2.0"
   }
 }