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

package/index.js

@@ -1,3 +1,422 @@
+// 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, module, name, span, detail = [], label = (kind === "query" || kind === "slice") && module ? `${module}${name ? `.${name}` : " (default)"}` : name) {
+    const existing = this.#nodes.get(id);
+    if (existing)
+      return existing;
+    const node = {
+      id,
+      kind,
+      name,
+      label,
+      owner,
+      module,
+      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);
@@ -64,7 +483,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("/");
@@ -86,6 +505,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))
@@ -129,7 +552,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))
@@ -142,6 +565,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
@@ -178,6 +602,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
@@ -189,17 +614,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: [],
@@ -218,12 +680,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,
@@ -241,7 +709,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;
@@ -250,12 +719,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}`,
@@ -301,7 +770,7 @@ var sliceNames = (refName, suffix = "") => {
   };
 };
 var queryNames = (queryKey) => {
-  const Key = capitalize(queryKey);
+  const Key = capitalize2(queryKey);
   return {
     list: `list${Key}`,
     listIds: `listIds${Key}`,
@@ -321,7 +790,7 @@ var queryNames = (queryKey) => {
   };
 };
 var databaseStateNames = (refName) => {
-  const className = capitalize(refName);
+  const className = capitalize2(refName);
   return {
     model: refName,
     modelLoading: `${refName}Loading`,
@@ -337,7 +806,7 @@ var databaseStateNames = (refName) => {
   };
 };
 var modelNames = (refName) => {
-  const Model = capitalize(refName);
+  const Model = capitalize2(refName);
   return {
     ...databaseStateNames(refName),
     getModel: `get${Model}`,
@@ -381,7 +850,7 @@ var modelNames = (refName) => {
   };
 };
 var moduleNames = (refName) => {
-  const Model = capitalize(refName);
+  const Model = capitalize2(refName);
   return {
     service: `${refName}Service`,
     ServiceClass: `${Model}Service`,
@@ -394,7 +863,7 @@ var moduleNames = (refName) => {
   };
 };
 var formSetterNames = (className, key) => {
-  const classKeyName = capitalize(key);
+  const classKeyName = capitalize2(key);
   return {
     field: lowerlize(key),
     Field: classKeyName,
@@ -407,14 +876,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;
@@ -489,7 +958,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;
@@ -782,6 +1251,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;
@@ -1027,6 +1514,7 @@ ${dictionary.className}
   }
 }
 export {
+  AkanGraphDiff,
   AkanIndex,
   createAst,
   createFactReader,