@facilis.dev/analyze 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 facilis-dev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,19 @@
-# Temporary Holding Version
+# @facilis.dev/analyze
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Facilis AST analyzer: static facts for the project DSL (routes, schema, relations, pages) with an injected parser.
+
+Part of [Facilis](https://github.com/facilis-dev/facilis), a browser-first low-code framework: the Studio
+runs a generated project in a WebContainer where vite dev is the only dev server
+and Nitro v3 runs as a Vite plugin. Framework contracts live in
+[docs/SPEC.md](https://github.com/facilis-dev/facilis/blob/main/docs/SPEC.md) and architectural decisions in
+[docs/DECISIONS.md](https://github.com/facilis-dev/facilis/blob/main/docs/DECISIONS.md).
+
+```sh
+npm install @facilis.dev/analyze
+```
+
+The package publishes its TypeScript sources and its compiled dist/; the exports map
+of the published manifest points at dist/, so Node and bundlers load JavaScript and
+the bundled .d.ts files.
+
+Licensed under the MIT License.

package/dist/analyze.d.ts

@@ -0,0 +1,17 @@
+import { type TransportSpec } from "./passes/clients.js";
+import type { PathAlias } from "./path-resolver.js";
+import type { Parser } from "./parser.js";
+import type { Analysis } from "./types.js";
+export interface AnalyzeInput {
+    /** Project-relative path -> source. The analyzer never touches the filesystem itself. */
+    readonly files: ReadonlyMap<string, string>;
+    readonly parser: Parser;
+    /** Project root inside the file map (defaults to the map root). */
+    readonly rootDir?: string;
+    readonly aliases?: readonly PathAlias[];
+    readonly transport?: TransportSpec;
+}
+/** The sanctioned client transport (docs/findings/ast-dsl-contract.md §3.4). */
+export declare const DEFAULT_TRANSPORT: TransportSpec;
+/** Analyze a project snapshot into the fact model + project graph. Pure and synchronous. */
+export declare function analyzeProject(input: AnalyzeInput): Analysis;

package/dist/analyze.js

@@ -0,0 +1,99 @@
+import { buildPageFacts } from "./passes/clients.js";
+import { buildConfigFacts } from "./passes/config.js";
+import { buildFileFacts } from "./passes/file-facts.js";
+import { readLocaleCatalogs } from "./passes/i18n.js";
+import { buildJobFacts } from "./passes/jobs.js";
+import { buildJobRelationFacts } from "./passes/job-relations.js";
+import { buildRouteFacts } from "./passes/routes.js";
+import { buildRouteRelationFacts } from "./passes/route-relations.js";
+import { routeSystemTableDiagnostics } from "./passes/route-tables.js";
+import { buildSchemaFacts } from "./passes/schema.js";
+import { buildScreens } from "./passes/screens.js";
+import { buildViewFacts } from "./passes/views.js";
+import { buildWorkflowFacts } from "./passes/workflows.js";
+import { buildWorkflowTableFacts } from "./passes/workflow-tables.js";
+import { buildProjectGraph } from "./graph.js";
+import { createModuleGraph } from "./module-graph.js";
+import { computeRevision } from "./revision.js";
+import { diagnostic } from "./diagnostics.js";
+/** The sanctioned client transport (docs/findings/ast-dsl-contract.md §3.4). */
+export const DEFAULT_TRANSPORT = {
+    module: "src/lib/api.ts",
+    exportName: "api",
+};
+/** Analyze a project snapshot into the fact model + project graph. Pure and synchronous. */
+export function analyzeProject(input) {
+    const graph = createModuleGraph({
+        files: input.files,
+        parser: input.parser,
+        root: input.rootDir ?? "",
+        ...(input.aliases === undefined ? {} : { aliases: input.aliases }),
+    });
+    const config = buildConfigFacts(graph);
+    const routes = buildRouteFacts(graph, config.facts);
+    const schema = buildSchemaFacts(graph, config.facts);
+    const views = buildViewFacts(graph);
+    // D-157: the declaration check runs after the schema and the views, because a route's
+    // `dbTables` and its usage are compared against both (tables and views).
+    const routeRelations = buildRouteRelationFacts(graph, routes.routes, schema.tables, views.views);
+    // D-157 applies to jobs too: their `run` sees the system-scoped db client, tables and
+    // views alike, and the relation index is the same one the route pass builds its cases on.
+    const jobs = buildJobFacts(graph);
+    const jobRelations = buildJobRelationFacts(graph, jobs.jobs, schema.tables, views.views);
+    const workflows = buildWorkflowFacts(graph);
+    // A workflow declares no tables: its surface is derived from the jobs its steps reference.
+    const workflowTables = buildWorkflowTableFacts(workflows.workflows, jobs.jobs);
+    const locales = readLocaleCatalogs(graph);
+    const pages = buildPageFacts(graph, routes.routes, input.transport ?? DEFAULT_TRANSPORT);
+    const screens = buildScreens(graph, pages.pages);
+    const fileFacts = buildFileFacts(graph);
+    const diagnostics = [];
+    for (const file of graph.files.values()) {
+        for (const error of file.errors) {
+            diagnostics.push(diagnostic("parse-error", "error", error.message, error.source));
+        }
+    }
+    diagnostics.push(...[
+        ...config.diagnostics,
+        ...routes.diagnostics,
+        ...schema.diagnostics,
+        ...views.diagnostics,
+        ...routeRelations.diagnostics,
+        ...jobs.diagnostics,
+        ...jobRelations.diagnostics,
+        ...locales.diagnostics,
+        ...pages.diagnostics,
+        ...routeSystemTableDiagnostics(routes.routes, schema.tables),
+        ...workflows.diagnostics,
+        ...workflowTables.diagnostics,
+    ].filter(
+    // Framework sources are shipped code: their facts stay, but their lint-style
+    // diagnostics are not the project's. Project files start outside node_modules/.
+    (entry) => entry.source === null || !entry.source.file.startsWith("node_modules/")));
+    return {
+        revision: computeRevision(input.files),
+        files: [...graph.files.keys()].toSorted((left, right) => left.localeCompare(right)),
+        config: config.facts,
+        routes: routeRelations.routes,
+        tables: schema.tables,
+        relations: schema.relations,
+        views: views.views,
+        pages: pages.pages,
+        workflows: workflows.workflows,
+        jobs: jobs.jobs,
+        jobRelations: jobRelations.relations,
+        workflowTables: workflowTables.facts,
+        fileFacts,
+        locales: locales.locales,
+        diagnostics,
+        graph: buildProjectGraph({
+            routes: routes.routes,
+            tables: schema.tables,
+            relations: schema.relations,
+            pages: pages.pages,
+            views: views.views,
+            screens,
+            workflows: workflows.workflows,
+        }),
+    };
+}

package/dist/ast/node.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal ESTree narrowing helpers shared by every analyzer pass.
+ *
+ * The AST shape is parser-independent: oxc-parser (Node, browser) and any future adapter
+ * produce plain ESTree / TS-ESTree nodes. Passes never import a parser package.
+ */
+export interface AstNode {
+    type: string;
+    start?: number;
+    end?: number;
+    [key: string]: unknown;
+}
+export declare function isAstNode(value: unknown): value is AstNode;
+export declare function asNode(value: unknown): AstNode | undefined;
+export declare function nodeArray(node: AstNode, key: string): AstNode[];
+export declare function identifierName(node: unknown): string | undefined;
+export declare function literalString(node: unknown): string | undefined;
+/** Name of an object-literal property, or undefined for computed/spread entries. */
+export declare function propertyName(property: AstNode): string | undefined;
+export declare function propertyValue(property: AstNode): AstNode | undefined;
+/** Object-literal entries, including spread elements. */
+export declare function objectEntries(node: AstNode): AstNode[];
+export declare function isCallTo(node: unknown, calleeName: string): node is AstNode;
+export declare function callArguments(node: AstNode): AstNode[];
+/** Strip parentheses and TypeScript-only wrappers from an expression. */
+export declare function unwrapExpression(value: unknown): AstNode | undefined;
+/** A call expression after unwrapping parentheses/TS wrappers. */
+export declare function callExpression(value: unknown): AstNode | undefined;
+export declare function memberName(node: AstNode): string | undefined;

package/dist/ast/node.js

@@ -0,0 +1,85 @@
+export function isAstNode(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    return typeof value.type === "string";
+}
+export function asNode(value) {
+    return isAstNode(value) ? value : undefined;
+}
+export function nodeArray(node, key) {
+    const value = node[key];
+    if (!Array.isArray(value))
+        return [];
+    return value.filter(isAstNode);
+}
+export function identifierName(node) {
+    const candidate = asNode(node);
+    if (!candidate || candidate.type !== "Identifier")
+        return undefined;
+    return typeof candidate.name === "string" ? candidate.name : undefined;
+}
+export function literalString(node) {
+    const candidate = asNode(node);
+    if (!candidate || candidate.type !== "Literal")
+        return undefined;
+    return typeof candidate.value === "string" ? candidate.value : undefined;
+}
+/** Name of an object-literal property, or undefined for computed/spread entries. */
+export function propertyName(property) {
+    if (property.type !== "Property")
+        return undefined;
+    const key = asNode(property.key);
+    if (!key)
+        return undefined;
+    if (key.type === "Identifier") {
+        return property.computed === true ? undefined : identifierName(key);
+    }
+    if (key.type === "Literal" && (typeof key.value === "string" || typeof key.value === "number")) {
+        return String(key.value);
+    }
+    return undefined;
+}
+export function propertyValue(property) {
+    return asNode(property.value);
+}
+/** Object-literal entries, including spread elements. */
+export function objectEntries(node) {
+    return nodeArray(node, "properties");
+}
+export function isCallTo(node, calleeName) {
+    const candidate = asNode(node);
+    if (!candidate || candidate.type !== "CallExpression")
+        return false;
+    return identifierName(candidate.callee) === calleeName;
+}
+export function callArguments(node) {
+    return nodeArray(node, "arguments");
+}
+const UNWRAPPED_EXPRESSIONS = new Set([
+    "ParenthesizedExpression",
+    "TSAsExpression",
+    "TSSatisfiesExpression",
+    "TSNonNullExpression",
+    "TSInstantiationExpression",
+    "ChainExpression",
+]);
+/** Strip parentheses and TypeScript-only wrappers from an expression. */
+export function unwrapExpression(value) {
+    let node = asNode(value);
+    while (node && UNWRAPPED_EXPRESSIONS.has(node.type)) {
+        node = asNode(node.expression);
+    }
+    return node;
+}
+/** A call expression after unwrapping parentheses/TS wrappers. */
+export function callExpression(value) {
+    const node = unwrapExpression(value);
+    return node?.type === "CallExpression" ? node : undefined;
+}
+export function memberName(node) {
+    if (node.type !== "MemberExpression")
+        return undefined;
+    if (node.computed === true)
+        return literalString(node.property);
+    return identifierName(node.property);
+}

package/dist/ast/walk.d.ts

@@ -0,0 +1,8 @@
+import { type AstNode } from "./node.js";
+/**
+ * Depth-first walk over an ESTree node. The AST is plain data (no cycles), so a generic
+ * recursion is enough and keeps the analyzer independent of a parser-specific visitor.
+ */
+export declare function walk(node: AstNode, visit: (node: AstNode) => void): void;
+/** Visit descendants of a node, not the node itself. */
+export declare function walkChildren(node: AstNode, visit: (node: AstNode) => void): void;

package/dist/ast/walk.js

@@ -0,0 +1,40 @@
+import { isAstNode } from "./node.js";
+const SKIPPED_KEYS = new Set(["type", "start", "end", "range"]);
+/**
+ * Depth-first walk over an ESTree node. The AST is plain data (no cycles), so a generic
+ * recursion is enough and keeps the analyzer independent of a parser-specific visitor.
+ */
+export function walk(node, visit) {
+    visit(node);
+    for (const key of Object.keys(node)) {
+        if (SKIPPED_KEYS.has(key))
+            continue;
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (isAstNode(child))
+                    walk(child, visit);
+            }
+            continue;
+        }
+        if (isAstNode(value))
+            walk(value, visit);
+    }
+}
+/** Visit descendants of a node, not the node itself. */
+export function walkChildren(node, visit) {
+    for (const key of Object.keys(node)) {
+        if (SKIPPED_KEYS.has(key))
+            continue;
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (isAstNode(child))
+                    walk(child, visit);
+            }
+            continue;
+        }
+        if (isAstNode(value))
+            walk(value, visit);
+    }
+}

package/dist/diagnostics.d.ts

@@ -0,0 +1,5 @@
+import type { Diagnostic, Severity, SourceRef } from "./types.js";
+export declare function diagnostic(code: string, severity: Severity, message: string, source: SourceRef | null): Diagnostic;
+export declare function error(code: string, message: string, source: SourceRef | null): Diagnostic;
+export declare function warning(code: string, message: string, source: SourceRef | null): Diagnostic;
+export declare function info(code: string, message: string, source: SourceRef | null): Diagnostic;

package/dist/diagnostics.js

@@ -0,0 +1,12 @@
+export function diagnostic(code, severity, message, source) {
+    return { code, severity, message, source };
+}
+export function error(code, message, source) {
+    return diagnostic(code, "error", message, source);
+}
+export function warning(code, message, source) {
+    return diagnostic(code, "warning", message, source);
+}
+export function info(code, message, source) {
+    return diagnostic(code, "info", message, source);
+}

package/dist/fs.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Node filesystem loader for the analyzer (exported as `@facilis.dev/analyze/fs`).
+ *
+ * Kept apart from the `./node` parser adapter: a Vite config that runs in the browser VM
+ * needs to read a project directory but must not load a native/wasm parser. The loader only
+ * reads and filters the file map; the caller injects the parser (D-092).
+ */
+export interface LoadProjectOptions {
+    /** Package scopes allowed under node_modules (default: @facilis.dev). */
+    readonly nodeModuleScopes?: readonly string[];
+}
+/** Read a project directory into the analyzer's path -> source map. */
+export declare function loadProjectFiles(root: string, options?: LoadProjectOptions): Map<string, string>;

package/dist/fs.js

@@ -0,0 +1,51 @@
+/**
+ * Node filesystem loader for the analyzer (exported as `@facilis.dev/analyze/fs`).
+ *
+ * Kept apart from the `./node` parser adapter: a Vite config that runs in the browser VM
+ * needs to read a project directory but must not load a native/wasm parser. The loader only
+ * reads and filters the file map; the caller injects the parser (D-092).
+ */
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, sep } from "node:path";
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".json"];
+const ALWAYS_SKIPPED = new Set([".git", "dist", "coverage", ".turbo", ".facilis", ".output"]);
+/** Read a project directory into the analyzer's path -> source map. */
+export function loadProjectFiles(root, options = {}) {
+    const scopes = options.nodeModuleScopes ?? ["@facilis.dev"];
+    const files = new Map();
+    const walk = (directory, relativeDirectory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            if (ALWAYS_SKIPPED.has(entry.name))
+                continue;
+            const full = join(directory, entry.name);
+            const path = relativeDirectory.length === 0 ? entry.name : relativeDirectory + "/" + entry.name;
+            const stat = entry.isSymbolicLink() ? statSync(full) : null;
+            const isDirectory = stat === null ? entry.isDirectory() : stat.isDirectory();
+            const isFile = stat === null ? entry.isFile() : stat.isFile();
+            if (isDirectory) {
+                if (entry.name === "node_modules") {
+                    for (const scope of scopes) {
+                        const scopeDirectory = join(full, scope);
+                        try {
+                            readdirSync(scopeDirectory);
+                        }
+                        catch {
+                            continue;
+                        }
+                        walk(scopeDirectory, path + "/" + scope);
+                    }
+                    continue;
+                }
+                walk(full, path);
+                continue;
+            }
+            if (!isFile)
+                continue;
+            if (!SOURCE_EXTENSIONS.some((extension) => entry.name.endsWith(extension)))
+                continue;
+            files.set(path.split(sep).join("/"), readFileSync(full, "utf8"));
+        }
+    };
+    walk(root, "");
+    return files;
+}

package/dist/graph-edges.d.ts

@@ -0,0 +1,3 @@
+import type { GraphEdge } from "./types.js";
+import type { GraphInput } from "./graph.js";
+export declare function collectEdges(input: GraphInput, nodeIds: ReadonlySet<string>): GraphEdge[];

package/dist/graph-edges.js

@@ -0,0 +1,148 @@
+import { pageId, routeId, tableId, viewId } from "./graph-ids.js";
+function fkLabel(table, targetTable, targetColumns, onDelete) {
+    let label = table.name + " -> " + targetTable + "." + targetColumns.join(", ");
+    if (onDelete !== null)
+        label += " on delete " + onDelete;
+    return label;
+}
+function relationLabel(cardinality) {
+    return cardinality;
+}
+function buildTableLookupMap(tables) {
+    const byName = new Map();
+    for (const table of tables) {
+        if (!byName.has(table.name))
+            byName.set(table.name, table);
+    }
+    return byName;
+}
+function elevatedTables(route) {
+    const tables = new Set();
+    for (const elevation of route.elevations) {
+        for (const table of elevation.tables)
+            tables.add(table);
+    }
+    return tables;
+}
+export function collectEdges(input, nodeIds) {
+    const edges = new Map();
+    const tablesByName = buildTableLookupMap(input.tables);
+    // Tables and views share the SQL namespace, so a relation name is at most one of the two.
+    const viewNames = new Set(input.views.map((view) => view.name));
+    const add = (edge) => {
+        if (!nodeIds.has(edge.source) || !nodeIds.has(edge.target))
+            return;
+        if (edges.has(edge.id))
+            return;
+        edges.set(edge.id, edge);
+    };
+    for (const table of input.tables) {
+        for (const foreignKey of table.foreignKeys) {
+            add({
+                id: "fk:" +
+                    table.name +
+                    ":" +
+                    foreignKey.columns.join(",") +
+                    ":" +
+                    foreignKey.targetTable +
+                    ":" +
+                    foreignKey.targetColumns.join(","),
+                kind: "fk",
+                source: tableId(table.name),
+                target: tableId(foreignKey.targetTable),
+                label: fkLabel(table, foreignKey.targetTable, foreignKey.targetColumns, foreignKey.onDelete),
+            });
+        }
+    }
+    for (const relation of input.relations) {
+        const id = ["relation", relation.from, relation.to, relation.cardinality];
+        if (relation.fields.length > 0)
+            id.push(relation.fields.join(","));
+        if (relation.references.length > 0)
+            id.push(relation.references.join(","));
+        add({
+            id: id.join(":"),
+            kind: "relation",
+            source: tableId(relation.from),
+            target: tableId(relation.to),
+            label: relationLabel(relation.cardinality),
+        });
+    }
+    // A view depends on the base tables its declaration names (metadata only, D-097). The target
+    // is a view when a view declares another view as its base, so the edge lands on the node that
+    // exists rather than on a phantom table.
+    for (const view of input.views) {
+        const source = viewId(view.name);
+        for (const base of view.tables) {
+            if (base === view.name)
+                continue;
+            add({
+                id: "view-base:" + view.name + ":" + base,
+                kind: "view-base",
+                source,
+                target: viewNames.has(base) ? viewId(base) : tableId(base),
+                label: null,
+            });
+        }
+    }
+    for (const route of input.routes) {
+        const routeNodeId = routeId(route);
+        const elevated = elevatedTables(route);
+        // A route declares every relation it touches in dbTables (D-157), tables and views alike:
+        // the target kind is decided by the relation the name denotes.
+        for (const name of route.dbTables ?? []) {
+            const isView = viewNames.has(name);
+            add({
+                id: (isView ? "route-view:" : "route-table:") + routeNodeId + ":dbTables:" + name,
+                kind: isView ? "route-view" : "route-table",
+                source: routeNodeId,
+                target: isView ? viewId(name) : tableId(name),
+                label: "dbTables",
+                ...(elevated.has(name) ? { access: "elevated" } : {}),
+            });
+        }
+        for (const entry of route.dbColumns ?? []) {
+            const separator = entry.indexOf(".");
+            if (separator <= 0)
+                continue;
+            const tableName = entry.slice(0, separator);
+            const columnName = entry.slice(separator + 1);
+            const table = tablesByName.get(tableName);
+            const knownColumn = table?.columns.some((column) => column.property === columnName);
+            if (knownColumn !== true)
+                continue;
+            add({
+                id: "route-table:" + routeNodeId + ":dbColumns:" + tableName,
+                kind: "route-table",
+                source: routeNodeId,
+                target: tableId(tableName),
+                label: "dbColumns",
+                ...(elevated.has(tableName) ? { access: "elevated" } : {}),
+            });
+        }
+    }
+    for (const page of input.pages) {
+        const source = pageId(page.path);
+        for (const call of page.calls) {
+            for (const matchedRouteId of call.matchedRouteIds) {
+                add({
+                    id: "page-route:" + page.path + ":" + matchedRouteId,
+                    kind: "page-route",
+                    source,
+                    target: matchedRouteId,
+                    label: null,
+                });
+            }
+        }
+    }
+    for (const link of input.screens?.links ?? []) {
+        add({
+            id: "page-link:" + link.from + ":" + link.to + ":" + link.kind + ":" + link.toPath,
+            kind: "page-link",
+            source: pageId(link.from),
+            target: pageId(link.to),
+            label: link.toPath,
+        });
+    }
+    return [...edges.values()];
+}

package/dist/graph-ids.d.ts

@@ -0,0 +1,6 @@
+import type { RouteFact } from "./types.js";
+export declare function tableId(name: string): string;
+export declare function viewId(name: string): string;
+export declare function routeId(route: RouteFact): string;
+export declare function pageId(path: string): string;
+export declare function workflowId(name: string): string;

package/dist/graph-ids.js

@@ -0,0 +1,22 @@
+const NODE_PREFIX = {
+    page: "page:",
+    route: "route:",
+    table: "table:",
+    view: "view:",
+    workflow: "workflow:",
+};
+export function tableId(name) {
+    return NODE_PREFIX.table + name;
+}
+export function viewId(name) {
+    return NODE_PREFIX.view + name;
+}
+export function routeId(route) {
+    return NODE_PREFIX.route + route.method + " " + route.path;
+}
+export function pageId(path) {
+    return NODE_PREFIX.page + path;
+}
+export function workflowId(name) {
+    return NODE_PREFIX.workflow + name;
+}

package/dist/graph.d.ts

@@ -0,0 +1,15 @@
+import type { PageFact, ProjectGraph, RelationFact, RouteFact, ScreenFacts, TableFact, ViewFact, WorkflowFact } from "./types.js";
+export interface GraphInput {
+    readonly routes: readonly RouteFact[];
+    readonly tables: readonly TableFact[];
+    readonly relations: readonly RelationFact[];
+    readonly pages: readonly PageFact[];
+    /** Declarative views (D-097/D-098): nodes plus view-base edges since D-160. */
+    readonly views: readonly ViewFact[];
+    /** Route paths, bounded page previews and explicit page links. */
+    readonly screens?: ScreenFacts;
+    /** Workflow definitions read from `server/workflows/**` (D-135 W3). */
+    readonly workflows?: readonly WorkflowFact[];
+}
+/** Build the single project graph from facts. Ids and ordering are stable across runs. */
+export declare function buildProjectGraph(input: GraphInput): ProjectGraph;