@wairon/cli 5.1.1-dev.109 → 5.1.1-dev.110

package/dist/index.d.ts

@@ -155,6 +155,13 @@ type NamingRuleConfig = z.infer<typeof NamingRuleConfigSchema>;
  * and rename accept the same names. Pure.
  */
 declare function methodCasingFor(naming: Pick<NamingRuleConfig, 'methods'> | undefined, targetLanguage?: string): string;
+/**
+ * Whether a method name fits a casing (methodCasingFor's answer): a known
+ * style, or a configured regular expression on top of the identifier grammar.
+ * An unreadable expression refuses nothing here (the naming rule reports it as
+ * INVALID_NAMING_PATTERN). Pure.
+ */
+declare function fitsMethodCasing(name: string, casing: string): boolean;
 declare const DocumentationRuleConfigSchema: z.ZodObject<{
     /** Minimum character length for description fields */
     minDescriptionLength: z.ZodOptional<z.ZodNumber>;
@@ -2931,7 +2938,7 @@ declare function projectIdentity(config: Pick<ProjectConfig, 'id' | 'name' | 'pr
  * (`.wai/externals/<alias>.yaml`), which no Windows checkout could hold.
  */
 declare const EXTERNAL_ALIAS_RE: RegExp;
-/** Why an alias breaks EXTERNAL_ALIAS_RE, in words: the grammar, or a Windows device name. */
+/** Why an alias breaks EXTERNAL_ALIAS_RE, in words (identifier.problemAs alias): the grammar, a device name, the length, ... */
 declare function aliasGrammarProblem(alias: string): string;
 /**
  * declared_external — one external as the configuration declares it,
@@ -5742,7 +5749,7 @@ declare const PackAssertionSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<
         profile?: string[] | undefined;
         componentType?: string[] | undefined;
     };
-    level: "component" | "interface" | "implementation";
+    level: "interface" | "implementation" | "component";
     values?: string[] | undefined;
 }, {
     code: string;
@@ -5756,7 +5763,7 @@ declare const PackAssertionSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<
     };
     values?: string[] | undefined;
     severity?: "error" | "warning" | undefined;
-    level?: "component" | "interface" | "implementation" | undefined;
+    level?: "interface" | "implementation" | "component" | undefined;
 }>, z.ZodObject<{
     on: z.ZodObject<{
         componentType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -6508,7 +6515,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
             profile?: string[] | undefined;
             componentType?: string[] | undefined;
         };
-        level: "component" | "interface" | "implementation";
+        level: "interface" | "implementation" | "component";
         values?: string[] | undefined;
     }, {
         code: string;
@@ -6522,7 +6529,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
         };
         values?: string[] | undefined;
         severity?: "error" | "warning" | undefined;
-        level?: "component" | "interface" | "implementation" | undefined;
+        level?: "interface" | "implementation" | "component" | undefined;
     }>, z.ZodObject<{
         on: z.ZodObject<{
             componentType: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -6727,7 +6734,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
             profile?: string[] | undefined;
             componentType?: string[] | undefined;
         };
-        level: "component" | "interface" | "implementation";
+        level: "interface" | "implementation" | "component";
         values?: string[] | undefined;
     } | {
         code: string;
@@ -6873,7 +6880,7 @@ declare const DeclarativePackSchema: z.ZodObject<{
         };
         values?: string[] | undefined;
         severity?: "error" | "warning" | undefined;
-        level?: "component" | "interface" | "implementation" | undefined;
+        level?: "interface" | "implementation" | "component" | undefined;
     } | {
         code: string;
         kind: "endpoint-shape";
@@ -7108,12 +7115,6 @@ interface PackDiagnosis {
 declare function defaultPackSelections(): PackSelection[];
 /** Diagnose this project's pack situation for `wairon doctor`. Never throws. */
 declare function diagnoseProjectPacks(): PackDiagnosis;
-/**
- * Convert the implicitly-applied global packs into EXPLICIT selections and turn
- * global auto-load off, so this project's doctrine survives a change of default
- * and is visible in a diff. Returns the names recorded.
- */
-declare function pinInstalledPacksAsSelections(): string[];
 /**
  * A stable human label for a config pack entry — the path for a legacy ref, or
  * `name[@version]` for a selection. For messages and listings, never for loading.
@@ -7388,407 +7389,1204 @@ interface CandidateOptions {
  */
 declare function validateComponentCandidate(candidate: ComponentSpec, opts?: CandidateOptions): CandidateVerdict;
 
+/** type_dialect — one language's reading and writing of the neutral grammar. */
+interface TypeDialect {
+    /** The language this dialect reads and writes, as the code analyzer names it. */
+    language: string;
+    /** The canonical expression a code annotation spells, or null when it has no canonical reading. */
+    read(annotation: string): TypeExpression | null;
+    /** Whether a code annotation and a canonical spec expression describe the same type. */
+    agrees(annotation: string, expression: TypeExpression, codeNames: Map<string, string>): boolean;
+    /** This language's idiomatic spelling of a canonical expression. */
+    write(expression: TypeExpression): string;
+    /** The write table as lines an implementer brief carries. */
+    mappingLines(): string[];
+}
+/** type_dialect.forLanguage — the dialect shipped for a language, or null when none reads it yet. */
+declare function typeDialectFor(language: string): TypeDialect | null;
+/**
+ * type_dialect.mappingFor — the write table an implementer brief carries for
+ * a language: a shipped dialect's mappingLines, else a MAPPING-ONLY table for
+ * a language no analyzer reads yet (Rust, Python), whose last line says that
+ * code conformance does not compare its types. Null for a language with
+ * neither.
+ */
+declare function typeMappingFor(language: string): string[] | null;
+
+type AnalysisGrade = 'exact' | 'pattern' | 'generic';
+type SourceFileStatus = 'analyzed' | 'missing' | 'escaped' | 'unreadable';
 /**
- * The tests that encode one method a write just changed or deleted
- * (tests_to_revisit).
+ * One runtime (value) import binding a file makes: the module specifier a
+ * local name came from, and whether it was bound as a whole NAMESPACE.
  *
- * Two lists rather than one because the two ways of finding them fail in
- * OPPOSITE directions, and merging them would hide which is which — see the
- * measurement above.
+ * The namespace flag separates the two readings of `x.save()`. For a namespace
+ * import (`import * as specs from './specs.js'`), `specs.save` IS that
+ * module's own export, so the call site resolves to the module. For a named or
+ * default binding, `db.save` is a property of a VALUE that module handed over,
+ * and where that property's function was written is beyond a pure model — so
+ * it resolves to nothing rather than to the module.
+ *
+ * Type-only imports are never recorded: a type binding cannot be a call origin.
  */
-interface TestsToRevisit {
-    /** The contract method the write changed or deleted. */
-    method: string;
-    /** The code-level name searched for: the method's `symbol` when it declares one, else its name. */
-    symbol: string;
+/**
+ * One name a file republishes from another module (source_file_facts
+ * reexportBindings): `export { local as exported } from 'from'`, or a star
+ * re-export, which republishes every name its module exports under that same
+ * name and is written with `*` on both sides.
+ */
+interface ReexportBindingFact {
+    /** The name this file publishes it under; `*` for a star re-export. */
+    exported: string;
+    /** The name the module it comes from publishes it under; `*` for a star re-export. */
+    local: string;
+    /** The module specifier, exactly as written. */
+    from: string;
+}
+/**
+ * One name a file publishes BOUND to another name of its own scope, with no
+ * module specifier of its own (source_file_facts exportAliases): an export
+ * specifier `export { local as exported }`, renamed or not, or an
+ * identifier-valued property of an exported top-level object literal —
+ * `{ exported: local }` or the shorthand `{ exported }` — which then carries
+ * the object's binding name as its `container`. The local name is this file's
+ * own declaration, or an import binding that leads on to the module it came
+ * from: either way the forwarding is written down, one hop away.
+ */
+interface ExportAliasFact {
+    /** The name this file publishes: the export specifier's exported name, or the object property's key. */
+    exported: string;
+    /** The name of this file's own scope it is bound to: a local declaration, or an import binding. */
+    local: string;
+    /** The exported object literal's binding name, set only for a property alias — what an `exportedVia` handle names. */
+    container?: string;
+}
+interface ImportBindingFact {
+    /** The module specifier the binding came from, exactly as written. */
+    from: string;
+    /** True for `import * as name from …` — the only binding whose property calls are that module's own exports. */
+    namespace?: boolean;
+    /** The name the module publishes it under, set only when the import renamed it (`import { save as store }`). */
+    imported?: string;
+}
+/**
+ * One call SITE SHAPE inside a named function-like: the invoked name together
+ * with how the call was written. Shape is what a pure model can honestly say
+ * about a call's ORIGIN — with no type checker, `save(x)`, `ledger.save(x)`,
+ * `this.store.save(x)` and `new Ledger(db).save(x)` are four different
+ * questions, and collapsing them onto the name "save" is what let a call into
+ * an unrelated module count as realizing a narrative step.
+ *
+ * Sites are deduplicated per shape, never counted: the checks that read them
+ * ask where a call could land, never how often it was written.
+ */
+interface CallSiteFact {
+    /** The invoked name: the identifier of a bare call, the property name of a member call. */
+    name: string;
+    /** True when the call was written as a member access (`receiver.name(…)`). */
+    member: boolean;
     /**
-     * Test files that IMPORT that symbol — from the method's own source file, or
-     * from a module re-exporting it from there, when that file is known. The
-     * high-confidence list.
+     * The receiver identifier — set only when the receiver is a plain identifier
+     * (`specs.save()` → "specs"). The one receiver that can be PROVEN, when the
+     * name is a namespace import binding and its properties are that module's
+     * own exports — and otherwise a receiver to follow past the value it holds,
+     * through the type the file ANNOTATES the name with.
      */
-    imported: string[];
+    via?: string;
     /**
-     * Test files that name the symbol without importing it — usually a test
-     * driving the method through a portal or a helper. A file that binds the
-     * name to ANOTHER module is not here: the name in it is that module's.
-     * Empty when `indiscriminate` is true.
+     * The instance FIELD the receiver is — set only when the call was written
+     * `this.<field>.name(…)` (`this.store.save()` → "store"), and never together
+     * with `via`. A receiver a pure model can follow past the value it holds,
+     * because the class DECLARES what the field is; what that type resolves to
+     * is a POSSIBLE origin, never a proven one, since the declared type says
+     * what a collaborator is and not which class ships the body.
      */
-    mentioned: string[];
+    field?: string;
     /**
-     * True when the bare name matched more than a tenth of the walked test files,
-     * so mentioning it carries no signal and `mentioned` was withheld.
+     * The CLASS the receiver was constructed from — set only when the call was
+     * written `new Class(…).name(…)` (`new ApprovalRegistry(store).create()` →
+     * "ApprovalRegistry"), and never together with `via` or `field`. Another
+     * receiver a pure model can follow, because the code NAMES the class it
+     * built. Like a declared field type it is a POSSIBLE origin and never a
+     * proven one: a method the class INHERITS is written in its base's module,
+     * not in the constructed class's.
      */
-    indiscriminate: boolean;
+    constructed?: string;
+    /**
+     * The function whose RESULT the receiver is — set only when the call was
+     * written `fn(…).name(…)` with `fn` a plain identifier
+     * (`current().updateSpec()` → "current"), and never together with `via`,
+     * `field` or `constructed`. Followed through what the code writes down
+     * about fn's result (SourceFileFacts.returnTypes): a POSSIBLE origin and
+     * never a proven one, and only where the module that type leads to holds a
+     * body under the invoked name.
+     */
+    returnedBy?: string;
+    /**
+     * The top-level named class whose own method the call sits in — set only
+     * when the call was written `this.name(…)` directly inside a method,
+     * accessor or constructor of that class (an arrow function keeps `this`; a
+     * nested function expression rebinds it and records nothing). A POSSIBLE
+     * origin and never a proven one, since a subclass may override the method,
+     * and only where the class holds a body under the invoked name.
+     */
+    enclosingClass?: string;
+    /**
+     * The receiver written as a CHAIN of property accesses — set only when the
+     * call was written `this.<field>.<property>….name(…)`
+     * (`this.c.tracker.checkIn()` → ["this", "c", "tracker"]) or
+     * `<name>.<property>….name(…)` (`deps.tracker.checkIn()` → ["deps",
+     * "tracker"]), and never together with `via`, `field`, `constructed`,
+     * `returnedBy` or `enclosingClass`. The shape constructor-injected
+     * collaborators take when they arrive as ONE bag object. Followed link by
+     * link through what the code DECLARES each link to be — the root's field
+     * or annotated type, then each property's declared type on the shape that
+     * declares it — and, like every receiver past an import binding, a
+     * POSSIBLE origin and never a proven one.
+     */
+    receiverPath?: string[];
+    /**
+     * The file this site was READ in, set only when it is not the file these
+     * facts describe — a pure re-export barrel carries the sites of the function
+     * it publishes. A carried site's bare names and receivers resolve in that
+     * file's scope, never in the barrel's.
+     */
+    from?: string;
 }
-
 /**
- * ispec_validator/ivalidator_portal.findTestsReferencing — the tests that
- * encode a given set of methods, so a write that changes or deletes one can
- * say which tests it just invalidated.
+ * One function-like BODY under its name, with where it is bound — the
+ * identity that tells same-named functions in one file apart.
  *
- * The walk itself belongs to the source analyzer, which already owns this
- * subsystem's only source-code I/O and the containment rules a root is held
- * to. A project that declares no test roots answers empty rather than
- * throwing: naming the tests must never be the thing that fails a write.
+ *   module     (no `container`, no `nested`) a top-level function declaration,
+ *              or a function/arrow initializer of a top-level variable: what
+ *              the bare name means anywhere in the module's scope.
+ *   member     `container` set: a member of a top-level named class, or a
+ *              property of an object literal a top-level variable is bound to
+ *              (`const store = { save() {} }` → container "store"). Reachable
+ *              only through that container, never by the bare name.
+ *   nested     `nested` set: any other binding — a function inside a
+ *              function, a member of a class or object literal the model
+ *              cannot name. A nested body can shadow the bare name in the
+ *              scope it sits in, so where one exists the name stays ambiguous.
  */
-declare function findTestsReferencing(methods: ReadonlyArray<Pick<MethodImplementation, 'name' | 'symbol'>>, projectRoot: string, testRoots: readonly string[]): TestsToRevisit[];
-interface ValidationIssue {
+interface FunctionBodyFact {
+    /** The named class or top-level object literal the body is a member of. */
+    container?: string;
+    /** True when the body is bound somewhere the model cannot name. */
+    nested?: boolean;
+    /** The call sites written inside this body alone. */
+    sites: CallSiteFact[];
+}
+/**
+ * One data member of a shape a file declares: its name, and whether the code
+ * lets it be ABSENT.
+ *
+ * Absent-able is the only optionality worth recording, because it is the only
+ * one a spec can be wrong about in a way a reader would notice — a field the
+ * spec calls required that the code lets you omit is a promise the data does
+ * not keep. A wrapper that FILLS a missing key is not absent-able: the value
+ * the type finally holds always has it, which is the shape the spec describes.
+ */
+interface ShapeMemberFact {
+    /** The member's name, as the code spells it. */
+    name: string;
+    /** Whether the code lets the member be absent from a value of this shape. */
+    optional: boolean;
+}
+/**
+ * One parameter of a function as the code declares it: what it is called, what
+ * it is annotated with, and whether a caller may leave it out.
+ *
+ * The TYPE is what makes a RENAME tellable from a dropped parameter —
+ * `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)`
+ * is one parameter under two names, and matching on names alone reads it as a
+ * parameter the code lost. A parameter bound by destructuring has no name to
+ * compare, so it records none rather than inventing one: a guess about
+ * somebody's signature is worse than silence, exactly as it is for a field.
+ */
+interface ParameterFact {
+    /** The parameter's name, absent when it is bound by a destructuring pattern instead. */
+    name?: string;
+    /** The type it is annotated with, exactly as written and whitespace-normalized; absent when the code annotates nothing. */
+    type?: string;
+    /** Whether a caller may leave it out — marked optional, given a default, or a rest parameter. */
+    optional: boolean;
+}
+/**
+ * One route a router function handles, rebuilt from the conditions that guard
+ * the branch serving it — the branch's own AND every enclosing one on the path
+ * taken, because routers nest: an outer check on the first segment, an inner
+ * one on the rest. Reading only the innermost guard would turn every route
+ * into `/*` followed by whatever the inner branch happened to check.
+ *
+ * A segment is the literal the code compares it to, or `*` where nothing
+ * constrains it. A leading `*` is usually the segment the listener's mount
+ * already guarantees, which the router never re-checks — so it is left open
+ * here and completed by whoever knows the mount.
+ *
+ * Only one idiom is read: a method comparison together with comparisons on the
+ * path's split segments and their count. A router written another way yields
+ * nothing, and the reader reports that as unread rather than passing it — a
+ * check that cannot see a router must say so rather than stay quiet.
+ */
+interface RouteFact {
+    /** The HTTP method the branch requires. */
+    verb: string;
+    /** The path's segments in order: the literal compared against, or `*` where nothing constrains it. */
+    segments: string[];
     /**
-     * After project and profile overrides. A `notice` is reported like any other
-     * finding but never makes a result invalid (`valid` counts errors only) and
-     * never fails `--ci`.
+     * Whether the branch pins the number of segments. When it does not, the path
+     * may continue past the last one read, so the route covers any longer path
+     * with the same leading segments.
      */
-    severity: IssueSeverity;
-    code: string;
-    message: string;
-    /** Optional: agent id related to the issue */
-    agentId?: string;
-    specId?: string;
+    exactLength: boolean;
+}
+/** How a type shape's members were read: listed by the shape itself, or followed one hop from an alias to the value its shape comes from. */
+type ShapeOrigin = 'declared' | 'derived';
+/**
+ * The members of one named shape a file declares — what a data type IS, read
+ * off the code so a type spec's claim about it can be checked.
+ *
+ * Two origins answer, and the difference is recorded rather than smoothed
+ * away. A DECLARED shape lists its own members, so the file is the whole
+ * answer. A DERIVED one names a VALUE instead — an alias resolved one hop to
+ * the object literal its schema is built from, where the keys are the members
+ * — so the answer is as good as that hop and no better, and a hop that lands
+ * on nothing readable records no shape at all. Silence, not a guess: a wrong
+ * member list is worse than none, because nothing downstream would correct it.
+ *
+ * Methods are kept apart from fields because a spec models them on a different
+ * axis — the one `typeRealization` already judges. Counting a behavioural
+ * interface's method signatures as data would accuse every one of them of
+ * carrying undeclared state.
+ */
+interface TypeShapeFact {
+    /** How the members were read. */
+    origin: ShapeOrigin;
+    /** The data members, each with whether the code lets it be absent. */
+    fields: ShapeMemberFact[];
+    /** The method-style members, kept on the axis a spec models them on. */
+    methods: string[];
     /**
-     * True when this issue was raised in a draft/design context — i.e. the spec
-     * it concerns (or an ancestor) is not yet complete. Rules that already know
-     * this (e.g. DRAFT_COMPONENT_WARNING, UNUSED_COMPONENT on a draft component)
-     * surface it so downstream policy — like the --ci gate — can waive warnings
-     * that merely reflect declared, unfinished work without silencing the rule.
+     * True when the shape EXTENDS another, so members it does not list exist
+     * but are not in this file to count. Presence and absence are therefore
+     * different questions for it: what it shows can be judged, what it omits
+     * cannot.
      */
-    draftContext?: boolean;
+    inherited?: boolean;
+}
+interface SourceFileFacts {
+    /** Project-relative resolved source path (many implementations may share it, N:1). */
+    path: string;
+    status: SourceFileStatus;
+    /** Effective language the file was analyzed as. */
+    language?: string;
+    analysisGrade?: AnalysisGrade;
     /**
-     * On a finding about a cross-project reference: how the owner's gate
-     * resolved it (outcome, owner, call site, canonical target, input digest,
-     * reason), decided before the severity.
+     * Declaration-tier anchors: named declarations at any nesting depth,
+     * destructuring bindings, object-literal keys, import bindings, and export
+     * specifiers (export-* barrels chased through relative specifiers).
      */
-    resolution?: ReferenceResolution;
+    declaredNames: string[];
+    /** Weaker anchors: exact string-literal occurrences (tool/route registrations). */
+    anchoredNames: string[];
+    /** Exported bindings (Level 2 dependency-conformance and UNDECLARED_EXPORT fuel). */
+    exportedNames: string[];
     /**
-     * In a family run: the key of the project whose gate (or whose external,
-     * for a composition finding) the finding belongs to — '' for the family
-     * root. Absent on the owner's own run.
+     * Runtime import/require module specifiers (dependency-conformance fuel).
+     * Type-only imports and export-from specifiers are excluded — type coupling
+     * is allowed by default, and re-exporting is surface republication, not
+     * collaboration.
      */
-    project?: string;
+    imports: string[];
+    /** Module specifiers of export-from declarations (surface republication). */
+    reexports: string[];
     /**
-     * True on a finding reported beside a gate rather than by it — the live
-     * comparison of an external with its producer (family_validator.advise).
-     * Printed and counted with its severity, but never part of a failure
-     * decision: `valid` and `validate --ci` both ignore it, because the pin is
-     * the reproducible gate and a live producer is not.
+     * What each export-from declaration republishes, name by name: a named one
+     * with both sides of its rename (`export { a as b } from 'm'` publishes `b`
+     * as m's `a`), a star with `*` on both sides. Runtime re-exports only — a
+     * type-only one republishes no function. EXACT grade only: it is what lets a
+     * reader follow a republished name to the module that wrote it, and a
+     * weaker grade leaves it unset rather than guess.
      */
-    advisory?: boolean;
-}
-interface ValidationResult {
-    valid: boolean;
-    issues: ValidationIssue[];
+    reexportBindings?: ReexportBindingFact[];
     /**
-     * One line, never a finding. The owner's gate: present when the project
-     * declares externals, saying they were judged against their pins and the
-     * advisory live comparison reads their live producers. A family run: present when externals were left out
-     * because their producers lie outside the run's reach.
+     * The forwarding bindings the file publishes with no module specifier of
+     * its own (see ExportAliasFact): each runtime `export { local as exported }`
+     * specifier, renamed or not, and each identifier-valued property of an
+     * exported top-level object literal, under that object's binding name.
+     * EXACT grade only. The analyzer carries the local name's body onto the
+     * published one when the local name settles on exactly one — a module-scope
+     * body of this file with no nested same-named one, or an import binding
+     * whose module holds one — and leaves the published name bodiless otherwise.
      */
-    hint?: string;
+    exportAliases?: ExportAliasFact[];
     /**
-     * A family run only: one line per selected project (the root first, then its
-     * members in scan order) with its own gate's totals. Absent on the owner's
-     * gate.
+     * The type name each named function-like RETURNS, by function name,
+     * recorded only where the code settles it: a return annotation naming a
+     * type outright (`Promise<T>` unwrapped), else, unannotated, a body whose
+     * ONE return statement constructs a plainly named class. Same-named
+     * functions that disagree, a generic, union or literal annotation, and
+     * several returns record nothing. EXACT grade only. What a `fn().method()`
+     * receiver is followed through.
      */
-    projects?: ProjectVerdict[];
+    returnTypes?: Record<string, string>;
     /**
-     * The as-complete run only (validateAsComplete): the code-conformance half
-     * summarized with the analyzer that produced it. Absent on the owner's gate
-     * and on a family run.
+     * Cyclomatic complexity per named function-like (function/method/accessor
+     * declarations, and function/arrow initializers of named slots). EXACT grade
+     * only — lower grades omit the map rather than guess. Same-named functions
+     * in one file record their maximum. Fuel for the detail-sufficiency lint.
      */
-    analysis?: CodeAnalysis;
+    functionComplexity?: Record<string, number>;
     /**
-     * A family run only: the aliases of the bound project's externals the run
-     * composed as part of its gate (their producers in reach) — the advisory
-     * live comparison skips them, so they get no second word.
+     * Direct call sites per named function-like: every call written inside the
+     * function body, with its shape (see CallSiteFact) — nested NAMED functions
+     * excluded (they carry their own entries), anonymous callbacks included.
+     * EXACT grade only. Same-named functions union their sites.
+     *
+     * A function-like WITH A BODY always gets an entry, empty when it calls
+     * nothing; a name with NO entry has no body in this file to read — a bare
+     * declaration, an overload signature, an ambient declaration, an interface
+     * member, a plain value binding or an imported name. That difference is the
+     * whole of hasFunctionBody, which is why an empty entry is never dropped.
+     *
+     * Fuel for the call-step realization checks (Level 3).
      */
-    composed?: string[];
-}
-/**
- * project_verdict — one project's line in a family run: which project it is,
- * where it lives, and the totals of its own gate's verdict, which the family
- * run carries verbatim under the project's key.
- */
-interface ProjectVerdict {
-    /** The project's key in the family root's scan ('' for the root itself). */
-    key: string;
-    /** The project's effective id. */
-    id?: string;
-    /** The project's root directory. */
-    directory: string;
-    /** Whether its own gate found no error. */
-    valid: boolean;
-    errors: number;
-    warnings: number;
-    notices: number;
-}
-declare function validateRegistry(registry: Registry, rules: RulesConfig): ValidationResult;
-declare function validateProjectConfig(config: ProjectConfig): ValidationResult;
-interface ValidationOptions {
-    rules?: RulesConfig;
-    projectType?: string;
-    scopeSubsystem?: string;
+    functionCallSites?: Record<string, CallSiteFact[]>;
     /**
-     * At a project that declares members: how many member levels the run
-     * reaches. Absent, every level (the family run); 0, the owner's gate alone;
-     * n, the family run selecting that many levels.
+     * The same call sites, BODY by body, under each function-like's name: one
+     * entry per body, carrying WHERE that body is bound (see FunctionBodyFact).
+     * EXACT grade only. Where functionCallSites unions every same-named body,
+     * this keeps them apart, so an exported facade `save` and the class member
+     * `Workspace.save` it forwards to are read as the two functions they are.
+     * Which body a NAME means is bodySitesOf's question, and it answers only
+     * where the code itself settles it.
      */
-    memberDepth?: number;
+    functionBodies?: Record<string, FunctionBodyFact[]>;
     /**
-     * Pre-loaded extension packs (the programmatic-wrapper path). When omitted,
-     * the packs declared in the project's own config are loaded — so CLI and
-     * MCP callers get pack rules/profiles/languages without passing anything.
+     * Runtime (value) import bindings by local name (see ImportBindingFact).
+     * EXACT grade only — a weaker grade sees module specifiers but never which
+     * local name they bound.
      */
-    extensions?: LoadedExtensions;
+    importBindings?: Record<string, ImportBindingFact>;
     /**
-     * Validate at FULL strictness: treat every spec as `complete`, so the
-     * completeness rules that relax to warnings while draft/design apply as
-     * errors. This is the as-complete gate behind `wairon lock`. The flip must
-     * happen INSIDE the validation run — clearLoaderIssues() invalidates the
-     * spec cache, so any status mutation done before calling in is lost to the
-     * rescan (statuses are restored before returning, so the flip is never
-     * observable to later callers).
+     * The type names an instance FIELD is DECLARED with, by field name — read
+     * off class property declarations and constructor parameter properties,
+     * which is where a constructor-injected collaborator says what it is.
+     * EXACT grade only.
+     *
+     * Same-named fields of different classes in one file keep EVERY declared
+     * type: the file cannot say which class a call site's `this` was, and a
+     * wider answer only ever widens what a call may have reached. A field with
+     * no annotation records nothing — what an initializer INFERS is not what
+     * the code declares, and a guess is not a fact.
      */
-    treatAllAsComplete?: boolean;
+    fieldTypes?: Record<string, string[]>;
     /**
-     * Ask for the family run explicitly (`validate --family`, MCP `family:
-     * true`). Omitted, a project that declares members runs its family and any
-     * other project runs its owner's gate (validation_options.selectsFamily).
+     * The type names a LOCALLY BOUND name is DECLARED with, by name — read off
+     * function and method parameters and off variable declarations that carry
+     * an annotation, which is where a module that wires its collaborators as
+     * closures writes down what each one is. EXACT grade only.
+     *
+     * Keyed by name across the WHOLE file, as `fieldTypes` is: the facts cannot
+     * say which function a call site sits in, and a receiver is as often a
+     * parameter of an ENCLOSING function as of the one that calls it — a
+     * closure captures it, which is the shape this records at all. Same-named
+     * bindings therefore keep EVERY declared type, and a wider answer only ever
+     * widens what a call may have reached. A binding the file annotates with
+     * nothing records nothing, and so does one annotated with anything but a
+     * plain type reference or a member-preserving utility (`Pick`, `Omit`,
+     * `Partial`, `Required`, `Readonly`) around one, which names the type it
+     * wraps: what an initializer INFERS is not what the code
+     * declares, and a guess is not a fact.
      */
-    family?: boolean;
+    localTypes?: Record<string, string[]>;
     /**
-     * The by-name pack selections the pack rules judge. Omitted, the project's
-     * own stored selections are read. Given only by a dry run that judges a
-     * candidate configuration it has not written (pack_impact.measure), together
-     * with that candidate's rules, projectType and loaded extensions.
-     */
-    packSelections?: PackSelection[];
-}
-/**
- * The active conformance rule set — the built-in rules plus the loaded
- * programmatic pack rules, in run order — for `wairon rules list`. Loads and
- * registers the governing packs, then reads the composed sequence.
+     * The module specifier each TYPE-ONLY import binding came from, by local
+     * name. EXACT grade only.
+     *
+     * The half of the import list `importBindings` deliberately leaves out,
+     * because a type binding can never be a call ORIGIN — and exactly what a
+     * declared field type is resolved through, which is why it is kept apart
+     * rather than folded in.
+     */
+    typeOnlyBindings?: Record<string, string>;
+    /**
+     * The type names each PROPERTY of a named shape the file declares is
+     * DECLARED with, keyed `<shape>.<property>` — an interface's or a type
+     * literal alias's property signatures, and a class's property declarations
+     * and constructor parameter properties. EXACT grade only.
+     *
+     * What a receiver CHAIN (`CallSiteFact.receiverPath`) is followed through:
+     * a bag of collaborators handed to a constructor names each one's type
+     * exactly here. Read the way `fieldTypes` is, and a property annotated with
+     * anything else records nothing.
+     */
+    memberTypes?: Record<string, string[]>;
+    /**
+     * The ONE type each type alias NAMES outright, by alias name —
+     * `type Contract = Pick<HabitRepository, 'find'>` names HabitRepository,
+     * `type Store = SpecStore` names SpecStore. EXACT grade only. Read the way
+     * `fieldTypes` is, so a union, an intersection, a literal or any other
+     * generic names nothing. The one hop a declared type is followed through
+     * when it is an alias of this file.
+     */
+    aliasTargets?: Record<string, string>;
+    /**
+     * The interface names each named class's `implements` clause writes, by
+     * class name; exact grade only. What lets a receiver whose declared type is
+     * an interface written in a shared contracts file be followed to the class
+     * that implements it, wherever that class lives — a possible origin, never
+     * a proven one, like every declared type.
+     */
+    implementsClauses?: Record<string, string[]>;
+    /**
+     * The members of each named shape the file declares, by declaration name
+     * (see TypeShapeFact). EXACT grade only — below it a member list cannot be
+     * told from a mention, and a guess about somebody's data model is worse
+     * than silence.
+     *
+     * What lets a type spec's `fields` be CHECKED rather than read as truth by
+     * the ERD, the briefs and every implementer. A wrong method signature
+     * eventually breaks at a call site; a type spec that lies about its data is
+     * only ever read by humans and agents, so nothing corrects it until
+     * somebody measures it against the code.
+     */
+    typeShapes?: Record<string, TypeShapeFact>;
+    /**
+     * The parameter lists of each named function-like in the file, by name (see
+     * ParameterFact) — what lets a contract's declared `params` be checked
+     * against the signature that realizes them, the last of the three
+     * code-to-spec readings nothing had ever made. EXACT grade only: below it a
+     * parameter list cannot be told from a call.
+     *
+     * EVERY body under a name is kept, not the first: a file routinely holds a
+     * class member and the module-level facade that forwards to it under one
+     * name, with different parameters, and picking one silently drops the
+     * other's leading argument from view. Same-named bodies therefore keep every
+     * candidate, exactly as the field-type facts do, and a reader accuses only
+     * what all of them agree on.
+     *
+     * Overloads record the IMPLEMENTATION signature, the one with a body,
+     * because that is the one a caller actually reaches — and a name with no
+     * entry at all has no signature here to read, which is the silence a
+     * forwarding file owes: that the body is not here is already
+     * `methodRealization`'s finding.
+     */
+    functionParams?: Record<string, ParameterFact[][]>;
+    /**
+     * The routes each named function-like in the file handles, by name (see
+     * RouteFact) — what lets a listener's mount be read against the contract
+     * endpoints of the portal it serves, so a route the router answers that no
+     * contract declares cannot go unnoticed again. EXACT grade only: reading a
+     * guard as a route needs the conditions as expressions, not as text.
+     *
+     * A function with no recognisable route records NO entry rather than an
+     * empty one — an empty guess would read as "a router with no routes", and
+     * the reader needs to tell a router it could not read from one it read.
+     * Same-named bodies union their routes; nested NAMED functions carry their
+     * own entries, while anonymous callbacks count into the enclosing one.
+     */
+    functionRoutes?: Record<string, RouteFact[]>;
+    /**
+     * The named function-likes in the file that complete LATER — declared
+     * `async`, or annotated to return a Promise — listed once per such BODY, in
+     * the order the bodies are met, exactly as `functionParams` keeps one
+     * signature per body. A name with several bodies (a class member and the
+     * module-level facade forwarding to it) is therefore judged on what they ALL
+     * say: as many entries as signatures is every body, none is no body. What
+     * ASYNC_MISMATCH compares a contract method's `async` returns with. EXACT
+     * grade only: below it a body cannot be told from a call.
+     */
+    asyncFunctions?: string[];
+    /**
+     * The values of each ENUM-LIKE declaration in the file, by declaration name,
+     * in declared order: a string-literal union alias (`type E = 'a' | 'b'`),
+     * the string array a `z.enum([...])` constant holds — an alias
+     * `z.infer<typeof X>` followed one hop, as a derived shape is — or a string
+     * enum's member values. What UNREALIZED_ENUM_VALUE and UNDECLARED_ENUM_VALUE
+     * read. EXACT grade only; a union mixing in anything but string literals is
+     * not enum-like and is left out.
+     */
+    enumValues?: Record<string, string[]>;
+    /**
+     * The right side of each TYPE ALIAS the file declares, as written, by alias
+     * name — every alias whose right side is not an object shape
+     * (`type PackPath = string`). What a named scalar's holds is compared with
+     * through the file's dialect (TYPE_HOLDS_MISMATCH). EXACT grade only.
+     */
+    aliasTypes?: Record<string, string>;
+    /**
+     * Module-scope mutable bindings (`let`/`var` at the top level of the file).
+     * EXACT grade only. The static approximation of held state a logic
+     * component may be hiding — fuel for the HIDDEN_STATE lint. (Mutation of
+     * const-bound containers is invisible to this collection; the lint says so.)
+     */
+    topLevelMutableBindings?: string[];
+    /**
+     * True when the file declared nothing of its own and only re-exported —
+     * a pure re-export barrel, which has no code to claim. Measured BEFORE the
+     * barrel chase folds the republished names into `declaredNames`, since
+     * after it a barrel is indistinguishable from the files it publishes.
+     * EXACT grade only: a weaker grade cannot tell a barrel from a file it
+     * failed to parse, so it leaves this unset rather than guess.
+     */
+    reexportOnly?: boolean;
+    /**
+     * Every call expression of the file as the TypeScript type checker resolved
+     * it (see ResolvedCallFact), in source order. EXACT grade only, and only
+     * where a compiler with a type checker was loaded. What the Portal
+     * write-shortcut twin and the unnarrated-write check read first: the
+     * checker follows every spelling of a receiver to the declaration, where
+     * the shape facts follow the spellings they know.
+     */
+    resolvedCalls?: ResolvedCallFact[];
+}
+/**
+ * One place a call the type checker resolved can land in THIS project's code:
+ * the file holding the declaration (or an implementor of it), the class,
+ * interface or shape it is a member of, and the member's name. A declaration
+ * in a dependency's typings or the language's own library is no target — it
+ * is nobody's component.
  */
-declare function listRules(): SddRule[];
+interface CallTargetFact {
+    /** Canonical project-relative path of the file holding the declaration or implementor. */
+    path: string;
+    /** The class, interface or named shape the member belongs to; absent for a module-level function. */
+    container?: string;
+    /** The declared name of the method or function the call reaches. */
+    member: string;
+    /**
+     * `declaration` when the checker named this declaration itself;
+     * `implementor` when the declaration sits in an interface or type shape and
+     * this is a class of the project that realizes it.
+     */
+    via: 'declaration' | 'implementor';
+}
 /**
- * ispec_validator/ivalidator_portal.validateProject — the owner's gate (stage
- * 4): judge the bound project from its own files alone — its specs, its
- * configuration and doctrine, its code, its lock, its externals lock and
- * pinned snapshots, and the export tables of the members it contains — and
- * nothing else. It never walks up to a parent, never reads a sibling's live
- * tree and discovers nothing, so a project's verdict is the same from every
- * root and with or without its family on disk. A contained member's own specs
- * are never judged here: its gate judges them under its own configuration.
+ * One call expression of a file as the TypeScript type checker resolved it:
+ * what was invoked, how it was written, which body it sits in, and every
+ * place in this project it can land. Where CallSiteFact records the SHAPE a
+ * pure model can follow, this records the checker's answer — so a receiver
+ * reached through an alias, a field chain, an element access, a destructured
+ * method, a factory's result, a barrel or a port interface lands where the
+ * checker says it lands, whatever its spelling.
  */
-declare function validateProject(rulesOrOptions?: RulesConfig | ValidationOptions, projectType?: string): ValidationResult;
+interface ResolvedCallFact {
+    /** The invoked name: the declared member a target names, else the name as written. */
+    name: string;
+    /** The callee as written, whitespace-collapsed and shortened — what a finding quotes. */
+    written: string;
+    /** The innermost named function-like the call sits in; absent at module scope. */
+    enclosing?: string;
+    /** The top-level class or object literal whose member that function-like is, when it is one. */
+    enclosingContainer?: string;
+    /** Every place in this project's own code the call can land; empty for a call into a dependency or the language library. */
+    targets: CallTargetFact[];
+    /**
+     * True when the call lands nowhere this analysis can name and the CODE made
+     * it so: the checker resolved the callee to no declaration because its
+     * receiver (or the callee itself) is typed any, unknown or not at all; or
+     * the call reaches no declaration of this project because its member is
+     * chosen by a computed key that names no single member, or its receiver is
+     * cast to an index-signature type — neither a landing nor its absence means
+     * anything.
+     */
+    unresolved?: boolean;
+    /**
+     * For an unresolved call, where its receiver's ORIGINAL type lands — the
+     * expression with every cast, assertion, non-null mark and parenthesis
+     * taken off: each project class that type is, or that realizes the
+     * interface or shape it is, as a target whose member is the call's name
+     * (empty when a computed key names none). What tells a cast that hid a data
+     * component from a receiver that never was one.
+     */
+    receivers?: CallTargetFact[];
+    /**
+     * True when this is no call but a REFERENCE to a function or method of this
+     * project the code takes as a value at this site — passes as an argument,
+     * assigns, returns, binds, or hands to Reflect.apply — rather than invoking
+     * it where it is written. A use all the same: what the reference lands on
+     * can be invoked anywhere the value travels.
+     */
+    reference?: boolean;
+}
+interface CodeModel {
+    /** One facts entry per distinct resolved sourcePath (missing/escaped/unreadable included). */
+    files: SourceFileFacts[];
+    /** The root every sourcePath was resolved and containment-checked against. */
+    projectRoot: string;
+    /**
+     * Every source file the declared source-root walk found, as canonical keys
+     * in walk order — the domain the unclaimed-source rule judges. Empty when
+     * the project declares no source roots, which is what keeps that rule
+     * opt-in. Facts for these files live in `files`, like any other path.
+     */
+    rootFiles: string[];
+    /**
+     * The package specifiers that name a package of THIS repository, each
+     * mapped to the canonical source file it resolves to: the root package and
+     * every workspace package the root package.json declares (never
+     * node_modules), `name` for the main entry and `name/sub` for each plain
+     * subpath export, build entries mapped back to their source through the
+     * package's tsconfig outDir/rootDir. What lets a package import resolve like
+     * a relative one; a third-party specifier is in no entry and resolves to
+     * nothing. Absent or empty when the repository declares no packages.
+     */
+    packages?: Record<string, string>;
+    /**
+     * The resolved calls of the project's own source files that no facts entry
+     * holds but a resolved call or reference of the run reaches — a helper
+     * module no spec names and no source-root walk found — keyed by canonical
+     * path. What lets a rule read unowned code as part of whoever calls it.
+     * Absent where no type checker was loaded.
+     */
+    reachedCalls?: Record<string, ResolvedCallFact[]>;
+}
 /**
- * Validate the tree at FULL strictness — treating every spec as `complete`, so
- * the completeness rules that relax to warnings while draft/design apply as
- * errors — WITHOUT mutating anything on disk. This is the as-complete gate that
- * `wairon lock` and the hosting lock require: a draft tree can "pass" a normal
- * validate yet break the moment it is frozen, so lock must gate on this.
- *
- * The status flip lives inside validateProject (treatAllAsComplete) because
- * validation begins by invalidating the spec cache (clearLoaderIssues), which
- * would discard any objects mutated out here before the rules ever saw them —
- * exactly the silent degradation this wrapper previously suffered from.
+ * code_model.pathKey — the canonical key form of a source path in the model:
+ * forward slashes, no leading `./`. Every facts entry is stored under it, and
+ * every lookup or path comparison uses it.
  */
-declare function validateAsComplete(options?: ValidationOptions): ValidationResult;
+declare function pathKey(sourcePath: string): string;
 /**
- * ivalidator_portal.validateFamily — the family run: every selected project's
- * own gate verbatim under its project key, the composition of each project's
- * externals against their live producers, and the family checks. `wairon
- * validate` at a project that declares members, and `--family` anywhere, call
- * this; the owner's gate is validateProject. It forwards to the family
- * validator, which keeps the owner's gate a pure function of one project.
+ * code_model.factsFor — the facts entry for a source path, looked up by its
+ * canonical key; undefined when the run analyzed no such path. The model holds
+ * one entry per key; were it to hold two, the later one answers, as it does in
+ * the keyed indexes the rules build over the same files.
  */
-declare function validateFamily(options: ValidationOptions): ValidationResult;
+declare function factsFor(model: CodeModel, sourcePath: string): SourceFileFacts | undefined;
 /**
- * ivalidator_portal.measurePackImpact — what one pack write would change on
- * the bound project, measured before it happens: the pack's doctrine against
- * wairon's defaults, the profiles of it that would govern, and the owner's-gate
- * findings that differ between the current and the candidate configuration.
- * Writes nothing. Forwarded to the pack impact workflow.
+ * source_file_facts.importBindingOf — the runtime import binding a file makes
+ * under a local name, or undefined when the name is not an import of this
+ * file (it is local, global, or bound type-only).
  */
-declare function measurePackImpact(candidate: PackCandidate): PackImpact;
+declare function importBindingOf(facts: SourceFileFacts, name: string): ImportBindingFact | undefined;
 /**
- * ivalidator_portal.measurePackDoctrine — what one pack changes against
- * wairon's defaults, with no project to validate. Writes nothing. Forwarded to
- * the pack impact workflow.
+ * source_file_facts.fieldTypesOf — the type names an instance field is
+ * DECLARED with, or EMPTY when the file declares no such field, annotates it
+ * with nothing, or was analyzed below exact grade. The empty answer is what
+ * keeps an unresolvable field from becoming a guess.
  */
-declare function measurePackDoctrine(manifest: ExtensionPack): PackDoctrine;
+declare function fieldTypesOf(facts: SourceFileFacts, field: string): string[];
 /**
- * ispec_validator/ivalidator_portal.builtinProfileIds — the ids of wairon's
- * built-in architectural profiles: the built-in half of the profiles a
- * projectType may name. A copy of the rule set's own constant, so a caller can
- * never mutate it.
+ * source_file_facts.localTypesOf — the type names a locally bound name is
+ * DECLARED with, or EMPTY when the file binds no such name, annotates it with
+ * nothing, or was analyzed below exact grade. The empty answer is what keeps
+ * an unannotated receiver from becoming a guess, exactly as it does for a
+ * field.
  */
-declare function builtinProfileIds(): string[];
+declare function localTypesOf(facts: SourceFileFacts, name: string): string[];
 /**
- * ispec_validator/ivalidator_portal.builtinProjectKinds — the built-in
- * composite project kinds: legal projectType values that are not
- * architectural profiles and carry no doctrine of their own.
+ * source_file_facts.memberTypesOf — the type names a property of a named
+ * shape this file declares is DECLARED with, or EMPTY when the file declares
+ * no such shape or property, annotates it with nothing, or was analyzed below
+ * exact grade. The empty answer keeps an unresolvable link of a receiver
+ * chain from becoming a guess.
  */
-declare function builtinProjectKinds(): string[];
+declare function memberTypesOf(facts: SourceFileFacts, shape: string, property: string): string[];
 /**
- * The gate identity a lock records and every staleness check compares
- * (ispec_validator/ivalidator_portal.computeGateStateId): the project's OWN
- * DESIGN identity (code linkage and timestamps out), the design doctrine, its own consumed contract inputs, its
- * `composition`, and each direct member's composition subject — read from the
- * member's own lock record, never recomputed and never its specs. So a
- * parent's identity costs its own tree plus one lock file per direct member,
- * and a lock taken at a member's own root and one taken inside its family
- * record the same identity. The validator computes it because the doctrine it
- * covers is the validator's own rule set; core only compares a lock against
- * the identity its caller passes (readLockState).
+ * source_file_facts.aliasTargetOf — the type a type alias this file declares
+ * names outright, or undefined when the name is no such alias or its right
+ * side names no single type.
  */
-declare function computeGateStateId(): StateId;
+declare function aliasTargetOf(facts: SourceFileFacts, name: string): string | undefined;
 /**
- * ivalidator_portal.familyApprovals — the bound project's pin tree: its own
- * approval state and each member's within `depth` levels, each computed at the
- * member's own root, with each member's subject and how its parent pinned it.
- * The one source the lock workflow, `wairon status` and sdd_get_status read,
- * so they cannot disagree. Writes nothing; a hosted caller gates on reach
- * itself before asking about a family.
+ * source_file_facts.typeBindingOf — the module specifier a NAME was imported
+ * from, whether the import was type-only or a runtime one, since a declared
+ * type may be spelled either way. Undefined when the file imports no such
+ * name, which leaves the name local, global or ambient.
  */
-declare function familyApprovals(depth?: number): ProjectApproval[];
+declare function typeBindingOf(facts: SourceFileFacts, name: string): string | undefined;
 /**
- * ivalidator_portal.familyRelations — the bound family's relation health: each
- * project's externals status read at its own root, stamped with when, a project
- * that could not be opened answered with its reason. What the canvas colours
- * its consumption edges from. Writes nothing; callers grant the reach first.
+ * source_file_facts.callSitesOf — the call sites written inside one named
+ * function-like, or undefined when the file holds no BODY under that name.
+ * The two answers are different findings and must never be collapsed: an
+ * empty array is a body that calls nothing, undefined is nothing to read.
  */
-declare function familyRelations(): ProjectRelations[];
-
-/** How an approver's identity was established. */
-type ApproverSource = 'git' | 'hosted' | 'os' | 'legacy';
+declare function callSitesOf(facts: SourceFileFacts, fn: string): CallSiteFact[] | undefined;
+/** The bodies one name resolved to, and an identity a walk can de-duplicate on. */
+interface ResolvedBody {
+    /** `<container>.<name>` for a member, `<name>` for the module binding, `*<name>` for the union. */
+    key: string;
+    sites: CallSiteFact[];
+}
 /**
- * Who approved, and HOW that identity was established — because the two are
- * different claims. A `hosted` identity was authenticated by the instance that
- * issued the caller's credential; `git` and `os` are self-declared, read from
- * the machine's own config. Recording the source keeps the record honest about
- * how much it proves instead of leaving a bare name to imply more than it can.
+ * source_file_facts.bodySitesOf — the call sites of the ONE body a name
+ * means, told apart from its same-named neighbours by where each is bound;
+ * undefined when the file holds no body under the name.
  *
- * The actual proof is the commit that introduces the lock record — signed
- * commits or a protected branch establish it; no field inside the file ever
- * can.
+ * `container` and `member` are what the reference says about its owner:
+ * `container` is an anchor's `exportedVia` handle or a call's plain-identifier
+ * receiver, and `member` says the reference was written through a receiver at
+ * all. Only the code
+ * settles which body a name means, and where it does not this answers what
+ * the name-keyed union always answered — never a guess:
+ *
+ *   - with a container the file binds bodies of this name under, those bodies;
+ *   - else a BARE reference (an anchor's symbol, a bare call) means the
+ *     module-scope bodies, when the name has some and NO nested one: a bare
+ *     name in the module's scope binds the top-level declaration, a member is
+ *     reachable only through its container, and a nested body could shadow
+ *     the name where it sits;
+ *   - else every body under the name, unioned, as callSitesOf answers — a
+ *     receiver the file binds no container to holds a value the model cannot
+ *     follow, so which body it reaches is not this model's to say.
  */
-interface ApproverIdentity {
-    /** Git author line, hosted subject id, or OS username — per `source`. */
-    id: string;
-    /** Display name when the source carries one separately from the id. */
-    name?: string;
-    /** 'legacy' is a record written before this field existed: an opaque string. */
-    source: ApproverSource;
-}
-/** Weakest-first order of the analysis grades; `none` when no file was analyzed. */
-type AnalysisGradeLabel = 'exact' | 'pattern' | 'generic' | 'none';
+declare function bodySitesOf(facts: SourceFileFacts, fn: string, container?: string, member?: boolean): ResolvedBody | undefined;
 /**
- * analyzer_identity — which code analyzer produced a set of code-conformance
- * results. Deliberately NOT an input of the gate identity: an analyzer upgrade
- * changes this and never stales a lock.
+ * source_file_facts.hasFunctionBody — whether the file holds a function-like
+ * BODY under a name, as the model measured it: a function, method or accessor
+ * declaration, or a function/arrow initializer bound to a named slot. A name
+ * the file declares WITHOUT one — an overload signature, an ambient
+ * declaration, an interface or type member, a plain value binding, an import
+ * binding, a re-export specifier — answers false, because there is no body
+ * there to read.
+ *
+ * Only exact grade measures bodies at all, so a file analyzed below it always
+ * answers false; a caller that would ACCUSE on the answer must check the grade
+ * itself rather than read "no body" into "not measured".
  */
-interface AnalyzerIdentity {
-    /** The wairon version that ran the analysis. */
-    validatorVersion: string;
-    /** sha256 (hex) of the code-conformance doctrine (gate_identity.analyzer). */
-    doctrineDigest: string;
-    /** The weakest analysis grade applied to any analyzed file, or `none`. */
-    grade: AnalysisGradeLabel;
-}
+declare function hasFunctionBody(facts: SourceFileFacts, symbol: string): boolean;
 /**
- * code_analysis — the code-conformance half of a validation run, summarized
- * apart from the design half. A lock records it as `code`, beside the claim
- * and never inside it; its `codes` list is left out there.
+ * The language a source file is analyzed as, read from its extension; undefined
+ * for a file no analyzer reads. The one table the analyzer and the implementer
+ * briefs share, so a brief's type mapping is the dialect its code is judged by.
  */
-interface CodeAnalysis {
-    analyzer: AnalyzerIdentity;
-    /** Every code a code-judging rule declares, sorted. Absent on a lock record. */
-    codes?: string[];
-    errors: number;
-    warnings: number;
-    notices: number;
-}
+declare function languageOfSourcePath(sourcePath: string): string | undefined;
 /**
- * spec_digest_reading — which reading of a spec file a lock record's per-spec
- * digests were taken in. `content`: the raw text, line endings normalized —
- * what every record written before format 3 carries (the field absent).
- * `design`: the spec's design view (code linkage and timestamps out) in
- * canonical form, so a sourcePath, a whitespace edit or a no-op re-save never
- * moves it.
+ * source_file_facts.dialect — the type dialect shipped for the language this
+ * file was analyzed as (type_dialect.forLanguage of its effective language),
+ * or null when the file has no language or no dialect reads it yet. What a
+ * conformance rule reads this file's type annotations through; a null answer
+ * is silence, never a finding.
  */
-type SpecDigestReading = 'content' | 'design';
+declare function dialectOf(facts: SourceFileFacts): TypeDialect | null;
 /**
- * lock_reexpression — provenance on a lock record a tool carried into a newer
- * reading after PROVING the design is the one approved (its own earlier
- * identity, recomputed over the tree as it stands, matched), rather than a
- * human re-approving it. Who approved and when stay the human's.
+ * The type name a named function-like returns, where the code settles it
+ * (SourceFileFacts.returnTypes); undefined otherwise — the silence a
+ * `fn().method()` receiver keeps when the code does not say what fn returns.
  */
-interface LockReexpression {
-    /** ISO-8601 time of the re-expression. */
-    at: string;
-    /** The gate algorithm the record carried before. */
-    fromAlgorithm: string;
-    /** The per-spec digest reading the record carried before. */
-    fromReading: SpecDigestReading;
-    /** The command that re-expressed it (e.g. `wairon doctor --fix`), never a person. */
-    by: string;
-}
-/** A project's approval state as seen from its own root. */
-type ProjectApprovalState = 'approved' | 'drifted' | 'never';
-/** How a parent's lock pinned a member. */
-type PinState = 'matches' | 'moved' | 'unpinned';
+declare function returnTypeOf(facts: SourceFileFacts, fn: string): string | undefined;
 /**
- * project_approval — one project's approval state, computed at that project's
- * OWN root, so the answer is the same whichever root asked (status-agrees).
- * The family's pin tree is a list of these, the root's own entry first.
+ * source_file_facts.resolveImport — resolve one of a file's import specifiers
+ * against a set of known source paths, purely (no I/O). A relative one: join
+ * it with the importing file's directory, then try the joined path, `.js`
+ * swapped for `.ts` or `.tsx`, the `.ts`, `.tsx` and `.js` extensions, and an
+ * index file. A package specifier: the source file `packages` (the code
+ * model's local-package map) names for it, when that file is known.
+ * Undefined for a package the map does not name — a third-party one — or
+ * when nothing matches.
  */
-interface ProjectApproval {
-    /** '' for the root the question was asked at, else the member's key. */
-    key: string;
-    /** The alias the parent declares this member under; absent on the root. */
-    alias?: string;
-    /** The key of the declaring project; absent on the root. */
-    parent?: string;
-    /** The project's effective id, when it has a usable one. */
-    projectId?: string;
-    state: ProjectApprovalState;
-    /** Its composition subject: its own record's stateId, `<algorithm>:<digest>`. Absent when never. */
-    subject?: string;
-    /** Drifted only because the lock predates the stage-5 gate identity. */
-    upgraded?: boolean;
-    /**
-     * Why the approval on record does not cover the project although its gate
-     * identity may match: its id moved since the approval, or a declared
-     * external was never pinned or is used beyond its pin. Set only on a
-     * drifted entry; status, lock-check and lock read the same entry.
-     */
-    owed?: string;
-    /** How the parent's lock pinned it; absent on the root. */
-    pinned?: PinState;
-    /** part | project (stage 8). A part's state is its declaring project's, and it has no subject of its own. */
-    as?: MemberKind;
-    /** A part's content digest (ScannedPart.contentDigest), recorded by the lock as its MemberPin. */
-    contentDigest?: string;
-    /** The commit a part or a referenced project member was read at, when known — provenance the lock records. */
-    commit?: string;
-}
+declare function resolveImport(fromFile: string, specifier: string, knownPaths: Set<string>, packages?: Readonly<Record<string, string>>): string | undefined;
 
 /**
- * member_pin — one direct member as a parent's lock recorded it: the member's
- * composition subject (the stateId its OWN lock record carries) and its
- * approval state when the parent locked. A record of the member owner's
- * decision, never of the member's specs; the parent never writes below itself.
+ * The tests that encode one method a write just changed or deleted
+ * (tests_to_revisit).
+ *
+ * Two lists rather than one because the two ways of finding them fail in
+ * OPPOSITE directions, and merging them would hide which is which — see the
+ * measurement above.
  */
-interface MemberPin {
-    /** The member's effective project id when the parent locked. */
-    project?: string;
-    /** The member's recorded gate identity, `<algorithm>:<digest>`; absent when it had no lock. */
-    subject?: string;
-    /** approved | drifted | never, as it stood when the parent locked (a part records approved). Recorded, never hashed. */
-    state: ProjectApprovalState;
-    /** part | project, as the member's content made it when the parent locked; absent in a record written before stage 8. */
-    as?: MemberKind;
-    /** The commit the member was read at when the parent locked. Provenance only: never read by a verdict. */
-    commit?: string;
+interface TestsToRevisit {
+    /** The contract method the write changed or deleted. */
+    method: string;
+    /** The code-level name searched for: the method's `symbol` when it declares one, else its name. */
+    symbol: string;
+    /**
+     * Test files that IMPORT that symbol — from the method's own source file, or
+     * from a module re-exporting it from there, when that file is known. The
+     * high-confidence list.
+     */
+    imported: string[];
+    /**
+     * Test files that name the symbol without importing it — usually a test
+     * driving the method through a portal or a helper. A file that binds the
+     * name to ANOTHER module is not here: the name in it is that module's.
+     * Empty when `indiscriminate` is true.
+     */
+    mentioned: string[];
+    /**
+     * True when the bare name matched more than a tenth of the walked test files,
+     * so mentioning it carries no signal and `mentioned` was withheld.
+     */
+    indiscriminate: boolean;
+}
+
+/**
+ * ispec_validator/ivalidator_portal.findTestsReferencing — the tests that
+ * encode a given set of methods, so a write that changes or deletes one can
+ * say which tests it just invalidated.
+ *
+ * The walk itself belongs to the source analyzer, which already owns this
+ * subsystem's only source-code I/O and the containment rules a root is held
+ * to. A project that declares no test roots answers empty rather than
+ * throwing: naming the tests must never be the thing that fails a write.
+ */
+declare function findTestsReferencing(methods: ReadonlyArray<Pick<MethodImplementation, 'name' | 'symbol'>>, projectRoot: string, testRoots: readonly string[]): TestsToRevisit[];
+interface ValidationIssue {
+    /**
+     * After project and profile overrides. A `notice` is reported like any other
+     * finding but never makes a result invalid (`valid` counts errors only) and
+     * never fails `--ci`.
+     */
+    severity: IssueSeverity;
+    code: string;
+    message: string;
+    /** Optional: agent id related to the issue */
+    agentId?: string;
+    specId?: string;
+    /**
+     * True when this issue was raised in a draft/design context — i.e. the spec
+     * it concerns (or an ancestor) is not yet complete. Rules that already know
+     * this (e.g. DRAFT_COMPONENT_WARNING, UNUSED_COMPONENT on a draft component)
+     * surface it so downstream policy — like the --ci gate — can waive warnings
+     * that merely reflect declared, unfinished work without silencing the rule.
+     */
+    draftContext?: boolean;
+    /**
+     * On a finding about a cross-project reference: how the owner's gate
+     * resolved it (outcome, owner, call site, canonical target, input digest,
+     * reason), decided before the severity.
+     */
+    resolution?: ReferenceResolution;
+    /**
+     * In a family run: the key of the project whose gate (or whose external,
+     * for a composition finding) the finding belongs to — '' for the family
+     * root. Absent on the owner's own run.
+     */
+    project?: string;
+    /**
+     * True on a finding reported beside a gate rather than by it — the live
+     * comparison of an external with its producer (family_validator.advise).
+     * Printed and counted with its severity, but never part of a failure
+     * decision: `valid` and `validate --ci` both ignore it, because the pin is
+     * the reproducible gate and a live producer is not.
+     */
+    advisory?: boolean;
+}
+interface ValidationResult {
+    valid: boolean;
+    issues: ValidationIssue[];
+    /**
+     * One line, never a finding. The owner's gate: present when the project
+     * declares externals, saying they were judged against their pins and the
+     * advisory live comparison reads their live producers. A family run: present when externals were left out
+     * because their producers lie outside the run's reach.
+     */
+    hint?: string;
+    /**
+     * A family run only: one line per selected project (the root first, then its
+     * members in scan order) with its own gate's totals. Absent on the owner's
+     * gate.
+     */
+    projects?: ProjectVerdict[];
+    /**
+     * The as-complete run only (validateAsComplete): the code-conformance half
+     * summarized with the analyzer that produced it. Absent on the owner's gate
+     * and on a family run.
+     */
+    analysis?: CodeAnalysis;
+    /**
+     * One line, never a finding: how the owner's gate read the code — the
+     * weakest grade any file was read at and, at exact grade, the compiler and
+     * whose copy it is; or that no source file the design names exists yet.
+     * `wairon validate` prints it; sdd_validate_tree carries it in its hint.
+     */
+    codeReading?: string;
+    /**
+     * A family run only: the aliases of the bound project's externals the run
+     * composed as part of its gate (their producers in reach) — the advisory
+     * live comparison skips them, so they get no second word.
+     */
+    composed?: string[];
+}
+/**
+ * project_verdict — one project's line in a family run: which project it is,
+ * where it lives, and the totals of its own gate's verdict, which the family
+ * run carries verbatim under the project's key.
+ */
+interface ProjectVerdict {
+    /** The project's key in the family root's scan ('' for the root itself). */
+    key: string;
+    /** The project's effective id. */
+    id?: string;
+    /** The project's root directory. */
+    directory: string;
+    /** Whether its own gate found no error. */
+    valid: boolean;
+    errors: number;
+    warnings: number;
+    notices: number;
+}
+declare function validateRegistry(registry: Registry, rules: RulesConfig): ValidationResult;
+declare function validateProjectConfig(config: ProjectConfig): ValidationResult;
+interface ValidationOptions {
+    rules?: RulesConfig;
+    projectType?: string;
+    scopeSubsystem?: string;
+    /**
+     * At a project that declares members: how many member levels the run
+     * reaches. Absent, every level (the family run); 0, the owner's gate alone;
+     * n, the family run selecting that many levels.
+     */
+    memberDepth?: number;
+    /**
+     * Pre-loaded extension packs (the programmatic-wrapper path). When omitted,
+     * the packs declared in the project's own config are loaded — so CLI and
+     * MCP callers get pack rules/profiles/languages without passing anything.
+     */
+    extensions?: LoadedExtensions;
+    /**
+     * Validate at FULL strictness: treat every spec as `complete`, so the
+     * completeness rules that relax to warnings while draft/design apply as
+     * errors. This is the as-complete gate behind `wairon lock`. The flip must
+     * happen INSIDE the validation run — clearLoaderIssues() invalidates the
+     * spec cache, so any status mutation done before calling in is lost to the
+     * rescan (statuses are restored before returning, so the flip is never
+     * observable to later callers).
+     */
+    treatAllAsComplete?: boolean;
+    /**
+     * Ask for the family run explicitly (`validate --family`, MCP `family:
+     * true`). Omitted, a project that declares members runs its family and any
+     * other project runs its owner's gate (validation_options.selectsFamily).
+     */
+    family?: boolean;
+    /**
+     * The by-name pack selections the pack rules judge. Omitted, the project's
+     * own stored selections are read. Given only by a dry run that judges a
+     * candidate configuration it has not written (pack_impact.measure), together
+     * with that candidate's rules, projectType and loaded extensions.
+     */
+    packSelections?: PackSelection[];
+}
+/**
+ * The active conformance rule set — the built-in rules plus the loaded
+ * programmatic pack rules, in run order — for `wairon rules list`. Loads and
+ * registers the governing packs, then reads the composed sequence.
+ */
+declare function listRules(): SddRule[];
+/**
+ * ispec_validator/ivalidator_portal.validateProject — the owner's gate (stage
+ * 4): judge the bound project from its own files alone — its specs, its
+ * configuration and doctrine, its code, its lock, its externals lock and
+ * pinned snapshots, and the export tables of the members it contains — and
+ * nothing else. It never walks up to a parent, never reads a sibling's live
+ * tree and discovers nothing, so a project's verdict is the same from every
+ * root and with or without its family on disk. A contained member's own specs
+ * are never judged here: its gate judges them under its own configuration.
+ */
+declare function validateProject(rulesOrOptions?: RulesConfig | ValidationOptions, projectType?: string): ValidationResult;
+/**
+ * Validate the tree at FULL strictness — treating every spec as `complete`, so
+ * the completeness rules that relax to warnings while draft/design apply as
+ * errors — WITHOUT mutating anything on disk. This is the as-complete gate that
+ * `wairon lock` and the hosting lock require: a draft tree can "pass" a normal
+ * validate yet break the moment it is frozen, so lock must gate on this.
+ *
+ * The status flip lives inside validateProject (treatAllAsComplete) because
+ * validation begins by invalidating the spec cache (clearLoaderIssues), which
+ * would discard any objects mutated out here before the rules ever saw them —
+ * exactly the silent degradation this wrapper previously suffered from.
+ */
+declare function validateAsComplete(options?: ValidationOptions): ValidationResult;
+/**
+ * ivalidator_portal.validateFamily — the family run: every selected project's
+ * own gate verbatim under its project key, the composition of each project's
+ * externals against their live producers, and the family checks. `wairon
+ * validate` at a project that declares members, and `--family` anywhere, call
+ * this; the owner's gate is validateProject. It forwards to the family
+ * validator, which keeps the owner's gate a pure function of one project.
+ */
+declare function validateFamily(options: ValidationOptions): ValidationResult;
+/**
+ * ivalidator_portal.measurePackImpact — what one pack write would change on
+ * the bound project, measured before it happens: the pack's doctrine against
+ * wairon's defaults, the profiles of it that would govern, and the owner's-gate
+ * findings that differ between the current and the candidate configuration.
+ * Writes nothing. Forwarded to the pack impact workflow.
+ */
+declare function measurePackImpact(candidate: PackCandidate): PackImpact;
+/**
+ * ivalidator_portal.measurePackDoctrine — what one pack changes against
+ * wairon's defaults, with no project to validate. Writes nothing. Forwarded to
+ * the pack impact workflow.
+ */
+declare function measurePackDoctrine(manifest: ExtensionPack): PackDoctrine;
+/**
+ * ispec_validator/ivalidator_portal.builtinProfileIds — the ids of wairon's
+ * built-in architectural profiles: the built-in half of the profiles a
+ * projectType may name. A copy of the rule set's own constant, so a caller can
+ * never mutate it.
+ */
+declare function builtinProfileIds(): string[];
+/**
+ * ispec_validator/ivalidator_portal.builtinProjectKinds — the built-in
+ * composite project kinds: legal projectType values that are not
+ * architectural profiles and carry no doctrine of their own.
+ */
+declare function builtinProjectKinds(): string[];
+/**
+ * The gate identity a lock records and every staleness check compares
+ * (ispec_validator/ivalidator_portal.computeGateStateId): the project's OWN
+ * DESIGN identity (code linkage and timestamps out), the design doctrine, its own consumed contract inputs, its
+ * `composition`, and each direct member's composition subject — read from the
+ * member's own lock record, never recomputed and never its specs. So a
+ * parent's identity costs its own tree plus one lock file per direct member,
+ * and a lock taken at a member's own root and one taken inside its family
+ * record the same identity. The validator computes it because the doctrine it
+ * covers is the validator's own rule set; core only compares a lock against
+ * the identity its caller passes (readLockState).
+ */
+declare function computeGateStateId(): StateId;
+/**
+ * ivalidator_portal.familyApprovals — the bound project's pin tree: its own
+ * approval state and each member's within `depth` levels, each computed at the
+ * member's own root, with each member's subject and how its parent pinned it.
+ * The one source the lock workflow, `wairon status` and sdd_get_status read,
+ * so they cannot disagree. Writes nothing; a hosted caller gates on reach
+ * itself before asking about a family.
+ */
+declare function familyApprovals(depth?: number): ProjectApproval[];
+/**
+ * ivalidator_portal.familyRelations — the bound family's relation health: each
+ * project's externals status read at its own root, stamped with when, a project
+ * that could not be opened answered with its reason. What the canvas colours
+ * its consumption edges from. Writes nothing; callers grant the reach first.
+ */
+declare function familyRelations(): ProjectRelations[];
+
+/** How an approver's identity was established. */
+type ApproverSource = 'git' | 'hosted' | 'os' | 'legacy';
+/**
+ * Who approved, and HOW that identity was established — because the two are
+ * different claims. A `hosted` identity was authenticated by the instance that
+ * issued the caller's credential; `git` and `os` are self-declared, read from
+ * the machine's own config. Recording the source keeps the record honest about
+ * how much it proves instead of leaving a bare name to imply more than it can.
+ *
+ * The actual proof is the commit that introduces the lock record — signed
+ * commits or a protected branch establish it; no field inside the file ever
+ * can.
+ */
+interface ApproverIdentity {
+    /** Git author line, hosted subject id, or OS username — per `source`. */
+    id: string;
+    /** Display name when the source carries one separately from the id. */
+    name?: string;
+    /** 'legacy' is a record written before this field existed: an opaque string. */
+    source: ApproverSource;
+}
+/** Weakest-first order of the analysis grades; `none` when no file was analyzed. */
+type AnalysisGradeLabel = 'exact' | 'pattern' | 'generic' | 'none';
+/**
+ * analyzer_identity — which code analyzer produced a set of code-conformance
+ * results. Deliberately NOT an input of the gate identity: an analyzer upgrade
+ * changes this and never stales a lock.
+ */
+interface AnalyzerIdentity {
+    /** The wairon version that ran the analysis. */
+    validatorVersion: string;
+    /** sha256 (hex) of the code-conformance doctrine (gate_identity.analyzer). */
+    doctrineDigest: string;
+    /** The weakest analysis grade applied to any analyzed file, or `none`. */
+    grade: AnalysisGradeLabel;
+}
+/**
+ * code_analysis — the code-conformance half of a validation run, summarized
+ * apart from the design half. A lock records it as `code`, beside the claim
+ * and never inside it; its `codes` list is left out there.
+ */
+interface CodeAnalysis {
+    analyzer: AnalyzerIdentity;
+    /** Every code a code-judging rule declares, sorted. Absent on a lock record. */
+    codes?: string[];
+    errors: number;
+    warnings: number;
+    notices: number;
+}
+/**
+ * spec_digest_reading — which reading of a spec file a lock record's per-spec
+ * digests were taken in. `content`: the raw text, line endings normalized —
+ * what every record written before format 3 carries (the field absent).
+ * `design`: the spec's design view (code linkage and timestamps out) in
+ * canonical form, so a sourcePath, a whitespace edit or a no-op re-save never
+ * moves it.
+ */
+type SpecDigestReading = 'content' | 'design';
+/**
+ * lock_reexpression — provenance on a lock record a tool carried into a newer
+ * reading after PROVING the design is the one approved (its own earlier
+ * identity, recomputed over the tree as it stands, matched), rather than a
+ * human re-approving it. Who approved and when stay the human's.
+ */
+interface LockReexpression {
+    /** ISO-8601 time of the re-expression. */
+    at: string;
+    /** The gate algorithm the record carried before. */
+    fromAlgorithm: string;
+    /** The per-spec digest reading the record carried before. */
+    fromReading: SpecDigestReading;
+    /** The command that re-expressed it (e.g. `wairon doctor --fix`), never a person. */
+    by: string;
+}
+/** A project's approval state as seen from its own root. */
+type ProjectApprovalState = 'approved' | 'drifted' | 'never';
+/** How a parent's lock pinned a member. */
+type PinState = 'matches' | 'moved' | 'unpinned';
+/**
+ * project_approval — one project's approval state, computed at that project's
+ * OWN root, so the answer is the same whichever root asked (status-agrees).
+ * The family's pin tree is a list of these, the root's own entry first.
+ */
+interface ProjectApproval {
+    /** '' for the root the question was asked at, else the member's key. */
+    key: string;
+    /** The alias the parent declares this member under; absent on the root. */
+    alias?: string;
+    /** The key of the declaring project; absent on the root. */
+    parent?: string;
+    /** The project's effective id, when it has a usable one. */
+    projectId?: string;
+    state: ProjectApprovalState;
+    /** Its composition subject: its own record's stateId, `<algorithm>:<digest>`. Absent when never. */
+    subject?: string;
+    /** Drifted only because the lock predates the stage-5 gate identity. */
+    upgraded?: boolean;
+    /**
+     * Why the approval on record does not cover the project although its gate
+     * identity may match: its id moved since the approval, or a declared
+     * external was never pinned or is used beyond its pin. Set only on a
+     * drifted entry; status, lock-check and lock read the same entry.
+     */
+    owed?: string;
+    /** How the parent's lock pinned it; absent on the root. */
+    pinned?: PinState;
+    /** part | project (stage 8). A part's state is its declaring project's, and it has no subject of its own. */
+    as?: MemberKind;
+    /** A part's content digest (ScannedPart.contentDigest), recorded by the lock as its MemberPin. */
+    contentDigest?: string;
+    /** The commit a part or a referenced project member was read at, when known — provenance the lock records. */
+    commit?: string;
+}
+
+/**
+ * member_pin — one direct member as a parent's lock recorded it: the member's
+ * composition subject (the stateId its OWN lock record carries) and its
+ * approval state when the parent locked. A record of the member owner's
+ * decision, never of the member's specs; the parent never writes below itself.
+ */
+interface MemberPin {
+    /** The member's effective project id when the parent locked. */
+    project?: string;
+    /** The member's recorded gate identity, `<algorithm>:<digest>`; absent when it had no lock. */
+    subject?: string;
+    /** approved | drifted | never, as it stood when the parent locked (a part records approved). Recorded, never hashed. */
+    state: ProjectApprovalState;
+    /** part | project, as the member's content made it when the parent locked; absent in a record written before stage 8. */
+    as?: MemberKind;
+    /** The commit the member was read at when the parent locked. Provenance only: never read by a verdict. */
+    commit?: string;
     /** Part only: its content digest (ScannedPart.contentDigest) when the parent locked. */
     contentDigest?: string;
 }
@@ -7880,7 +8678,7 @@ interface LockRecord {
     /** For git-backed projects: the compare/PR URL a human opens to merge. */
     compareUrl?: string;
 }
-/** Read the current project's lock record, or null when absent/unreadable. */
+/** Read the current project's lock record: null when ABSENT, LockRecordUnreadableError when present but unreadable. */
 declare function readLockRecord(): LockRecord | null;
 
 declare class WaironError extends Error {
@@ -7899,6 +8697,20 @@ declare class YamlSyntaxError extends WaironError {
     readonly key: string | undefined;
     constructor(file: string | undefined, line: number | undefined, reason: string, key: string | undefined);
 }
+/**
+ * Thrown when a lock record EXISTS but cannot be read as one: it does not
+ * parse, it is empty, it is JSON that is not a lock record, or it names a
+ * format this release does not read. An approval that cannot be read is
+ * never read as no approval — that turned a truncated merge into "nothing is
+ * gated" — so every reader fails closed on it, with one line naming the file,
+ * what is wrong, and the two ways out. A WaironError: every command prints it
+ * as one `✖` line and exits non-zero.
+ */
+declare class LockRecordUnreadableError extends WaironError {
+    readonly file: string;
+    readonly reason: string;
+    constructor(file: string, reason: string);
+}
 /**
  * Thrown when the project has not been initialized (.wai/ directory missing).
  */
@@ -8803,6 +9615,12 @@ declare function typeSpellingFacts(): TypeSpellingFacts;
 /** ispec_loader.retiredReachFacts — forwarded 1:1 to the index read face. */
 declare function retiredReachFacts(): RetiredReachFact[];
 declare function findLegacySpecFiles(): LegacySpecFile[];
+/**
+ * core_orchestrator.findOrphanedSpecFiles — the bound tree's spec files left
+ * standing while its specs folder holds no L0: what `validate` and
+ * `lock-check` report as an error instead of reading the tree as empty.
+ */
+declare function findOrphanedSpecFiles(): string[];
 /**
  * spec_loader.loadSpec / icore_orchestrator.loadSpec — one stored spec of the
  * named kind in the bound tree, or null: for a caller that holds the kind as
@@ -9076,6 +9894,13 @@ interface ExternalConsumer {
  * that renaming that method breaks this consumer. Pure.
  */
 declare function consumerReaches(consumer: ExternalConsumer, publicNames: readonly string[], member: string): boolean;
+/**
+ * external_consumer.narrowedTo — a consumer as a rename of `member` on one of
+ * `publicNames` breaks it: only those public names, each with that one member,
+ * so a dry run names what breaks rather than the consumer's whole use of the
+ * producer. Its specs stay those that reach the public name. Pure.
+ */
+declare function narrowedToMember(consumer: ExternalConsumer, publicNames: readonly string[], member: string): ExternalConsumer;
 /**
  * project_family.bindExternal — one external declaration bound to its
  * producer the way the graph binds every declared external: its own problem,
@@ -9194,6 +10019,15 @@ declare function isWindowsReservedName(name: string): boolean;
  */
 declare const MAX_SPEC_ID_LENGTH = 64;
 declare const SpecIdSchema: z.ZodString;
+declare const MethodNameSchema: z.ZodString;
+declare const ParamNameSchema: z.ZodString;
+declare const FieldNameSchema: z.ZodString;
+/**
+ * A spec's human-readable `name`: display_name.problem — never empty or blank,
+ * and no control, NUL or zero-width character (invisible in every view, cut
+ * short by some tools, and a diagram holding one is a binary file).
+ */
+declare const DisplayNameSchema: z.ZodString;
 /**
  * Split a qualified id at its last `::` into the namespace prefix and the local
  * id. An unqualified id has an empty prefix and is its own local id.
@@ -9396,9 +10230,9 @@ declare const SystemPublicInterfaceSchema: z.ZodObject<{
     name?: string | undefined;
     as?: string | undefined;
     version?: string | undefined;
+    interface?: string | undefined;
     component?: string | undefined;
     subsystem?: string | undefined;
-    interface?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     audience?: string | undefined;
@@ -9412,9 +10246,9 @@ declare const SystemPublicInterfaceSchema: z.ZodObject<{
     name?: string | undefined;
     as?: string | undefined;
     version?: string | undefined;
+    interface?: string | undefined;
     component?: string | undefined;
     subsystem?: string | undefined;
-    interface?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     audience?: string | undefined;
@@ -9486,9 +10320,9 @@ declare const SystemSpecSchema: z.ZodObject<{
         name?: string | undefined;
         as?: string | undefined;
         version?: string | undefined;
+        interface?: string | undefined;
         component?: string | undefined;
         subsystem?: string | undefined;
-        interface?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         audience?: string | undefined;
@@ -9502,9 +10336,9 @@ declare const SystemSpecSchema: z.ZodObject<{
         name?: string | undefined;
         as?: string | undefined;
         version?: string | undefined;
+        interface?: string | undefined;
         component?: string | undefined;
         subsystem?: string | undefined;
-        interface?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         audience?: string | undefined;
@@ -9585,9 +10419,9 @@ declare const SystemSpecSchema: z.ZodObject<{
         name?: string | undefined;
         as?: string | undefined;
         version?: string | undefined;
+        interface?: string | undefined;
         component?: string | undefined;
         subsystem?: string | undefined;
-        interface?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         audience?: string | undefined;
@@ -9614,9 +10448,9 @@ declare const SystemSpecSchema: z.ZodObject<{
         name?: string | undefined;
         as?: string | undefined;
         version?: string | undefined;
+        interface?: string | undefined;
         component?: string | undefined;
         subsystem?: string | undefined;
-        interface?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         audience?: string | undefined;
@@ -9686,8 +10520,8 @@ declare const PublicInterfaceSchema: z.ZodEffects<z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
     as?: string | undefined;
-    component?: string | undefined;
     interface?: string | undefined;
+    component?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     role?: "implement" | "call" | undefined;
@@ -9696,8 +10530,8 @@ declare const PublicInterfaceSchema: z.ZodEffects<z.ZodObject<{
 }, {
     type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
     as?: string | undefined;
-    component?: string | undefined;
     interface?: string | undefined;
+    component?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     role?: "implement" | "call" | undefined;
@@ -9706,8 +10540,8 @@ declare const PublicInterfaceSchema: z.ZodEffects<z.ZodObject<{
 }>, {
     type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
     as?: string | undefined;
-    component?: string | undefined;
     interface?: string | undefined;
+    component?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     role?: "implement" | "call" | undefined;
@@ -9716,8 +10550,8 @@ declare const PublicInterfaceSchema: z.ZodEffects<z.ZodObject<{
 }, {
     type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
     as?: string | undefined;
-    component?: string | undefined;
     interface?: string | undefined;
+    component?: string | undefined;
     typeDef?: string | undefined;
     details?: string | undefined;
     role?: "implement" | "call" | undefined;
@@ -9907,13 +10741,13 @@ declare const LifecycleEntrypointSchema: z.ZodObject<{
     /** What this lifecycle flow establishes or tears down. */
     description: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    component: string;
     method: string;
+    component: string;
     phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
     description?: string | undefined;
 }, {
-    component: string;
     method: string;
+    component: string;
     phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
     description?: string | undefined;
 }>;
@@ -9953,8 +10787,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -9963,8 +10797,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     }, {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -9973,8 +10807,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     }>, {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -9983,8 +10817,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     }, {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -10002,13 +10836,13 @@ declare const SubsystemSpecSchema: z.ZodObject<{
         /** What this lifecycle flow establishes or tears down. */
         description: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        component: string;
         method: string;
+        component: string;
         phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
         description?: string | undefined;
     }, {
-        component: string;
         method: string;
+        component: string;
         phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
         description?: string | undefined;
     }>, "many">>;
@@ -10121,8 +10955,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     publicInterfaces: {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -10136,8 +10970,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     profile?: string | undefined;
     designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
     lifecycle?: {
-        component: string;
         method: string;
+        component: string;
         phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
         description?: string | undefined;
     }[] | undefined;
@@ -10165,8 +10999,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
     publicInterfaces?: {
         type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
         as?: string | undefined;
-        component?: string | undefined;
         interface?: string | undefined;
+        component?: string | undefined;
         typeDef?: string | undefined;
         details?: string | undefined;
         role?: "implement" | "call" | undefined;
@@ -10174,8 +11008,8 @@ declare const SubsystemSpecSchema: z.ZodObject<{
         consumers?: string[] | undefined;
     }[] | undefined;
     lifecycle?: {
-        component: string;
         method: string;
+        component: string;
         phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
         description?: string | undefined;
     }[] | undefined;
@@ -10223,14 +11057,14 @@ declare const DispatchBindingSchema: z.ZodObject<{
     /** What this capability does. */
     description: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    component: string;
     method: string;
     capability: string;
+    component: string;
     description?: string | undefined;
 }, {
-    component: string;
     method: string;
     capability: string;
+    component: string;
     description?: string | undefined;
 }>;
 type DispatchBinding = z.infer<typeof DispatchBindingSchema>;
@@ -10560,14 +11394,14 @@ declare const ComponentSpecSchema: z.ZodObject<{
         /** What this capability does. */
         description: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }, {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }>, "many">>;
     /** Store-only: whether held state survives restart (see DurabilitySchema). */
@@ -10751,9 +11585,9 @@ declare const ComponentSpecSchema: z.ZodObject<{
         example?: string | undefined;
     } | undefined;
     dispatch?: {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }[] | undefined;
     durability?: "ram-projection" | "durable" | "read-through" | "cache" | undefined;
@@ -10825,9 +11659,9 @@ declare const ComponentSpecSchema: z.ZodObject<{
         example?: string | undefined;
     } | undefined;
     dispatch?: {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }[] | undefined;
     durability?: "ram-projection" | "durable" | "read-through" | "cache" | undefined;
@@ -13650,7 +14484,7 @@ declare const NarrativeStepSchema: z.ZodObject<{
     outcome: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+    type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
     description: string;
     stepNumber: number;
     label?: string | undefined;
@@ -13689,7 +14523,7 @@ declare const NarrativeStepSchema: z.ZodObject<{
     detach?: boolean | undefined;
     outcome?: string | undefined;
 }, {
-    type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+    type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
     description: string;
     stepNumber: number;
     label?: string | undefined;
@@ -13851,7 +14685,7 @@ declare const MethodImplementationSchema: z.ZodObject<{
         outcome: z.ZodOptional<z.ZodString>;
         error: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+        type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
         description: string;
         stepNumber: number;
         label?: string | undefined;
@@ -13890,7 +14724,7 @@ declare const MethodImplementationSchema: z.ZodObject<{
         detach?: boolean | undefined;
         outcome?: string | undefined;
     }, {
-        type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+        type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
         description: string;
         stepNumber: number;
         label?: string | undefined;
@@ -13996,7 +14830,7 @@ declare const MethodImplementationSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     name: string;
     narrative: {
-        type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+        type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
         description: string;
         stepNumber: number;
         label?: string | undefined;
@@ -14051,7 +14885,7 @@ declare const MethodImplementationSchema: z.ZodObject<{
     ext?: Record<string, unknown> | undefined;
     intent?: string | undefined;
     narrative?: {
-        type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+        type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
         description: string;
         stepNumber: number;
         label?: string | undefined;
@@ -14299,7 +15133,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
             outcome: z.ZodOptional<z.ZodString>;
             error: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14338,7 +15172,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
             detach?: boolean | undefined;
             outcome?: string | undefined;
         }, {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14444,7 +15278,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         name: string;
         narrative: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14499,7 +15333,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
         ext?: Record<string, unknown> | undefined;
         intent?: string | undefined;
         narrative?: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14544,7 +15378,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
     }>, "many">>, {
         name: string;
         narrative: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14599,7 +15433,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
         ext?: Record<string, unknown> | undefined;
         intent?: string | undefined;
         narrative?: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14721,7 +15555,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
     methods: {
         name: string;
         narrative: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -14809,7 +15643,7 @@ declare const ImplementationSpecSchema: z.ZodObject<{
         ext?: Record<string, unknown> | undefined;
         intent?: string | undefined;
         narrative?: {
-            type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+            type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
             description: string;
             stepNumber: number;
             label?: string | undefined;
@@ -15631,7 +16465,7 @@ declare const TypeSpecSchema: z.ZodObject<{
         previousNames?: string[] | undefined;
         references?: string | undefined;
     }[];
-    kind: "signature" | "entity" | "value-object" | "enum";
+    kind: "enum" | "signature" | "entity" | "value-object";
     createdAt: string;
     updatedAt: string;
     symbol?: string | undefined;
@@ -15673,7 +16507,7 @@ declare const TypeSpecSchema: z.ZodObject<{
 }, {
     id: string;
     name: string;
-    kind: "signature" | "entity" | "value-object" | "enum";
+    kind: "enum" | "signature" | "entity" | "value-object";
     createdAt: string;
     updatedAt: string;
     symbol?: string | undefined;
@@ -16003,7 +16837,7 @@ declare const ResolvedTypeSpecSchema: z.ZodObject<{
         previousNames?: string[] | undefined;
         references?: string | undefined;
     }[];
-    kind: "signature" | "entity" | "value-object" | "enum";
+    kind: "enum" | "signature" | "entity" | "value-object";
     createdAt: string;
     updatedAt: string;
     symbol?: string | undefined;
@@ -16045,7 +16879,7 @@ declare const ResolvedTypeSpecSchema: z.ZodObject<{
 }, {
     id: string;
     name: string;
-    kind: "signature" | "entity" | "value-object" | "enum";
+    kind: "enum" | "signature" | "entity" | "value-object";
     createdAt: string;
     updatedAt: string;
     symbol?: string | undefined;
@@ -16373,7 +17207,7 @@ declare const SCHEMA_OF_KIND: {
                 outcome: z.ZodOptional<z.ZodString>;
                 error: z.ZodOptional<z.ZodString>;
             }, "strip", z.ZodTypeAny, {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16412,7 +17246,7 @@ declare const SCHEMA_OF_KIND: {
                 detach?: boolean | undefined;
                 outcome?: string | undefined;
             }, {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16518,7 +17352,7 @@ declare const SCHEMA_OF_KIND: {
         }, "strip", z.ZodTypeAny, {
             name: string;
             narrative: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16573,7 +17407,7 @@ declare const SCHEMA_OF_KIND: {
             ext?: Record<string, unknown> | undefined;
             intent?: string | undefined;
             narrative?: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16618,7 +17452,7 @@ declare const SCHEMA_OF_KIND: {
         }>, "many">>, {
             name: string;
             narrative: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16673,7 +17507,7 @@ declare const SCHEMA_OF_KIND: {
             ext?: Record<string, unknown> | undefined;
             intent?: string | undefined;
             narrative?: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16795,7 +17629,7 @@ declare const SCHEMA_OF_KIND: {
         methods: {
             name: string;
             narrative: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -16883,7 +17717,7 @@ declare const SCHEMA_OF_KIND: {
             ext?: Record<string, unknown> | undefined;
             intent?: string | undefined;
             narrative?: {
-                type: "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "loop" | "try" | "parallel" | "jump" | "return" | "throw";
+                type: "loop" | "return" | "call" | "local" | "dispatch" | "register" | "branch" | "switch" | "try" | "parallel" | "jump" | "throw";
                 description: string;
                 stepNumber: number;
                 label?: string | undefined;
@@ -17306,7 +18140,7 @@ declare const SCHEMA_OF_KIND: {
             previousNames?: string[] | undefined;
             references?: string | undefined;
         }[];
-        kind: "signature" | "entity" | "value-object" | "enum";
+        kind: "enum" | "signature" | "entity" | "value-object";
         createdAt: string;
         updatedAt: string;
         symbol?: string | undefined;
@@ -17348,7 +18182,7 @@ declare const SCHEMA_OF_KIND: {
     }, {
         id: string;
         name: string;
-        kind: "signature" | "entity" | "value-object" | "enum";
+        kind: "enum" | "signature" | "entity" | "value-object";
         createdAt: string;
         updatedAt: string;
         symbol?: string | undefined;
@@ -17528,14 +18362,14 @@ declare const SCHEMA_OF_KIND: {
             /** What this capability does. */
             description: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }, {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }>, "many">>;
         /** Store-only: whether held state survives restart (see DurabilitySchema). */
@@ -17719,9 +18553,9 @@ declare const SCHEMA_OF_KIND: {
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         durability?: "ram-projection" | "durable" | "read-through" | "cache" | undefined;
@@ -17793,9 +18627,9 @@ declare const SCHEMA_OF_KIND: {
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         durability?: "ram-projection" | "durable" | "read-through" | "cache" | undefined;
@@ -17856,8 +18690,8 @@ declare const SCHEMA_OF_KIND: {
         }, "strip", z.ZodTypeAny, {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -17866,8 +18700,8 @@ declare const SCHEMA_OF_KIND: {
         }, {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -17876,8 +18710,8 @@ declare const SCHEMA_OF_KIND: {
         }>, {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -17886,8 +18720,8 @@ declare const SCHEMA_OF_KIND: {
         }, {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -17905,13 +18739,13 @@ declare const SCHEMA_OF_KIND: {
             /** What this lifecycle flow establishes or tears down. */
             description: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            component: string;
             method: string;
+            component: string;
             phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
             description?: string | undefined;
         }, {
-            component: string;
             method: string;
+            component: string;
             phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
             description?: string | undefined;
         }>, "many">>;
@@ -18024,8 +18858,8 @@ declare const SCHEMA_OF_KIND: {
         publicInterfaces: {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -18039,8 +18873,8 @@ declare const SCHEMA_OF_KIND: {
         profile?: string | undefined;
         designDepth?: "components" | "interfaces" | "implementations" | "narratives" | undefined;
         lifecycle?: {
-            component: string;
             method: string;
+            component: string;
             phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
             description?: string | undefined;
         }[] | undefined;
@@ -18068,8 +18902,8 @@ declare const SCHEMA_OF_KIND: {
         publicInterfaces?: {
             type?: "REST" | "GraphQL" | "MessageBus" | "RPC" | "Custom" | undefined;
             as?: string | undefined;
-            component?: string | undefined;
             interface?: string | undefined;
+            component?: string | undefined;
             typeDef?: string | undefined;
             details?: string | undefined;
             role?: "implement" | "call" | undefined;
@@ -18077,8 +18911,8 @@ declare const SCHEMA_OF_KIND: {
             consumers?: string[] | undefined;
         }[] | undefined;
         lifecycle?: {
-            component: string;
             method: string;
+            component: string;
             phase: "init" | "shutdown" | "cyclic" | "interrupt" | "scheduled";
             description?: string | undefined;
         }[] | undefined;
@@ -18947,33 +19781,44 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
         type: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         optional: z.ZodOptional<z.ZodBoolean>;
+        /**
+         * The field's rename trace as the producer recorded it (previousNames), so
+         * a consumer pinned to a former field name reads a rename, never an
+         * anonymous shape change. Provenance: it enters no digest.
+         */
+        formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         type: string;
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }, {
         type: string;
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }>, "many">>;
-    /** A signature's parameters (name, type, optional, description) in declared order; only on kind signature. */
+    /** A signature's parameters (name, type, optional, description, rename trace) in declared order; only on kind signature. */
     params: z.ZodOptional<z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         type: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         optional: z.ZodOptional<z.ZodBoolean>;
+        formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     }, "strip", z.ZodTypeAny, {
         type: string;
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }, {
         type: string;
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }>, "many">>;
     /** A signature's one output type; only on kind signature. */
     returns: z.ZodOptional<z.ZodString>;
@@ -19054,6 +19899,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }[];
     kind: string;
     values?: {
@@ -19065,6 +19911,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     methods?: {
         name: string;
@@ -19093,6 +19940,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     methods?: {
         name: string;
@@ -19111,6 +19959,7 @@ declare const SurfaceTypeDefSchema: z.ZodObject<{
         name: string;
         description?: string | undefined;
         optional?: boolean | undefined;
+        formerly?: string[] | undefined;
     }[] | undefined;
     kind?: string | undefined;
     returns?: string | undefined;
@@ -19467,14 +20316,14 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         /** What this capability does. */
         description: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }, {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }>, "many">>;
     details: z.ZodDefault<z.ZodString>;
@@ -19537,7 +20386,7 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         openIdConnectUrl?: string | undefined;
         example?: string | undefined;
     }>>;
-    /** The backing Portal's basePath — becomes the per-portal OpenAPI `servers` url. */
+    /** The backing Portal's basePath — joined before every endpoint path of the per-portal OpenAPI document. */
     basePath: z.ZodOptional<z.ZodString>;
     /** Stereotype of the backing component; absent on snapshots written before exports carried it. */
     componentType: z.ZodOptional<z.ZodString>;
@@ -19658,9 +20507,9 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         example?: string | undefined;
     } | undefined;
     dispatch?: {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }[] | undefined;
     formerly?: string[] | undefined;
@@ -19760,9 +20609,9 @@ declare const SurfaceContractEntrySchema: z.ZodObject<{
         example?: string | undefined;
     } | undefined;
     dispatch?: {
-        component: string;
         method: string;
         capability: string;
+        component: string;
         description?: string | undefined;
     }[] | undefined;
     formerly?: string[] | undefined;
@@ -20129,14 +20978,14 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             /** What this capability does. */
             description: z.ZodOptional<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }, {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }>, "many">>;
         details: z.ZodDefault<z.ZodString>;
@@ -20199,7 +21048,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             openIdConnectUrl?: string | undefined;
             example?: string | undefined;
         }>>;
-        /** The backing Portal's basePath — becomes the per-portal OpenAPI `servers` url. */
+        /** The backing Portal's basePath — joined before every endpoint path of the per-portal OpenAPI document. */
         basePath: z.ZodOptional<z.ZodString>;
         /** Stereotype of the backing component; absent on snapshots written before exports carried it. */
         componentType: z.ZodOptional<z.ZodString>;
@@ -20320,9 +21169,9 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         formerly?: string[] | undefined;
@@ -20422,9 +21271,9 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         formerly?: string[] | undefined;
@@ -20439,33 +21288,44 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             type: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             optional: z.ZodOptional<z.ZodBoolean>;
+            /**
+             * The field's rename trace as the producer recorded it (previousNames), so
+             * a consumer pinned to a former field name reads a rename, never an
+             * anonymous shape change. Provenance: it enters no digest.
+             */
+            formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             type: string;
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }, {
             type: string;
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }>, "many">>;
-        /** A signature's parameters (name, type, optional, description) in declared order; only on kind signature. */
+        /** A signature's parameters (name, type, optional, description, rename trace) in declared order; only on kind signature. */
         params: z.ZodOptional<z.ZodArray<z.ZodObject<{
             name: z.ZodString;
             type: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             optional: z.ZodOptional<z.ZodBoolean>;
+            formerly: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         }, "strip", z.ZodTypeAny, {
             type: string;
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }, {
             type: string;
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }>, "many">>;
         /** A signature's one output type; only on kind signature. */
         returns: z.ZodOptional<z.ZodString>;
@@ -20546,6 +21406,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[];
         kind: string;
         values?: {
@@ -20557,6 +21418,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         methods?: {
             name: string;
@@ -20585,6 +21447,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         methods?: {
             name: string;
@@ -20603,6 +21466,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         kind?: string | undefined;
         returns?: string | undefined;
@@ -20759,9 +21623,9 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         formerly?: string[] | undefined;
@@ -20774,6 +21638,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[];
         kind: string;
         values?: {
@@ -20785,6 +21650,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         methods?: {
             name: string;
@@ -20921,9 +21787,9 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             example?: string | undefined;
         } | undefined;
         dispatch?: {
-            component: string;
             method: string;
             capability: string;
+            component: string;
             description?: string | undefined;
         }[] | undefined;
         formerly?: string[] | undefined;
@@ -20940,6 +21806,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         methods?: {
             name: string;
@@ -20958,6 +21825,7 @@ declare const SurfaceSnapshotSchema: z.ZodObject<{
             name: string;
             description?: string | undefined;
             optional?: boolean | undefined;
+            formerly?: string[] | undefined;
         }[] | undefined;
         kind?: string | undefined;
         returns?: string | undefined;
@@ -21239,1146 +22107,430 @@ interface ExternalAddition {
  * declaration and its pin (lock entry and snapshot) went, or why nothing was
  * removed, in one sentence.
  */
-interface ExternalRemoval {
-    alias: string;
-    /** Whether this call took the declaration out of `.wai/project.yaml` (false on a refusal, a dry run, and an orphaned pin). */
-    removed: boolean;
-    /** Whether the alias's lock entry and pinned snapshot were removed (or would be, on a dry run). */
-    unpinned: boolean;
-    /** Why nothing was removed: the alias is neither declared nor pinned. */
-    refusal?: string;
-}
-/**
- * external_use_request — what `wairon externals use` and sdd_update_external
- * ask for: names to add to and remove from one declared external's `use`.
- */
-interface ExternalUseRequest {
-    alias: string;
-    /** Public names to import bare (`*` for all). */
-    add?: string[];
-    /** Names to stop importing. */
-    remove?: string[];
-    /** Answer what the `use` would become, writing nothing. */
-    dryRun?: boolean;
-}
-/**
- * external_use_change — the answer to changing one external's `use`: the
- * list after the change, what was added and removed, or the refusal.
- */
-interface ExternalUseChange {
-    alias: string;
-    /** Whether `.wai/project.yaml` now carries the changed `use` (false on a refusal, a dry run and when nothing changed). */
-    written: boolean;
-    /** The `use` list after the change, in order. */
-    use: string[];
-    /** The names this change imports that were not imported before. */
-    added: string[];
-    /** The names this change stops importing. */
-    removed: string[];
-    /** Why nothing was written, in one sentence. */
-    refusal?: string;
-}
-/** The verdict on one used member of a pinned external. */
-type ExternalUseState = 'unchanged' | 'changed' | 'removed' | 'unlocked' | 'unavailable' | 'renamed';
-/** external_use_status — the verdict on one used member of one pinned external. */
-interface ExternalUseStatus {
-    publicName?: string;
-    member?: string;
-    state: ExternalUseState;
-    /** EXTERNAL_CHECK_UNAVAILABLE on an unavailable entry — never a pass. */
-    code?: string;
-    detail?: string;
-    /**
-     * On a renamed use: the public name (and member, as `name.member`) the live
-     * producer's rename trace carries the used name forward to — what the
-     * consumer's references should now name.
-     */
-    renamedTo?: string;
-}
-/** external_status — the status of one declared external. */
-interface ExternalStatus {
-    alias: string;
-    project: string;
-    sourceKind: ExternalSourceKind;
-    pinned: boolean;
-    reachable: boolean;
-    stale: boolean;
-    drifted?: boolean;
-    uses: ExternalUseStatus[];
-    detail?: string;
-    /**
-     * True when the producer's root lies outside the request's reach and was
-     * therefore not read: a family run that narrowed the reach to its selection
-     * counts it in its hint rather than as a comparison that failed.
-     */
-    outOfReach?: boolean;
-    /** The content digest the lock recorded for this producer; provenance only, never compared here. */
-    pinnedDigest?: string;
-    /** The producer's commit as the lock recorded it (another repository only); provenance only. */
-    pinnedCommit?: string;
-    /**
-     * The carried facts the pinned snapshot no longer matches in the live
-     * producer (an abi, a transport, a role, the targetLanguage, a rename
-     * trace): the snapshot is stale and a re-pin refreshes it. Absent when the
-     * producer was not read or nothing carried moved.
-     */
-    staleFacts?: string[];
-}
-/** ok | drifted | incompatible | unavailable — a relation's health in one word. */
-type RelationHealth = 'ok' | 'drifted' | 'incompatible' | 'unavailable';
-/**
- * external_status.health — the relation's health in one word, the same on the
- * canvas's edges and on the hosted Relations tab. A known break outranks the
- * unknown, and the unknown outranks a benign change, so nothing that could not
- * be checked ever reads as ok. Pure: over the status's own fields.
- */
-declare function relationHealth(status: ExternalStatus): RelationHealth;
-/**
- * project_relations — one project of a family with its externals status, read
- * at its own root: what the canvas colours its consumption edges from.
- */
-interface ProjectRelations {
-    /** The consuming project's key in the bound family ('' for the bound root). */
-    project: string;
-    /** Its externals status, per use — and one per contained project member it references. */
-    externals: ExternalStatus[];
-    /** ISO-8601 time the statuses were read. */
-    comparedAt: string;
-    /** Why the project's statuses could not be read at all; then externals is empty. */
-    detail?: string;
-}
-/** external_listing — one row of `wairon externals list`. */
-interface ExternalListing {
-    alias: string;
-    project: string;
-    sourceKind: ExternalSourceKind;
-    relation?: ExternalRelation;
-    directory?: string;
-    audience: string;
-    lock?: ExternalLockEntry;
-    problem?: string;
-}
-/** One rendered per-portal OpenAPI document (see the codec's toOpenApiSet). */
-declare const NamedOpenApiSpecSchema: z.ZodObject<{
-    portalId: z.ZodString;
-    name: z.ZodString;
-    document: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    document: string;
-    portalId: string;
-}, {
-    name: string;
-    document: string;
-    portalId: string;
-}>;
-type NamedOpenApiSpec = z.infer<typeof NamedOpenApiSpecSchema>;
-declare const GroupSpecSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"group">;
-    id: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    name: string;
-    kind: "group";
-    createdAt: string;
-    updatedAt: string;
-    description?: string | undefined;
-}, {
-    id: string;
-    name: string;
-    kind: "group";
-    createdAt: string;
-    updatedAt: string;
-    description?: string | undefined;
-}>;
-type GroupSpec = z.infer<typeof GroupSpecSchema>;
-
-/**
- * technology.packages — the package names the code twin of the leakage rule
- * (TECH_LEAKAGE_IN_CODE) compares an import's package name with.
- *
- * A design names a technology the way people say it (`postgres`), while the
- * code imports its driver (`pg`). Comparing only the declared tokens left the
- * code fence inert on an ordinary design, so this module carries a CURATED,
- * DOCUMENTED table of the common packages each technology is known by, keyed by
- * the technology's usual spellings. It is deliberately short: a package belongs
- * here only when importing it can mean nothing BUT that technology. An HTTP
- * client (fetch, axios, got, undici) is never a technology — it is how an
- * Adapter reaches anything — so no entry names one.
- *
- * Extending it takes no code change: a technology written `{ name, matches }`
- * adds its own tokens, and a loaded pack contributes packages per technology
- * name (an extension pack's `technologyPackages`).
- */
-
-/** The common packages of one technology. */
-interface TechnologyPackageEntry {
-    /** The names a design writes the technology under, lower-case. */
-    names: readonly string[];
-    /** The packages importing which means that technology. */
-    packages: readonly string[];
-}
-/**
- * The built-in table. Documented in docs/cli.md ("Technologies and their
- * packages"); keep the two in step.
- */
-declare const TECHNOLOGY_PACKAGES: readonly TechnologyPackageEntry[];
-/**
- * technology.packages — the entry's tokens, then the built-in table's packages
- * for its name, then the packages `contributed` lists under its name (what
- * loaded packs contribute, keyed by technology name), lower-cased and
- * de-duplicated in that order. Pure: the contributions are handed in.
- */
-declare function technologyPackages(tech: Technology, contributed?: Readonly<Record<string, readonly string[]>>): string[];
-
-/**
- * The type identifiers a type string names, with comments, trailing prose and
- * string literals stripped. Duplicates are kept, in order of appearance.
- */
-declare function extractTypeIdentifiers(typeStr: string): string[];
-/**
- * The method shape the type references are read from: a contract method or a
- * type method (whose params feed its references exactly as a contract
- * method's do). The text and returns may be absent while a method is still in
- * its stored form — a sourced method states neither, and a params-bearing one
- * need not store its text — and an absent one names nothing.
- */
-interface MethodLike {
-    signature?: string;
-    returns?: string;
-    params?: {
-        name: string;
-        type: string;
-    }[];
-}
-/**
- * method_signature.typeRefs — the named types a method references. Structured
- * `params` are authoritative when present (no prose parsing): the named
- * references of every param type and of the returns, each parsed under the
- * grammar. Otherwise the prose signature and the returns are tokenized
- * leniently, as the unstructured form always was.
- */
-declare function methodTypeRefs(m: MethodLike): string[];
-/**
- * type_spec.signatureTypeRefs — the named types a signature type references:
- * every param type, then its returns, each parsed under the grammar — the
- * references a signature carries in place of fields. None for any other kind,
- * whose references are its fields'.
- */
-declare function signatureTypeRefs(type: Pick<TypeSpec, 'kind' | 'params' | 'returns'>): string[];
-/**
- * method_signature.genericParameters — the generic parameters declared before
- * the parameter list of the method's prose signature (find<T>(id: string)
- * gives T).
- */
-declare function methodGenericParameters(method: {
-    signature?: string;
-}): Set<string>;
-/**
- * reference_resolution.nameKey — the one key a bare name is compared by,
- * locally and through imports alike: lower-cased, every character outside
- * [a-z0-9] removed, so `SharedError`, `shared-error` and `shared_error` are
- * one name. It is normalizePart, the per-segment normalization
- * type_spec.matchesRef already applies.
- */
-declare function nameKey(name: string): string;
-/**
- * Whether a written type reference names a type id: the reference's `::` or
- * `.` segments are a suffix of the id's, compared ignoring case and
- * punctuation.
- */
-declare function matchTypeRef(ref: string, typeId: string): boolean;
-/**
- * type_spec.qualifiedId — the type's id qualified by its owning subsystem, when
- * the id is not already qualified.
- */
-declare function qualifiedTypeId(type: Pick<TypeSpec, 'id' | 'subsystem'>): string;
-/**
- * type_spec.matchesRef — whether a written type reference names this type: the
- * reference's `::` or `.` segments are a suffix of the qualified id, compared
- * ignoring case and punctuation.
- */
-declare function typeMatchesRef(type: Pick<TypeSpec, 'id' | 'subsystem'>, ref: string): boolean;
-/** type_spec.genericParameters — the generic parameters declared in the type's name (Page<T> gives T). */
-declare function typeGenericParameters(type: Pick<TypeSpec, 'name'>): Set<string>;
-/**
- * type_spec.fieldTypeRefs — the named types one of this type's field types
- * references (type_expression.namedRefs of the field's parsed type), with the
- * type's own generic parameters left out (compared ignoring case). A field
- * type that does not parse names nothing: its problem is
- * TYPE_EXPRESSION_INVALID's to report. It takes the field's type rather than
- * its name, because nothing makes field names unique within a type.
- */
-declare function fieldTypeRefs(type: Pick<TypeSpec, 'name'>, fieldType: string): string[];
-/** interface_spec.genericParameters — the generic parameters declared in the interface's name. */
-declare function interfaceGenericParameters(intf: Pick<InterfaceSpec, 'name'>): Set<string>;
-
-/** type_dialect — one language's reading and writing of the neutral grammar. */
-interface TypeDialect {
-    /** The language this dialect reads and writes, as the code analyzer names it. */
-    language: string;
-    /** The canonical expression a code annotation spells, or null when it has no canonical reading. */
-    read(annotation: string): TypeExpression | null;
-    /** Whether a code annotation and a canonical spec expression describe the same type. */
-    agrees(annotation: string, expression: TypeExpression, codeNames: Map<string, string>): boolean;
-    /** This language's idiomatic spelling of a canonical expression. */
-    write(expression: TypeExpression): string;
-    /** The write table as lines an implementer brief carries. */
-    mappingLines(): string[];
-}
-/** type_dialect.forLanguage — the dialect shipped for a language, or null when none reads it yet. */
-declare function typeDialectFor(language: string): TypeDialect | null;
-/**
- * type_dialect.mappingFor — the write table an implementer brief carries for
- * a language: a shipped dialect's mappingLines, else a MAPPING-ONLY table for
- * a language no analyzer reads yet (Rust, Python), whose last line says that
- * code conformance does not compare its types. Null for a language with
- * neither.
- */
-declare function typeMappingFor(language: string): string[] | null;
-
-/**
- * The step graph of one narrative (step_graph): the SINGLE source of truth for
- * successor semantics (fall-through + jumps; loop and try headers carry both
- * their body edge and their after-region exit edge; return/throw terminate).
- * The narrative-reachability check and the antipattern analysis both read
- * it, so the two never disagree about what "next" means.
- */
-interface StepGraph {
-    /** The narrative's step numbers in ascending order. */
-    stepNumbers: number[];
-    /** The step with this number, if there is one. */
-    stepAt(stepNumber: number): NarrativeStep | undefined;
-    /** The next step number in ascending order, ignoring jumps and parallel joins. */
-    nextOf(stepNumber: number): number | undefined;
-    /** The distinct existing step numbers flow can continue at from this step. */
-    successorsOf(stepNumber: number): number[];
-}
-/**
- * method_implementation.stepGraph — the step graph of the method's narrative.
- * Simple steps fall through; a branch continues at its true and false steps, a
- * switch at its cases and default; a loop at its body and the step after its
- * region; a try at its body, catch steps, finally step and the step after its
- * region; a parallel fans out to its arms, whose last steps continue at the
- * join; a jump at its target; return and throw end the path.
- */
-declare function stepGraph(method: Pick<MethodImplementation, 'narrative'>): StepGraph;
-
-/** The finding codes a narrative step-configuration problem maps to. */
-type StepConfigCode = 'DUPLICATE_STEP_LABEL' | 'MALFORMED_FLOW_STEP' | 'INVALID_STEP_JUMP' | 'FOREIGN_STEP_FIELD';
-/**
- * One thing wrong with a narrative's step configuration (step_config_problem):
- * the step it sits on, the finding code it maps to, and the detail a rule
- * appends to its own "Method X in implementation Y" prefix. Duplicate labels,
- * missing or misplaced flow config, and jumps that land nowhere are all
- * reported through this one shape.
- */
-interface StepConfigProblem {
-    /** The step the problem sits on; a duplicate label names the earlier step in its detail. */
-    stepNumber: number;
-    /** The finding code this problem maps to. */
-    code: StepConfigCode;
-    /** The problem stated in full, ready to follow a rule's own location prefix. */
-    detail: string;
-}
-/**
- * What a narrative's step configuration says about itself (step_config_verdict):
- * the problems it carries, in step order, and whether its control flow is
- * SOUND — no duplicate step number, no missing or misplaced flow config, and
- * no jump that lands outside the narrative. A duplicate label is a problem but
- * not an unsoundness: labels name steps, they do not route flow.
- *
- * Soundness is the gate every later phase runs behind. Reachability, region
- * nesting and jump-edge judgement all read the step graph, and a graph built
- * over jumps that target nothing reports steps as dead that are merely
- * mis-numbered — wrong findings, not just noisier ones.
- */
-interface StepConfigVerdict {
-    /** The step-config problems, in step order: labels first, then numbering, then per-step config and jump targets. */
-    problems: StepConfigProblem[];
-    /** True when nothing found makes the control flow unreadable — the precondition for judging structure. */
-    sound: boolean;
+/** external_removal_plan — what removing one external takes out: its declaration, its pin, or both. */
+interface ExternalRemovalPlan {
+    /** Whether the declaration in `.wai/project.yaml` goes. */
+    declaration: boolean;
+    /** Whether the lock entry and pinned snapshot go. */
+    pin: boolean;
 }
-/**
- * The configuration each narrative step TYPE may carry, beyond what every step
- * carries. This is the field set a retype rebuilds against, and the field set
- * a stored step is judged against.
- *
- * Changing a step's `type` used to merge the new type's fields over the old
- * step's and leave the rest standing, so a `branch` that became a `call` kept
- * its `condition` and `onFalseStep`: a step the schema accepts, a write that
- * reports success, and a MALFORMED_FLOW_STEP at the next validate, blamed on
- * the narrative rather than on the edit that made it. The writer no longer
- * leaves those behind; FOREIGN_STEP_FIELD reports the ones already written.
- */
-declare const STEP_TYPE_FIELDS: Readonly<Record<string, readonly string[]>>;
-/**
- * What a step carries whatever its type — the human's own content. A retype
- * keeps these: the author is changing HOW the step works, not what it is for,
- * and re-typing a step should never cost them the sentence they wrote or the
- * anchor other steps address it by.
- */
-declare const STEP_COMMON_FIELDS: readonly string[];
-/** The transient `*Label` twin of each jump-by-number field, resolved and dropped at write time. */
-declare const STEP_LABEL_TWINS: Readonly<Record<string, string>>;
-/** Every field a step of this type may carry, including the transient label twins. */
-declare function stepFieldsFor(type: string): Set<string>;
-/**
- * narrative_step.foreignFields — the fields this step carries that its own
- * `type` cannot: everything set on it beyond the common fields and the ones
- * its type adds. An unknown step type has no table, so nothing is foreign to
- * it — the schema is what names that.
- */
-declare function narrativeStepForeignFields(step: NarrativeStep): string[];
-/**
- * method_implementation.stepConfigVerdict — the step-config problems of this
- * method's narrative and whether its control flow is sound. The schema keeps
- * every flow field optional, so this derivation is what holds each step type
- * to the config it needs, each label to one step, each step number to one
- * step, and every jump field to a step number the narrative actually has.
- */
-declare function stepConfigVerdict(method: Pick<MethodImplementation, 'narrative'>): StepConfigVerdict;
-
-type AnalysisGrade = 'exact' | 'pattern' | 'generic';
-type SourceFileStatus = 'analyzed' | 'missing' | 'escaped' | 'unreadable';
-/**
- * One runtime (value) import binding a file makes: the module specifier a
- * local name came from, and whether it was bound as a whole NAMESPACE.
- *
- * The namespace flag separates the two readings of `x.save()`. For a namespace
- * import (`import * as specs from './specs.js'`), `specs.save` IS that
- * module's own export, so the call site resolves to the module. For a named or
- * default binding, `db.save` is a property of a VALUE that module handed over,
- * and where that property's function was written is beyond a pure model — so
- * it resolves to nothing rather than to the module.
- *
- * Type-only imports are never recorded: a type binding cannot be a call origin.
- */
-/**
- * One name a file republishes from another module (source_file_facts
- * reexportBindings): `export { local as exported } from 'from'`, or a star
- * re-export, which republishes every name its module exports under that same
- * name and is written with `*` on both sides.
- */
-interface ReexportBindingFact {
-    /** The name this file publishes it under; `*` for a star re-export. */
-    exported: string;
-    /** The name the module it comes from publishes it under; `*` for a star re-export. */
-    local: string;
-    /** The module specifier, exactly as written. */
-    from: string;
-}
-/**
- * One name a file publishes BOUND to another name of its own scope, with no
- * module specifier of its own (source_file_facts exportAliases): an export
- * specifier `export { local as exported }`, renamed or not, or an
- * identifier-valued property of an exported top-level object literal —
- * `{ exported: local }` or the shorthand `{ exported }` — which then carries
- * the object's binding name as its `container`. The local name is this file's
- * own declaration, or an import binding that leads on to the module it came
- * from: either way the forwarding is written down, one hop away.
- */
-interface ExportAliasFact {
-    /** The name this file publishes: the export specifier's exported name, or the object property's key. */
-    exported: string;
-    /** The name of this file's own scope it is bound to: a local declaration, or an import binding. */
-    local: string;
-    /** The exported object literal's binding name, set only for a property alias — what an `exportedVia` handle names. */
-    container?: string;
-}
-interface ImportBindingFact {
-    /** The module specifier the binding came from, exactly as written. */
-    from: string;
-    /** True for `import * as name from …` — the only binding whose property calls are that module's own exports. */
-    namespace?: boolean;
-    /** The name the module publishes it under, set only when the import renamed it (`import { save as store }`). */
-    imported?: string;
-}
-/**
- * One call SITE SHAPE inside a named function-like: the invoked name together
- * with how the call was written. Shape is what a pure model can honestly say
- * about a call's ORIGIN — with no type checker, `save(x)`, `ledger.save(x)`,
- * `this.store.save(x)` and `new Ledger(db).save(x)` are four different
- * questions, and collapsing them onto the name "save" is what let a call into
- * an unrelated module count as realizing a narrative step.
- *
- * Sites are deduplicated per shape, never counted: the checks that read them
- * ask where a call could land, never how often it was written.
- */
-interface CallSiteFact {
-    /** The invoked name: the identifier of a bare call, the property name of a member call. */
-    name: string;
-    /** True when the call was written as a member access (`receiver.name(…)`). */
-    member: boolean;
-    /**
-     * The receiver identifier — set only when the receiver is a plain identifier
-     * (`specs.save()` → "specs"). The one receiver that can be PROVEN, when the
-     * name is a namespace import binding and its properties are that module's
-     * own exports — and otherwise a receiver to follow past the value it holds,
-     * through the type the file ANNOTATES the name with.
-     */
-    via?: string;
-    /**
-     * The instance FIELD the receiver is — set only when the call was written
-     * `this.<field>.name(…)` (`this.store.save()` → "store"), and never together
-     * with `via`. A receiver a pure model can follow past the value it holds,
-     * because the class DECLARES what the field is; what that type resolves to
-     * is a POSSIBLE origin, never a proven one, since the declared type says
-     * what a collaborator is and not which class ships the body.
-     */
-    field?: string;
-    /**
-     * The CLASS the receiver was constructed from — set only when the call was
-     * written `new Class(…).name(…)` (`new ApprovalRegistry(store).create()` →
-     * "ApprovalRegistry"), and never together with `via` or `field`. Another
-     * receiver a pure model can follow, because the code NAMES the class it
-     * built. Like a declared field type it is a POSSIBLE origin and never a
-     * proven one: a method the class INHERITS is written in its base's module,
-     * not in the constructed class's.
-     */
-    constructed?: string;
-    /**
-     * The function whose RESULT the receiver is — set only when the call was
-     * written `fn(…).name(…)` with `fn` a plain identifier
-     * (`current().updateSpec()` → "current"), and never together with `via`,
-     * `field` or `constructed`. Followed through what the code writes down
-     * about fn's result (SourceFileFacts.returnTypes): a POSSIBLE origin and
-     * never a proven one, and only where the module that type leads to holds a
-     * body under the invoked name.
-     */
-    returnedBy?: string;
-    /**
-     * The top-level named class whose own method the call sits in — set only
-     * when the call was written `this.name(…)` directly inside a method,
-     * accessor or constructor of that class (an arrow function keeps `this`; a
-     * nested function expression rebinds it and records nothing). A POSSIBLE
-     * origin and never a proven one, since a subclass may override the method,
-     * and only where the class holds a body under the invoked name.
-     */
-    enclosingClass?: string;
-    /**
-     * The receiver written as a CHAIN of property accesses — set only when the
-     * call was written `this.<field>.<property>….name(…)`
-     * (`this.c.tracker.checkIn()` → ["this", "c", "tracker"]) or
-     * `<name>.<property>….name(…)` (`deps.tracker.checkIn()` → ["deps",
-     * "tracker"]), and never together with `via`, `field`, `constructed`,
-     * `returnedBy` or `enclosingClass`. The shape constructor-injected
-     * collaborators take when they arrive as ONE bag object. Followed link by
-     * link through what the code DECLARES each link to be — the root's field
-     * or annotated type, then each property's declared type on the shape that
-     * declares it — and, like every receiver past an import binding, a
-     * POSSIBLE origin and never a proven one.
-     */
-    receiverPath?: string[];
-    /**
-     * The file this site was READ in, set only when it is not the file these
-     * facts describe — a pure re-export barrel carries the sites of the function
-     * it publishes. A carried site's bare names and receivers resolve in that
-     * file's scope, never in the barrel's.
-     */
-    from?: string;
-}
-/**
- * One function-like BODY under its name, with where it is bound — the
- * identity that tells same-named functions in one file apart.
- *
- *   module     (no `container`, no `nested`) a top-level function declaration,
- *              or a function/arrow initializer of a top-level variable: what
- *              the bare name means anywhere in the module's scope.
- *   member     `container` set: a member of a top-level named class, or a
- *              property of an object literal a top-level variable is bound to
- *              (`const store = { save() {} }` → container "store"). Reachable
- *              only through that container, never by the bare name.
- *   nested     `nested` set: any other binding — a function inside a
- *              function, a member of a class or object literal the model
- *              cannot name. A nested body can shadow the bare name in the
- *              scope it sits in, so where one exists the name stays ambiguous.
- */
-interface FunctionBodyFact {
-    /** The named class or top-level object literal the body is a member of. */
-    container?: string;
-    /** True when the body is bound somewhere the model cannot name. */
-    nested?: boolean;
-    /** The call sites written inside this body alone. */
-    sites: CallSiteFact[];
-}
-/**
- * One data member of a shape a file declares: its name, and whether the code
- * lets it be ABSENT.
- *
- * Absent-able is the only optionality worth recording, because it is the only
- * one a spec can be wrong about in a way a reader would notice — a field the
- * spec calls required that the code lets you omit is a promise the data does
- * not keep. A wrapper that FILLS a missing key is not absent-able: the value
- * the type finally holds always has it, which is the shape the spec describes.
- */
-interface ShapeMemberFact {
-    /** The member's name, as the code spells it. */
-    name: string;
-    /** Whether the code lets the member be absent from a value of this shape. */
-    optional: boolean;
-}
-/**
- * One parameter of a function as the code declares it: what it is called, what
- * it is annotated with, and whether a caller may leave it out.
- *
- * The TYPE is what makes a RENAME tellable from a dropped parameter —
- * `seed(config: HostConfig)` realized as `bootstrapInstance(cfg: HostConfig)`
- * is one parameter under two names, and matching on names alone reads it as a
- * parameter the code lost. A parameter bound by destructuring has no name to
- * compare, so it records none rather than inventing one: a guess about
- * somebody's signature is worse than silence, exactly as it is for a field.
- */
-interface ParameterFact {
-    /** The parameter's name, absent when it is bound by a destructuring pattern instead. */
-    name?: string;
-    /** The type it is annotated with, exactly as written and whitespace-normalized; absent when the code annotates nothing. */
-    type?: string;
-    /** Whether a caller may leave it out — marked optional, given a default, or a rest parameter. */
-    optional: boolean;
-}
-/**
- * One route a router function handles, rebuilt from the conditions that guard
- * the branch serving it — the branch's own AND every enclosing one on the path
- * taken, because routers nest: an outer check on the first segment, an inner
- * one on the rest. Reading only the innermost guard would turn every route
- * into `/*` followed by whatever the inner branch happened to check.
- *
- * A segment is the literal the code compares it to, or `*` where nothing
- * constrains it. A leading `*` is usually the segment the listener's mount
- * already guarantees, which the router never re-checks — so it is left open
- * here and completed by whoever knows the mount.
- *
- * Only one idiom is read: a method comparison together with comparisons on the
- * path's split segments and their count. A router written another way yields
- * nothing, and the reader reports that as unread rather than passing it — a
- * check that cannot see a router must say so rather than stay quiet.
- */
-interface RouteFact {
-    /** The HTTP method the branch requires. */
-    verb: string;
-    /** The path's segments in order: the literal compared against, or `*` where nothing constrains it. */
-    segments: string[];
-    /**
-     * Whether the branch pins the number of segments. When it does not, the path
-     * may continue past the last one read, so the route covers any longer path
-     * with the same leading segments.
-     */
-    exactLength: boolean;
-}
-/** How a type shape's members were read: listed by the shape itself, or followed one hop from an alias to the value its shape comes from. */
-type ShapeOrigin = 'declared' | 'derived';
-/**
- * The members of one named shape a file declares — what a data type IS, read
- * off the code so a type spec's claim about it can be checked.
- *
- * Two origins answer, and the difference is recorded rather than smoothed
- * away. A DECLARED shape lists its own members, so the file is the whole
- * answer. A DERIVED one names a VALUE instead — an alias resolved one hop to
- * the object literal its schema is built from, where the keys are the members
- * — so the answer is as good as that hop and no better, and a hop that lands
- * on nothing readable records no shape at all. Silence, not a guess: a wrong
- * member list is worse than none, because nothing downstream would correct it.
- *
- * Methods are kept apart from fields because a spec models them on a different
- * axis — the one `typeRealization` already judges. Counting a behavioural
- * interface's method signatures as data would accuse every one of them of
- * carrying undeclared state.
- */
-interface TypeShapeFact {
-    /** How the members were read. */
-    origin: ShapeOrigin;
-    /** The data members, each with whether the code lets it be absent. */
-    fields: ShapeMemberFact[];
-    /** The method-style members, kept on the axis a spec models them on. */
-    methods: string[];
-    /**
-     * True when the shape EXTENDS another, so members it does not list exist
-     * but are not in this file to count. Presence and absence are therefore
-     * different questions for it: what it shows can be judged, what it omits
-     * cannot.
-     */
-    inherited?: boolean;
-}
-interface SourceFileFacts {
-    /** Project-relative resolved source path (many implementations may share it, N:1). */
-    path: string;
-    status: SourceFileStatus;
-    /** Effective language the file was analyzed as. */
-    language?: string;
-    analysisGrade?: AnalysisGrade;
-    /**
-     * Declaration-tier anchors: named declarations at any nesting depth,
-     * destructuring bindings, object-literal keys, import bindings, and export
-     * specifiers (export-* barrels chased through relative specifiers).
-     */
-    declaredNames: string[];
-    /** Weaker anchors: exact string-literal occurrences (tool/route registrations). */
-    anchoredNames: string[];
-    /** Exported bindings (Level 2 dependency-conformance and UNDECLARED_EXPORT fuel). */
-    exportedNames: string[];
-    /**
-     * Runtime import/require module specifiers (dependency-conformance fuel).
-     * Type-only imports and export-from specifiers are excluded — type coupling
-     * is allowed by default, and re-exporting is surface republication, not
-     * collaboration.
-     */
-    imports: string[];
-    /** Module specifiers of export-from declarations (surface republication). */
-    reexports: string[];
-    /**
-     * What each export-from declaration republishes, name by name: a named one
-     * with both sides of its rename (`export { a as b } from 'm'` publishes `b`
-     * as m's `a`), a star with `*` on both sides. Runtime re-exports only — a
-     * type-only one republishes no function. EXACT grade only: it is what lets a
-     * reader follow a republished name to the module that wrote it, and a
-     * weaker grade leaves it unset rather than guess.
-     */
-    reexportBindings?: ReexportBindingFact[];
-    /**
-     * The forwarding bindings the file publishes with no module specifier of
-     * its own (see ExportAliasFact): each runtime `export { local as exported }`
-     * specifier, renamed or not, and each identifier-valued property of an
-     * exported top-level object literal, under that object's binding name.
-     * EXACT grade only. The analyzer carries the local name's body onto the
-     * published one when the local name settles on exactly one — a module-scope
-     * body of this file with no nested same-named one, or an import binding
-     * whose module holds one — and leaves the published name bodiless otherwise.
-     */
-    exportAliases?: ExportAliasFact[];
-    /**
-     * The type name each named function-like RETURNS, by function name,
-     * recorded only where the code settles it: a return annotation naming a
-     * type outright (`Promise<T>` unwrapped), else, unannotated, a body whose
-     * ONE return statement constructs a plainly named class. Same-named
-     * functions that disagree, a generic, union or literal annotation, and
-     * several returns record nothing. EXACT grade only. What a `fn().method()`
-     * receiver is followed through.
-     */
-    returnTypes?: Record<string, string>;
-    /**
-     * Cyclomatic complexity per named function-like (function/method/accessor
-     * declarations, and function/arrow initializers of named slots). EXACT grade
-     * only — lower grades omit the map rather than guess. Same-named functions
-     * in one file record their maximum. Fuel for the detail-sufficiency lint.
-     */
-    functionComplexity?: Record<string, number>;
-    /**
-     * Direct call sites per named function-like: every call written inside the
-     * function body, with its shape (see CallSiteFact) — nested NAMED functions
-     * excluded (they carry their own entries), anonymous callbacks included.
-     * EXACT grade only. Same-named functions union their sites.
-     *
-     * A function-like WITH A BODY always gets an entry, empty when it calls
-     * nothing; a name with NO entry has no body in this file to read — a bare
-     * declaration, an overload signature, an ambient declaration, an interface
-     * member, a plain value binding or an imported name. That difference is the
-     * whole of hasFunctionBody, which is why an empty entry is never dropped.
-     *
-     * Fuel for the call-step realization checks (Level 3).
-     */
-    functionCallSites?: Record<string, CallSiteFact[]>;
-    /**
-     * The same call sites, BODY by body, under each function-like's name: one
-     * entry per body, carrying WHERE that body is bound (see FunctionBodyFact).
-     * EXACT grade only. Where functionCallSites unions every same-named body,
-     * this keeps them apart, so an exported facade `save` and the class member
-     * `Workspace.save` it forwards to are read as the two functions they are.
-     * Which body a NAME means is bodySitesOf's question, and it answers only
-     * where the code itself settles it.
-     */
-    functionBodies?: Record<string, FunctionBodyFact[]>;
-    /**
-     * Runtime (value) import bindings by local name (see ImportBindingFact).
-     * EXACT grade only — a weaker grade sees module specifiers but never which
-     * local name they bound.
-     */
-    importBindings?: Record<string, ImportBindingFact>;
-    /**
-     * The type names an instance FIELD is DECLARED with, by field name — read
-     * off class property declarations and constructor parameter properties,
-     * which is where a constructor-injected collaborator says what it is.
-     * EXACT grade only.
-     *
-     * Same-named fields of different classes in one file keep EVERY declared
-     * type: the file cannot say which class a call site's `this` was, and a
-     * wider answer only ever widens what a call may have reached. A field with
-     * no annotation records nothing — what an initializer INFERS is not what
-     * the code declares, and a guess is not a fact.
-     */
-    fieldTypes?: Record<string, string[]>;
-    /**
-     * The type names a LOCALLY BOUND name is DECLARED with, by name — read off
-     * function and method parameters and off variable declarations that carry
-     * an annotation, which is where a module that wires its collaborators as
-     * closures writes down what each one is. EXACT grade only.
-     *
-     * Keyed by name across the WHOLE file, as `fieldTypes` is: the facts cannot
-     * say which function a call site sits in, and a receiver is as often a
-     * parameter of an ENCLOSING function as of the one that calls it — a
-     * closure captures it, which is the shape this records at all. Same-named
-     * bindings therefore keep EVERY declared type, and a wider answer only ever
-     * widens what a call may have reached. A binding the file annotates with
-     * nothing records nothing, and so does one annotated with anything but a
-     * plain type reference or a member-preserving utility (`Pick`, `Omit`,
-     * `Partial`, `Required`, `Readonly`) around one, which names the type it
-     * wraps: what an initializer INFERS is not what the code
-     * declares, and a guess is not a fact.
-     */
-    localTypes?: Record<string, string[]>;
-    /**
-     * The module specifier each TYPE-ONLY import binding came from, by local
-     * name. EXACT grade only.
-     *
-     * The half of the import list `importBindings` deliberately leaves out,
-     * because a type binding can never be a call ORIGIN — and exactly what a
-     * declared field type is resolved through, which is why it is kept apart
-     * rather than folded in.
-     */
-    typeOnlyBindings?: Record<string, string>;
-    /**
-     * The type names each PROPERTY of a named shape the file declares is
-     * DECLARED with, keyed `<shape>.<property>` — an interface's or a type
-     * literal alias's property signatures, and a class's property declarations
-     * and constructor parameter properties. EXACT grade only.
-     *
-     * What a receiver CHAIN (`CallSiteFact.receiverPath`) is followed through:
-     * a bag of collaborators handed to a constructor names each one's type
-     * exactly here. Read the way `fieldTypes` is, and a property annotated with
-     * anything else records nothing.
-     */
-    memberTypes?: Record<string, string[]>;
-    /**
-     * The ONE type each type alias NAMES outright, by alias name —
-     * `type Contract = Pick<HabitRepository, 'find'>` names HabitRepository,
-     * `type Store = SpecStore` names SpecStore. EXACT grade only. Read the way
-     * `fieldTypes` is, so a union, an intersection, a literal or any other
-     * generic names nothing. The one hop a declared type is followed through
-     * when it is an alias of this file.
-     */
-    aliasTargets?: Record<string, string>;
-    /**
-     * The interface names each named class's `implements` clause writes, by
-     * class name; exact grade only. What lets a receiver whose declared type is
-     * an interface written in a shared contracts file be followed to the class
-     * that implements it, wherever that class lives — a possible origin, never
-     * a proven one, like every declared type.
-     */
-    implementsClauses?: Record<string, string[]>;
-    /**
-     * The members of each named shape the file declares, by declaration name
-     * (see TypeShapeFact). EXACT grade only — below it a member list cannot be
-     * told from a mention, and a guess about somebody's data model is worse
-     * than silence.
-     *
-     * What lets a type spec's `fields` be CHECKED rather than read as truth by
-     * the ERD, the briefs and every implementer. A wrong method signature
-     * eventually breaks at a call site; a type spec that lies about its data is
-     * only ever read by humans and agents, so nothing corrects it until
-     * somebody measures it against the code.
-     */
-    typeShapes?: Record<string, TypeShapeFact>;
-    /**
-     * The parameter lists of each named function-like in the file, by name (see
-     * ParameterFact) — what lets a contract's declared `params` be checked
-     * against the signature that realizes them, the last of the three
-     * code-to-spec readings nothing had ever made. EXACT grade only: below it a
-     * parameter list cannot be told from a call.
-     *
-     * EVERY body under a name is kept, not the first: a file routinely holds a
-     * class member and the module-level facade that forwards to it under one
-     * name, with different parameters, and picking one silently drops the
-     * other's leading argument from view. Same-named bodies therefore keep every
-     * candidate, exactly as the field-type facts do, and a reader accuses only
-     * what all of them agree on.
-     *
-     * Overloads record the IMPLEMENTATION signature, the one with a body,
-     * because that is the one a caller actually reaches — and a name with no
-     * entry at all has no signature here to read, which is the silence a
-     * forwarding file owes: that the body is not here is already
-     * `methodRealization`'s finding.
-     */
-    functionParams?: Record<string, ParameterFact[][]>;
-    /**
-     * The routes each named function-like in the file handles, by name (see
-     * RouteFact) — what lets a listener's mount be read against the contract
-     * endpoints of the portal it serves, so a route the router answers that no
-     * contract declares cannot go unnoticed again. EXACT grade only: reading a
-     * guard as a route needs the conditions as expressions, not as text.
-     *
-     * A function with no recognisable route records NO entry rather than an
-     * empty one — an empty guess would read as "a router with no routes", and
-     * the reader needs to tell a router it could not read from one it read.
-     * Same-named bodies union their routes; nested NAMED functions carry their
-     * own entries, while anonymous callbacks count into the enclosing one.
-     */
-    functionRoutes?: Record<string, RouteFact[]>;
-    /**
-     * The named function-likes in the file that complete LATER — declared
-     * `async`, or annotated to return a Promise — listed once per such BODY, in
-     * the order the bodies are met, exactly as `functionParams` keeps one
-     * signature per body. A name with several bodies (a class member and the
-     * module-level facade forwarding to it) is therefore judged on what they ALL
-     * say: as many entries as signatures is every body, none is no body. What
-     * ASYNC_MISMATCH compares a contract method's `async` returns with. EXACT
-     * grade only: below it a body cannot be told from a call.
-     */
-    asyncFunctions?: string[];
-    /**
-     * The values of each ENUM-LIKE declaration in the file, by declaration name,
-     * in declared order: a string-literal union alias (`type E = 'a' | 'b'`),
-     * the string array a `z.enum([...])` constant holds — an alias
-     * `z.infer<typeof X>` followed one hop, as a derived shape is — or a string
-     * enum's member values. What UNREALIZED_ENUM_VALUE and UNDECLARED_ENUM_VALUE
-     * read. EXACT grade only; a union mixing in anything but string literals is
-     * not enum-like and is left out.
-     */
-    enumValues?: Record<string, string[]>;
-    /**
-     * The right side of each TYPE ALIAS the file declares, as written, by alias
-     * name — every alias whose right side is not an object shape
-     * (`type PackPath = string`). What a named scalar's holds is compared with
-     * through the file's dialect (TYPE_HOLDS_MISMATCH). EXACT grade only.
-     */
-    aliasTypes?: Record<string, string>;
-    /**
-     * Module-scope mutable bindings (`let`/`var` at the top level of the file).
-     * EXACT grade only. The static approximation of held state a logic
-     * component may be hiding — fuel for the HIDDEN_STATE lint. (Mutation of
-     * const-bound containers is invisible to this collection; the lint says so.)
-     */
-    topLevelMutableBindings?: string[];
-    /**
-     * True when the file declared nothing of its own and only re-exported —
-     * a pure re-export barrel, which has no code to claim. Measured BEFORE the
-     * barrel chase folds the republished names into `declaredNames`, since
-     * after it a barrel is indistinguishable from the files it publishes.
-     * EXACT grade only: a weaker grade cannot tell a barrel from a file it
-     * failed to parse, so it leaves this unset rather than guess.
-     */
-    reexportOnly?: boolean;
-    /**
-     * Every call expression of the file as the TypeScript type checker resolved
-     * it (see ResolvedCallFact), in source order. EXACT grade only, and only
-     * where a compiler with a type checker was loaded. What the Portal
-     * write-shortcut twin and the unnarrated-write check read first: the
-     * checker follows every spelling of a receiver to the declaration, where
-     * the shape facts follow the spellings they know.
-     */
-    resolvedCalls?: ResolvedCallFact[];
+interface ExternalRemoval {
+    alias: string;
+    /** Whether this call took the declaration out of `.wai/project.yaml` (false on a refusal, a dry run, and an orphaned pin). */
+    removed: boolean;
+    /** Whether this call removed the alias's lock entry and pinned snapshot (false on a refusal and a dry run). */
+    unpinned: boolean;
+    /** Present, true, on a dry run: nothing was written, and `wouldRemove` says what the real run removes. */
+    dryRun?: boolean;
+    /** On a dry run: what the real run would take out — the declaration, the pin, or both. */
+    wouldRemove?: ExternalRemovalPlan;
+    /** Why nothing was removed: the alias is neither declared nor pinned. */
+    refusal?: string;
 }
 /**
- * One place a call the type checker resolved can land in THIS project's code:
- * the file holding the declaration (or an implementor of it), the class,
- * interface or shape it is a member of, and the member's name. A declaration
- * in a dependency's typings or the language's own library is no target — it
- * is nobody's component.
+ * external_use_request — what `wairon externals use` and sdd_update_external
+ * ask for: names to add to and remove from one declared external's `use`.
  */
-interface CallTargetFact {
-    /** Canonical project-relative path of the file holding the declaration or implementor. */
-    path: string;
-    /** The class, interface or named shape the member belongs to; absent for a module-level function. */
-    container?: string;
-    /** The declared name of the method or function the call reaches. */
-    member: string;
-    /**
-     * `declaration` when the checker named this declaration itself;
-     * `implementor` when the declaration sits in an interface or type shape and
-     * this is a class of the project that realizes it.
-     */
-    via: 'declaration' | 'implementor';
+interface ExternalUseRequest {
+    alias: string;
+    /** Public names to import bare (`*` for all). */
+    add?: string[];
+    /** Names to stop importing. */
+    remove?: string[];
+    /** Answer what the `use` would become, writing nothing. */
+    dryRun?: boolean;
 }
 /**
- * One call expression of a file as the TypeScript type checker resolved it:
- * what was invoked, how it was written, which body it sits in, and every
- * place in this project it can land. Where CallSiteFact records the SHAPE a
- * pure model can follow, this records the checker's answer — so a receiver
- * reached through an alias, a field chain, an element access, a destructured
- * method, a factory's result, a barrel or a port interface lands where the
- * checker says it lands, whatever its spelling.
+ * external_use_change — the answer to changing one external's `use`: the
+ * list after the change, what was added and removed, or the refusal.
  */
-interface ResolvedCallFact {
-    /** The invoked name: the declared member a target names, else the name as written. */
-    name: string;
-    /** The callee as written, whitespace-collapsed and shortened — what a finding quotes. */
-    written: string;
-    /** The innermost named function-like the call sits in; absent at module scope. */
-    enclosing?: string;
-    /** The top-level class or object literal whose member that function-like is, when it is one. */
-    enclosingContainer?: string;
-    /** Every place in this project's own code the call can land; empty for a call into a dependency or the language library. */
-    targets: CallTargetFact[];
+interface ExternalUseChange {
+    alias: string;
+    /** Whether `.wai/project.yaml` now carries the changed `use` (false on a refusal, a dry run and when nothing changed). */
+    written: boolean;
+    /** The `use` list after the change, in order. */
+    use: string[];
+    /** The names this change imports that were not imported before. */
+    added: string[];
+    /** The names this change stops importing. */
+    removed: string[];
+    /** Why nothing was written, in one sentence. */
+    refusal?: string;
+}
+/** The verdict on one used member of a pinned external. */
+type ExternalUseState = 'unchanged' | 'changed' | 'removed' | 'unlocked' | 'unavailable' | 'renamed';
+/** external_use_status — the verdict on one used member of one pinned external. */
+interface ExternalUseStatus {
+    publicName?: string;
+    member?: string;
+    state: ExternalUseState;
+    /** EXTERNAL_CHECK_UNAVAILABLE on an unavailable entry — never a pass. */
+    code?: string;
+    detail?: string;
     /**
-     * True when the checker resolved the callee to no declaration at all
-     * because its receiver (or the callee itself) is typed any, unknown or not
-     * at all — neither a landing nor its absence means anything.
+     * On a renamed use: the public name (and member, as `name.member`) the live
+     * producer's rename trace carries the used name forward to — what the
+     * consumer's references should now name.
      */
-    unresolved?: boolean;
+    renamedTo?: string;
 }
-interface CodeModel {
-    /** One facts entry per distinct resolved sourcePath (missing/escaped/unreadable included). */
-    files: SourceFileFacts[];
-    /** The root every sourcePath was resolved and containment-checked against. */
-    projectRoot: string;
+/** external_status — the status of one declared external. */
+interface ExternalStatus {
+    alias: string;
+    project: string;
+    sourceKind: ExternalSourceKind;
+    pinned: boolean;
+    reachable: boolean;
+    stale: boolean;
+    drifted?: boolean;
+    uses: ExternalUseStatus[];
+    detail?: string;
     /**
-     * Every source file the declared source-root walk found, as canonical keys
-     * in walk order — the domain the unclaimed-source rule judges. Empty when
-     * the project declares no source roots, which is what keeps that rule
-     * opt-in. Facts for these files live in `files`, like any other path.
+     * True when the producer's root lies outside the request's reach and was
+     * therefore not read: a family run that narrowed the reach to its selection
+     * counts it in its hint rather than as a comparison that failed.
      */
-    rootFiles: string[];
+    outOfReach?: boolean;
+    /** The content digest the lock recorded for this producer; provenance only, never compared here. */
+    pinnedDigest?: string;
+    /** The producer's commit as the lock recorded it (another repository only); provenance only. */
+    pinnedCommit?: string;
     /**
-     * The package specifiers that name a package of THIS repository, each
-     * mapped to the canonical source file it resolves to: the root package and
-     * every workspace package the root package.json declares (never
-     * node_modules), `name` for the main entry and `name/sub` for each plain
-     * subpath export, build entries mapped back to their source through the
-     * package's tsconfig outDir/rootDir. What lets a package import resolve like
-     * a relative one; a third-party specifier is in no entry and resolves to
-     * nothing. Absent or empty when the repository declares no packages.
+     * The carried facts the pinned snapshot no longer matches in the live
+     * producer (an abi, a transport, a role, the targetLanguage, a rename
+     * trace): the snapshot is stale and a re-pin refreshes it. Absent when the
+     * producer was not read or nothing carried moved.
      */
-    packages?: Record<string, string>;
+    staleFacts?: string[];
 }
+/** ok | drifted | incompatible | unavailable — a relation's health in one word. */
+type RelationHealth = 'ok' | 'drifted' | 'incompatible' | 'unavailable';
 /**
- * code_model.pathKey — the canonical key form of a source path in the model:
- * forward slashes, no leading `./`. Every facts entry is stored under it, and
- * every lookup or path comparison uses it.
+ * external_status.health — the relation's health in one word, the same on the
+ * canvas's edges and on the hosted Relations tab. A known break outranks the
+ * unknown, and the unknown outranks a benign change, so nothing that could not
+ * be checked ever reads as ok. Pure: over the status's own fields.
  */
-declare function pathKey(sourcePath: string): string;
+declare function relationHealth(status: ExternalStatus): RelationHealth;
 /**
- * code_model.factsFor — the facts entry for a source path, looked up by its
- * canonical key; undefined when the run analyzed no such path. The model holds
- * one entry per key; were it to hold two, the later one answers, as it does in
- * the keyed indexes the rules build over the same files.
+ * project_relations — one project of a family with its externals status, read
+ * at its own root: what the canvas colours its consumption edges from.
  */
-declare function factsFor(model: CodeModel, sourcePath: string): SourceFileFacts | undefined;
+interface ProjectRelations {
+    /** The consuming project's key in the bound family ('' for the bound root). */
+    project: string;
+    /** Its externals status, per use — and one per contained project member it references. */
+    externals: ExternalStatus[];
+    /** ISO-8601 time the statuses were read. */
+    comparedAt: string;
+    /** Why the project's statuses could not be read at all; then externals is empty. */
+    detail?: string;
+}
+/** external_listing — one row of `wairon externals list`. */
+interface ExternalListing {
+    alias: string;
+    project: string;
+    sourceKind: ExternalSourceKind;
+    relation?: ExternalRelation;
+    directory?: string;
+    audience: string;
+    lock?: ExternalLockEntry;
+    problem?: string;
+}
+/** One rendered per-portal OpenAPI document (see the codec's toOpenApiSet). */
+declare const NamedOpenApiSpecSchema: z.ZodObject<{
+    portalId: z.ZodString;
+    name: z.ZodString;
+    document: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    document: string;
+    portalId: string;
+}, {
+    name: string;
+    document: string;
+    portalId: string;
+}>;
+type NamedOpenApiSpec = z.infer<typeof NamedOpenApiSpecSchema>;
+declare const GroupSpecSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"group">;
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    kind: "group";
+    createdAt: string;
+    updatedAt: string;
+    description?: string | undefined;
+}, {
+    id: string;
+    name: string;
+    kind: "group";
+    createdAt: string;
+    updatedAt: string;
+    description?: string | undefined;
+}>;
+type GroupSpec = z.infer<typeof GroupSpecSchema>;
+
+/** identifier — one identifier as written: a spec id, a project id, an alias, or a method, parameter or field name. */
+type Identifier = string;
+/** display_name — a spec's human-readable `name`: free text, never blank, no invisible character. */
+type DisplayName = string;
+/** identifier_kind — what an identifier names, which decides the grammar it is judged by. */
+type IdentifierKind = 'spec-id' | 'project-id' | 'alias' | 'method' | 'param' | 'field';
 /**
- * source_file_facts.importBindingOf — the runtime import binding a file makes
- * under a local name, or undefined when the name is not an import of this
- * file (it is local, global, or bound type-only).
+ * The longest identifier of any kind. A spec id is a folder and a file name
+ * under `.wai/specs/`, and git for Windows refuses paths over 260 characters
+ * by default; 64 keeps two nested ids plus a file name near 150. The same cap
+ * holds for every kind (a DNS label stops at 63, a Postgres identifier at 63).
  */
-declare function importBindingOf(facts: SourceFileFacts, name: string): ImportBindingFact | undefined;
+declare const MAX_IDENTIFIER_LENGTH = 64;
+/** The invisible characters (a control character — C0, DEL, C1 — a soft hyphen, a zero-width or bidi-control character, or a BOM) as a regular-expression character-class body (for a schema's negated class). */
+declare const INVISIBLE_CHARACTERS = "\\u0000-\\u001f\\u007f-\\u009f\\u00ad\\u061c\\u180e\\u200b-\\u200f\\u2028-\\u202e\\u2060-\\u206f\\ufeff";
 /**
- * source_file_facts.fieldTypesOf — the type names an instance field is
- * DECLARED with, or EMPTY when the file declares no such field, annotates it
- * with nothing, or was analyzed below exact grade. The empty answer is what
- * keeps an unresolvable field from becoming a guess.
+ * identifier.problemAs — why `text` is no identifier of this kind, as one
+ * sentence a refusal can carry (it starts with the quoted text), or null when
+ * it is one. Pure.
  */
-declare function fieldTypesOf(facts: SourceFileFacts, field: string): string[];
+declare function identifierProblem(text: string, kind: IdentifierKind): string | null;
 /**
- * source_file_facts.localTypesOf — the type names a locally bound name is
- * DECLARED with, or EMPTY when the file binds no such name, annotates it with
- * nothing, or was analyzed below exact grade. The empty answer is what keeps
- * an unannotated receiver from becoming a guess, exactly as it does for a
- * field.
+ * display_name.problem — why `text` is no display name: empty or blank, or
+ * holding an invisible character. Null when it is one. Pure.
  */
-declare function localTypesOf(facts: SourceFileFacts, name: string): string[];
+declare function displayNameProblem(text: string): string | null;
 /**
- * source_file_facts.memberTypesOf — the type names a property of a named
- * shape this file declares is DECLARED with, or EMPTY when the file declares
- * no such shape or property, annotates it with nothing, or was analyzed below
- * exact grade. The empty answer keeps an unresolvable link of a receiver
- * chain from becoming a guess.
+ * identifier.reservedIn — why the target language cannot use `text` as this
+ * kind of identifier, naming the language and offering an alternative that
+ * fits the casing; null when it can, when the kind is not a member name, or
+ * when the language has no table. Pure.
  */
-declare function memberTypesOf(facts: SourceFileFacts, shape: string, property: string): string[];
+declare function reservedWordProblem(text: string, kind: IdentifierKind, targetLanguage?: string, casing?: string): string | null;
+
 /**
- * source_file_facts.aliasTargetOf — the type a type alias this file declares
- * names outright, or undefined when the name is no such alias or its right
- * side names no single type.
+ * technology.packages — the package names the code twin of the leakage rule
+ * (TECH_LEAKAGE_IN_CODE) compares an import's package name with.
+ *
+ * A design names a technology the way people say it (`postgres`), while the
+ * code imports its driver (`pg`). Comparing only the declared tokens left the
+ * code fence inert on an ordinary design, so this module carries a CURATED,
+ * DOCUMENTED table of the common packages each technology is known by, keyed by
+ * the technology's usual spellings. It is deliberately short: a package belongs
+ * here only when importing it can mean nothing BUT that technology. An HTTP
+ * client (fetch, axios, got, undici) is never a technology — it is how an
+ * Adapter reaches anything — so no entry names one.
+ *
+ * Extending it takes no code change: a technology written `{ name, matches }`
+ * adds its own tokens, and a loaded pack contributes packages per technology
+ * name (an extension pack's `technologyPackages`).
  */
-declare function aliasTargetOf(facts: SourceFileFacts, name: string): string | undefined;
+
+/** The common packages of one technology. */
+interface TechnologyPackageEntry {
+    /** The names a design writes the technology under, lower-case. */
+    names: readonly string[];
+    /** The packages importing which means that technology. */
+    packages: readonly string[];
+}
 /**
- * source_file_facts.typeBindingOf — the module specifier a NAME was imported
- * from, whether the import was type-only or a runtime one, since a declared
- * type may be spelled either way. Undefined when the file imports no such
- * name, which leaves the name local, global or ambient.
+ * The built-in table. Documented in docs/cli.md ("Technologies and their
+ * packages"); keep the two in step.
  */
-declare function typeBindingOf(facts: SourceFileFacts, name: string): string | undefined;
+declare const TECHNOLOGY_PACKAGES: readonly TechnologyPackageEntry[];
 /**
- * source_file_facts.callSitesOf — the call sites written inside one named
- * function-like, or undefined when the file holds no BODY under that name.
- * The two answers are different findings and must never be collapsed: an
- * empty array is a body that calls nothing, undefined is nothing to read.
+ * technology.packages — the entry's tokens, then the built-in table's packages
+ * for its name, then the packages `contributed` lists under its name (what
+ * loaded packs contribute, keyed by technology name), lower-cased and
+ * de-duplicated in that order. Pure: the contributions are handed in.
  */
-declare function callSitesOf(facts: SourceFileFacts, fn: string): CallSiteFact[] | undefined;
-/** The bodies one name resolved to, and an identity a walk can de-duplicate on. */
-interface ResolvedBody {
-    /** `<container>.<name>` for a member, `<name>` for the module binding, `*<name>` for the union. */
-    key: string;
-    sites: CallSiteFact[];
+declare function technologyPackages(tech: Technology, contributed?: Readonly<Record<string, readonly string[]>>): string[];
+
+/**
+ * The type identifiers a type string names, with comments, trailing prose and
+ * string literals stripped. Duplicates are kept, in order of appearance.
+ */
+declare function extractTypeIdentifiers(typeStr: string): string[];
+/**
+ * The method shape the type references are read from: a contract method or a
+ * type method (whose params feed its references exactly as a contract
+ * method's do). The text and returns may be absent while a method is still in
+ * its stored form — a sourced method states neither, and a params-bearing one
+ * need not store its text — and an absent one names nothing.
+ */
+interface MethodLike {
+    signature?: string;
+    returns?: string;
+    params?: {
+        name: string;
+        type: string;
+    }[];
 }
 /**
- * source_file_facts.bodySitesOf — the call sites of the ONE body a name
- * means, told apart from its same-named neighbours by where each is bound;
- * undefined when the file holds no body under the name.
- *
- * `container` and `member` are what the reference says about its owner:
- * `container` is an anchor's `exportedVia` handle or a call's plain-identifier
- * receiver, and `member` says the reference was written through a receiver at
- * all. Only the code
- * settles which body a name means, and where it does not this answers what
- * the name-keyed union always answered — never a guess:
- *
- *   - with a container the file binds bodies of this name under, those bodies;
- *   - else a BARE reference (an anchor's symbol, a bare call) means the
- *     module-scope bodies, when the name has some and NO nested one: a bare
- *     name in the module's scope binds the top-level declaration, a member is
- *     reachable only through its container, and a nested body could shadow
- *     the name where it sits;
- *   - else every body under the name, unioned, as callSitesOf answers — a
- *     receiver the file binds no container to holds a value the model cannot
- *     follow, so which body it reaches is not this model's to say.
+ * method_signature.typeRefs — the named types a method references. Structured
+ * `params` are authoritative when present (no prose parsing): the named
+ * references of every param type and of the returns, each parsed under the
+ * grammar. Otherwise the prose signature and the returns are tokenized
+ * leniently, as the unstructured form always was.
  */
-declare function bodySitesOf(facts: SourceFileFacts, fn: string, container?: string, member?: boolean): ResolvedBody | undefined;
+declare function methodTypeRefs(m: MethodLike): string[];
 /**
- * source_file_facts.hasFunctionBody — whether the file holds a function-like
- * BODY under a name, as the model measured it: a function, method or accessor
- * declaration, or a function/arrow initializer bound to a named slot. A name
- * the file declares WITHOUT one — an overload signature, an ambient
- * declaration, an interface or type member, a plain value binding, an import
- * binding, a re-export specifier — answers false, because there is no body
- * there to read.
+ * type_spec.signatureTypeRefs — the named types a signature type references:
+ * every param type, then its returns, each parsed under the grammar — the
+ * references a signature carries in place of fields. None for any other kind,
+ * whose references are its fields'.
+ */
+declare function signatureTypeRefs(type: Pick<TypeSpec, 'kind' | 'params' | 'returns'>): string[];
+/**
+ * method_signature.genericParameters — the generic parameters declared before
+ * the parameter list of the method's prose signature (find<T>(id: string)
+ * gives T).
+ */
+declare function methodGenericParameters(method: {
+    signature?: string;
+}): Set<string>;
+/**
+ * reference_resolution.nameKey — the one key a bare name is compared by,
+ * locally and through imports alike: lower-cased, every character outside
+ * [a-z0-9] removed, so `SharedError`, `shared-error` and `shared_error` are
+ * one name. It is normalizePart, the per-segment normalization
+ * type_spec.matchesRef already applies.
+ */
+declare function nameKey(name: string): string;
+/**
+ * Whether a written type reference names a type id: the reference's `::` or
+ * `.` segments are a suffix of the id's, compared ignoring case and
+ * punctuation.
+ */
+declare function matchTypeRef(ref: string, typeId: string): boolean;
+/**
+ * type_spec.qualifiedId — the type's id qualified by its owning subsystem, when
+ * the id is not already qualified.
+ */
+declare function qualifiedTypeId(type: Pick<TypeSpec, 'id' | 'subsystem'>): string;
+/**
+ * type_spec.matchesRef — whether a written type reference names this type: the
+ * reference's `::` or `.` segments are a suffix of the qualified id, compared
+ * ignoring case and punctuation.
+ */
+declare function typeMatchesRef(type: Pick<TypeSpec, 'id' | 'subsystem'>, ref: string): boolean;
+/** type_spec.genericParameters — the generic parameters declared in the type's name (Page<T> gives T). */
+declare function typeGenericParameters(type: Pick<TypeSpec, 'name'>): Set<string>;
+/**
+ * type_spec.fieldTypeRefs — the named types one of this type's field types
+ * references (type_expression.namedRefs of the field's parsed type), with the
+ * type's own generic parameters left out (compared ignoring case). A field
+ * type that does not parse names nothing: its problem is
+ * TYPE_EXPRESSION_INVALID's to report. It takes the field's type rather than
+ * its name, because nothing makes field names unique within a type.
+ */
+declare function fieldTypeRefs(type: Pick<TypeSpec, 'name'>, fieldType: string): string[];
+/** interface_spec.genericParameters — the generic parameters declared in the interface's name. */
+declare function interfaceGenericParameters(intf: Pick<InterfaceSpec, 'name'>): Set<string>;
+
+/**
+ * The step graph of one narrative (step_graph): the SINGLE source of truth for
+ * successor semantics (fall-through + jumps; loop and try headers carry both
+ * their body edge and their after-region exit edge; return/throw terminate).
+ * The narrative-reachability check and the antipattern analysis both read
+ * it, so the two never disagree about what "next" means.
+ */
+interface StepGraph {
+    /** The narrative's step numbers in ascending order. */
+    stepNumbers: number[];
+    /** The step with this number, if there is one. */
+    stepAt(stepNumber: number): NarrativeStep | undefined;
+    /** The next step number in ascending order, ignoring jumps and parallel joins. */
+    nextOf(stepNumber: number): number | undefined;
+    /** The distinct existing step numbers flow can continue at from this step. */
+    successorsOf(stepNumber: number): number[];
+}
+/**
+ * method_implementation.stepGraph — the step graph of the method's narrative.
+ * Simple steps fall through; a branch continues at its true and false steps, a
+ * switch at its cases and default; a loop at its body and the step after its
+ * region; a try at its body, catch steps, finally step and the step after its
+ * region; a parallel fans out to its arms, whose last steps continue at the
+ * join; a jump at its target; return and throw end the path.
+ */
+declare function stepGraph(method: Pick<MethodImplementation, 'narrative'>): StepGraph;
+
+/** The finding codes a narrative step-configuration problem maps to. */
+type StepConfigCode = 'DUPLICATE_STEP_LABEL' | 'MALFORMED_FLOW_STEP' | 'INVALID_STEP_JUMP' | 'FOREIGN_STEP_FIELD';
+/**
+ * One thing wrong with a narrative's step configuration (step_config_problem):
+ * the step it sits on, the finding code it maps to, and the detail a rule
+ * appends to its own "Method X in implementation Y" prefix. Duplicate labels,
+ * missing or misplaced flow config, and jumps that land nowhere are all
+ * reported through this one shape.
+ */
+interface StepConfigProblem {
+    /** The step the problem sits on; a duplicate label names the earlier step in its detail. */
+    stepNumber: number;
+    /** The finding code this problem maps to. */
+    code: StepConfigCode;
+    /** The problem stated in full, ready to follow a rule's own location prefix. */
+    detail: string;
+}
+/**
+ * What a narrative's step configuration says about itself (step_config_verdict):
+ * the problems it carries, in step order, and whether its control flow is
+ * SOUND — no duplicate step number, no missing or misplaced flow config, and
+ * no jump that lands outside the narrative. A duplicate label is a problem but
+ * not an unsoundness: labels name steps, they do not route flow.
  *
- * Only exact grade measures bodies at all, so a file analyzed below it always
- * answers false; a caller that would ACCUSE on the answer must check the grade
- * itself rather than read "no body" into "not measured".
+ * Soundness is the gate every later phase runs behind. Reachability, region
+ * nesting and jump-edge judgement all read the step graph, and a graph built
+ * over jumps that target nothing reports steps as dead that are merely
+ * mis-numbered — wrong findings, not just noisier ones.
  */
-declare function hasFunctionBody(facts: SourceFileFacts, symbol: string): boolean;
+interface StepConfigVerdict {
+    /** The step-config problems, in step order: labels first, then numbering, then per-step config and jump targets. */
+    problems: StepConfigProblem[];
+    /** True when nothing found makes the control flow unreadable — the precondition for judging structure. */
+    sound: boolean;
+}
 /**
- * The language a source file is analyzed as, read from its extension; undefined
- * for a file no analyzer reads. The one table the analyzer and the implementer
- * briefs share, so a brief's type mapping is the dialect its code is judged by.
+ * The configuration each narrative step TYPE may carry, beyond what every step
+ * carries. This is the field set a retype rebuilds against, and the field set
+ * a stored step is judged against.
+ *
+ * Changing a step's `type` used to merge the new type's fields over the old
+ * step's and leave the rest standing, so a `branch` that became a `call` kept
+ * its `condition` and `onFalseStep`: a step the schema accepts, a write that
+ * reports success, and a MALFORMED_FLOW_STEP at the next validate, blamed on
+ * the narrative rather than on the edit that made it. The writer no longer
+ * leaves those behind; FOREIGN_STEP_FIELD reports the ones already written.
  */
-declare function languageOfSourcePath(sourcePath: string): string | undefined;
+declare const STEP_TYPE_FIELDS: Readonly<Record<string, readonly string[]>>;
 /**
- * source_file_facts.dialect — the type dialect shipped for the language this
- * file was analyzed as (type_dialect.forLanguage of its effective language),
- * or null when the file has no language or no dialect reads it yet. What a
- * conformance rule reads this file's type annotations through; a null answer
- * is silence, never a finding.
+ * What a step carries whatever its type — the human's own content. A retype
+ * keeps these: the author is changing HOW the step works, not what it is for,
+ * and re-typing a step should never cost them the sentence they wrote or the
+ * anchor other steps address it by.
  */
-declare function dialectOf(facts: SourceFileFacts): TypeDialect | null;
+declare const STEP_COMMON_FIELDS: readonly string[];
+/** The transient `*Label` twin of each jump-by-number field, resolved and dropped at write time. */
+declare const STEP_LABEL_TWINS: Readonly<Record<string, string>>;
+/** Every field a step of this type may carry, including the transient label twins. */
+declare function stepFieldsFor(type: string): Set<string>;
 /**
- * The type name a named function-like returns, where the code settles it
- * (SourceFileFacts.returnTypes); undefined otherwise — the silence a
- * `fn().method()` receiver keeps when the code does not say what fn returns.
+ * narrative_step.foreignFields — the fields this step carries that its own
+ * `type` cannot: everything set on it beyond the common fields and the ones
+ * its type adds. An unknown step type has no table, so nothing is foreign to
+ * it — the schema is what names that.
  */
-declare function returnTypeOf(facts: SourceFileFacts, fn: string): string | undefined;
+declare function narrativeStepForeignFields(step: NarrativeStep): string[];
 /**
- * source_file_facts.resolveImport — resolve one of a file's import specifiers
- * against a set of known source paths, purely (no I/O). A relative one: join
- * it with the importing file's directory, then try the joined path, `.js`
- * swapped for `.ts` or `.tsx`, the `.ts`, `.tsx` and `.js` extensions, and an
- * index file. A package specifier: the source file `packages` (the code
- * model's local-package map) names for it, when that file is known.
- * Undefined for a package the map does not name — a third-party one — or
- * when nothing matches.
+ * method_implementation.stepConfigVerdict — the step-config problems of this
+ * method's narrative and whether its control flow is sound. The schema keeps
+ * every flow field optional, so this derivation is what holds each step type
+ * to the config it needs, each label to one step, each step number to one
+ * step, and every jump field to a step number the narrative actually has.
  */
-declare function resolveImport(fromFile: string, specifier: string, knownPaths: Set<string>, packages?: Readonly<Record<string, string>>): string | undefined;
+declare function stepConfigVerdict(method: Pick<MethodImplementation, 'narrative'>): StepConfigVerdict;
 
 /**
  * How a cross-tree reference fared against the stored surface snapshots
@@ -22486,6 +22638,33 @@ interface SurfaceChange {
     /** What changed, said in one line. */
     detail: string;
 }
+/** One name a rename trace carries forward: the former name and the current one. */
+interface TracedRename {
+    from: string;
+    to: string;
+}
+/**
+ * surface_snapshot.fieldRenames — the fields of one type renamed between an
+ * older and a newer definition of it, per the newer one's rename trace
+ * (`formerly`): a field the older definition had that the newer lacks, which a
+ * newer field's trace names. Pure.
+ */
+declare function fieldRenames(was: SurfaceTypeDef, now: SurfaceTypeDef): TracedRename[];
+/** field_rename_reading — the field renames inside a used member's closure, and whether they are its whole change. */
+interface FieldRenameReading {
+    /** Each rename, read `field "<type>.<old>" renamed to "<new>"`. */
+    renames: string[];
+    /** Whether undoing the renames gives back the pinned member digest exactly. */
+    renameOnly: boolean;
+}
+/**
+ * surface_snapshot.fieldRenamesSince — every field rename inside the closure
+ * of one used member between a pinned snapshot and the live one, as
+ * `<type>.<old> → <new>` readings, and whether undoing them leaves the
+ * member's digest exactly as pinned (a rename and nothing else). Empty
+ * when no field of its closure was renamed. Pure.
+ */
+declare function fieldRenamesSince(pinned: SurfaceSnapshot, live: SurfaceSnapshot, publicName: string, member: string, pinnedDigest: string): FieldRenameReading;
 /**
  * surface_snapshot.changesSince — what one producer's public surface changed
  * from an older snapshot of it to this one: each public name (contract entry
@@ -41954,7 +42133,7 @@ type DesignExport = z.infer<typeof DesignExportSchema>;
 
 declare const DEFAULT_TARGET_DIRS: Record<string, string>;
 declare function defaultTargetConfig(type: 'claude' | 'gemini' | 'agy' | 'cursor' | 'copilot' | 'codex'): BuiltinTargetConfig;
-declare const WAIRON_VERSION = "5.1.1-dev.109";
+declare const WAIRON_VERSION = "5.1.1-dev.110";
 declare const GITHUB_REPO = "SYW-Apps/Waffle-AIron";
 declare const ARCHITECT_AGENT_ID = "agent-architect";
 declare const ARCHITECT_TEMPLATE_ID = "architect";
@@ -42713,6 +42892,14 @@ declare function exportSpecTree(includeDerived?: boolean, allowPartial?: boolean
  */
 declare function importSpecTree(archive: Uint8Array, options: TreeImportOptions): TreeImportResult;
 
+/**
+ * Author the ShopFlow example spec tree at the currently-bound project root.
+ * Overwrites the L0 system spec the provisioner wrote with a richer one, then
+ * lays down the three subsystems and their layered component/interface/
+ * implementation/type slices. Invalidates the spec cache at the end.
+ */
+declare function seedDemoTree(): void;
+
 /** One retired Specialist and the Orchestrator it becomes (specialist_retype). */
 interface SpecialistRetype {
     /** The component id. */
@@ -43481,4 +43668,4 @@ declare function schemaFingerprint(): string;
  */
 declare function loadProjectConfig(): ProjectConfig;
 
-export { AI_PATHS, ARCHITECT_AGENT_ID, ARCHITECT_TEMPLATE_ID, type AgentBrief, AgentBriefSchema, type AgentRecord, AgentRecordSchema, type AgentStatus, AgentStatusSchema, type AgentTemplate, AgentTemplateSchema, type AnalysisGrade, type ApiKeyLocation, ApiKeyLocationSchema, type ApprovalDiff, type ApprovalVerdict, type ApprovedRevision, type ArchProfile, type AuthoredReference, BACKEND_COMMANDS, BUILTIN_PROFILES, type BoundaryItem, BoundaryItemSchema, type BuildContextOptions, type BuiltinTarget, type BuiltinTargetConfig, BuiltinTargetConfigSchema, BuiltinTargetSchema, BundleNotFoundError, type CallSiteFact, type CallTargetFact, type CarriedDebt, type CarriedDebtKind, CarriedDebtKindSchema, CarriedDebtSchema, type CarriedFinding, type CarriedFindingEntry, CarriedFindingSchema, type CatchClause, CatchClauseSchema, ChainingMigrationRefusedError, ClaudeExporter, type ClaudeExporterOptions, type CodeIndex, type CodeModel, type ComplexityRuleConfig, ComplexityRuleConfigSchema, type ComponentPlacement, type ComponentRename, type ComponentSpec, ComponentSpecSchema, type ComponentType, ComponentTypeSchema, type CompositionConfig, CompositionConfigSchema, ConfigValidationError, type ConformanceRuleConfig, ConformanceRuleConfigSchema, type ConformanceTier, ConformanceTierSchema, type CrossProjectReference, CustomExporter, type CustomTarget, type CustomTargetConfig, CustomTargetConfigSchema, CustomTargetSchema, DEFAULT_TARGET_DIRS, DESIGN_APPROVALS, DESIGN_DEPENDENCY_ROLES, DESIGN_FORMAT, DESIGN_FORMAT_VERSION, DESIGN_VIEW_FIELDS, type DatabaseSpec, DatabaseSpecSchema, type DeclarativePack, type DeclaredCall, type DeclaredExternal, type DeclaredInvocation, DeclaredInvocationSchema, type DeclaredMember, type DependencyClass, DependencyClassSchema, type DependencyEdge, type DependencyEdges, type DesignApproval, DesignApprovalSchema, type DesignComponent, DesignComponentSchema, type DesignDependency, type DesignDependencyRole, DesignDependencyRoleSchema, DesignDependencySchema, type DesignDepth, DesignDepthSchema, type DesignExport, type DesignExportEntry, DesignExportEntrySchema, DesignExportSchema, type DesignField, DesignFieldSchema, type DesignImplementation, DesignImplementationSchema, type DesignInterface, DesignInterfaceSchema, type DesignMethod, type DesignMethodBody, DesignMethodBodySchema, DesignMethodSchema, type DesignParam, DesignParamSchema, type DesignProject, DesignProjectSchema, type DesignSource, DesignSourceSchema, type DesignSubsystem, DesignSubsystemSchema, type DesignType, type DesignTypeRef, DesignTypeRefSchema, DesignTypeSchema, type DetectedDomainCandidate, type DiagramConfig, DiagramConfigSchema, type DiagramLineStyle, DiagramLineStyleSchema, type DiagramView, DiagramViewSchema, type DispatchBinding, DispatchBindingSchema, DoctorOptionsError, type DocumentationRuleConfig, DocumentationRuleConfigSchema, type Domain, DomainSchema, type DomainType, DomainTypeSchema, type Durability, DurabilitySchema, EXTERNAL_ALIAS_RE, EXTERNAL_SOURCE_FORMS, type EdgeReach, type Endpoint, EndpointSchema, type EndpointTransport, type EntryScope, EntryScopeSchema, type EnumValue, EnumValueSchema, type EventBinding, EventBindingSchema, type ExportAliasFact, type ExportContext, type ExportKind, type ExportProblem, type ExportProblemKind, type ExportResult, type ExportRole, ExportRoleSchema, type ExportTableLevel, type ExportUsage, type ExportUse, type Exporter, type ExtData, ExtDataSchema, type ExtensionPack, type ExternalAddition, type ExternalBinding, type ExternalConsumer, type ExternalDeclaration, ExternalDeclarationSchema, type ExternalLink, ExternalLinkSchema, type ExternalLinkType, ExternalLinkTypeSchema, type ExternalListing, type ExternalLockEntry, ExternalLockEntrySchema, type ExternalPin, type ExternalPinOutcome, type ExternalRelation, type ExternalRemoval, type ExternalRequest, type ExternalRole, type ExternalSource, type ExternalSourceKind, ExternalSourceSchema, type ExternalStatus, type ExternalUseChange, type ExternalUseRequest, type ExternalUseState, type ExternalUseStatus, type ExternalsLock, ExternalsLockSchema, FULL_COMMIT_RE, type FamilyProblemKind, type FamilySwitches, type FieldRename, type FindingDeclaration, FindingDeclarationSchema, type FindingParts, type ForeignFieldRepair, type ForwardedName, type FunctionBodyFact, GITHUB_REPO, GeminiExporter, type GenerateOptions, type GenerateSummary, type GroupSpec, GroupSpecSchema, type Guarantee, GuaranteeSchema, HOLDABLE_PRIMITIVES, type HostedRecordLookup, type HttpMethod, HttpMethodSchema, type ImplementationSpec, ImplementationSpecSchema, type ImportBindingFact, type ImportGraph, type ImportSection, type InstalledPack, type InterfaceSpec, InterfaceSpecSchema, type InternalizeDestination, type InternalizeResult, type Invariant, InvariantSchema, type InvocationKind, InvocationKindSchema, type IssueSeverity, type LegacySpecFile, type LifecycleEntrypoint, LifecycleEntrypointSchema, type LifecyclePhase, LifecyclePhaseSchema, type LintAllow, LintAllowSchema, type LintConfig, LintConfigSchema, type LoadedExtensions, type LoadedPackSkill, type LockRecord, type LockStatus, type LogLevel, type LoopKind, LoopKindSchema, MAX_SPEC_ID_LENGTH, type MemberAdvance, type MemberCreation, type MemberDeclaration, MemberDeclarationSchema, type MemberKind, type MemberPin, type MemberSource, type MemberStorage, type MethodEffect, MethodEffectSchema, type MethodImplementation, MethodImplementationSchema, type MethodLike, type MethodParam, MethodParamSchema, type MethodRename, type MethodSignature, MethodSignatureSchema, type ModelledCall, type MountForm, type NamedOpenApiSpec, NamedOpenApiSpecSchema, type NamingRuleConfig, NamingRuleConfigSchema, type NarrativeDetail, NarrativeDetailSchema, type NarrativeStep, NarrativeStepSchema, type NarrativeStepType, NarrativeStepTypeSchema, type NetworkBoundary, type NetworkDeclaration, NetworkDeclarationSchema, NetworkOptionsError, type OAuthFlow, OAuthFlowSchema, type OutputTarget, OutputTargetSchema, type OwnershipIndex, PATTERN_TYPES, PRIMITIVE_TYPES, PROJECT_ID_RE, PROJECT_KINDS, PUBLIC_NAME_RE, type PackDiagnosis, type PackEntry, type PackPath, type PackRef, type PackRequirement, PackRequirementSchema, type PackScope, type PackSelection, PackSelectionSchema, type ParallelBranch, ParallelBranchSchema, type ParamRename, type ParameterFact, type ParentExcerpt, ParentExcerptSchema, type ParsedMemberSource, type PartOf, PartOfSchema, type PathsConfig, PathsConfigSchema, type PatternRef, PatternRefSchema, type PinnedExternal, type PinnedParent, type PortalAuth, PortalAuthSchema, type PortalAuthScheme, PortalAuthSchemeSchema, PreviousIdsSchema, PreviousNamesSchema, ProfileSelectionSubjectSchema, type ProjectBinding, type ProjectBindingVia, type ProjectConfig, ProjectConfigSchema, type ProjectFamily, type ProjectFamilyProblem, type ProjectIdOrigin, type ProjectIdSource, type ProjectIdentity, type ProjectIdentityProblem, type ProjectImport, type ProjectNode, ProjectNotInitializedError, type ProjectProfileSelection, ProjectProfileSelectionSchema, type ProjectRelations, type PromoteResult, type PublicInterface, PublicInterfaceSchema, type PublicInterfaceType, PublicInterfaceTypeSchema, RETIRED_INVOCATION_KINDS, RETIRED_PORTAL_TYPE_SPELLINGS, RETIRED_STEREOTYPES, type ReachFinding, type ReachModel, type ReachRewrite, type ReachabilityMigrationPlan, type ReadExternalSource, type ReadableProject, type RealizationIndex, type ReexportBindingFact, type ReferenceBinding, type ReferenceEdit, type ReferenceForm, type ReferenceLanding, type ReferenceResolution, type Registry, RegistrySchema, type RelationHealth, type RenameTraceHolders, type RequirementItem, RequirementItemSchema, type ResolutionOutcome, type ResolvedBody, type ResolvedCallFact, type ResolvedDetail, type ResolvedExport, type ResolvedExportTable, type ResolvedExternal, ResolvedInterfaceSpecSchema, type ResolvedMethod, ResolvedMethodSignatureSchema, ResolvedTypeMethodSchema, ResolvedTypeSpecSchema, type RetiredMount, type RetiredReachFact, type RetiredReachForm, RetiredReachFormSchema, type RetiredReachHolder, type RouteFact, type RuleCode, type RuleContext, type RuleJudgement, type RuleScope, type RulesConfig, RulesConfigSchema, SCAN_EXCLUDE_DIRS, SDD_RULES, SEMANTIC_GUARANTEES, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, STEP_TYPE_FIELDS, SUPPORTED_ALIASES, SURFACE_AUDIENCES, type ScopeFilterOptions, type SddRule, type Severity, type ShapeMemberFact, type ShapeOrigin, type SignatureFacts, type SignatureResolution, type SignatureSourceFact, type SignatureTextRepair, type SourceFileFacts, type SourceFileStatus, type SpecId, type SpecIdKind, SpecIdSchema, type SpecIndex, type SpecScanOptions, type SpecStatus, SpecStatusSchema, type SpecialistRetirement, type SpecialistRetype, type StaleSignatureText, type StateId, type StatusDecor, type StatusOptions, type StatusReport, type StepConfigCode, type StepConfigProblem, type StepConfigVerdict, type StepGraph, type StoredInterfaceSpec, type StoredMethodSignature, StoredMethodSignatureSchema, type StoredTypeMethod, StoredTypeMethodSchema, type StoredTypeSpec, type SubsystemSpec, SubsystemSpecSchema, type SubsystemWriteRule, type SupportedAlias, type SurfaceAudience, SurfaceAudienceSchema, type SurfaceChange, type SurfaceChangeKind, type SurfaceContractEntry, SurfaceContractEntrySchema, type SurfaceOrigin, SurfaceOriginSchema, type SurfaceRefResolution, type SurfaceSnapshot, SurfaceSnapshotSchema, type SurfaceTypeDef, SurfaceTypeDefSchema, type SurfaceTypeExport, SurfaceTypeExportSchema, type SurfaceUnresolvedExport, SurfaceUnresolvedExportSchema, type SwitchCase, SwitchCaseSchema, type SyncResult, type SystemPublicInterface, SystemPublicInterfaceSchema, type SystemSpec, SystemSpecSchema, TECHNOLOGY_PACKAGES, type TargetConfig, TargetConfigSchema, type Technology, TechnologySchema, type Template, TemplateNotFoundError, TemplateSchema, type TopicEnd, type TopologyConfig, TopologyConfigSchema, type Transport, type TransportKind, TransportKindSchema, TransportSchema, type TreeExportResult, type TreeImportOptions, type TreeImportResult, type TrustedLink, TrustedLinkSchema, type TypeCanonicalization, type TypeDialect, type TypeEnumProposal, type TypeExpression, type TypeExpressionProblem, TypeExpressionSchema, type TypeField, TypeFieldSchema, type TypeForm, type TypeKind, TypeKindSchema, type TypeMethod, TypeMethodSchema, type TypeParse, type TypePosition, type TypeProblemCode, type TypeRename, type TypeRespelling, type TypeShapeFact, type TypeSpec, TypeSpecSchema, type TypeSpellingFacts, type TypeSpellingRepair, type TypedSpecKind, USE_ENTRY_RE, type VerbReach, WAIRON_MANAGED_BANNER, WAIRON_MANAGED_MARKER, WAIRON_VERSION, WINDOWS_RESERVED_NAME_RE, type WaiPaths, WaironError, type WriteReach, YamlSyntaxError, activeTargetTypes, addDomain, admits, advanceMember, aiDir, aiDirAt, aiPathsAt, aliasGrammarProblem, aliasTargetOf, ambiguityMessage, approvalKeyIn, approvalRecord, approvalVerdict, approvedRevision, approvedStatuses, asSchemaReads, assertContainedProjectPath, assertProjectInitialized, attachRetiredMounts, backendCommand, backfillChainedSubprojectConfigs, backupBeside, bindDeclaredExternal, bodySitesOf, buildCanvasDataModel, buildProjectGraph, buildRuleContext, builtinProfileIds, builtinProjectKinds, callSitesOf, callersOf, canonicalTypeRef, canonicalTypeText, captureApprovedSpecs, carriedFactChanges, carryRetiredReachForms, checkDeclarativePack, clearLoaderIssues, cognitiveScore, complexityLevel, componentDesignView, componentEntryFor, composeAgentBrief, composeRuleSequence, computeGateStateId, computeOwnDesignStateId as computeOwnDesignId, computeOwnDesignStateIdAsRecorded as computeOwnDesignIdAsRecorded, computeOwnStateId, computeStateId, computeStateIdAt, conceptNoun, consumedContractInputs, consumerReaches, containedPathOf, contentDigest, createAgentRecord, createEmptyRegistry, createEmptyTopologyConfig, createMember, createProjectConfig, currentRootBinding, declareExternal, declareMember, declaredExternals, declaredMembers, declaredPackNames, declaredProfileIds, declares, declaresGlobalPacks, defaultConformanceTier, defaultNarrativeDetail, defaultPackSelections, defaultTargetConfig, deleteSpec, demoteMember, dependencyCycles, deregisterPackRef, deriveExecutionProfile, deriveMethodSignature, deriveTypeSignature, derivedDocPaths, describeProject, detectDomainCandidates, diagnoseProjectPacks, diagramSetIndex, dialectOf, diffAgainstApproval, diffSize, discoverPacks, dryRunSerializeSpecs, effectiveDetail, effectiveProjectId, emptyExtensions, emptyTypeSpellingFacts, enclosing, ensureDir, ensureProjectInitialized, excerpt as excerptParent, exportDesign, exportSpecTree, exportSurface, exportTargetKey, exportUsage, externalizeSubsystem, extractTypeIdentifiers, factsFor, familyApprovals, familyNode, familyRelations, fieldTypeRefs, fieldTypesOf, findChainingParent, findChainingSubprojectsMissingConfig, findLegacySpecFiles, findProjectRoot, findSystemRoot, findTestsReferencing, fromProjectRoot, generateAgent, generateAll, generateComponentDiagram, generateDiagramSet, generateSequenceDiagram, getExporter, getExternalsStatus, getHostedLookup, getLoaderIssues, getProjectRoot, getProjectRootOverride, getRequestParentReach, getRequestProjectRoot, getSnapshot, getStatusReport, getWriteReach, globalGuideFilePath, globalPacksDir, globalPacksEnabled, globalTemplatesDir, hasContext, hasFunctionBody, headNoun, holdsState, implementationDesignView, implementationSourceFiles, importBindingOf, importNames, importSpecTree, importSurface, injectGuide, installPackFromDirectory, interfaceCanonicalTypes, interfaceDesignView, interfaceGenericParameters, internalizeMember, isDraftSubsystem, isInProcessAddress, isLogic, isOutsideRoot, isOwnComponentEntry, isPart, isPattern, isProjectInitialized, isProvidedBy, isRetired, isSilent, isTypeVocabulary, isWindowsReservedName, judgesCode, keyIn, landReference, languageOfSourcePath, lineEndingFor, listDirectChainedSubprojects, listConsumers as listExternalConsumers, listExternals, listFiles, listFilesRecursive, listInstalledPacks, listPinnedExternals, listRules, listSnapshots, loadComponentSpec, loadComponentSpecs, loadExtensionPacks, loadExtensions, loadFor as loadExtensionsFor, loadImplementationSpec, loadImplementationSpecs, loadInterfaceSpec, loadInterfaceSpecs, loadProjectConfig, loadProjectExtensions, loadProjectVariants, loadRegistry, loadSpec, loadSpecGraph, loadSubsystemSpec, loadSubsystemSpecs, loadSystemSpec, loadTopologyConfig, loadTypeSpec, loadTypeSpecs, localApprover, localGuideFilePath, localTypesOf, logger, makeScopeFilter, markSelectionsBundled, matchTypeRef, measurePackDoctrine, measurePackImpact, memberDeclarationOf, memberDigest, memberLocationOf, memberTypesOf, methodCasingFor, methodGenericParameters, methodSourceFile, methodTypeRefs, migrate as migrateReachability, moveMember, moveMethods, moveMountToMembers, nameKey, namesAnInteger, narrativeStepForeignFields, normalizeReferences, ownerOf, packDirEntry, packEntryLabel, packEntryRef, manifestOf as packManifest, packStoreDir, parseDeclarativePack, parseDeclaredCall, parseMemberSource, parseTypeExpression, parseTypePosition, parseYaml, passesIntentFloor, pathExists, pathKey, pinExternals, pinInstalledPacksAsSelections, pinnedParent, producerOf, projectConfigExists, graph as projectFamily, projectIdentity, promoteMember, provisionProject, qualifiedTypeId, rangeProblem, readCodeAnnotation, readExternalSource, readFileOrNull, readJsonFile, readLockRecord, readLockState, readRetiredReachForms, readStampVersion, readYamlFile, recordProfileSelection, reexpress, registerExporter, registerPackRef, registerProjectServer, reinjectLocalGuides, relationHealth, removeDomain, removeExternal, removeMember, removePackSelection, removeSnapshot, renameAlias, renameComponent, renameField, renameProjectId as renameId, renameMethod, renameParam, renameType, renderDiagram, repairForeignStepFields, repairSignatures, repairTypeSpellings, repointExternal, requiredPolicies, resolveAgentTopology, resolveBudget, resolveChainingParent, resolveDomains, resolveExpectedOutputPaths, resolveCandidate as resolveExternalCandidate, resolveDeclared as resolveExternals, resolveImport, resolveInstalledPack, resolveProjectBinding, resolveProjectExports, resolveSignatures, resolveSubprojectForNamespace, resolveSubsystemExports, resolveVariantGuidance, retireSpecialists, retiredInvocationReadAs, retiredMountsOf, retiredReachFacts, returnTypeOf, rewriteReferences, runWithHostedLookup, runWithProjectBinding, runWithProjectRoot, sameContract, saveSpec, saveTopologyConfig, scanAllSpecs, schemaFingerprint, selectsFamily, serializeYaml, setExecutionTier, setProjectId as setId, setLogLevel, setNetwork, setProjectRoot, setProjectType, settledSpecPaths, signatureFacts, signatureTypeRefs, specIndexRetiredBy, specPathsInScope, splitNamespace, stepConfigVerdict, stepFieldsFor, stepGraph, storedMethodSignature, storedTypeMethod, subsystemDesignView, surfaceChanges, syncContextFiles, technologyName, technologyPackages, technologyTokens, toMarkdown, transportExportKind, transportKind, transportRequiresEndpoint, typeBindingOf, typeCanonicalTypes, typeDesignView, typeDialectFor, typeGenericParameters, typeIsMany, typeMappingFor, typeMatchesRef, typeNamedRefs, typeProblemEnumProposal, typeProblemIntProposal, typeSourceFiles, typeSpellingFacts, uninstallPack, updateMember, updateSpec, upsertPackSelection, validateAsComplete, validateComponentCandidate, validateFamily, validateProject, validateProjectConfig, validateRegistry, withLineEndings, withPack, writeFile, writeFileIfChanged, writeJsonFile, writeLockRecord, writeReachDenials, writeReachPermits, writeRootGuideDelegator, writeYamlFile, writtenTypeRefs };
+export { AI_PATHS, ARCHITECT_AGENT_ID, ARCHITECT_TEMPLATE_ID, type AgentBrief, AgentBriefSchema, type AgentRecord, AgentRecordSchema, type AgentStatus, AgentStatusSchema, type AgentTemplate, AgentTemplateSchema, type AnalysisGrade, type ApiKeyLocation, ApiKeyLocationSchema, type ApprovalDiff, type ApprovalVerdict, type ApprovedRevision, type ArchProfile, type AuthoredReference, BACKEND_COMMANDS, BUILTIN_PROFILES, type BoundaryItem, BoundaryItemSchema, type BuildContextOptions, type BuiltinTarget, type BuiltinTargetConfig, BuiltinTargetConfigSchema, BuiltinTargetSchema, BundleNotFoundError, type CallSiteFact, type CallTargetFact, type CarriedDebt, type CarriedDebtKind, CarriedDebtKindSchema, CarriedDebtSchema, type CarriedFinding, type CarriedFindingEntry, CarriedFindingSchema, type CatchClause, CatchClauseSchema, ChainingMigrationRefusedError, ClaudeExporter, type ClaudeExporterOptions, type CodeIndex, type CodeModel, type ComplexityRuleConfig, ComplexityRuleConfigSchema, type ComponentPlacement, type ComponentRename, type ComponentSpec, ComponentSpecSchema, type ComponentType, ComponentTypeSchema, type CompositionConfig, CompositionConfigSchema, ConfigValidationError, type ConformanceRuleConfig, ConformanceRuleConfigSchema, type ConformanceTier, ConformanceTierSchema, type CrossProjectReference, CustomExporter, type CustomTarget, type CustomTargetConfig, CustomTargetConfigSchema, CustomTargetSchema, DEFAULT_TARGET_DIRS, DESIGN_APPROVALS, DESIGN_DEPENDENCY_ROLES, DESIGN_FORMAT, DESIGN_FORMAT_VERSION, DESIGN_VIEW_FIELDS, type DatabaseSpec, DatabaseSpecSchema, type DeclarativePack, type DeclaredCall, type DeclaredExternal, type DeclaredInvocation, DeclaredInvocationSchema, type DeclaredMember, type DependencyClass, DependencyClassSchema, type DependencyEdge, type DependencyEdges, type DesignApproval, DesignApprovalSchema, type DesignComponent, DesignComponentSchema, type DesignDependency, type DesignDependencyRole, DesignDependencyRoleSchema, DesignDependencySchema, type DesignDepth, DesignDepthSchema, type DesignExport, type DesignExportEntry, DesignExportEntrySchema, DesignExportSchema, type DesignField, DesignFieldSchema, type DesignImplementation, DesignImplementationSchema, type DesignInterface, DesignInterfaceSchema, type DesignMethod, type DesignMethodBody, DesignMethodBodySchema, DesignMethodSchema, type DesignParam, DesignParamSchema, type DesignProject, DesignProjectSchema, type DesignSource, DesignSourceSchema, type DesignSubsystem, DesignSubsystemSchema, type DesignType, type DesignTypeRef, DesignTypeRefSchema, DesignTypeSchema, type DetectedDomainCandidate, type DiagramConfig, DiagramConfigSchema, type DiagramLineStyle, DiagramLineStyleSchema, type DiagramView, DiagramViewSchema, type DispatchBinding, DispatchBindingSchema, type DisplayName, DisplayNameSchema, DoctorOptionsError, type DocumentationRuleConfig, DocumentationRuleConfigSchema, type Domain, DomainSchema, type DomainType, DomainTypeSchema, type Durability, DurabilitySchema, EXTERNAL_ALIAS_RE, EXTERNAL_SOURCE_FORMS, type EdgeReach, type Endpoint, EndpointSchema, type EndpointTransport, type EntryScope, EntryScopeSchema, type EnumValue, EnumValueSchema, type EventBinding, EventBindingSchema, type ExportAliasFact, type ExportContext, type ExportKind, type ExportProblem, type ExportProblemKind, type ExportResult, type ExportRole, ExportRoleSchema, type ExportTableLevel, type ExportUsage, type ExportUse, type Exporter, type ExtData, ExtDataSchema, type ExtensionPack, type ExternalAddition, type ExternalBinding, type ExternalConsumer, type ExternalDeclaration, ExternalDeclarationSchema, type ExternalLink, ExternalLinkSchema, type ExternalLinkType, ExternalLinkTypeSchema, type ExternalListing, type ExternalLockEntry, ExternalLockEntrySchema, type ExternalPin, type ExternalPinOutcome, type ExternalRelation, type ExternalRemoval, type ExternalRemovalPlan, type ExternalRequest, type ExternalRole, type ExternalSource, type ExternalSourceKind, ExternalSourceSchema, type ExternalStatus, type ExternalUseChange, type ExternalUseRequest, type ExternalUseState, type ExternalUseStatus, type ExternalsLock, ExternalsLockSchema, FULL_COMMIT_RE, type FamilyProblemKind, type FamilySwitches, FieldNameSchema, type FieldRename, type FieldRenameReading, type FindingDeclaration, FindingDeclarationSchema, type FindingParts, type ForeignFieldRepair, type ForwardedName, type FunctionBodyFact, GITHUB_REPO, GeminiExporter, type GenerateOptions, type GenerateSummary, type GroupSpec, GroupSpecSchema, type Guarantee, GuaranteeSchema, HOLDABLE_PRIMITIVES, type HostedRecordLookup, type HttpMethod, HttpMethodSchema, INVISIBLE_CHARACTERS, type Identifier, type IdentifierKind, type ImplementationSpec, ImplementationSpecSchema, type ImportBindingFact, type ImportGraph, type ImportSection, type InstalledPack, type InterfaceSpec, InterfaceSpecSchema, type InternalizeDestination, type InternalizeResult, type Invariant, InvariantSchema, type InvocationKind, InvocationKindSchema, type IssueSeverity, type LegacySpecFile, type LifecycleEntrypoint, LifecycleEntrypointSchema, type LifecyclePhase, LifecyclePhaseSchema, type LintAllow, LintAllowSchema, type LintConfig, LintConfigSchema, type LoadedExtensions, type LoadedPackSkill, type LockRecord, LockRecordUnreadableError, type LockStatus, type LogLevel, type LoopKind, LoopKindSchema, MAX_IDENTIFIER_LENGTH, MAX_SPEC_ID_LENGTH, type MemberAdvance, type MemberCreation, type MemberDeclaration, MemberDeclarationSchema, type MemberKind, type MemberPin, type MemberSource, type MemberStorage, type MethodEffect, MethodEffectSchema, type MethodImplementation, MethodImplementationSchema, type MethodLike, MethodNameSchema, type MethodParam, MethodParamSchema, type MethodRename, type MethodSignature, MethodSignatureSchema, type ModelledCall, type MountForm, type NamedOpenApiSpec, NamedOpenApiSpecSchema, type NamingRuleConfig, NamingRuleConfigSchema, type NarrativeDetail, NarrativeDetailSchema, type NarrativeStep, NarrativeStepSchema, type NarrativeStepType, NarrativeStepTypeSchema, type NetworkBoundary, type NetworkDeclaration, NetworkDeclarationSchema, NetworkOptionsError, type OAuthFlow, OAuthFlowSchema, type OutputTarget, OutputTargetSchema, type OwnershipIndex, PATTERN_TYPES, PRIMITIVE_TYPES, PROJECT_ID_RE, PROJECT_KINDS, PUBLIC_NAME_RE, type PackDiagnosis, type PackEntry, type PackPath, type PackRef, type PackRequirement, PackRequirementSchema, type PackScope, type PackSelection, PackSelectionSchema, type ParallelBranch, ParallelBranchSchema, ParamNameSchema, type ParamRename, type ParameterFact, type ParentExcerpt, ParentExcerptSchema, type ParsedMemberSource, type PartOf, PartOfSchema, type PathsConfig, PathsConfigSchema, type PatternRef, PatternRefSchema, type PinnedExternal, type PinnedParent, type PortalAuth, PortalAuthSchema, type PortalAuthScheme, PortalAuthSchemeSchema, PreviousIdsSchema, PreviousNamesSchema, ProfileSelectionSubjectSchema, type ProjectBinding, type ProjectBindingVia, type ProjectConfig, ProjectConfigSchema, type ProjectFamily, type ProjectFamilyProblem, type ProjectIdOrigin, type ProjectIdSource, type ProjectIdentity, type ProjectIdentityProblem, type ProjectImport, type ProjectNode, ProjectNotInitializedError, type ProjectProfileSelection, ProjectProfileSelectionSchema, type ProjectRelations, type PromoteResult, type PublicInterface, PublicInterfaceSchema, type PublicInterfaceType, PublicInterfaceTypeSchema, RETIRED_INVOCATION_KINDS, RETIRED_PORTAL_TYPE_SPELLINGS, RETIRED_STEREOTYPES, type ReachFinding, type ReachModel, type ReachRewrite, type ReachabilityMigrationPlan, type ReadExternalSource, type ReadableProject, type RealizationIndex, type ReexportBindingFact, type ReferenceBinding, type ReferenceEdit, type ReferenceForm, type ReferenceLanding, type ReferenceResolution, type Registry, RegistrySchema, type RelationHealth, type RenameTraceHolders, type RequirementItem, RequirementItemSchema, type ResolutionOutcome, type ResolvedBody, type ResolvedCallFact, type ResolvedDetail, type ResolvedExport, type ResolvedExportTable, type ResolvedExternal, ResolvedInterfaceSpecSchema, type ResolvedMethod, ResolvedMethodSignatureSchema, ResolvedTypeMethodSchema, ResolvedTypeSpecSchema, type RetiredMount, type RetiredReachFact, type RetiredReachForm, RetiredReachFormSchema, type RetiredReachHolder, type RouteFact, type RuleCode, type RuleContext, type RuleJudgement, type RuleScope, type RulesConfig, RulesConfigSchema, SCAN_EXCLUDE_DIRS, SDD_RULES, SEMANTIC_GUARANTEES, STEP_COMMON_FIELDS, STEP_LABEL_TWINS, STEP_TYPE_FIELDS, SUPPORTED_ALIASES, SURFACE_AUDIENCES, type ScopeFilterOptions, type SddRule, type Severity, type ShapeMemberFact, type ShapeOrigin, type SignatureFacts, type SignatureResolution, type SignatureSourceFact, type SignatureTextRepair, type SourceFileFacts, type SourceFileStatus, type SpecId, type SpecIdKind, SpecIdSchema, type SpecIndex, type SpecScanOptions, type SpecStatus, SpecStatusSchema, type SpecialistRetirement, type SpecialistRetype, type StaleSignatureText, type StateId, type StatusDecor, type StatusOptions, type StatusReport, type StepConfigCode, type StepConfigProblem, type StepConfigVerdict, type StepGraph, type StoredInterfaceSpec, type StoredMethodSignature, StoredMethodSignatureSchema, type StoredTypeMethod, StoredTypeMethodSchema, type StoredTypeSpec, type SubsystemSpec, SubsystemSpecSchema, type SubsystemWriteRule, type SupportedAlias, type SurfaceAudience, SurfaceAudienceSchema, type SurfaceChange, type SurfaceChangeKind, type SurfaceContractEntry, SurfaceContractEntrySchema, type SurfaceOrigin, SurfaceOriginSchema, type SurfaceRefResolution, type SurfaceSnapshot, SurfaceSnapshotSchema, type SurfaceTypeDef, SurfaceTypeDefSchema, type SurfaceTypeExport, SurfaceTypeExportSchema, type SurfaceUnresolvedExport, SurfaceUnresolvedExportSchema, type SwitchCase, SwitchCaseSchema, type SyncResult, type SystemPublicInterface, SystemPublicInterfaceSchema, type SystemSpec, SystemSpecSchema, TECHNOLOGY_PACKAGES, type TargetConfig, TargetConfigSchema, type Technology, TechnologySchema, type Template, TemplateNotFoundError, TemplateSchema, type TopicEnd, type TopologyConfig, TopologyConfigSchema, type TracedRename, type Transport, type TransportKind, TransportKindSchema, TransportSchema, type TreeExportResult, type TreeImportOptions, type TreeImportResult, type TrustedLink, TrustedLinkSchema, type TypeCanonicalization, type TypeDialect, type TypeEnumProposal, type TypeExpression, type TypeExpressionProblem, TypeExpressionSchema, type TypeField, TypeFieldSchema, type TypeForm, type TypeKind, TypeKindSchema, type TypeMethod, TypeMethodSchema, type TypeParse, type TypePosition, type TypeProblemCode, type TypeRename, type TypeRespelling, type TypeShapeFact, type TypeSpec, TypeSpecSchema, type TypeSpellingFacts, type TypeSpellingRepair, type TypedSpecKind, USE_ENTRY_RE, type VerbReach, WAIRON_MANAGED_BANNER, WAIRON_MANAGED_MARKER, WAIRON_VERSION, WINDOWS_RESERVED_NAME_RE, type WaiPaths, WaironError, type WriteReach, YamlSyntaxError, activeTargetTypes, addDomain, admits, advanceMember, aiDir, aiDirAt, aiPathsAt, aliasGrammarProblem, aliasTargetOf, ambiguityMessage, approvalKeyIn, approvalRecord, approvalVerdict, approvedRevision, approvedStatuses, asSchemaReads, assertContainedProjectPath, assertProjectInitialized, attachRetiredMounts, backendCommand, backfillChainedSubprojectConfigs, backupBeside, bindDeclaredExternal, bodySitesOf, buildCanvasDataModel, buildProjectGraph, buildRuleContext, builtinProfileIds, builtinProjectKinds, callSitesOf, callersOf, canonicalTypeRef, canonicalTypeText, captureApprovedSpecs, carriedFactChanges, carryRetiredReachForms, checkDeclarativePack, clearLoaderIssues, cognitiveScore, complexityLevel, componentDesignView, componentEntryFor, composeAgentBrief, composeRuleSequence, computeGateStateId, computeOwnDesignStateId as computeOwnDesignId, computeOwnDesignStateIdAsRecorded as computeOwnDesignIdAsRecorded, computeOwnStateId, computeStateId, computeStateIdAt, conceptNoun, consumedContractInputs, consumerReaches, containedPathOf, contentDigest, createAgentRecord, createEmptyRegistry, createEmptyTopologyConfig, createMember, createProjectConfig, currentRootBinding, declareExternal, declareMember, declaredExternals, declaredMembers, declaredPackNames, declaredProfileIds, declares, declaresGlobalPacks, defaultConformanceTier, defaultNarrativeDetail, defaultPackSelections, defaultTargetConfig, deleteSpec, demoteMember, dependencyCycles, deregisterPackRef, deriveExecutionProfile, deriveMethodSignature, deriveTypeSignature, derivedDocPaths, describeProject, detectDomainCandidates, diagnoseProjectPacks, diagramSetIndex, dialectOf, diffAgainstApproval, diffSize, discoverPacks, displayNameProblem, dryRunSerializeSpecs, effectiveDetail, effectiveProjectId, emptyExtensions, emptyTypeSpellingFacts, enclosing, ensureDir, ensureProjectInitialized, excerpt as excerptParent, exportDesign, exportSpecTree, exportSurface, exportTargetKey, exportUsage, externalizeSubsystem, extractTypeIdentifiers, factsFor, familyApprovals, familyNode, familyRelations, fieldRenames, fieldRenamesSince, fieldTypeRefs, fieldTypesOf, findChainingParent, findChainingSubprojectsMissingConfig, findLegacySpecFiles, findOrphanedSpecFiles, findProjectRoot, findSystemRoot, findTestsReferencing, fitsMethodCasing, fromProjectRoot, generateAgent, generateAll, generateComponentDiagram, generateDiagramSet, generateSequenceDiagram, getExporter, getExternalsStatus, getHostedLookup, getLoaderIssues, getProjectRoot, getProjectRootOverride, getRequestParentReach, getRequestProjectRoot, getSnapshot, getStatusReport, getWriteReach, globalGuideFilePath, globalPacksDir, globalPacksEnabled, globalTemplatesDir, hasContext, hasFunctionBody, headNoun, holdsState, identifierProblem, implementationDesignView, implementationSourceFiles, importBindingOf, importNames, importSpecTree, importSurface, injectGuide, installPackFromDirectory, interfaceCanonicalTypes, interfaceDesignView, interfaceGenericParameters, internalizeMember, isDraftSubsystem, isInProcessAddress, isLogic, isOutsideRoot, isOwnComponentEntry, isPart, isPattern, isProjectInitialized, isProvidedBy, isRetired, isSilent, isTypeVocabulary, isWindowsReservedName, judgesCode, keyIn, landReference, languageOfSourcePath, lineEndingFor, listDirectChainedSubprojects, listConsumers as listExternalConsumers, listExternals, listFiles, listFilesRecursive, listInstalledPacks, listPinnedExternals, listRules, listSnapshots, loadComponentSpec, loadComponentSpecs, loadExtensionPacks, loadExtensions, loadFor as loadExtensionsFor, loadImplementationSpec, loadImplementationSpecs, loadInterfaceSpec, loadInterfaceSpecs, loadProjectConfig, loadProjectExtensions, loadProjectVariants, loadRegistry, loadSpec, loadSpecGraph, loadSubsystemSpec, loadSubsystemSpecs, loadSystemSpec, loadTopologyConfig, loadTypeSpec, loadTypeSpecs, localApprover, localGuideFilePath, localTypesOf, logger, makeScopeFilter, markSelectionsBundled, matchTypeRef, measurePackDoctrine, measurePackImpact, memberDeclarationOf, memberDigest, memberLocationOf, memberTypesOf, methodCasingFor, methodGenericParameters, methodSourceFile, methodTypeRefs, migrate as migrateReachability, moveMember, moveMethods, moveMountToMembers, nameKey, namesAnInteger, narrativeStepForeignFields, narrowedToMember, normalizeReferences, ownerOf, packDirEntry, packEntryLabel, packEntryRef, manifestOf as packManifest, packStoreDir, parseDeclarativePack, parseDeclaredCall, parseMemberSource, parseTypeExpression, parseTypePosition, parseYaml, passesIntentFloor, pathExists, pathKey, pinExternals, pinnedParent, producerOf, projectConfigExists, graph as projectFamily, projectIdentity, promoteMember, provisionProject, qualifiedTypeId, rangeProblem, readCodeAnnotation, readExternalSource, readFileOrNull, readJsonFile, readLockRecord, readLockState, readRetiredReachForms, readStampVersion, readYamlFile, recordProfileSelection, reexpress, registerExporter, registerPackRef, registerProjectServer, reinjectLocalGuides, relationHealth, removeDomain, removeExternal, removeMember, removePackSelection, removeSnapshot, renameAlias, renameComponent, renameField, renameProjectId as renameId, renameMethod, renameParam, renameType, renderDiagram, repairForeignStepFields, repairSignatures, repairTypeSpellings, repointExternal, requiredPolicies, reservedWordProblem, resolveAgentTopology, resolveBudget, resolveChainingParent, resolveDomains, resolveExpectedOutputPaths, resolveCandidate as resolveExternalCandidate, resolveDeclared as resolveExternals, resolveImport, resolveInstalledPack, resolveProjectBinding, resolveProjectExports, resolveSignatures, resolveSubprojectForNamespace, resolveSubsystemExports, resolveVariantGuidance, retireSpecialists, retiredInvocationReadAs, retiredMountsOf, retiredReachFacts, returnTypeOf, rewriteReferences, runWithHostedLookup, runWithProjectBinding, runWithProjectRoot, sameContract, saveSpec, saveTopologyConfig, scanAllSpecs, schemaFingerprint, seedDemoTree, selectsFamily, serializeYaml, setExecutionTier, setProjectId as setId, setLogLevel, setNetwork, setProjectRoot, setProjectType, settledSpecPaths, signatureFacts, signatureTypeRefs, specIndexRetiredBy, specPathsInScope, splitNamespace, stepConfigVerdict, stepFieldsFor, stepGraph, storedMethodSignature, storedTypeMethod, subsystemDesignView, surfaceChanges, syncContextFiles, technologyName, technologyPackages, technologyTokens, toMarkdown, transportExportKind, transportKind, transportRequiresEndpoint, typeBindingOf, typeCanonicalTypes, typeDesignView, typeDialectFor, typeGenericParameters, typeIsMany, typeMappingFor, typeMatchesRef, typeNamedRefs, typeProblemEnumProposal, typeProblemIntProposal, typeSourceFiles, typeSpellingFacts, uninstallPack, updateMember, updateSpec, upsertPackSelection, validateAsComplete, validateComponentCandidate, validateFamily, validateProject, validateProjectConfig, validateRegistry, withLineEndings, withPack, writeFile, writeFileIfChanged, writeJsonFile, writeLockRecord, writeReachDenials, writeReachPermits, writeRootGuideDelegator, writeYamlFile, writtenTypeRefs };