@akanjs/language 3.1.2-rc.2 → 3.1.2-rc.4

package/index.cjs

@@ -39,6 +39,7 @@ var __export = (target, all) => {
 // pkgs/@akanjs/language/index.ts
 var exports_language = {};
 __export(exports_language, {
+  AkanGraphDiff: () => AkanGraphDiff,
   AkanIndex: () => AkanIndex,
   createAst: () => createAst,
   createFactReader: () => createFactReader,
@@ -46,6 +47,425 @@ __export(exports_language, {
 });
 module.exports = __toCommonJS(exports_language);
 
+// pkgs/@akanjs/language/akanGraphDiff.ts
+var edgeKeyOf = ({ from, to, kind, label }) => `${from}
+${to}
+${kind}
+${label ?? ""}`;
+var shapeOf = ({ type, array, optional, declaredIn }) => `${type ?? ""}${array ? "[]" : ""}${optional ? "?" : ""} ${declaredIn}`;
+var isEdited = (before, after) => before.digest !== undefined && after.digest !== undefined && before.digest !== after.digest;
+var byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+
+class AkanGraphDiff {
+  static between(base, head) {
+    const baseNodes = new Map(base.nodes.map((node) => [node.id, node]));
+    const headNodes = new Map(head.nodes.map((node) => [node.id, node]));
+    const marked = new Map;
+    for (const node of head.nodes) {
+      const before = baseNodes.get(node.id);
+      const next = before ? AkanGraphDiff.#compare(before, node) : AkanGraphDiff.#mark(node, "added");
+      if (next)
+        marked.set(node.id, next);
+    }
+    for (const node of base.nodes)
+      if (!headNodes.has(node.id))
+        marked.set(node.id, AkanGraphDiff.#mark(node, "removed"));
+    const baseKeys = new Set(base.edges.map(edgeKeyOf));
+    const headKeys = new Set(head.edges.map(edgeKeyOf));
+    const edges = [
+      ...head.edges.flatMap((edge) => !baseKeys.has(edgeKeyOf(edge)) ? [{ ...edge, change: "added" }] : marked.has(edge.from) || marked.has(edge.to) ? [edge] : []),
+      ...base.edges.filter((edge) => !headKeys.has(edgeKeyOf(edge))).map((edge) => ({ ...edge, change: "removed" }))
+    ];
+    const context = edges.flatMap((edge) => [edge.from, edge.to]).filter((id) => !marked.has(id)).flatMap((id) => {
+      const node = headNodes.get(id) ?? baseNodes.get(id);
+      return node ? [node] : [];
+    });
+    const nodes = [...new Map([...marked.values(), ...context].map((node) => [node.id, node])).values()].map(AkanGraphDiff.#withoutDigest).sort(byId);
+    const summary = { added: 0, removed: 0, changed: 0 };
+    for (const node of marked.values())
+      if (node.change)
+        summary[node.change] += 1;
+    return { version: 1, nodes, edges, summary };
+  }
+  static #mark(node, change) {
+    return node.fields ? { ...node, change, fields: node.fields.map((field) => ({ ...field, change })) } : { ...node, change };
+  }
+  static #compare(before, after) {
+    const fields = AkanGraphDiff.#fieldsBetween(before.fields, after.fields);
+    const isChanged = isEdited(before, after) || before.label !== after.label || before.detail.join(`
+`) !== after.detail.join(`
+`) || (before.values ?? []).join(`
+`) !== (after.values ?? []).join(`
+`) || !!fields?.some((field) => field.change);
+    if (!isChanged)
+      return null;
+    return fields ? { ...after, change: "changed", fields } : { ...after, change: "changed" };
+  }
+  static #fieldsBetween(before, after) {
+    if (!before && !after)
+      return;
+    const previous = new Map((before ?? []).map((field) => [field.name, field]));
+    const names = new Set((after ?? []).map((field) => field.name));
+    return [
+      ...(after ?? []).map((field) => {
+        const old = previous.get(field.name);
+        if (!old)
+          return { ...field, change: "added" };
+        return shapeOf(old) === shapeOf(field) && !isEdited(old, field) ? field : { ...field, change: "changed" };
+      }),
+      ...(before ?? []).filter((field) => !names.has(field.name)).map((field) => ({ ...field, change: "removed" }))
+    ];
+  }
+  static #withoutDigest({ digest: _digest, ...node }) {
+    return node.fields ? { ...node, fields: node.fields.map(({ digest: _field, ...field }) => field) } : node;
+  }
+}
+// pkgs/@akanjs/language/akanGraph.ts
+var capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+var memberSourcePattern = /\.(signal|service|store)\.ts$/;
+var skippedPattern = /(?:\.(?:constant|document|dictionary|test|spec)\.tsx?|\/lib\/(?:cnst|db|dict|sig|srv|st|useClient|useServer)\.ts|\/index\.tsx?|^(?:apps|libs)\/[^/]+\/(?:client|server)\.ts)$/;
+var scalarPattern = /\/lib\/__scalar\/([^/]+)\/[^/]+\.constant\.ts$/;
+var moduleDirPattern = /\/lib\/([^/]+)\//;
+var typeKinds = new Set(["model", "scalar", "enum"]);
+var clientRoots = new Set(["fetch", "st", "sig"]);
+
+class GraphBuilder {
+  #source;
+  #nodes = new Map;
+  #edges = new Map;
+  #contexts = new Map;
+  #members = new Map;
+  constructor(source) {
+    this.#source = source;
+  }
+  build() {
+    const { facts } = this.#source;
+    const constantsByOwner = new Map;
+    for (const file of facts)
+      constantsByOwner.set(file.owner, [...constantsByOwner.get(file.owner) ?? [], ...file.constants]);
+    const scopeOf = (owner) => [
+      ...constantsByOwner.get(owner) ?? [],
+      ...[...constantsByOwner].filter(([key]) => key !== owner && key?.startsWith("libs/")).flatMap(([, list]) => list)
+    ];
+    const typed = [];
+    for (const file of facts) {
+      const { owner } = file;
+      const scalar = this.#source.relative(file.fileName).match(scalarPattern)?.[1];
+      const scalarClass = scalar ? file.constants.find((constant) => constant.name === capitalize(scalar)) : undefined;
+      if (scalar && scalarClass) {
+        const id = this.#key("scalar", owner, scalar);
+        const node = this.#addNode(id, "scalar", owner, scalar, scalarClass.name, scalarClass.span);
+        node.fields = this.#fieldsOf(scalarClass, scopeOf(owner));
+        typed.push(node);
+      }
+      for (const item of file.enums) {
+        const id = this.#key("enum", owner, item.name);
+        this.#addNode(id, "enum", owner, this.#moduleDirOf(file.fileName), item.name, item.span).values = item.values;
+      }
+    }
+    for (const file of facts) {
+      const { owner } = file;
+      for (const service of file.services) {
+        const refName = service.model;
+        if (!refName)
+          continue;
+        const modelId = this.#key("model", owner, refName);
+        const modelClass = constantsByOwner.get(owner)?.find((constant) => constant.name === capitalize(refName));
+        if (modelClass && !this.#nodes.has(modelId)) {
+          const node = this.#addNode(modelId, "model", owner, refName, modelClass.name, modelClass.span);
+          node.fields = this.#fieldsOf(modelClass, scopeOf(owner));
+          typed.push(node);
+        }
+        for (const method of service.methods)
+          this.#addMember("method", owner, refName, method, `${service.name}.${method.name}`, file.fileName);
+      }
+      for (const filter of file.filters) {
+        if (!filter.name.endsWith("Filter"))
+          continue;
+        const refName = lowerFirst(filter.name.slice(0, -"Filter".length));
+        this.#addNode(this.#key("query", owner, refName), "query", owner, refName, "", filter.span);
+        for (const query of filter.queries)
+          this.#digest(this.#addNode(this.#key("query", owner, refName, query.name), "query", owner, refName, query.name, query.span), this.#source.readText(file.fileName), query.extent);
+      }
+      for (const slice of file.slices) {
+        const refName = slice.model;
+        if (!refName)
+          continue;
+        const fallback = this.#addNode(this.#key("slice", owner, refName), "slice", owner, refName, "", slice.span, slice.guards);
+        for (const guard of slice.guards)
+          this.#guard(fallback, guard);
+        for (const key of slice.keys) {
+          const detail = [...key.guards, ...key.live ? ["live"] : []];
+          const node = this.#addMember("slice", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+          for (const guard of key.guards)
+            this.#guard(node, guard);
+        }
+      }
+      for (const endpoint of file.endpoints) {
+        const refName = endpoint.model;
+        if (!refName)
+          continue;
+        for (const key of endpoint.keys) {
+          const detail = [...key.verb ? [key.verb] : [], ...key.guards];
+          const node = this.#addMember("endpoint", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+          for (const guard of key.guards)
+            this.#guard(node, guard);
+        }
+      }
+      for (const store of file.stores)
+        if (store.model)
+          for (const action of store.actions)
+            this.#addMember("action", owner, store.model, action, `${store.name}.${action.name}`, file.fileName);
+    }
+    const types = new Map;
+    for (const node of this.#nodes.values())
+      if (typeKinds.has(node.kind))
+        types.set(node.label, [...types.get(node.label) ?? [], node]);
+    for (const node of typed)
+      for (const field of node.fields ?? []) {
+        const candidates = (field.type ? types.get(field.type) ?? [] : []).filter((type) => this.#visible(type.owner, node.owner));
+        field.ref = (candidates.find((type) => type.owner === node.owner) ?? candidates[0])?.id ?? null;
+        if (field.ref)
+          this.#addEdge(node.id, field.ref, "field", `${field.name}${field.array ? "[]" : ""}`, field.at);
+      }
+    for (const [fileName, words] of this.#source.files)
+      this.#walk(fileName, words);
+    return {
+      version: 1,
+      nodes: [...this.#nodes.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+      edges: [...this.#edges.values()]
+    };
+  }
+  #key(kind, owner, scope, name = "") {
+    return `${kind}:${owner ?? ""}:${scope}${name ? `.${name}` : ""}`;
+  }
+  #location(span) {
+    return { file: this.#source.relative(span.fileName), line: span.line + 1, column: span.character + 1 };
+  }
+  #addNode(id, kind, owner, module2, name, span, detail = [], label = (kind === "query" || kind === "slice") && module2 ? `${module2}${name ? `.${name}` : " (default)"}` : name) {
+    const existing = this.#nodes.get(id);
+    if (existing)
+      return existing;
+    const node = {
+      id,
+      kind,
+      name,
+      label,
+      owner,
+      module: module2,
+      detail,
+      at: span ? this.#location(span) : null
+    };
+    this.#nodes.set(id, node);
+    return node;
+  }
+  #addMember(kind, owner, refName, member, label, fileName, detail = []) {
+    const id = this.#key(kind, owner, refName, member.name);
+    const node = this.#addNode(id, kind, owner, refName, member.name, member.span, detail, label);
+    this.#digest(node, this.#source.readText(fileName), member.extent);
+    this.#contexts.set(fileName, [
+      ...this.#contexts.get(fileName) ?? [],
+      { id, kind, owner, module: refName, extent: member.extent }
+    ]);
+    const byName = `${kind}:${member.name}`;
+    this.#members.set(byName, [...this.#members.get(byName) ?? [], node]);
+    return node;
+  }
+  #hashOf(text, { start, end }) {
+    if (!this.#source.digests || text === undefined)
+      return null;
+    let hash = 2166136261;
+    for (let idx = start;idx < end; idx++) {
+      const code = text.charCodeAt(idx);
+      if (code !== 13)
+        hash = Math.imul(hash ^ code, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
+  #digest(node, text, extent) {
+    const digest = node.digest ? null : this.#hashOf(text, extent);
+    if (digest)
+      node.digest = digest;
+  }
+  #addEdge(from, to, kind, label, at) {
+    if (from === to)
+      return;
+    const key = `${from}
+${to}
+${kind}
+${label ?? ""}`;
+    const existing = this.#edges.get(key);
+    if (existing)
+      existing.count += 1;
+    else
+      this.#edges.set(key, { from, to, kind, label, count: 1, at });
+  }
+  #guard(node, guard) {
+    const [role, name] = guard.includes(" ") ? guard.split(" ") : [null, guard];
+    if (!name || name === "?")
+      return;
+    const id = `guard:${name}`;
+    if (!this.#nodes.has(id))
+      this.#nodes.set(id, { id, kind: "guard", name, label: name, owner: null, module: null, detail: [], at: null });
+    this.#addEdge(node.id, id, "guard", role, node.at);
+  }
+  #moduleDirOf(fileName) {
+    const dir = this.#source.relative(fileName).match(moduleDirPattern)?.[1] ?? null;
+    return dir?.startsWith("_") && !dir.startsWith("__") ? dir.slice(1) : dir;
+  }
+  #fieldsOf(constant, scope) {
+    const fields = new Map;
+    const seen = new Set;
+    const visit = (current) => {
+      if (seen.has(current))
+        return;
+      seen.add(current);
+      for (const parent of current.parents) {
+        const parentClass = scope.find((other) => other.name === parent && other.span.fileName === current.span.fileName) ?? scope.find((other) => other.name === parent);
+        if (parentClass)
+          visit(parentClass);
+      }
+      for (const field of current.fields) {
+        if (fields.has(field.name))
+          continue;
+        const digest = this.#hashOf(this.#source.readText(field.span.fileName), field.extent);
+        fields.set(field.name, {
+          name: field.name,
+          type: field.type,
+          array: field.array,
+          optional: field.optional,
+          ref: null,
+          declaredIn: current.name,
+          at: this.#location(field.span),
+          ...digest ? { digest } : {}
+        });
+      }
+    };
+    visit(constant);
+    return [...fields.values()];
+  }
+  #visible(target, from) {
+    return !from || !target || target === from || target.startsWith("libs/");
+  }
+  #targetNodeOf({ family, owner, refName, sourceKey }) {
+    const isDefault = /^[A-Z]/.test(sourceKey);
+    const id = family === "slice" || family === "query" ? this.#key(family, owner, refName, isDefault ? "" : sourceKey) : family === "model" || family === "formSetter" ? this.#key("model", owner, refName) : family === "endpoint" ? this.#key("endpoint", owner, refName, sourceKey) : null;
+    return id && this.#nodes.has(id) ? id : null;
+  }
+  #membersNamed(kind, name, owner, refName) {
+    const nodes = (this.#members.get(`${kind}:${name}`) ?? []).filter((node) => (!refName || node.module === refName) && this.#visible(node.owner, owner));
+    const own = nodes.filter((node) => node.owner === owner);
+    return (own.length ? own : nodes).map((node) => node.id);
+  }
+  #plainTargetsOf(chain, name, context, owner) {
+    const [head, second] = chain ?? [];
+    if (chain?.length === 1 && head === "fetch")
+      return this.#membersNamed("endpoint", name, owner);
+    if (chain?.length === 2 && head === "st" && second === "do")
+      return this.#membersNamed("action", name, owner);
+    if (chain?.length === 1 && head === "this" && (context.kind === "method" || context.kind === "action"))
+      return this.#membersNamed(context.kind, name, context.owner, context.module).filter((id) => id.startsWith(`${context.kind}:${context.owner ?? ""}:`));
+    if (chain?.length === 2 && head === "this" && second && /.Service$/.test(second))
+      return this.#membersNamed("method", name, owner, second.slice(0, -"Service".length));
+    return [];
+  }
+  #walk(fileName, words) {
+    const relative = this.#source.relative(fileName);
+    const contexts = this.#contexts.get(fileName);
+    const isComponentFile = !memberSourcePattern.test(fileName) && !skippedPattern.test(relative) && (words.includes(`
+fetch
+`) || words.includes(`
+st
+`));
+    if (!contexts && !isComponentFile)
+      return;
+    const text = this.#source.readText(fileName);
+    if (text === undefined)
+      return;
+    const { ts } = this.#source;
+    const owner = this.#source.ownerOf(fileName);
+    const source = this.#source.parse(fileName, text);
+    const visit = (node) => {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+        const start = node.name.getStart(source);
+        const chain = this.#chainOf(node.expression);
+        const context = contexts ? contexts.find(({ extent }) => extent.start <= start && start < extent.end) : chain && clientRoots.has(chain[0]) ? this.#componentOf(source, node) : undefined;
+        if (context)
+          this.#link(fileName, source, node.name, chain, context, owner);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+  #link(fileName, source, identifier, chain, context, owner) {
+    const resolved = this.#source.resolve(fileName, identifier).map((target) => this.#targetNodeOf(target)).filter((id) => id !== null);
+    const targets = resolved.length ? resolved : this.#plainTargetsOf(chain, identifier.text, context, owner);
+    if (!targets.length)
+      return;
+    if (context.pending && !this.#nodes.has(context.id)) {
+      this.#nodes.set(context.id, context.pending);
+      this.#digest(context.pending, source.text, context.extent);
+    }
+    const own = targets.filter((id) => this.#nodes.get(id)?.owner === owner);
+    const kind = context.kind === "component" ? "uses" : chain?.[0] === "fetch" ? "fetches" : "calls";
+    const position = source.getLineAndCharacterOfPosition(identifier.getStart(source));
+    const at = { file: this.#source.relative(fileName), line: position.line + 1, column: position.character + 1 };
+    for (const target of new Set(own.length ? own : targets))
+      this.#addEdge(context.id, target, kind, identifier.text, at);
+  }
+  #chainOf(expression) {
+    const { ts } = this.#source;
+    if (ts.isNonNullExpression(expression) || ts.isParenthesizedExpression(expression))
+      return this.#chainOf(expression.expression);
+    if (ts.isIdentifier(expression))
+      return [expression.text];
+    if (expression.kind === ts.SyntaxKind.ThisKeyword)
+      return ["this"];
+    if (!ts.isPropertyAccessExpression(expression))
+      return null;
+    const head = this.#chainOf(expression.expression);
+    return head ? [...head, expression.name.text] : null;
+  }
+  #componentOf(source, node) {
+    const { ts } = this.#source;
+    let top = node;
+    while (top.parent && !ts.isSourceFile(top.parent))
+      top = top.parent;
+    const declared = ts.isVariableStatement(top) ? top.declarationList.declarations[0]?.name : ts.isFunctionDeclaration(top) || ts.isClassDeclaration(top) ? top.name : undefined;
+    const isDefaultExport = ts.canHaveModifiers(top) && !!ts.getModifiers(top)?.some(({ kind }) => kind === ts.SyntaxKind.DefaultKeyword);
+    const name = declared && ts.isIdentifier(declared) && !isDefaultExport ? declared.text : "default";
+    const relative = this.#source.relative(source.fileName);
+    const owner = this.#source.ownerOf(source.fileName);
+    const id = `component:${relative}#${name}`;
+    const context = {
+      id,
+      kind: "component",
+      owner,
+      module: null,
+      extent: { start: top.getStart(source), end: top.getEnd() }
+    };
+    if (this.#nodes.has(id))
+      return context;
+    const pagePrefix = owner ? `${owner}/page/` : null;
+    const route = pagePrefix && relative.startsWith(pagePrefix) ? relative.slice(pagePrefix.length).replace(/\.tsx?$/, "") : null;
+    const base = relative.slice(relative.lastIndexOf("/") + 1).replace(/\.tsx?$/, "");
+    const label = route ? `${route}${name === "default" ? "" : `#${name}`}` : name === "default" ? base : `${base}.${name}`;
+    const position = source.getLineAndCharacterOfPosition((declared ?? top).getStart(source));
+    context.pending = {
+      id,
+      kind: "component",
+      name,
+      label,
+      owner,
+      module: this.#moduleDirOf(source.fileName),
+      detail: route ? ["page"] : [],
+      at: { file: relative, line: position.line + 1, column: position.character + 1 }
+    };
+    return context;
+  }
+}
+
 // pkgs/@akanjs/language/ast.ts
 var createAst = (ts) => {
   const sourceFileFor = (fileName, content, scriptKind = ts.ScriptKind.TS) => ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, scriptKind);
@@ -112,7 +532,7 @@ var createAst = (ts) => {
 };
 
 // pkgs/@akanjs/language/moduleFacts.ts
-var moduleCallees = new Set(["via", "from", "into", "serve", "slice", "endpoint", "store"]);
+var moduleCallees = new Set(["via", "from", "into", "serve", "slice", "endpoint", "store", "enumOf"]);
 var argMethods = new Set(["param", "body", "search", "room", "msg"]);
 var ownerOf = (relativePath) => {
   const [root, name] = relativePath.split("/");
@@ -134,6 +554,10 @@ var createFactReader = (ts, ast) => {
       endCharacter: tail.character
     };
   };
+  const extentOf = (source, node) => ({
+    start: node.getStart(source),
+    end: node.getEnd()
+  });
   const unwrap = (expression) => {
     let current = expression;
     while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current))
@@ -177,7 +601,7 @@ var createFactReader = (ts, ast) => {
   const objectKeys = (source, object) => (object?.properties ?? []).flatMap((property) => {
     const name = ast.propertyName(property);
     const node = keyName(property);
-    return name && node ? [{ name, span: spanOf(source, node) }] : [];
+    return name && node ? [{ name, span: spanOf(source, node), extent: extentOf(source, property) }] : [];
   });
   const sliceKeysOf = (source, builder) => (returnedObject(builder)?.properties ?? []).flatMap((property) => {
     if (!ts.isPropertyAssignment(property))
@@ -190,6 +614,7 @@ var createFactReader = (ts, ast) => {
       {
         name,
         span: spanOf(source, property.name),
+        extent: extentOf(source, property),
         guards: root ? guardsIn(optionObjectOf(root)) : [],
         live: methods.includes("live"),
         argCount: methods.filter((method) => argMethods.has(method)).length
@@ -226,6 +651,7 @@ var createFactReader = (ts, ast) => {
         {
           name,
           span: spanOf(source, property.name),
+          extent: extentOf(source, property),
           verb: root ? verbOf(root.expression) : null,
           guards: root ? guardsIn(optionObjectOf(root)) : [],
           argCount: methods.filter((method) => argMethods.has(method)).length
@@ -237,17 +663,54 @@ var createFactReader = (ts, ast) => {
     const query = returnedObject(builder)?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "query")?.initializer;
     return query && ts.isObjectLiteralExpression(query) ? objectKeys(source, query) : [];
   };
+  const typeOf = (expression) => {
+    const value = expression && unwrap(expression);
+    if (value && ts.isArrayLiteralExpression(value))
+      return { type: typeOf(value.elements[0]).type, array: true };
+    return { type: value ? ast.expressionName(value) : null, array: false };
+  };
+  const fieldsOf = (source, object) => (object?.properties ?? []).flatMap((property) => {
+    const name = ast.propertyName(property);
+    const node = keyName(property);
+    if (!name || !node)
+      return [];
+    const { root, methods } = ts.isPropertyAssignment(property) ? chainOf(property.initializer) : { root: null, methods: [] };
+    return [
+      {
+        name,
+        span: spanOf(source, node),
+        extent: extentOf(source, property),
+        ...typeOf(root?.arguments[0]),
+        optional: methods.includes("optional")
+      }
+    ];
+  });
   const constantOf = (source, name, call) => {
     const parents = call.arguments.map(unwrap).filter((arg) => ts.isIdentifier(arg) || ts.isPropertyAccessExpression(arg)).map((arg) => ast.expressionName(arg)).filter((parent) => parent !== null);
-    const fields = call.arguments.flatMap((arg) => objectKeys(source, ast.firstObjectReturnedByArrow(arg)));
+    const fields = call.arguments.flatMap((arg) => fieldsOf(source, ast.firstObjectReturnedByArrow(arg)));
     return { ...name, parents, fields };
   };
+  const enumValuesOf = (call) => {
+    const list = call.arguments[1] && unwrap(call.arguments[1]);
+    if (!list || !ts.isArrayLiteralExpression(list))
+      return [];
+    return list.elements.flatMap((element) => ts.isStringLiteralLike(element) ? [element.text] : []);
+  };
+  const methodsOf = (source, statement) => statement.members.flatMap((member) => {
+    if (!ts.isMethodDeclaration(member) || !member.body)
+      return [];
+    const name = ast.nodeName(member.name);
+    if (!name || ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))
+      return [];
+    return [{ name, span: spanOf(source, member.name), extent: extentOf(source, member) }];
+  });
   const lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
   const read = (source, owner) => {
     const facts = {
       fileName: source.fileName,
       owner,
       constants: [],
+      enums: [],
       filters: [],
       models: [],
       services: [],
@@ -266,12 +729,18 @@ var createFactReader = (ts, ast) => {
       const builder = builderOf(call);
       if (callee === "via")
         facts.constants.push(constantOf(source, name, call));
+      else if (callee === "enumOf")
+        facts.enums.push({ ...name, values: enumValuesOf(call) });
       else if (callee === "from")
         facts.filters.push({ ...name, queries: filterQueriesOf(source, builder) });
       else if (callee === "into")
         facts.models.push({ ...name, model: name.name.endsWith("Model") ? lowerFirst(name.name.slice(0, -5)) : null });
       else if (callee === "serve")
-        facts.services.push({ ...name, model: moduleRefOf(call.arguments[0], "db") });
+        facts.services.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "db"),
+          methods: methodsOf(source, statement)
+        });
       else if (callee === "slice")
         facts.slices.push({
           ...name,
@@ -289,7 +758,8 @@ var createFactReader = (ts, ast) => {
         facts.stores.push({
           ...name,
           model: moduleRefOf(call.arguments[0], "sig"),
-          stateKeys: objectKeys(source, returnedObject(builder))
+          stateKeys: objectKeys(source, returnedObject(builder)),
+          actions: methodsOf(source, statement)
         });
     }
     return facts;
@@ -298,12 +768,12 @@ var createFactReader = (ts, ast) => {
 };
 
 // pkgs/akanjs/common/capitalize.ts
-var capitalize = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var capitalize2 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 var lowerlize = (str) => str.charAt(0).toLowerCase() + str.slice(1);
 
 // pkgs/akanjs/common/akanNames.ts
 var sliceNames = (refName, suffix = "") => {
-  const [Model, Suffix] = [capitalize(refName), capitalize(suffix)];
+  const [Model, Suffix] = [capitalize2(refName), capitalize2(suffix)];
   const live = `${refName}Live${Suffix}`;
   return {
     slice: `${refName}${Suffix}`,
@@ -349,7 +819,7 @@ var sliceNames = (refName, suffix = "") => {
   };
 };
 var queryNames = (queryKey) => {
-  const Key = capitalize(queryKey);
+  const Key = capitalize2(queryKey);
   return {
     list: `list${Key}`,
     listIds: `listIds${Key}`,
@@ -369,7 +839,7 @@ var queryNames = (queryKey) => {
   };
 };
 var databaseStateNames = (refName) => {
-  const className = capitalize(refName);
+  const className = capitalize2(refName);
   return {
     model: refName,
     modelLoading: `${refName}Loading`,
@@ -385,7 +855,7 @@ var databaseStateNames = (refName) => {
   };
 };
 var modelNames = (refName) => {
-  const Model = capitalize(refName);
+  const Model = capitalize2(refName);
   return {
     ...databaseStateNames(refName),
     getModel: `get${Model}`,
@@ -429,7 +899,7 @@ var modelNames = (refName) => {
   };
 };
 var moduleNames = (refName) => {
-  const Model = capitalize(refName);
+  const Model = capitalize2(refName);
   return {
     service: `${refName}Service`,
     ServiceClass: `${Model}Service`,
@@ -442,7 +912,7 @@ var moduleNames = (refName) => {
   };
 };
 var formSetterNames = (className, key) => {
-  const classKeyName = capitalize(key);
+  const classKeyName = capitalize2(key);
   return {
     field: lowerlize(key),
     Field: classKeyName,
@@ -455,14 +925,14 @@ var formSetterNames = (className, key) => {
     postSetField: `_postSet${classKeyName}`
   };
 };
-var stateSetterName = (key) => `set${capitalize(key)}`;
+var stateSetterName = (key) => `set${capitalize2(key)}`;
 var endpointNames = (key) => {
-  const Key = capitalize(key);
+  const Key = capitalize2(key);
   return { subscribe: `subscribe${Key}`, listen: `listen${Key}` };
 };
 
 // pkgs/@akanjs/language/nameTable.ts
-var capitalize2 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+var capitalize3 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
 
 class NameTable {
   #byName = new Map;
@@ -537,7 +1007,7 @@ class NameTable {
   }
   #addGroup(group, constants) {
     const { owner, refName } = group;
-    const Model = capitalize2(refName);
+    const Model = capitalize3(refName);
     const base = { owner, refName };
     const modelClass = group.constants.find((constant) => constant.name === Model);
     const facts = group.facts;
@@ -830,6 +1300,24 @@ ${[...new Set(text.match(wordPattern))].join(`
   referencesAt(givenName, offset, readText) {
     return this.#usesOf(this.#sourceEntriesAt(pathOf(givenName), offset), readText).map((use) => use.span);
   }
+  graph(readText, { digests = false } = {}) {
+    return new GraphBuilder({
+      digests,
+      ts: this.#ts,
+      facts: [...this.#facts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, facts]) => facts),
+      files: [...this.#fileWords].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+      readText,
+      parse: (fileName, text) => this.#parse(fileName, text),
+      resolve: (fileName, identifier) => {
+        if (!this.#nameTable().lookup(identifier.text).length)
+          return [];
+        const site = this.#siteOf(identifier);
+        return site ? this.#resolve(fileName, site) : [];
+      },
+      relative: (fileName) => this.#relative(fileName),
+      ownerOf: (fileName) => this.#ownerOf(fileName)
+    }).build();
+  }
   renameTargetAt(givenName, offset) {
     const source = this.#sourceEntriesAt(pathOf(givenName), offset).find((entry) => entry.renamed);
     return source ? { family: source.family, sourceKey: source.sourceKey, span: source.span } : null;

package/index.d.ts

@@ -1,4 +1,6 @@
+export type { AkanChangedFile, AkanChangeMap, AkanGraph, AkanGraphChange, AkanGraphEdge, AkanGraphEdgeKind, AkanGraphField, AkanGraphLocation, AkanGraphNode, AkanGraphNodeKind, } from "akanjs/common/akanGraph.ts";
+export { type AkanGraphChanges, AkanGraphDiff } from "./akanGraphDiff";
 export { type AkanHover, AkanIndex, type AkanIndexOptions, type AkanRenameEdit, type AkanSourceKey } from "./akanIndex";
 export { type AkanAst, createAst, type Ts } from "./ast";
-export { type AkanFactReader, type AkanSpan, type ConstantClassFact, createFactReader, type EndpointClassFact, type EndpointKeyFact, type FileFacts, type FilterClassFact, type ModuleClassFact, type NamedFact, ownerOf, type SliceClassFact, type SliceKeyFact, type StoreClassFact, } from "./moduleFacts";
+export { type AkanFactReader, type AkanSpan, type ConstantClassFact, createFactReader, type EndpointClassFact, type EndpointKeyFact, type EnumClassFact, type Extent, type FieldFact, type FileFacts, type FilterClassFact, type MemberFact, type ModuleClassFact, type NamedFact, ownerOf, type ServiceClassFact, type SliceClassFact, type SliceKeyFact, type StoreClassFact, } from "./moduleFacts";
 export type { AkanFamily, AkanTarget } from "./nameTable";