@opencode/browse 0.0.6-dev.19 → 0.0.6-dev.21

package/dist/{main-8a245rm1.mjs → main-qm2keaeb.mjs}

@@ -1,22 +1,28 @@
 import {
-  cliCommand,
-  installCommand,
-  npmRuntime,
   unpackedExtensionId,
   extensionReconnectAlarmPeriodMs,
   extensionProtocolAdvice,
   parseJsonObject
-} from "./main-yd50d95g.mjs";
+} from "./main-3gthmkzw.mjs";
 import {
   relayAuthorization
-} from "./main-75rdz6bc.mjs";
+} from "./main-7qs0mwvc.mjs";
 import {
   opencodeBrowserBuildId2
-} from "./main-ts9jjqs8.mjs";
+} from "./main-ek76h9k1.mjs";
+import {
+  compiledBinary,
+  scriptEntry,
+  cliCommand,
+  installCommand,
+  npmRuntime
+} from "./main-0m569gdn.mjs";
 
 // src/relay/helpers.ts
-import crypto from "node:crypto";
-import { Effect, Option, Predicate, Schema as Schema2 } from "effect";
+import { Option, Predicate, Schema as Schema3 } from "effect";
+
+// src/relay/http.ts
+import { Effect, Schema as Schema2 } from "effect";
 
 // src/relay/schema.ts
 import { Schema } from "effect";
@@ -524,37 +530,7 @@ var ErrorEnvelope = Schema.Struct({
   code: Schema.optionalKey(RelayErrorCode)
 });
 
-// src/relay/helpers.ts
-var defaultHost2 = "127.0.0.1";
-var defaultPort2 = 19988;
-var stableUnpackedExtensionOrigin2 = `chrome-extension://${unpackedExtensionId}`;
-function chromeExtensionOriginForPath2(extensionPath, platform = process.platform) {
-  const normalizedPath = platform === "win32" && /^[a-z]:/.test(extensionPath) ? extensionPath.charAt(0).toUpperCase() + extensionPath.slice(1) : extensionPath;
-  const pathBytes = platform === "win32" ? Buffer.from(normalizedPath, "utf16le") : normalizedPath;
-  const digest = crypto.createHash("sha256").update(pathBytes).digest();
-  let extensionId = "";
-  for (const byte of digest.subarray(0, 16)) {
-    extensionId += String.fromCharCode(97 + (byte >> 4), 97 + (byte & 15));
-  }
-  return `chrome-extension://${extensionId}`;
-}
-var chromeExtensionOriginPattern = /^chrome-extension:\/\/[a-p]+$/;
-function parseAdditionalExtensionOrigins2(raw) {
-  if (!raw) {
-    return [];
-  }
-  const seen = new Set;
-  const origins = [];
-  for (const token of raw.split(/[\s,]+/)) {
-    const value = token.trim();
-    if (!value || !chromeExtensionOriginPattern.test(value) || seen.has(value)) {
-      continue;
-    }
-    seen.add(value);
-    origins.push(value);
-  }
-  return origins;
-}
+// src/relay/http.ts
 var maxCliBodyBytes = 1e6;
 
 class HttpRouteError2 extends Schema2.TaggedError()("HttpApi.HttpRouteError", { message: Schema2.String, status: Schema2.Number, code: RelayErrorCode }) {
@@ -565,98 +541,6 @@ function formatHostForUrl2(host) {
   }
   return host;
 }
-function validateHostHeader2(options) {
-  const parsed = parseHostHeader(options.hostHeader);
-  if (!parsed) {
-    return "Invalid Host header";
-  }
-  if (parsed.port !== undefined && parsed.port !== options.port) {
-    return "Invalid Host header port";
-  }
-  const allowedHosts = new Set(["localhost", "127.0.0.1", "::1", normalizeHostname(options.host)]);
-  if (!allowedHosts.has(parsed.hostname)) {
-    return "Invalid Host header";
-  }
-  return;
-}
-function validateBrowserFetchSite2(request) {
-  const secFetchSite = request.headers["sec-fetch-site"];
-  const value = Array.isArray(secFetchSite) ? secFetchSite[0] : secFetchSite;
-  if (!value || value === "same-origin" || value === "none") {
-    return;
-  }
-  return "Cross-origin browser requests are not allowed";
-}
-function validateWebSocketOrigin2(options) {
-  if (!options.origin) {
-    return options.requireChromeExtension ? "Extension WebSocket origin is required" : undefined;
-  }
-  if (options.origin === stableUnpackedExtensionOrigin2 || options.additionalChromeExtensionOrigins?.has(options.origin)) {
-    return;
-  }
-  if (options.requireChromeExtension) {
-    return "Extension WebSocket origin is not allowed";
-  }
-  return "WebSocket origin is not allowed";
-}
-function normalizeHostname(host) {
-  const value = host.trim().toLowerCase();
-  if (value.startsWith("[") && value.endsWith("]")) {
-    return value.slice(1, -1);
-  }
-  return value;
-}
-function parseHostHeader(hostHeader) {
-  const value = hostHeader?.trim().toLowerCase();
-  if (!value) {
-    return;
-  }
-  if (value.startsWith("[")) {
-    const closingBracket = value.indexOf("]");
-    if (closingBracket === -1) {
-      return;
-    }
-    const hostname = value.slice(1, closingBracket);
-    const rest = value.slice(closingBracket + 1);
-    if (!hostname) {
-      return;
-    }
-    if (!rest) {
-      return { hostname };
-    }
-    if (!rest.startsWith(":")) {
-      return;
-    }
-    const port = parsePort(rest.slice(1));
-    return port === undefined ? undefined : { hostname, port };
-  }
-  if (value === "::1") {
-    return { hostname: "::1" };
-  }
-  const colonCount = value.split(":").length - 1;
-  if (colonCount > 1) {
-    return;
-  }
-  if (colonCount === 0) {
-    return { hostname: value };
-  }
-  const [hostname, portText] = value.split(":");
-  if (!hostname || portText === undefined) {
-    return;
-  }
-  const port = parsePort(portText);
-  return port === undefined ? undefined : { hostname, port };
-}
-function parsePort(value) {
-  if (!/^\d+$/.test(value)) {
-    return;
-  }
-  const port = Number(value);
-  if (!Number.isInteger(port) || port < 1 || port > 65535) {
-    return;
-  }
-  return port;
-}
 function listenHttpServer2(options) {
   return Effect.callback((resume) => {
     const onError = (error) => {
@@ -791,22 +675,149 @@ function readJsonBody2(request) {
     });
   });
 }
-var RawTargetSelection = Schema2.Struct({
-  urlIncludes: Schema2.optionalKey(Schema2.String),
-  index: Schema2.optionalKey(Schema2.Int.check(Schema2.isGreaterThanOrEqualTo(0)))
+
+// src/relay/origins.ts
+import crypto from "node:crypto";
+var stableUnpackedExtensionOrigin2 = `chrome-extension://${unpackedExtensionId}`;
+function chromeExtensionOriginForPath2(extensionPath, platform = process.platform) {
+  const normalizedPath = platform === "win32" && /^[a-z]:/.test(extensionPath) ? extensionPath.charAt(0).toUpperCase() + extensionPath.slice(1) : extensionPath;
+  const pathBytes = platform === "win32" ? Buffer.from(normalizedPath, "utf16le") : normalizedPath;
+  const digest = crypto.createHash("sha256").update(pathBytes).digest();
+  let extensionId = "";
+  for (const byte of digest.subarray(0, 16)) {
+    extensionId += String.fromCharCode(97 + (byte >> 4), 97 + (byte & 15));
+  }
+  return `chrome-extension://${extensionId}`;
+}
+var chromeExtensionOriginPattern = /^chrome-extension:\/\/[a-p]+$/;
+function parseAdditionalExtensionOrigins2(raw) {
+  if (!raw) {
+    return [];
+  }
+  const seen = new Set;
+  const origins = [];
+  for (const token of raw.split(/[\s,]+/)) {
+    const value = token.trim();
+    if (!value || !chromeExtensionOriginPattern.test(value) || seen.has(value)) {
+      continue;
+    }
+    seen.add(value);
+    origins.push(value);
+  }
+  return origins;
+}
+function validateHostHeader2(options) {
+  const parsed = parseHostHeader(options.hostHeader);
+  if (!parsed) {
+    return "Invalid Host header";
+  }
+  if (parsed.port !== undefined && parsed.port !== options.port) {
+    return "Invalid Host header port";
+  }
+  const allowedHosts = new Set(["localhost", "127.0.0.1", "::1", normalizeHostname(options.host)]);
+  if (!allowedHosts.has(parsed.hostname)) {
+    return "Invalid Host header";
+  }
+  return;
+}
+function validateBrowserFetchSite2(request) {
+  const secFetchSite = request.headers["sec-fetch-site"];
+  const value = Array.isArray(secFetchSite) ? secFetchSite[0] : secFetchSite;
+  if (!value || value === "same-origin" || value === "none") {
+    return;
+  }
+  return "Cross-origin browser requests are not allowed";
+}
+function validateWebSocketOrigin2(options) {
+  if (!options.origin) {
+    return options.requireChromeExtension ? "Extension WebSocket origin is required" : undefined;
+  }
+  if (options.origin === stableUnpackedExtensionOrigin2 || options.additionalChromeExtensionOrigins?.has(options.origin)) {
+    return;
+  }
+  if (options.requireChromeExtension) {
+    return "Extension WebSocket origin is not allowed";
+  }
+  return "WebSocket origin is not allowed";
+}
+function normalizeHostname(host) {
+  const value = host.trim().toLowerCase();
+  if (value.startsWith("[") && value.endsWith("]")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseHostHeader(hostHeader) {
+  const value = hostHeader?.trim().toLowerCase();
+  if (!value) {
+    return;
+  }
+  if (value.startsWith("[")) {
+    const closingBracket = value.indexOf("]");
+    if (closingBracket === -1) {
+      return;
+    }
+    const hostname = value.slice(1, closingBracket);
+    const rest = value.slice(closingBracket + 1);
+    if (!hostname) {
+      return;
+    }
+    if (!rest) {
+      return { hostname };
+    }
+    if (!rest.startsWith(":")) {
+      return;
+    }
+    const port = parsePort(rest.slice(1));
+    return port === undefined ? undefined : { hostname, port };
+  }
+  if (value === "::1") {
+    return { hostname: "::1" };
+  }
+  const colonCount = value.split(":").length - 1;
+  if (colonCount > 1) {
+    return;
+  }
+  if (colonCount === 0) {
+    return { hostname: value };
+  }
+  const [hostname, portText] = value.split(":");
+  if (!hostname || portText === undefined) {
+    return;
+  }
+  const port = parsePort(portText);
+  return port === undefined ? undefined : { hostname, port };
+}
+function parsePort(value) {
+  if (!/^\d+$/.test(value)) {
+    return;
+  }
+  const port = Number(value);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    return;
+  }
+  return port;
+}
+
+// src/relay/helpers.ts
+var defaultHost2 = "127.0.0.1";
+var defaultPort2 = 19988;
+var RawTargetSelection = Schema3.Struct({
+  urlIncludes: Schema3.optionalKey(Schema3.String),
+  index: Schema3.optionalKey(Schema3.Int.check(Schema3.isGreaterThanOrEqualTo(0)))
 });
-var decodeRawTargetSelection = Schema2.decodeUnknownOption(RawTargetSelection);
-var RawTargetInfo = Schema2.Struct({
-  targetId: Schema2.String,
-  type: Schema2.Literals(["page", "iframe", "worker"]),
-  title: Schema2.optionalKey(Schema2.String),
-  url: Schema2.String,
-  canAccessOpener: Schema2.optionalKey(Schema2.Boolean),
-  browserContextId: Schema2.optionalKey(Schema2.String),
-  openerId: Schema2.optionalKey(Schema2.String),
-  parentFrameId: Schema2.optionalKey(Schema2.String)
+var decodeRawTargetSelection = Schema3.decodeUnknownOption(RawTargetSelection);
+var RawTargetInfo = Schema3.Struct({
+  targetId: Schema3.String,
+  type: Schema3.Literals(["page", "iframe", "worker"]),
+  title: Schema3.optionalKey(Schema3.String),
+  url: Schema3.String,
+  canAccessOpener: Schema3.optionalKey(Schema3.Boolean),
+  browserContextId: Schema3.optionalKey(Schema3.String),
+  openerId: Schema3.optionalKey(Schema3.String),
+  parentFrameId: Schema3.optionalKey(Schema3.String)
 });
-var decodeRawTargetInfo = Schema2.decodeUnknownOption(RawTargetInfo);
+var decodeRawTargetInfo = Schema3.decodeUnknownOption(RawTargetInfo);
 function optionalSessionId2(value) {
   if (!Predicate.isString(value) || !value.trim()) {
     return;
@@ -947,7 +958,7 @@ async function dataUrlDocument2(url) {
 }
 
 // src/relay/lifecycle.ts
-import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema4 } from "effect";
+import { Config as Config2, Effect as Effect3, Result, Schedule, Schema as Schema5 } from "effect";
 import { spawn } from "node:child_process";
 import crypto2 from "node:crypto";
 import path from "node:path";
@@ -956,52 +967,52 @@ import { fileURLToPath } from "node:url";
 
 // src/relay/client.ts
 import { NodeHttpClient } from "@effect/platform-node";
-import { Config, Context, Effect as Effect2, Layer, Option as Option2, Schema as Schema3 } from "effect";
+import { Config, Context, Effect as Effect2, Layer, Option as Option2, Schema as Schema4 } from "effect";
 import { HttpClient, HttpClientRequest } from "effect/http";
 var portConfig = Config.Int("OPENCODE_BROWSER_PORT").pipe(Config.withDefault(defaultPort2));
 var extensionOriginsConfig = Config.String("OPENCODE_BROWSER_EXTENSION_ORIGINS").pipe(Config.withDefault(""));
 var endpointForPort = (port) => `http://127.0.0.1:${port}`;
 
-class RelayUnreachable extends Schema3.TaggedError()("RelayClient.RelayUnreachable", {
-  message: Schema3.String,
-  endpoint: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayUnreachable extends Schema4.TaggedError()("RelayClient.RelayUnreachable", {
+  message: Schema4.String,
+  endpoint: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayRejected extends Schema3.TaggedError()("RelayClient.RelayRejected", {
-  message: Schema3.String,
-  status: Schema3.Number,
-  path: Schema3.String,
-  code: Schema3.optionalKey(RelayErrorCode)
+class RelayRejected extends Schema4.TaggedError()("RelayClient.RelayRejected", {
+  message: Schema4.String,
+  status: Schema4.Number,
+  path: Schema4.String,
+  code: Schema4.optionalKey(RelayErrorCode)
 }) {
 }
 
-class RelayDecodeFailed extends Schema3.TaggedError()("RelayClient.RelayDecodeFailed", {
-  message: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayDecodeFailed extends Schema4.TaggedError()("RelayClient.RelayDecodeFailed", {
+  message: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayEncodeFailed extends Schema3.TaggedError()("RelayClient.RelayEncodeFailed", {
-  message: Schema3.String,
-  path: Schema3.String,
-  cause: Schema3.Defect()
+class RelayEncodeFailed extends Schema4.TaggedError()("RelayClient.RelayEncodeFailed", {
+  message: Schema4.String,
+  path: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
-class RelayConfigInvalid extends Schema3.TaggedError()("RelayClient.RelayConfigInvalid", {
-  message: Schema3.String,
-  cause: Schema3.Defect()
+class RelayConfigInvalid extends Schema4.TaggedError()("RelayClient.RelayConfigInvalid", {
+  message: Schema4.String,
+  cause: Schema4.Defect()
 }) {
 }
 
 class Service extends Context.Service()("opencode-browser-cli/RelayClient") {
 }
-var decodeErrorEnvelope = Schema3.decodeUnknownOption(ErrorEnvelope);
-var decodeErrorMessage = Schema3.decodeUnknownOption(Schema3.Struct({ error: Schema3.String }));
+var decodeErrorEnvelope = Schema4.decodeUnknownOption(ErrorEnvelope);
+var decodeErrorMessage = Schema4.decodeUnknownOption(Schema4.Struct({ error: Schema4.String }));
 var make = Effect2.fn("RelayClient.make")(function* (options) {
   const port = yield* portConfig.pipe(Effect2.mapError((cause) => new RelayConfigInvalid({
     message: `Invalid OPENCODE_BROWSER_PORT configuration: ${cause.message}`,
@@ -1025,14 +1036,14 @@ var make = Effect2.fn("RelayClient.make")(function* (options) {
         ...Option2.isSome(envelope) && envelope.value.code ? { code: envelope.value.code } : {}
       }));
     }
-    return Schema3.decodeUnknownEffect(schema)(body).pipe(Effect2.mapError((cause) => new RelayDecodeFailed({
+    return Schema4.decodeUnknownEffect(schema)(body).pipe(Effect2.mapError((cause) => new RelayDecodeFailed({
       message: `Relay response for ${path} did not match the expected shape: ${cause.message}`,
       path,
       cause
     })));
   }));
   const transportError = (path) => (cause) => new RelayUnreachable({
-    message: `Browse relay is not reachable at ${endpoint}. Relay-backed CLI commands start it automatically; use \`${cliCommand("serve")}\` only for foreground debugging.`,
+    message: `browse relay is not reachable at ${endpoint}. Relay-backed CLI commands start it automatically; use \`${cliCommand("serve")}\` only for foreground debugging.`,
     endpoint,
     path,
     cause
@@ -1127,7 +1138,7 @@ function mcpClientPid() {
 var layerFetchMcp = Layer.effect(Service, make({ clientPid: mcpClientPid() })).pipe(Layer.provide(NodeHttpClient.layerNodeHttp));
 
 // src/relay/lifecycle.ts
-var loadedCliEntrypoint = fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../main.ts" : "./cli.mjs", import.meta.url));
+var loadedCliEntrypoint = compiledBinary() ? process2.execPath : fileURLToPath(new URL(import.meta.url.endsWith(".ts") ? "../main.ts" : "./cli.mjs", import.meta.url));
 var clientInstanceId = crypto2.randomUUID();
 function shouldWaitForExtensionReconnect(readiness) {
   return readiness.started || readiness.waitForReconnect === true;
@@ -1136,19 +1147,19 @@ function shouldWaitForExtensionReconnect(readiness) {
 class RelayStillRunning extends Error {
 }
 
-class RelayStartFailed extends Schema4.TaggedError()("RelayLifecycle.RelayStartFailed", {
-  message: Schema4.String,
-  endpoint: Schema4.String,
-  cause: Schema4.Defect()
+class RelayStartFailed extends Schema5.TaggedError()("RelayLifecycle.RelayStartFailed", {
+  message: Schema5.String,
+  endpoint: Schema5.String,
+  cause: Schema5.Defect()
 }) {
 }
 
-class ExtensionDisconnected extends Schema4.TaggedError()("RelayLifecycle.ExtensionDisconnected", { message: Schema4.String, needsPairing: Schema4.optionalKey(Schema4.Boolean) }) {
+class ExtensionDisconnected extends Schema5.TaggedError()("RelayLifecycle.ExtensionDisconnected", { message: Schema5.String, needsPairing: Schema5.optionalKey(Schema5.Boolean) }) {
 }
 
-class ExtensionProtocolIncompatible extends Schema4.TaggedError()("RelayLifecycle.ExtensionProtocolIncompatible", {
-  message: Schema4.String,
-  protocolVersion: Schema4.NullOr(Schema4.Number)
+class ExtensionProtocolIncompatible extends Schema5.TaggedError()("RelayLifecycle.ExtensionProtocolIncompatible", {
+  message: Schema5.String,
+  protocolVersion: Schema5.NullOr(Schema5.Number)
 }) {
 }
 function supersededRuntime() {
@@ -1205,7 +1216,7 @@ function waitForRelayReady(options) {
     schedule: Schedule.spaced(options.retryDelayMs ?? 50),
     while: isRelayStartingOrUnreachable
   }), Effect3.mapError((error) => isRelayStartingOrUnreachable(error) ? new RelayStartFailed({
-    message: `Browse relay did not start at ${options.relay.endpoint}`,
+    message: `browse relay did not start at ${options.relay.endpoint}`,
     endpoint: options.relay.endpoint,
     cause: error
   }) : error));
@@ -1278,7 +1289,7 @@ var restartRelay = Effect3.fn("RelayLifecycle.restartRelay")(function* (options)
   return { version: replacement, started, waitForReconnect: true };
 });
 function waitForRelayExitOrReplacement(options) {
-  return options.relay.version.pipe(Effect3.flatMap((version) => isSameRelayInstance(options.version, version) ? Effect3.fail(new RelayStillRunning("Browse relay is still draining; no replacement was started")) : Effect3.succeed(version)), Effect3.catch((error) => isRelayUnreachable(error) ? Effect3.succeed(undefined) : Effect3.fail(error)), Effect3.retry({
+  return options.relay.version.pipe(Effect3.flatMap((version) => isSameRelayInstance(options.version, version) ? Effect3.fail(new RelayStillRunning("browse relay is still draining; no replacement was started")) : Effect3.succeed(version)), Effect3.catch((error) => isRelayUnreachable(error) ? Effect3.succeed(undefined) : Effect3.fail(error)), Effect3.retry({
     times: options.retryTimes ?? 200,
     schedule: Schedule.spaced(options.retryDelayMs ?? 50),
     while: (error) => error instanceof RelayStillRunning || isRelayStarting(error)
@@ -1311,7 +1322,7 @@ var ensureExtensionConnected = Effect3.fn("RelayLifecycle.ensureExtensionConnect
       }));
     }
     return status.connected ? Effect3.succeed(status) : Effect3.fail(new ExtensionDisconnected({
-      message: status.nextStep ?? `Browse extension is not connected. Open the browser with Browse installed (\`${installCommand()}\`); it reconnects automatically after relay or browser startup.`,
+      message: status.nextStep ?? `browse extension is not connected. Open the browser with browse installed (\`${installCommand()}\`); it reconnects automatically after relay or browser startup.`,
       needsPairing: status.pairingState === "refused" || status.pairingState === "unpaired"
     }));
   }));
@@ -1351,7 +1362,7 @@ function startManagedRelay(entrypoint = loadedCliEntrypoint, executable = proces
       });
       child.unref();
     },
-    catch: (cause) => cause instanceof Error ? cause : new Error("Failed to start Browse relay", { cause })
+    catch: (cause) => cause instanceof Error ? cause : new Error("Failed to start browse relay", { cause })
   });
 }
 var relayEnvironmentNames = new Set([
@@ -1403,6 +1414,8 @@ function relayEnvironment(env) {
   }));
 }
 function managedRelayLaunch(entrypoint = loadedCliEntrypoint, executable = process2.execPath, execArgv = process2.execArgv) {
+  if (!scriptEntry(entrypoint))
+    return { executable: entrypoint, args: ["serve"] };
   return {
     executable,
     args: [...execArgv, managedRelayEntrypoint(entrypoint), "serve"]
@@ -1424,4 +1437,4 @@ function isRelayStartingOrUnreachable(error) {
   return isRelayStarting(error) || isRelayUnreachable(error);
 }
 
-export { ExecuteRequest, SessionAdoptRequest, SessionNewRequest, SessionEnsureRequest, SessionIdRequest, SessionAllowlistRequest, AuthenticatedJsonRequest, AuthenticatedJsonOutcome, RelayShutdownRequest, NetworkStartRequest, NetworkSessionRequest, NetworkStopRequest, DeadboltLoginsRequest, AuthProfileRequest, AuthRefreshRequest, AuthRunRequest, RecordingTargetRequest, RecordingStartRequest, FlightRecorderStartRequest, FlightRecorderSaveRequest, defaultHost2, defaultPort2, stableUnpackedExtensionOrigin2, chromeExtensionOriginForPath2, parseAdditionalExtensionOrigins2, HttpRouteError2, formatHostForUrl2, validateHostHeader2, validateBrowserFetchSite2, validateWebSocketOrigin2, listenHttpServer2, closeHttpServer2, closeWebSocketServer2, logCloseError2, sendJson2, readJsonBody2, optionalSessionId2, isValidSessionId2, requiredSessionId2, parseTargetSelection2, generateSessionId2, sendCdpResponse2, sendCdpEvent2, getObject2, getString2, getNumber2, getIdText2, headerValue2, getTargetInfo2, isRestrictedTarget2, isRestrictedUrl2, dataUrlDocument2, portConfig, extensionOriginsConfig, endpointForPort, RelayUnreachable, RelayRejected, Service, layerFetch, layerFetchMcp, shouldWaitForExtensionReconnect, relayBuildProblem, ensureRelay, restartRelay, extensionReconnectWaitMs, ensureExtensionConnected, stoppedRelayStatus, statusCollections, startManagedRelay };
+export { ExecuteRequest, SessionAdoptRequest, SessionNewRequest, SessionEnsureRequest, SessionIdRequest, SessionAllowlistRequest, AuthenticatedJsonRequest, AuthenticatedJsonOutcome, RelayShutdownRequest, NetworkStartRequest, NetworkSessionRequest, NetworkStopRequest, DeadboltLoginsRequest, AuthProfileRequest, AuthRefreshRequest, AuthRunRequest, RecordingTargetRequest, RecordingStartRequest, FlightRecorderStartRequest, FlightRecorderSaveRequest, HttpRouteError2, formatHostForUrl2, listenHttpServer2, closeHttpServer2, closeWebSocketServer2, logCloseError2, sendJson2, readJsonBody2, stableUnpackedExtensionOrigin2, chromeExtensionOriginForPath2, parseAdditionalExtensionOrigins2, validateHostHeader2, validateBrowserFetchSite2, validateWebSocketOrigin2, defaultHost2, defaultPort2, optionalSessionId2, isValidSessionId2, requiredSessionId2, parseTargetSelection2, generateSessionId2, sendCdpResponse2, sendCdpEvent2, getObject2, getString2, getNumber2, getIdText2, headerValue2, getTargetInfo2, isRestrictedTarget2, isRestrictedUrl2, dataUrlDocument2, portConfig, extensionOriginsConfig, endpointForPort, RelayUnreachable, RelayRejected, Service, layerFetch, layerFetchMcp, shouldWaitForExtensionReconnect, relayBuildProblem, ensureRelay, restartRelay, extensionReconnectWaitMs, ensureExtensionConnected, stoppedRelayStatus, statusCollections, startManagedRelay };

package/dist/{main-knahxbey.mjs → main-ybvatjk0.mjs}

@@ -1,12 +1,12 @@
 import {
   isNodeError
-} from "./main-75rdz6bc.mjs";
-import {
-  dataRoot
-} from "./main-yd50d95g.mjs";
+} from "./main-7qs0mwvc.mjs";
 import {
   isValidSessionId2
-} from "./main-8a245rm1.mjs";
+} from "./main-qm2keaeb.mjs";
+import {
+  dataRoot
+} from "./main-0m569gdn.mjs";
 
 // src/session-manager/journal.ts
 import fs from "node:fs";

package/dist/{main-90enpn5q.mjs → main-yq58hnwq.mjs}

@@ -1,16 +1,16 @@
-import {
-  dataRoot,
-  cliCommand
-} from "./main-yd50d95g.mjs";
 import {
   parseTargetSelection2,
   getObject2,
   getString2
-} from "./main-8a245rm1.mjs";
+} from "./main-qm2keaeb.mjs";
 import {
   isNodeError,
   writeJsonFileAtomically
-} from "./main-75rdz6bc.mjs";
+} from "./main-7qs0mwvc.mjs";
+import {
+  dataRoot,
+  cliCommand
+} from "./main-0m569gdn.mjs";
 
 // src/relay/user-settings.ts
 var settingKeys = ["window", "grouping", "idleMinutes", "cursor", "humanInput", "handoffNotifications", "autoUpdate"];
@@ -145,7 +145,7 @@ function browsersNote2(browsers) {
   return ` Connected browsers: ${list}. Pass browser to use one other than the default.`;
 }
 function mcpUpdateNote2(notice) {
-  return `Note: Browse has an update: ${notice.summary}. Tell the user they can run \`${notice.command}\` and then restart opencode, or ask you to run it for them.`;
+  return `Note: browse has an update: ${notice.summary}. Tell the user they can run \`${notice.command}\` and then restart opencode, or ask you to run it for them.`;
 }
 function objectSchema(properties, required = []) {
   return {
@@ -410,7 +410,7 @@ function errorCode(code) {
 }
 var errorHints = {
   locked: "Deadbolt is locked, so agent sign-ins are paused until the user unlocks it.",
-  forbidden: "Deadbolt doesn't know this Browse install (its client was removed or revoked). Ask the user to run `opencode-browser deadbolt connect`.",
+  forbidden: "Deadbolt doesn't know this browse install (its client was removed or revoked). Ask the user to run `opencode-browser deadbolt connect`.",
   rate_limited: "Deadbolt is rate-limiting this client; wait before trying again."
 };
 function rawRequest(socket, request, timeoutMs = requestTimeoutMs) {
@@ -502,7 +502,7 @@ function toLogin(raw) {
 function connect(options = {}) {
   const client = options.client ?? readClient(options.root);
   if (!client) {
-    throw new DeadboltError("not_connected", "Browse isn't connected to Deadbolt. Ask the user to run `opencode-browser deadbolt connect` and to allow the logins agents may use with `deadbolt agents allow <site>`.");
+    throw new DeadboltError("not_connected", "browse isn't connected to Deadbolt. Ask the user to run `opencode-browser deadbolt connect` and to allow the logins agents may use with `deadbolt agents allow <site>`.");
   }
   const socket = options.socket ?? socketPath();
   let protocol;
@@ -604,7 +604,7 @@ function pickLogin(logins, site, username, field) {
   if (candidates.length === 1)
     return candidates[0];
   if (candidates.length === 0) {
-    throw new DeadboltError("not_granted", username === undefined ? `No Deadbolt login is granted to Browse for ${site}${field ? ` (${field})` : ""}. Ask the user to allow one with \`deadbolt agents allow ${site}\`.` : `No Deadbolt login for ${username} is granted to Browse for ${site}${field ? ` (${field})` : ""}. Ask the user to allow it with \`deadbolt agents allow ${site} --login ${username}\`.`, { site, ...username ? { login: username } : {} });
+    throw new DeadboltError("not_granted", username === undefined ? `No Deadbolt login is granted to browse for ${site}${field ? ` (${field})` : ""}. Ask the user to allow one with \`deadbolt agents allow ${site}\`.` : `No Deadbolt login for ${username} is granted to browse for ${site}${field ? ` (${field})` : ""}. Ask the user to allow it with \`deadbolt agents allow ${site} --login ${username}\`.`, { site, ...username ? { login: username } : {} });
   }
   throw new DeadboltError("failed", `Several Deadbolt logins are granted for ${site}; name one: deadbolt:${site}/<username> (${candidates.map((login) => login.username ?? login.title).join(", ")})`);
 }