@telorun/analyzer 0.68.0 → 0.70.0

package/dist/module-graph.d.ts

@@ -0,0 +1,500 @@
+/**
+ * The module graph — what a module IS, as boxes, rows and classed edges.
+ *
+ * One fold over the call graph, the reference field map and each kind's own
+ * schema, producing the three primitives an editor draws:
+ *
+ *  - **Box** — a declaration and what it owns. Every resource is a node whatever
+ *    declaration form it arrived in (named, inline, `with:`-scoped, imported,
+ *    injected), plus the module root, which is not a resource but owns `targets`.
+ *  - **Row** — one ORDERED entry inside a box: a step, an entry-list item (a
+ *    route, a mount), a boot target. Order is manifest data, so it is carried
+ *    rather than re-derived; a row is where reordering is expressible at all.
+ *  - **Edge** — a reference leaving a PORT, classed by what the slot's `use`
+ *    says happens at it.
+ *
+ * **Ports are declared, not discovered.** A port exists because the kind's
+ * schema declares a ref slot, so an EMPTY slot is a port with an empty
+ * occupancy — the fact that `notFoundHandler` is unset is as much a property of
+ * the application as the fact that `mounts` has two entries, and it is the only
+ * thing an editor can offer to fill.
+ *
+ * **Three edge classes, not six uses.** What a reader must distinguish is
+ * whether control transfers, not which of four ways it does:
+ * `call` / `detached` / `trigger.inbound` / `trigger.consumer` are **flow**,
+ * `dependency` is **holds**, `schema` is **shape** — a type annotation rather
+ * than a runtime relation. The six-value `use` stays on the edge for consumers
+ * that need the distinction; the class is what a view draws.
+ *
+ * **Identity is anchored on names, never on indices.** A row addressed by array
+ * index shifts when a sibling is inserted above it, so selection and sticky
+ * expansion would detach precisely while the user is editing — the primary use
+ * case. Where the grammar offers a name (a step's `name:`, a resource's
+ * `metadata.name`) the name is the identity; where it does not (an unnamed
+ * route, an unnamed step) the identity is the nearest named ancestor plus a
+ * content-derived key. The same reason the migration driver refuses indexed
+ * matches into a resized array: a stale key resolves to nothing, a stale index
+ * silently names a different element.
+ *
+ * **What is deliberately NOT here: view policy.** Bands, labels, layout and
+ * expansion are the editor's, so nothing in this file reads a schema `title` or
+ * decides where a node is drawn. What it emits is the fact each of those
+ * decisions is taken from — capability, ownership, edge class, `boot` — so two
+ * hosts drawing the same module cannot disagree about what it contains.
+ *
+ * Browser-safe: no Node built-ins.
+ */
+import type { ResourceDefinition, ResourceManifest } from "@telorun/sdk";
+import { type CallGraph } from "./call-graph.js";
+import { type RefUse } from "./ref-slot.js";
+/** How a node's declaration reached the module, which is what decides where a
+ *  view may draw it — an inline child exists nowhere but its parent's YAML, so
+ *  it is never a peer of the resource holding it. */
+export type NodeOwnership = "root" | "named" | "inline" | "scoped" | "imported" | "injected";
+/**
+ * What happens at a site, reduced to what a view draws.
+ *
+ * The first three classify a REFERENCE by its `use`; `data` is not a reference
+ * at all — it is one resource reading another's published state in CEL
+ * (`resources.<name>.status.<field>`), which is a real dependency the reference
+ * graph does not carry and which no slot declares.
+ */
+export type EdgeClass = "flow" | "holds" | "shape" | "data";
+/**
+ * What a line of a body is.
+ *
+ * The first three are ORDERED entries of an array — a step, an entry-list item,
+ * a boot target — and reordering one is the point of drawing them. The last two
+ * are not positions at all: a slot may hold a DECLARATION rather than a name
+ * (`invoke: { kind: …, …config }`), and that declaration exists nowhere but the
+ * site, so it has no array to sit in and no sibling to be moved past. It is a
+ * line of the body because it is a thing the author wrote and has to be able to
+ * reach; see {@link isOrderedRow}.
+ */
+export type RowKind = "step" | "entry" | "target" | "inline" | "reference";
+/**
+ * Rows that are ordered entries of their array.
+ *
+ * A consumer offering reorder, removal or an index must ask — a declaration
+ * written at a dispatch site carries an `index` of 0 and an `array` it shares
+ * with its host, both of which are borrowed so it groups into the right branch,
+ * and neither of which means what it means on a step.
+ */
+export declare function isOrderedRow(row: GraphRow): boolean;
+/** One occupancy of a port: the concrete site, and the name it holds. */
+export interface PortSlot {
+    /** Concrete path of this site (`mounts[1].mount`), the write target. */
+    path: string;
+    /** Referenced resource name, absent for an empty slot. */
+    target?: string;
+    /** Node id the name resolves to, absent when it resolves to nothing. */
+    targetNode?: string;
+    /** The site holds an inline declaration rather than a reference; `targetNode`
+     *  is the extracted child. */
+    inline?: boolean;
+}
+/** A reference slot the kind declares, filled or not. */
+export interface GraphPort {
+    /** Field-map path with `[]` / `{}` markers — the port's identity on its node. */
+    slot: string;
+    /** Accepted `x-telo-ref` constraints, canonicalized. */
+    refs: string[];
+    /** Capabilities a target may satisfy — what validates a wire. */
+    capabilities: string[];
+    /** The slot traverses at least one array, so it takes many targets. */
+    array: boolean;
+    class: EdgeClass;
+    slots: PortSlot[];
+    /** Concrete path a new array item would be written at. Array ports only. */
+    addPath?: string;
+    /** This slot's occupancy is drawn as ROWS rather than as port slots — the
+     *  slot sits inside a step body or an entry list, where order is semantic and
+     *  the row is the thing a reader manipulates. */
+    rowOwned?: boolean;
+}
+/** One ordered entry inside a box. */
+export interface GraphRow {
+    /** Name-anchored identity, stable across insertion of a sibling. */
+    id: string;
+    kind: RowKind;
+    /** What the manifest calls this line: a step's `name:`, or — for a
+     *  `reference` row — the field holding it. Absent where the grammar offers
+     *  neither (an unnamed route, an `inline` row, which is named by its kind). */
+    name?: string;
+    /** Concrete path of the row (`steps[0].do[1]`, `routes[2]`) — the write
+     *  target, and what a position index is keyed by. */
+    path: string;
+    /** Concrete path of the array holding it, the reorder domain. */
+    array: string;
+    /** Lexical index within that array. */
+    index: number;
+    /** Nesting depth: 0 at the body's top level, +1 inside each branch. */
+    depth: number;
+    /** Row id of the enclosing row, when this one nests inside a branch. */
+    parent?: string;
+    /** Referenced name this row dispatches to, when it dispatches. */
+    target?: string;
+    /** Node id of that target, when it resolves. */
+    targetNode?: string;
+    /** JSON Pointer to this call's argument map, when the slot declares one. */
+    inputs?: string;
+    /** The values a matcher-role field holds (`{path: "/orders", method: "POST"}`)
+     *  — what identifies an entry to a reader, and what its content key is
+     *  derived from. Entry rows only. */
+    match?: Record<string, unknown>;
+    /**
+     * What this row IS, in the grammar's own words — `invoke`, `if/then/else`,
+     * `while/do`, `switch/cases/default`, `try/catch/finally`, `throw`, `value`.
+     *
+     * Without it every statement in a body reads alike: a loop and a dispatch are
+     * both a name and an arrow, so a reader has to open the source to find out
+     * which is which. Read off the branch the step matches, so a kind declaring a
+     * body of its own is described in the words its author chose.
+     */
+    variant?: string;
+    /** The branch's title as its author wrote it — a label to render, never to
+     *  parse. See `StepGraphNode.variantLabel`. */
+    variantLabel?: string;
+    /**
+     * The expression deciding whether or how this row runs, as written — an
+     * `if:`, a `while:`, a `switch:`, or a dispatch's `when:` guard.
+     *
+     * A step drawn without it says it is conditional and not on what, which for a
+     * loop is the whole behaviour.
+     */
+    predicate?: string;
+    /** This row declares an error branch — a field the kind annotated
+     *  `x-telo-error-context`, which is where a raised code is discharged. Found
+     *  by the annotation, so a third-party composer's `catches:` is seen too. */
+    catches?: boolean;
+    /**
+     * Where this row's call is WRITTEN, and what may fill it.
+     *
+     * A row is the dispatch site a reader manipulates — a step's `invoke:`, a
+     * route's `handler:`, a boot target — and until now the site was recoverable
+     * only from an edge, so a row dispatching to nothing yet had no address at
+     * all. That is exactly the row an editor has something to offer at: it is
+     * where a reference is written, and where a new resource would be wired in.
+     *
+     * Absent for a row that dispatches nothing by grammar (a pure `value:` step)
+     * and for a declaration row, which IS the thing dispatched to.
+     */
+    dispatch?: {
+        path: string;
+        refs: string[];
+        /** The slot holds a DECLARATION written at the site rather than a reference
+         *  to one elsewhere. A consumer offers different things at the two: nothing
+         *  can be wired into an occupied declaration without destroying it, and a
+         *  declaration is the one thing that can be given a name of its own. */
+        inline?: boolean;
+        /**
+         * The row's OTHER sites — the same call, written a different way, under a
+         * different constraint.
+         *
+         * A boot target is the case that forced it: the entry takes a bare
+         * `!ref` to a `Telo.Runnable | Telo.Service`, and it takes an invoke step
+         * whose `invoke:` takes any `Telo.Executable`. Reporting only the first made
+         * every `Telo.Invocable` in the application unbootable from the editor —
+         * legal in the manifest, and offered nowhere, since a slot with nothing to
+         * put in it reads as an empty module rather than as a missing site.
+         *
+         * Primary first, and a site is listed once per CONSTRAINT: a boot target's
+         * `ref:` accepts exactly what its bare form does, so the two are one site
+         * and the bare spelling wins. Which spelling to write is a choice a reader
+         * should not have to make, and the constraint is the only thing that
+         * changes what may be written at all.
+         */
+        alternatives?: {
+            path: string;
+            refs: string[];
+        }[];
+    };
+    /** `inline` rows: the kind the declaration written at this site names. A
+     *  declaration is not a reference — there is nothing elsewhere to point at,
+     *  which is the whole reason the row has to carry its own identity. */
+    declares?: string;
+    /** That kind resolved to no definition. */
+    unknownKind?: boolean;
+}
+/** A resource, the module root, or a declaration owned by either. */
+export interface GraphNode {
+    /** `<kind>\0<name>` for a module-level resource — the call graph's own id, so
+     *  a consumer holding one can address the other. */
+    id: string;
+    kind: string;
+    name: string;
+    /** Declared capability, absent when the kind does not resolve — an unresolved
+     *  import, a kind with no definition. A view must render it as unknown rather
+     *  than guessing a placement it would have to take back. */
+    capability?: string;
+    /**
+     * `<module>.<Kind>` — what `kind` NAMES, resolved.
+     *
+     * `kind` is the string the author wrote, and it is written in the DECLARING
+     * module's alias scope: a library declares its own instances as
+     * `kind: Self.WriteLine`, and `Self` means that library. Carried into a
+     * flattened application the spelling survives and resolves to nothing there,
+     * so every consumer joining on a kind — does this slot accept it, which
+     * instances does this kind have, what schema does the form use — silently
+     * missed a whole imported library.
+     *
+     * Absent when the kind is already canonical, and when it resolves to nothing
+     * (which `unknownKind` says).
+     */
+    canonicalKind?: string;
+    /** The kind resolved to no definition at all. */
+    unknownKind?: boolean;
+    ownership: NodeOwnership;
+    /** Node that owns this declaration — set for `inline` and `scoped`. */
+    owner?: string;
+    /** Site on the owner that declares it (`/with`, `mounts[0].mount`). */
+    ownerSite?: string;
+    /** Module that declared it, when stamped. */
+    module?: string;
+    /** True when the declaring module is not the entry module — an instance
+     *  reached across an import boundary. */
+    external?: boolean;
+    /** Import alias the entry module reaches it under, when it is external and
+     *  one alias points at its module. What a boundary box is labelled by, and
+     *  what a reference to it is written with. */
+    alias?: string;
+    ports: GraphPort[];
+    rows: GraphRow[];
+    /**
+     * The ordered arrays this kind can hold rows in, whether or not any exist.
+     *
+     * Declared rather than observed, for the same reason a port is: a server with
+     * no mounts still HAS mounts, and a canvas that lists only what is there
+     * offers no way to add the first one. Each is a field name plus what its rows
+     * would be.
+     */
+    rowArrays: {
+        field: string;
+        kind: RowKind;
+    }[];
+    /** What invoking this can raise, resolved along its own call graph — the
+     *  error contract a caller has to render or let escape. `unbounded` means the
+     *  union could not be closed statically, so a catch-all is required. */
+    throws?: {
+        codes: string[];
+        unbounded: boolean;
+    };
+    /** The module root, which owns `targets` and the module's own config. */
+    root?: boolean;
+}
+/** A reference site, classed. */
+export interface GraphEdge {
+    /** Stable within the graph: source, slot and site. */
+    id: string;
+    /** Node id of the declaring resource — never a step, since a step is a ROW of
+     *  its owner here rather than a node. `row` says which row declared it. */
+    from: string;
+    /** Node id of the target, absent when the name resolves to nothing. */
+    to?: string;
+    /** The referenced name as written, always present — a `!ref` to a name that
+     *  does not exist is a real edge some other pass reports, and dropping it
+     *  would make the graph disagree with the manifest about what was written. */
+    toName: string;
+    class: EdgeClass;
+    /** The declared uses at this site, unreduced. */
+    use: RefUse[];
+    /** Field-map path of the slot — part of the edge's identity, so two slots
+     *  naming one target are two edges. */
+    slot: string;
+    /** Concrete path of the site. */
+    path: string;
+    /** Row this edge leaves from, when a row declares it. */
+    row?: string;
+    /** JSON Pointer to this call's argument map, when declared. */
+    inputs?: string;
+    /** The edge is a boot target of the module root: ordered, and the reason the
+     *  target runs at all. */
+    boot?: boolean;
+    /** The target is declared inside the source's own scope. */
+    scoped?: boolean;
+    /** Data edges only: the access chain as written (`resources.db.status.port`),
+     *  so a reader is told WHAT is read rather than only that something is. */
+    read?: string;
+}
+/**
+ * A genuine containment: a set of nodes something else encloses.
+ *
+ * Reference reachability is NOT containment — that mistake is what drew a mount
+ * as a child of its server while the slot said `dependency`. The three that ARE:
+ * an **inline** declaration and a **scope**'s resources exist nowhere but their
+ * owner's YAML, and a **zone** is a region of execution every dispatch inside it
+ * runs within.
+ */
+export interface GraphRegion {
+    id: string;
+    kind: "inline" | "scope" | "zone";
+    /** Node whose declaration encloses the members. */
+    owner: string;
+    /** Site on the owner (`/with`, `invoke`, `steps`). */
+    site: string;
+    /** Node ids inside. */
+    members: string[];
+    /** Zone regions only: what the region GUARANTEES about its contents, as the
+     *  declaring kind wrote it — the attribute name mapped to the author's
+     *  reason, which a consumer quotes rather than paraphrases. */
+    attributes?: Readonly<Record<string, string>>;
+    /** Zone regions only: dispatches inside the region the zone does NOT extend
+     *  through — a detached call, an inbound trigger. Recorded because the site is
+     *  inside the region even though its target is not. */
+    boundaries?: {
+        from: string;
+        toName: string;
+        escaping: string[];
+    }[];
+}
+/**
+ * A kind declaration — the second plane.
+ *
+ * Kept apart from the instance nodes rather than mixed in: a `Telo.Definition`
+ * is a TYPE, and drawing it among the instances would put things that exist at
+ * runtime and things that do not on one surface with nothing separating them.
+ * A module that declares only kinds has this plane and no other, which is why
+ * it is a first-class list rather than a flag on a node.
+ */
+export interface GraphKind {
+    /** Canonical `<module>.<Name>` — what a `kind:` resolves to. */
+    id: string;
+    name: string;
+    module?: string;
+    /** Non-instantiable: the contract has no default implementation. */
+    abstract: boolean;
+    capability?: string;
+    /** Canonical id of the kind this one specializes, when it resolves. */
+    extendsId?: string;
+    /** The `extends` target as WRITTEN, kept when it resolves to nothing — an
+     *  unresolved parent is a fact about the manifest, not a reason to draw the
+     *  kind as having none. */
+    extendsName?: string;
+    /** Ids of the instance nodes declared of this kind — the join between the
+     *  two planes. */
+    instances: string[];
+    /** Declares a body of its own (`resources:` / `invoke:` / `run:` / `provide:`)
+     *  rather than naming a controller — the kind's interior. */
+    template: boolean;
+    /** Declared by the entry module rather than reached through an import. */
+    own: boolean;
+    /** Listed in the entry module's `exports.kinds`, so an importer may construct
+     *  one. Undefined for a kind this module did not declare, whose gate is its
+     *  own library's to state. */
+    exported?: boolean;
+}
+export interface ModuleGraph {
+    /** The module root, when one was supplied. */
+    root?: GraphNode;
+    nodes: GraphNode[];
+    edges: GraphEdge[];
+    regions: GraphRegion[];
+    /** The kind plane — every kind declaration in scope. */
+    kinds: GraphKind[];
+    nodeById(id: string): GraphNode | undefined;
+    edgesFrom(id: string): GraphEdge[];
+    edgesTo(id: string): GraphEdge[];
+}
+/**
+ * A hold whose target is ambient infrastructure — the collapse candidate.
+ *
+ * Stated here rather than in the view because it is the rule the plan fixes,
+ * and two hosts applying it differently would disagree about which edges exist:
+ * a hold into a shared connection or store is fan-in that swamps a layout and
+ * carries no structure, while a hold BETWEEN working resources is the
+ * application's spine — a server holding its mounts — and demoting the second
+ * with the first is exactly the mistake this replaces.
+ */
+/**
+ * Is anything reaching this declaration at all?
+ *
+ * "Declared, referenced by nothing, in no `targets`" — the resource a reader
+ * cannot otherwise tell apart from a wired one, since a manifest states no
+ * difference between the two. Every incoming edge counts, not only flow: a
+ * connection is HELD rather than called, and reading it as unwired would mark
+ * every provider in the module. An owned declaration is reached by its owner,
+ * and the root is what reaches everything else.
+ *
+ * A declaration this module did not write is NEVER unwired, however little it
+ * is used here. An imported library exports what it exports, and the flatten
+ * forwards all of it; "nothing references this" would be a true sentence about
+ * an unused export and a useless one, since the reader cannot act on it — the
+ * declaration is not theirs to remove.
+ */
+export declare function isUnwired(node: GraphNode, graph: ModuleGraph): boolean;
+export declare function isAmbientHold(edge: GraphEdge, graph: ModuleGraph): boolean;
+/**
+ * Capabilities whose resources are AMBIENT: held and read, never run, and never
+ * drawn as the target of a line.
+ *
+ * Exported because the view partitions on the same fact — which boxes go off
+ * the canvas into the drawer — and two spellings of it is how a host ends up
+ * collapsing a hold the other still draws an edge for.
+ */
+export declare const AMBIENT_CAPABILITIES: ReadonlySet<string>;
+/** Is this an ambient declaration — held and read rather than run? */
+export declare function isAmbientCapability(capability: string | undefined): boolean;
+/**
+ * The class a site is drawn as.
+ *
+ * A slot declaring NO use reads as flow, the same conservative direction the
+ * call graph takes: the cost of a false "control reaches here" is an edge drawn
+ * more prominently than it deserved, while the cost of a false "it never does"
+ * is a call the picture denies exists.
+ */
+export declare function edgeClassOf(use: readonly RefUse[]): EdgeClass;
+/** What the projection needs from a registry, as a structural contract — so it
+ *  folds over stubs in tests and over the real registry in a host, and so this
+ *  module imports no registry class. */
+export interface ModuleGraphDeps {
+    /** Every reference slot a resource's kind declares, filled or not. */
+    refFields(resource: ResourceManifest): {
+        path: string;
+        isArray: boolean;
+        refs: string[];
+        capabilities: string[];
+    }[];
+    /** The resource's definition, resolved in its declaring module's scope. */
+    definition(kind: string, module?: string): ResourceDefinition | undefined;
+    /** What invoking this resource can raise. Optional: a host without the
+     *  resolver gets nodes with no error contract rather than a wrong one. */
+    throwsOf?(manifest: ResourceManifest): {
+        codes: string[];
+        unbounded: boolean;
+    } | undefined;
+    /** Import aliases pointing at a module, so a reference written across the
+     *  boundary as `!ref <Alias>.<name>` resolves to the instance it names. The
+     *  call graph resolves bare names only — correct for a name declared here,
+     *  and the reason every cross-module reference otherwise reads as dangling. */
+    aliasesForModule(module: string): string[];
+}
+export interface BuildModuleGraphOptions {
+    /** The module doc (`Telo.Application` / `Telo.Library`), which is not a
+     *  resource but owns `targets` and is the boot root. */
+    root?: ResourceManifest;
+    /** Module name of the entry module, so an instance declared elsewhere is
+     *  marked external rather than being told apart by a heuristic. */
+    entryModule?: string;
+}
+/**
+ * A short, stable key over a value's shape.
+ *
+ * FNV-1a over canonical JSON: what is wanted is that the same written entry
+ * keeps the same identity when a sibling is inserted above it, which a hash of
+ * the entry's own content gives and an index cannot. Collisions are resolved by
+ * declaration order at the call site, so two byte-identical rows stay
+ * distinguishable without either one's identity depending on the other's
+ * position.
+ */
+export declare function contentKey(value: unknown): string;
+/**
+ * Fold a manifest set into the module graph.
+ *
+ * The call graph supplies what calls what — including the scoped nodes and step
+ * bodies it already discovers — and this pass adds what a picture needs and a
+ * call graph has no reason to carry: declared-but-empty ports, ownership,
+ * ordered rows, region membership, and the reduction of six uses to three
+ * classes.
+ */
+export declare function buildModuleGraph(resources: ResourceManifest[], callGraph: CallGraph, deps: ModuleGraphDeps, options?: BuildModuleGraphOptions): ModuleGraph;
+//# sourceMappingURL=module-graph.d.ts.map

package/dist/module-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module-graph.d.ts","sourceRoot":"","sources":["../src/module-graph.ts"],"names":[],"mappings":"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"}