opendevbrowser 0.0.15 → 0.0.17

package/extension/dist/ops/ops-session-store.js

@@ -1,3 +1,5 @@
+import { DEFAULT_OPS_PARALLELISM_POLICY, createOpsGovernorState } from "./parallelism-governor.js";
+import { createCoordinatorId, TargetSessionCoordinator } from "./target-session-coordinator.js";
 export class OpsRefStore {
     refsByTarget = new Map();
     snapshotByTarget = new Map();
@@ -6,7 +8,7 @@ export class OpsRefStore {
         for (const entry of entries) {
             map.set(entry.ref, entry);
         }
-        const snapshotId = createId();
+        const snapshotId = createCoordinatorId();
         this.refsByTarget.set(targetId, map);
         this.snapshotByTarget.set(targetId, snapshotId);
         return { snapshotId, targetId, count: entries.length };
@@ -30,160 +32,79 @@ export class OpsRefStore {
     }
 }
 export class OpsSessionStore {
-    sessions = new Map();
-    tabToSession = new Map();
-    createSession(ownerClientId, tabId, leaseId, info) {
-        const id = createId();
-        const targetId = `tab-${tabId}`;
-        const target = {
-            targetId,
-            tabId,
-            url: info?.url,
-            title: info?.title
-        };
-        const session = {
-            id,
-            ownerClientId,
-            leaseId,
-            state: "active",
-            tabId,
-            targetId,
-            activeTargetId: targetId,
-            createdAt: Date.now(),
-            lastUsedAt: Date.now(),
-            targets: new Map([[targetId, target]]),
-            nameToTarget: new Map(),
-            targetToName: new Map(),
+    coordinator = new TargetSessionCoordinator();
+    createSession(ownerClientId, tabId, leaseId, info, options) {
+        const parallelismPolicy = options?.parallelismPolicy ?? DEFAULT_OPS_PARALLELISM_POLICY;
+        return this.coordinator.createSession(ownerClientId, tabId, leaseId, info, {
             refStore: new OpsRefStore(),
+            syntheticTargets: new Map(),
             consoleEvents: [],
             networkEvents: [],
             networkRequests: new Map(),
             consoleSeq: 0,
             networkSeq: 0,
-            queue: Promise.resolve()
-        };
-        this.sessions.set(id, session);
-        this.tabToSession.set(tabId, id);
-        return session;
+            queue: Promise.resolve(),
+            targetQueues: new Map(),
+            targetQueueDepth: new Map(),
+            targetQueueOldestAt: new Map(),
+            parallelInFlight: 0,
+            pendingParallel: 0,
+            discardedSignals: 0,
+            frozenSignals: 0,
+            parallelismPolicy,
+            parallelismState: createOpsGovernorState(parallelismPolicy, "extensionOpsHeaded")
+        });
     }
     get(sessionId) {
-        return this.sessions.get(sessionId) ?? null;
+        return this.coordinator.get(sessionId);
     }
     getByTabId(tabId) {
-        const id = this.tabToSession.get(tabId);
-        if (!id)
-            return null;
-        return this.sessions.get(id) ?? null;
+        return this.coordinator.getByTabId(tabId);
     }
     listOwnedBy(clientId) {
-        return Array.from(this.sessions.values()).filter((session) => session.ownerClientId === clientId);
+        return this.coordinator.listOwnedBy(clientId);
     }
     delete(sessionId) {
-        const session = this.sessions.get(sessionId) ?? null;
-        if (!session)
-            return null;
-        this.sessions.delete(sessionId);
-        for (const target of session.targets.values()) {
-            this.tabToSession.delete(target.tabId);
-        }
-        return session;
+        return this.coordinator.delete(sessionId);
     }
     addTarget(sessionId, tabId, info) {
-        const session = this.requireSession(sessionId);
-        const targetId = `tab-${tabId}`;
-        const target = {
-            targetId,
-            tabId,
-            url: info?.url,
-            title: info?.title
-        };
-        session.targets.set(targetId, target);
-        this.tabToSession.set(tabId, sessionId);
-        if (!session.activeTargetId) {
-            session.activeTargetId = targetId;
-        }
-        return target;
+        return this.coordinator.addTarget(sessionId, tabId, info);
     }
     removeTarget(sessionId, targetId) {
+        const target = this.coordinator.removeTarget(sessionId, targetId);
         const session = this.requireSession(sessionId);
-        const target = session.targets.get(targetId) ?? null;
         if (!target)
             return null;
-        session.targets.delete(targetId);
-        this.tabToSession.delete(target.tabId);
-        const name = session.targetToName.get(targetId);
-        if (name) {
-            session.targetToName.delete(targetId);
-            session.nameToTarget.delete(name);
-        }
-        if (session.activeTargetId === targetId) {
-            const [first] = session.targets.keys();
-            session.activeTargetId = first ?? "";
-        }
+        session.targetQueues.delete(targetId);
+        session.targetQueueDepth.delete(targetId);
+        session.targetQueueOldestAt.delete(targetId);
         session.refStore.clearTarget(targetId);
+        session.syntheticTargets.delete(targetId);
         return target;
     }
     getTargetIdByTabId(sessionId, tabId) {
-        const session = this.requireSession(sessionId);
-        for (const target of session.targets.values()) {
-            if (target.tabId === tabId) {
-                return target.targetId;
-            }
-        }
-        return null;
+        return this.coordinator.getTargetIdByTabId(sessionId, tabId);
     }
     removeTargetByTabId(sessionId, tabId) {
-        const targetId = this.getTargetIdByTabId(sessionId, tabId);
+        const targetId = this.coordinator.getTargetIdByTabId(sessionId, tabId);
         if (!targetId)
             return null;
         return this.removeTarget(sessionId, targetId);
     }
     setActiveTarget(sessionId, targetId) {
-        const session = this.requireSession(sessionId);
-        if (!session.targets.has(targetId)) {
-            throw new Error(`Unknown targetId: ${targetId}`);
-        }
-        session.activeTargetId = targetId;
+        this.coordinator.setActiveTarget(sessionId, targetId);
     }
     setName(sessionId, targetId, name) {
-        const session = this.requireSession(sessionId);
-        const trimmed = name.trim();
-        if (!trimmed) {
-            throw new Error("Name must be non-empty");
-        }
-        if (!session.targets.has(targetId)) {
-            throw new Error(`Unknown targetId: ${targetId}`);
-        }
-        const existing = session.nameToTarget.get(trimmed);
-        if (existing && existing !== targetId) {
-            throw new Error(`Name already in use: ${trimmed}`);
-        }
-        const previousName = session.targetToName.get(targetId);
-        if (previousName && previousName !== trimmed) {
-            session.nameToTarget.delete(previousName);
-        }
-        session.nameToTarget.set(trimmed, targetId);
-        session.targetToName.set(targetId, trimmed);
+        this.coordinator.setName(sessionId, targetId, name);
     }
     getTargetIdByName(sessionId, name) {
-        const session = this.requireSession(sessionId);
-        return session.nameToTarget.get(name.trim()) ?? null;
+        return this.coordinator.getTargetIdByName(sessionId, name);
     }
     listNamedTargets(sessionId) {
-        const session = this.requireSession(sessionId);
-        return Array.from(session.nameToTarget.entries()).map(([name, targetId]) => ({ name, targetId }));
+        return this.coordinator.listNamedTargets(sessionId);
     }
     requireSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new Error(`Unknown sessionId: ${sessionId}`);
-        }
-        return session;
+        return this.coordinator.requireSession(sessionId);
     }
 }
-const createId = () => {
-    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
-        return crypto.randomUUID();
-    }
-    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
-};
+export const createOpsSessionId = () => createCoordinatorId();

package/extension/dist/ops/parallelism-governor.js

@@ -0,0 +1,117 @@
+export const DEFAULT_OPS_PARALLELISM_POLICY = {
+    floor: 1,
+    backpressureTimeoutMs: 5000,
+    sampleIntervalMs: 2000,
+    recoveryStableWindows: 3,
+    hostFreeMemMediumPct: 25,
+    hostFreeMemHighPct: 18,
+    hostFreeMemCriticalPct: 10,
+    rssBudgetMb: 2048,
+    rssSoftPct: 65,
+    rssHighPct: 75,
+    rssCriticalPct: 85,
+    queueAgeHighMs: 2000,
+    queueAgeCriticalMs: 5000,
+    modeCaps: {
+        managedHeaded: 6,
+        managedHeadless: 8,
+        cdpConnectHeaded: 6,
+        cdpConnectHeadless: 8,
+        extensionOpsHeaded: 6,
+        extensionLegacyCdpHeaded: 1
+    }
+};
+const clamp = (value, floor, ceil) => {
+    if (value < floor)
+        return floor;
+    if (value > ceil)
+        return ceil;
+    return value;
+};
+const floorPercent = (value) => clamp(Number.isFinite(value) ? value : 0, 0, 100);
+const classifyPressure = (policy, input) => {
+    const hostFreeMemPct = floorPercent(input.hostFreeMemPct);
+    const rssUsagePct = floorPercent(input.rssUsagePct);
+    const queueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const discardedSignals = Math.max(0, input.discardedSignals ?? 0);
+    const frozenSignals = Math.max(0, input.frozenSignals ?? 0);
+    const critical = hostFreeMemPct <= policy.hostFreeMemCriticalPct
+        || rssUsagePct >= policy.rssCriticalPct
+        || queueAgeMs >= policy.queueAgeCriticalMs;
+    if (critical)
+        return "critical";
+    const high = hostFreeMemPct <= policy.hostFreeMemHighPct
+        || rssUsagePct >= policy.rssHighPct
+        || queueAgeMs >= policy.queueAgeHighMs
+        || discardedSignals > 0;
+    if (high)
+        return "high";
+    const medium = hostFreeMemPct <= policy.hostFreeMemMediumPct
+        || rssUsagePct >= policy.rssSoftPct
+        || frozenSignals > 0;
+    return medium ? "medium" : "healthy";
+};
+const pressurePenalty = (pressure) => {
+    switch (pressure) {
+        case "medium":
+            return 1;
+        case "high":
+            return 2;
+        case "critical":
+            return Number.MAX_SAFE_INTEGER;
+        default:
+            return 0;
+    }
+};
+export const resolveOpsStaticCap = (policy, modeVariant) => {
+    const cap = policy.modeCaps[modeVariant];
+    return clamp(cap, policy.floor, cap);
+};
+export const createOpsGovernorState = (policy, modeVariant) => {
+    const staticCap = resolveOpsStaticCap(policy, modeVariant);
+    return {
+        modeVariant,
+        staticCap,
+        effectiveCap: staticCap,
+        healthyWindows: 0,
+        lastSampleAt: 0,
+        lastPressure: "healthy"
+    };
+};
+export const evaluateOpsGovernor = (policy, current, input, sampledAt = Date.now()) => {
+    const normalizedQueueDepth = Math.max(0, Number.isFinite(input.queueDepth) ? input.queueDepth : 0);
+    const normalizedQueueAgeMs = Math.max(0, Number.isFinite(input.queueAgeMs) ? input.queueAgeMs : 0);
+    const pressure = classifyPressure(policy, input);
+    const basePenalty = pressurePenalty(pressure);
+    const lifecyclePenalty = Math.max(0, input.discardedSignals ?? 0) + Math.max(0, input.frozenSignals ?? 0);
+    const targetCap = pressure === "critical"
+        ? policy.floor
+        : clamp(current.staticCap - basePenalty - lifecyclePenalty, policy.floor, current.staticCap);
+    let effectiveCap = current.effectiveCap;
+    let healthyWindows = pressure === "healthy" ? current.healthyWindows + 1 : 0;
+    if (targetCap < current.effectiveCap) {
+        effectiveCap = targetCap;
+        healthyWindows = 0;
+    }
+    else if (targetCap > current.effectiveCap) {
+        const windowsRequired = Math.max(1, policy.recoveryStableWindows);
+        if (healthyWindows >= windowsRequired) {
+            effectiveCap = clamp(current.effectiveCap + 1, policy.floor, targetCap);
+            healthyWindows = 0;
+        }
+    }
+    return {
+        state: {
+            modeVariant: current.modeVariant,
+            staticCap: current.staticCap,
+            effectiveCap,
+            healthyWindows,
+            lastSampleAt: sampledAt,
+            lastPressure: pressure
+        },
+        pressure,
+        targetCap,
+        waitQueueDepth: normalizedQueueDepth,
+        waitQueueAgeMs: normalizedQueueAgeMs
+    };
+};

package/extension/dist/ops/snapshot-shared.js

@@ -49,13 +49,27 @@ export const selectorFunction = function () {
         }
         return String(value).replace(/([^\w-])/g, "\\$1");
     };
+    const isUniqueSelector = (selector) => {
+        try {
+            return document.querySelectorAll(selector).length === 1;
+        }
+        catch {
+            return false;
+        }
+    };
     const testId = this.getAttribute("data-testid");
     if (testId) {
-        return '[data-testid="' + escape(testId) + '"]';
+        const selector = '[data-testid="' + escape(testId) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
     }
     const ariaLabel = this.getAttribute("aria-label");
     if (ariaLabel && ariaLabel.length < 50) {
-        return '[aria-label="' + escape(ariaLabel) + '"]';
+        const selector = '[aria-label="' + escape(ariaLabel) + '"]';
+        if (isUniqueSelector(selector)) {
+            return selector;
+        }
     }
     const buildPathSelector = (start) => {
         const parts = [];
@@ -63,9 +77,11 @@ export const selectorFunction = function () {
         while (current && current.nodeType === Node.ELEMENT_NODE) {
             let selector = current.nodeName.toLowerCase();
             if (current.id) {
-                selector += "#" + escape(current.id);
-                parts.unshift(selector);
-                break;
+                const withId = selector + "#" + escape(current.id);
+                if (isUniqueSelector(withId)) {
+                    parts.unshift(withId);
+                    break;
+                }
             }
             const parentEl = current.parentElement;
             if (!parentEl) {

package/extension/dist/ops/target-session-coordinator.js

@@ -0,0 +1,157 @@
+export class TargetSessionCoordinator {
+    sessions = new Map();
+    tabToSession = new Map();
+    createSession(ownerClientId, tabId, leaseId, info, extra, sessionId) {
+        const id = sessionId ?? createCoordinatorId();
+        const targetId = `tab-${tabId}`;
+        const target = {
+            targetId,
+            tabId,
+            url: info?.url,
+            title: info?.title
+        };
+        const createdAt = Date.now();
+        const session = {
+            id,
+            ownerClientId,
+            leaseId,
+            state: "active",
+            tabId,
+            targetId,
+            activeTargetId: targetId,
+            createdAt,
+            lastUsedAt: createdAt,
+            targets: new Map([[targetId, target]]),
+            nameToTarget: new Map(),
+            targetToName: new Map(),
+            ...extra
+        };
+        this.sessions.set(id, session);
+        this.tabToSession.set(tabId, id);
+        return session;
+    }
+    get(sessionId) {
+        return this.sessions.get(sessionId) ?? null;
+    }
+    getByTabId(tabId) {
+        const sessionId = this.tabToSession.get(tabId);
+        if (!sessionId) {
+            return null;
+        }
+        return this.sessions.get(sessionId) ?? null;
+    }
+    listOwnedBy(clientId) {
+        return Array.from(this.sessions.values()).filter((session) => session.ownerClientId === clientId);
+    }
+    delete(sessionId) {
+        const session = this.sessions.get(sessionId) ?? null;
+        if (!session) {
+            return null;
+        }
+        this.sessions.delete(sessionId);
+        for (const target of session.targets.values()) {
+            this.tabToSession.delete(target.tabId);
+        }
+        return session;
+    }
+    addTarget(sessionId, tabId, info) {
+        const session = this.requireSession(sessionId);
+        const targetId = `tab-${tabId}`;
+        const target = {
+            targetId,
+            tabId,
+            url: info?.url,
+            title: info?.title
+        };
+        session.targets.set(targetId, target);
+        this.tabToSession.set(tabId, sessionId);
+        if (!session.activeTargetId) {
+            session.activeTargetId = targetId;
+        }
+        return target;
+    }
+    removeTarget(sessionId, targetId) {
+        const session = this.requireSession(sessionId);
+        const target = session.targets.get(targetId) ?? null;
+        if (!target) {
+            return null;
+        }
+        session.targets.delete(targetId);
+        this.tabToSession.delete(target.tabId);
+        const name = session.targetToName.get(targetId);
+        if (name) {
+            session.targetToName.delete(targetId);
+            session.nameToTarget.delete(name);
+        }
+        if (session.activeTargetId === targetId) {
+            const [first] = session.targets.keys();
+            session.activeTargetId = first ?? "";
+        }
+        return target;
+    }
+    getTargetIdByTabId(sessionId, tabId) {
+        const session = this.requireSession(sessionId);
+        for (const target of session.targets.values()) {
+            if (target.tabId === tabId) {
+                return target.targetId;
+            }
+        }
+        return null;
+    }
+    removeTargetByTabId(sessionId, tabId) {
+        const targetId = this.getTargetIdByTabId(sessionId, tabId);
+        if (!targetId) {
+            return null;
+        }
+        return this.removeTarget(sessionId, targetId);
+    }
+    setActiveTarget(sessionId, targetId) {
+        const session = this.requireSession(sessionId);
+        if (!session.targets.has(targetId)) {
+            throw new Error(`Unknown targetId: ${targetId}`);
+        }
+        session.activeTargetId = targetId;
+    }
+    setName(sessionId, targetId, name) {
+        const session = this.requireSession(sessionId);
+        const trimmed = name.trim();
+        if (!trimmed) {
+            throw new Error("Name must be non-empty");
+        }
+        if (!session.targets.has(targetId)) {
+            throw new Error(`Unknown targetId: ${targetId}`);
+        }
+        const existing = session.nameToTarget.get(trimmed);
+        if (existing && existing !== targetId) {
+            throw new Error(`Name already in use: ${trimmed}`);
+        }
+        const previousName = session.targetToName.get(targetId);
+        if (previousName && previousName !== trimmed) {
+            session.nameToTarget.delete(previousName);
+        }
+        session.nameToTarget.set(trimmed, targetId);
+        session.targetToName.set(targetId, trimmed);
+    }
+    getTargetIdByName(sessionId, name) {
+        const session = this.requireSession(sessionId);
+        return session.nameToTarget.get(name.trim()) ?? null;
+    }
+    listNamedTargets(sessionId) {
+        const session = this.requireSession(sessionId);
+        return Array.from(session.nameToTarget.entries()).map(([name, targetId]) => ({ name, targetId }));
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new Error(`Unknown sessionId: ${sessionId}`);
+        }
+        session.lastUsedAt = Date.now();
+        return session;
+    }
+}
+export const createCoordinatorId = () => {
+    if (typeof crypto !== "undefined" && "randomUUID" in crypto) {
+        return crypto.randomUUID();
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+};