super-dsh 0.1.5 → 0.1.6

package/superd-hub/dist/client-shim.js

@@ -0,0 +1,251 @@
+/**
+ * Client mount shim (AW-B DL8).
+ *
+ * ONE head script installs every client-side break point:
+ *   - `__DSH_TRANSPORT__.fetch`  → the Connection RPC fetch (URL object input)
+ *   - `WebSocket` / `EventSource` / `XMLHttpRequest` constructors → path rewrite
+ *   - `__DSH_FILE_UPLOAD__`      → uploads bypass the blob worker + its XHR
+ *   - Storage.prototype get/set/remove → per-world key namespace
+ *   - `globalThis.fetch`         → global-fetch calls asking for ctx0-root `/api`
+ *     URLs (2026-09-17 H1: upstream session-log-export resolves the GLOBAL
+ *     fetch at call time; narrow `/api`-only rule, query + hash preserved)
+ *   - `HTMLAnchorElement.prototype.click` → download-anchor clicks re-rooted
+ *     (2026-09-18 H1 r2: upstream hands the UNREWRITTEN absolute URL to a
+ *     DETACHED `<a download>` and clicks it — detached clicks never reach
+ *     document, so a document-level listener cannot see them, and a blanket
+ *     rewrite breaks the runtime selector's root-absolute anchors
+ *     (live-found 2026-09-18). Narrow rule: ONLY anchors carrying a
+ *     `download` attribute AND a same-authority root-absolute `/api` href.)
+ * The rule is namespace-agnostic: a same-origin root-absolute URL is re-rooted
+ * under the mount (`/omp`), nothing else is touched. That covers every prefix
+ * a plugin may declare later — no list to keep in sync.
+ */
+/** Escape a label for embedding in generated JavaScript. */
+function js(value) {
+    return JSON.stringify(value);
+}
+/**
+ * Render the shim as a classic script (parser-blocking head injection).
+ * @param labelPath - mount root, e.g. `/omp`.
+ * @returns JavaScript source.
+ */
+export function renderClientShim(labelPath) {
+    if (typeof labelPath !== 'string' || !labelPath.startsWith('/') || labelPath === '/' || labelPath.endsWith('/')) {
+        throw new Error(`client-shim: labelPath must start with "/" and carry no trailing slash, got ${JSON.stringify(labelPath)}`);
+    }
+    const prefix = `${labelPath}/`;
+    return `(() => {
+  const LABEL = ${js(labelPath)}
+  const PREFIX = ${js(prefix)}
+
+  /** Re-root one pathname when it is same-origin root-absolute and not mounted yet. */
+  const rewritePath = (path) => {
+    if (typeof path !== 'string' || !path.startsWith('/') || path.startsWith('//')) return path
+    if (path === LABEL || path.startsWith(PREFIX)) return path
+    return PREFIX + path.slice(1)
+  }
+
+  const origin = () => {
+    const loc = globalThis.location
+    if (loc !== undefined && typeof loc.origin === 'string' && loc.origin !== 'null') return loc.origin
+    return 'http://dsh.internal'
+  }
+
+  /** Same authority as the page (scheme-agnostic: ws/wss/http/https share host). */
+  const sameAuthority = (url) => {
+    try {
+      return url.host === new URL(origin()).host
+    } catch {
+      return false
+    }
+  }
+
+  /** Rewrite a full URL (absolute or relative); other authorities are untouched. */
+  const rewriteUrl = (input) => {
+    if (typeof input === 'string') {
+      if (input.startsWith('/')) return rewritePath(input)
+      try {
+        const url = new URL(input, origin())
+        if (!sameAuthority(url)) return input
+        const next = rewritePath(url.pathname)
+        if (next === url.pathname) return input
+        url.pathname = next
+        return url.href
+      } catch {
+        return input
+      }
+    }
+    if (input !== null && typeof input === 'object' && typeof input.href === 'string') {
+      try {
+        const url = new URL(input.href)
+        if (!sameAuthority(url)) return input
+        const next = rewritePath(url.pathname)
+        if (next === url.pathname) return input
+        url.pathname = next
+        return url
+      } catch {
+        return input
+      }
+    }
+    return input
+  }
+
+  const nativeFetch = globalThis.fetch
+  const shimFetch = (input, init) => {
+    if (typeof nativeFetch !== 'function') throw new Error('client-shim: fetch is unavailable')
+    if (typeof Request === 'function' && input instanceof Request) {
+      const url = rewriteUrl(input.url)
+      return nativeFetch(url === input.url ? input : new Request(url, input), init)
+    }
+    return nativeFetch(rewriteUrl(input), init)
+  }
+
+  const transport = (globalThis.__DSH_TRANSPORT__ = globalThis.__DSH_TRANSPORT__ || {})
+  transport.rewrite = rewritePath
+  transport.fetch = shimFetch
+
+  // Construct through a Proxy, never a hand-rolled wrapper function: the
+  // upstream client compares socket.readyState against WebSocket.OPEN, so the
+  // native statics (CONNECTING/OPEN/CLOSING/CLOSED), prototype and instanceof
+  // must survive the interception.
+  const NativeWebSocket = globalThis.WebSocket
+  if (typeof NativeWebSocket === 'function') {
+    globalThis.WebSocket = new Proxy(NativeWebSocket, {
+      construct: (Target, args) => new Target(rewriteUrl(args[0]), ...args.slice(1)),
+    })
+  }
+
+  const NativeEventSource = globalThis.EventSource
+
+  if (typeof NativeEventSource === 'function') {
+    globalThis.EventSource = new Proxy(NativeEventSource, {
+      construct: (Target, args) => new Target(rewriteUrl(args[0]), ...args.slice(1)),
+    })
+  }
+
+  const NativeXhr = globalThis.XMLHttpRequest
+  if (typeof NativeXhr === 'function' && NativeXhr.prototype !== undefined && typeof NativeXhr.prototype.open === 'function') {
+    const nativeOpen = NativeXhr.prototype.open
+    NativeXhr.prototype.open = function (method, url, ...rest) {
+      return nativeOpen.call(this, method, rewriteUrl(url), ...rest)
+    }
+  }
+
+  // Read by the file-upload service at construction time: present ⇒ the page
+  // fetch carries uploads (no blob worker, and therefore no worker-scope XHR).
+  globalThis.__DSH_FILE_UPLOAD__ = { fetch: shimFetch }
+
+  // Narrow '/api' re-root helpers (2026-09-17 session-log 404, H1): upstream
+  // client code (session-log-export) resolves the GLOBAL fetch at call time
+  // and hands absolute ctx0-root URLs both to fetch and to a DETACHED
+  // download anchor — neither is visible to the transport faces above.
+  // Narrow rule: only root-absolute '/api' paths move under the mount;
+  // relative, same-mount, and foreign URLs pass through untouched. Query and
+  // hash survive because only the pathname is rewritten. The mount root comes
+  // from this shim's argument, never from location.pathname. NOTE: the '/api'
+  // literals below stay SINGLE-quoted on purpose — index-pass.ts rewrites
+  // every DOUBLE-quoted root-absolute string in the served HTML, and a
+  // doubled literal would silently disable these rewrites (regression tests
+  // survive the mount HTML pass).
+  const rewriteApiPath = (path) => {
+    if (path === '/api' || path.startsWith('/api/')) return PREFIX + path.slice(1)
+    return path
+  }
+  const rewriteApiUrl = (input) => {
+    if (typeof input === 'string') {
+      if (input.startsWith('/') && !input.startsWith('//')) return rewriteApiPath(input)
+      try {
+        const url = new URL(input, origin())
+        if (!sameAuthority(url)) return input
+        const next = rewriteApiPath(url.pathname)
+        if (next === url.pathname) return input
+        url.pathname = next
+        return url.href
+      } catch {
+        return input
+      }
+    }
+    if (input !== null && typeof input === 'object' && typeof input.href === 'string') {
+      try {
+        const url = new URL(input.href)
+        if (!sameAuthority(url)) return input
+        const next = rewriteApiPath(url.pathname)
+        if (next === url.pathname) return input
+        url.pathname = next
+        return url
+      } catch {
+        return input
+      }
+    }
+    return input
+  }
+  if (typeof nativeFetch === 'function' && globalThis.__DSH_FETCH_REWRITE__ !== true) {
+    globalThis.__DSH_FETCH_REWRITE__ = true
+    globalThis.fetch = (input, init) => nativeFetch(rewriteApiUrl(input), init)
+  }
+
+  // Download anchors (2026-09-18 H1 r2): upstream session-log-export hands
+  // the UNREWRITTEN absolute URL to a DETACHED '<a download>' element and
+  // calls .click() — detached clicks never propagate to document, so the r1
+  // document-level capture listener could not see them, while its BLANKET
+  // rewrite re-rooted the runtime selector's root-absolute anchors and broke
+  // cross-world navigation (live-found 2026-09-18). Narrow seam: wrap
+  // HTMLAnchorElement.prototype.click itself and rewrite ONLY anchors that
+  // carry a 'download' attribute AND a same-authority root-absolute '/api'
+  // href. Everything else — the runtime selector's links included — passes
+  // through untouched.
+  if (globalThis.HTMLAnchorElement !== undefined
+    && globalThis.HTMLAnchorElement.prototype !== undefined
+    && typeof globalThis.HTMLAnchorElement.prototype.click === 'function'
+    && globalThis.__DSH_ANCHOR_CLICK_REWRITE__ !== true) {
+    globalThis.__DSH_ANCHOR_CLICK_REWRITE__ = true
+    const nativeAnchorClick = globalThis.HTMLAnchorElement.prototype.click
+    globalThis.HTMLAnchorElement.prototype.click = function (...args) {
+      try {
+        if (this.hasAttribute('download')) {
+          const current = this.getAttribute('href')
+          if (typeof current === 'string' && current !== '') {
+            const next = rewriteApiUrl(current)
+            if (typeof next === 'string' && next !== current) this.setAttribute('href', next)
+          }
+        }
+      } catch {
+        /* best-effort: never break the click itself */
+      }
+      return nativeAnchorClick.apply(this, args)
+    }
+  }
+
+  // Storage namespace (2026-09-16 storage findings P1): all worlds share one
+
+  // origin, so bare localStorage keys would overwrite each other across
+  // mounts. Prefix every key with the label; root '/' never injects this
+  // shim and keeps bare keys. Never throws: attachPersistence only
+  // console-errors on failure, so a throwing shim would silently disable
+  // persistence.
+  try {
+  const StorageProto = globalThis.Storage && globalThis.Storage.prototype
+  if (globalThis.localStorage !== undefined && StorageProto !== undefined
+    && !globalThis.__DSH_STORAGE_NS__
+    && typeof StorageProto.getItem === 'function'
+    && typeof StorageProto.setItem === 'function'
+    && typeof StorageProto.removeItem === 'function') {
+    // NS derives from PREFIX, never LABEL: the mount HTML pass (index-pass)
+    // rewrites every quoted root-absolute string EXCEPT "<label>/"-prefixed
+    // ones, so the shim's LABEL="/omp" literal doubles to "/omp/omp" while
+    // PREFIX="/omp/" is immune (live-found 2026-09-17, acceptance A2/A5).
+    // The NS-from-PREFIX coupling is DELIBERATE: index-pass.ts rewrites double-quoted root-absolute strings except "<label>/"-prefixed ones, so LABEL="/omp" doubles while PREFIX="/omp/" survives; do NOT derive NS from LABEL.
+    const NS = PREFIX.slice(1, -1) + ':'
+    globalThis.__DSH_STORAGE_NS__ = NS
+    const nativeGetItem = StorageProto.getItem
+    const nativeSetItem = StorageProto.setItem
+    const nativeRemoveItem = StorageProto.removeItem
+    StorageProto.getItem = function (name) { return nativeGetItem.call(this, NS + name) }
+    StorageProto.setItem = function (name, value) { return nativeSetItem.call(this, NS + name, value) }
+    StorageProto.removeItem = function (name) { return nativeRemoveItem.call(this, NS + name) }
+  }
+  } catch {
+    /* storage namespace is best-effort: never break the shim */
+  }
+})()`;
+}

package/superd-hub/dist/fusion-transport.d.ts

@@ -48,9 +48,9 @@
  * so cordis's FIFO effect order guarantees trust pushes first and fusion
  * pushes last — the non-merging `if(!window.__DSH_TRANSPORT__)` verdict in the
  * trust script is always evaluated before anything could own that global.
- * Flag gate (minimal, Task 5 formalizes the config face): row config
- * `enabled`, defaulting OFF from the `SUPERD_UI_FUSION` env — while the flag
- * is off the component stays dormant and injects no row at all.
+ * Row gate: the row config `enabled`, ON by default — the composite patch
+ * composing this row is the switch. `enabled: false` (or `disabled: true`)
+ * leaves the component dormant: no listener, no script, no flag global.
  *
  * @module @pgmi-builds/superd-hub/fusion-transport
  */
@@ -64,27 +64,25 @@ import z from '@deepseek-ai/schemastery';
  * @returns JavaScript source.
  */
 export declare function renderFusionTransport(): string;
-/** The env name the minimal Task-3 gate reads; Task 5 builds the config face on it. */
-export declare const FUSION_FLAG_ENV = "SUPERD_UI_FUSION";
 /**
- * The page global the ctx0 index carries when the gate is on: the client
+ * The page global the ctx0 index carries when this row is on: the client
  * half's fusion-branch discriminator (the Hub UI switch surfaces read its
  * presence to intercept agent clicks into the switch orchestration instead
  * of letting the hyperlinks navigate — the sole switch surface since the T-B
  * RuntimeSeat retirement; world pages never carry it, so they keep the real
- * navigation half — spec §5 双半边). Baked by the SAME gated listener as the
+ * navigation half — spec §5 双半边). Baked by the SAME listener as the
  * transport script, so the two halves can never disagree.
  */
 export declare const FUSION_FLAG_GLOBAL = "__SUPERD_UI_FUSION__";
 /**
- * The flag's SEMANTICS after the path-separation Part 2 closeout (T-C/T-D
+ * The row's SEMANTICS after the path-separation Part 2 closeout (T-C/T-D
  * landed; this block is the T-E closeout record) — native-ui-only, there is
  * no fallback route anywhere:
  *
  *   - ON: the ctx0 page fuses. The transport script arms the in-place switch
  *     and `/hub` is the sole surface for every runtime. The per-label URL
  *     family (`/<label>/` ctx0 pages, T-C) and the world web UIs (T-D) are
- *     RETIRED from the product, not gated by this flag — there is nothing
+ *     RETIRED from the product, not gated by this row — there is nothing
  *     navigational behind them to fall back to.
  *   - OFF: NO foreign entry exists AT ALL. The served product is the bare
  *     native UI plus the Hub panel as an information surface: the roster
@@ -94,20 +92,24 @@ export declare const FUSION_FLAG_GLOBAL = "__SUPERD_UI_FUSION__";
  *     has no /<label>/ page to reach and the Hub UI ships no hrefs to reach
  *     one with.
  *
- * The shipped default stays OFF (truthy env opt-in). Moving the default ON is
- * the user's 放行 (acceptance/release) round — a two-gate decision per repo
- * §〇.1, never a code-side choice.
- *
- * Derivation: truthy spellings only (`1` / `true` / `yes` / `on`,
- * case-insensitive, trimmed). Anything else — unset included — is OFF.
+ * The switch is ROW COMPOSITION, exactly like every other row here: the
+ * composite patch composes this row, so the fused surface is what the product
+ * ships. A deployment that does not want it turns the row off where cordis
+ * already owns that decision — a profile layer restating the row with
+ * `config: { enabled: false }` (整行重述: same id, same name) or
+ * `disabled: true`, or dropping `super-dsh/fusion-transport` from the
+ * composition entirely. There is deliberately no env-derived default: a
+ * release gate living in an environment variable is deployment state that no
+ * patch layer can see, read, or diff.
  */
-export declare function deriveFusionFlag(env: string | undefined): boolean;
-/** Row config schema face. */
 export interface FusionConfig {
-    /** Master gate: inject the transport script on ctx0's index. Default off. */
+    /**
+     * Whether this row injects the transport script and the flag global on
+     * ctx0's index. Default on — the row being composed is the switch.
+     */
     enabled?: boolean;
 }
-/** Row config (schema-level default derives from the {@link FUSION_FLAG_ENV} env). */
+/** Row config: ON unless a patch layer restates the row with `enabled: false`. */
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     enabled: z<boolean, boolean, "defined">;
 }>>, Schemastery.ObjectT<NoInfer<{
@@ -129,10 +131,10 @@ export declare const inject: string[];
  * the {@link FUSION_FLAG_GLOBAL} baked global row (Task 4): one gate, both
  * halves.
  *
- * Flag off → the component registers nothing: no listener, no row, no script,
+ * Off → the component registers nothing: no listener, no row, no script,
  * no flag global.
  * @param ctx - host plugin context.
- * @param config - the row config.
+ * @param config - the row config (`enabled`, default on).
  */
 export declare function apply(ctx: Context, config: FusionConfig | undefined): void;
 declare const _default: {

package/superd-hub/dist/fusion-transport.js

@@ -48,9 +48,9 @@
  * so cordis's FIFO effect order guarantees trust pushes first and fusion
  * pushes last — the non-merging `if(!window.__DSH_TRANSPORT__)` verdict in the
  * trust script is always evaluated before anything could own that global.
- * Flag gate (minimal, Task 5 formalizes the config face): row config
- * `enabled`, defaulting OFF from the `SUPERD_UI_FUSION` env — while the flag
- * is off the component stays dormant and injects no row at all.
+ * Row gate: the row config `enabled`, ON by default — the composite patch
+ * composing this row is the switch. `enabled: false` (or `disabled: true`)
+ * leaves the component dormant: no listener, no script, no flag global.
  *
  * @module @pgmi-builds/superd-hub/fusion-transport
  */
@@ -319,49 +319,19 @@ try {
 } catch { /* the whole install is best-effort: a partial page is still a page */ }
 })()`;
 }
-/** The env name the minimal Task-3 gate reads; Task 5 builds the config face on it. */
-export const FUSION_FLAG_ENV = 'SUPERD_UI_FUSION';
 /**
- * The page global the ctx0 index carries when the gate is on: the client
+ * The page global the ctx0 index carries when this row is on: the client
  * half's fusion-branch discriminator (the Hub UI switch surfaces read its
  * presence to intercept agent clicks into the switch orchestration instead
  * of letting the hyperlinks navigate — the sole switch surface since the T-B
  * RuntimeSeat retirement; world pages never carry it, so they keep the real
- * navigation half — spec §5 双半边). Baked by the SAME gated listener as the
+ * navigation half — spec §5 双半边). Baked by the SAME listener as the
  * transport script, so the two halves can never disagree.
  */
 export const FUSION_FLAG_GLOBAL = '__SUPERD_UI_FUSION__';
-/**
- * The flag's SEMANTICS after the path-separation Part 2 closeout (T-C/T-D
- * landed; this block is the T-E closeout record) — native-ui-only, there is
- * no fallback route anywhere:
- *
- *   - ON: the ctx0 page fuses. The transport script arms the in-place switch
- *     and `/hub` is the sole surface for every runtime. The per-label URL
- *     family (`/<label>/` ctx0 pages, T-C) and the world web UIs (T-D) are
- *     RETIRED from the product, not gated by this flag — there is nothing
- *     navigational behind them to fall back to.
- *   - OFF: NO foreign entry exists AT ALL. The served product is the bare
- *     native UI plus the Hub panel as an information surface: the roster
- *     still lists the runtimes (the control plane is not gated), but the
- *     switch affordances render inert with the degradation hint
- *     (`switchAffordance` in switch-core) instead of dead controls — a row
- *     has no /<label>/ page to reach and the Hub UI ships no hrefs to reach
- *     one with.
- *
- * The shipped default stays OFF (truthy env opt-in). Moving the default ON is
- * the user's 放行 (acceptance/release) round — a two-gate decision per repo
- * §〇.1, never a code-side choice.
- *
- * Derivation: truthy spellings only (`1` / `true` / `yes` / `on`,
- * case-insensitive, trimmed). Anything else — unset included — is OFF.
- */
-export function deriveFusionFlag(env) {
-    return ['1', 'true', 'yes', 'on'].includes((env ?? '').trim().toLowerCase());
-}
-/** Row config (schema-level default derives from the {@link FUSION_FLAG_ENV} env). */
+/** Row config: ON unless a patch layer restates the row with `enabled: false`. */
 export const Config = z.object({
-    enabled: z.boolean().default(deriveFusionFlag(process.env[FUSION_FLAG_ENV])),
+    enabled: z.boolean().default(true),
 });
 /** Cordis plugin name. */
 export const name = 'superd-fusion-transport';
@@ -379,13 +349,15 @@ export const inject = [];
  * the {@link FUSION_FLAG_GLOBAL} baked global row (Task 4): one gate, both
  * halves.
  *
- * Flag off → the component registers nothing: no listener, no row, no script,
+ * Off → the component registers nothing: no listener, no row, no script,
  * no flag global.
  * @param ctx - host plugin context.
- * @param config - the row config.
+ * @param config - the row config (`enabled`, default on).
  */
 export function apply(ctx, config) {
-    if (config?.enabled !== true)
+    // Composed row = on. Only an explicit `enabled: false` turns it off, so a
+    // composition that omits the config key cannot silently disable the surface.
+    if (config?.enabled === false)
         return;
     ctx.inject(['webServer'], () => {
         ctx.on('webserver/index-inject', (table) => {

package/superd-hub/dist/index-pass.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Mount HTML pass (AW-B DL1/DL8 server half).
+ *
+ * The world dist is built with RELATIVE asset URLs (`./assets/...`), so a
+ * `<base>` pointing at the mount makes every relative reference resolve under
+ * `/<label>/`. Root-absolute strings (the boot graph's `/plugins/...` URLs,
+ * injected script sources, `href="/"`-style anchors) do NOT follow `<base>`,
+ * so they are re-rooted explicitly — one generic rule, no namespace list.
+ */
+/**
+ * Rewrite a world index for serving under `<labelPath>/`.
+ *
+ * - pins `<base>` at the mount (inserting one after `<head>` when absent);
+ * - prefixes every double-quoted root-absolute string that is not already
+ *   mounted and not protocol-relative (`//host/...`);
+ * - idempotent (a second pass changes nothing).
+ *
+ * @param html - the world's index.html (already rendered with its own rows).
+ * @param labelPath - mount root, e.g. `/omp`.
+ * @returns the mount-ready HTML.
+ */
+export declare function rewriteIndexHtml(html: string, labelPath: string): string;

package/superd-hub/dist/index-pass.js

@@ -0,0 +1,47 @@
+/**
+ * Mount HTML pass (AW-B DL1/DL8 server half).
+ *
+ * The world dist is built with RELATIVE asset URLs (`./assets/...`), so a
+ * `<base>` pointing at the mount makes every relative reference resolve under
+ * `/<label>/`. Root-absolute strings (the boot graph's `/plugins/...` URLs,
+ * injected script sources, `href="/"`-style anchors) do NOT follow `<base>`,
+ * so they are re-rooted explicitly — one generic rule, no namespace list.
+ */
+/** Root of the mount including the trailing slash (`/omp` → `/omp/`). */
+function mountPrefix(labelPath) {
+    return labelPath.endsWith('/') ? labelPath : `${labelPath}/`;
+}
+/**
+ * Rewrite a world index for serving under `<labelPath>/`.
+ *
+ * - pins `<base>` at the mount (inserting one after `<head>` when absent);
+ * - prefixes every double-quoted root-absolute string that is not already
+ *   mounted and not protocol-relative (`//host/...`);
+ * - idempotent (a second pass changes nothing).
+ *
+ * @param html - the world's index.html (already rendered with its own rows).
+ * @param labelPath - mount root, e.g. `/omp`.
+ * @returns the mount-ready HTML.
+ */
+export function rewriteIndexHtml(html, labelPath) {
+    if (typeof labelPath !== 'string' || !labelPath.startsWith('/') || labelPath === '/' || labelPath.endsWith('/')) {
+        throw new Error(`index-pass: labelPath must start with "/" and carry no trailing slash, got ${JSON.stringify(labelPath)}`);
+    }
+    const prefix = mountPrefix(labelPath);
+    let out = html;
+    if (/<base\b[^>]*>/i.test(out)) {
+        out = out.replace(/<base\b[^>]*>/i, `<base href="${prefix}">`);
+    }
+    else if (/<head(?:\s[^>]*)?>/i.test(out)) {
+        out = out.replace(/<head(?:\s[^>]*)?>/i, open => `${open}<base href="${prefix}">`);
+    }
+    out = out.replace(/"(\/[^"]*)"/g, (whole, path) => {
+        if (path.startsWith('//'))
+            return whole;
+        // Load-bearing contract: client-shim.ts derives its storage NS from the surviving "<label>/" literal (regression test: the storage NS survives the mount HTML pass). Changing this exclusion breaks that coupling.
+        if (path.startsWith(prefix))
+            return whole;
+        return `"${prefix}${path.slice(1)}"`;
+    });
+    return out;
+}

package/superd-hub/dist/index.d.ts

@@ -16,7 +16,7 @@
  */
 export { handleAgentRuntime, registerSelectorRpc, AGENT_RUNTIME_RPC_PATH, registryTargets, type RuntimeTargetSource } from './rpc.js';
 export { registerForeignTarget, unregisterForeignTarget, getTarget, listRuntimeKeys, type ForeignTarget, type GatewayFace } from './targets.js';
-export { registerAgent, unregisterAgent, setReady, listAgents, onRosterChanged, type RosterEntry } from './roster.js';
+export { registerAgent, unregisterAgent, setReady, setFailed, listAgents, onRosterChanged, type RosterEntry } from './roster.js';
 export { spawnWorld, type SpawnWorldOptions } from './spawn-world.js';
 export { provisionWorldProfile, resolveInstallAnchor, type ProvisionWorldOptions } from './world-provision.js';
 export { WorldWebServer, stripLabelFromUrl, type WorldWebRoute, type WorldWebUpgradeRoute, type RealWebServerFace } from './world-web-server.js';
@@ -24,12 +24,12 @@ export { parseClientRequest, serverResponse, serverError, serverResult, wireErro
 export { WorldMuxServer, parseClientMessage, defaultFailure, type MuxOpen, type MuxFailure, type WorldMuxOptions } from './world-mux.js';
 export { forwardApiCall, forwardWorldFetch, worldMuxOf, writeJson, type CarrierGatewayFace, type ForwardOptions } from './carrier.js';
 export { registerHubRoute, HUB_MOUNT_PATH, HUB_MUX_PATH, type HubRouteOptions } from './hub-route.js';
-export { renderFusionTransport, deriveFusionFlag, FUSION_FLAG_ENV, FUSION_FLAG_GLOBAL, type FusionConfig } from './fusion-transport.js';
+export { renderFusionTransport, FUSION_FLAG_GLOBAL, type FusionConfig } from './fusion-transport.js';
 export { createSwitchController, parseLandingTarget, namespacedKey, storageNamespace, seatClickDecision, NATIVE_AGENT, SESSIONS_CURRENT_KEY, SWITCH_FALLBACK_MS, type SwitchHost, type SwitchController, type SwitchOptions, type SeatClickInput, type SeatClickDecision } from './switch-core.js';
 export { agentLinks, agentRosterRow, AGENT_ROSTER_GLOBAL, type AgentLink } from './agent-roster.js';
 export { createOwnershipIndex, type OwnershipIndex, type OwnershipRow } from './ownership.js';
 export { registerHostMount, takeHostMount, listHostMounts, noteWorldServer, worldServerOf, type HostMount } from './world-host.js';
-export { worldMountPatches, superdTrustedHosts, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, type WorldPatchLayer, } from './world-mount.js';
+export { worldMountPatches, superdTrustedHosts, WORLD_WAVE1_DISABLED_ROWS, WORLD_WAVE2_DISABLED_ROWS, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, type WorldPatchLayer, } from './world-mount.js';
 export { buildTrustScript, deriveDefaultPageAuthorities, type BootScriptRow, type TrustConfig, } from './web-trust.js';
 export { withSystemHead, type HeadAwareSessionFace, type HeadPlaceholder, type WithSystemHead } from './system-head.js';
 export { default as worldApply, name as worldPluginName, type Config as WorldEntryConfig } from './world-entry.js';

package/superd-hub/dist/index.js

@@ -16,7 +16,7 @@
  */
 export { handleAgentRuntime, registerSelectorRpc, AGENT_RUNTIME_RPC_PATH, registryTargets } from './rpc.js';
 export { registerForeignTarget, unregisterForeignTarget, getTarget, listRuntimeKeys } from './targets.js';
-export { registerAgent, unregisterAgent, setReady, listAgents, onRosterChanged } from './roster.js';
+export { registerAgent, unregisterAgent, setReady, setFailed, listAgents, onRosterChanged } from './roster.js';
 export { spawnWorld } from './spawn-world.js';
 export { provisionWorldProfile, resolveInstallAnchor } from './world-provision.js';
 export { WorldWebServer, stripLabelFromUrl } from './world-web-server.js';
@@ -24,12 +24,12 @@ export { parseClientRequest, serverResponse, serverError, serverResult, wireErro
 export { WorldMuxServer, parseClientMessage, defaultFailure } from './world-mux.js';
 export { forwardApiCall, forwardWorldFetch, worldMuxOf, writeJson } from './carrier.js';
 export { registerHubRoute, HUB_MOUNT_PATH, HUB_MUX_PATH } from './hub-route.js';
-export { renderFusionTransport, deriveFusionFlag, FUSION_FLAG_ENV, FUSION_FLAG_GLOBAL } from './fusion-transport.js';
+export { renderFusionTransport, FUSION_FLAG_GLOBAL } from './fusion-transport.js';
 export { createSwitchController, parseLandingTarget, namespacedKey, storageNamespace, seatClickDecision, NATIVE_AGENT, SESSIONS_CURRENT_KEY, SWITCH_FALLBACK_MS } from './switch-core.js';
 export { agentLinks, agentRosterRow, AGENT_ROSTER_GLOBAL } from './agent-roster.js';
 export { createOwnershipIndex } from './ownership.js';
 export { registerHostMount, takeHostMount, listHostMounts, noteWorldServer, worldServerOf } from './world-host.js';
-export { worldMountPatches, superdTrustedHosts, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, } from './world-mount.js';
+export { worldMountPatches, superdTrustedHosts, WORLD_WAVE1_DISABLED_ROWS, WORLD_WAVE2_DISABLED_ROWS, WORLD_MOUNT_PLUGIN, WORLD_MOUNT_ROW_ID, WORLD_HUB_PLUGIN, WORLD_HUB_ROW_ID, } from './world-mount.js';
 export { buildTrustScript, deriveDefaultPageAuthorities, } from './web-trust.js';
 export { withSystemHead } from './system-head.js';
 export { default as worldApply, name as worldPluginName } from './world-entry.js';

package/superd-hub/dist/labels.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Label table (AW-B DL2/DL4): one world ↔ one mount path under the ctx0 origin.
+ *
+ * The addressed world is the request's path (`/<label>/...`), so the label is
+ * the ONLY routing key. Reserving it must be atomic against the real
+ * webServer's duplicate-registration throw — that throw is the only collision
+ * signal the framework offers (the route tables are private and there is no
+ * query API), so it is used here as the probe.
+ *
+ * A collision is a composition-level conflict and must be loud; an optional
+ * alternate root lets a deployment re-home instead of failing to boot.
+ */
+/** One reserved mount path. */
+export interface LabelClaim {
+    /** Runtime key (`omp`, `codex`, …). */
+    readonly key: string;
+    /** Reserved mount root, e.g. `/omp` or `/_agents/omp` (no trailing slash). */
+    readonly path: string;
+    /** Release the claim (idempotent). */
+    release(): void;
+}
+/** How to reserve a path: the injected real-webServer registration. */
+export interface ClaimOptions {
+    /** Attempt a prefix registration; throws when `(kind, path)` is already taken. */
+    register(path: string): () => void;
+    /** Optional root prefix (default: the origin root). */
+    root?: string;
+    /** Candidate roots to try, in order, when the clean path is taken. */
+    alternateRoots?: readonly string[];
+}
+/**
+ * Reserve the mount path for `key`.
+ * @param key - runtime key (one path segment).
+ * @param opts - registration probe plus optional roots.
+ * @returns the live claim.
+ */
+export declare function claimLabel(key: string, opts: ClaimOptions): LabelClaim;
+/** The reserved mount root for a key, or undefined when unclaimed. */
+export declare function labelOf(key: string): string | undefined;
+/** Release a key's claim; unknown keys are a no-op. */
+export declare function releaseLabel(key: string): void;
+/** Claimed keys, registration order. */
+export declare function listLabels(): string[];
+/** Test/introspection helper: is this object a claim? */
+export declare function isLabelClaim(value: unknown): value is LabelClaim;