surf-cli 2.14.0 → 2.15.0

package/README.md

@@ -142,7 +142,7 @@ surf remote revoke agent-macbook
 surf remote list
 ```
 
-`--remote <host>:<port>` takes precedence over `SURF_REMOTE`; `--remote-credential` takes precedence over `SURF_REMOTE_CREDENTIAL`. A selected remote endpoint overrides `SURF_SOCKET` and the default local socket. Local and remote requests share one bounded FIFO browser lease, so they cannot race each other. Disconnects and timeouts abort queued or in-flight work and hold the lease until request-owned cleanup drains or the hard deadline is reached. Browser side effects that already completed are not rolled back.
+`--remote <host>:<port>` takes precedence over `SURF_REMOTE`; `--remote-credential` takes precedence over `SURF_REMOTE_CREDENTIAL`. A selected remote endpoint overrides `SURF_SOCKET` and the default local socket. Local and remote requests share the same host scheduler: each tab has a FIFO lane, different tabs may execute concurrently, and browser-wide writers are exclusive. Disconnects and timeouts abort queued or in-flight work and retain admission until request-owned cleanup drains or the hard deadline is reached. Browser side effects that already completed are not rolled back.
 
 `surf install --listen` persists the explicit Tailnet address in the native-host wrapper. Re-run `surf install` without `--listen` to remove it. The address must be a Tailscale IPv4 or IPv6 address with a port; Surf does not bind every interface. Remote listeners currently require a POSIX browser host and are not supported by Windows native-host wrappers.
 
@@ -348,44 +348,65 @@ surf tab.switch "dashboard"         # Switch by name
 surf tab.group --name "Work" --color blue
 ```
 
-### Window Isolation
+### Browser Sessions and Concurrent Agents
 
-Keep using your browser while the agent works in a separate window:
+Give every independent agent a durable Surf session before its first browser command. `session.ensure` is idempotent: it creates a missing session, reuses a live one, and reopens a stale or closed binding.
 
 ```bash
-# Create a separate window for agent work
-surf window.new "https://example.com"
-# Returns: Window 123456 (tab 789)
+# First command rule for every independent agent shell
+export SURF_SESSION="$(basename "$PWD" | sed 's/[^A-Za-z0-9._-]/-/g')"
+surf session.ensure "$SURF_SESSION" about:blank
 
-# Target that window or its tab from later commands
-surf click e5 --window-id 123456
-surf read --tab-id 789
-surf tab.new "https://other.com" --window-id 123456
+# All later tab-scoped commands use that session automatically
+surf go "https://example.com"
+surf read
+surf click e5
+```
 
-# Name tabs when humans or agents need stable aliases
-surf tab.name dashboard --tab-id 789
-surf tab.switch dashboard
+Use a distinct worktree/directory name per agent. When several agents share one directory, append a stable agent identifier instead of reusing the same `SURF_SESSION` value.
+
+A session owns one explicit Chrome tab. New sessions use a separate **unfocused normal window** by default, so Chrome focus changes cannot retarget another agent's commands.
+
+```bash
+surf session.new research "https://example.com"   # separate unfocused window
+surf session.ensure research about:blank           # safe to run repeatedly
+surf session.new scout about:blank --tab            # inactive tab instead
+
+surf --session research read                        # explicit selector
+SURF_SESSION=research surf screenshot               # environment selector
 
-# Or manage windows directly
-surf window.list                    # List all windows
-surf window.list --tabs             # Include tab details
-surf window.focus 123456            # Bring window to front
-surf window.close 123456            # Close window
+surf session.list --refresh                         # all bindings + queue state
+surf session.info research --refresh                # target and scheduler details
+surf session.close research                         # closes Surf-created target
+surf session.rebind research --tab-id 789            # adopt an existing tab
+surf session.reopen research                         # recreate from last URL
 ```
 
-`window.new`, `--window-id`, `--tab-id`, and named tabs are Surf's supported coordination tools for parallel workflows. They help agents avoid accidentally driving the same visible tab.
+Commands for the same session tab run FIFO. Commands for different session tabs can overlap. Browser-wide mutations—such as creating, moving, closing, or focusing tabs/windows and writing cookies—wait for active tab lanes to drain. Add `--no-wait` to return `tab_busy` or `browser_busy` immediately instead of queueing.
 
-Surf also serializes non-streaming browser CLI requests per socket with a file-based lock, so two agents sharing the same native host wait instead of interleaving browser commands. Use `--no-lock` only when you intentionally want to bypass the guard for a command.
+Recovery errors print an exact command that can be copied directly:
 
-For hard isolation, run separate browser instances/profiles with separate Surf native hosts and socket paths, then point each shell at the matching socket. Each socket has its own independent lock:
+```text
+Error: The tab for session research is gone.
+Recovery: surf session.reopen research
+```
+
+`session.info` distinguishes work queued on the session's own tab, activity on other tabs, and an active or waiting browser-wide writer. Browser-login provider commands such as `surf chatgpt`, `surf gemini`, and `surf oracle ask` print a warning before taking exclusive browser access, so a queued provider flow is not mistaken for a hung command.
+
+Sessions share the same Chrome profile. Cookies, authentication, same-origin storage, downloads, history, bookmarks, and other profile state are shared. For hard isolation, use separate browser profiles/instances with separate native hosts and `SURF_SOCKET` values.
+
+### Explicit Tabs and Windows
+
+Session targeting is the recommended coordination mechanism. Explicit IDs and named tabs remain available for one-off work:
 
 ```bash
-SURF_SOCKET=/tmp/surf-agent-a.sock surf tab.list
-SURF_SOCKET=/tmp/surf-agent-b.sock surf tab.list
+surf window.new "https://example.com"
+surf read --tab-id 789
+surf click e5 --window-id 123456
+surf tab.name dashboard --tab-id 789
+surf tab.switch dashboard
 ```
 
-Surf does not yet provide `session.new`, session IDs, or independent per-agent CDP sessions.
-
 ### Device Emulation
 
 Test responsive designs and mobile layouts:
@@ -505,7 +526,7 @@ surf aistudio.build "game" --keep-open --timeout 600          # Keep tab open, 1
 
 #### Oracle
 
-Use `surf oracle` for a durable, local ChatGPT consult instead of a quick `surf chatgpt` one-shot. It persists jobs by conversation URL, supports repeatable file-context globs, and verifies requested model and reasoning effort before submission. ChatGPT model aliases include `instant`, `thinking`, `pro`, `gpt-5.5`, and `gpt-5.6-sol`.
+Use `surf oracle` for a durable, local ChatGPT consult instead of a quick `surf chatgpt` one-shot. It persists jobs by conversation URL, supports repeatable file-context globs, and verifies requested model and reasoning effort before submission. ChatGPT model aliases include `instant`, `thinking`, `pro`, `gpt-5.5`, and `gpt-5.6-sol`; `pro` selects the current ChatGPT GPT-5.6 Sol Pro web mode.
 
 ```bash
 surf oracle ask "review this change" --files "src/**/*.ts" --model gpt-5.5 --effort pro --detach --json
@@ -764,11 +785,13 @@ Generated manifests declare provenance and authentication environment inputs. Su
 ## Global Options
 
 ```bash
---tab-id <id>      # Target specific tab
---window-id <id>   # Target specific window (isolate agent from your browsing)
---json             # Output raw JSON
+--session <name>   # Target a durable browser session (or set SURF_SESSION)
+--tab-id <id>      # Target a specific tab
+--window-id <id>   # Target a specific window
+--no-wait          # Return tab_busy/browser_busy instead of queueing
+--json             # Raw JSON including resolved target metadata
 --soft-fail        # Warn instead of error (exit 0) on restricted pages
---no-lock          # Bypass the per-socket browser request lock
+--no-lock          # Bypass the legacy lock for compound client-side commands
 --no-screenshot    # Skip auto-screenshot after actions
 --full             # Full resolution screenshots (skip resize)
 ```
@@ -777,6 +800,8 @@ Generated manifests declare provenance and authentication environment inputs. Su
 
 ```bash
 SURF_NETWORK_PATH         # Native-host network state root (default: ~/.surf/state/network)
+SURF_STATE_DIR            # Private Surf state root, including browser sessions (default: ~/.surf/state)
+SURF_SESSION              # Default named browser session for tab-scoped commands
 SURF_SOCKET               # Socket path or named pipe (default: /tmp/surf.sock, Windows: //./pipe/surf)
 SURF_REMOTE               # Remote Surf endpoint as host:port (overrides SURF_SOCKET)
 SURF_REMOTE_CREDENTIAL    # Client Ed25519 credential for the selected remote endpoint
@@ -788,7 +813,9 @@ SURF_EXTENSION_PATH       # Path to extension dist/ directory
 ```
 
 **Use cases:**
-- `SURF_SOCKET`: Advanced socket override. Set it for both the native host and CLI if you need a non-default socket, including separate sockets for separate browser/profile instances in hard-isolated multi-agent workflows. Each socket gets an independent request lock.
+- `SURF_SESSION`: Per-shell default session. Give each independent agent a unique value and run `surf session.ensure "$SURF_SESSION" about:blank` before its first browser command.
+- `SURF_STATE_DIR`: Private mode-0700 state root for durable browser-session bindings and other Surf state.
+- `SURF_SOCKET`: Advanced socket override. Set it for both the native host and CLI when separate browser/profile instances need hard isolation.
 - `SURF_REMOTE`: Remote client endpoint. `--remote <host>:<port>` overrides it; both override `SURF_SOCKET`.
 - `SURF_REMOTE_CREDENTIAL`: Credential used for mutual remote authentication. `--remote-credential <path>` overrides it.
 - `SURF_REMOTE_STATE_DIR`: Advanced host-side override for the mode-0700 identity and client registry directory.
@@ -969,9 +996,11 @@ pi -e /path/to/surf-cli/pi-extension/surf.ts
 
 It registers `surf_read`, `surf_screenshot`, `surf_click`, `surf_type`, `surf_tool`, and the `surf_oracle_*` tools. Browser calls use Surf's native-host socket, not shell commands. If `pi-subagents/background-work` is installed, the extension also reports active oracle jobs started by that Pi session. Pi still loads the browser tools when pi-subagents is not installed.
 
-The extension also registers a `surf-oracle` external-job provider when a Pi runtime exposes that provider bridge. The provider has `start`, `status`, `result`, `reattach`, and `follow` operations. Each operation returns Surf job metadata with the durable conversation URL, requested and verified ChatGPT model and effort, prompt digest, result text when captured, and failure details when present. Capacity stays fail-closed: Surf returns the blocking job id instead of silently queueing a second ChatGPT job.
+The extension also registers a `surf-oracle` external-job provider when a Pi runtime exposes that provider bridge. The provider has `start`, `status`, `result`, `reattach`, and `follow` operations. It reads `options.model` and `options.effort` for starts and follows, so a Pi profile can request `model: pro` and reach the ChatGPT GPT-5.6 Sol Pro web mode through Surf. Each operation returns Surf job metadata with the durable conversation URL, requested and verified ChatGPT model and effort, prompt digest, result text when captured, and failure details when present. Capacity stays fail-closed: Surf returns the blocking job id instead of silently queueing a second ChatGPT job.
+
+When Surf is installed as a Pi package, it also exposes an optional `gpt-pro` package agent for `pi-subagents`. That profile uses `runner.type: external-job`, provider `surf-oracle`, and `options.model: pro`. Surf remains useful without Pi or `pi-subagents`; the package agent only wires Surf's browser-backed model alias into Pi's agent picker.
 
-Surf agents share one browser session. Use read tools for parallel scouts when possible. `surf_click` and `surf_type` can interfere with another agent's browser actions. Browser leases are not available yet.
+Shell-based agents should select a unique session with `SURF_SESSION` and call `surf session.ensure` before their first browser command. The optional Pi extension still uses its existing socket-tool interface; callers that coordinate several Pi workers should pass explicit tab targets until session selection is exposed by that integration.
 
 ## Development
 

package/agents/gpt-pro.md

@@ -0,0 +1,19 @@
+---
+name: gpt-pro
+description: Surf GPT Pro advisor through ChatGPT GPT-5.6 Sol Pro web mode
+runner:
+  type: external-job
+  provider: surf-oracle
+  options:
+    model: pro
+async: true
+systemPromptMode: replace
+inheritProjectContext: false
+inheritSkills: false
+---
+
+You are a read-only GPT Pro advisor reached through Surf Oracle.
+
+Review the supplied task and context.
+Return clear advice, risks, and recommended next steps.
+Do not claim you edited files or ran local tools.

package/native/browser-scheduler.cjs

@@ -0,0 +1,348 @@
+const { surfError } = require("./surf-error.cjs");
+
+const DEFAULT_MAX_QUEUED = 64;
+const DEFAULT_MAX_PER_LANE = 16;
+const DEFAULT_QUEUE_TIMEOUT_MS = 60000;
+const WRITE_SCOPES = new Set(["browser-write", "provider"]);
+
+function normalizeResourceKeys(resourceKeys) {
+  if (!Array.isArray(resourceKeys)) return [];
+  return [...new Set(resourceKeys.filter((key) => typeof key === "string" && key).map(String))].sort();
+}
+
+class BrowserScheduler {
+  constructor({
+    maxQueued = DEFAULT_MAX_QUEUED,
+    maxPerLane = DEFAULT_MAX_PER_LANE,
+    queueTimeoutMs = DEFAULT_QUEUE_TIMEOUT_MS,
+    audit = () => {},
+  } = {}) {
+    this.maxQueued = maxQueued;
+    this.maxPerLane = maxPerLane;
+    this.queueTimeoutMs = queueTimeoutMs;
+    this.audit = audit;
+    this.queue = [];
+    this.activeTabs = new Map();
+    this.activeReaders = new Set();
+    this.activeWriter = null;
+    this.activeResources = new Map();
+    this.sequence = 0;
+  }
+
+  acquire({ scope, laneKey, resourceKeys = [], wait = true, signal, request, session } = {}) {
+    const normalizedResources = normalizeResourceKeys(resourceKeys);
+    if (scope === "host" && normalizedResources.length === 0) {
+      return Promise.resolve(this.#token({
+        scope,
+        laneKey,
+        resourceKeys: normalizedResources,
+        request,
+        session,
+        queuedAt: Date.now(),
+      }));
+    }
+    if (scope === "tab" && !laneKey) {
+      return Promise.reject(surfError("target_required", "tab-scoped command requires a resolved tab"));
+    }
+    if (!scope || !["host", "tab", "browser-read", "browser-write", "provider"].includes(scope)) {
+      return Promise.reject(surfError("scheduler_scope_invalid", `invalid browser scheduler scope: ${scope}`));
+    }
+    if (signal?.aborted) return Promise.reject(signal.reason || surfError("request_cancelled", "Request cancelled"));
+
+    const entry = {
+      id: ++this.sequence,
+      scope,
+      laneKey,
+      resourceKeys: normalizedResources,
+      wait,
+      signal,
+      request,
+      session,
+      queuedAt: Date.now(),
+      resolve: null,
+      reject: null,
+      timer: null,
+      abortCleanup: null,
+    };
+
+    if (this.#canGrantImmediately(entry)) {
+      return Promise.resolve(this.#grant(entry));
+    }
+    if (!wait) {
+      const blockedResources = this.#blockedResourceKeys(entry);
+      if (blockedResources.length > 0) {
+        return Promise.reject(surfError("resource_busy", `shared resource is busy: ${blockedResources.join(", ")}`, {
+          laneKey,
+          session,
+          resourceKeys: blockedResources,
+          retryable: true,
+          queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+          recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+        }));
+      }
+      const browserBlocked = Boolean(this.activeWriter) || this.#hasQueuedWriter() || WRITE_SCOPES.has(scope);
+      const code = browserBlocked ? "browser_busy" : "tab_busy";
+      const message = browserBlocked
+        ? "a browser-wide writer is active or waiting"
+        : `tab lane is busy: ${laneKey}`;
+      return Promise.reject(surfError(code, message, {
+        laneKey,
+        session,
+        retryable: true,
+        queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+        recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+      }));
+    }
+    if (this.queue.length >= this.maxQueued) {
+      return Promise.reject(surfError("queue_full", "browser scheduler queue is full", { retryable: true }));
+    }
+    if (scope === "tab") {
+      const laneDepth = this.queue.filter((queued) => queued.scope === "tab" && queued.laneKey === laneKey).length;
+      if (laneDepth >= this.maxPerLane) {
+        return Promise.reject(surfError("queue_full", `tab lane queue is full: ${laneKey}`, {
+          laneKey,
+          retryable: true,
+        }));
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      entry.resolve = resolve;
+      entry.reject = reject;
+      entry.timer = setTimeout(() => {
+        this.#removeQueued(entry);
+        reject(surfError("queue_timeout", "timed out waiting for browser admission", {
+          laneKey,
+          session,
+          resourceKeys: normalizedResources,
+          retryable: true,
+          queue: this.stats({ laneKey, resourceKeys: normalizedResources }),
+          recoveryCommand: session ? `surf session.info ${session}` : "surf session.list --refresh",
+        }));
+        this.audit({
+          event: "scheduler",
+          outcome: "queue-timeout",
+          request,
+          scope,
+          laneKey,
+          resourceKeys: normalizedResources,
+        });
+        this.#drain();
+      }, this.queueTimeoutMs);
+      if (signal) {
+        const onAbort = () => {
+          if (!this.#removeQueued(entry)) return;
+          reject(signal.reason || surfError("request_cancelled", "Request cancelled"));
+          this.audit({
+            event: "scheduler",
+            outcome: "queue-cancel",
+            request,
+            scope,
+            laneKey,
+            resourceKeys: normalizedResources,
+          });
+          this.#drain();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        entry.abortCleanup = () => signal.removeEventListener("abort", onAbort);
+      }
+      this.queue.push(entry);
+      this.audit({
+        event: "scheduler",
+        outcome: "queued",
+        request,
+        scope,
+        laneKey,
+        resourceKeys: normalizedResources,
+        queueDepth: this.queue.length,
+      });
+      this.#drain();
+    });
+  }
+
+  stats({ laneKey, resourceKeys = [] } = {}) {
+    const queuedByLane = {};
+    for (const entry of this.queue) {
+      if (entry.scope !== "tab") continue;
+      queuedByLane[entry.laneKey] = (queuedByLane[entry.laneKey] || 0) + 1;
+    }
+    const writer = this.activeWriter
+      ? {
+          scope: this.activeWriter.scope,
+          session: this.activeWriter.session || null,
+          acquiredAt: this.activeWriter.acquiredAt,
+        }
+      : null;
+    const queuedWriters = this.queue.filter((entry) => WRITE_SCOPES.has(entry.scope));
+    const normalizedResources = normalizeResourceKeys(resourceKeys);
+    const activeResources = [...this.activeResources.entries()].map(([key, token]) => ({
+      key,
+      scope: token.scope,
+      laneKey: token.laneKey || null,
+      session: token.session || null,
+      acquiredAt: token.acquiredAt,
+    }));
+    return {
+      activeTabLanes: [...this.activeTabs.entries()].map(([key, token]) => ({
+        laneKey: key,
+        session: token.session || null,
+        acquiredAt: token.acquiredAt,
+      })),
+      activeReaders: this.activeReaders.size,
+      writerActive: Boolean(writer),
+      writer,
+      activeResources,
+      blockedResourceKeys: normalizedResources.filter((key) => this.activeResources.has(key)),
+      queued: this.queue.length,
+      queuedWriters: queuedWriters.length,
+      queuedWriterSessions: queuedWriters.map((entry) => entry.session || null),
+      queuedByLane,
+      lane: laneKey ? {
+        laneKey,
+        active: this.activeTabs.has(laneKey),
+        queued: queuedByLane[laneKey] || 0,
+        blockedBy: this.activeWriter || queuedWriters.length > 0
+          ? "browser-writer"
+          : this.activeTabs.has(laneKey)
+            ? "own-tab"
+            : null,
+      } : undefined,
+    };
+  }
+
+  #blockedResourceKeys(entry) {
+    return entry.resourceKeys.filter((key) => this.activeResources.has(key));
+  }
+
+  #hasQueuedWriter() {
+    return this.queue.some((entry) => WRITE_SCOPES.has(entry.scope));
+  }
+
+  #canGrantImmediately(entry) {
+    if (this.queue.length > 0) return false;
+    if (this.#blockedResourceKeys(entry).length > 0) return false;
+    if (entry.scope === "host") return true;
+    if (WRITE_SCOPES.has(entry.scope)) {
+      return !this.activeWriter && this.activeReaders.size === 0 && this.activeTabs.size === 0;
+    }
+    if (this.activeWriter || this.#hasQueuedWriter()) return false;
+    if (entry.scope === "browser-read") return true;
+    return !this.activeTabs.has(entry.laneKey);
+  }
+
+  #grant(entry) {
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.abortCleanup?.();
+    const token = this.#token(entry);
+    if (WRITE_SCOPES.has(entry.scope)) this.activeWriter = token;
+    else if (entry.scope === "browser-read") this.activeReaders.add(token);
+    else if (entry.scope === "tab") this.activeTabs.set(entry.laneKey, token);
+    for (const key of entry.resourceKeys) this.activeResources.set(key, token);
+    this.audit({
+      event: "scheduler",
+      outcome: "acquired",
+      request: entry.request,
+      scope: entry.scope,
+      laneKey: entry.laneKey,
+      resourceKeys: entry.resourceKeys,
+      queueMs: Date.now() - entry.queuedAt,
+    });
+    return token;
+  }
+
+  #token(entry) {
+    let released = false;
+    const token = {
+      scope: entry.scope,
+      laneKey: entry.laneKey,
+      resourceKeys: entry.resourceKeys,
+      session: entry.session,
+      queuedAt: entry.queuedAt,
+      acquiredAt: Date.now(),
+      release: () => {
+        if (released) return;
+        released = true;
+        if (WRITE_SCOPES.has(entry.scope)) {
+          if (this.activeWriter === token) this.activeWriter = null;
+        } else if (entry.scope === "browser-read") this.activeReaders.delete(token);
+        else if (entry.scope === "tab" && this.activeTabs.get(entry.laneKey) === token) {
+          this.activeTabs.delete(entry.laneKey);
+        }
+        for (const key of entry.resourceKeys) {
+          if (this.activeResources.get(key) === token) this.activeResources.delete(key);
+        }
+        this.audit({
+          event: "scheduler",
+          outcome: "released",
+          request: entry.request,
+          scope: entry.scope,
+          laneKey: entry.laneKey,
+          resourceKeys: entry.resourceKeys,
+          session: entry.session,
+        });
+        this.#drain();
+      },
+    };
+    return token;
+  }
+
+  #removeQueued(entry) {
+    const index = this.queue.indexOf(entry);
+    if (index === -1) return false;
+    this.queue.splice(index, 1);
+    if (entry.timer) clearTimeout(entry.timer);
+    entry.abortCleanup?.();
+    return true;
+  }
+
+  #drain() {
+    for (let index = 0; index < this.queue.length;) {
+      const entry = this.queue[index];
+      if (entry.scope !== "host" || this.#blockedResourceKeys(entry).length > 0) {
+        index += 1;
+        continue;
+      }
+      this.queue.splice(index, 1);
+      entry.resolve(this.#grant(entry));
+    }
+
+    if (this.activeWriter) return;
+    const writerIndex = this.queue.findIndex((entry) => WRITE_SCOPES.has(entry.scope));
+    if (writerIndex !== -1) {
+      const writer = this.queue[writerIndex];
+      if (
+        this.activeReaders.size > 0 ||
+        this.activeTabs.size > 0 ||
+        this.#blockedResourceKeys(writer).length > 0
+      ) return;
+      this.queue.splice(writerIndex, 1);
+      writer.resolve(this.#grant(writer));
+      return;
+    }
+
+    for (let index = 0; index < this.queue.length;) {
+      const entry = this.queue[index];
+      if (this.#blockedResourceKeys(entry).length > 0) {
+        index += 1;
+        continue;
+      }
+      let grant = false;
+      if (entry.scope === "browser-read") grant = true;
+      else if (entry.scope === "tab") grant = !this.activeTabs.has(entry.laneKey);
+      if (!grant) {
+        index += 1;
+        continue;
+      }
+      this.queue.splice(index, 1);
+      entry.resolve(this.#grant(entry));
+    }
+  }
+}
+
+module.exports = {
+  BrowserScheduler,
+  DEFAULT_MAX_PER_LANE,
+  DEFAULT_MAX_QUEUED,
+  DEFAULT_QUEUE_TIMEOUT_MS,
+  normalizeResourceKeys,
+};