@rolexjs/system 0.1.0

package/README.md

@@ -0,0 +1,241 @@
+# @rolexjs/system
+
+A concept world engine. Define concepts, build a tree, link them with relations — the world emerges.
+
+This package provides the **rules** of the concept world. It is domain-agnostic — it knows nothing about roles, organizations, or AI agents. The upper layer's job is to **define concepts** and paint the world using these rules.
+
+## The World
+
+The world is a graph made of concepts.
+
+Every node is a **Structure** — simultaneously three things:
+
+- **Concept** — what it is (name + description)
+- **Container** — can have child nodes
+- **Information carrier** — can hold information (e.g. a Gherkin Feature text)
+
+There is no special "container" type or "leaf" type. Every node is all three at once.
+
+```
+world
+├── agent                          ← concept, also a container
+│   ├── knowledge                  ← container (has children)
+│   │   ├── pattern                ← information carrier
+│   │   │      info: "Feature: ..."
+│   │   └── procedure
+│   │          info: "Feature: ..."
+│   ├── experience                 ← information carrier (no children)
+│   │      info: "Feature: I learned..."
+│   └── experience                 ← OR a container (has children)
+│       └── insight
+│              info: "Feature: JWT lesson..."
+└── org
+    └── position ──relation──→ agent    ← cross-branch link
+```
+
+### Tree + Relations = Graph
+
+- **Tree** (parent → child) provides the hierarchical backbone
+- **Relations** provide cross-branch associations
+- Together they form a graph
+
+## Four Concepts
+
+```
+Structure   — the node          (what exists)
+Relation    — the link          (how they connect)
+Process     — the change        (how it evolves)
+State       — the projection    (what you see)
+```
+
+### Structure
+
+A Structure defines a type of node in the concept world.
+
+```typescript
+import { structure } from "@rolexjs/system";
+
+// Root concept
+const world = structure("world", "The concept world", null);
+
+// Child concepts — parent defines where they live in the tree
+const agent = structure("agent", "An agent identity", world);
+const knowledge = structure("knowledge", "What I know", agent);
+const experience = structure("experience", "What I learned", agent);
+const insight = structure("insight", "A specific learning", experience);
+```
+
+The `parent` parameter establishes the tree backbone: `insight` lives under `experience`, which lives under `agent`, which lives under `world`.
+
+### Relation
+
+A Relation defines a cross-branch link type on a Structure.
+
+```typescript
+import { structure, relation } from "@rolexjs/system";
+
+const agent = structure("agent", "An agent identity", world);
+const org = structure("org", "An organization", world);
+
+// position lives under org, and can link to agent
+const position = structure("position", "A role in an organization", org, [
+  relation("appointment", "The individual holding this position", agent),
+]);
+```
+
+Relations are declared on the Structure definition as an array. A Structure can have multiple relations pointing to different concept types.
+
+### Process
+
+A Process defines how the world changes — a named composition of graph operations.
+
+Five graph primitives:
+
+| Primitive         | What it does                                         |
+| ----------------- | ---------------------------------------------------- |
+| `create(s)`       | Add a child node of structure type `s`               |
+| `remove(s)`       | Delete a node of structure type `s` and its subtree  |
+| `transform(a, b)` | Harvest from structure `a`, produce in structure `b` |
+| `link(s, r)`      | Establish relation `r` on structure `s`              |
+| `unlink(s, r)`    | Remove relation `r` on structure `s`                 |
+
+```typescript
+import { process, create, remove, transform, link, unlink } from "@rolexjs/system";
+
+// Read-only process (no ops) — just projects state
+const identity = process("identity", "Project full identity", agent);
+
+// Create process — adds a new concept instance
+const want = process("want", "Declare a goal", agent, create(goal));
+
+// Transform process — converts one concept into another
+const achieve = process("achieve", "Complete a goal", goal, transform(goal, insight));
+
+// Link process — establishes a cross-branch relation
+const appoint = process("appoint", "Assign to position", position, link(position, "appointment"));
+
+// Unlink process — removes a cross-branch relation
+const dismiss = process(
+  "dismiss",
+  "Remove from position",
+  position,
+  unlink(position, "appointment")
+);
+```
+
+### State
+
+A State is the projection of a node — a snapshot of its subtree and links.
+
+```typescript
+// State extends Structure, adding:
+interface State extends Structure {
+  children?: readonly State[]; // subtree
+  links?: readonly { relation: string; target: State }[]; // cross-branch links
+}
+```
+
+State is never stored — it is computed on demand via `runtime.project(node)`.
+
+## Runtime
+
+The Runtime is the execution engine. It operates on concept instances (nodes with `id`).
+
+```typescript
+import { createRuntime } from "@rolexjs/system";
+
+const rt = createRuntime();
+
+// Create instances
+const root = rt.create(null, world);
+const sean = rt.create(root, agent, "Feature: I am Sean...");
+const dp = rt.create(root, org);
+const arch = rt.create(dp, position);
+
+// Link them
+rt.link(arch, sean, "appointment");
+
+// Project the state
+const state = rt.project(root);
+// → world
+//   ├── agent (Sean)    info: "Feature: I am Sean..."
+//   └── org
+//       └── position
+//             links: [{ relation: "appointment", target: agent(Sean) }]
+
+// Unlink
+rt.unlink(arch, sean, "appointment");
+
+// Remove (cleans up subtree + all related links)
+rt.remove(arch);
+```
+
+### Runtime API
+
+| Method                             | Description                                          |
+| ---------------------------------- | ---------------------------------------------------- |
+| `create(parent, type, info?)`      | Create a node. `parent=null` for root.               |
+| `remove(node)`                     | Remove a node, its subtree, and all related links.   |
+| `transform(source, target, info?)` | Produce a new node in target's branch.               |
+| `link(from, to, relation)`         | Establish a cross-branch relation. Idempotent.       |
+| `unlink(from, to, relation)`       | Remove a cross-branch relation.                      |
+| `project(node)`                    | Compute the current state of a node and its subtree. |
+
+## Defining Your World
+
+This package provides the rules. Your job is to define the concepts.
+
+**Step 1: Define the concept tree** — what kinds of things exist and how they nest.
+
+```typescript
+const society = structure("society", "The world", null);
+const individual = structure("individual", "An agent", society);
+const persona = structure("persona", "Who I am", individual);
+const goal = structure("goal", "What I pursue", individual);
+const plan = structure("plan", "How to achieve it", goal);
+const task = structure("task", "Concrete work", plan);
+```
+
+**Step 2: Define relations** — what connects across branches.
+
+```typescript
+const org = structure("organization", "A group", society);
+const position = structure("position", "A role in the group", org, [
+  relation("appointment", "Who holds this", individual),
+]);
+```
+
+**Step 3: Define processes** — how the world changes.
+
+```typescript
+const want = process("want", "Declare a goal", individual, create(goal));
+const design = process("design", "Plan for a goal", goal, create(plan));
+const achieve = process("achieve", "Complete a goal", goal, transform(goal, conclusion));
+const appoint = process("appoint", "Assign to position", position, link(position, "appointment"));
+```
+
+**Step 4: Run it** — create instances, link them, project state.
+
+```typescript
+const rt = createRuntime();
+const world = rt.create(null, society);
+const sean = rt.create(world, individual, "Feature: I am Sean...");
+const myGoal = rt.create(sean, goal, "Feature: Build auth system...");
+const myPlan = rt.create(myGoal, plan, "Feature: Auth plan...");
+```
+
+The rules are fixed. The world is yours to paint.
+
+## Universal Formula
+
+```
+State = Process(Structure, Information?)
+```
+
+Everything reduces to this: a Process operates on a Structure (optionally with Information), and produces a State.
+
+## Install
+
+```bash
+bun add @rolexjs/system
+```

package/dist/index.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Structure — the universal node of the system graph.
+ *
+ * Every node is a Structure:
+ *   - What it is (name + description)
+ *   - Where it lives (parent — tree backbone)
+ *   - What it carries (information — Gherkin Feature source)
+ *   - What it relates to (relations — cross-branch links)
+ *
+ * Tree (parent-child) provides the hierarchical backbone.
+ * Relations provide cross-branch associations.
+ * Together they form a graph.
+ *
+ * Type definitions have no ref (schema).
+ * Runtime instances have ref (assigned by runtime).
+ * Every node can carry information AND have children.
+ *
+ * Identifiers:
+ *   ref   — graph engine internal reference (e.g., "n3", "e5"), assigned by runtime
+ *   id    — user-facing kebab-case identifier (e.g., "sean", "build-auth")
+ *   alias — alternative names for lookup (e.g., ["Sean", "姜山"])
+ */
+/** Relation — a cross-branch link type between structures. */
+interface Relation {
+    /** The relation name (e.g., "appointment"). */
+    readonly name: string;
+    /** What this relation means. */
+    readonly description: string;
+    /** The target structure type this relation points to. */
+    readonly target: Structure;
+}
+interface Structure {
+    /** Graph engine internal reference (e.g., "n3", "e5"), assigned by runtime. */
+    readonly ref?: string;
+    /** User-facing kebab-case identifier (e.g., "sean", "build-auth"). */
+    readonly id?: string;
+    /** Alternative names for lookup (e.g., ["Sean", "姜山"]). */
+    readonly alias?: readonly string[];
+    /** The structure name (e.g., "goal", "persona", "task"). */
+    readonly name: string;
+    /** What this structure is. */
+    readonly description: string;
+    /** Parent structure. null = root of the graph. */
+    readonly parent: Structure | null;
+    /** Gherkin Feature source text. */
+    readonly information?: string;
+    /** Relations to other structure types (cross-branch links). */
+    readonly relations?: readonly Relation[];
+}
+/**
+ * relation — declare a cross-branch link type.
+ */
+declare const relation: (name: string, description: string, target: Structure) => Relation;
+/**
+ * structure — declare a type of node in the system graph.
+ */
+declare const structure: (name: string, description: string, parent: Structure | null, relations?: Relation[]) => Structure;
+
+/**
+ * Process — how the system graph changes.
+ *
+ * Five graph primitives:
+ *   create    — add a child node under a parent
+ *   remove    — delete a node and its subtree
+ *   transform — harvest from one branch, produce in another
+ *   link      — establish a cross-branch relation
+ *   unlink    — remove a cross-branch relation
+ *
+ * Universal formula:
+ *   State = Process(Structure, Information?)
+ */
+
+/** create — add a new child node of a structure type. */
+interface Create {
+    readonly op: "create";
+    readonly structure: Structure;
+}
+/** remove — delete a node (and its subtree). */
+interface Remove {
+    readonly op: "remove";
+    readonly structure: Structure;
+}
+/** transform — harvest from one structure, produce another in a different branch. */
+interface Transform {
+    readonly op: "transform";
+    readonly from: Structure;
+    readonly to: Structure;
+}
+/** link — establish a cross-branch relation. */
+interface Link {
+    readonly op: "link";
+    readonly structure: Structure;
+    readonly relation: string;
+}
+/** unlink — remove a cross-branch relation. */
+interface Unlink {
+    readonly op: "unlink";
+    readonly structure: Structure;
+    readonly relation: string;
+}
+/** A single graph operation. */
+type GraphOp = Create | Remove | Transform | Link | Unlink;
+/**
+ * Process — a named composition of graph operations.
+ *
+ * Universal formula:
+ *   State = Process(Structure, Information?)
+ */
+interface Process {
+    /** The process name (e.g., "want", "achieve", "reflect"). */
+    readonly name: string;
+    /** What this process does. */
+    readonly description: string;
+    /** The structure type this process targets. */
+    readonly target: Structure;
+    /** The graph operations this process performs, in order. */
+    readonly ops: readonly GraphOp[];
+}
+/**
+ * State — the projection of a node after a process executes.
+ *
+ * A State is a Structure snapshot with its subtree and links.
+ */
+interface State extends Structure {
+    /** Child states (subtree projection). */
+    readonly children?: readonly State[];
+    /** Cross-branch links from this node. */
+    readonly links?: readonly {
+        readonly relation: string;
+        readonly target: State;
+    }[];
+    /** Origin of this node in a merged projection: prototype (read-only) or instance (mutable). */
+    readonly origin?: "prototype" | "instance";
+}
+declare const create: (structure: Structure) => Create;
+declare const remove: (structure: Structure) => Remove;
+declare const transform: (from: Structure, to: Structure) => Transform;
+declare const link: (structure: Structure, relation: string) => Link;
+declare const unlink: (structure: Structure, relation: string) => Unlink;
+declare const process: (name: string, description: string, target: Structure, ...ops: GraphOp[]) => Process;
+
+/**
+ * mergeState — union merge two State trees.
+ *
+ * Prototype mechanism: merge a base (prototype) with an overlay (instance).
+ * Children are unioned, not overwritten. Links are unioned and deduplicated.
+ *
+ * Matching rules for children:
+ *   - Same name + same id (both defined)  → recursive merge
+ *   - Same name + both no id + one each   → recursive merge (structural singleton)
+ *   - Everything else                     → include from both sides
+ */
+
+declare const mergeState: (base: State, overlay: State) => State;
+
+/**
+ * Prototype — a source of base State trees for merging.
+ *
+ * A prototype provides a pre-configured State tree (template) that gets
+ * merged with an instance State via mergeState.
+ *
+ * Matching is by id: if prototype and instance share the same id,
+ * they are the same entity — prototype provides the base,
+ * instance provides the overlay.
+ *
+ * activate(id) = mergeState(prototype.resolve(id), runtime.project(id))
+ */
+
+/** A source that resolves prototype State trees by id. */
+interface Prototype {
+    /** Resolve a prototype State by id. Returns undefined if no prototype exists. */
+    resolve(id: string): Promise<State | undefined>;
+}
+/** Create an in-memory prototype source. */
+declare const createPrototype: () => Prototype & {
+    /** Register a State tree as a prototype (keyed by state.id). */
+    register(state: State): void;
+};
+
+/**
+ * Runtime — execution engine for the system graph.
+ *
+ * Six operations:
+ *   create    — add a child node under a parent
+ *   remove    — delete a node and its subtree
+ *   transform — produce from one branch into another
+ *   link      — establish a cross-branch relation
+ *   unlink    — remove a cross-branch relation
+ *   project   — read the current state
+ *
+ * State = Process(Structure, Information?)
+ */
+
+interface Runtime {
+    /** Create a child node (parent=null for root). Type is the structure template. */
+    create(parent: Structure | null, type: Structure, information?: string, id?: string, alias?: readonly string[]): Structure;
+    /** Remove a node and its subtree. */
+    remove(node: Structure): void;
+    /** Produce a new node in target structure's branch, sourced from another branch. */
+    transform(source: Structure, target: Structure, information?: string): Structure;
+    /** Establish a bidirectional cross-branch relation between two nodes. */
+    link(from: Structure, to: Structure, relation: string, reverse: string): void;
+    /** Remove a bidirectional cross-branch relation between two nodes. */
+    unlink(from: Structure, to: Structure, relation: string, reverse: string): void;
+    /** Project the current state of a node and its subtree (including links). */
+    project(node: Structure): State;
+    /** Return all root nodes (nodes without a parent edge). */
+    roots(): Structure[];
+}
+declare const createRuntime: () => Runtime;
+
+export { type Create, type GraphOp, type Link, type Process, type Prototype, type Relation, type Remove, type Runtime, type State, type Structure, type Transform, type Unlink, create, createPrototype, createRuntime, link, mergeState, process, relation, remove, structure, transform, unlink };

package/dist/index.js

@@ -0,0 +1,312 @@
+// src/structure.ts
+var relation = (name, description, target) => ({
+  name,
+  description,
+  target
+});
+var structure = (name, description, parent, relations) => ({
+  name,
+  description,
+  parent,
+  ...relations ? { relations } : {}
+});
+
+// src/process.ts
+var create = (structure2) => ({ op: "create", structure: structure2 });
+var remove = (structure2) => ({ op: "remove", structure: structure2 });
+var transform = (from, to) => ({
+  op: "transform",
+  from,
+  to
+});
+var link = (structure2, relation2) => ({
+  op: "link",
+  structure: structure2,
+  relation: relation2
+});
+var unlink = (structure2, relation2) => ({
+  op: "unlink",
+  structure: structure2,
+  relation: relation2
+});
+var process = (name, description, target, ...ops) => ({
+  name,
+  description,
+  target,
+  ops
+});
+
+// src/merge.ts
+var mergeState = (base, overlay) => {
+  const taggedBase = tagOrigin(base, "prototype");
+  const taggedOverlay = tagOrigin(overlay, "instance");
+  const mergedChildren = mergeChildren(taggedBase.children, taggedOverlay.children);
+  const mergedLinks = mergeLinks(taggedBase.links, taggedOverlay.links);
+  return {
+    ...taggedBase,
+    // overlay scalar properties take precedence when present
+    ...overlay.ref ? { ref: overlay.ref } : {},
+    ...overlay.id ? { id: overlay.id } : {},
+    ...overlay.information ? { information: overlay.information } : {},
+    ...overlay.alias ? { alias: overlay.alias } : {},
+    ...mergedChildren ? { children: mergedChildren } : {},
+    ...mergedLinks ? { links: mergedLinks } : {},
+    // root node with overlay ref is instance
+    origin: overlay.ref ? "instance" : "prototype"
+  };
+};
+var tagOrigin = (state, origin) => ({
+  ...state,
+  origin,
+  ...state.children ? { children: state.children.map((c) => tagOrigin(c, origin)) } : {}
+});
+var mergeChildren = (baseChildren, overlayChildren) => {
+  if (!baseChildren && !overlayChildren) return void 0;
+  if (!baseChildren) return overlayChildren;
+  if (!overlayChildren) return baseChildren;
+  const result = [];
+  const baseByName = groupByName(baseChildren);
+  const overlayByName = groupByName(overlayChildren);
+  const allNames = /* @__PURE__ */ new Set([...baseByName.keys(), ...overlayByName.keys()]);
+  for (const name of allNames) {
+    const baseGroup = baseByName.get(name) ?? [];
+    const overlayGroup = overlayByName.get(name) ?? [];
+    if (baseGroup.length === 0) {
+      result.push(...overlayGroup);
+      continue;
+    }
+    if (overlayGroup.length === 0) {
+      result.push(...baseGroup);
+      continue;
+    }
+    const matchedOverlay = /* @__PURE__ */ new Set();
+    const unmatchedBase = [];
+    for (const b of baseGroup) {
+      if (b.id) {
+        const oIdx = overlayGroup.findIndex((o, i) => !matchedOverlay.has(i) && o.id === b.id);
+        if (oIdx >= 0) {
+          result.push(mergeState(b, overlayGroup[oIdx]));
+          matchedOverlay.add(oIdx);
+        } else {
+          unmatchedBase.push(b);
+        }
+      } else {
+        unmatchedBase.push(b);
+      }
+    }
+    const unmatchedOverlay = overlayGroup.filter((_, i) => !matchedOverlay.has(i));
+    const noIdBase = unmatchedBase.filter((s) => !s.id);
+    const hasIdBase = unmatchedBase.filter((s) => s.id);
+    const noIdOverlay = unmatchedOverlay.filter((s) => !s.id);
+    const hasIdOverlay = unmatchedOverlay.filter((s) => s.id);
+    if (noIdBase.length === 1 && noIdOverlay.length === 1) {
+      result.push(mergeState(noIdBase[0], noIdOverlay[0]));
+    } else {
+      result.push(...noIdBase, ...noIdOverlay);
+    }
+    result.push(...hasIdBase, ...hasIdOverlay);
+  }
+  return result;
+};
+var mergeLinks = (baseLinks, overlayLinks) => {
+  if (!baseLinks && !overlayLinks) return void 0;
+  if (!baseLinks) return overlayLinks;
+  if (!overlayLinks) return baseLinks;
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const link2 of [...baseLinks, ...overlayLinks]) {
+    const key = `${link2.relation}:${link2.target.id ?? link2.target.ref ?? link2.target.name}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(link2);
+    }
+  }
+  return result;
+};
+var groupByName = (states) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const s of states) {
+    const group = map.get(s.name);
+    if (group) {
+      group.push(s);
+    } else {
+      map.set(s.name, [s]);
+    }
+  }
+  return map;
+};
+
+// src/prototype.ts
+var createPrototype = () => {
+  const prototypes = /* @__PURE__ */ new Map();
+  return {
+    async resolve(id) {
+      return prototypes.get(id);
+    },
+    register(state) {
+      if (!state.id) {
+        throw new Error("Prototype state must have an id");
+      }
+      prototypes.set(state.id, state);
+    }
+  };
+};
+
+// src/runtime.ts
+var createRuntime = () => {
+  const nodes = /* @__PURE__ */ new Map();
+  const links = /* @__PURE__ */ new Map();
+  let counter = 0;
+  const nextRef = () => `e${++counter}`;
+  const findByStructure = (structure2) => {
+    for (const treeNode of nodes.values()) {
+      if (treeNode.node.name === structure2.name) return treeNode;
+    }
+    return void 0;
+  };
+  const removeSubtree = (ref) => {
+    const treeNode = nodes.get(ref);
+    if (!treeNode) return;
+    for (const childRef of [...treeNode.children]) {
+      removeSubtree(childRef);
+    }
+    links.delete(ref);
+    for (const [fromRef, fromLinks] of links.entries()) {
+      const filtered = fromLinks.filter((l) => l.toId !== ref);
+      if (filtered.length === 0) {
+        links.delete(fromRef);
+      } else {
+        links.set(fromRef, filtered);
+      }
+    }
+    nodes.delete(ref);
+  };
+  const projectRef = (ref) => {
+    const treeNode = nodes.get(ref);
+    return { ...treeNode.node, children: [] };
+  };
+  const projectNode = (ref) => {
+    const treeNode = nodes.get(ref);
+    const nodeLinks = links.get(ref);
+    return {
+      ...treeNode.node,
+      children: treeNode.children.map(projectNode),
+      ...nodeLinks && nodeLinks.length > 0 ? {
+        links: nodeLinks.map((l) => ({
+          relation: l.relation,
+          target: projectRef(l.toId)
+        }))
+      } : {}
+    };
+  };
+  const createNode = (parentRef, type, information, id, alias) => {
+    const ref = nextRef();
+    const node = {
+      ref,
+      ...id ? { id } : {},
+      ...alias && alias.length > 0 ? { alias } : {},
+      name: type.name,
+      description: type.description,
+      parent: type.parent,
+      information
+    };
+    const treeNode = { node, parent: parentRef, children: [] };
+    nodes.set(ref, treeNode);
+    if (parentRef) {
+      const parentTreeNode = nodes.get(parentRef);
+      if (!parentTreeNode) throw new Error(`Parent not found: ${parentRef}`);
+      parentTreeNode.children.push(ref);
+    }
+    return node;
+  };
+  return {
+    create(parent, type, information, id, alias) {
+      return createNode(parent?.ref ?? null, type, information, id, alias);
+    },
+    remove(node) {
+      if (!node.ref) return;
+      const treeNode = nodes.get(node.ref);
+      if (!treeNode) return;
+      if (treeNode.parent) {
+        const parentTreeNode = nodes.get(treeNode.parent);
+        if (parentTreeNode) {
+          parentTreeNode.children = parentTreeNode.children.filter((r) => r !== node.ref);
+        }
+      }
+      removeSubtree(node.ref);
+    },
+    transform(_source, target, information) {
+      const targetParent = target.parent;
+      if (!targetParent) {
+        throw new Error(`Cannot transform to root structure: ${target.name}`);
+      }
+      const parentTreeNode = findByStructure(targetParent);
+      if (!parentTreeNode) {
+        throw new Error(`No node found for structure: ${targetParent.name}`);
+      }
+      return createNode(parentTreeNode.node.ref, target, information);
+    },
+    link(from, to, relationName, reverseName) {
+      if (!from.ref) throw new Error("Source node has no ref");
+      if (!to.ref) throw new Error("Target node has no ref");
+      const fromLinks = links.get(from.ref) ?? [];
+      if (!fromLinks.some((l) => l.toId === to.ref && l.relation === relationName)) {
+        fromLinks.push({ toId: to.ref, relation: relationName });
+        links.set(from.ref, fromLinks);
+      }
+      const toLinks = links.get(to.ref) ?? [];
+      if (!toLinks.some((l) => l.toId === from.ref && l.relation === reverseName)) {
+        toLinks.push({ toId: from.ref, relation: reverseName });
+        links.set(to.ref, toLinks);
+      }
+    },
+    unlink(from, to, relationName, reverseName) {
+      if (!from.ref || !to.ref) return;
+      const fromLinks = links.get(from.ref);
+      if (fromLinks) {
+        const filtered = fromLinks.filter(
+          (l) => !(l.toId === to.ref && l.relation === relationName)
+        );
+        if (filtered.length === 0) links.delete(from.ref);
+        else links.set(from.ref, filtered);
+      }
+      const toLinks = links.get(to.ref);
+      if (toLinks) {
+        const filtered = toLinks.filter(
+          (l) => !(l.toId === from.ref && l.relation === reverseName)
+        );
+        if (filtered.length === 0) links.delete(to.ref);
+        else links.set(to.ref, filtered);
+      }
+    },
+    project(node) {
+      if (!node.ref || !nodes.has(node.ref)) {
+        throw new Error(`Node not found: ${node.ref}`);
+      }
+      return projectNode(node.ref);
+    },
+    roots() {
+      const result = [];
+      for (const treeNode of nodes.values()) {
+        if (treeNode.parent === null) {
+          result.push(treeNode.node);
+        }
+      }
+      return result;
+    }
+  };
+};
+export {
+  create,
+  createPrototype,
+  createRuntime,
+  link,
+  mergeState,
+  process,
+  relation,
+  remove,
+  structure,
+  transform,
+  unlink
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/structure.ts","../src/process.ts","../src/merge.ts","../src/prototype.ts","../src/runtime.ts"],"sourcesContent":["/**\n * Structure — the universal node of the system graph.\n *\n * Every node is a Structure:\n *   - What it is (name + description)\n *   - Where it lives (parent — tree backbone)\n *   - What it carries (information — Gherkin Feature source)\n *   - What it relates to (relations — cross-branch links)\n *\n * Tree (parent-child) provides the hierarchical backbone.\n * Relations provide cross-branch associations.\n * Together they form a graph.\n *\n * Type definitions have no ref (schema).\n * Runtime instances have ref (assigned by runtime).\n * Every node can carry information AND have children.\n *\n * Identifiers:\n *   ref   — graph engine internal reference (e.g., \"n3\", \"e5\"), assigned by runtime\n *   id    — user-facing kebab-case identifier (e.g., \"sean\", \"build-auth\")\n *   alias — alternative names for lookup (e.g., [\"Sean\", \"姜山\"])\n */\n\n// ===== Relation =====\n\n/** Relation — a cross-branch link type between structures. */\nexport interface Relation {\n  /** The relation name (e.g., \"appointment\"). */\n  readonly name: string;\n\n  /** What this relation means. */\n  readonly description: string;\n\n  /** The target structure type this relation points to. */\n  readonly target: Structure;\n}\n\n// ===== Structure =====\n\nexport interface Structure {\n  /** Graph engine internal reference (e.g., \"n3\", \"e5\"), assigned by runtime. */\n  readonly ref?: string;\n\n  /** User-facing kebab-case identifier (e.g., \"sean\", \"build-auth\"). */\n  readonly id?: string;\n\n  /** Alternative names for lookup (e.g., [\"Sean\", \"姜山\"]). */\n  readonly alias?: readonly string[];\n\n  /** The structure name (e.g., \"goal\", \"persona\", \"task\"). */\n  readonly name: string;\n\n  /** What this structure is. */\n  readonly description: string;\n\n  /** Parent structure. null = root of the graph. */\n  readonly parent: Structure | null;\n\n  /** Gherkin Feature source text. */\n  readonly information?: string;\n\n  /** Relations to other structure types (cross-branch links). */\n  readonly relations?: readonly Relation[];\n}\n\n// ===== Constructors =====\n\n/**\n * relation — declare a cross-branch link type.\n */\nexport const relation = (name: string, description: string, target: Structure): Relation => ({\n  name,\n  description,\n  target,\n});\n\n/**\n * structure — declare a type of node in the system graph.\n */\nexport const structure = (\n  name: string,\n  description: string,\n  parent: Structure | null,\n  relations?: Relation[]\n): Structure => ({\n  name,\n  description,\n  parent,\n  ...(relations ? { relations } : {}),\n});\n","/**\n * Process — how the system graph changes.\n *\n * Five graph primitives:\n *   create    — add a child node under a parent\n *   remove    — delete a node and its subtree\n *   transform — harvest from one branch, produce in another\n *   link      — establish a cross-branch relation\n *   unlink    — remove a cross-branch relation\n *\n * Universal formula:\n *   State = Process(Structure, Information?)\n */\nimport type { Structure } from \"./structure.js\";\n\n// ===== Graph Primitives =====\n\n/** create — add a new child node of a structure type. */\nexport interface Create {\n  readonly op: \"create\";\n  readonly structure: Structure;\n}\n\n/** remove — delete a node (and its subtree). */\nexport interface Remove {\n  readonly op: \"remove\";\n  readonly structure: Structure;\n}\n\n/** transform — harvest from one structure, produce another in a different branch. */\nexport interface Transform {\n  readonly op: \"transform\";\n  readonly from: Structure;\n  readonly to: Structure;\n}\n\n/** link — establish a cross-branch relation. */\nexport interface Link {\n  readonly op: \"link\";\n  readonly structure: Structure;\n  readonly relation: string;\n}\n\n/** unlink — remove a cross-branch relation. */\nexport interface Unlink {\n  readonly op: \"unlink\";\n  readonly structure: Structure;\n  readonly relation: string;\n}\n\n/** A single graph operation. */\nexport type GraphOp = Create | Remove | Transform | Link | Unlink;\n\n// ===== Process =====\n\n/**\n * Process — a named composition of graph operations.\n *\n * Universal formula:\n *   State = Process(Structure, Information?)\n */\nexport interface Process {\n  /** The process name (e.g., \"want\", \"achieve\", \"reflect\"). */\n  readonly name: string;\n\n  /** What this process does. */\n  readonly description: string;\n\n  /** The structure type this process targets. */\n  readonly target: Structure;\n\n  /** The graph operations this process performs, in order. */\n  readonly ops: readonly GraphOp[];\n}\n\n// ===== State =====\n\n/**\n * State — the projection of a node after a process executes.\n *\n * A State is a Structure snapshot with its subtree and links.\n */\nexport interface State extends Structure {\n  /** Child states (subtree projection). */\n  readonly children?: readonly State[];\n\n  /** Cross-branch links from this node. */\n  readonly links?: readonly { readonly relation: string; readonly target: State }[];\n\n  /** Origin of this node in a merged projection: prototype (read-only) or instance (mutable). */\n  readonly origin?: \"prototype\" | \"instance\";\n}\n\n// ===== Constructors =====\n\nexport const create = (structure: Structure): Create => ({ op: \"create\", structure });\n\nexport const remove = (structure: Structure): Remove => ({ op: \"remove\", structure });\n\nexport const transform = (from: Structure, to: Structure): Transform => ({\n  op: \"transform\",\n  from,\n  to,\n});\n\nexport const link = (structure: Structure, relation: string): Link => ({\n  op: \"link\",\n  structure,\n  relation,\n});\n\nexport const unlink = (structure: Structure, relation: string): Unlink => ({\n  op: \"unlink\",\n  structure,\n  relation,\n});\n\nexport const process = (\n  name: string,\n  description: string,\n  target: Structure,\n  ...ops: GraphOp[]\n): Process => ({\n  name,\n  description,\n  target,\n  ops,\n});\n","/**\n * mergeState — union merge two State trees.\n *\n * Prototype mechanism: merge a base (prototype) with an overlay (instance).\n * Children are unioned, not overwritten. Links are unioned and deduplicated.\n *\n * Matching rules for children:\n *   - Same name + same id (both defined)  → recursive merge\n *   - Same name + both no id + one each   → recursive merge (structural singleton)\n *   - Everything else                     → include from both sides\n */\nimport type { State } from \"./process.js\";\n\nexport const mergeState = (base: State, overlay: State): State => {\n  const taggedBase = tagOrigin(base, \"prototype\");\n  const taggedOverlay = tagOrigin(overlay, \"instance\");\n  const mergedChildren = mergeChildren(taggedBase.children, taggedOverlay.children);\n  const mergedLinks = mergeLinks(taggedBase.links, taggedOverlay.links);\n\n  return {\n    ...taggedBase,\n    // overlay scalar properties take precedence when present\n    ...(overlay.ref ? { ref: overlay.ref } : {}),\n    ...(overlay.id ? { id: overlay.id } : {}),\n    ...(overlay.information ? { information: overlay.information } : {}),\n    ...(overlay.alias ? { alias: overlay.alias } : {}),\n    ...(mergedChildren ? { children: mergedChildren } : {}),\n    ...(mergedLinks ? { links: mergedLinks } : {}),\n    // root node with overlay ref is instance\n    origin: overlay.ref ? \"instance\" : \"prototype\",\n  };\n};\n\n/** Tag all nodes in a state tree with an origin marker. */\nconst tagOrigin = (state: State, origin: \"prototype\" | \"instance\"): State => ({\n  ...state,\n  origin,\n  ...(state.children ? { children: state.children.map((c) => tagOrigin(c, origin)) } : {}),\n});\n\nconst mergeChildren = (\n  baseChildren?: readonly State[],\n  overlayChildren?: readonly State[]\n): readonly State[] | undefined => {\n  if (!baseChildren && !overlayChildren) return undefined;\n  if (!baseChildren) return overlayChildren;\n  if (!overlayChildren) return baseChildren;\n\n  const result: State[] = [];\n\n  // Group children by name\n  const baseByName = groupByName(baseChildren);\n  const overlayByName = groupByName(overlayChildren);\n  const allNames = new Set([...baseByName.keys(), ...overlayByName.keys()]);\n\n  for (const name of allNames) {\n    const baseGroup = baseByName.get(name) ?? [];\n    const overlayGroup = overlayByName.get(name) ?? [];\n\n    if (baseGroup.length === 0) {\n      result.push(...overlayGroup);\n      continue;\n    }\n    if (overlayGroup.length === 0) {\n      result.push(...baseGroup);\n      continue;\n    }\n\n    // Match by id\n    const matchedOverlay = new Set<number>();\n    const unmatchedBase: State[] = [];\n\n    for (const b of baseGroup) {\n      if (b.id) {\n        const oIdx = overlayGroup.findIndex((o, i) => !matchedOverlay.has(i) && o.id === b.id);\n        if (oIdx >= 0) {\n          result.push(mergeState(b, overlayGroup[oIdx]));\n          matchedOverlay.add(oIdx);\n        } else {\n          unmatchedBase.push(b);\n        }\n      } else {\n        unmatchedBase.push(b);\n      }\n    }\n\n    const unmatchedOverlay = overlayGroup.filter((_, i) => !matchedOverlay.has(i));\n\n    // Singleton merge: same name, no id, exactly one on each side\n    const noIdBase = unmatchedBase.filter((s) => !s.id);\n    const hasIdBase = unmatchedBase.filter((s) => s.id);\n    const noIdOverlay = unmatchedOverlay.filter((s) => !s.id);\n    const hasIdOverlay = unmatchedOverlay.filter((s) => s.id);\n\n    if (noIdBase.length === 1 && noIdOverlay.length === 1) {\n      result.push(mergeState(noIdBase[0], noIdOverlay[0]));\n    } else {\n      result.push(...noIdBase, ...noIdOverlay);\n    }\n\n    result.push(...hasIdBase, ...hasIdOverlay);\n  }\n\n  return result;\n};\n\nconst mergeLinks = (\n  baseLinks?: State[\"links\"],\n  overlayLinks?: State[\"links\"]\n): State[\"links\"] | undefined => {\n  if (!baseLinks && !overlayLinks) return undefined;\n  if (!baseLinks) return overlayLinks;\n  if (!overlayLinks) return baseLinks;\n\n  const seen = new Set<string>();\n  const result: { readonly relation: string; readonly target: State }[] = [];\n\n  for (const link of [...baseLinks, ...overlayLinks]) {\n    const key = `${link.relation}:${link.target.id ?? link.target.ref ?? link.target.name}`;\n    if (!seen.has(key)) {\n      seen.add(key);\n      result.push(link);\n    }\n  }\n\n  return result;\n};\n\nconst groupByName = (states: readonly State[]): Map<string, State[]> => {\n  const map = new Map<string, State[]>();\n  for (const s of states) {\n    const group = map.get(s.name);\n    if (group) {\n      group.push(s);\n    } else {\n      map.set(s.name, [s]);\n    }\n  }\n  return map;\n};\n","/**\n * Prototype — a source of base State trees for merging.\n *\n * A prototype provides a pre-configured State tree (template) that gets\n * merged with an instance State via mergeState.\n *\n * Matching is by id: if prototype and instance share the same id,\n * they are the same entity — prototype provides the base,\n * instance provides the overlay.\n *\n * activate(id) = mergeState(prototype.resolve(id), runtime.project(id))\n */\nimport type { State } from \"./process.js\";\n\n// ===== Prototype interface =====\n\n/** A source that resolves prototype State trees by id. */\nexport interface Prototype {\n  /** Resolve a prototype State by id. Returns undefined if no prototype exists. */\n  resolve(id: string): Promise<State | undefined>;\n}\n\n// ===== In-memory implementation =====\n\n/** Create an in-memory prototype source. */\nexport const createPrototype = (): Prototype & {\n  /** Register a State tree as a prototype (keyed by state.id). */\n  register(state: State): void;\n} => {\n  const prototypes = new Map<string, State>();\n\n  return {\n    async resolve(id) {\n      return prototypes.get(id);\n    },\n\n    register(state) {\n      if (!state.id) {\n        throw new Error(\"Prototype state must have an id\");\n      }\n      prototypes.set(state.id, state);\n    },\n  };\n};\n","/**\n * Runtime — execution engine for the system graph.\n *\n * Six operations:\n *   create    — add a child node under a parent\n *   remove    — delete a node and its subtree\n *   transform — produce from one branch into another\n *   link      — establish a cross-branch relation\n *   unlink    — remove a cross-branch relation\n *   project   — read the current state\n *\n * State = Process(Structure, Information?)\n */\n\nimport type { State } from \"./process.js\";\nimport type { Structure } from \"./structure.js\";\n\n// ===== Runtime interface =====\n\nexport interface Runtime {\n  /** Create a child node (parent=null for root). Type is the structure template. */\n  create(\n    parent: Structure | null,\n    type: Structure,\n    information?: string,\n    id?: string,\n    alias?: readonly string[]\n  ): Structure;\n\n  /** Remove a node and its subtree. */\n  remove(node: Structure): void;\n\n  /** Produce a new node in target structure's branch, sourced from another branch. */\n  transform(source: Structure, target: Structure, information?: string): Structure;\n\n  /** Establish a bidirectional cross-branch relation between two nodes. */\n  link(from: Structure, to: Structure, relation: string, reverse: string): void;\n\n  /** Remove a bidirectional cross-branch relation between two nodes. */\n  unlink(from: Structure, to: Structure, relation: string, reverse: string): void;\n\n  /** Project the current state of a node and its subtree (including links). */\n  project(node: Structure): State;\n\n  /** Return all root nodes (nodes without a parent edge). */\n  roots(): Structure[];\n}\n\n// ===== In-memory implementation =====\n\ninterface TreeNode {\n  node: Structure;\n  parent: string | null;\n  children: string[];\n}\n\ninterface LinkEntry {\n  toId: string;\n  relation: string;\n}\n\nexport const createRuntime = (): Runtime => {\n  const nodes = new Map<string, TreeNode>();\n  const links = new Map<string, LinkEntry[]>();\n  let counter = 0;\n  const nextRef = () => `e${++counter}`;\n\n  const findByStructure = (structure: Structure): TreeNode | undefined => {\n    for (const treeNode of nodes.values()) {\n      if (treeNode.node.name === structure.name) return treeNode;\n    }\n    return undefined;\n  };\n\n  const removeSubtree = (ref: string): void => {\n    const treeNode = nodes.get(ref);\n    if (!treeNode) return;\n    for (const childRef of [...treeNode.children]) {\n      removeSubtree(childRef);\n    }\n    // Clean up links from this node\n    links.delete(ref);\n    // Clean up links to this node\n    for (const [fromRef, fromLinks] of links.entries()) {\n      const filtered = fromLinks.filter((l) => l.toId !== ref);\n      if (filtered.length === 0) {\n        links.delete(fromRef);\n      } else {\n        links.set(fromRef, filtered);\n      }\n    }\n    nodes.delete(ref);\n  };\n\n  const projectRef = (ref: string): State => {\n    const treeNode = nodes.get(ref)!;\n    return { ...treeNode.node, children: [] };\n  };\n\n  const projectNode = (ref: string): State => {\n    const treeNode = nodes.get(ref)!;\n    const nodeLinks = links.get(ref);\n    return {\n      ...treeNode.node,\n      children: treeNode.children.map(projectNode),\n      ...(nodeLinks && nodeLinks.length > 0\n        ? {\n            links: nodeLinks.map((l) => ({\n              relation: l.relation,\n              target: projectRef(l.toId),\n            })),\n          }\n        : {}),\n    };\n  };\n\n  const createNode = (\n    parentRef: string | null,\n    type: Structure,\n    information?: string,\n    id?: string,\n    alias?: readonly string[]\n  ): Structure => {\n    const ref = nextRef();\n    const node: Structure = {\n      ref,\n      ...(id ? { id } : {}),\n      ...(alias && alias.length > 0 ? { alias } : {}),\n      name: type.name,\n      description: type.description,\n      parent: type.parent,\n      information,\n    };\n    const treeNode: TreeNode = { node, parent: parentRef, children: [] };\n    nodes.set(ref, treeNode);\n\n    if (parentRef) {\n      const parentTreeNode = nodes.get(parentRef);\n      if (!parentTreeNode) throw new Error(`Parent not found: ${parentRef}`);\n      parentTreeNode.children.push(ref);\n    }\n\n    return node;\n  };\n\n  return {\n    create(parent, type, information, id, alias) {\n      return createNode(parent?.ref ?? null, type, information, id, alias);\n    },\n\n    remove(node) {\n      if (!node.ref) return;\n      const treeNode = nodes.get(node.ref);\n      if (!treeNode) return;\n\n      if (treeNode.parent) {\n        const parentTreeNode = nodes.get(treeNode.parent);\n        if (parentTreeNode) {\n          parentTreeNode.children = parentTreeNode.children.filter((r) => r !== node.ref);\n        }\n      }\n\n      removeSubtree(node.ref);\n    },\n\n    transform(_source, target, information) {\n      const targetParent = target.parent;\n      if (!targetParent) {\n        throw new Error(`Cannot transform to root structure: ${target.name}`);\n      }\n\n      const parentTreeNode = findByStructure(targetParent);\n      if (!parentTreeNode) {\n        throw new Error(`No node found for structure: ${targetParent.name}`);\n      }\n\n      return createNode(parentTreeNode.node.ref!, target, information);\n    },\n\n    link(from, to, relationName, reverseName) {\n      if (!from.ref) throw new Error(\"Source node has no ref\");\n      if (!to.ref) throw new Error(\"Target node has no ref\");\n\n      // Forward: from → to\n      const fromLinks = links.get(from.ref) ?? [];\n      if (!fromLinks.some((l) => l.toId === to.ref && l.relation === relationName)) {\n        fromLinks.push({ toId: to.ref, relation: relationName });\n        links.set(from.ref, fromLinks);\n      }\n\n      // Reverse: to → from\n      const toLinks = links.get(to.ref) ?? [];\n      if (!toLinks.some((l) => l.toId === from.ref && l.relation === reverseName)) {\n        toLinks.push({ toId: from.ref, relation: reverseName });\n        links.set(to.ref, toLinks);\n      }\n    },\n\n    unlink(from, to, relationName, reverseName) {\n      if (!from.ref || !to.ref) return;\n\n      // Forward\n      const fromLinks = links.get(from.ref);\n      if (fromLinks) {\n        const filtered = fromLinks.filter(\n          (l) => !(l.toId === to.ref && l.relation === relationName)\n        );\n        if (filtered.length === 0) links.delete(from.ref);\n        else links.set(from.ref, filtered);\n      }\n\n      // Reverse\n      const toLinks = links.get(to.ref);\n      if (toLinks) {\n        const filtered = toLinks.filter(\n          (l) => !(l.toId === from.ref && l.relation === reverseName)\n        );\n        if (filtered.length === 0) links.delete(to.ref);\n        else links.set(to.ref, filtered);\n      }\n    },\n\n    project(node) {\n      if (!node.ref || !nodes.has(node.ref)) {\n        throw new Error(`Node not found: ${node.ref}`);\n      }\n      return projectNode(node.ref);\n    },\n\n    roots() {\n      const result: Structure[] = [];\n      for (const treeNode of nodes.values()) {\n        if (treeNode.parent === null) {\n          result.push(treeNode.node);\n        }\n      }\n      return result;\n    },\n  };\n};\n"],"mappings":"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","names":["structure","relation","link","structure"]}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@rolexjs/system",
+  "version": "0.1.0",
+  "description": "RoleX Systems Theory — six primitives + declarative process composition",
+  "keywords": [
+    "rolex",
+    "systems-theory",
+    "system",
+    "process",
+    "define"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Deepractice/RoleX.git",
+    "directory": "packages/system"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "biome lint .",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "publishConfig": {
+    "access": "public"
+  }
+}