@telorun/kernel 0.85.0 → 0.86.0

package/dist/evaluation-context.d.ts

@@ -122,9 +122,27 @@ export declare class EvaluationContext implements IEvaluationContext {
     protected readonly declaredManifests: Map<string, ResourceManifest>;
     /** Per-resource dependency names, captured at create() time — BEFORE Phase-5
      *  injection swaps refs for live instances, so the walk sees plain objects and
-     *  cannot wander into a controller's (possibly cyclic) object graph. Read only
-     *  when init fails, to attribute each failure to its cause. */
+     *  cannot wander into a controller's (possibly cyclic) object graph.
+     *
+     *  Read twice, and RETAINED for the context's lifetime because of the second
+     *  reader: to attribute an init failure to its cause, and to order teardown
+     *  (`teardownOrder`) so a consumer's inverses run while the resources it holds
+     *  are still alive. */
     private readonly resourceDependencies;
+    /**
+     * Names resolved by NAME during initialization, rather than through a
+     * declared reference slot — so a resource somebody may be holding, with no
+     * edge recording who.
+     *
+     * The set is of TARGETS, not of pairs: the door that records
+     * (`ModuleContext.getInstance`) is reached as `ctx.moduleContext`, which every
+     * resource of the module shares, so there is no caller to attribute the read
+     * to. That is enough for the one decision that depends on it — see
+     * {@link impactedBy}.
+     */
+    protected readonly opaquelyRead: Set<string>;
+    /** Record a by-name resolution. Called by the recording door only. */
+    protected recordOpaqueRead(name: string): void;
     /**
      * Optional hook called between create() and init() for each resource.
      * Set by the kernel to inject live instances into reference fields.
@@ -231,6 +249,22 @@ export declare class EvaluationContext implements IEvaluationContext {
      */
     hasManifest(name: string): boolean;
     registerManifest(resource: ResourceManifest): void;
+    /**
+     * Forget a declaration entirely — the inverse of {@link registerManifest}.
+     *
+     * Reconciliation's other half: {@link unwindResources} disposes the INSTANCE,
+     * and this clears everything keyed by the name so the same name can be
+     * declared again. Without it `registerManifest` refuses with
+     * `ERR_DUPLICATE_RESOURCE`, which is the right answer for a manifest
+     * declaring one name twice and the wrong one for a second load of the same
+     * manifest.
+     *
+     * Every per-name record goes, not just the declaration: a resource left in
+     * `withheldResources` would be skipped by the init loop for the life of the
+     * kernel, and a stale `createdInstances` entry would have the loop initialize
+     * the object built from the PREVIOUS declaration.
+     */
+    deregisterManifest(name: string): void;
     /**
      * The manifest a name was DECLARED with, resolved scope-local first and then
      * up the enclosing chain — the order `getInstance` and the CEL `resources`
@@ -320,39 +354,138 @@ export declare class EvaluationContext implements IEvaluationContext {
      */
     createScopeHandle(manifests: ResourceManifest[]): ScopeHandle;
     /**
-     * Cascade teardown depth-first through the tree:
-     *   1. Tear down child contexts in reverse registration order.
-     *   2. Tear down own resource instances in reverse registration order,
-     *      emitting a Teardown event for each via the injected emit callback.
+     * Cascade teardown through the tree:
+     *   1. Tear down own resource instances in {@link teardownOrder}, emitting a
+     *      Teardown event for each via the injected emit callback.
+     *   2. Sweep any child context still standing, in {@link childTeardownOrder}.
+     *
+     * **Own resources go FIRST, and the child sweep is a backstop.** A child
+     * context that belongs to a resource is torn down by that resource's own
+     * inverse — an import's `init()` returns `child.teardownResources()`, and so
+     * does a template's — so it already unwinds at its owner's position in step 1,
+     * which is the position the edges put it at. Running a child cascade ahead of
+     * step 1 tore every imported library down before any resource of THIS context,
+     * so an app resource holding `!ref Alias.name` unwound after its provider was
+     * already gone, and the owner's inverse then found nothing left to do.
+     *
+     * Sweeping afterwards rather than not at all is what still reclaims a context
+     * no inverse claims: a `lifecycle: shared` library, which is spawned under the
+     * root and deliberately gives no importer a claim on it, and an import whose
+     * `init()` never ran to register one. `teardownResources` is idempotent, so a
+     * context already taken down in step 1 costs the sweep nothing.
      */
     teardownResources(): Promise<void>;
     /**
-     * Child contexts in teardown order: ascending `teardownPriority` (default 0),
-     * with the base reverse-registration order preserved within each tier.
+     * Unwind SOME of this context's resources and leave the rest running.
+     *
+     * The reconciliation half of teardown: a host that has decided which
+     * declarations moved unwinds exactly {@link impactedBy}'s answer, then
+     * re-registers and re-initializes. Ordering is {@link teardownOrder}
+     * restricted to the selection, so a consumer still unwinds before what it
+     * holds — and the selection being closed under holders is what makes that
+     * true of the resources left standing as well, since none of them holds
+     * anything in it.
+     *
+     * The context keeps its state: it is neither draining nor torn down, and no
+     * child context is swept, because a child belonging to an unwound import goes
+     * down with that import's own inverse exactly as it does at teardown.
+     *
+     * A name with no live instance is skipped rather than reported — a resource
+     * that failed to initialize has nothing to unwind, and a host asking for it is
+     * asking about a declaration, not about an instance.
+     */
+    unwindResources(names: ReadonlySet<string>): Promise<void>;
+    private raiseTeardownFailures;
+    /** Unwind the given entries in the order supplied, aggregating what refused.
+     *  Failures are returned rather than thrown so one refusing inverse cannot
+     *  strand the resources after it — the log sinks above all. */
+    private unwindEach;
+    /**
+     * Child contexts for the backstop sweep: ascending `teardownPriority`
+     * (default 0), reverse registration within a tier.
+     *
+     * What reaches the sweep is a context no resource's inverse claimed, which in
+     * practice is the `lifecycle: shared` libraries. Those are spawned under the
+     * ROOT and give no importer a claim, so nothing but this orders them — and
+     * reverse registration alone does not, since a singleton is registered when
+     * the FIRST import reaches it, which for an import declared inside another
+     * library is after that library's own context. `TEARDOWN_LAST` on the context
+     * is what keeps a singleton alive until the libraries borrowing it have gone.
      *
-     * The same rule `teardownOrder` applies to resource instances, and for the
-     * same reason: reverse registration is reverse init order in the happy path,
-     * but a node that must reliably outlive the rest has to say so rather than
-     * depend on when it happened to be created. A `lifecycle: shared` library is
-     * registered when the FIRST import reaches it — which, for an import declared
-     * inside another library, is after that library's own context — so reverse
-     * registration would tear the singleton down while a borrower still holds it.
+     * Its protection now stops at library-against-library. Every resource of the
+     * context that owns the sweep has already unwound by the time it runs, which
+     * is the ordering the sweep used to invert.
      */
     private childTeardownOrder;
     /**
-     * Resource instances in teardown order: ascending `teardownPriority`, with the
-     * base reverse-insertion order preserved within each priority tier.
+     * Resource instances in teardown order: ascending `teardownPriority` as a hard
+     * tier, and within a tier a consumer before every resource it holds
+     * ({@link reverseTopologicalOrder} over the create-time edges), with reverse
+     * insertion as the tiebreak.
      *
-     * The base order is reverse *insertion*, which is reverse init order in the
-     * happy path — but the init loop is a multi-pass retry, so a resource that
-     * failed its first pass lands later in the map than its topological rank
-     * implies. That makes the dependency graph an unreliable way to say "last".
-     * A resource that must reliably outlive the rest declares it directly via
-     * `teardownPriority` (log sinks set `TEARDOWN_LAST`), so the generic teardown
-     * path orders by a declared number rather than sniffing any one subsystem's
-     * instance shape.
+     * `teardownPriority` is a TIER rather than another edge because it is the
+     * author's statement about an edge nothing captured: a log sink is reached
+     * through `ctx.log` rather than through a ref slot, so no walk of the manifest
+     * can find the resources that will log on the way down. Letting topology
+     * reorder across tiers would let one discovered edge override a declaration
+     * made precisely because the edges are not all discoverable.
      */
     private teardownOrder;
+    /**
+     * Every resource of this context that becomes invalid when `names` do — the
+     * named resources plus everything that transitively holds one
+     * ({@link impactClosure} over the same create-time edges teardown reads).
+     *
+     * What a reconciliation unwinds. A cross-module reference projects onto the
+     * local `Telo.Import` (`localDependencyNames`), so a change inside an
+     * imported library reaches this context as its import being impacted, and the
+     * library goes down with that import's own inverse — which is why this
+     * answers for one context rather than walking the tree.
+     *
+     * **`opaque` is what the answer cannot cover.** A name resolved by NAME during
+     * initialization ({@link opaquelyRead}) may be held by a resource no edge
+     * names, so a closure reaching one is not an answer at all. Those names are
+     * reported rather than absorbed: expanding the set to "every resource here"
+     * would sweep in the module document, which is not a resource a caller can
+     * unwind and re-register, and would present a whole-context rebuild as a
+     * narrowing. The caller escalates, and can say which resource forced it.
+     */
+    impactedBy(names: Iterable<string>): {
+        impacted: Set<string>;
+        opaque: string[];
+    };
+    /** Whether this resource's `run()` has been dispatched. A rebuilt resource
+     *  that had been started is one nothing will start again — boot targets run
+     *  once — so a caller reconciling has to escalate rather than leave it
+     *  constructed and idle. */
+    wasStarted(name: string): boolean;
+    /** Drop a resource's published reading. A context with no `resources` scope of
+     *  its own has nothing to drop; `ModuleContext` overrides. */
+    clearPublishedReading(name: string): void;
+    /** The declaration registered under `name` in THIS context, without the
+     *  walk up the enclosing chain a name lookup does. */
+    declaredManifestFor(name: string): ResourceManifest | undefined;
+    /** Replace a declaration in place, without queueing the resource for
+     *  creation. For a survivor of a reconciliation: its declaration is
+     *  content-identical by construction, but the object carries fresh loader
+     *  stamps (`metadata.sourceLine` above all), and a diagnostic anchored on the
+     *  stale one points at a pre-edit line. */
+    refreshManifest(name: string, resource: ResourceManifest): void;
+    /** Re-open an initialized context for another initialization pass.
+     *
+     *  The transition is the context's own, not a field a caller assigns: while it
+     *  is open, a reference to a resource that has not been rebuilt yet must
+     *  produce the deferral the init loop retries on rather than a hard
+     *  not-found, and leaving it open after a failed pass turns every later
+     *  lookup into that deferral with no pass coming. */
+    reopenForInitialization(): void;
+    /** Close a pass opened by {@link reopenForInitialization} that did not reach
+     *  the end of `initializeResources`. */
+    closeInitialization(): void;
+    /** Names a resource resolved by NAME while this context was initializing, so
+     *  no edge records who is holding them. Read by {@link impactedBy}; exposed so
+     *  a host can report why a reconciliation could not be narrowed. */
+    opaqueReads(): ReadonlySet<string>;
     transientChild(context: Record<string, any>): EvaluationContext;
     /**
      * Invoke a resource by kind and name within this context's resourceInstances.

package/dist/evaluation-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"evaluation-context.d.ts","sourceRoot":"","sources":["../src/evaluation-context.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,WAAW,EAEX,KAAK,iBAAiB,IAAI,kBAAkB,EAC5C,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAGlB,KAAK,WAAW,EAChB,KAAK,MAAM,EACZ,MAAM,cAAc,CAAC;AAsBtB,OAAO,EAAE,WAAW,EAAE,CAAC;AAyGvB,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,gBAAgB,EAC1B,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GACxB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CA6CzB;AAuED;iFACiF;AACjF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,OAAO,GAChB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAIrC;AAwCD,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAkBlF;AAgCD,wBAAsB,gBAAgB,CACpC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,aAAa,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,kBAAkB,GAAG,SAAS,CAAC,GAAG,SAAS,GAC5E,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAgBlC;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,IAAI,aAAa,GAAG,SAAS,CAEhE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,GAAG,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE3E;AAsED;;;;;;;;;;GAUG;AACH,qBAAa,iBAAkB,YAAW,kBAAkB;IAsMxD,QAAQ,CAAC,MAAM,EAAE,MAAM;IArMzB,QAAQ,CAAC,EAAE,SAA0C;IACrD,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5C,SAAS,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACrC,SAAS,CAAC,eAAe,EAAE,eAAe,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAEzB,sCAAsC;IACtC,MAAM,EAAE,kBAAkB,GAAG,SAAS,CAAa;IACnD,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,EAAE,CAAM;IAE7C;2EACuE;IACvE,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAa;IAEjD,oDAAoD;IACpD,KAAK,EAAE,cAAc,CAAa;IAElC,6EAA6E;IAC7E,QAAQ,CAAC,iBAAiB;kBAEZ,gBAAgB;kBAAY,gBAAgB;OACtD;IAEJ;;;2BAGuB;IACvB,SAAS,CAAC,QAAQ,CAAC,gBAAgB;kBAErB,gBAAgB;kBAAY,gBAAgB;aAAO,GAAG;gBAAU,gBAAgB;OAC1F;IAEJ;;;;;;OAMG;IACH,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAqB;IAEvD;wEACoE;IACpE,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAqB;IAExD;;;;;;;;;OASG;IACH,SAAS,CAAC,QAAQ,CAAC,iBAAiB,cAAqB;IAEzD;;;;;;;;;;;OAWG;IACH,qBAAqB,CACnB,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,QAAQ,EAAE,gBAAgB,EAC1B,KAAK,EAAE,iBAAiB,GACvB,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC;IAsBtB;yCACqC;IACrC,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAG/B;IAEJ;;;kCAG8B;IAC9B,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI;IAgB5F,gEAAgE;IAChE,OAAO,CAAC,gBAAgB,CAA0B;IAElD;;;;;;;;;;OAUG;IACH,SAAS,CAAC,QAAQ,CAAC,iBAAiB,gCAAuC;IAE3E;;;mEAG+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA+B;IAEpE;;;OAGG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,kBAAkB,GAAG,SAAS,CAAC;IAEjE;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,aAAa,CAAC;IAEtB;uFACmF;IACnF,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,wEAAwE;IACxE,OAAO,CAAC,UAAU;IAIlB;;;yEAGqE;IACrE,OAAO,CAAC,WAAW;gBAQR,MAAM,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,cAAc,EAAE,eAAe,YAAmB,EAClD,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,EACzB,IAAI,EAAE,SAAS;IAQjB,IAAI,cAAc,IAAI,eAAe,CAEpC;IAED;iFAC6E;IAC7E,SAAS,CAAC,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI;IAIlF;;4CAEwC;IACxC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,CAAC;IAE5F;;mCAE+B;YACjB,WAAW;IAMzB;;;;;;;;OAQG;IACG,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBrF;;;8EAG0E;IAC1E,OAAO,CAAC,cAAc;IAKtB;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,OAAO,CAAC,eAAe;IAgBvB;;;;;OAKG;IACG,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAwBlD,IAAI,OAAO,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAErC;IAED,IAAI,YAAY,IAAI,GAAG,CAAC,MAAM,CAAC,CAE9B;IAED;;;;;OAKG;IACH,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IASnC;;OAEG;IACH,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAQlC,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,IAAI;IAYlD;;;;;;;;;;OAUG;IACH,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAWnF;oEACgE;IAChE,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIlF;;;OAGG;IACH;;;;;;;;OAQG;IACH,WAAW,CAAC,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAK5C,UAAU,CAAC,CAAC,SAAS,kBAAkB,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAuBrD;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI;IAIpD;;;;;;4DAMwD;IACxD,iBAAiB,IAAI,iBAAiB;IActC;;;;;OAKG;IACH,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIlF;;;;;;;;;;;;;;;;;;OAkBG;IACG,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAoN1C,aAAa,CAAC,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC;IAuBlD;;;;;;;;OAQG;IACH,iBAAiB,CAAC,SAAS,EAAE,gBAAgB,EAAE,GAAG,WAAW;IA8G7D;;;;;OAKG;IAEG,iBAAiB,IAAI,OAAO,CAAC,IAAI,CAAC;IAkFxC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,kBAAkB;IAU1B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,aAAa;IAerB,cAAc,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,iBAAiB;IAU/D;;;;;OAKG;IACG,MAAM,CAAC,OAAO,EAClB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,OAAO,EACf,GAAG,CAAC,EAAE,aAAa,GAClB,OAAO,CAAC,GAAG,CAAC;IA6Bf;;;;;OAKG;IACG,cAAc,CAAC,OAAO,EAC1B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,MAAM,EAAE,OAAO,EACf,GAAG,CAAC,EAAE,aAAa,GAClB,OAAO,CAAC,GAAG,CAAC;IAUf;;;;;;;;;;OAUG;IACH;;;;;;OAMG;IACH,SAAS,CAAC,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS;IAI/D,SAAS,CAAC,YAAY,CACpB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,YAAY,EAAE,MAAM,GAAG,SAAS,EAChC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,UAAU,EAAE,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,SAAS,EACpD,KAAK,EAAE,OAAO,GAAG,KAAK,EACtB,OAAO,EAAE,WAAW,GAAG,SAAS,EAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;YAkBZ,SAAS;IAuLvB;;;;;;OAMG;IACH;;;gFAG4E;IAC5E,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI/C;;;0EAGsE;IACtE,YAAY,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC,GAAG,SAAS,CAAC;IAErD,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,qBAAqB;IAgBvB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAW3D;;;;;OAKG;IACG,WAAW,CACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,gBAAgB,EAC1B,GAAG,CAAC,EAAE,aAAa,GAClB,OAAO,CAAC,IAAI,CAAC;IAUhB;;;;;OAKG;IACG,QAAQ,CAAC,IAAI,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC;YAsD3E,WAAW;IA6HzB;;;;;;;;OAQG;IACH,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIhD;;;;;;;;;;OAUG;IACH,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO;IAS/B;;;;;;;;OAQG;IACH,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;IAyB1E;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;OAIG;IACH,SAAS,CACP,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,EAC7C,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IA2C1B;mEAC+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAGxB;IAEN;;;;SAIK;IACH,WAAW,CACT,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,MAAM,EAAE,EACf,YAAY,GAAE,MAAM,EAAO,GAC1B,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAmB3B;AA4ED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,IAAI,CAIf;AAED;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,OAAO,EACZ,GAAG,EAAE,MAAM,GACV,MAAM,GAAG,IAAI,CAIf"}
+{"version":3,"file":"evaluation-context.d.ts","sourceRoot":"","sources":["../src/evaluation-context.ts"],"names":[],"mappings":"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"}

package/dist/evaluation-context.js

@@ -2,8 +2,9 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { formatSpanCounter } from "./logging/span-id.js";
 import { deriveContext, getRefIdentity, isCompiledValue, isInvokeError, isCancellationError, isSuspension, resourceKey, UNCANCELLABLE_CONTEXT, } from "@telorun/sdk";
 import { RuntimeError } from "@telorun/sdk";
-import { evalPathCovers } from "@telorun/analyzer";
+import { celResourceReads, evalPathCovers } from "@telorun/analyzer";
 import { effectOwnerOf, executeReturnedChain } from "./effect-scope.js";
+import { impactClosure, reverseTopologicalOrder } from "./resource-edges.js";
 import { REDACTED, redactSensitive, sensitivePathsOfInstance, } from "./instance-sensitive-paths.js";
 import { classifyInitFailures, isDeferral, renderInitFailureText, summarizeInitFailures, } from "./init-failure-diagnostics.js";
 import { acceptReportedStatus, buildPublishedProps, diagnoseObservedStateAccess, } from "./observed-state.js";
@@ -521,9 +522,29 @@ export class EvaluationContext {
     declaredManifests = new Map();
     /** Per-resource dependency names, captured at create() time — BEFORE Phase-5
      *  injection swaps refs for live instances, so the walk sees plain objects and
-     *  cannot wander into a controller's (possibly cyclic) object graph. Read only
-     *  when init fails, to attribute each failure to its cause. */
+     *  cannot wander into a controller's (possibly cyclic) object graph.
+     *
+     *  Read twice, and RETAINED for the context's lifetime because of the second
+     *  reader: to attribute an init failure to its cause, and to order teardown
+     *  (`teardownOrder`) so a consumer's inverses run while the resources it holds
+     *  are still alive. */
     resourceDependencies = new Map();
+    /**
+     * Names resolved by NAME during initialization, rather than through a
+     * declared reference slot — so a resource somebody may be holding, with no
+     * edge recording who.
+     *
+     * The set is of TARGETS, not of pairs: the door that records
+     * (`ModuleContext.getInstance`) is reached as `ctx.moduleContext`, which every
+     * resource of the module shares, so there is no caller to attribute the read
+     * to. That is enough for the one decision that depends on it — see
+     * {@link impactedBy}.
+     */
+    opaquelyRead = new Set();
+    /** Record a by-name resolution. Called by the recording door only. */
+    recordOpaqueRead(name) {
+        this.opaquelyRead.add(name);
+    }
     /**
      * Optional hook called between create() and init() for each resource.
      * Set by the kernel to inject live instances into reference fields.
@@ -730,6 +751,32 @@ export class EvaluationContext {
         this.pendingResources.push(resource);
         this.declaredManifests.set(name, resource);
     }
+    /**
+     * Forget a declaration entirely — the inverse of {@link registerManifest}.
+     *
+     * Reconciliation's other half: {@link unwindResources} disposes the INSTANCE,
+     * and this clears everything keyed by the name so the same name can be
+     * declared again. Without it `registerManifest` refuses with
+     * `ERR_DUPLICATE_RESOURCE`, which is the right answer for a manifest
+     * declaring one name twice and the wrong one for a second load of the same
+     * manifest.
+     *
+     * Every per-name record goes, not just the declaration: a resource left in
+     * `withheldResources` would be skipped by the init loop for the life of the
+     * kernel, and a stale `createdInstances` entry would have the loop initialize
+     * the object built from the PREVIOUS declaration.
+     */
+    deregisterManifest(name) {
+        this.declaredManifests.delete(name);
+        this.resourceDependencies.delete(name);
+        this.createdInstances.delete(name);
+        this.withheldResources.delete(name);
+        this.recreatedResources.delete(name);
+        this.opaquelyRead.delete(name);
+        const pending = this.pendingResources.findIndex((r) => r.metadata?.name === name);
+        if (pending >= 0)
+            this.pendingResources.splice(pending, 1);
+    }
     /**
      * The manifest a name was DECLARED with, resolved scope-local first and then
      * up the enclosing chain — the order `getInstance` and the CEL `resources`
@@ -890,7 +937,12 @@ export class EvaluationContext {
                             progress = true;
                         const createdRes = created.resource;
                         const refs = collectResourceRefs(createdRes);
-                        this.resourceDependencies.set(name, localDependencyNames(refs));
+                        // `resource` rather than `createdRes`: the registered declaration
+                        // still holds its expressions, while the created copy holds the
+                        // values they were expanded to.
+                        this.resourceDependencies.set(name, [
+                            ...new Set([...localDependencyNames(refs), ...celResourceReads(resource)]),
+                        ]);
                         const payload = {
                             resource: {
                                 kind: createdRes.kind,
@@ -1001,9 +1053,6 @@ export class EvaluationContext {
                     await this.publishSnapshot(name);
                     this.resourceInstances.set(name, { resource, instance });
                     this.createdInstances.delete(name);
-                    // Read only on failure, and this one succeeded — drop it rather than
-                    // holding a dep-name array per resource for the context's lifetime.
-                    this.resourceDependencies.delete(name);
                     errors.delete(name);
                     progress = true;
                     await this.emit(`${resource.kind}.${resource.metadata.name}.Initialized`, {
@@ -1173,15 +1222,32 @@ export class EvaluationContext {
         };
     }
     /**
-     * Cascade teardown depth-first through the tree:
-     *   1. Tear down child contexts in reverse registration order.
-     *   2. Tear down own resource instances in reverse registration order,
-     *      emitting a Teardown event for each via the injected emit callback.
+     * Cascade teardown through the tree:
+     *   1. Tear down own resource instances in {@link teardownOrder}, emitting a
+     *      Teardown event for each via the injected emit callback.
+     *   2. Sweep any child context still standing, in {@link childTeardownOrder}.
+     *
+     * **Own resources go FIRST, and the child sweep is a backstop.** A child
+     * context that belongs to a resource is torn down by that resource's own
+     * inverse — an import's `init()` returns `child.teardownResources()`, and so
+     * does a template's — so it already unwinds at its owner's position in step 1,
+     * which is the position the edges put it at. Running a child cascade ahead of
+     * step 1 tore every imported library down before any resource of THIS context,
+     * so an app resource holding `!ref Alias.name` unwound after its provider was
+     * already gone, and the owner's inverse then found nothing left to do.
+     *
+     * Sweeping afterwards rather than not at all is what still reclaims a context
+     * no inverse claims: a `lifecycle: shared` library, which is spawned under the
+     * root and deliberately gives no importer a claim on it, and an import whose
+     * `init()` never ran to register one. `teardownResources` is idempotent, so a
+     * context already taken down in step 1 costs the sweep nothing.
      */
     // eslint-disable-next-line @typescript-eslint/member-ordering
     async teardownResources() {
         this.state = "Draining";
-        const failures = [];
+        const failures = await this.unwindEach(this.teardownOrder());
+        // The backstop: whatever no resource's inverse claimed. Everything an import
+        // or a template owns is already down, so this is a no-op for it.
         for (const child of this.childTeardownOrder()) {
             try {
                 await child.teardownResources();
@@ -1190,7 +1256,48 @@ export class EvaluationContext {
                 failures.push({ resource: "(child context)", error: err });
             }
         }
-        for (const [key, { resource, instance }] of this.teardownOrder()) {
+        this.state = "Teardown";
+        this.raiseTeardownFailures(failures);
+    }
+    /**
+     * Unwind SOME of this context's resources and leave the rest running.
+     *
+     * The reconciliation half of teardown: a host that has decided which
+     * declarations moved unwinds exactly {@link impactedBy}'s answer, then
+     * re-registers and re-initializes. Ordering is {@link teardownOrder}
+     * restricted to the selection, so a consumer still unwinds before what it
+     * holds — and the selection being closed under holders is what makes that
+     * true of the resources left standing as well, since none of them holds
+     * anything in it.
+     *
+     * The context keeps its state: it is neither draining nor torn down, and no
+     * child context is swept, because a child belonging to an unwound import goes
+     * down with that import's own inverse exactly as it does at teardown.
+     *
+     * A name with no live instance is skipped rather than reported — a resource
+     * that failed to initialize has nothing to unwind, and a host asking for it is
+     * asking about a declaration, not about an instance.
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    async unwindResources(names) {
+        const selected = this.teardownOrder().filter(([, entry]) => names.has(entry.resource.metadata.name));
+        this.raiseTeardownFailures(await this.unwindEach(selected));
+    }
+    raiseTeardownFailures(failures) {
+        if (failures.length === 0)
+            return;
+        throw new RuntimeError("ERR_TEARDOWN_FAILED", `${failures.length} resource(s) failed during teardown`, failures.map(({ resource, error }) => ({
+            severity: "error",
+            message: error instanceof Error ? error.message : String(error),
+            resource,
+        })));
+    }
+    /** Unwind the given entries in the order supplied, aggregating what refused.
+     *  Failures are returned rather than thrown so one refusing inverse cannot
+     *  strand the resources after it — the log sinks above all. */
+    async unwindEach(entries) {
+        const failures = [];
+        for (const [key, { resource, instance }] of entries) {
             const label = `${resource.kind}.${resource.metadata.name}`;
             // A reading belongs to the run that produced it. The WeakMap would drop it
             // with the instance anyway; clearing here also covers an instance something
@@ -1242,27 +1349,27 @@ export class EvaluationContext {
                 failures.push({ resource: `${label} (Teardown event)`, error: err });
             }
             this.resourceInstances.delete(key);
+            // A torn-down resource must stop being readable: a CEL expansion that still
+            // found its reading would bake a value nothing is serving any more.
+            this.clearPublishedReading(resource.metadata.name);
         }
-        this.state = "Teardown";
-        if (failures.length > 0) {
-            throw new RuntimeError("ERR_TEARDOWN_FAILED", `${failures.length} resource(s) failed during teardown`, failures.map(({ resource, error }) => ({
-                severity: "error",
-                message: error instanceof Error ? error.message : String(error),
-                resource,
-            })));
-        }
+        return failures;
     }
     /**
-     * Child contexts in teardown order: ascending `teardownPriority` (default 0),
-     * with the base reverse-registration order preserved within each tier.
+     * Child contexts for the backstop sweep: ascending `teardownPriority`
+     * (default 0), reverse registration within a tier.
+     *
+     * What reaches the sweep is a context no resource's inverse claimed, which in
+     * practice is the `lifecycle: shared` libraries. Those are spawned under the
+     * ROOT and give no importer a claim, so nothing but this orders them — and
+     * reverse registration alone does not, since a singleton is registered when
+     * the FIRST import reaches it, which for an import declared inside another
+     * library is after that library's own context. `TEARDOWN_LAST` on the context
+     * is what keeps a singleton alive until the libraries borrowing it have gone.
      *
-     * The same rule `teardownOrder` applies to resource instances, and for the
-     * same reason: reverse registration is reverse init order in the happy path,
-     * but a node that must reliably outlive the rest has to say so rather than
-     * depend on when it happened to be created. A `lifecycle: shared` library is
-     * registered when the FIRST import reaches it — which, for an import declared
-     * inside another library, is after that library's own context — so reverse
-     * registration would tear the singleton down while a borrower still holds it.
+     * Its protection now stops at library-against-library. Every resource of the
+     * context that owns the sweep has already unwound by the time it runs, which
+     * is the ordering the sweep used to invert.
      */
     childTeardownOrder() {
         return [...this.children]
@@ -1271,17 +1378,17 @@ export class EvaluationContext {
             (b.teardownPriority ?? 0));
     }
     /**
-     * Resource instances in teardown order: ascending `teardownPriority`, with the
-     * base reverse-insertion order preserved within each priority tier.
+     * Resource instances in teardown order: ascending `teardownPriority` as a hard
+     * tier, and within a tier a consumer before every resource it holds
+     * ({@link reverseTopologicalOrder} over the create-time edges), with reverse
+     * insertion as the tiebreak.
      *
-     * The base order is reverse *insertion*, which is reverse init order in the
-     * happy path — but the init loop is a multi-pass retry, so a resource that
-     * failed its first pass lands later in the map than its topological rank
-     * implies. That makes the dependency graph an unreliable way to say "last".
-     * A resource that must reliably outlive the rest declares it directly via
-     * `teardownPriority` (log sinks set `TEARDOWN_LAST`), so the generic teardown
-     * path orders by a declared number rather than sniffing any one subsystem's
-     * instance shape.
+     * `teardownPriority` is a TIER rather than another edge because it is the
+     * author's statement about an edge nothing captured: a log sink is reached
+     * through `ctx.log` rather than through a ref slot, so no walk of the manifest
+     * can find the resources that will log on the way down. Letting topology
+     * reorder across tiers would let one discovered edge override a declaration
+     * made precisely because the edges are not all discoverable.
      */
     teardownOrder() {
         // A borrowed instance is torn down by the scope that declared it, never
@@ -1289,10 +1396,93 @@ export class EvaluationContext {
         const entries = [...this.resourceInstances.entries()]
             .filter(([name]) => !this.borrowedResources.has(name))
             .reverse();
-        // Stable sort by priority (default 0); Array.prototype.sort is stable, so
-        // the reverse-insertion order survives within each tier.
-        return entries.sort(([, a], [, b]) => (a.instance?.teardownPriority ?? 0) -
-            (b.instance?.teardownPriority ?? 0));
+        const tiers = new Map();
+        for (const entry of entries) {
+            const priority = entry[1].instance?.teardownPriority ?? 0;
+            const tier = tiers.get(priority);
+            if (tier)
+                tier.push(entry);
+            else
+                tiers.set(priority, [entry]);
+        }
+        return [...tiers.keys()]
+            .sort((a, b) => a - b)
+            .flatMap((priority) => reverseTopologicalOrder(tiers.get(priority), (value) => value.resource.metadata.name, (name) => this.resourceDependencies.get(name)));
+    }
+    /**
+     * Every resource of this context that becomes invalid when `names` do — the
+     * named resources plus everything that transitively holds one
+     * ({@link impactClosure} over the same create-time edges teardown reads).
+     *
+     * What a reconciliation unwinds. A cross-module reference projects onto the
+     * local `Telo.Import` (`localDependencyNames`), so a change inside an
+     * imported library reaches this context as its import being impacted, and the
+     * library goes down with that import's own inverse — which is why this
+     * answers for one context rather than walking the tree.
+     *
+     * **`opaque` is what the answer cannot cover.** A name resolved by NAME during
+     * initialization ({@link opaquelyRead}) may be held by a resource no edge
+     * names, so a closure reaching one is not an answer at all. Those names are
+     * reported rather than absorbed: expanding the set to "every resource here"
+     * would sweep in the module document, which is not a resource a caller can
+     * unwind and re-register, and would present a whole-context rebuild as a
+     * narrowing. The caller escalates, and can say which resource forced it.
+     */
+    // eslint-disable-next-line @typescript-eslint/member-ordering
+    impactedBy(names) {
+        const impacted = impactClosure(names, this.resourceDependencies);
+        const opaque = [...impacted].filter((name) => this.opaquelyRead.has(name));
+        return { impacted, opaque };
+    }
+    /** Whether this resource's `run()` has been dispatched. A rebuilt resource
+     *  that had been started is one nothing will start again — boot targets run
+     *  once — so a caller reconciling has to escalate rather than leave it
+     *  constructed and idle. */
+    wasStarted(name) {
+        const instance = this.resourceInstances.get(name)?.instance;
+        return instance !== undefined && startedInstances.has(instance);
+    }
+    /** Drop a resource's published reading. A context with no `resources` scope of
+     *  its own has nothing to drop; `ModuleContext` overrides. */
+    clearPublishedReading(name) {
+        void name;
+    }
+    /** The declaration registered under `name` in THIS context, without the
+     *  walk up the enclosing chain a name lookup does. */
+    declaredManifestFor(name) {
+        return this.declaredManifests.get(name);
+    }
+    /** Replace a declaration in place, without queueing the resource for
+     *  creation. For a survivor of a reconciliation: its declaration is
+     *  content-identical by construction, but the object carries fresh loader
+     *  stamps (`metadata.sourceLine` above all), and a diagnostic anchored on the
+     *  stale one points at a pre-edit line. */
+    refreshManifest(name, resource) {
+        if (this.declaredManifests.has(name))
+            this.declaredManifests.set(name, resource);
+    }
+    /** Re-open an initialized context for another initialization pass.
+     *
+     *  The transition is the context's own, not a field a caller assigns: while it
+     *  is open, a reference to a resource that has not been rebuilt yet must
+     *  produce the deferral the init loop retries on rather than a hard
+     *  not-found, and leaving it open after a failed pass turns every later
+     *  lookup into that deferral with no pass coming. */
+    reopenForInitialization() {
+        if (this.state === "Initialized")
+            this.state = "Validated";
+    }
+    /** Close a pass opened by {@link reopenForInitialization} that did not reach
+     *  the end of `initializeResources`. */
+    closeInitialization() {
+        if (this.state === "Validated")
+            this.state = "Initialized";
+    }
+    /** Names a resource resolved by NAME while this context was initializing, so
+     *  no edge records who is holding them. Read by {@link impactedBy}; exposed so
+     *  a host can report why a reconciliation could not be narrowed. */
+    opaqueReads() {
+        return this.opaquelyRead;
     }
     transientChild(context) {
         return new EvaluationContext(this.source, { ...this.context, ...context }, this._createInstance, this._secretValues, this.emit);