@rolexjs/core 1.5.0-dev-20260309145703 → 1.5.0-dev-20260310020353

package/dist/index.d.ts

@@ -167,6 +167,30 @@ declare const dissolve: _rolexjs_system.Process;
 declare const abolish: _rolexjs_system.Process;
 declare const rehire: _rolexjs_system.Process;
 
+/**
+ * Projection — the single projection pipeline for RoleX.
+ *
+ * Pipeline: raw project → compact(depth) → enrich permissions.
+ *
+ * All projections go through this pipeline. No special cases.
+ * Control behavior via ProjectionContext.
+ *
+ * Rules:
+ *   - Root (depth 0): full
+ *   - Level 1 children: full (with content)
+ *   - Level 2+ grandchildren: compact (name/id/tag only, no subtree)
+ *   - All link targets: compact (name/id/tag only, no subtree)
+ */
+
+interface ProjectionContext {
+    /** Children expansion depth. Default 1: one level fully expanded, then compact. */
+    depth?: number;
+}
+interface Projection {
+    /** Project a node through the full pipeline: raw → compact → enrich. */
+    (node: Structure, ctx?: ProjectionContext): Promise<State>;
+}
+
 /**
  * Commands — platform-agnostic command implementations.
  *
@@ -188,6 +212,7 @@ interface CommandContext {
     past: Structure;
     resolve(id: string): Structure | Promise<Structure>;
     find(id: string): (Structure | null) | Promise<Structure | null>;
+    project: Projection;
     resourcex?: ResourceX;
     issuex?: IssueX;
     prototype?: PrototypeRepository;
@@ -414,6 +439,7 @@ interface RoleX {
 declare class RoleXService implements RoleX {
     private rt;
     private commands;
+    private project;
     private resourcex?;
     private issuex?;
     private repo;
@@ -438,10 +464,8 @@ declare class RoleXService implements RoleX {
     direct<T = unknown>(locator: string, args?: Record<string, unknown>, options?: {
         raw?: boolean;
     }): Promise<T>;
-    /** Find a node by id across the entire society tree. */
+    /** Find a node by id across the entire society tree (raw, no pipeline). */
     private find;
-    /** Find and project a node's full subtree by id. */
-    private projectById;
 }
 
 /**

package/dist/index.js

@@ -654,9 +654,9 @@ async function applyPrototype(data, repo, direct) {
 import { parse } from "@rolexjs/parser";
 import { structure as structure2 } from "@rolexjs/system";
 function createCommands(ctx) {
-  const { rt, society: society2, past: past2, resolve, resourcex, issuex } = ctx;
+  const { rt, society: society2, past: past2, resolve, project: project2, resourcex, issuex } = ctx;
   async function ok(node, process8) {
-    return { state: await rt.project(node), process: process8 };
+    return { state: await project2(node), process: process8 };
   }
   async function archive2(node, process8) {
     const target = structure2(node.name, node.description ?? "", past);
@@ -848,14 +848,14 @@ ${text}`;
       if (org) await rt.link(node, await resolve(org), "ownership", "project");
       return ok(node, "launch");
     },
-    async "project.scope"(project2, scope2, id) {
+    async "project.scope"(project3, scope2, id) {
       validateGherkin(scope2);
-      const node = await rt.create(await resolve(project2), scope, scope2, id);
+      const node = await rt.create(await resolve(project3), scope, scope2, id);
       return ok(node, "scope");
     },
-    async "project.milestone"(project2, milestone2, id) {
+    async "project.milestone"(project3, milestone2, id) {
       validateGherkin(milestone2);
-      const node = await rt.create(await resolve(project2), milestone, milestone2, id);
+      const node = await rt.create(await resolve(project3), milestone, milestone2, id);
       return ok(node, "milestone");
     },
     async "project.achieve"(milestone2) {
@@ -863,44 +863,44 @@ ${text}`;
       await rt.tag(node, "done");
       return ok(node, "achieve");
     },
-    async "project.enroll"(project2, individual2) {
-      const projNode = await resolve(project2);
+    async "project.enroll"(project3, individual2) {
+      const projNode = await resolve(project3);
       await rt.link(projNode, await resolve(individual2), "participation", "participate");
       return ok(projNode, "enroll");
     },
-    async "project.remove"(project2, individual2) {
-      const projNode = await resolve(project2);
+    async "project.remove"(project3, individual2) {
+      const projNode = await resolve(project3);
       await rt.unlink(projNode, await resolve(individual2), "participation", "participate");
       return ok(projNode, "remove");
     },
-    async "project.deliver"(project2, deliverable2, id) {
+    async "project.deliver"(project3, deliverable2, id) {
       validateGherkin(deliverable2);
-      const node = await rt.create(await resolve(project2), deliverable, deliverable2, id);
+      const node = await rt.create(await resolve(project3), deliverable, deliverable2, id);
       return ok(node, "deliver");
     },
-    async "project.wiki"(project2, wiki2, id) {
+    async "project.wiki"(project3, wiki2, id) {
       validateGherkin(wiki2);
-      const node = await rt.create(await resolve(project2), wiki, wiki2, id);
+      const node = await rt.create(await resolve(project3), wiki, wiki2, id);
       return ok(node, "wiki");
     },
-    async "project.archive"(project2) {
-      return archive2(await resolve(project2), "archive");
+    async "project.archive"(project3) {
+      return archive2(await resolve(project3), "archive");
     },
-    async "project.produce"(project2, content, id, alias) {
+    async "project.produce"(project3, content, id, alias) {
       validateGherkin(content);
-      const projNode = await resolve(project2);
+      const projNode = await resolve(project3);
       const node = await rt.create(society2, product, content, id, alias);
       await rt.link(projNode, node, "production", "produce");
       await rt.link(node, projNode, "origin", "produced-by");
       return ok(node, "produce");
     },
-    async "project.maintain"(project2, individual2) {
-      const projNode = await resolve(project2);
+    async "project.maintain"(project3, individual2) {
+      const projNode = await resolve(project3);
       await rt.link(projNode, await resolve(individual2), "maintain", "maintained-by");
       return ok(projNode, "maintain");
     },
-    async "project.unmaintain"(project2, individual2) {
-      const projNode = await resolve(project2);
+    async "project.unmaintain"(project3, individual2) {
+      const projNode = await resolve(project3);
       await rt.unlink(projNode, await resolve(individual2), "maintain", "maintained-by");
       return ok(projNode, "unmaintain");
     },
@@ -1019,7 +1019,7 @@ ${text}`;
     // ---- Census ----
     async "census.list"(type) {
       const target = type === "past" ? past2 : society2;
-      const state = await rt.project(target);
+      const state = await project2(target);
       const children = state.children ?? [];
       const filtered = type === "past" ? children : children.filter((c) => type ? c.name === type : c.name !== "past");
       return { state: { ...state, children: filtered }, process: "list" };
@@ -2832,41 +2832,36 @@ var sovereignPermissions = [
 ];
 
 // src/projection.ts
-var compactRelations = /* @__PURE__ */ new Set([
-  "crowned",
-  "belong",
-  "appointment",
-  "administer",
-  "maintained-by",
-  "own"
-]);
+var DEFAULT_DEPTH = 1;
+function createProjection(rt, permissions) {
+  return async (node, ctx) => {
+    const raw = await rt.project(node);
+    const compacted = compactState(raw, ctx?.depth ?? DEFAULT_DEPTH);
+    return permissions.enrich(compacted);
+  };
+}
 function compact(state) {
   const { children, links, ...node } = state;
   return node;
 }
-function compactState(state) {
-  const children = state.children?.map((c) => compactState(c));
-  const compactedLinks = state.links?.map(
-    (l) => compactRelations.has(l.relation) ? { ...l, target: compact(l.target) } : { ...l, target: compactLinkedTarget(l.target) }
-  );
+function compactState(state, depth) {
+  const children = depth > 0 ? state.children?.map((c) => compactState(c, depth - 1)) : state.children?.map((c) => compact(c));
+  const compactedLinks = state.links?.map((l) => ({
+    ...l,
+    target: compact(l.target)
+  }));
   return {
     ...state,
     ...children ? { children } : {},
     ...compactedLinks ? { links: compactedLinks } : {}
   };
 }
-function compactLinkedTarget(state) {
-  const children = state.children?.map((c) => compactLinkedTarget(c));
-  return {
-    ...state,
-    ...children ? { children } : {}
-  };
-}
 
 // src/rolex-service.ts
 var RoleXService = class _RoleXService {
   rt;
   commands;
+  project;
   resourcex;
   issuex;
   repo;
@@ -2901,11 +2896,10 @@ var RoleXService = class _RoleXService {
     return service;
   }
   async init() {
-    const originalProject = this.rt.project.bind(this.rt);
-    this.rt.project = async (node) => this.permissions.enrich(compactState(await originalProject(node)));
+    this.project = createProjection(this.rt, this.permissions);
     const roots = await this.rt.roots();
     this.society = roots.find((r) => r.name === "society") ?? await this.rt.create(null, society);
-    const societyState = await this.rt.project(this.society);
+    const societyState = await this.project(this.society);
     const existingPast = societyState.children?.find((c) => c.name === "past");
     this.past = existingPast ?? await this.rt.create(this.society, past);
     this.commands = createCommands({
@@ -2918,6 +2912,7 @@ var RoleXService = class _RoleXService {
         return node;
       },
       find: (id) => this.find(id),
+      project: this.project,
       resourcex: this.resourcex,
       issuex: this.issuex,
       prototype: this.repo.prototype,
@@ -2939,13 +2934,13 @@ var RoleXService = class _RoleXService {
     const cached = this.roles.get(individual2);
     if (cached) {
       const node2 = await this.findOrAutoBorn(individual2);
-      const state2 = await this.rt.project(node2);
+      const state2 = await this.project(node2);
       cached.hydrate(state2);
       await this.restoreSnapshot(cached);
       return cached;
     }
     const node = await this.findOrAutoBorn(individual2);
-    const state = await this.rt.project(node);
+    const state = await this.project(node);
     const role = new Role(individual2, {
       commands: this.commands,
       renderer: this.renderer,
@@ -2995,7 +2990,9 @@ var RoleXService = class _RoleXService {
   //  inspect — project any node's subtree
   // ================================================================
   async inspect(id) {
-    const state = await this.projectById(id);
+    const node = await this.find(id);
+    if (!node) throw new Error(`"${id}" not found.`);
+    const state = await this.project(node);
     const result = { state, process: "inspect" };
     return this.renderer.render("inspect", result);
   }
@@ -3004,7 +3001,7 @@ var RoleXService = class _RoleXService {
   // ================================================================
   async survey(type) {
     const target = type === "past" ? this.past : this.society;
-    const state = await this.rt.project(target);
+    const state = await this.project(target);
     const children = state.children ?? [];
     const filtered = type === "past" ? children : children.filter((c) => type ? c.name === type : c.name !== "past");
     const result = { state: { ...state, children: filtered }, process: "list" };
@@ -3040,16 +3037,10 @@ You may be guessing the command name. Load the relevant skill first with skill(l
   // ================================================================
   //  Internal helpers
   // ================================================================
-  /** Find a node by id across the entire society tree. */
+  /** Find a node by id across the entire society tree (raw, no pipeline). */
   async find(id) {
-    const state = await this.rt.project(this.society);
-    return findInState(state, id);
-  }
-  /** Find and project a node's full subtree by id. */
-  async projectById(id) {
-    const node = await this.find(id);
-    if (!node) throw new Error(`"${id}" not found.`);
-    return this.rt.project(node);
+    const raw = await this.rt.project(this.society);
+    return findInState(raw, id);
   }
 };
 function isCommandResult(value) {