@noego/wood 0.5.0 → 0.6.0

package/dist/controller/controller_lifecycle.js

@@ -2,6 +2,7 @@ async function disposeControllerLifecycle(target) {
   if (!target || typeof target !== "object" && typeof target !== "function") {
     return;
   }
+  guardControllerLifecycleOnce(target);
   const lifecycle = target;
   if (typeof lifecycle.dispose === "function") {
     await lifecycle.dispose();
@@ -11,7 +12,29 @@ async function disposeControllerLifecycle(target) {
     await lifecycle.destroy();
   }
 }
+const guardedControllers = /* @__PURE__ */ new WeakSet();
+function guardControllerLifecycleOnce(target) {
+  if (!target || typeof target !== "object" && typeof target !== "function") return;
+  if (guardedControllers.has(target)) return;
+  guardedControllers.add(target);
+  const instance = target;
+  for (const name of ["dispose", "destroy"]) {
+    const original = instance[name];
+    if (typeof original !== "function") continue;
+    let called = false;
+    Object.defineProperty(instance, name, {
+      configurable: true,
+      writable: true,
+      value: function(...args) {
+        if (called) return;
+        called = true;
+        return original.apply(this, args);
+      }
+    });
+  }
+}
 export {
-  disposeControllerLifecycle
+  disposeControllerLifecycle,
+  guardControllerLifecycleOnce
 };
 //# sourceMappingURL=controller_lifecycle.js.map

package/dist/controller/controller_lifecycle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/controller/controller_lifecycle.ts"],"sourcesContent":["export interface ControllerLifecycle {\n  dispose?(): void | Promise<void>;\n  destroy?(): void | Promise<void>;\n}\n\n/**\n * Dispose a controller or controller-like instance if it exposes a lifecycle\n * hook. `dispose` is the preferred Wood lifecycle name; `destroy` is supported\n * for existing page controllers.\n */\nexport async function disposeControllerLifecycle(target: unknown): Promise<void> {\n  if (!target || (typeof target !== 'object' && typeof target !== 'function')) {\n    return;\n  }\n\n  const lifecycle = target as ControllerLifecycle;\n  if (typeof lifecycle.dispose === 'function') {\n    await lifecycle.dispose();\n    return;\n  }\n  if (typeof lifecycle.destroy === 'function') {\n    await lifecycle.destroy();\n  }\n}\n"],"mappings":"AAUA,eAAsB,2BAA2B,QAAgC;AAC/E,MAAI,CAAC,UAAW,OAAO,WAAW,YAAY,OAAO,WAAW,YAAa;AAC3E;AAAA,EACF;AAEA,QAAM,YAAY;AAClB,MAAI,OAAO,UAAU,YAAY,YAAY;AAC3C,UAAM,UAAU,QAAQ;AACxB;AAAA,EACF;AACA,MAAI,OAAO,UAAU,YAAY,YAAY;AAC3C,UAAM,UAAU,QAAQ;AAAA,EAC1B;AACF;","names":[]}
+{"version":3,"sources":["../../src/controller/controller_lifecycle.ts"],"sourcesContent":["export interface ControllerLifecycle {\n  dispose?(): void | Promise<void>;\n  destroy?(): void | Promise<void>;\n}\n\n/**\n * Dispose a controller or controller-like instance if it exposes a lifecycle\n * hook. `dispose` is the preferred Wood lifecycle name; `destroy` is supported\n * for existing page controllers.\n */\nexport async function disposeControllerLifecycle(target: unknown): Promise<void> {\n  if (!target || (typeof target !== 'object' && typeof target !== 'function')) {\n    return;\n  }\n\n  guardControllerLifecycleOnce(target);\n  const lifecycle = target as ControllerLifecycle;\n  if (typeof lifecycle.dispose === 'function') {\n    await lifecycle.dispose();\n    return;\n  }\n  if (typeof lifecycle.destroy === 'function') {\n    await lifecycle.destroy();\n  }\n}\n\nconst guardedControllers = new WeakSet<object>();\n\n/** Share one teardown attempt between the explicit controller owner and IoC. */\nexport function guardControllerLifecycleOnce(target: unknown): void {\n  if (!target || (typeof target !== 'object' && typeof target !== 'function')) return;\n  if (guardedControllers.has(target as object)) return;\n  guardedControllers.add(target as object);\n  const instance = target as Record<string, unknown>;\n  for (const name of ['dispose', 'destroy'] as const) {\n    const original = instance[name];\n    if (typeof original !== 'function') continue;\n    let called = false;\n    Object.defineProperty(instance, name, {\n      configurable: true, writable: true,\n      value: function (this: unknown, ...args: unknown[]) {\n        if (called) return;\n        called = true;\n        return original.apply(this, args);\n      },\n    });\n  }\n}\n"],"mappings":"AAUA,eAAsB,2BAA2B,QAAgC;AAC/E,MAAI,CAAC,UAAW,OAAO,WAAW,YAAY,OAAO,WAAW,YAAa;AAC3E;AAAA,EACF;AAEA,+BAA6B,MAAM;AACnC,QAAM,YAAY;AAClB,MAAI,OAAO,UAAU,YAAY,YAAY;AAC3C,UAAM,UAAU,QAAQ;AACxB;AAAA,EACF;AACA,MAAI,OAAO,UAAU,YAAY,YAAY;AAC3C,UAAM,UAAU,QAAQ;AAAA,EAC1B;AACF;AAEA,MAAM,qBAAqB,oBAAI,QAAgB;AAGxC,SAAS,6BAA6B,QAAuB;AAClE,MAAI,CAAC,UAAW,OAAO,WAAW,YAAY,OAAO,WAAW,WAAa;AAC7E,MAAI,mBAAmB,IAAI,MAAgB,EAAG;AAC9C,qBAAmB,IAAI,MAAgB;AACvC,QAAM,WAAW;AACjB,aAAW,QAAQ,CAAC,WAAW,SAAS,GAAY;AAClD,UAAM,WAAW,SAAS,IAAI;AAC9B,QAAI,OAAO,aAAa,WAAY;AACpC,QAAI,SAAS;AACb,WAAO,eAAe,UAAU,MAAM;AAAA,MACpC,cAAc;AAAA,MAAM,UAAU;AAAA,MAC9B,OAAO,YAA4B,MAAiB;AAClD,YAAI,OAAQ;AACZ,iBAAS;AACT,eAAO,SAAS,MAAM,MAAM,IAAI;AAAA,MAClC;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/frontend/frontend_lifecycle.cjs

@@ -21,6 +21,7 @@ __export(frontend_lifecycle_exports, {
   FrontendLifecycleOwner: () => FrontendLifecycleOwner
 });
 module.exports = __toCommonJS(frontend_lifecycle_exports);
+var import_cleanup = require("../controller/cleanup.js");
 var import_work_registry = require("./work_registry.js");
 class FrontendLifecycleOwner {
   constructor(registry, owner) {
@@ -56,15 +57,12 @@ class FrontendLifecycleOwner {
   get isDisposed() {
     return this.disposed;
   }
-  /** Abort owned work and dispose owned resources in reverse order. */
-  async dispose() {
-    if (this.disposed) return;
+  dispose() {
+    if (this.closing) return this.closing;
     this.disposed = true;
     this.abortController.abort();
-    for (const resource of this.resources.reverse()) {
-      await resource.dispose();
-    }
-    this.resources.length = 0;
+    const resources = this.resources.splice(0).reverse();
+    return this.closing = (0, import_cleanup.cleanupAll)(resources.map((resource) => () => resource.dispose()), "Wood frontend lifecycle cleanup failed");
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/frontend/frontend_lifecycle.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/frontend/frontend_lifecycle.ts"],"sourcesContent":["/**\n * Production lifecycle owners for deliberately detached frontend work\n * (18A D-FAS-01 §2.2). Two natural owners exist per environment:\n *\n *   page lifecycle         — default for PageController work; aborted and\n *                            disposed when that page ends\n *   application lifecycle  — explicit for work that intentionally survives\n *                            page navigation; disposed with the environment\n *\n * PageControllers/client services register their own deliberately detached\n * finite work through their injected lifecycle owner — tests do not repair\n * unowned product code by wrapping it in track() from the outside.\n */\nimport { WorkRegistry, FrontendWorkError } from './work_registry.js';\n\nexport interface FrontendLifecycle {\n  readonly signal: AbortSignal;\n\n  track<T>(\n    work: Promise<T>,\n    options: {\n      label: string;\n      kind?: string;\n    },\n  ): Promise<T>;\n\n  own(resource: { dispose(): void | Promise<void> }): void;\n}\n\nexport class FrontendLifecycleOwner implements FrontendLifecycle {\n  private readonly abortController = new AbortController();\n  private readonly resources: Array<{ dispose(): void | Promise<void> }> = [];\n  private disposed = false;\n\n  constructor(\n    private readonly registry: WorkRegistry,\n    /** Diagnostic owner identity, e.g. `page main.chat_dom` or `application`. */\n    readonly owner: string,\n  ) {}\n\n  get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n\n  track<T>(work: Promise<T>, options: { label: string; kind?: string }): Promise<T> {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot track \"${options.label}\": lifecycle \"${this.owner}\" is disposed. ` +\n        'Work started after a page/environment ended is a product lifecycle bug.',\n      );\n    }\n    return this.registry.track(work, {\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: this.owner,\n    });\n  }\n\n  own(resource: { dispose(): void | Promise<void> }): void {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot own a resource: lifecycle \"${this.owner}\" is disposed.`,\n      );\n    }\n    this.resources.push(resource);\n  }\n\n  get isDisposed(): boolean {\n    return this.disposed;\n  }\n\n  /** Abort owned work and dispose owned resources in reverse order. */\n  async dispose(): Promise<void> {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.abortController.abort();\n    for (const resource of this.resources.reverse()) {\n      await resource.dispose();\n    }\n    this.resources.length = 0;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,2BAAgD;AAgBzC,MAAM,uBAAoD;AAAA,EAK/D,YACmB,UAER,OACT;AAHiB;AAER;AAPX,SAAiB,kBAAkB,IAAI,gBAAgB;AACvD,SAAiB,YAAwD,CAAC;AAC1E,SAAQ,WAAW;AAAA,EAMhB;AAAA,EAEH,IAAI,SAAsB;AACxB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,MAAS,MAAkB,SAAuD;AAChF,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,iBAAiB,QAAQ,KAAK,iBAAiB,KAAK,KAAK;AAAA,MAE3D;AAAA,IACF;AACA,WAAO,KAAK,SAAS,MAAM,MAAM;AAAA,MAC/B,OAAO,QAAQ;AAAA,MACf,MAAM,QAAQ,QAAQ;AAAA,MACtB,OAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,UAAqD;AACvD,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,KAAK;AAAA,MACjD;AAAA,IACF;AACA,SAAK,UAAU,KAAK,QAAQ;AAAA,EAC9B;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,MAAM,UAAyB;AAC7B,QAAI,KAAK,SAAU;AACnB,SAAK,WAAW;AAChB,SAAK,gBAAgB,MAAM;AAC3B,eAAW,YAAY,KAAK,UAAU,QAAQ,GAAG;AAC/C,YAAM,SAAS,QAAQ;AAAA,IACzB;AACA,SAAK,UAAU,SAAS;AAAA,EAC1B;AACF;","names":[]}
+{"version":3,"sources":["../../src/frontend/frontend_lifecycle.ts"],"sourcesContent":["/**\n * Production lifecycle owners for deliberately detached frontend work\n * (18A D-FAS-01 §2.2). Two natural owners exist per environment:\n *\n *   page lifecycle         — default for PageController work; aborted and\n *                            disposed when that page ends\n *   application lifecycle  — explicit for work that intentionally survives\n *                            page navigation; disposed with the environment\n *\n * PageControllers/client services register their own deliberately detached\n * finite work through their injected lifecycle owner — tests do not repair\n * unowned product code by wrapping it in track() from the outside.\n */\nimport { cleanupAll } from '../controller/cleanup.js';\nimport { WorkRegistry, FrontendWorkError } from './work_registry.js';\n\nexport interface FrontendLifecycle {\n  readonly signal: AbortSignal;\n\n  track<T>(\n    work: Promise<T>,\n    options: {\n      label: string;\n      kind?: string;\n    },\n  ): Promise<T>;\n\n  own(resource: { dispose(): void | Promise<void> }): void;\n}\n\nexport class FrontendLifecycleOwner implements FrontendLifecycle {\n  private readonly abortController = new AbortController();\n  private readonly resources: Array<{ dispose(): void | Promise<void> }> = [];\n  private disposed = false;\n\n  constructor(\n    private readonly registry: WorkRegistry,\n    /** Diagnostic owner identity, e.g. `page main.chat_dom` or `application`. */\n    readonly owner: string,\n  ) {}\n\n  get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n\n  track<T>(work: Promise<T>, options: { label: string; kind?: string }): Promise<T> {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot track \"${options.label}\": lifecycle \"${this.owner}\" is disposed. ` +\n        'Work started after a page/environment ended is a product lifecycle bug.',\n      );\n    }\n    return this.registry.track(work, {\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: this.owner,\n    });\n  }\n\n  own(resource: { dispose(): void | Promise<void> }): void {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot own a resource: lifecycle \"${this.owner}\" is disposed.`,\n      );\n    }\n    this.resources.push(resource);\n  }\n\n  get isDisposed(): boolean {\n    return this.disposed;\n  }\n\n  /** Abort owned work and dispose owned resources in reverse order. */\n  private closing?: Promise<void>;\n  dispose(): Promise<void> {\n    if (this.closing) return this.closing;\n    this.disposed = true;\n    this.abortController.abort();\n    const resources = this.resources.splice(0).reverse();\n    return this.closing = cleanupAll(resources.map(resource => () => resource.dispose()), 'Wood frontend lifecycle cleanup failed');\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAaA,qBAA2B;AAC3B,2BAAgD;AAgBzC,MAAM,uBAAoD;AAAA,EAK/D,YACmB,UAER,OACT;AAHiB;AAER;AAPX,SAAiB,kBAAkB,IAAI,gBAAgB;AACvD,SAAiB,YAAwD,CAAC;AAC1E,SAAQ,WAAW;AAAA,EAMhB;AAAA,EAEH,IAAI,SAAsB;AACxB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,MAAS,MAAkB,SAAuD;AAChF,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,iBAAiB,QAAQ,KAAK,iBAAiB,KAAK,KAAK;AAAA,MAE3D;AAAA,IACF;AACA,WAAO,KAAK,SAAS,MAAM,MAAM;AAAA,MAC/B,OAAO,QAAQ;AAAA,MACf,MAAM,QAAQ,QAAQ;AAAA,MACtB,OAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,UAAqD;AACvD,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,KAAK;AAAA,MACjD;AAAA,IACF;AACA,SAAK,UAAU,KAAK,QAAQ;AAAA,EAC9B;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAIA,UAAyB;AACvB,QAAI,KAAK,QAAS,QAAO,KAAK;AAC9B,SAAK,WAAW;AAChB,SAAK,gBAAgB,MAAM;AAC3B,UAAM,YAAY,KAAK,UAAU,OAAO,CAAC,EAAE,QAAQ;AACnD,WAAO,KAAK,cAAU,2BAAW,UAAU,IAAI,cAAY,MAAM,SAAS,QAAQ,CAAC,GAAG,wCAAwC;AAAA,EAChI;AACF;","names":[]}

package/dist/frontend/frontend_lifecycle.d.cts

@@ -1,19 +1,5 @@
 import { WorkRegistry } from './work_registry.cjs';
 
-/**
- * Production lifecycle owners for deliberately detached frontend work
- * (18A D-FAS-01 §2.2). Two natural owners exist per environment:
- *
- *   page lifecycle         — default for PageController work; aborted and
- *                            disposed when that page ends
- *   application lifecycle  — explicit for work that intentionally survives
- *                            page navigation; disposed with the environment
- *
- * PageControllers/client services register their own deliberately detached
- * finite work through their injected lifecycle owner — tests do not repair
- * unowned product code by wrapping it in track() from the outside.
- */
-
 interface FrontendLifecycle {
     readonly signal: AbortSignal;
     track<T>(work: Promise<T>, options: {
@@ -44,6 +30,7 @@ declare class FrontendLifecycleOwner implements FrontendLifecycle {
     }): void;
     get isDisposed(): boolean;
     /** Abort owned work and dispose owned resources in reverse order. */
+    private closing?;
     dispose(): Promise<void>;
 }
 

package/dist/frontend/frontend_lifecycle.d.ts

@@ -1,19 +1,5 @@
 import { WorkRegistry } from './work_registry.js';
 
-/**
- * Production lifecycle owners for deliberately detached frontend work
- * (18A D-FAS-01 §2.2). Two natural owners exist per environment:
- *
- *   page lifecycle         — default for PageController work; aborted and
- *                            disposed when that page ends
- *   application lifecycle  — explicit for work that intentionally survives
- *                            page navigation; disposed with the environment
- *
- * PageControllers/client services register their own deliberately detached
- * finite work through their injected lifecycle owner — tests do not repair
- * unowned product code by wrapping it in track() from the outside.
- */
-
 interface FrontendLifecycle {
     readonly signal: AbortSignal;
     track<T>(work: Promise<T>, options: {
@@ -44,6 +30,7 @@ declare class FrontendLifecycleOwner implements FrontendLifecycle {
     }): void;
     get isDisposed(): boolean;
     /** Abort owned work and dispose owned resources in reverse order. */
+    private closing?;
     dispose(): Promise<void>;
 }
 

package/dist/frontend/frontend_lifecycle.js

@@ -1,3 +1,4 @@
+import { cleanupAll } from "../controller/cleanup.js";
 import { FrontendWorkError } from "./work_registry.js";
 class FrontendLifecycleOwner {
   constructor(registry, owner) {
@@ -33,15 +34,12 @@ class FrontendLifecycleOwner {
   get isDisposed() {
     return this.disposed;
   }
-  /** Abort owned work and dispose owned resources in reverse order. */
-  async dispose() {
-    if (this.disposed) return;
+  dispose() {
+    if (this.closing) return this.closing;
     this.disposed = true;
     this.abortController.abort();
-    for (const resource of this.resources.reverse()) {
-      await resource.dispose();
-    }
-    this.resources.length = 0;
+    const resources = this.resources.splice(0).reverse();
+    return this.closing = cleanupAll(resources.map((resource) => () => resource.dispose()), "Wood frontend lifecycle cleanup failed");
   }
 }
 export {

package/dist/frontend/frontend_lifecycle.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/frontend/frontend_lifecycle.ts"],"sourcesContent":["/**\n * Production lifecycle owners for deliberately detached frontend work\n * (18A D-FAS-01 §2.2). Two natural owners exist per environment:\n *\n *   page lifecycle         — default for PageController work; aborted and\n *                            disposed when that page ends\n *   application lifecycle  — explicit for work that intentionally survives\n *                            page navigation; disposed with the environment\n *\n * PageControllers/client services register their own deliberately detached\n * finite work through their injected lifecycle owner — tests do not repair\n * unowned product code by wrapping it in track() from the outside.\n */\nimport { WorkRegistry, FrontendWorkError } from './work_registry.js';\n\nexport interface FrontendLifecycle {\n  readonly signal: AbortSignal;\n\n  track<T>(\n    work: Promise<T>,\n    options: {\n      label: string;\n      kind?: string;\n    },\n  ): Promise<T>;\n\n  own(resource: { dispose(): void | Promise<void> }): void;\n}\n\nexport class FrontendLifecycleOwner implements FrontendLifecycle {\n  private readonly abortController = new AbortController();\n  private readonly resources: Array<{ dispose(): void | Promise<void> }> = [];\n  private disposed = false;\n\n  constructor(\n    private readonly registry: WorkRegistry,\n    /** Diagnostic owner identity, e.g. `page main.chat_dom` or `application`. */\n    readonly owner: string,\n  ) {}\n\n  get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n\n  track<T>(work: Promise<T>, options: { label: string; kind?: string }): Promise<T> {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot track \"${options.label}\": lifecycle \"${this.owner}\" is disposed. ` +\n        'Work started after a page/environment ended is a product lifecycle bug.',\n      );\n    }\n    return this.registry.track(work, {\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: this.owner,\n    });\n  }\n\n  own(resource: { dispose(): void | Promise<void> }): void {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot own a resource: lifecycle \"${this.owner}\" is disposed.`,\n      );\n    }\n    this.resources.push(resource);\n  }\n\n  get isDisposed(): boolean {\n    return this.disposed;\n  }\n\n  /** Abort owned work and dispose owned resources in reverse order. */\n  async dispose(): Promise<void> {\n    if (this.disposed) return;\n    this.disposed = true;\n    this.abortController.abort();\n    for (const resource of this.resources.reverse()) {\n      await resource.dispose();\n    }\n    this.resources.length = 0;\n  }\n}\n"],"mappings":"AAaA,SAAuB,yBAAyB;AAgBzC,MAAM,uBAAoD;AAAA,EAK/D,YACmB,UAER,OACT;AAHiB;AAER;AAPX,SAAiB,kBAAkB,IAAI,gBAAgB;AACvD,SAAiB,YAAwD,CAAC;AAC1E,SAAQ,WAAW;AAAA,EAMhB;AAAA,EAEH,IAAI,SAAsB;AACxB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,MAAS,MAAkB,SAAuD;AAChF,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,iBAAiB,QAAQ,KAAK,iBAAiB,KAAK,KAAK;AAAA,MAE3D;AAAA,IACF;AACA,WAAO,KAAK,SAAS,MAAM,MAAM;AAAA,MAC/B,OAAO,QAAQ;AAAA,MACf,MAAM,QAAQ,QAAQ;AAAA,MACtB,OAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,UAAqD;AACvD,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,KAAK;AAAA,MACjD;AAAA,IACF;AACA,SAAK,UAAU,KAAK,QAAQ;AAAA,EAC9B;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA;AAAA,EAGA,MAAM,UAAyB;AAC7B,QAAI,KAAK,SAAU;AACnB,SAAK,WAAW;AAChB,SAAK,gBAAgB,MAAM;AAC3B,eAAW,YAAY,KAAK,UAAU,QAAQ,GAAG;AAC/C,YAAM,SAAS,QAAQ;AAAA,IACzB;AACA,SAAK,UAAU,SAAS;AAAA,EAC1B;AACF;","names":[]}
+{"version":3,"sources":["../../src/frontend/frontend_lifecycle.ts"],"sourcesContent":["/**\n * Production lifecycle owners for deliberately detached frontend work\n * (18A D-FAS-01 §2.2). Two natural owners exist per environment:\n *\n *   page lifecycle         — default for PageController work; aborted and\n *                            disposed when that page ends\n *   application lifecycle  — explicit for work that intentionally survives\n *                            page navigation; disposed with the environment\n *\n * PageControllers/client services register their own deliberately detached\n * finite work through their injected lifecycle owner — tests do not repair\n * unowned product code by wrapping it in track() from the outside.\n */\nimport { cleanupAll } from '../controller/cleanup.js';\nimport { WorkRegistry, FrontendWorkError } from './work_registry.js';\n\nexport interface FrontendLifecycle {\n  readonly signal: AbortSignal;\n\n  track<T>(\n    work: Promise<T>,\n    options: {\n      label: string;\n      kind?: string;\n    },\n  ): Promise<T>;\n\n  own(resource: { dispose(): void | Promise<void> }): void;\n}\n\nexport class FrontendLifecycleOwner implements FrontendLifecycle {\n  private readonly abortController = new AbortController();\n  private readonly resources: Array<{ dispose(): void | Promise<void> }> = [];\n  private disposed = false;\n\n  constructor(\n    private readonly registry: WorkRegistry,\n    /** Diagnostic owner identity, e.g. `page main.chat_dom` or `application`. */\n    readonly owner: string,\n  ) {}\n\n  get signal(): AbortSignal {\n    return this.abortController.signal;\n  }\n\n  track<T>(work: Promise<T>, options: { label: string; kind?: string }): Promise<T> {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot track \"${options.label}\": lifecycle \"${this.owner}\" is disposed. ` +\n        'Work started after a page/environment ended is a product lifecycle bug.',\n      );\n    }\n    return this.registry.track(work, {\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: this.owner,\n    });\n  }\n\n  own(resource: { dispose(): void | Promise<void> }): void {\n    if (this.disposed) {\n      throw new FrontendWorkError(\n        `cannot own a resource: lifecycle \"${this.owner}\" is disposed.`,\n      );\n    }\n    this.resources.push(resource);\n  }\n\n  get isDisposed(): boolean {\n    return this.disposed;\n  }\n\n  /** Abort owned work and dispose owned resources in reverse order. */\n  private closing?: Promise<void>;\n  dispose(): Promise<void> {\n    if (this.closing) return this.closing;\n    this.disposed = true;\n    this.abortController.abort();\n    const resources = this.resources.splice(0).reverse();\n    return this.closing = cleanupAll(resources.map(resource => () => resource.dispose()), 'Wood frontend lifecycle cleanup failed');\n  }\n}\n"],"mappings":"AAaA,SAAS,kBAAkB;AAC3B,SAAuB,yBAAyB;AAgBzC,MAAM,uBAAoD;AAAA,EAK/D,YACmB,UAER,OACT;AAHiB;AAER;AAPX,SAAiB,kBAAkB,IAAI,gBAAgB;AACvD,SAAiB,YAAwD,CAAC;AAC1E,SAAQ,WAAW;AAAA,EAMhB;AAAA,EAEH,IAAI,SAAsB;AACxB,WAAO,KAAK,gBAAgB;AAAA,EAC9B;AAAA,EAEA,MAAS,MAAkB,SAAuD;AAChF,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,iBAAiB,QAAQ,KAAK,iBAAiB,KAAK,KAAK;AAAA,MAE3D;AAAA,IACF;AACA,WAAO,KAAK,SAAS,MAAM,MAAM;AAAA,MAC/B,OAAO,QAAQ;AAAA,MACf,MAAM,QAAQ,QAAQ;AAAA,MACtB,OAAO,KAAK;AAAA,IACd,CAAC;AAAA,EACH;AAAA,EAEA,IAAI,UAAqD;AACvD,QAAI,KAAK,UAAU;AACjB,YAAM,IAAI;AAAA,QACR,qCAAqC,KAAK,KAAK;AAAA,MACjD;AAAA,IACF;AACA,SAAK,UAAU,KAAK,QAAQ;AAAA,EAC9B;AAAA,EAEA,IAAI,aAAsB;AACxB,WAAO,KAAK;AAAA,EACd;AAAA,EAIA,UAAyB;AACvB,QAAI,KAAK,QAAS,QAAO,KAAK;AAC9B,SAAK,WAAW;AAChB,SAAK,gBAAgB,MAAM;AAC3B,UAAM,YAAY,KAAK,UAAU,OAAO,CAAC,EAAE,QAAQ;AACnD,WAAO,KAAK,UAAU,WAAW,UAAU,IAAI,cAAY,MAAM,SAAS,QAAQ,CAAC,GAAG,wCAAwC;AAAA,EAChI;AACF;","names":[]}

package/dist/frontend/frontend_surface.cjs

@@ -24,6 +24,7 @@ __export(frontend_surface_exports, {
 module.exports = __toCommonJS(frontend_surface_exports);
 var import_ioc = require("@noego/ioc");
 var import_layout_preservation = require("../navigation/layout_preservation.js");
+var import_cleanup = require("../controller/cleanup.js");
 var import_controller_lifecycle = require("../controller/controller_lifecycle.js");
 var import_page_catalog = require("./page_catalog.js");
 var import_work_registry = require("./work_registry.js");
@@ -34,26 +35,6 @@ function registerControllerUnlessBound(scope, ControllerClass) {
   if (typeof registrable.isRegistered === "function" && registrable.isRegistered(ControllerClass)) return;
   if (typeof scope.registerClass === "function") scope.registerClass(ControllerClass);
 }
-function guardControllerLifecycleOnce(instance) {
-  if (!instance || typeof instance !== "object") return;
-  const target = instance;
-  for (const hook of ["dispose", "destroy"]) {
-    const original = target[hook];
-    if (typeof original !== "function") continue;
-    if (Object.prototype.hasOwnProperty.call(target, hook)) continue;
-    let called = false;
-    Object.defineProperty(target, hook, {
-      configurable: true,
-      writable: true,
-      enumerable: false,
-      value: function guarded(...args) {
-        if (called) return void 0;
-        called = true;
-        return original.apply(this, args);
-      }
-    });
-  }
-}
 function createFrontendSurface(options) {
   const { catalog, rendererRoot, registry, navigation } = options;
   const flushHooks = options.flushHooks ?? [];
@@ -61,6 +42,16 @@ function createFrontendSurface(options) {
   let active = null;
   let transitioning = false;
   let disposed = false;
+  let navigationQueue = Promise.resolve();
+  let closing;
+  const retainedPageScopes = /* @__PURE__ */ new Map();
+  const locallyOwnedControllers = /* @__PURE__ */ new WeakSet();
+  const markController = (instance, token) => {
+    const root = rendererRoot;
+    if (!root.isRegistered?.(token) && instance && typeof instance === "object") locallyOwnedControllers.add(instance);
+    (0, import_controller_lifecycle.guardControllerLifecycleOnce)(instance);
+  };
+  const disposeLocalController = (instance) => instance && typeof instance === "object" && locallyOwnedControllers.has(instance) ? (0, import_controller_lifecycle.disposeControllerLifecycle)(instance) : Promise.resolve();
   const currentOwner = () => active ? `page ${active.identity}` : "application";
   async function constructPage(view, params, query, preserved = []) {
     const identity = (0, import_page_catalog.pageIdentity)(view);
@@ -72,91 +63,111 @@ function createFrontendSurface(options) {
     const ControllerClass = await options.resolveController(view.controller, view);
     const scope = rendererRoot.extend();
     const lifecycle = new import_frontend_lifecycle.FrontendLifecycleOwner(registry, `page ${identity}`);
-    scope.registerFunction?.(import_frontend_lifecycle.FrontendLifecycleOwner, () => lifecycle, { loadAs: import_ioc.LoadAs.Scoped });
-    await options.configurePageScope?.(scope, view, {
-      kind: "page",
-      controller: view.controller
-    });
-    registerControllerUnlessBound(scope, ControllerClass);
-    const layouts = [...preserved];
-    for (let index = preserved.length; index < view.layouts.length; index += 1) {
-      const layoutIdentity = view.layoutControllers?.[index];
-      if (!layoutIdentity) continue;
-      const preserve = view.layoutPreserve?.[index] === true;
-      const LayoutClass = await options.resolveController(layoutIdentity, view);
-      const ownScope = preserve ? rendererRoot.extend() : null;
-      const ownLifecycle = ownScope ? new import_frontend_lifecycle.FrontendLifecycleOwner(registry, `layout ${layoutIdentity}`) : null;
-      const layoutScope = ownScope ?? scope;
-      if (ownScope) {
-        ownScope.registerFunction?.(import_frontend_lifecycle.FrontendLifecycleOwner, () => ownLifecycle, { loadAs: import_ioc.LoadAs.Scoped });
-        await options.configurePageScope?.(ownScope, view, {
-          kind: "layout",
-          layoutIndex: index,
-          controller: layoutIdentity
+    const rollback = [
+      () => import_ioc.ExecutionContext.run(scope, () => scope.dispose?.()),
+      () => lifecycle.dispose()
+    ];
+    try {
+      scope.registerFunction?.(import_frontend_lifecycle.FrontendLifecycleOwner, () => lifecycle, { loadAs: import_ioc.LoadAs.Scoped });
+      await import_ioc.ExecutionContext.run(scope, () => options.configurePageScope?.(scope, view, { kind: "page", controller: view.controller }));
+      registerControllerUnlessBound(scope, ControllerClass);
+      const layouts = [...preserved];
+      for (let index = preserved.length; index < view.layouts.length; index += 1) {
+        const layoutIdentity = view.layoutControllers?.[index];
+        if (!layoutIdentity) continue;
+        const preserve = view.layoutPreserve?.[index] === true;
+        const LayoutClass = await options.resolveController(layoutIdentity, view);
+        const ownScope = preserve ? rendererRoot.extend() : null;
+        const ownLifecycle = ownScope ? new import_frontend_lifecycle.FrontendLifecycleOwner(registry, `layout ${layoutIdentity}`) : null;
+        const layoutScope = ownScope ?? scope;
+        if (ownScope) {
+          rollback.push(() => import_ioc.ExecutionContext.run(ownScope, () => ownScope.dispose?.()));
+          rollback.push(() => ownLifecycle.dispose());
+          ownScope.registerFunction?.(import_frontend_lifecycle.FrontendLifecycleOwner, () => ownLifecycle, { loadAs: import_ioc.LoadAs.Scoped });
+          await import_ioc.ExecutionContext.run(ownScope, () => options.configurePageScope?.(ownScope, view, {
+            kind: "layout",
+            layoutIndex: index,
+            controller: layoutIdentity
+          }));
+        }
+        registerControllerUnlessBound(layoutScope, LayoutClass);
+        const instance = await import_ioc.ExecutionContext.run(
+          layoutScope,
+          () => layoutScope.get(LayoutClass)
+        );
+        markController(instance, LayoutClass);
+        rollback.push(() => import_ioc.ExecutionContext.run(layoutScope, () => disposeLocalController(instance)));
+        layouts.push({
+          index,
+          path: view.layouts[index],
+          controller: layoutIdentity,
+          preserve,
+          instance,
+          scope: layoutScope,
+          ownScope,
+          ownLifecycle
         });
       }
-      registerControllerUnlessBound(layoutScope, LayoutClass);
-      const instance = await import_ioc.ExecutionContext.run(
-        layoutScope,
-        () => layoutScope.get(LayoutClass)
+      const controller = await import_ioc.ExecutionContext.run(
+        scope,
+        () => scope.get(ControllerClass)
       );
-      guardControllerLifecycleOnce(instance);
-      layouts.push({
-        index,
-        path: view.layouts[index],
-        controller: layoutIdentity,
-        preserve,
-        instance,
-        scope: layoutScope,
-        ownScope,
-        ownLifecycle
+      markController(controller, ControllerClass);
+      rollback.push(() => import_ioc.ExecutionContext.run(scope, () => disposeLocalController(controller)));
+      if (typeof controller.initialize === "function") {
+        await registry.track(
+          Promise.resolve(
+            import_ioc.ExecutionContext.run(
+              scope,
+              () => controller.initialize({ params, query })
+            )
+          ).then(() => void 0),
+          { label: `initialize ${identity}`, kind: "initialize", owner: `page ${identity}` }
+        );
+      }
+      const handle = (0, import_frontend_page.createFrontendPage)({
+        identity,
+        controller,
+        scope,
+        layouts,
+        onClose: async () => {
+          await disposePage(identity);
+        }
       });
-    }
-    const controller = await import_ioc.ExecutionContext.run(
-      scope,
-      () => scope.get(ControllerClass)
-    );
-    guardControllerLifecycleOnce(controller);
-    if (typeof controller.initialize === "function") {
-      await registry.track(
-        Promise.resolve(
-          import_ioc.ExecutionContext.run(
-            scope,
-            () => controller.initialize({ params, query })
-          )
-        ).then(() => void 0),
-        { label: `initialize ${identity}`, kind: "initialize", owner: `page ${identity}` }
-      );
-    }
-    const handle = (0, import_frontend_page.createFrontendPage)({
-      identity,
-      controller,
-      scope,
-      layouts,
-      onClose: async () => {
-        await disposePage(identity);
+      return { identity, view, scope, lifecycle, handle, controller, layouts };
+    } catch (error) {
+      try {
+        await (0, import_cleanup.cleanupAll)(rollback.reverse(), "Wood page rollback failed");
+      } catch (cleanupError) {
+        throw Object.assign(new Error("Wood page construction and cleanup failed"), { cause: error, errors: [error, cleanupError] });
       }
-    });
-    return { identity, view, scope, lifecycle, handle, controller, layouts };
+      throw error;
+    }
   }
   async function endPage(page, preservedDepth = 0) {
     page.handle.invalidate();
-    await (0, import_controller_lifecycle.disposeControllerLifecycle)(page.controller);
+    const steps = [
+      () => import_ioc.ExecutionContext.run(page.scope, () => disposeLocalController(page.controller))
+    ];
     for (const layout of page.layouts) {
       if (layout.index < preservedDepth) continue;
-      await (0, import_controller_lifecycle.disposeControllerLifecycle)(layout.instance);
+      steps.push(() => import_ioc.ExecutionContext.run(layout.scope, () => disposeLocalController(layout.instance)));
+      steps.push(() => layout.ownLifecycle?.dispose());
+      if (layout.ownScope) steps.push(() => import_ioc.ExecutionContext.run(layout.ownScope, () => layout.ownScope.dispose?.()));
     }
-    await page.lifecycle.dispose();
-    if (typeof page.scope.dispose === "function") {
-      await page.scope.dispose();
+    const carriesPageScope = page.layouts.some((layout) => layout.index < preservedDepth && layout.scope === page.scope);
+    if (carriesPageScope) retainedPageScopes.set(page.scope, page.lifecycle);
+    else {
+      steps.push(() => page.lifecycle.dispose());
+      steps.push(() => import_ioc.ExecutionContext.run(page.scope, () => page.scope.dispose?.()));
     }
-    for (const layout of page.layouts) {
-      if (layout.index < preservedDepth) continue;
-      await layout.ownLifecycle?.dispose();
-      if (layout.ownScope && typeof layout.ownScope.dispose === "function") {
-        await layout.ownScope.dispose();
-      }
+    for (const [scope, lifecycle] of retainedPageScopes) {
+      if (active?.layouts.some((layout) => layout.scope === scope)) continue;
+      retainedPageScopes.delete(scope);
+      steps.push(() => lifecycle.dispose());
+      steps.push(() => import_ioc.ExecutionContext.run(scope, () => scope.dispose?.()));
     }
+    await (0, import_cleanup.cleanupAll)(steps, "Wood page cleanup failed");
   }
   async function disposePage(identity) {
     if (!active || active.identity !== identity) return;
@@ -165,6 +176,7 @@ function createFrontendSurface(options) {
     await endPage(ended);
   }
   async function transitionTo(entry) {
+    if (disposed) return;
     const view = catalog.resolve(entry.page);
     const previous = active;
     const depth = previous ? (0, import_layout_preservation.computePreservedLayoutDepth)(
@@ -174,16 +186,23 @@ function createFrontendSurface(options) {
     ) : 0;
     const carried = previous ? previous.layouts.filter((layout) => layout.index < depth) : [];
     const next = await constructPage(view, entry.params, entry.query, carried);
+    if (disposed) {
+      await endPage(next, depth);
+      return;
+    }
     active = next;
     if (previous) {
       await endPage(previous, depth);
     }
   }
-  navigation.subscribe((entry) => {
+  const unsubscribe = navigation.subscribe((entry) => {
     if (!entry || transitioning || disposed) return;
     if (active && entry.page === active.identity) return;
     if (!active) return;
-    registry.track(transitionTo(entry), {
+    const transition = navigationQueue.then(() => transitionTo(entry));
+    navigationQueue = transition.catch(() => {
+    });
+    registry.track(transition, {
       label: `navigate ${active.identity} -> ${entry.page}`,
       kind: "navigation",
       owner: currentOwner()
@@ -192,6 +211,7 @@ function createFrontendSurface(options) {
   return {
     navigation,
     async open(openOptions) {
+      if (disposed || transitioning) throw new import_page_catalog.PageCatalogError("Wood frontend is closed or opening a page");
       if (!openOptions || typeof openOptions.page !== "string" || !openOptions.page.length) {
         throw new import_page_catalog.PageCatalogError("frontend.open() requires an explicit { page } identity");
       }
@@ -206,7 +226,12 @@ function createFrontendSurface(options) {
       transitioning = true;
       try {
         navigation.replace((0, import_page_catalog.pageIdentity)(view), params, query);
-        active = await constructPage(view, params, query);
+        const opened = await constructPage(view, params, query);
+        if (disposed) {
+          await endPage(opened);
+          throw new import_page_catalog.PageCatalogError("Wood frontend was disposed during page construction");
+        }
+        active = opened;
       } finally {
         transitioning = false;
       }
@@ -216,7 +241,7 @@ function createFrontendSurface(options) {
       return active ? active.handle.page : null;
     },
     async act(action) {
-      await registry.track(
+      void registry.track(
         Promise.resolve().then(() => action()).then(() => void 0),
         { label: "act()", kind: "tracked", owner: currentOwner() }
       ).catch(() => {
@@ -229,15 +254,16 @@ function createFrontendSurface(options) {
     get errors() {
       return registry.errors();
     },
-    async dispose() {
-      if (disposed) return;
+    dispose() {
+      if (closing) return closing;
       disposed = true;
-      if (active) {
-        const ended = active;
-        active = null;
-        await endPage(ended);
-      }
-      await application.dispose();
+      unsubscribe();
+      const ended = active;
+      active = null;
+      return closing = (0, import_cleanup.cleanupAll)([
+        () => ended ? endPage(ended) : void 0,
+        () => application.dispose()
+      ], "Wood frontend cleanup failed");
     }
   };
 }