bc-atlas 0.11.0 → 0.13.0

package/.bca.example.json

@@ -50,8 +50,6 @@
   },
   "details": false,
   "noExternal": false,
-  "layout": "elk",
-  "theme": 0,
   "sourceUrl": "https://github.com/example/repo/blob/{ref}/{file}#L{line}",
   "sourceRef": "main",
   "sourcePathPrefix": "apps/Sales",

package/CHANGELOG.md

@@ -4,6 +4,127 @@ All notable changes to BC Atlas will be documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project
 follows [Semantic Versioning](https://semver.org/).
 
+## 0.13.0 - 2026-11-04
+
+### Added
+
+- `bca check` flags interface methods whose enum implementation can complete
+  silently: an empty body, a constant `true` return, or a conditional path
+  with no error (`contract-fallback`). Without configuration these are
+  informational; `check.contractExpectations` names the interface methods
+  that must not fall back silently and turns them into warnings. Unresolved
+  delegation, symbol-only bodies, and ambiguous signatures stay unknown
+  instead of counting as safe. See [Configuration](./docs/configuration.md).
+- `check.contexts` summarizes the responsibilities of selected objects:
+  reads, persistent and temporary writes, commits, resolved calls, and global
+  state, direct and up to `maxCallDepth` calls away. `roles`,
+  `lazyReadMethods`, and `forbid` turn them into policy warnings; bounded or
+  unresolved evidence is reported with its limitations.
+- Architecture component selectors accept `file:` (one file, globs allowed),
+  more specific than a namespace, folder, or ID range.
+- Enum bindings keep `DefaultImplementation` and `UnknownValueImplementation`
+  as evidence, and calls keep their arguments.
+
+### Changed
+
+- Health and architecture findings carry their basis (`configured-policy`,
+  `observed-code-fact`, or `heuristic` for a proposed architecture), a
+  primary location, all evidence, and limitations. Text and Markdown show up
+  to five locations; JSON and SARIF keep everything.
+- Component cycles are explained by a representative path with the
+  dependencies behind each hop, and, where several providers call back into
+  the same orchestrator procedure, suggest extracting a shared service.
+- `bca refactor move` defaults to the common parent folder of a component's
+  objects instead of the folder most of them are in.
+- Records of pages and tables with `SourceTableTemporary` count as temporary,
+  and record parameters of unknown temporariness are no longer reported as
+  persistent writes.
+- Release: one *Release* workflow publishes the npm package and the VS Code
+  extension under one version, after testing both, and attaches the `.vsix`
+  to the GitHub release.
+
+### Fixed
+
+- Health reports no longer print `architecture origin: undefined`, and
+  Markdown evidence cells with `|` no longer break the table.
+
+## 0.12.0 - 2026-10-29
+
+### Added
+
+- `bca export --view knowledge-graph` writes the project as RDF with the BC
+  Atlas OWL ontology, for triple stores, graph databases, and ontology
+  editors: Turtle (`.ttl`), RDF/XML (`.rdf`, `.owl`), N-Triples (`.nt`), or
+  JSON-LD (`.jsonld`). Apps, namespaces, objects with fields, keys, and
+  procedures, every relation as a property (`bca:calls`, `bca:writes`, ...)
+  and as a `bca:Relation` with its evidence, objects outside the workspace,
+  architecture components, and violations. Stable IRIs (`urn:bc-atlas:...`, or
+  `--base-iri`), and `SOURCE_DATE_EPOCH` for reproducible files. See
+  [Knowledge graph](./docs/knowledge-graph.md).
+- Knowledge graph: `--no-evidence` writes only the direct relation triples,
+  without a `bca:Relation` per relation; the Base Application's graph drops
+  from 4.4 million triples (270 MB of Turtle) to 1.1 million (78 MB).
+- The BC Atlas ontology is published at its IRI,
+  `https://schulzoli.github.io/BC-Atlas/ontology`: a page with every class
+  and property (each term's IRI opens its row), and the ontology as
+  `ontology.ttl`, `.owl`, `.rdf`, `.nt`, and `.jsonld` next to it, for
+  Protégé and other tools that resolve IRIs. Exports point to it with
+  `rdfs:seeAlso`.
+
+### Changed
+
+- App and VS Code panel: Diagrams and Docs work the same way. On the left, a
+  filterable list (the views; the overview, use cases, and scenarios) with
+  the settings below it; on the right, the selected item with its tools.
+  `J`/`K` and **‹**/**›** step through the list, **Enter** in the filter opens
+  the first match, and the address keeps the selection and the settings.
+- Diagrams: views are listed with what they show, choices apply at once,
+  **PNG** saves the diagram besides **SVG** and **D2**, and a click on an
+  object opens its page.
+- Diagrams are drawn by BC Atlas itself instead of D2: an ELK layered layout
+  with groups, right-angled routes (curves beyond 120 relations), labels, and
+  a legend, as SVG, PNG, or vector PDF. `--format png` and `--format pdf` no
+  longer need the `d2` executable, and every drawing still writes its D2
+  source next to it. Text is sized with the metrics of the bundled Liberation
+  Sans (Arial and Helvetica widths), so boxes fit in all three formats. Large
+  views are faster and far less tall (a 200-object project view: 5 instead of
+  19 seconds, 7499 × 6811 instead of 6112 × 25030 pixels).
+- Diagrams page: hover an object to light up its relations and neighbors,
+  click it to open its page, find objects by name (**Enter** jumps to the next
+  match), and click a legend entry to hide that kind of relation.
+- The npm package no longer installs `@terrastruct/d2` (58 MB); it uses
+  `elkjs` and `@resvg/resvg-wasm`. The VS Code extension shrinks from about 9
+  to 4.5 MB. The `layout` and `theme` settings of `.bca.json` (D2 options)
+  have no effect any more.
+- Docs: the guides are part of the page instead of a page in a frame, one
+  overview, use case, or scenario at a time. Switch between user guide and
+  test case and between English and German; **Open test** opens the AL test
+  at its procedure; **Markdown**, **DITA**, **BPMN**, and **SVG** save the
+  page, **All as HTML** the whole documentation. Links between guides and
+  from a use case's process to its scenarios stay on the page.
+- Large diagrams as an overview of their groups: every closed group is one
+  box with its object count and main object types, and the relations into,
+  out of, and between closed groups are bundled (one route per pair of groups
+  with the number of relations, per kind towards single objects). On the
+  Diagrams page, views with more than 120 objects or 250 relations start this
+  way; click a box to open its group, a group's name to close it, or use
+  **Open groups** and **Close groups**. Files of views with more than 1,500
+  objects are drawn as the overview instead of only writing the D2 source, so
+  the Base Application's project view (8,083 objects) now has a diagram.
+- Diagrams page and the flows on the Docs page: on a dark theme the diagrams
+  turn dark too (saved files stay light).
+- PDF diagrams with text outside Windows-1252 (Polish, Czech, Greek,
+  Cyrillic, ...) embed Liberation Sans, so the text shows and can be copied
+  and searched; other PDFs keep using Helvetica and stay small.
+- The README's diagram images are rendered from the example SVGs by
+  `npm run examples`, and CI checks them with the other generated examples.
+
+### Security
+
+- The Azure DevOps test-case CSV (`--export ado-csv`) writes cells that start
+  with `=`, `+`, `-`, or `@` with a leading apostrophe, so Excel and Google
+  Sheets do not run them as formulas.
+
 ## 0.11.0 - 2026-10-29
 
 ### Changed

package/README.md

@@ -41,10 +41,10 @@ In VS Code, install the **BC Atlas** extension and open an AL project:
 | **Get started** | `bca setup` | Guided setup in the terminal or through your AI agent (Claude Code, Copilot, Cursor): a starter `.bca.json`, features, Husky or Git hooks, GitHub Actions or Azure Pipelines, cron schedule, and sync. |
 | **Analyze** | `bca check` | Health findings - cycles, forbidden dependencies, architecture violations, hot spots, diagnostics, and AL compiler and CodeCop/UICop/AppSourceCop findings - with a CI exit code, also as SARIF for code scanning. |
 | | `bca architecture` | Find a target architecture (components, layers), list every dependency that blocks it with how to resolve it, and enforce it with a shrinking baseline. [Guide](./docs/clean-architecture.md) |
-| **Export** | `bca export` | Everything the extension shows, as files: the BC Atlas pages as one offline HTML file to share (default), the Markdown report ([example](./examples/report/README.md)), the 3D explorer, one Markdown page per object, any of ten diagram views as D2, SVG, PNG, PDF, or JSON, with `--watch`. |
+| **Export** | `bca export` | Everything the extension shows, as files: the BC Atlas pages as one offline HTML file to share (default), the Markdown report ([example](./examples/report/README.md)), the 3D explorer, one Markdown page per object, any of ten diagram views as D2, SVG, PNG, PDF, or JSON, with `--watch`, and the project as a knowledge graph in RDF with an OWL ontology ([Turtle, RDF/XML, OWL, N-Triples, JSON-LD](./docs/knowledge-graph.md)). |
 | | `bca docs` | User guides and test cases from AL UI tests (`[SCENARIO]`, `[GIVEN]`, `[WHEN]`, `[THEN]`) as Markdown, HTML, DITA 1.3, or Azure DevOps CSV, with real captions and translations, a flow diagram per scenario, and BPMN 2.0 processes per use case. [Example](./examples/docs/index.md) |
 | **Integrate** | `bca run` | One entry point for Git hooks, schedules, and pipelines; verifies, stages, or publishes generated files. Also available as a [GitHub Action](./docs/automation-and-ci.md#github-actions). |
-| | `bca update` | "BC Atlas 0.12.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
+| | `bca update` | "BC Atlas 0.14.0 is available": release notes, one-step update, and regenerated hooks, tasks, and pipelines. Dependabot pull requests on request. |
 | | `bca mcp` | A Model Context Protocol server for AI agents; `bca help --format json` is the versioned command contract. |
 
 Run `bca` for the same overview in your terminal and `bca help <command>` for
@@ -65,7 +65,7 @@ options and examples.
 | `ui` | How do pages, actions, and source tables connect? | `bca export --view ui --focus "Sales Order" -o ui.svg` |
 | `workflow` | What happens after an action or entry point? | `bca export --view workflow --entry action:Release -o flow.svg` |
 
-In VS Code, the Diagrams page of the BC Atlas panel renders every view with zoom and pan.
+In VS Code, the Diagrams page of the BC Atlas panel renders every view with zoom and pan; click an object to open it.
 
 ### Clean architecture
 
@@ -208,7 +208,7 @@ and update-check tools. `bca setup agent --agent claude|copilot|cursor` adds a
   -> AL compiler: calls and diagnostics   (src/al, when the toolchain is installed)
   -> resolved model with evidence         (resolver, call analysis, semantics)
   -> view projection and insights         (views, workflow, health)
-  -> D2 / SVG / JSON / Markdown / HTML    (renderers)
+  -> SVG / PNG / PDF / D2 / JSON / Markdown / HTML    (renderers)
   -> the pages: one workspace, in VS Code (vscode/) or exported as one file
 ```
 
@@ -259,27 +259,25 @@ lists planned work.
 
 ### Publishing
 
-Releases are published manually through the `Publish npm package` workflow.
-Update and commit the version in `package.json` and `package-lock.json`, then
-enter that exact version in the workflow form. The workflow rejects mismatched
-or already published versions, runs all checks, and publishes with the selected
-dist-tag. It then tags the commit as `v<version>`, so
+Releases are published manually through the `Release` workflow
+(`.github/workflows/publish-npm.yml`). Set the version of both packages with
+`npm run version:set -- <version>`, merge it, then run the workflow on `main`
+with that exact version. It rejects mismatched, already published, or already
+tagged versions, and tests the npm package and the VS Code extension, the
+packaged `.vsix` included, before anything is published. Then it publishes the
+npm package with the selected dist-tag and, unless switched off, the extension
+to the Visual Studio Marketplace and, with the secret `OVSX_PAT`, to Open VSX.
+Last, it tags the commit as `v<version>`, so
 `uses: SchulzOli/BC-Atlas@v<version>` resolves, and creates a GitHub release
-with the version's `CHANGELOG.md` section. npm authenticates through
+with the version's `CHANGELOG.md` section and the `.vsix`.
+
+No token is stored for either registry. npm authenticates through
 [trusted publishing](https://docs.npmjs.com/trusted-publishers): the package's
 trusted publisher on npmjs.com is this repository's `publish-npm.yml`
-workflow, so no npm token is stored in GitHub.
-
-
-The VS Code extension in `vscode/` is published by the `Publish VS Code
-extension` workflow: set `version` in `vscode/package.json`, then run the
-workflow with that version. It tests and packages the extension with the
-current engine and publishes it to the Visual Studio Marketplace as the
-publisher `SchulzOli`, signed in with Microsoft Entra ID through GitHub's OIDC
-token (no Marketplace token is stored; see the
-[launch checklist](https://github.com/SchulzOli/BC-Atlas/blob/main/vscode/marketing/README.md#launch-checklist)), and, with
-the secret `OVSX_PAT`, to Open VSX. Every CI run uploads the `.vsix` as the
-`bc-atlas-vsix` artifact.
+workflow. The Marketplace publisher `SchulzOli` is signed in with Microsoft
+Entra ID through GitHub's OIDC token in the `marketplace` environment (see the
+[launch checklist](https://github.com/SchulzOli/BC-Atlas/blob/main/vscode/marketing/README.md#launch-checklist)).
+Every CI run uploads the `.vsix` as the `bc-atlas-vsix` artifact.
 
 ## Contributing and support
 
@@ -291,5 +289,6 @@ Release notes are in [CHANGELOG.md](./CHANGELOG.md).
 ## License
 
 [MIT](./LICENSE). Dependencies retain their own licenses: `tree-sitter-al` and
-`web-tree-sitter` are MIT, and D2 is MPL-2.0. See
+`web-tree-sitter` are MIT, elkjs is EPL-2.0, resvg is MPL-2.0, and the
+Liberation Sans font is OFL-1.1. See
 [THIRD_PARTY_NOTICES.md](./THIRD_PARTY_NOTICES.md).

package/THIRD_PARTY_NOTICES.md

@@ -13,14 +13,31 @@ project.
 Copyright Tree-sitter contributors. Licensed under the MIT License.
 Source: <https://github.com/tree-sitter/tree-sitter>
 
-## D2
+## ELK (elkjs)
 
-Copyright Terrastruct, Inc. and contributors. Licensed under the Mozilla Public
-License 2.0. Source: <https://github.com/terrastruct/d2>
+Copyright Kiel University and others. Licensed under the Eclipse Public License
+2.0 (or, at your option, GPL-3.0-or-later). Source: <https://github.com/kieler/elkjs>
 
-The official D2 WebAssembly package is redistributed as an npm dependency for
-SVG rendering. The CLI can optionally invoke a separately installed D2
-executable for PNG and PDF output.
+`elkjs` lays out the diagram views (layered layout, routes, and labels).
+
+## resvg (@resvg/resvg-wasm)
+
+Copyright the resvg authors. Licensed under the Mozilla Public License 2.0.
+Source: <https://github.com/yisibl/resvg-js>
+
+The resvg WebAssembly package is an npm dependency that turns diagrams into
+PNG files.
+
+## Liberation Sans
+
+Digitized data copyright (c) 2010 Google Corporation; copyright (c) 2012 Red
+Hat, Inc. Licensed under the SIL Open Font License 1.1. Source:
+<https://github.com/liberationfonts/liberation-fonts>
+
+`vendor/fonts/LiberationSans-Regular.ttf` and `LiberationSans-Bold.ttf` are
+redistributed (license in `vendor/fonts/LICENSE-LiberationSans.txt`): PNG files
+are rendered with them, and their glyph widths size the boxes of every
+diagram.
 
 ## 3d-force-graph and three.js
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bc-atlas",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "BC Atlas maps Microsoft Dynamics 365 Business Central AL projects: architecture diagrams, health checks, reports, and documentation generated from source.",
   "homepage": "https://github.com/SchulzOli/BC-Atlas#readme",
   "bugs": {
@@ -38,7 +38,8 @@
     "site:build": "vitepress build website && node ./scripts/site-assets.js",
     "site:preview": "vitepress preview website",
     "version:set": "node ./scripts/set-version.js",
-    "update:graph-vendor": "node ./scripts/build-graph-vendor.js"
+    "update:graph-vendor": "node ./scripts/build-graph-vendor.js",
+    "update:font-metrics": "node ./scripts/build-font-metrics.js"
   },
   "keywords": [
     "al",
@@ -62,7 +63,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/server": "^2.4.0",
-    "@terrastruct/d2": "^0.1.33",
+    "@resvg/resvg-wasm": "^2.6.2",
+    "elkjs": "^0.12.1",
     "fflate": "^0.8.3",
     "graphology": "^0.26.0",
     "graphology-communities-louvain": "^2.0.2",
@@ -71,10 +73,14 @@
     "zod": "^4.6.7"
   },
   "devDependencies": {
-    "3d-force-graph": "^1.80.0",
     "@modelcontextprotocol/client": "^2.4.0",
+    "3d-force-graph": "^1.80.0",
     "bpmn-moddle": "^10.3.1",
     "esbuild": "^0.28.2",
+    "jsonld": "^9.0.0",
+    "n3": "^2.13.12",
+    "opentype.js": "^2.0.0",
+    "rdfxml-streaming-parser": "^3.3.0",
     "three": "^0.186.1",
     "vitepress": "2.0.0-alpha.20"
   }

package/src/analyzer.js

@@ -293,10 +293,18 @@ function enclosingMember(node, source, types) {
   return undefined;
 }
 
-function implementationRelations(value, node, source, add) {
+function implementationRelations(property, value, node, source, add) {
+  const bindingKind = {
+    implementation: "explicit",
+    defaultimplementation: "default",
+    unknownvalueimplementation: "unknownValue"
+  }[property];
+  if (!bindingKind) return;
   const identifier = String.raw`(?:"((?:""|[^"])*)"|([A-Za-z_][\w.]*))`;
   const pattern = new RegExp(`${identifier}\\s*=\\s*${identifier}`, "gu");
-  const member = enclosingMember(node, source, ["enum_value_declaration"]);
+  const member = bindingKind === "explicit"
+    ? enclosingMember(node, source, ["enum_value_declaration"])
+    : undefined;
   for (const match of value.matchAll(pattern)) {
     const contract = (match[1] ?? match[2]).replaceAll('""', '"');
     const target = (match[3] ?? match[4]).replaceAll('""', '"');
@@ -304,6 +312,7 @@ function implementationRelations(value, node, source, add) {
       target,
       targetType: "codeunit",
       kind: "selects",
+      bindingKind,
       contract,
       member
     });
@@ -496,8 +505,8 @@ function referencesFor(objectNode, source, file) {
       if (name === "includedpermissionsets") {
         includedPermissionSetRelations(value, node, add);
       }
-      if (name === "implementation") {
-        implementationRelations(value, node, source, add);
+      if (["implementation", "defaultimplementation", "unknownvalueimplementation"].includes(name)) {
+        implementationRelations(name, value, node, source, add);
       }
       if (name === "runobject") {
         const match = value.match(
@@ -533,6 +542,9 @@ function callsFor(node, source, file) {
       ? functionNode.childForFieldName("object")
       : undefined;
     const argumentsNode = callNode.childForFieldName("arguments");
+    const argumentsList = argumentsNode?.namedChildren.map((argument) =>
+      source.slice(argument.startIndex, argument.endIndex).trim()
+    ) ?? [];
     return {
       name: cleanName(source.slice(
         (memberNode ?? functionNode).startIndex,
@@ -543,6 +555,7 @@ function callsFor(node, source, file) {
         : undefined,
       receiverCall: receiverNode?.type === "call_expression" ? describe(receiverNode) : undefined,
       arity: argumentsNode?.namedChildCount ?? 0,
+      ...(argumentsList.length ? { arguments: argumentsList } : {}),
       scope: node.startPosition.row + 1,
       location: locationFor(callNode, file)
     };
@@ -610,6 +623,149 @@ function variableType(node, source) {
   return declaredType(type);
 }
 
+function fallbackStatements(node, source, file, conditional = false) {
+  if (!node) return [];
+  if (node.type === "statement_block") {
+    return node.namedChildren.flatMap((child) =>
+      fallbackStatements(child, source, file, conditional)
+    );
+  }
+  if (node.type === "if_statement") {
+    return [{
+      kind: "conditional",
+      then: fallbackStatements(node.childForFieldName("then_branch"), source, file, true),
+      else: node.childForFieldName("else_branch")
+        ? fallbackStatements(node.childForFieldName("else_branch"), source, file, true)
+        : null,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "case_statement") {
+    const body = node.childForFieldName("body");
+    const branches = (body?.namedChildren ?? [])
+      .filter((child) => child.type === "case_branch")
+      .map((branch) => fallbackStatements(
+        branch.childForFieldName("body"),
+        source,
+        file,
+        true
+      ));
+    const elseBranch = node.namedChildren.find((child) => child.type === "case_else_branch");
+    if (elseBranch) {
+      branches.push(elseBranch.namedChildren
+        .filter((child) => child.type !== "else_keyword")
+        .flatMap((child) => fallbackStatements(child, source, file, true)));
+    }
+    return [{
+      kind: "conditional",
+      branches,
+      hasImplicitEmptyPath: !elseBranch,
+      location: locationFor(node, file)
+    }];
+  }
+  if (["while_statement", "for_statement", "repeat_statement"].includes(node.type)) {
+    const body = node.childForFieldName("body");
+    return [{
+      kind: "conditional",
+      branches: [fallbackStatements(body, source, file, true)],
+      hasImplicitEmptyPath: node.type !== "repeat_statement",
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "call_expression") {
+    const functionNode = node.childForFieldName("function");
+    const memberNode = functionNode?.type === "member_expression"
+      ? functionNode.childForFieldName("member")
+      : undefined;
+    const receiverNode = functionNode?.type === "member_expression"
+      ? functionNode.childForFieldName("object")
+      : undefined;
+    const target = functionNode
+      ? cleanName(source.slice(
+        (memberNode ?? functionNode).startIndex,
+        (memberNode ?? functionNode).endIndex
+      ))
+      : undefined;
+    const argumentsNode = node.childForFieldName("arguments");
+    return [{
+      kind: "call",
+      target,
+      receiver: receiverNode
+        ? cleanName(source.slice(receiverNode.startIndex, receiverNode.endIndex))
+        : undefined,
+      arity: argumentsNode?.namedChildCount ?? 0,
+      directError: !receiverNode && target?.toLocaleLowerCase("en-US") === "error",
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "exit_statement") {
+    const returnNode = node.childForFieldName("return_value");
+    return [{
+      kind: "return",
+      value: returnNode ? source.slice(returnNode.startIndex, returnNode.endIndex).trim() : undefined,
+      constant: Boolean(returnNode && [
+        "boolean",
+        "integer",
+        "decimal",
+        "string_literal"
+      ].includes(returnNode.type)),
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  if (node.type === "assignment_statement") {
+    const targetNode = node.childForFieldName("left");
+    return [{
+      kind: "assignment",
+      target: targetNode
+        ? cleanName(source.slice(targetNode.startIndex, targetNode.endIndex))
+        : undefined,
+      conditional,
+      location: locationFor(node, file)
+    }];
+  }
+  return [{
+    kind: "other",
+    conditional,
+    location: locationFor(node, file)
+  }];
+}
+
+function fallbackFactsFor(node, source, file, hasBody) {
+  if (!hasBody) return undefined;
+  const codeBlock = node.namedChildren.find((child) =>
+    ["code_block", "statement_block"].includes(child.type)
+  );
+  const body = codeBlock?.childForFieldName("body") ??
+    codeBlock?.namedChildren.find((child) => child.type === "statement_block");
+  return {
+    complete: !node.hasError && !codeBlock?.hasError,
+    statements: fallbackStatements(body, source, file),
+    ...((node.hasError || codeBlock?.hasError)
+      ? { limitations: ["The AL parser reported errors in this procedure body."] }
+      : {})
+  };
+}
+
+function resolveFallbackCalls(statements, procedures) {
+  for (const statement of statements) {
+    if (statement.kind === "conditional") {
+      if (statement.then) resolveFallbackCalls(statement.then, procedures);
+      if (statement.else) resolveFallbackCalls(statement.else, procedures);
+      for (const branch of statement.branches ?? []) {
+        resolveFallbackCalls(branch, procedures);
+      }
+      continue;
+    }
+    if (statement.kind !== "call" || statement.directError) continue;
+    const candidates = procedures.get(`${statement.target?.toLocaleLowerCase("en-US")}:${statement.arity}`) ?? [];
+    const target = !statement.receiver && candidates.length === 1 ? candidates[0] : undefined;
+    statement.resolved = Boolean(target?.fallbackFacts?.complete);
+    if (target) statement.targetSignature = target.signature;
+  }
+}
+
 function membersFor(objectNode, source, file) {
   const procedures = [];
   const fields = [];
@@ -624,18 +780,24 @@ function membersFor(objectNode, source, file) {
       const name = fieldText(node, "name", source);
       if (name) {
         const returnTypeNode = node.childForFieldName("return_type");
-        const returnType = returnTypeNode
-          ? declaredType(source.slice(returnTypeNode.startIndex, returnTypeNode.endIndex).trim())
-          : {};
+        const header = procedureHeader(node, source);
+        const returnTypeText = returnTypeNode
+          ? source.slice(returnTypeNode.startIndex, returnTypeNode.endIndex).trim()
+          : header.match(/\)\s*:\s*([^;\r\n]+)$/u)?.[1]?.trim();
+        const returnType = declaredType(returnTypeText);
         const attributes = [
           ...node.namedChildren
           .filter((child) => child.type === "attribute_item")
           .map((child) => source.slice(child.startIndex, child.endIndex)),
           ...attributesFor(node, source)
         ];
+        const hasBody = node.namedChildren.some((child) =>
+          ["code_block", "statement_block"].includes(child.type)
+        );
+        const fallbackFacts = fallbackFactsFor(node, source, file, hasBody);
         procedures.push({
           name,
-          header: procedureHeader(node, source),
+          header,
           visibility: node.type === "trigger_declaration"
             ? undefined
             : fieldText(node, "modifier", source)?.toLowerCase() ?? "public",
@@ -647,6 +809,8 @@ function membersFor(objectNode, source, file) {
               : attributes.some((attribute) => /\[(?:Integration|Business)Event\b/iu.test(attribute))
                 ? "event"
               : "procedure",
+          hasBody,
+          ...(fallbackFacts ? { fallbackFacts } : {}),
           location: locationFor(node, file),
           calls: callsFor(node, source, file),
           attributes,
@@ -825,6 +989,18 @@ function membersFor(objectNode, source, file) {
       .map(({ order, location }) => ({ kind: "commit", order, location }));
     procedure.transactionSegments = procedure.transactionBoundaries.length + 1;
   }
+  const localProcedures = new Map();
+  for (const procedure of procedures) {
+    const key = `${procedure.name.toLocaleLowerCase("en-US")}:${procedure.arity}`;
+    const candidates = localProcedures.get(key) ?? [];
+    candidates.push(procedure);
+    localProcedures.set(key, candidates);
+  }
+  for (const procedure of procedures) {
+    if (procedure.fallbackFacts) {
+      resolveFallbackCalls(procedure.fallbackFacts.statements, localProcedures);
+    }
+  }
   const transactionBoundaries = procedures.flatMap((procedure) =>
     procedure.transactionBoundaries.map((boundary) => ({
       ...boundary,
@@ -854,8 +1030,8 @@ function dataOperationRelations(members, object) {
         .map((variable) => [variable.name.toLowerCase(), variable])
     );
     if (sourceTable) {
-      variables.set("rec", { target: sourceTable, temporary: false });
-      variables.set("xrec", { target: sourceTable, temporary: false });
+      variables.set("rec", { target: sourceTable, temporary: object.sourceTableTemporary });
+      variables.set("xrec", { target: sourceTable, temporary: object.sourceTableTemporary });
     }
     let transactionSegment = 1;
     for (const call of procedure.calls) {
@@ -874,7 +1050,10 @@ function dataOperationRelations(members, object) {
         kind,
         relationClass: "runtime",
         operation: call.name,
-        temporary: variable.temporary,
+        recordVariable: call.receiver,
+        temporary: variable.parameter && variable.temporary !== true
+          ? undefined
+          : variable.temporary,
         member: procedure.signature,
         sourceProcedure: procedure.signature,
         transactionSegment,
@@ -885,6 +1064,24 @@ function dataOperationRelations(members, object) {
   return relations;
 }
 
+function subscriberRelations(procedures) {
+  const relations = [];
+  for (const procedure of procedures) {
+    for (const attribute of procedure.attributes ?? []) {
+      const match = attribute.match(/^\[\s*EventSubscriber\s*\(\s*ObjectType::(Codeunit|Table|Page|Report|XmlPort)\s*,\s*(?:Codeunit|Database|Page|Report|XmlPort)::\s*(?:"((?:""|[^"])*)"|([^,\]\s]+))/iu);
+      if (!match) continue;
+      relations.push({
+        target: (match[2] ?? match[3]).replaceAll('""', '"'),
+        targetType: match[1].toLowerCase(),
+        kind: "subscribes",
+        member: procedure.name,
+        location: procedure.location
+      });
+    }
+  }
+  return relations;
+}
+
 function helperDataOperationRelations(members, directRelations) {
   const procedures = new Map();
   for (const procedure of members.procedures) {
@@ -971,7 +1168,18 @@ async function objectsFromSource(source, file) {
       });
     }
     const members = membersFor(node, source, file);
-    const dataRelations = dataOperationRelations(members, { type, name, base, relations });
+    const properties = propertiesFor(node, source);
+    const sourceTableTemporary = /^true$/iu.test(
+      propertyValueFor(node, source, "sourcetabletemporary") ?? "false"
+    );
+    relations.push(...subscriberRelations(members.procedures));
+    const dataRelations = dataOperationRelations(members, {
+      type,
+      name,
+      base,
+      relations,
+      sourceTableTemporary
+    });
     relations.push(...dataRelations, ...helperDataOperationRelations(members, dataRelations));
 
     const assignableValue = type === "permissionset"
@@ -987,7 +1195,7 @@ async function objectsFromSource(source, file) {
       namespace,
       usings,
       file,
-      properties: propertiesFor(node, source),
+      properties,
       relations,
       procedures: members.procedures,
       fields: members.fields,