super-dsh 0.1.9 → 0.1.10-e

package/agent-omp-sdk/dist/knobs.js

@@ -0,0 +1,50 @@
+/**
+ * Env-tunable knobs.
+ *
+ * dsh-shape-session-log retired the union-era supervisor cadence and replay
+ * cache knobs along with the supervisor and the union persistence.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+function parseMs(raw, fallback) {
+    if (raw === undefined || raw.trim() === "")
+        return fallback;
+    const value = Number(raw);
+    return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+/** Bridge-index tick: workspace attach + model-default sync + model refresh. */
+export const STORAGE_RECONCILE_INTERVAL_MS = parseMs(process.env.OMP_STORAGE_RECONCILE_INTERVAL_MS, 30_000);
+/**
+ * Slash-command discovery refresh: the disk scan (omp+claude roots) re-mounts
+ * the host `commands` registrations on this cadence — boot once, then hourly.
+ * Pure disk reads, never a sidecar spawn. `0` disables the refresh.
+ */
+export const OMP_DISCOVERY_REFRESH_INTERVAL_MS = parseMs(process.env.OMP_DISCOVERY_REFRESH_INTERVAL_MS, 3_600_000);
+/**
+ * The OMP home — the SDK runtime app home (`agentDir`): runtime data
+ * (agent.db / models.db / sessions) and config live here. NATIVE by default
+ * (user ruling 2026-09-17, pi precedent):
+ *
+ *     OMP_HOME = $OMP_HOME (tests / adapter-level isolation) ?? ~/.omp
+ *
+ * The installed OMP app keeps its own home; the adapter never redirects it at
+ * spawn and never seeds config into it. `<dshHome>/agents/omp` remains the
+ * world's DSH home (its sessions/storages/settings) — it is NOT the app home
+ * anymore. The old nested derivation (`dshHomePath("agents", "omp", ".omp")`)
+ * and the config copy-in (`ensureOmpAppHome`) are retired with the same
+ * ruling; `OMP_HOME` stays overridable per the 2026-09-15 adapter-level
+ * freedom (optional isolation, never the default).
+ */
+export const OMP_HOME = process.env.OMP_HOME ?? resolveOmpNativeHome();
+/**
+ * The operator's NATIVE OMP home (`~/.omp`): the TUI/CLI installation owning
+ * `agent/config.yml`, `agent/models.yml` and the native session store. Since
+ * the 2026-09-17 native-home ruling this is ALSO the default runtime app home
+ * ({@link OMP_HOME}); the knob stays as a late env override seam (tests may
+ * pin disk-scan roots via `$OMP_NATIVE_HOME` independently of `$OMP_HOME`).
+ */
+export function resolveOmpNativeHome() {
+    return process.env.OMP_NATIVE_HOME ?? join(homedir(), ".omp");
+}
+/** Boot-time snapshot of {@link resolveOmpNativeHome}. */
+export const OMP_NATIVE_HOME = resolveOmpNativeHome();

package/agent-omp-sdk/dist/lazy-rpc.d.ts

@@ -0,0 +1,98 @@
+/**
+ * LazyOmpRpc — the create-time placeholder that makes a freshly created Dash
+ * session cost NOTHING on the backend (the "backend takes zero part in the
+ * UI's draft" contract):
+ *
+ *   - constructing one spawns no OMP child, writes no transcript, no index
+ *     row, and no session events — the session announces blank, exactly like
+ *     the native agent-loop factory's in-process agent;
+ *   - the shared-sidecar session materializes on the FIRST dispatch path
+ *     (`prompt` / `followUp` / `steer` / `ensureStarted`);
+ *   - passive queries (`getState` / `getSubagents` / `getSessionStats` /
+ *     `getSystemPrompt` / `abort` / `sendRaw`) answer synthetically without
+ *     spawning, so idle-exit revalidation, `whenIdle`, and avoidance checks
+ *     can never conjure a child;
+ *   - `close()` on a never-spawned wrapper is a no-op; a close racing an
+ *     in-flight spawn disposes the child the moment it lands.
+ *
+ * A model selection made before the child exists (`setModel` from the pre-turn
+ * sync) is parked and applied right after the spawn, ahead of the prompt.
+ */
+import type { OmpSessionStats, OmpState, RpcEvent } from "./rpc-types.js";
+import { OmpSdkClient, type OmpSdkSidecarPool } from "./sdk-client.js";
+/**
+ * The client surface `OmpAgent` drives. `OmpSdkClient` satisfies this
+ * structurally (plus `ensureStarted`/`spawned`, which are no-ops/trues there);
+ * `LazyOmpRpc` implements it with deferred spawning.
+ */
+export interface OmpAgentRpc {
+    on(listener: (event: RpcEvent) => void): () => void;
+    onTitle(listener: (title: string) => void): () => void;
+    onFailure(listener: (error: Error) => void): () => void;
+    prompt(message: string): Promise<unknown>;
+    followUp(message: string): Promise<unknown>;
+    steer(message: string): Promise<unknown>;
+    compact(instructions?: string): Promise<unknown>;
+    contextUsage(): Promise<{
+        tokens?: number;
+        percent?: number;
+    } | undefined>;
+    abort(): Promise<unknown>;
+    /** Forces the child to exist (first prompt). Never rejects for being live. */
+    ensureStarted(): Promise<void>;
+    /** Whether the child exists — passive paths key off this, never spawn. */
+    readonly spawned: boolean;
+    getState(): Promise<OmpState>;
+    getSubagents(): Promise<unknown[]>;
+    getSessionStats(): Promise<OmpSessionStats>;
+    getSystemPrompt(): Promise<string | undefined>;
+    setModel(provider: string, modelId: string): Promise<unknown>;
+    sendRaw(command: Record<string, unknown>): void;
+    close(): void;
+}
+export declare class LazyOmpRpc implements OmpAgentRpc {
+    #private;
+    /**
+     * @param spawnArgs - the session's argv (`--approval-mode …`, optional
+     *   `--resume …`), or a thunk called AT SPAWN. Use the thunk whenever a
+     *   launch fact can still change between construction and the first prompt —
+     *   the new-chat permission pick does, and so does the lazily fetched SDK
+     *   runtime the spawn depends on.
+     * @param cwd - the session cwd.
+     * @param pool - the sidecar pool (default: the process-wide one).
+     */
+    constructor(spawnArgs: string[] | (() => string[]), cwd?: string, pool?: OmpSdkSidecarPool);
+    /**
+     * Bridge hook: runs once when the child first exists (the caller writes the
+     * index row + supervisor held-baseline there — the create-time counterparts
+     * were deliberately skipped). Registered before or after the spawn; both
+     * orders fire exactly once.
+     */
+    onSpawned(handler: (client: OmpSdkClient) => void): void;
+    get spawned(): boolean;
+    on(listener: (event: RpcEvent) => void): () => void;
+    /**
+     * Title frames must survive the deferred spawn: OMP generates the title from
+     * the first prompt, which is exactly the moment this RPC materializes, so a
+     * listener registered before then would otherwise miss the only frame.
+     */
+    onTitle(listener: (title: string) => void): () => void;
+    onFailure(listener: (error: Error) => void): () => void;
+    prompt(message: string): Promise<unknown>;
+    followUp(message: string): Promise<unknown>;
+    steer(message: string): Promise<unknown>;
+    compact(instructions?: string): Promise<unknown>;
+    contextUsage(): Promise<{
+        tokens?: number;
+        percent?: number;
+    } | undefined>;
+    abort(): Promise<unknown>;
+    ensureStarted(): Promise<void>;
+    getState(): Promise<OmpState>;
+    getSubagents(): Promise<unknown[]>;
+    getSessionStats(): Promise<OmpSessionStats>;
+    getSystemPrompt(): Promise<string | undefined>;
+    setModel(provider: string, modelId: string): Promise<unknown>;
+    sendRaw(command: Record<string, unknown>): void;
+    close(): void;
+}

package/agent-omp-sdk/dist/lazy-rpc.js

@@ -0,0 +1,178 @@
+import { defaultOmpSdkSidecarPool } from "./sdk-client.js";
+/** Synthetic state for a not-yet-spawned child: quiescent by definition. */
+const IDLE_STATE = { isStreaming: false };
+export class LazyOmpRpc {
+    #spawnArgs;
+    #cwd;
+    /**
+     * The sidecar pool this wrapper rides (the process-wide default unless a test
+     * or a second world injects its own). Every session of one pool shares ONE
+     * bun child — that singleton IS the reason the SDK row exists.
+     */
+    #pool;
+    #client;
+    #spawn;
+    #closed = false;
+    #eventListeners = new Set();
+    #titleListeners = new Set();
+    #failureListeners = new Set();
+    #pendingModel;
+    #onSpawned;
+    /**
+     * @param spawnArgs - the session's argv (`--approval-mode …`, optional
+     *   `--resume …`), or a thunk called AT SPAWN. Use the thunk whenever a
+     *   launch fact can still change between construction and the first prompt —
+     *   the new-chat permission pick does, and so does the lazily fetched SDK
+     *   runtime the spawn depends on.
+     * @param cwd - the session cwd.
+     * @param pool - the sidecar pool (default: the process-wide one).
+     */
+    constructor(spawnArgs, cwd, pool) {
+        this.#spawnArgs = spawnArgs;
+        this.#cwd = cwd;
+        this.#pool = pool ?? defaultOmpSdkSidecarPool();
+    }
+    /**
+     * Bridge hook: runs once when the child first exists (the caller writes the
+     * index row + supervisor held-baseline there — the create-time counterparts
+     * were deliberately skipped). Registered before or after the spawn; both
+     * orders fire exactly once.
+     */
+    onSpawned(handler) {
+        this.#onSpawned = handler;
+        if (this.#client !== undefined)
+            handler(this.#client);
+    }
+    get spawned() {
+        return this.#client !== undefined;
+    }
+    /** Spawn once; concurrent and later callers share the same child. */
+    #ensure() {
+        if (this.#client !== undefined)
+            return Promise.resolve(this.#client);
+        if (this.#spawn === undefined) {
+            const args = typeof this.#spawnArgs === "function" ? this.#spawnArgs() : this.#spawnArgs;
+            this.#spawn = this.#pool.spawnSession(args, this.#cwd).then((client) => {
+                // A close() that raced the in-flight spawn wins: dispose immediately.
+                if (this.#closed) {
+                    client.close();
+                    return client;
+                }
+                this.#client = client;
+                for (const listener of this.#eventListeners)
+                    client.on(listener);
+                for (const listener of this.#titleListeners)
+                    client.onTitle(listener);
+                for (const listener of this.#failureListeners)
+                    client.onFailure(listener);
+                this.#onSpawned?.(client);
+                return client;
+            }).catch((error) => {
+                // Allow a later dispatch to retry the spawn.
+                this.#spawn = undefined;
+                throw error;
+            });
+        }
+        return this.#spawn;
+    }
+    on(listener) {
+        this.#eventListeners.add(listener);
+        if (this.#client !== undefined)
+            this.#client.on(listener);
+        return () => {
+            this.#eventListeners.delete(listener);
+        };
+    }
+    /**
+     * Title frames must survive the deferred spawn: OMP generates the title from
+     * the first prompt, which is exactly the moment this RPC materializes, so a
+     * listener registered before then would otherwise miss the only frame.
+     */
+    onTitle(listener) {
+        this.#titleListeners.add(listener);
+        if (this.#client !== undefined)
+            this.#client.onTitle(listener);
+        return () => {
+            this.#titleListeners.delete(listener);
+        };
+    }
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        if (this.#client !== undefined)
+            this.#client.onFailure(listener);
+        return () => {
+            this.#failureListeners.delete(listener);
+        };
+    }
+    async prompt(message) {
+        const client = await this.#ensure();
+        // Apply a pre-spawn model selection now, ahead of the prompt (the sidecar
+        // records it as the session's model_change, like a pre-turn set_model).
+        const pending = this.#pendingModel;
+        if (pending !== undefined) {
+            this.#pendingModel = undefined;
+            await client.setModel(pending.provider, pending.modelId).catch(() => { });
+        }
+        return client.prompt(message);
+    }
+    async followUp(message) {
+        return (await this.#ensure()).followUp(message);
+    }
+    async steer(message) {
+        return (await this.#ensure()).steer(message);
+    }
+    async compact(instructions) {
+        return (await this.#ensure()).compact(instructions);
+    }
+    async contextUsage() {
+        if (this.#client === undefined)
+            return undefined;
+        return this.#client.contextUsage();
+    }
+    async abort() {
+        if (this.#client === undefined)
+            return undefined;
+        return this.#client.abort();
+    }
+    async ensureStarted() {
+        await this.#ensure();
+    }
+    async getState() {
+        if (this.#client === undefined)
+            return IDLE_STATE;
+        return this.#client.getState();
+    }
+    async getSubagents() {
+        if (this.#client === undefined)
+            return [];
+        return this.#client.getSubagents();
+    }
+    async getSessionStats() {
+        if (this.#client === undefined)
+            return {};
+        return this.#client.getSessionStats();
+    }
+    async getSystemPrompt() {
+        if (this.#client === undefined)
+            return undefined;
+        return this.#client.getSystemPrompt();
+    }
+    async setModel(provider, modelId) {
+        if (this.#client === undefined) {
+            // Park it: applied by prompt() immediately after the spawn.
+            this.#pendingModel = { provider, modelId };
+            return undefined;
+        }
+        return this.#client.setModel(provider, modelId);
+    }
+    sendRaw(command) {
+        if (this.#client !== undefined)
+            this.#client.sendRaw(command);
+    }
+    close() {
+        this.#closed = true;
+        const client = this.#client;
+        this.#client = undefined;
+        client?.close();
+    }
+}

package/agent-omp-sdk/dist/mobile/zoom-guard.d.ts

@@ -0,0 +1,187 @@
+/**
+ * iOS focus auto-zoom suppression — pure decision core (host half, change
+ * `2026-09-03-ios-focus-zoom-suppression`).
+ *
+ * iOS Safari auto-zooms the page (~115–120%) whenever ANY focusable control
+ * with a computed font-size below 16px receives focus; DSH's input surfaces
+ * are all 13–14px, so every focus on an iPhone trips it. Solution B (user
+ * ruling, 2026-09-03): rewrite the viewport meta early — appending
+ * `maximum-scale=1, user-scalable=no` — which suppresses the focus zoom on
+ * iOS 10+ WITHOUT disabling pinch zoom (Discourse PR #30877 empirics).
+ *
+ * v0.2.5 refinement (change `2026-09-03-zoomguard-standalone-font-floor`):
+ * that empiric holds only IN-BROWSER. Standalone (Add to Home Screen) iOS
+ * HONORS `user-scalable=no` — the meta rewrite kills pinch there, and the
+ * user's primary usage IS the PWA (real-device datum, 2026-09-03). The guard
+ * therefore forks by display mode: browser keeps the meta rewrite untouched;
+ * standalone never touches the meta at all and instead injects a 16px
+ * font-floor stylesheet (the font-size mechanism kills the focus zoom while
+ * pinch stays fully engine-available).
+ *
+ * The five exported predicates here are the entire decision surface:
+ * everything else (state machine, resize re-evaluation, stock-meta
+ * reconciliation) lives in the boot script section {@link buildZoomGuardSection}
+ * emits. That section embeds these functions via `Function.prototype.toString`
+ * — the unit-tested source IS the shipped source, byte for byte — which
+ * constrains their shape:
+ *
+ * - **ES5 syntax only** (the inline head script targets ancient parsers):
+ *   `var`, function declarations, string concatenation; no arrows, no
+ *   let/const, no template literals, no destructuring.
+ * - **Fully self-contained bodies**: no module-scope identifiers, no helper
+ *   calls, no shared constants. A bundler may rename the declaration, but a
+ *   renamed free reference would be a `ReferenceError` on the page. The
+ *   eval-style tests in `test/web-trust.spec.ts` execute the real generated
+ *   script against a stub DOM, so any such leak fails the suite.
+ *
+ * @module agent-omp/mobile/zoom-guard
+ */
+/** The two zoom tokens the guard merges into the stock viewport content. */
+export declare const ZOOM_GUARD_TOKENS: Readonly<Record<string, string>>;
+/**
+ * Whether a UA string + touch-capability pair is an iOS-class browser
+ * (design D2, mirroring Discourse `capabilities.isIOS`): iPhone/iPod/iPad,
+ * plus iPadOS 13+ desktop-Safari masquerade (`Macintosh` UA with a
+ * multi-touch digitizer). Deliberately NOT `pointer:coarse` — Android Chrome
+ * never focus-zooms and `maximum-scale` has historical side effects there,
+ * so the gate is tightened to the iOS family. UA-shape drift degrades
+ * benignly: a novel UA simply reads as non-iOS and no rewriting happens.
+ *
+ * @param ua - `navigator.userAgent`.
+ * @param maxTouchPoints - `navigator.maxTouchPoints` (0 when absent).
+ * @returns `true` for iOS-class browsers.
+ */
+export declare function isIOSClassUA(ua: string, maxTouchPoints: number): boolean;
+/**
+ * Token-level merge of viewport directives into a viewport meta `content`
+ * string (design D4): existing tokens keep their positions, a token whose key
+ * (compared case-insensitively) is in `tokens` is REPLACED by the configured
+ * key=value, and configured keys not present are APPENDED in insertion order.
+ * Idempotent by construction — merging always re-derives from the input, so
+ * repeated evaluation cannot accumulate duplicates.
+ *
+ *   mergeViewportTokens('width=device-width, initial-scale=1', T)
+ *   → 'width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no'
+ *   mergeViewportTokens('width=device-width, maximum-scale=5', T)
+ *   → 'width=device-width, maximum-scale=1, user-scalable=no'   // same-key override, position kept
+ *
+ * @param content - the stock (or stock-equivalent) content string.
+ * @param tokens - the directives to merge, keyed lowercase.
+ * @returns the merged content string.
+ */
+export declare function mergeViewportTokens(content: string, tokens: Record<string, string>): string;
+/**
+ * The double gate (design D2/D3 + the `zoomGuard` config): rewrite applies
+ * only on an iOS-class browser AND a narrow viewport AND a non-`off`
+ * `zoomGuard`. An absent payload (or absent key) means the `'meta'` default —
+ * the same default-on posture as the mobile leg itself — so only an explicit
+ * `'off'` disarms the guard. Unknown non-`off` values read as `'meta'`
+ * (schema validation makes them unreachable in production; benign here).
+ *
+ * @param config - the `__AGENT_OMP_MOBILE__` payload (only `zoomGuard` is read).
+ * @param isIOS - {@link isIOSClassUA} verdict for this page load.
+ * @param isNarrow - `matchMedia('(max-width: breakpoint-0.02px)')` verdict.
+ * @returns `true` when the viewport rewrite should be applied.
+ */
+export declare function shouldApplyZoomGuard(config: {
+    zoomGuard?: string;
+} | undefined, isIOS: boolean, isNarrow: boolean): boolean;
+/**
+ * Standalone display-mode verdict (design D4 of change
+ * `2026-09-03-zoomguard-standalone-font-floor`): standalone PWAs HONOR
+ * `user-scalable=no` (the real-device pinch regression that motivated the
+ * display-mode split), so they must never enter the meta-rewrite path. Two
+ * sources, strict-`true` OR: the `(display-mode: standalone)` media query
+ * (primary) and legacy `navigator.standalone` (older iOS Safari exposes only
+ * the latter). Anything else — `undefined` (engine without the source),
+ * `false`, or truthy junk — reads as NOT standalone.
+ *
+ * @param mqMatchesStandalone - `matchMedia('(display-mode: standalone)').matches`.
+ * @param navStandalone - `navigator.standalone === true`.
+ * @returns `true` in standalone display mode (either source).
+ */
+export declare function isStandaloneDisplay(mqMatchesStandalone: boolean | undefined, navStandalone: boolean | undefined): boolean;
+/**
+ * The 16px font floor stylesheet (design D3): iOS auto-zooms on focus into
+ * ANY control whose computed font-size is below 16px, so in standalone mode
+ * — where the meta rewrite is off the table (pinch must stay
+ * engine-available) — the floor IS the suppression. Scoped by the same
+ * breakpoint band the meta leg uses and derived the same way
+ * (`breakpoint - 0.02`: 768 → 767.98, 900 → 899.98); `!important` beats the
+ * 13/14px CSS module rules and the body inline var chain;
+ * `[contenteditable="true"]` matches only the editable state (React
+ * serializes `contentEditable={bool}` to the literal attribute value
+ * "true"/"false").
+ *
+ * @param breakpointPx - the configured `mobile.breakpoint` (raw — this
+ * function derives the `-0.02` band itself, do NOT pre-subtract).
+ * @returns the complete stylesheet text.
+ */
+export declare function buildFontFloorCss(breakpointPx: number): string;
+/**
+ * Build the boot script's zoomGuard section: the five decision predicates
+ * embedded via `toString()` plus the DOM state machine that applies them.
+ * The machine implements design D3/D4 with one discovered refinement —
+ *
+ * **The standalone fork (2026-09-03, change
+ * `2026-09-03-zoomguard-standalone-font-floor`).** Real-device datum:
+ * standalone (Add to Home Screen) iOS HONORS `user-scalable=no`, so the
+ * meta rewrite that is benign in-browser (pinch stays engine-controlled)
+ * kills pinch in the PWA — the user's primary surface. The section
+ * therefore forks right after the iOS gate, BEFORE any meta machinery: a
+ * one-shot startup verdict (display-mode never flips mid-session) via the
+ * `(display-mode: standalone)` MQ or legacy `navigator.standalone` (D4).
+ * Standalone → inject the `ios-zoom-font-floor` style element into the
+ * head (16px floor, media-query-scoped to the same breakpoint band, D3)
+ * and RETURN — no provisional meta, no reconcile observer, no ladder
+ * timer, no listeners, byte-identical stock meta (D1). The width dimension
+ * lives inside the stylesheet's media query, so the injection itself is
+ * NOT width-gated: a wide standalone load still gets the element; the rule
+ * simply does not match above the breakpoint. Browser mode runs the v0.2.4
+ * machinery unchanged.
+ * **Why reconciliation exists.** The webserver splices head injections
+ * immediately after the opening `<head>` tag, i.e. BEFORE the stock
+ * `<meta name="viewport">` in upstream's `index.html`. At boot-script time
+ * the stock meta is therefore NOT yet parsed, so the "meta missing"
+ * branch is the NORMAL path on the served shell, not an edge case. A
+ * provisional meta is created right away (the timing requirement: the
+ * suppressive tokens are live before any application bundle can focus an
+ * input), and a MutationObserver watches for the parser to insert the stock
+ * meta; the moment it appears, the guard records the true stock content,
+ * rewrites the STOCK meta (token merge, D4's actual semantics — restore
+ * later writes these exact bytes back), and removes the provisional one —
+ * leaving a single-meta document instead of relying on engines'
+ * unspecified multi-meta merge behavior. Engines without MutationObserver
+ * keep the provisional meta for the page's lifetime (degraded but still
+ * suppressive); the observer is never started once the stock meta was
+ * found synchronously.
+ *
+ * **Why the re-evaluation ladder exists (2026-09-03 rework, lead CDP
+ * finding on the 4999 instance).** The boot script runs during head parsing,
+ * BEFORE the engine applies the stock viewport meta — the layout viewport at
+ * first evaluation is the pre-meta engine default (980px observed), so
+ * `mq.matches` reads false on an initial narrow load, and the narrowing that
+ * follows meta application does NOT reliably dispatch `resize` to the page
+ * during load (headless Chrome: never). A ~10ms poll ladder therefore
+ * re-evaluates until the guard IS applied, `document.readyState` reaches
+ * `'complete'`, or ~2s elapse — the first layout always precedes deferred
+ * scripts, so the ladder lands the guard before any application bundle can
+ * focus an input. Steady-state ticks are idempotent no-ops; a wide load
+ * idles to the readyState stop and leaves no timer behind (a pending tick
+ * is also cancelled the moment the guard lands). MediaQuery `change` events
+ * (with the legacy `addListener` fallback) form a second re-evaluation
+ * channel alongside window `resize`.
+ *
+ * State machine (ES5, zero dependencies, synchronous first evaluation):
+ * `meta` is the element under management (provisional or reconciled stock),
+ * `stock` its recorded stock content, `mine` whether we created it,
+ * `applied` the last applied gate verdict. `apply(on)` is idempotent per
+ * state (no-op when the verdict is unchanged); merges always re-derive
+ * from the recorded stock, never from the live content, so resize storms
+ * cannot accumulate tokens. Non-iOS pages never wire any listener.
+ *
+ * Emitted only when the mobile payload exists and `zoomGuard !== 'off'`.
+ *
+ * @returns the inline section text (truthy `var` declarations + IIFE).
+ */
+export declare function buildZoomGuardSection(): string;