super-dsh 0.1.0 → 0.1.2

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

@@ -0,0 +1,161 @@
+import { OmpSdkClient } 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;
+    #client;
+    #spawn;
+    #closed = false;
+    #eventListeners = new Set();
+    #titleListeners = new Set();
+    #failureListeners = new Set();
+    #pendingModel;
+    #onSpawned;
+    constructor(spawnArgs, cwd) {
+        this.#spawnArgs = spawnArgs;
+        this.#cwd = cwd;
+    }
+    /**
+     * 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) {
+            this.#spawn = OmpSdkClient.spawn(this.#spawnArgs, 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/dist/mobile/gesture.js

@@ -0,0 +1,148 @@
+/**
+ * Mobile swipe recognition (pure, unit-tested) — an EXACT port of the
+ * operator's own ui-layout patch (retired `z_dsh-alpha` checkout, commit
+ * `1706b81` "ui-layout: mobile swipe opens Better Sidebar right panel via
+ * its DOM toggle", `packages/client/ui-layout/src/client/AppFrame.tsx`)
+ * from patched-source form into plugin form, plus exactly ONE addition:
+ * an average-velocity gate (`swipeVelocityPxPerMs`, the 2026-09-02
+ * supplemental requirement — the only constant here without a source
+ * precedent; `0` disarms it and restores the source's behavior verbatim).
+ *
+ * Source semantics, preserved number-for-number:
+ * - **Start admission** (pointerdown): with BOTH panels closed, only the
+ *   left band `x ≤ 120` (the source's X120) or the right three quarters
+ *   `x ≥ viewport/4` may start a gesture — the center band stays inert so
+ *   content swipes don't misfire. With a panel open, ANY position may
+ *   start (the dismiss swipe naturally starts on the panel body).
+ * - **Firing** (pointermove, mid-gesture): the gesture fires DURING the
+ *   drag as soon as `|dx| ≥ 40` AND `|dx| > |dy| × 1.3` (horizontal
+ *   dominance over scroll intent) — then the drag is spent (one shot).
+ *   Firing mid-gesture rather than at pointerup is what keeps a lazy
+ *   swipe triggerable: a pointerup-time decision loses the pointer to the
+ *   browser's scroll/pan heuristics (pointercancel) whenever the drag is
+ *   slow, which reads to the user as "I must flick fast to trigger".
+ * - **State machine** (symmetric, from the source):
+ *     left-swipe:  close the sidebar if open, else open the right panel
+ *                  (Better Sidebar) when a session is current;
+ *     right-swipe: close the right panel if open, else open the sidebar
+ *                  when collapsed.
+ * - **Band admission (2026-09-11 mobile wave)**: no own pixel cut-off. The
+ *   feature is live on coarse pointers (phones/tablets) and wherever a
+ *   panel is already in its narrow-viewport state — i.e. it follows the
+ *   upstream layout STATE, never a threshold we invented. Upstream may
+ *   move their auto-collapse boundary (1024 today) freely; we track the
+ *   resulting state attributes.
+ *
+ * Both panel reads address OFFICIAL upstream surfaces ONLY (hard rule,
+ * 2026-09-11): the left sidebar through the layout service
+ * (`ctx.layout.toggleSidebar()`) and AppFrame's `[data-sidebar-collapsed]`;
+ * the right panel through the official 0.1.5 controls — expand
+ * `[data-sidebar-right-expand]` (conversation header corner) and toggle
+ * `[data-sidebar-right-toggle]` (dock chrome) — with its open state read
+ * off AppFrame's `[data-rightbar-collapsed]`. Third-party plugin DOM is
+ * never a state input again (the retired Better Sidebar coupling poisoned
+ * the whole state machine once that plugin was removed).
+ *
+ * No DOM here: these are pure predicates over gesture facts plus the
+ * panel state the caller reads off live DOM.
+ *
+ * @module omp-web/mobile/gesture
+ */
+/** Resolved defaults — the `1706b81` constants (120 / viewport÷4 / 40 / 1.3)
+ * plus the one addition, the velocity gate. A slow text-selection drag runs
+ * ~0.13 px/ms; 0.15 px/ms filters those while any comfortable sweep (0.4
+ * px/ms and up) passes.
+ */
+export const DEFAULT_SWIPE_THRESHOLDS = {
+    swipeDistancePx: 40,
+    dominanceRatio: 1.3,
+    leftEdgeBandPx: 120,
+    rightZoneRatio: 0.25,
+    swipeVelocityPxPerMs: 0.15,
+};
+/**
+ * Whether a pointerdown may START a gesture — the source's pointerdown
+ * gate, verbatim: with both panels closed, only the left band (X120) or
+ * the right three quarters of the screen admit; with a panel open, any
+ * position admits (that swipe is a dismiss).
+ *
+ * @param x - pointerdown client X.
+ * @param viewportWidth - viewport width at gesture time (px).
+ * @param panels - panel state at pointerdown.
+ * @param thresholds - resolved recognition thresholds.
+ * @returns `true` when the origin is admitted into tracking.
+ */
+export function admitsSwipeStart(x, viewportWidth, panels, thresholds) {
+    if (!(panels.leftCollapsed && !panels.rightOpen))
+        return true;
+    return x <= thresholds.leftEdgeBandPx || x >= viewportWidth * thresholds.rightZoneRatio;
+}
+/**
+ * Classify one in-flight drag into a panel action — the source's
+ * pointermove decision, verbatim, plus the velocity gate. Callers fire
+ * ONCE (then drop the drag): a `null` here means "not yet / not this
+ * gesture", and the same drag may classify on a LATER move event as its
+ * displacement or velocity grows.
+ *
+ * @param progress - the drag's displacement and elapsed time so far.
+ * @param panels - panel state read live at this event.
+ * @param sessionLive - whether a session is current (gates opening the
+ *   right panel, mirroring the source's `detailsSession !== undefined`).
+ * @param thresholds - resolved recognition thresholds.
+ * @returns the action the drag maps to, or `null` when no panel admits
+ *   it yet.
+ */
+export function classifySwipeProgress(progress, panels, sessionLive, thresholds) {
+    const adx = Math.abs(progress.dx);
+    const ady = Math.abs(progress.dy);
+    if (adx < thresholds.swipeDistancePx)
+        return null;
+    if (adx <= ady * thresholds.dominanceRatio)
+        return null;
+    if (thresholds.swipeVelocityPxPerMs > 0) {
+        if (progress.dtMs <= 0)
+            return null;
+        if (adx / progress.dtMs < thresholds.swipeVelocityPxPerMs)
+            return null;
+    }
+    if (progress.dx < 0) {
+        // Left swipe: close the sidebar if open, otherwise open the right
+        // panel when a session is current.
+        if (!panels.leftCollapsed)
+            return 'close-left';
+        if (sessionLive && !panels.rightOpen)
+            return 'open-right';
+        return null;
+    }
+    // Right swipe: close the right panel if open, otherwise open the
+    // sidebar when collapsed.
+    if (panels.rightOpen)
+        return 'close-right';
+    if (panels.leftCollapsed)
+        return 'open-left';
+    return null;
+}
+/**
+ * Merge the host-injected page config over the defaults. An absent config
+ * (host feature off, or an old cached page) resolves to enabled=false — the
+ * client half is inert unless the host opted the page in.
+ *
+ * @param pageConfig - `window.__OMP_WEB_MOBILE__` as left by the boot script.
+ * @returns resolved thresholds plus the enable flag.
+ */
+export function resolveMobileConfig(pageConfig) {
+    if (pageConfig === undefined || pageConfig.enabled !== true) {
+        return { enabled: false, ...DEFAULT_SWIPE_THRESHOLDS };
+    }
+    const n = (value, fallback) => typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+    // The velocity gate alone accepts 0 (disarm) as a configured value.
+    const v = (value, fallback) => typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : fallback;
+    return {
+        enabled: true,
+        swipeDistancePx: n(pageConfig.swipeDistancePx, DEFAULT_SWIPE_THRESHOLDS.swipeDistancePx),
+        dominanceRatio: n(pageConfig.dominanceRatio, DEFAULT_SWIPE_THRESHOLDS.dominanceRatio),
+        leftEdgeBandPx: n(pageConfig.leftEdgeBandPx, DEFAULT_SWIPE_THRESHOLDS.leftEdgeBandPx),
+        rightZoneRatio: n(pageConfig.rightZoneRatio, DEFAULT_SWIPE_THRESHOLDS.rightZoneRatio),
+        swipeVelocityPxPerMs: v(pageConfig.swipeVelocityPxPerMs, DEFAULT_SWIPE_THRESHOLDS.swipeVelocityPxPerMs),
+    };
+}

package/agent-omp/dist/mobile/zoom-guard.js

@@ -0,0 +1,294 @@
+/**
+ * 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 omp-web/mobile/zoom-guard
+ */
+/** The two zoom tokens the guard merges into the stock viewport content. */
+export const ZOOM_GUARD_TOKENS = {
+    'maximum-scale': '1',
+    'user-scalable': 'no',
+};
+/**
+ * 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 function isIOSClassUA(ua, maxTouchPoints) {
+    return /iPhone|iPod|iPad/.test(ua) || (/Macintosh/.test(ua) && maxTouchPoints > 1);
+}
+/**
+ * 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 function mergeViewportTokens(content, tokens) {
+    var out = [];
+    var seen = {};
+    var parts = content.split(',');
+    for (var i = 0; i < parts.length; i++) {
+        var part = parts[i];
+        var raw = (part === undefined ? '' : part).replace(/^\s+|\s+$/g, '');
+        if (raw === '')
+            continue;
+        var eq = raw.indexOf('=');
+        var key = eq < 0 ? raw : raw.slice(0, eq).replace(/^\s+|\s+$/g, '');
+        var hit = null;
+        for (var k in tokens) {
+            if (tokens.hasOwnProperty(k) && k.toLowerCase() === key.toLowerCase()) {
+                hit = k;
+                break;
+            }
+        }
+        if (hit === null) {
+            out[out.length] = raw;
+            continue;
+        }
+        out[out.length] = hit + '=' + tokens[hit];
+        seen[hit] = true;
+    }
+    for (var j in tokens) {
+        if (tokens.hasOwnProperty(j) && !seen[j])
+            out[out.length] = j + '=' + tokens[j];
+    }
+    return out.join(', ');
+}
+/**
+ * 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 `__OMP_WEB_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 function shouldApplyZoomGuard(config, isIOS, isNarrow) {
+    if (!isIOS || !isNarrow)
+        return false;
+    if (!config)
+        return true;
+    return config.zoomGuard !== 'off';
+}
+/**
+ * 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 function isStandaloneDisplay(mqMatchesStandalone, navStandalone) {
+    return mqMatchesStandalone === true || navStandalone === true;
+}
+/**
+ * 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 function buildFontFloorCss(breakpointPx) {
+    var bp = breakpointPx - 0.02;
+    return '@media (max-width:' + bp + 'px){ input,textarea,select,[contenteditable="true"]{ font-size:16px !important } }';
+}
+/**
+ * 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 function buildZoomGuardSection() {
+    return [
+        `var ZI=${isIOSClassUA.toString()};`,
+        `var ZM=${mergeViewportTokens.toString()};`,
+        `var ZS=${shouldApplyZoomGuard.toString()};`,
+        `var ZD=${isStandaloneDisplay.toString()};`,
+        `var ZF=${buildFontFloorCss.toString()};`,
+        '(function(){',
+        'var m=window.__OMP_WEB_MOBILE__;',
+        'var ios=ZI(navigator.userAgent,(navigator.maxTouchPoints||0));',
+        'if(!ios)return;',
+        "var bpx=(m&&typeof m.breakpoint==='number'&&m.breakpoint>0)?m.breakpoint:768;",
+        'var bp=bpx-0.02;',
+        "var sa=ZD((window.matchMedia&&window.matchMedia('(display-mode: standalone)').matches),(navigator.standalone===true));",
+        "if(sa){var f=document.createElement('style');f.setAttribute('id','ios-zoom-font-floor');f.setAttribute('data-plugin','omp-web');f.setAttribute('data-plugin-css','omp-web/zoom-font-floor');f.textContent=ZF(bpx);headEl().appendChild(f);return}",
+        "var mq=(typeof window.matchMedia==='function')?window.matchMedia('(max-width:'+bp+'px)'):null;",
+        "var T={'maximum-scale':'1','user-scalable':'no'};",
+        'var meta=null,stock=null,mine=false,applied=false,obs=null,lad=null,lN=0;',
+        "function findStock(){var s=document.getElementsByTagName('meta');for(var i=0;i<s.length;i++){var e=s[i];if(e!==meta&&(e.getAttribute('name')||'').toLowerCase()==='viewport')return e}return null}",
+        "function headEl(){return document.head||document.getElementsByTagName('head')[0]||document.documentElement}",
+        'function stopWatch(){if(obs){obs.disconnect();obs=null}}',
+        'function stopLadder(){if(lad){clearTimeout(lad);lad=null}}',
+        "function dropMine(){if(meta&&mine){if(meta.parentNode)meta.parentNode.removeChild(meta);meta=null;mine=false}}",
+        'function apply(on){',
+        'if(on===applied)return;',
+        'applied=on;',
+        'if(on)stopLadder();',
+        'if(on){',
+        'var el=findStock();',
+        "if(el){meta=el;mine=false;stock=el.getAttribute('content')||''}",
+        "else if(!meta){meta=document.createElement('meta');meta.setAttribute('name','viewport');mine=true;stock='';headEl().appendChild(meta)}",
+        "meta.setAttribute('content',ZM(stock,T));",
+        "if(mine&&typeof MutationObserver==='function'&&!obs){obs=new MutationObserver(check);obs.observe(document.documentElement,{childList:true,subtree:true})}",
+        '}else{',
+        'stopWatch();',
+        'if(!meta)return;',
+        'if(mine)dropMine();',
+        "else meta.setAttribute('content',stock);", // restore = exact stock bytes (D4)
+        '}',
+        '}',
+        'function check(){',
+        'var el=findStock();',
+        'if(!el)return;',
+        'stopWatch();',
+        "stock=el.getAttribute('content')||'';",
+        "if(applied){dropMine();meta=el;mine=false;meta.setAttribute('content',ZM(stock,T))}",
+        'else{dropMine();meta=null;stock=null}',
+        '}',
+        'function re(){apply(ZS(m,true,mq?mq.matches:false))}',
+        'function tick(){',
+        'lad=null;',
+        're();',
+        'if(applied)return;',
+        'lN++;',
+        "if(document.readyState==='complete'||lN>=200)return;",
+        'lad=setTimeout(tick,10);',
+        '}',
+        're();',
+        "window.addEventListener('resize',re);",
+        "if(mq&&mq.addEventListener)mq.addEventListener('change',re);else if(mq&&mq.addListener)mq.addListener(re);",
+        "if(!applied&&typeof setTimeout==='function')lad=setTimeout(tick,10);",
+        '})()',
+    ].join('');
+}

package/agent-omp/dist/mobile-boot.js

@@ -0,0 +1,38 @@
+import { buildZoomGuardSection } from './mobile/zoom-guard.js';
+/**
+ * Build the boot script text. Pure: same constants in, same script out — the
+ * unit tests pin the shape (mobile global present, zoom-guard section present,
+ * wrapped in a non-throwing IIFE).
+ *
+ * @returns the script text.
+ */
+export function buildMobileBootScript() {
+    const parts = ['(function(){try{'];
+    // Ship default ON: a bare page carries the mobile global (the client's
+    // `resolveMobileConfig` merges the threshold defaults over `enabled: true`).
+    parts.push(`window.__OMP_WEB_MOBILE__=${JSON.stringify({ enabled: true })};`);
+    // The zoom guard rides the mobile leg (default 'meta' mode): emitted always.
+    parts.push(buildZoomGuardSection());
+    parts.push('}catch(e){}})();');
+    return parts.join('');
+}
+/**
+ * Mount the boot-script injection: one `webserver/index-inject` listener
+ * pushing the rendered row. Conditional on the webServer service, so the
+ * plugin loads (with the feature dormant) in compositions without one.
+ * Fail-open: a push failure is logged, never thrown.
+ *
+ * @param ctx - host plugin context.
+ */
+export function installMobileBootScript(ctx) {
+    ctx.inject(['webServer'], () => {
+        ctx.on('webserver/index-inject', (table) => {
+            try {
+                table.push({ kind: 'script', placement: 'head', text: buildMobileBootScript() });
+            }
+            catch (error) {
+                ctx.logger.warn(`omp-web: mobile boot script injection failed: ${String(error)}`);
+            }
+        });
+    });
+}