@noego/wood 0.4.10 → 0.5.0

package/dist/frontend/tracked_transport.d.cts

@@ -0,0 +1,36 @@
+import { WoodRpcTransport } from '../transport/wood_rpc_transport.cjs';
+import { WorkRegistry } from './work_registry.cjs';
+
+/**
+ * Work-tracking decorator over any `WoodRpcTransport` (18A D-FAS-01 §2.2).
+ *
+ * Every client invocation registers finite owned work at the transport seam;
+ * every queued event delivery to a frontend listener is finite owned work
+ * (promise-returning listeners are awaited). A subscription itself is a
+ * resident resource — it never blocks settling and is removed when the
+ * owning page/application lifecycle ends.
+ *
+ * This is a wrapper, not a modification: `InProcessRouterTransport` and the
+ * shared bridge builders are untouched, so existing harness users see no
+ * behavior change.
+ *
+ * Honesty note: backend work that continues after `invoke` resolves (e.g. a
+ * stream emitting after the dispatch returned) is only observable when its
+ * emissions arrive as tracked event deliveries. `settle()` drains queued
+ * deliveries; it does not claim to await a backend's private timeline —
+ * tests script the external boundary or await a terminal event.
+ */
+
+declare class TrackedTransport implements WoodRpcTransport {
+    private readonly inner;
+    private readonly registry;
+    /** Captures the owning lifecycle identity at call/subscription time. */
+    private readonly currentOwner;
+    constructor(inner: WoodRpcTransport, registry: WorkRegistry, 
+    /** Captures the owning lifecycle identity at call/subscription time. */
+    currentOwner: () => string);
+    invoke(channel: string, payload?: unknown): Promise<unknown>;
+    subscribe(channel: string, listener: (payload: unknown) => void): () => void;
+}
+
+export { TrackedTransport };

package/dist/frontend/tracked_transport.d.ts

@@ -0,0 +1,36 @@
+import { WoodRpcTransport } from '../transport/wood_rpc_transport.js';
+import { WorkRegistry } from './work_registry.js';
+
+/**
+ * Work-tracking decorator over any `WoodRpcTransport` (18A D-FAS-01 §2.2).
+ *
+ * Every client invocation registers finite owned work at the transport seam;
+ * every queued event delivery to a frontend listener is finite owned work
+ * (promise-returning listeners are awaited). A subscription itself is a
+ * resident resource — it never blocks settling and is removed when the
+ * owning page/application lifecycle ends.
+ *
+ * This is a wrapper, not a modification: `InProcessRouterTransport` and the
+ * shared bridge builders are untouched, so existing harness users see no
+ * behavior change.
+ *
+ * Honesty note: backend work that continues after `invoke` resolves (e.g. a
+ * stream emitting after the dispatch returned) is only observable when its
+ * emissions arrive as tracked event deliveries. `settle()` drains queued
+ * deliveries; it does not claim to await a backend's private timeline —
+ * tests script the external boundary or await a terminal event.
+ */
+
+declare class TrackedTransport implements WoodRpcTransport {
+    private readonly inner;
+    private readonly registry;
+    /** Captures the owning lifecycle identity at call/subscription time. */
+    private readonly currentOwner;
+    constructor(inner: WoodRpcTransport, registry: WorkRegistry, 
+    /** Captures the owning lifecycle identity at call/subscription time. */
+    currentOwner: () => string);
+    invoke(channel: string, payload?: unknown): Promise<unknown>;
+    subscribe(channel: string, listener: (payload: unknown) => void): () => void;
+}
+
+export { TrackedTransport };

package/dist/frontend/tracked_transport.js

@@ -0,0 +1,31 @@
+class TrackedTransport {
+  constructor(inner, registry, currentOwner) {
+    this.inner = inner;
+    this.registry = registry;
+    this.currentOwner = currentOwner;
+  }
+  invoke(channel, payload) {
+    return this.registry.track(this.inner.invoke(channel, payload), {
+      label: `invoke ${channel}`,
+      kind: "invoke",
+      owner: this.currentOwner()
+    });
+  }
+  subscribe(channel, listener) {
+    const owner = this.currentOwner();
+    return this.inner.subscribe(channel, (payload) => {
+      const result = listener(payload);
+      if (result && typeof result.then === "function") {
+        this.registry.track(result, {
+          label: `event ${channel}`,
+          kind: "event-delivery",
+          owner
+        });
+      }
+    });
+  }
+}
+export {
+  TrackedTransport
+};
+//# sourceMappingURL=tracked_transport.js.map

package/dist/frontend/tracked_transport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/frontend/tracked_transport.ts"],"sourcesContent":["/**\n * Work-tracking decorator over any `WoodRpcTransport` (18A D-FAS-01 §2.2).\n *\n * Every client invocation registers finite owned work at the transport seam;\n * every queued event delivery to a frontend listener is finite owned work\n * (promise-returning listeners are awaited). A subscription itself is a\n * resident resource — it never blocks settling and is removed when the\n * owning page/application lifecycle ends.\n *\n * This is a wrapper, not a modification: `InProcessRouterTransport` and the\n * shared bridge builders are untouched, so existing harness users see no\n * behavior change.\n *\n * Honesty note: backend work that continues after `invoke` resolves (e.g. a\n * stream emitting after the dispatch returned) is only observable when its\n * emissions arrive as tracked event deliveries. `settle()` drains queued\n * deliveries; it does not claim to await a backend's private timeline —\n * tests script the external boundary or await a terminal event.\n */\nimport type { WoodRpcTransport } from '../transport/wood_rpc_transport.js';\nimport type { WorkRegistry } from './work_registry.js';\n\nexport class TrackedTransport implements WoodRpcTransport {\n  constructor(\n    private readonly inner: WoodRpcTransport,\n    private readonly registry: WorkRegistry,\n    /** Captures the owning lifecycle identity at call/subscription time. */\n    private readonly currentOwner: () => string,\n  ) {}\n\n  invoke(channel: string, payload?: unknown): Promise<unknown> {\n    return this.registry.track(this.inner.invoke(channel, payload), {\n      label: `invoke ${channel}`,\n      kind: 'invoke',\n      owner: this.currentOwner(),\n    });\n  }\n\n  subscribe(channel: string, listener: (payload: unknown) => void): () => void {\n    // Owner is fixed at subscription time: deliveries belong to the\n    // subscribing page, not to whichever context happens to be active\n    // when the backend pushes.\n    const owner = this.currentOwner();\n    return this.inner.subscribe(channel, (payload) => {\n      // Deliver SYNCHRONOUSLY — identical to the production bridge path.\n      // Deferring delivery to a microtask would reorder produce/consume\n      // loops the product paces at the event seam. Only an asynchronous\n      // continuation (a promise-returning listener) becomes tracked work.\n      const result = listener(payload) as unknown;\n      if (result && typeof (result as Promise<unknown>).then === 'function') {\n        this.registry.track(result as Promise<unknown>, {\n          label: `event ${channel}`,\n          kind: 'event-delivery',\n          owner,\n        });\n      }\n    });\n  }\n}\n"],"mappings":"AAsBO,MAAM,iBAA6C;AAAA,EACxD,YACmB,OACA,UAEA,cACjB;AAJiB;AACA;AAEA;AAAA,EAChB;AAAA,EAEH,OAAO,SAAiB,SAAqC;AAC3D,WAAO,KAAK,SAAS,MAAM,KAAK,MAAM,OAAO,SAAS,OAAO,GAAG;AAAA,MAC9D,OAAO,UAAU,OAAO;AAAA,MACxB,MAAM;AAAA,MACN,OAAO,KAAK,aAAa;AAAA,IAC3B,CAAC;AAAA,EACH;AAAA,EAEA,UAAU,SAAiB,UAAkD;AAI3E,UAAM,QAAQ,KAAK,aAAa;AAChC,WAAO,KAAK,MAAM,UAAU,SAAS,CAAC,YAAY;AAKhD,YAAM,SAAS,SAAS,OAAO;AAC/B,UAAI,UAAU,OAAQ,OAA4B,SAAS,YAAY;AACrE,aAAK,SAAS,MAAM,QAA4B;AAAA,UAC9C,OAAO,SAAS,OAAO;AAAA,UACvB,MAAM;AAAA,UACN;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF,CAAC;AAAA,EACH;AACF;","names":[]}

package/dist/frontend/work_registry.cjs

@@ -0,0 +1,153 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var work_registry_exports = {};
+__export(work_registry_exports, {
+  FrontendWorkError: () => FrontendWorkError,
+  WorkRegistry: () => WorkRegistry
+});
+module.exports = __toCommonJS(work_registry_exports);
+const MAX_DRAIN_PASSES = 100;
+class FrontendWorkError extends Error {
+  constructor(message, failures = []) {
+    super(message);
+    this.failures = failures;
+    this.name = "FrontendWorkError";
+  }
+}
+function describe(work) {
+  return `[${work.kind}] ${work.label} (owner: ${work.owner})`;
+}
+class WorkRegistry {
+  constructor() {
+    this.nextId = 1;
+    /** Total registrations ever — the fixed-point signal for draining. */
+    this.registrations = 0;
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.failures = [];
+    /** How many failures a completed drain has already reported. */
+    this.reportedFailures = 0;
+    this.drainChain = Promise.resolve();
+  }
+  /**
+   * Register finite owned work. Returns a promise with the work's own
+   * settlement semantics — callers may await it directly; the registry
+   * additionally observes completion (success or failure) for draining.
+   */
+  track(work, options) {
+    const descriptor = {
+      id: this.nextId++,
+      label: options.label,
+      kind: options.kind ?? "tracked",
+      owner: options.owner ?? "application"
+    };
+    this.registrations += 1;
+    const promise = typeof work === "function" ? work() : work;
+    const observed = promise.then(
+      () => void 0,
+      (error) => {
+        this.failures.push({ ...descriptor, error });
+      }
+    ).finally(() => {
+      this.inFlight.delete(descriptor.id);
+    });
+    this.inFlight.set(descriptor.id, { descriptor, observed });
+    return promise;
+  }
+  /** Descriptors of currently incomplete owned work. */
+  pending() {
+    return [...this.inFlight.values()].map((entry) => entry.descriptor);
+  }
+  /** Every owned-work failure observed so far (accumulates across drains). */
+  errors() {
+    return [...this.failures];
+  }
+  /**
+   * Fixed-point drain: await all pending owned work, run the adapter flush
+   * hooks, repeat until one full pass observes no pending work and causes
+   * no new registrations. Concurrent drains queue — each caller gets its
+   * own complete pass over whatever work exists when its turn arrives.
+   *
+   * Rejects with `FrontendWorkError` naming the owners when owned work
+   * failed since the previous drain, or when the pass bound is exceeded
+   * (repeating owned work), listing pending and repeating labels.
+   */
+  drain(flushHooks = []) {
+    const run = this.drainChain.then(() => this.drainOnce(flushHooks));
+    this.drainChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async drainOnce(flushHooks) {
+    const seenPerLabel = /* @__PURE__ */ new Map();
+    for (let pass = 1; pass <= MAX_DRAIN_PASSES; pass++) {
+      const registrationsBefore = this.registrations;
+      const snapshot = [...this.inFlight.values()];
+      for (const { descriptor } of snapshot) {
+        seenPerLabel.set(descriptor.label, (seenPerLabel.get(descriptor.label) ?? 0) + 1);
+      }
+      await Promise.all(snapshot.map((entry) => entry.observed));
+      for (const hook of flushHooks) {
+        await hook();
+      }
+      await Promise.resolve();
+      await Promise.resolve();
+      const stable = this.inFlight.size === 0 && this.registrations === registrationsBefore;
+      if (stable) {
+        this.throwNewFailures();
+        return;
+      }
+    }
+    const pendingLines = this.pending().map(describe);
+    const repeating = [...seenPerLabel.entries()].filter(([, count]) => count > 3).map(([label, count]) => `${label} (seen in ${count} passes)`);
+    throw new FrontendWorkError(
+      `settle did not converge within ${MAX_DRAIN_PASSES} drain passes.
+` + (pendingLines.length ? `Still pending:
+  ${pendingLines.join("\n  ")}
+` : "") + (repeating.length ? `Repeating owned work:
+  ${repeating.join("\n  ")}
+` : "") + "Owned work keeps creating more owned work \u2014 this names the owners; it is not a timeout.",
+      this.takeNewFailures()
+    );
+  }
+  takeNewFailures() {
+    const fresh = this.failures.slice(this.reportedFailures);
+    this.reportedFailures = this.failures.length;
+    return fresh;
+  }
+  throwNewFailures() {
+    const fresh = this.takeNewFailures();
+    if (!fresh.length) return;
+    const lines = fresh.map(
+      (failure) => `${describe(failure)}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`
+    );
+    throw new FrontendWorkError(
+      `owned frontend work failed:
+  ${lines.join("\n  ")}`,
+      fresh
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FrontendWorkError,
+  WorkRegistry
+});
+//# sourceMappingURL=work_registry.cjs.map

package/dist/frontend/work_registry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/frontend/work_registry.ts"],"sourcesContent":["/**\n * Owned-work registry for the frontend application slice (18A D-FAS-01).\n *\n * `act()` and `settle()` drain framework-owned finite work registered here\n * through production seams (transport invokes, event deliveries, navigation\n * transitions, tracked lifecycle tasks). The registry never patches global\n * async primitives and never guesses at event-loop emptiness: work exists\n * only because an owner registered it, and a drain is a fixed point —\n * repeated passes until one complete pass creates no new owned work.\n *\n * Floating promises and bare timers are explicitly outside the guarantee;\n * they are product lifecycle bugs, not framework blind spots to paper over.\n */\n\nexport type WorkKind =\n  | 'invoke'\n  | 'event-delivery'\n  | 'navigation'\n  | 'initialize'\n  | 'tracked'\n  | (string & {});\n\nexport interface WorkOptions {\n  /** Human-readable diagnostic label, e.g. `invoke messages.send`. */\n  label: string;\n  kind?: WorkKind;\n  /** Owning lifecycle identity, e.g. `page main.chat_dom` or `application`. */\n  owner?: string;\n}\n\nexport interface WorkDescriptor {\n  readonly id: number;\n  readonly label: string;\n  readonly kind: WorkKind;\n  readonly owner: string;\n}\n\nexport interface WorkFailure extends WorkDescriptor {\n  readonly error: unknown;\n}\n\n/** Safety bound on drain passes — a diagnostic limit, not the readiness mechanism. */\nconst MAX_DRAIN_PASSES = 100;\n\nexport class FrontendWorkError extends Error {\n  constructor(message: string, readonly failures: readonly WorkFailure[] = []) {\n    super(message);\n    this.name = 'FrontendWorkError';\n  }\n}\n\nfunction describe(work: WorkDescriptor): string {\n  return `[${work.kind}] ${work.label} (owner: ${work.owner})`;\n}\n\nexport class WorkRegistry {\n  private nextId = 1;\n  /** Total registrations ever — the fixed-point signal for draining. */\n  private registrations = 0;\n  private readonly inFlight = new Map<number, { descriptor: WorkDescriptor; observed: Promise<void> }>();\n  private readonly failures: WorkFailure[] = [];\n  /** How many failures a completed drain has already reported. */\n  private reportedFailures = 0;\n  private drainChain: Promise<void> = Promise.resolve();\n\n  /**\n   * Register finite owned work. Returns a promise with the work's own\n   * settlement semantics — callers may await it directly; the registry\n   * additionally observes completion (success or failure) for draining.\n   */\n  track<T>(work: Promise<T> | (() => Promise<T>), options: WorkOptions): Promise<T> {\n    const descriptor: WorkDescriptor = {\n      id: this.nextId++,\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: options.owner ?? 'application',\n    };\n\n    this.registrations += 1;\n    const promise = typeof work === 'function' ? work() : work;\n\n    // Observe settlement without altering the caller's promise semantics.\n    const observed = promise.then(\n      () => undefined,\n      (error) => {\n        this.failures.push({ ...descriptor, error });\n      },\n    ).finally(() => {\n      this.inFlight.delete(descriptor.id);\n    });\n\n    this.inFlight.set(descriptor.id, { descriptor, observed });\n    return promise;\n  }\n\n  /** Descriptors of currently incomplete owned work. */\n  pending(): WorkDescriptor[] {\n    return [...this.inFlight.values()].map((entry) => entry.descriptor);\n  }\n\n  /** Every owned-work failure observed so far (accumulates across drains). */\n  errors(): readonly WorkFailure[] {\n    return [...this.failures];\n  }\n\n  /**\n   * Fixed-point drain: await all pending owned work, run the adapter flush\n   * hooks, repeat until one full pass observes no pending work and causes\n   * no new registrations. Concurrent drains queue — each caller gets its\n   * own complete pass over whatever work exists when its turn arrives.\n   *\n   * Rejects with `FrontendWorkError` naming the owners when owned work\n   * failed since the previous drain, or when the pass bound is exceeded\n   * (repeating owned work), listing pending and repeating labels.\n   */\n  drain(flushHooks: ReadonlyArray<() => void | Promise<void>> = []): Promise<void> {\n    const run = this.drainChain.then(() => this.drainOnce(flushHooks));\n    // Keep the chain alive regardless of this drain's outcome.\n    this.drainChain = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    return run;\n  }\n\n  private async drainOnce(flushHooks: ReadonlyArray<() => void | Promise<void>>): Promise<void> {\n    const seenPerLabel = new Map<string, number>();\n\n    for (let pass = 1; pass <= MAX_DRAIN_PASSES; pass++) {\n      const registrationsBefore = this.registrations;\n      const snapshot = [...this.inFlight.values()];\n\n      for (const { descriptor } of snapshot) {\n        seenPerLabel.set(descriptor.label, (seenPerLabel.get(descriptor.label) ?? 0) + 1);\n      }\n\n      // Observed promises never reject (failures are recorded by track());\n      // awaiting them cannot abort the pass mid-way.\n      await Promise.all(snapshot.map((entry) => entry.observed));\n\n      for (const hook of flushHooks) {\n        await hook();\n      }\n\n      // Give completion continuations a microtask to register follow-on\n      // owned work before the fixed point is tested.\n      await Promise.resolve();\n      await Promise.resolve();\n\n      const stable = this.inFlight.size === 0 && this.registrations === registrationsBefore;\n      if (stable) {\n        this.throwNewFailures();\n        return;\n      }\n    }\n\n    const pendingLines = this.pending().map(describe);\n    const repeating = [...seenPerLabel.entries()]\n      .filter(([, count]) => count > 3)\n      .map(([label, count]) => `${label} (seen in ${count} passes)`);\n\n    throw new FrontendWorkError(\n      `settle did not converge within ${MAX_DRAIN_PASSES} drain passes.\\n` +\n      (pendingLines.length ? `Still pending:\\n  ${pendingLines.join('\\n  ')}\\n` : '') +\n      (repeating.length ? `Repeating owned work:\\n  ${repeating.join('\\n  ')}\\n` : '') +\n      'Owned work keeps creating more owned work — this names the owners; it is not a timeout.',\n      this.takeNewFailures(),\n    );\n  }\n\n  private takeNewFailures(): WorkFailure[] {\n    const fresh = this.failures.slice(this.reportedFailures);\n    this.reportedFailures = this.failures.length;\n    return fresh;\n  }\n\n  private throwNewFailures(): void {\n    const fresh = this.takeNewFailures();\n    if (!fresh.length) return;\n    const lines = fresh.map(\n      (failure) =>\n        `${describe(failure)}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`,\n    );\n    throw new FrontendWorkError(\n      `owned frontend work failed:\\n  ${lines.join('\\n  ')}`,\n      fresh,\n    );\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/frontend/work_registry.d.cts

@@ -0,0 +1,70 @@
+/**
+ * Owned-work registry for the frontend application slice (18A D-FAS-01).
+ *
+ * `act()` and `settle()` drain framework-owned finite work registered here
+ * through production seams (transport invokes, event deliveries, navigation
+ * transitions, tracked lifecycle tasks). The registry never patches global
+ * async primitives and never guesses at event-loop emptiness: work exists
+ * only because an owner registered it, and a drain is a fixed point —
+ * repeated passes until one complete pass creates no new owned work.
+ *
+ * Floating promises and bare timers are explicitly outside the guarantee;
+ * they are product lifecycle bugs, not framework blind spots to paper over.
+ */
+type WorkKind = 'invoke' | 'event-delivery' | 'navigation' | 'initialize' | 'tracked' | (string & {});
+interface WorkOptions {
+    /** Human-readable diagnostic label, e.g. `invoke messages.send`. */
+    label: string;
+    kind?: WorkKind;
+    /** Owning lifecycle identity, e.g. `page main.chat_dom` or `application`. */
+    owner?: string;
+}
+interface WorkDescriptor {
+    readonly id: number;
+    readonly label: string;
+    readonly kind: WorkKind;
+    readonly owner: string;
+}
+interface WorkFailure extends WorkDescriptor {
+    readonly error: unknown;
+}
+declare class FrontendWorkError extends Error {
+    readonly failures: readonly WorkFailure[];
+    constructor(message: string, failures?: readonly WorkFailure[]);
+}
+declare class WorkRegistry {
+    private nextId;
+    /** Total registrations ever — the fixed-point signal for draining. */
+    private registrations;
+    private readonly inFlight;
+    private readonly failures;
+    /** How many failures a completed drain has already reported. */
+    private reportedFailures;
+    private drainChain;
+    /**
+     * Register finite owned work. Returns a promise with the work's own
+     * settlement semantics — callers may await it directly; the registry
+     * additionally observes completion (success or failure) for draining.
+     */
+    track<T>(work: Promise<T> | (() => Promise<T>), options: WorkOptions): Promise<T>;
+    /** Descriptors of currently incomplete owned work. */
+    pending(): WorkDescriptor[];
+    /** Every owned-work failure observed so far (accumulates across drains). */
+    errors(): readonly WorkFailure[];
+    /**
+     * Fixed-point drain: await all pending owned work, run the adapter flush
+     * hooks, repeat until one full pass observes no pending work and causes
+     * no new registrations. Concurrent drains queue — each caller gets its
+     * own complete pass over whatever work exists when its turn arrives.
+     *
+     * Rejects with `FrontendWorkError` naming the owners when owned work
+     * failed since the previous drain, or when the pass bound is exceeded
+     * (repeating owned work), listing pending and repeating labels.
+     */
+    drain(flushHooks?: ReadonlyArray<() => void | Promise<void>>): Promise<void>;
+    private drainOnce;
+    private takeNewFailures;
+    private throwNewFailures;
+}
+
+export { FrontendWorkError, type WorkDescriptor, type WorkFailure, type WorkKind, type WorkOptions, WorkRegistry };

package/dist/frontend/work_registry.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Owned-work registry for the frontend application slice (18A D-FAS-01).
+ *
+ * `act()` and `settle()` drain framework-owned finite work registered here
+ * through production seams (transport invokes, event deliveries, navigation
+ * transitions, tracked lifecycle tasks). The registry never patches global
+ * async primitives and never guesses at event-loop emptiness: work exists
+ * only because an owner registered it, and a drain is a fixed point —
+ * repeated passes until one complete pass creates no new owned work.
+ *
+ * Floating promises and bare timers are explicitly outside the guarantee;
+ * they are product lifecycle bugs, not framework blind spots to paper over.
+ */
+type WorkKind = 'invoke' | 'event-delivery' | 'navigation' | 'initialize' | 'tracked' | (string & {});
+interface WorkOptions {
+    /** Human-readable diagnostic label, e.g. `invoke messages.send`. */
+    label: string;
+    kind?: WorkKind;
+    /** Owning lifecycle identity, e.g. `page main.chat_dom` or `application`. */
+    owner?: string;
+}
+interface WorkDescriptor {
+    readonly id: number;
+    readonly label: string;
+    readonly kind: WorkKind;
+    readonly owner: string;
+}
+interface WorkFailure extends WorkDescriptor {
+    readonly error: unknown;
+}
+declare class FrontendWorkError extends Error {
+    readonly failures: readonly WorkFailure[];
+    constructor(message: string, failures?: readonly WorkFailure[]);
+}
+declare class WorkRegistry {
+    private nextId;
+    /** Total registrations ever — the fixed-point signal for draining. */
+    private registrations;
+    private readonly inFlight;
+    private readonly failures;
+    /** How many failures a completed drain has already reported. */
+    private reportedFailures;
+    private drainChain;
+    /**
+     * Register finite owned work. Returns a promise with the work's own
+     * settlement semantics — callers may await it directly; the registry
+     * additionally observes completion (success or failure) for draining.
+     */
+    track<T>(work: Promise<T> | (() => Promise<T>), options: WorkOptions): Promise<T>;
+    /** Descriptors of currently incomplete owned work. */
+    pending(): WorkDescriptor[];
+    /** Every owned-work failure observed so far (accumulates across drains). */
+    errors(): readonly WorkFailure[];
+    /**
+     * Fixed-point drain: await all pending owned work, run the adapter flush
+     * hooks, repeat until one full pass observes no pending work and causes
+     * no new registrations. Concurrent drains queue — each caller gets its
+     * own complete pass over whatever work exists when its turn arrives.
+     *
+     * Rejects with `FrontendWorkError` naming the owners when owned work
+     * failed since the previous drain, or when the pass bound is exceeded
+     * (repeating owned work), listing pending and repeating labels.
+     */
+    drain(flushHooks?: ReadonlyArray<() => void | Promise<void>>): Promise<void>;
+    private drainOnce;
+    private takeNewFailures;
+    private throwNewFailures;
+}
+
+export { FrontendWorkError, type WorkDescriptor, type WorkFailure, type WorkKind, type WorkOptions, WorkRegistry };

package/dist/frontend/work_registry.js

@@ -0,0 +1,128 @@
+const MAX_DRAIN_PASSES = 100;
+class FrontendWorkError extends Error {
+  constructor(message, failures = []) {
+    super(message);
+    this.failures = failures;
+    this.name = "FrontendWorkError";
+  }
+}
+function describe(work) {
+  return `[${work.kind}] ${work.label} (owner: ${work.owner})`;
+}
+class WorkRegistry {
+  constructor() {
+    this.nextId = 1;
+    /** Total registrations ever — the fixed-point signal for draining. */
+    this.registrations = 0;
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.failures = [];
+    /** How many failures a completed drain has already reported. */
+    this.reportedFailures = 0;
+    this.drainChain = Promise.resolve();
+  }
+  /**
+   * Register finite owned work. Returns a promise with the work's own
+   * settlement semantics — callers may await it directly; the registry
+   * additionally observes completion (success or failure) for draining.
+   */
+  track(work, options) {
+    const descriptor = {
+      id: this.nextId++,
+      label: options.label,
+      kind: options.kind ?? "tracked",
+      owner: options.owner ?? "application"
+    };
+    this.registrations += 1;
+    const promise = typeof work === "function" ? work() : work;
+    const observed = promise.then(
+      () => void 0,
+      (error) => {
+        this.failures.push({ ...descriptor, error });
+      }
+    ).finally(() => {
+      this.inFlight.delete(descriptor.id);
+    });
+    this.inFlight.set(descriptor.id, { descriptor, observed });
+    return promise;
+  }
+  /** Descriptors of currently incomplete owned work. */
+  pending() {
+    return [...this.inFlight.values()].map((entry) => entry.descriptor);
+  }
+  /** Every owned-work failure observed so far (accumulates across drains). */
+  errors() {
+    return [...this.failures];
+  }
+  /**
+   * Fixed-point drain: await all pending owned work, run the adapter flush
+   * hooks, repeat until one full pass observes no pending work and causes
+   * no new registrations. Concurrent drains queue — each caller gets its
+   * own complete pass over whatever work exists when its turn arrives.
+   *
+   * Rejects with `FrontendWorkError` naming the owners when owned work
+   * failed since the previous drain, or when the pass bound is exceeded
+   * (repeating owned work), listing pending and repeating labels.
+   */
+  drain(flushHooks = []) {
+    const run = this.drainChain.then(() => this.drainOnce(flushHooks));
+    this.drainChain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  async drainOnce(flushHooks) {
+    const seenPerLabel = /* @__PURE__ */ new Map();
+    for (let pass = 1; pass <= MAX_DRAIN_PASSES; pass++) {
+      const registrationsBefore = this.registrations;
+      const snapshot = [...this.inFlight.values()];
+      for (const { descriptor } of snapshot) {
+        seenPerLabel.set(descriptor.label, (seenPerLabel.get(descriptor.label) ?? 0) + 1);
+      }
+      await Promise.all(snapshot.map((entry) => entry.observed));
+      for (const hook of flushHooks) {
+        await hook();
+      }
+      await Promise.resolve();
+      await Promise.resolve();
+      const stable = this.inFlight.size === 0 && this.registrations === registrationsBefore;
+      if (stable) {
+        this.throwNewFailures();
+        return;
+      }
+    }
+    const pendingLines = this.pending().map(describe);
+    const repeating = [...seenPerLabel.entries()].filter(([, count]) => count > 3).map(([label, count]) => `${label} (seen in ${count} passes)`);
+    throw new FrontendWorkError(
+      `settle did not converge within ${MAX_DRAIN_PASSES} drain passes.
+` + (pendingLines.length ? `Still pending:
+  ${pendingLines.join("\n  ")}
+` : "") + (repeating.length ? `Repeating owned work:
+  ${repeating.join("\n  ")}
+` : "") + "Owned work keeps creating more owned work \u2014 this names the owners; it is not a timeout.",
+      this.takeNewFailures()
+    );
+  }
+  takeNewFailures() {
+    const fresh = this.failures.slice(this.reportedFailures);
+    this.reportedFailures = this.failures.length;
+    return fresh;
+  }
+  throwNewFailures() {
+    const fresh = this.takeNewFailures();
+    if (!fresh.length) return;
+    const lines = fresh.map(
+      (failure) => `${describe(failure)}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`
+    );
+    throw new FrontendWorkError(
+      `owned frontend work failed:
+  ${lines.join("\n  ")}`,
+      fresh
+    );
+  }
+}
+export {
+  FrontendWorkError,
+  WorkRegistry
+};
+//# sourceMappingURL=work_registry.js.map

package/dist/frontend/work_registry.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/frontend/work_registry.ts"],"sourcesContent":["/**\n * Owned-work registry for the frontend application slice (18A D-FAS-01).\n *\n * `act()` and `settle()` drain framework-owned finite work registered here\n * through production seams (transport invokes, event deliveries, navigation\n * transitions, tracked lifecycle tasks). The registry never patches global\n * async primitives and never guesses at event-loop emptiness: work exists\n * only because an owner registered it, and a drain is a fixed point —\n * repeated passes until one complete pass creates no new owned work.\n *\n * Floating promises and bare timers are explicitly outside the guarantee;\n * they are product lifecycle bugs, not framework blind spots to paper over.\n */\n\nexport type WorkKind =\n  | 'invoke'\n  | 'event-delivery'\n  | 'navigation'\n  | 'initialize'\n  | 'tracked'\n  | (string & {});\n\nexport interface WorkOptions {\n  /** Human-readable diagnostic label, e.g. `invoke messages.send`. */\n  label: string;\n  kind?: WorkKind;\n  /** Owning lifecycle identity, e.g. `page main.chat_dom` or `application`. */\n  owner?: string;\n}\n\nexport interface WorkDescriptor {\n  readonly id: number;\n  readonly label: string;\n  readonly kind: WorkKind;\n  readonly owner: string;\n}\n\nexport interface WorkFailure extends WorkDescriptor {\n  readonly error: unknown;\n}\n\n/** Safety bound on drain passes — a diagnostic limit, not the readiness mechanism. */\nconst MAX_DRAIN_PASSES = 100;\n\nexport class FrontendWorkError extends Error {\n  constructor(message: string, readonly failures: readonly WorkFailure[] = []) {\n    super(message);\n    this.name = 'FrontendWorkError';\n  }\n}\n\nfunction describe(work: WorkDescriptor): string {\n  return `[${work.kind}] ${work.label} (owner: ${work.owner})`;\n}\n\nexport class WorkRegistry {\n  private nextId = 1;\n  /** Total registrations ever — the fixed-point signal for draining. */\n  private registrations = 0;\n  private readonly inFlight = new Map<number, { descriptor: WorkDescriptor; observed: Promise<void> }>();\n  private readonly failures: WorkFailure[] = [];\n  /** How many failures a completed drain has already reported. */\n  private reportedFailures = 0;\n  private drainChain: Promise<void> = Promise.resolve();\n\n  /**\n   * Register finite owned work. Returns a promise with the work's own\n   * settlement semantics — callers may await it directly; the registry\n   * additionally observes completion (success or failure) for draining.\n   */\n  track<T>(work: Promise<T> | (() => Promise<T>), options: WorkOptions): Promise<T> {\n    const descriptor: WorkDescriptor = {\n      id: this.nextId++,\n      label: options.label,\n      kind: options.kind ?? 'tracked',\n      owner: options.owner ?? 'application',\n    };\n\n    this.registrations += 1;\n    const promise = typeof work === 'function' ? work() : work;\n\n    // Observe settlement without altering the caller's promise semantics.\n    const observed = promise.then(\n      () => undefined,\n      (error) => {\n        this.failures.push({ ...descriptor, error });\n      },\n    ).finally(() => {\n      this.inFlight.delete(descriptor.id);\n    });\n\n    this.inFlight.set(descriptor.id, { descriptor, observed });\n    return promise;\n  }\n\n  /** Descriptors of currently incomplete owned work. */\n  pending(): WorkDescriptor[] {\n    return [...this.inFlight.values()].map((entry) => entry.descriptor);\n  }\n\n  /** Every owned-work failure observed so far (accumulates across drains). */\n  errors(): readonly WorkFailure[] {\n    return [...this.failures];\n  }\n\n  /**\n   * Fixed-point drain: await all pending owned work, run the adapter flush\n   * hooks, repeat until one full pass observes no pending work and causes\n   * no new registrations. Concurrent drains queue — each caller gets its\n   * own complete pass over whatever work exists when its turn arrives.\n   *\n   * Rejects with `FrontendWorkError` naming the owners when owned work\n   * failed since the previous drain, or when the pass bound is exceeded\n   * (repeating owned work), listing pending and repeating labels.\n   */\n  drain(flushHooks: ReadonlyArray<() => void | Promise<void>> = []): Promise<void> {\n    const run = this.drainChain.then(() => this.drainOnce(flushHooks));\n    // Keep the chain alive regardless of this drain's outcome.\n    this.drainChain = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    return run;\n  }\n\n  private async drainOnce(flushHooks: ReadonlyArray<() => void | Promise<void>>): Promise<void> {\n    const seenPerLabel = new Map<string, number>();\n\n    for (let pass = 1; pass <= MAX_DRAIN_PASSES; pass++) {\n      const registrationsBefore = this.registrations;\n      const snapshot = [...this.inFlight.values()];\n\n      for (const { descriptor } of snapshot) {\n        seenPerLabel.set(descriptor.label, (seenPerLabel.get(descriptor.label) ?? 0) + 1);\n      }\n\n      // Observed promises never reject (failures are recorded by track());\n      // awaiting them cannot abort the pass mid-way.\n      await Promise.all(snapshot.map((entry) => entry.observed));\n\n      for (const hook of flushHooks) {\n        await hook();\n      }\n\n      // Give completion continuations a microtask to register follow-on\n      // owned work before the fixed point is tested.\n      await Promise.resolve();\n      await Promise.resolve();\n\n      const stable = this.inFlight.size === 0 && this.registrations === registrationsBefore;\n      if (stable) {\n        this.throwNewFailures();\n        return;\n      }\n    }\n\n    const pendingLines = this.pending().map(describe);\n    const repeating = [...seenPerLabel.entries()]\n      .filter(([, count]) => count > 3)\n      .map(([label, count]) => `${label} (seen in ${count} passes)`);\n\n    throw new FrontendWorkError(\n      `settle did not converge within ${MAX_DRAIN_PASSES} drain passes.\\n` +\n      (pendingLines.length ? `Still pending:\\n  ${pendingLines.join('\\n  ')}\\n` : '') +\n      (repeating.length ? `Repeating owned work:\\n  ${repeating.join('\\n  ')}\\n` : '') +\n      'Owned work keeps creating more owned work — this names the owners; it is not a timeout.',\n      this.takeNewFailures(),\n    );\n  }\n\n  private takeNewFailures(): WorkFailure[] {\n    const fresh = this.failures.slice(this.reportedFailures);\n    this.reportedFailures = this.failures.length;\n    return fresh;\n  }\n\n  private throwNewFailures(): void {\n    const fresh = this.takeNewFailures();\n    if (!fresh.length) return;\n    const lines = fresh.map(\n      (failure) =>\n        `${describe(failure)}: ${failure.error instanceof Error ? failure.error.message : String(failure.error)}`,\n    );\n    throw new FrontendWorkError(\n      `owned frontend work failed:\\n  ${lines.join('\\n  ')}`,\n      fresh,\n    );\n  }\n}\n"],"mappings":"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","names":[]}