@opencode/browse 0.0.6-dev.27 → 0.0.6-dev.32

package/dist/{main-cxrsjs2z.mjs → main-q641ckf5.mjs}

@@ -2,16 +2,1340 @@ import {
   parseTargetSelection2,
   getObject2,
   getString2
-} from "./main-xzc7qp1c.mjs";
+} from "./main-aqzas8ts.mjs";
 import {
   isNodeError,
   writeJsonFileAtomically
-} from "./main-bq8az9yr.mjs";
+} from "./main-30dkfffj.mjs";
+import {
+  getStackTraceLimit,
+  setStackTraceLimit,
+  withFiber,
+  none,
+  some,
+  isSome,
+  fromUndefinedOr,
+  flatMap,
+  Service2,
+  makeUnsafe2,
+  empty,
+  make4,
+  add,
+  getOrUndefinedUnsafe,
+  merge,
+  TaggedError,
+  getCurrentFiber,
+  succeed2,
+  sync,
+  suspend,
+  succeedNone,
+  void_,
+  callback,
+  asSome,
+  flatMap2,
+  onExitPrimitive,
+  uninterruptibleMask,
+  effectContext,
+  StackTrace,
+  isEffect,
+  promise,
+  tryPromise,
+  succeed6,
+  sync2,
+  callback2,
+  gen,
+  fail4,
+  try_,
+  option2,
+  catchIf,
+  mapError,
+  context,
+  contextWith,
+  provide3,
+  acquireUseRelease,
+  fnUntraced,
+  fn,
+  isStream,
+  provideContext2,
+  passthrough,
+  transformOptional,
+  withDefault2,
+  declare,
+  decodeUnknownEffect2,
+  decodeUnknownSync,
+  make11,
+  isSchema,
+  optionalKey,
+  optional,
+  toType,
+  Literal,
+  TemplateLiteral,
+  Never,
+  Any,
+  Unknown,
+  String3,
+  Boolean3,
+  Void,
+  Struct,
+  Record,
+  StructWithRest,
+  ArraySchema,
+  Union,
+  Literals,
+  UndefinedOr,
+  decodeTo2,
+  decode2,
+  withConstructorDefault,
+  tag,
+  Opaque,
+  makeFilter,
+  isPattern,
+  Finite,
+  isBetween,
+  Int2,
+  Defect,
+  Uint8ArrayFromBase64,
+  Exit,
+  Class2,
+  Error2,
+  TaggedError2,
+  Json,
+  JsonObject
+} from "./main-9z6jbwdp.mjs";
 import {
   dataRoot,
   cliCommand
-} from "./main-a6mpfd6z.mjs";
+} from "./main-ea9djgtm.mjs";
+import {
+  pipeArguments,
+  identity,
+  constTrue,
+  constFalse,
+  constUndefined,
+  isString,
+  isNumber,
+  isBoolean,
+  isObject,
+  hasProperty
+} from "./main-yf9xhpn4.mjs";
+
+// node_modules/effect/dist/Semaphore.js
+var makeUnsafe = (permits) => new SemaphoreImpl(permits);
+var waitForPermits = (self, n, effect) => callback((resume) => {
+  if (self.free >= n)
+    return resume(effect);
+  const observer = () => {
+    if (self.free < n)
+      return;
+    self.waiters.delete(observer);
+    resume(effect);
+  };
+  self.waiters.add(observer);
+  return sync(() => {
+    self.waiters.delete(observer);
+  });
+});
+
+class SemaphoreImpl {
+  waiters = /* @__PURE__ */ new Set;
+  taken = 0;
+  permits;
+  constructor(permits) {
+    this.permits = permits;
+  }
+  get free() {
+    return this.permits - this.taken;
+  }
+  take(n) {
+    const take = suspend(() => {
+      if (this.free < n) {
+        return waitForPermits(this, n, take);
+      }
+      this.taken += n;
+      return succeed2(n);
+    });
+    return take;
+  }
+  takeIfAvailable(n) {
+    return suspend(() => {
+      if (this.free < n)
+        return succeed2(false);
+      this.taken += n;
+      return succeed2(true);
+    });
+  }
+  releaseUnsafe(fiber, n) {
+    this.taken -= n;
+    if (this.waiters.size > 0) {
+      fiber.currentDispatcher.scheduleTask(() => {
+        for (const observer of this.waiters) {
+          if (this.free <= 0)
+            break;
+          observer();
+        }
+      }, 0);
+    }
+    return this.free;
+  }
+  resize(permits) {
+    return withFiber((fiber) => {
+      this.permits = permits;
+      if (this.free < 0)
+        return void_;
+      this.releaseUnsafe(fiber, 0);
+      return void_;
+    });
+  }
+  release(n) {
+    return withFiber((fiber) => succeed2(this.releaseUnsafe(fiber, n)));
+  }
+  get releaseAll() {
+    return withFiber((fiber) => succeed2(this.releaseUnsafe(fiber, this.taken)));
+  }
+  withPermits(n) {
+    return (self) => uninterruptibleMask((restore) => {
+      const acquire = suspend(() => {
+        if (this.free < n) {
+          const wait = waitForPermits(this, n, void_);
+          return flatMap2(restore(wait), () => acquire);
+        }
+        this.taken += n;
+        return onExitPrimitive(restore(self), () => {
+          this.releaseUnsafe(getCurrentFiber(), n);
+          return;
+        }, true);
+      });
+      return acquire;
+    });
+  }
+  withPermit = /* @__PURE__ */ this.withPermits(1);
+  withPermitsIfAvailable(n) {
+    return (self) => uninterruptibleMask((restore) => {
+      if (this.free < n)
+        return succeedNone;
+      this.taken += n;
+      return onExitPrimitive(restore(asSome(self)), () => {
+        this.releaseUnsafe(getCurrentFiber(), n);
+        return;
+      }, true);
+    });
+  }
+}
+var make = (permits) => sync(() => new SemaphoreImpl(permits));
+
+// node_modules/effect/dist/PrimaryKey.js
+var symbol = "~effect/PrimaryKey";
+// node_modules/effect/dist/rpc/RpcSchema.js
+var StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema";
+function isStreamSchema(schema) {
+  return hasProperty(schema, StreamSchemaTypeId);
+}
+function getStreamSchemas(schema) {
+  return isStreamSchema(schema) ? some({
+    success: schema.success,
+    error: schema.error
+  }) : none();
+}
+var schema = /* @__PURE__ */ declare(isStream);
+function Stream(success, error) {
+  return make11(schema.ast, {
+    [StreamSchemaTypeId]: StreamSchemaTypeId,
+    success,
+    error
+  });
+}
+
+class ClientAbort extends (/* @__PURE__ */ Service2()("effect/rpc/RpcSchema/ClientAbort")) {
+  static annotation = /* @__PURE__ */ this.context(true).pipe(/* @__PURE__ */ add(StackTrace, {
+    name: "ClientAbort",
+    stack: constUndefined,
+    parent: undefined
+  }));
+}
+
+// node_modules/effect/dist/rpc/Rpc.js
+var TypeId = "~effect/rpc/Rpc";
+class ServerClient {
+  id;
+  annotations;
+  constructor(id) {
+    this.id = id;
+    this.annotations = empty();
+  }
+  annotate(tag, value) {
+    this.annotations = add(this.annotations, tag, value);
+    return this;
+  }
+}
+var Proto = {
+  [TypeId]: TypeId,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  setSuccess(successSchema) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      annotations: this.annotations,
+      middlewares: this.middlewares
+    });
+  },
+  setError(errorSchema) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema,
+      defectSchema: this.defectSchema,
+      annotations: this.annotations,
+      middlewares: this.middlewares
+    });
+  },
+  setPayload(payloadSchema) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: isSchema(payloadSchema) ? payloadSchema : Struct(payloadSchema),
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      annotations: this.annotations,
+      middlewares: this.middlewares
+    });
+  },
+  middleware(middleware) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      annotations: this.annotations,
+      middlewares: new Set([...this.middlewares, middleware])
+    });
+  },
+  prefix(prefix) {
+    return makeProto({
+      _tag: `${prefix}${this._tag}`,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      annotations: this.annotations,
+      middlewares: this.middlewares
+    });
+  },
+  annotate(tag, value) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      middlewares: this.middlewares,
+      annotations: add(this.annotations, tag, value)
+    });
+  },
+  annotateMerge(context) {
+    return makeProto({
+      _tag: this._tag,
+      payloadSchema: this.payloadSchema,
+      successSchema: this.successSchema,
+      errorSchema: this.errorSchema,
+      defectSchema: this.defectSchema,
+      middlewares: this.middlewares,
+      annotations: merge(this.annotations, context)
+    });
+  }
+};
+var makeProto = (options) => {
+  function Rpc() {}
+  Object.setPrototypeOf(Rpc, Proto);
+  Object.assign(Rpc, options);
+  Rpc.key = `effect/rpc/Rpc/${options._tag}`;
+  return Rpc;
+};
+var make2 = (tag, options) => {
+  const successSchema = options?.success ?? Void;
+  const errorSchema = options?.error ?? Never;
+  const defectSchema = options?.defect ?? Defect();
+  let payloadSchema;
+  if (options?.primaryKey) {
+    payloadSchema = class Payload extends Class2(`effect/rpc/Rpc/${tag}`)(options.payload) {
+      [symbol]() {
+        return options.primaryKey(this);
+      }
+    };
+  } else {
+    payloadSchema = isSchema(options?.payload) ? options?.payload : options?.payload ? Struct(options?.payload) : Void;
+  }
+  return makeProto({
+    _tag: tag,
+    payloadSchema,
+    successSchema: options?.stream ? Stream(successSchema, errorSchema) : successSchema,
+    errorSchema: options?.stream ? Never : errorSchema,
+    defectSchema,
+    annotations: empty(),
+    middlewares: new Set
+  });
+};
+var exitSchemaCache = /* @__PURE__ */ new WeakMap;
+var exitSchema = (self) => {
+  if (exitSchemaCache.has(self)) {
+    return exitSchemaCache.get(self);
+  }
+  const rpc = self;
+  const failures = new Set([rpc.errorSchema]);
+  const streamSchemas = getStreamSchemas(rpc.successSchema);
+  if (isSome(streamSchemas)) {
+    failures.add(streamSchemas.value.error);
+  }
+  for (const middleware of rpc.middlewares) {
+    failures.add(middleware.error);
+  }
+  const schema = Exit(isSome(streamSchemas) ? Void : rpc.successSchema, Union([...failures]), rpc.defectSchema);
+  exitSchemaCache.set(self, schema);
+  return schema;
+};
+var WrapperTypeId = "~effect/rpc/Rpc/Wrapper";
+var isWrapper = (u) => (WrapperTypeId in u);
+
+// node_modules/effect/dist/rpc/RpcGroup.js
+var RpcGroupProto = {
+  add(...rpcs) {
+    const requests = new Map(this.requests);
+    for (const rpc of rpcs) {
+      requests.set(rpc._tag, rpc);
+    }
+    return makeProto2({
+      requests,
+      annotations: this.annotations
+    });
+  },
+  merge(...groups) {
+    const requests = new Map(this.requests);
+    const annotations = new Map(this.annotations.mapUnsafe);
+    for (const group of groups) {
+      for (const [tag, rpc] of group.requests) {
+        requests.set(tag, rpc);
+      }
+      for (const [key, value] of group.annotations.mapUnsafe) {
+        annotations.set(key, value);
+      }
+    }
+    return makeProto2({
+      requests,
+      annotations: makeUnsafe2(annotations)
+    });
+  },
+  omit(...tags) {
+    const requests = new Map(this.requests);
+    for (const tag of tags) {
+      requests.delete(tag);
+    }
+    return makeProto2({
+      requests,
+      annotations: this.annotations
+    });
+  },
+  middleware(middleware) {
+    const requests = new Map;
+    for (const [tag, rpc] of this.requests) {
+      requests.set(tag, rpc.middleware(middleware));
+    }
+    return makeProto2({
+      requests,
+      annotations: this.annotations
+    });
+  },
+  toHandlers(build) {
+    const self = this;
+    return gen(function* () {
+      const services = yield* context();
+      const handlers = isEffect(build) ? yield* build : build;
+      const contextMap = new Map;
+      self.requests.forEach((rpc, tag) => {
+        contextMap.set(rpc.key, {
+          tag: rpc._tag,
+          handler: handlers[tag],
+          context: services
+        });
+      });
+      return makeUnsafe2(contextMap);
+    });
+  },
+  prefix(prefix) {
+    const requests = new Map;
+    for (const rpc of this.requests.values()) {
+      const newRpc = rpc.prefix(prefix);
+      requests.set(newRpc._tag, newRpc);
+    }
+    return makeProto2({
+      requests,
+      annotations: this.annotations
+    });
+  },
+  toLayer(build) {
+    return effectContext(this.toHandlers(build));
+  },
+  of: identity,
+  toLayerHandler(service, build) {
+    const self = this;
+    return effectContext(gen(function* () {
+      const services = yield* context();
+      const handler = isEffect(build) ? yield* build : build;
+      const contextMap = new Map;
+      const rpc = self.requests.get(service);
+      contextMap.set(rpc.key, {
+        handler,
+        context: services
+      });
+      return makeUnsafe2(contextMap);
+    }));
+  },
+  accessHandler(service) {
+    return contextWith((parentContext) => {
+      const rpc = this.requests.get(service);
+      const {
+        handler,
+        context
+      } = getOrUndefinedUnsafe(parentContext, rpc.key);
+      return succeed6((payload, options) => {
+        options.rpc = rpc;
+        const result = handler(payload, options);
+        const effectOrStream = isWrapper(result) ? result.value : result;
+        return isEffect(effectOrStream) ? provide3(effectOrStream, context) : provideContext2(effectOrStream, context);
+      });
+    });
+  },
+  annotate(service, value) {
+    return makeProto2({
+      requests: this.requests,
+      annotations: add(this.annotations, service, value)
+    });
+  },
+  annotateRpcs(service, value) {
+    return this.annotateRpcsMerge(make4(service, value));
+  },
+  annotateMerge(context) {
+    return makeProto2({
+      requests: this.requests,
+      annotations: merge(this.annotations, context)
+    });
+  },
+  annotateRpcsMerge(context) {
+    const requests = new Map;
+    for (const [tag, rpc] of this.requests) {
+      requests.set(tag, rpc.annotateMerge(merge(context, rpc.annotations)));
+    }
+    return makeProto2({
+      requests,
+      annotations: this.annotations
+    });
+  }
+};
+var makeProto2 = (options) => Object.assign(function() {}, RpcGroupProto, {
+  requests: options.requests,
+  annotations: options.annotations
+});
+var make3 = (...rpcs) => makeProto2({
+  requests: new Map(rpcs.map((rpc) => [rpc._tag, rpc])),
+  annotations: empty()
+});
+
+// node_modules/effect/dist/rpc/RpcMiddleware.js
+var TypeId2 = "~effect/rpc/RpcMiddleware";
+var Service = () => (id, options) => {
+  const limit = getStackTraceLimit();
+  let creationError;
+  if (limit !== 0) {
+    setStackTraceLimit(2);
+    creationError = new globalThis.Error;
+    setStackTraceLimit(limit);
+  }
+  function ServiceClass() {}
+  const ServiceClass_ = ServiceClass;
+  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(Service2(id)));
+  ServiceClass.key = id;
+  Object.defineProperty(ServiceClass, "stack", {
+    get() {
+      return creationError?.stack;
+    }
+  });
+  ServiceClass_[TypeId2] = TypeId2;
+  ServiceClass_.error = options?.error ?? Never;
+  ServiceClass_.requiredForClient = options?.requiredForClient ?? false;
+  return ServiceClass;
+};
+
+// node_modules/effect/dist/ai/McpSchema.js
+var optionalWithDefault = (schema, defaultValue) => {
+  const effect = sync2(defaultValue);
+  return optionalKey(schema).pipe(decode2({
+    decode: withDefault2(effect),
+    encode: passthrough()
+  }), withConstructorDefault(effect));
+};
+var optional2 = (schema) => optionalKey(schema).pipe(decodeTo2(toType(optional(schema)), {
+  decode: passthrough(),
+  encode: transformOptional(flatMap(fromUndefinedOr))
+}));
+var RequestId = /* @__PURE__ */ Union([String3, Finite]);
+var ProgressToken = /* @__PURE__ */ Union([String3, Finite]);
+
+class RequestMeta extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  _meta: /* @__PURE__ */ optional2(/* @__PURE__ */ StructWithRest(/* @__PURE__ */ Struct({
+    progressToken: /* @__PURE__ */ optional2(ProgressToken)
+  }), [JsonObject]))
+}))) {
+}
+
+class ResultMeta extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class NotificationMeta extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+var Cursor = String3;
+
+class PaginatedRequestMeta extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...RequestMeta.fields,
+  cursor: /* @__PURE__ */ optional2(Cursor)
+}))) {
+}
+
+class PaginatedResultMeta extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResultMeta.fields,
+  nextCursor: /* @__PURE__ */ optional2(Cursor)
+}))) {
+}
+var Role = /* @__PURE__ */ Literals(["user", "assistant"]);
+
+class Annotations extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  audience: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Role)),
+  priority: /* @__PURE__ */ optional2(/* @__PURE__ */ Finite.check(/* @__PURE__ */ isBetween({
+    minimum: 0,
+    maximum: 1
+  }))),
+  lastModified: /* @__PURE__ */ optional2(String3)
+}))) {
+}
+
+class Icon extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/Icon")({
+  src: String3,
+  mimeType: /* @__PURE__ */ optional2(String3),
+  sizes: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3)),
+  theme: /* @__PURE__ */ optional2(/* @__PURE__ */ Literals(["light", "dark"]))
+})) {
+}
+
+class Implementation extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  version: String3,
+  icons: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Icon)),
+  description: /* @__PURE__ */ optional2(String3),
+  websiteUrl: /* @__PURE__ */ optional2(String3)
+}))) {
+}
+
+class ClientCapabilities extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ClientCapabilities")({
+  experimental: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, /* @__PURE__ */ Struct({}))),
+  extensions: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(/* @__PURE__ */ TemplateLiteral([String3, "/", String3]), Json)),
+  roots: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    listChanged: /* @__PURE__ */ optional2(Boolean3)
+  })),
+  sampling: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    context: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({})),
+    tools: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({}))
+  })),
+  elicitation: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    form: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({})),
+    url: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({}))
+  }))
+})) {
+}
+
+class ServerCapabilities extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  experimental: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, /* @__PURE__ */ Struct({}))),
+  extensions: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(/* @__PURE__ */ TemplateLiteral([String3, "/", String3]), Json)),
+  logging: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({})),
+  completions: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({})),
+  prompts: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    listChanged: /* @__PURE__ */ optional2(Boolean3)
+  })),
+  resources: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    subscribe: /* @__PURE__ */ optional2(Boolean3),
+    listChanged: /* @__PURE__ */ optional2(Boolean3)
+  })),
+  tools: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct({
+    listChanged: /* @__PURE__ */ optional2(Boolean3)
+  }))
+}))) {
+}
+
+class McpErrorBase extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/McpErrorBase")({
+  code: Int2,
+  message: String3,
+  data: /* @__PURE__ */ optional2(Any)
+})) {
+}
+var INVALID_REQUEST_ERROR_CODE = -32600;
+var METHOD_NOT_FOUND_ERROR_CODE = -32601;
+var INVALID_PARAMS_ERROR_CODE = -32602;
+var INTERNAL_ERROR_CODE = -32603;
+var PARSE_ERROR_CODE = -32700;
+var HEADER_MISMATCH_ERROR_CODE = -32020;
+
+class ParseError extends (/* @__PURE__ */ Error2("effect/ai/McpSchema/ParseError")({
+  ...McpErrorBase.fields,
+  _tag: /* @__PURE__ */ tag("ParseError"),
+  code: /* @__PURE__ */ tag(PARSE_ERROR_CODE)
+})) {
+}
+
+class InvalidRequest extends (/* @__PURE__ */ Error2("effect/ai/McpSchema/InvalidRequest")({
+  ...McpErrorBase.fields,
+  _tag: /* @__PURE__ */ tag("InvalidRequest"),
+  code: /* @__PURE__ */ tag(INVALID_REQUEST_ERROR_CODE)
+})) {
+}
+
+class MethodNotFound extends (/* @__PURE__ */ Error2("effect/ai/McpSchema/MethodNotFound")({
+  ...McpErrorBase.fields,
+  _tag: /* @__PURE__ */ tag("MethodNotFound"),
+  code: /* @__PURE__ */ tag(METHOD_NOT_FOUND_ERROR_CODE)
+})) {
+}
+
+class InvalidParams extends (/* @__PURE__ */ Error2("effect/ai/McpSchema/InvalidParams")({
+  ...McpErrorBase.fields,
+  _tag: /* @__PURE__ */ tag("InvalidParams"),
+  code: /* @__PURE__ */ tag(INVALID_PARAMS_ERROR_CODE)
+})) {
+}
+
+class InternalError extends (/* @__PURE__ */ Error2("effect/ai/McpSchema/InternalError")({
+  ...McpErrorBase.fields,
+  _tag: /* @__PURE__ */ tag("InternalError"),
+  code: /* @__PURE__ */ tag(INTERNAL_ERROR_CODE)
+})) {
+  static notImplemented = /* @__PURE__ */ new InternalError({
+    message: "Not implemented"
+  });
+}
+var McpError = /* @__PURE__ */ Union([ParseError, InvalidRequest, MethodNotFound, InvalidParams, InternalError, McpErrorBase]);
+
+class Ping extends (/* @__PURE__ */ make2("ping", {
+  success: /* @__PURE__ */ Struct({}),
+  error: McpError,
+  payload: /* @__PURE__ */ UndefinedOr(RequestMeta)
+})) {
+}
+
+class InitializeResult extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResultMeta.fields,
+  protocolVersion: String3,
+  capabilities: ServerCapabilities,
+  serverInfo: Implementation,
+  instructions: /* @__PURE__ */ optional2(String3)
+}))) {
+}
+
+class Initialize extends (/* @__PURE__ */ make2("initialize", {
+  success: InitializeResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    protocolVersion: String3,
+    capabilities: ClientCapabilities,
+    clientInfo: Implementation
+  }
+})) {
+}
+class CancelledNotification extends (/* @__PURE__ */ make2("notifications/cancelled", {
+  payload: {
+    ...NotificationMeta.fields,
+    requestId: RequestId,
+    reason: /* @__PURE__ */ optional2(String3)
+  }
+})) {
+}
+
+class ProgressNotification extends (/* @__PURE__ */ make2("notifications/progress", {
+  payload: {
+    ...NotificationMeta.fields,
+    progressToken: ProgressToken,
+    progress: Finite,
+    total: /* @__PURE__ */ optional2(Finite),
+    message: /* @__PURE__ */ optional2(String3)
+  }
+})) {
+}
+
+class Resource extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/Resource")({
+  uri: String3,
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  mimeType: /* @__PURE__ */ optional2(String3),
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  icons: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Icon)),
+  size: /* @__PURE__ */ optional2(Int2),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class ResourceTemplate extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ResourceTemplate")({
+  uriTemplate: String3,
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  mimeType: /* @__PURE__ */ optional2(String3),
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  icons: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Icon)),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class ResourceContents extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  uri: String3,
+  mimeType: /* @__PURE__ */ optional2(String3),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class TextResourceContents extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResourceContents.fields,
+  text: String3
+}))) {
+}
+
+class BlobResourceContents extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResourceContents.fields,
+  blob: Uint8ArrayFromBase64
+}))) {
+}
+
+class ListResourcesResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ListResourcesResult")({
+  ...PaginatedResultMeta.fields,
+  resources: /* @__PURE__ */ ArraySchema(Resource)
+})) {
+}
+class ListResourceTemplatesResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ListResourceTemplatesResult")({
+  ...PaginatedResultMeta.fields,
+  resourceTemplates: /* @__PURE__ */ ArraySchema(ResourceTemplate)
+})) {
+}
+class ReadResourceResult extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResultMeta.fields,
+  contents: /* @__PURE__ */ ArraySchema(/* @__PURE__ */ Union([TextResourceContents, BlobResourceContents]))
+}))) {
+}
+
+class ReadResource extends (/* @__PURE__ */ make2("resources/read", {
+  success: ReadResourceResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: String3
+  }
+})) {
+}
+
+class ResourceListChangedNotification extends (/* @__PURE__ */ make2("notifications/resources/list_changed", {
+  payload: /* @__PURE__ */ UndefinedOr(NotificationMeta)
+})) {
+}
+
+class Subscribe extends (/* @__PURE__ */ make2("resources/subscribe", {
+  success: /* @__PURE__ */ Struct({}),
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: String3
+  }
+})) {
+}
+
+class Unsubscribe extends (/* @__PURE__ */ make2("resources/unsubscribe", {
+  success: /* @__PURE__ */ Struct({}),
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    uri: String3
+  }
+})) {
+}
+
+class ResourceUpdatedNotification extends (/* @__PURE__ */ make2("notifications/resources/updated", {
+  payload: {
+    ...NotificationMeta.fields,
+    uri: String3
+  }
+})) {
+}
+
+class PromptArgument extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  required: /* @__PURE__ */ optional2(Boolean3)
+}))) {
+}
+
+class Prompt extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/Prompt")({
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  arguments: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(PromptArgument)),
+  icons: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Icon)),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class TextContent extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  type: /* @__PURE__ */ tag("text"),
+  text: String3,
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class ImageContent extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  type: /* @__PURE__ */ tag("image"),
+  data: Uint8ArrayFromBase64,
+  mimeType: String3,
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class AudioContent extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  type: /* @__PURE__ */ tag("audio"),
+  data: Uint8ArrayFromBase64,
+  mimeType: String3,
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class EmbeddedResource extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  type: /* @__PURE__ */ tag("resource"),
+  resource: /* @__PURE__ */ Union([TextResourceContents, BlobResourceContents]),
+  annotations: /* @__PURE__ */ optional2(Annotations),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class ResourceLink extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...Resource.fields,
+  type: /* @__PURE__ */ tag("resource_link")
+}))) {
+}
+var ContentBlock = /* @__PURE__ */ Union([TextContent, ImageContent, AudioContent, EmbeddedResource, ResourceLink]);
+
+class PromptMessage extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  role: Role,
+  content: ContentBlock
+}))) {
+}
+
+class ListPromptsResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ListPromptsResult")({
+  ...PaginatedResultMeta.fields,
+  prompts: /* @__PURE__ */ ArraySchema(Prompt)
+})) {
+}
+class GetPromptResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/GetPromptResult")({
+  ...ResultMeta.fields,
+  messages: /* @__PURE__ */ ArraySchema(PromptMessage),
+  description: /* @__PURE__ */ optional2(String3)
+})) {
+}
+
+class GetPrompt extends (/* @__PURE__ */ make2("prompts/get", {
+  success: GetPromptResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    name: String3,
+    title: /* @__PURE__ */ optional2(String3),
+    arguments: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, String3))
+  }
+})) {
+}
+
+class PromptListChangedNotification extends (/* @__PURE__ */ make2("notifications/prompts/list_changed", {
+  payload: /* @__PURE__ */ UndefinedOr(NotificationMeta)
+})) {
+}
+
+class ToolAnnotations extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  title: /* @__PURE__ */ optional2(String3),
+  readOnlyHint: /* @__PURE__ */ optionalWithDefault(Boolean3, constFalse),
+  destructiveHint: /* @__PURE__ */ optionalWithDefault(Boolean3, constTrue),
+  idempotentHint: /* @__PURE__ */ optionalWithDefault(Boolean3, constFalse),
+  openWorldHint: /* @__PURE__ */ optionalWithDefault(Boolean3, constTrue)
+}))) {
+}
+var ToolJson = /* @__PURE__ */ StructWithRest(/* @__PURE__ */ Struct({
+  type: /* @__PURE__ */ Literal("object"),
+  properties: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, JsonObject)),
+  required: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3))
+}), [JsonObject]);
+var ToolOutputJson = JsonObject;
+
+class Tool extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/Tool")({
+  name: String3,
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  inputSchema: ToolJson,
+  outputSchema: /* @__PURE__ */ optional2(ToolOutputJson),
+  annotations: /* @__PURE__ */ optional2(ToolAnnotations),
+  icons: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(Icon)),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class ListToolsResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ListToolsResult")({
+  ...PaginatedResultMeta.fields,
+  tools: /* @__PURE__ */ ArraySchema(Tool)
+})) {
+}
+class CallToolResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/CallToolResult")({
+  ...ResultMeta.fields,
+  content: /* @__PURE__ */ ArraySchema(ContentBlock),
+  structuredContent: /* @__PURE__ */ optional2(Json),
+  isError: /* @__PURE__ */ optional2(Boolean3)
+})) {
+}
+
+class CallTool extends (/* @__PURE__ */ make2("tools/call", {
+  success: CallToolResult,
+  error: McpError,
+  payload: {
+    ...RequestMeta.fields,
+    name: String3,
+    arguments: /* @__PURE__ */ optionalWithDefault(/* @__PURE__ */ Record(String3, Any), () => ({}))
+  }
+})) {
+}
+
+class ToolListChangedNotification extends (/* @__PURE__ */ make2("notifications/tools/list_changed", {
+  payload: /* @__PURE__ */ UndefinedOr(NotificationMeta)
+})) {
+}
+var LoggingLevel = /* @__PURE__ */ Literals(["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]);
+
+class SetLevel extends (/* @__PURE__ */ make2("logging/setLevel", {
+  payload: {
+    ...RequestMeta.fields,
+    level: LoggingLevel
+  },
+  success: /* @__PURE__ */ Struct({}),
+  error: McpError
+})) {
+}
+
+class LoggingMessageNotification extends (/* @__PURE__ */ make2("notifications/message", {
+  payload: /* @__PURE__ */ Struct({
+    ...NotificationMeta.fields,
+    level: LoggingLevel,
+    logger: /* @__PURE__ */ optional2(String3),
+    data: Any
+  })
+})) {
+}
+
+class ToolUseContent extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ToolUseContent")({
+  type: /* @__PURE__ */ tag("tool_use"),
+  id: String3,
+  name: String3,
+  input: /* @__PURE__ */ Record(String3, Unknown),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class ToolResultContent extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ToolResultContent")({
+  type: /* @__PURE__ */ tag("tool_result"),
+  toolUseId: String3,
+  content: /* @__PURE__ */ ArraySchema(ContentBlock),
+  structuredContent: /* @__PURE__ */ optional2(Json),
+  isError: /* @__PURE__ */ optional2(Boolean3),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+var SamplingMessageContentBlock = /* @__PURE__ */ Union([TextContent, ImageContent, AudioContent, ToolUseContent, ToolResultContent]);
+
+class SamplingMessage extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  role: Role,
+  content: /* @__PURE__ */ Union([SamplingMessageContentBlock, /* @__PURE__ */ ArraySchema(SamplingMessageContentBlock)]),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+}))) {
+}
+
+class ToolChoice extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ToolChoice")({
+  mode: /* @__PURE__ */ optional2(/* @__PURE__ */ Literals(["auto", "required", "none"]))
+})) {
+}
+
+class ModelHint extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  name: /* @__PURE__ */ optional2(String3)
+}))) {
+}
+
+class ModelPreferences extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ModelPreferences")({
+  hints: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(ModelHint)),
+  costPriority: /* @__PURE__ */ optional2(/* @__PURE__ */ Finite.check(/* @__PURE__ */ isBetween({
+    minimum: 0,
+    maximum: 1
+  }))),
+  speedPriority: /* @__PURE__ */ optional2(/* @__PURE__ */ Finite.check(/* @__PURE__ */ isBetween({
+    minimum: 0,
+    maximum: 1
+  }))),
+  intelligencePriority: /* @__PURE__ */ optional2(/* @__PURE__ */ Finite.check(/* @__PURE__ */ isBetween({
+    minimum: 0,
+    maximum: 1
+  })))
+})) {
+}
+
+class CreateMessageResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/CreateMessageResult")({
+  role: Role,
+  content: /* @__PURE__ */ Union([SamplingMessageContentBlock, /* @__PURE__ */ ArraySchema(SamplingMessageContentBlock)]),
+  _meta: /* @__PURE__ */ optional2(JsonObject),
+  model: String3,
+  stopReason: /* @__PURE__ */ optional2(String3)
+})) {
+}
+
+class CreateMessage extends (/* @__PURE__ */ make2("sampling/createMessage", {
+  success: CreateMessageResult,
+  error: McpError,
+  payload: {
+    messages: /* @__PURE__ */ ArraySchema(SamplingMessage),
+    modelPreferences: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct(ModelPreferences.fields)),
+    systemPrompt: /* @__PURE__ */ optional2(String3),
+    includeContext: /* @__PURE__ */ optional2(/* @__PURE__ */ Literals(["none", "thisServer", "allServers"])),
+    temperature: /* @__PURE__ */ optional2(Finite),
+    maxTokens: Int2,
+    stopSequences: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3)),
+    metadata: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, Unknown)),
+    tools: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(/* @__PURE__ */ Struct(Tool.fields))),
+    toolChoice: /* @__PURE__ */ optional2(/* @__PURE__ */ Struct(ToolChoice.fields))
+  }
+})) {
+}
+class CompleteResult extends (/* @__PURE__ */ Opaque()(/* @__PURE__ */ Struct({
+  ...ResultMeta.fields,
+  completion: /* @__PURE__ */ Struct({
+    values: /* @__PURE__ */ ArraySchema(String3),
+    total: /* @__PURE__ */ optional2(Int2),
+    hasMore: /* @__PURE__ */ optional2(Boolean3)
+  })
+}))) {
+  static empty = /* @__PURE__ */ CompleteResult.make({
+    completion: {
+      values: [],
+      total: 0,
+      hasMore: false
+    }
+  });
+}
+class Root extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/Root")({
+  uri: String3,
+  name: /* @__PURE__ */ optional2(String3),
+  _meta: /* @__PURE__ */ optional2(JsonObject)
+})) {
+}
+
+class ListRootsResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ListRootsResult")({
+  roots: /* @__PURE__ */ ArraySchema(Root)
+})) {
+}
+
+class ListRoots extends (/* @__PURE__ */ make2("roots/list", {
+  success: ListRootsResult,
+  error: McpError,
+  payload: /* @__PURE__ */ UndefinedOr(RequestMeta)
+})) {
+}
+class ElicitationString extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitationString")({
+  type: /* @__PURE__ */ tag("string"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  minLength: /* @__PURE__ */ optional2(Int2),
+  maxLength: /* @__PURE__ */ optional2(Int2),
+  format: /* @__PURE__ */ optional2(/* @__PURE__ */ Literals(["email", "uri", "date", "date-time"])),
+  default: /* @__PURE__ */ optional2(String3)
+})) {
+}
+
+class ElicitationNumber extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitationNumber")({
+  type: /* @__PURE__ */ Literals(["number", "integer"]),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  minimum: /* @__PURE__ */ optional2(Finite),
+  maximum: /* @__PURE__ */ optional2(Finite),
+  default: /* @__PURE__ */ optional2(Finite)
+})) {
+}
+
+class ElicitationBoolean extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitationBoolean")({
+  type: /* @__PURE__ */ tag("boolean"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  default: /* @__PURE__ */ optional2(Boolean3)
+})) {
+}
 
+class UntitledSingleSelectEnum extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/UntitledSingleSelectEnum")({
+  type: /* @__PURE__ */ tag("string"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  enum: /* @__PURE__ */ ArraySchema(String3),
+  default: /* @__PURE__ */ optional2(String3)
+})) {
+}
+
+class TitledSingleSelectEnum extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/TitledSingleSelectEnum")({
+  type: /* @__PURE__ */ tag("string"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  oneOf: /* @__PURE__ */ ArraySchema(/* @__PURE__ */ Struct({
+    const: String3,
+    title: String3
+  })),
+  default: /* @__PURE__ */ optional2(String3)
+})) {
+}
+var SingleSelectEnum = /* @__PURE__ */ Union([UntitledSingleSelectEnum, TitledSingleSelectEnum]);
+
+class UntitledMultiSelectEnum extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/UntitledMultiSelectEnum")({
+  type: /* @__PURE__ */ tag("array"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  minItems: /* @__PURE__ */ optional2(Int2),
+  maxItems: /* @__PURE__ */ optional2(Int2),
+  items: /* @__PURE__ */ Struct({
+    type: /* @__PURE__ */ tag("string"),
+    enum: /* @__PURE__ */ ArraySchema(String3)
+  }),
+  default: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3))
+})) {
+}
+
+class TitledMultiSelectEnum extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/TitledMultiSelectEnum")({
+  type: /* @__PURE__ */ tag("array"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  minItems: /* @__PURE__ */ optional2(Int2),
+  maxItems: /* @__PURE__ */ optional2(Int2),
+  items: /* @__PURE__ */ Struct({
+    anyOf: /* @__PURE__ */ ArraySchema(/* @__PURE__ */ Struct({
+      const: String3,
+      title: String3
+    }))
+  }),
+  default: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3))
+})) {
+}
+var MultiSelectEnum = /* @__PURE__ */ Union([UntitledMultiSelectEnum, TitledMultiSelectEnum]);
+
+class LegacyTitledEnum extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/LegacyTitledEnum")({
+  type: /* @__PURE__ */ tag("string"),
+  title: /* @__PURE__ */ optional2(String3),
+  description: /* @__PURE__ */ optional2(String3),
+  enum: /* @__PURE__ */ ArraySchema(String3),
+  enumNames: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3)),
+  default: /* @__PURE__ */ optional2(String3)
+})) {
+}
+var ElicitationEnum = /* @__PURE__ */ Union([LegacyTitledEnum, SingleSelectEnum, MultiSelectEnum]);
+var PrimitiveSchemaDefinition = /* @__PURE__ */ Union([ElicitationEnum, ElicitationString, ElicitationNumber, ElicitationBoolean]);
+var ElicitationForm = /* @__PURE__ */ Struct({
+  $schema: /* @__PURE__ */ optional2(String3),
+  type: /* @__PURE__ */ tag("object"),
+  properties: /* @__PURE__ */ Record(String3, PrimitiveSchemaDefinition),
+  required: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String3))
+});
+
+class ElicitRequestFormParams extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitRequestFormParams")({
+  ...RequestMeta.fields,
+  mode: /* @__PURE__ */ optional2(/* @__PURE__ */ Literal("form")),
+  message: String3,
+  requestedSchema: ElicitationForm
+})) {
+}
+
+class ElicitRequestURLParams extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitRequestURLParams")({
+  ...RequestMeta.fields,
+  mode: /* @__PURE__ */ Literal("url"),
+  message: String3,
+  elicitationId: String3,
+  url: String3
+})) {
+}
+var ElicitRequestParams = /* @__PURE__ */ Union([ElicitRequestFormParams, ElicitRequestURLParams]);
+
+class ElicitAcceptResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitAcceptResult")({
+  ...ResultMeta.fields,
+  action: /* @__PURE__ */ Literal("accept"),
+  content: /* @__PURE__ */ optional2(/* @__PURE__ */ Record(String3, /* @__PURE__ */ Union([String3, Finite, Boolean3, /* @__PURE__ */ ArraySchema(String3)])))
+})) {
+}
+
+class ElicitDeclineResult extends (/* @__PURE__ */ Class2("@effect/ai/McpSchema/ElicitDeclineResult")({
+  ...ResultMeta.fields,
+  action: /* @__PURE__ */ Literals(["cancel", "decline"])
+})) {
+}
+var ElicitResult = /* @__PURE__ */ Union([ElicitAcceptResult, ElicitDeclineResult]);
+class Elicit extends (/* @__PURE__ */ make2("elicitation/create", {
+  success: ElicitResult,
+  error: McpError,
+  payload: ElicitRequestParams
+})) {
+}
+
+class ElicitationCompleteNotification extends (/* @__PURE__ */ make2("notifications/elicitation/complete", {
+  payload: {
+    elicitationId: String3
+  }
+})) {
+}
+
+class ElicitationDeclined extends (/* @__PURE__ */ Error2("@effect/ai/McpSchema/ElicitationDeclined")({
+  _tag: /* @__PURE__ */ tag("ElicitationDeclined"),
+  request: Elicit.payloadSchema,
+  cause: /* @__PURE__ */ optional2(/* @__PURE__ */ Defect())
+})) {
+}
+
+class McpReverseOperationUnsupported extends (/* @__PURE__ */ TaggedError("McpReverseOperationUnsupported")) {
+}
+
+class McpReverseOperationError extends (/* @__PURE__ */ TaggedError("McpReverseOperationError")) {
+}
+
+class McpRequestContext extends (/* @__PURE__ */ Service2()("effect/ai/McpSchema/McpRequestContext")) {
+}
+
+class McpServerClient extends (/* @__PURE__ */ Service2()("effect/ai/McpSchema/McpServerClient")) {
+}
+
+class McpServerClientMiddleware extends (/* @__PURE__ */ Service()("effect/ai/McpSchema/McpServerClientMiddleware")) {
+}
+class ServerNotificationRpcs extends (/* @__PURE__ */ make3(CancelledNotification, ProgressNotification, LoggingMessageNotification, ResourceUpdatedNotification, ResourceListChangedNotification, ToolListChangedNotification, PromptListChangedNotification, ElicitationCompleteNotification)) {
+}
+class EnabledWhen extends (/* @__PURE__ */ Service2()("effect/ai/McpSchema/EnabledWhen")) {
+}
 // src/relay/user-settings.ts
 var settingKeys = ["window", "grouping", "idleMinutes", "cursor", "humanInput", "handoffNotifications", "autoUpdate"];
 var relaySettingKeys = ["autoUpdate"];
@@ -136,8 +1460,6 @@ function formatSettings(settings) {
 }
 
 // src/mcp/schema.ts
-import { Effect, Predicate } from "effect";
-import { McpSchema } from "effect/ai";
 function browsersNote2(browsers) {
   if (browsers.length < 2)
     return "";
@@ -164,13 +1486,13 @@ var sessionAliasSchemaProperty = { type: "string", description: "Same as id." };
 var sessionOnlyInputSchema = objectSchema({
   session: sessionSchemaProperty
 });
-var ensureSessionExists = Effect.fnUntraced(function* (relay, id) {
+var ensureSessionExists = fnUntraced(function* (relay, id) {
   const sessions = yield* relay.sessions;
   const exists = sessions.some((session) => {
     return session.id === id;
   });
   if (!exists) {
-    return yield* Effect.fail(new Error(`Session not found: ${id}`));
+    return yield* fail4(new Error(`Session not found: ${id}`));
   }
 });
 function parseExecuteArguments(input) {
@@ -222,13 +1544,13 @@ function optionalStringField(input, field) {
 }
 function optionalBooleanField(input, field) {
   const value = requireObject(input)[field];
-  return Predicate.isBoolean(value) ? value : undefined;
+  return isBoolean(value) ? value : undefined;
 }
 function optionalPositiveIntegerField(input, field) {
   const value = requireObject(input)[field];
   if (value === undefined)
     return;
-  if (!Predicate.isNumber(value) || !Number.isInteger(value) || value <= 0) {
+  if (!isNumber(value) || !Number.isInteger(value) || value <= 0) {
     throw new Error(`${field} must be a positive integer`);
   }
   return value;
@@ -237,7 +1559,7 @@ function optionalNonNegativeIntegerField(input, field) {
   const value = requireObject(input)[field];
   if (value === undefined)
     return;
-  if (!Predicate.isNumber(value) || !Number.isInteger(value) || value < 0) {
+  if (!isNumber(value) || !Number.isInteger(value) || value < 0) {
     throw new Error(`${field} must be a non-negative integer`);
   }
   return value;
@@ -246,7 +1568,7 @@ function optionalStringArrayField(input, field) {
   const value = requireObject(input)[field];
   if (value === undefined)
     return;
-  if (!Array.isArray(value) || !value.every((item) => Predicate.isString(item) && item.length > 0)) {
+  if (!Array.isArray(value) || !value.every((item) => isString(item) && item.length > 0)) {
     throw new Error(`${field} must be an array of non-empty strings`);
   }
   return value;
@@ -259,7 +1581,7 @@ function requireObject(input) {
   return object;
 }
 function stringifyResult(value) {
-  if (Predicate.isString(value)) {
+  if (isString(value)) {
     return value;
   }
   return JSON.stringify(value, null, 2);
@@ -277,10 +1599,10 @@ function toolResultForValue2(value) {
   if (media.length > 0) {
     const { media: _media, ...structuredContent } = object ?? {};
     const text = errorText ?? stringifyResult(structuredContent);
-    return new McpSchema.CallToolResult({
+    return new CallToolResult({
       content: [
-        McpSchema.TextContent.make({ text }),
-        ...media.map((image) => McpSchema.ImageContent.make({
+        TextContent.make({ text }),
+        ...media.map((image) => ImageContent.make({
           data: new Uint8Array(Buffer.from(image.data, "base64")),
           mimeType: image.mimeType
         }))
@@ -299,460 +1621,23 @@ function mcpErrorMessage2(tool, message) {
   return tool === "execute" || tool === "session_adopt" ? `${message} Create it with session_new first, or omit the explicit session id to use the MCP current session.` : `${message} Create it with session_new first.`;
 }
 function toolResult(options) {
-  return new McpSchema.CallToolResult({
-    content: [McpSchema.TextContent.make({ text: options.text })],
+  return new CallToolResult({
+    content: [TextContent.make({ text: options.text })],
     structuredContent: options.structuredContent,
     isError: options.isError
   });
 }
 
-// src/auth/deadbolt.ts
-import { spawn, spawnSync } from "node:child_process";
-import crypto from "node:crypto";
-import fs from "node:fs";
-import net from "node:net";
-import os from "node:os";
-import path from "node:path";
-class DeadboltError extends Error {
-  name = "DeadboltError";
-  code;
-  detail;
-  constructor(code, message, detail = {}) {
-    super(message);
-    this.code = code;
-    this.detail = detail;
-  }
-}
-var clientFileName = "deadbolt-client.json";
-function clientFilePath(root = dataRoot()) {
-  return path.join(root, clientFileName);
-}
-function readClientFile(root = dataRoot()) {
-  let text;
-  try {
-    const file = clientFilePath(root);
-    const stat = fs.statSync(file);
-    if (process.platform !== "win32" && (stat.mode & 63) !== 0)
-      fs.chmodSync(file, 384);
-    text = fs.readFileSync(file, "utf8");
-  } catch {
-    return;
-  }
-  try {
-    const value = JSON.parse(text);
-    if (typeof value.id !== "string" || !value.id || typeof value.token !== "string" || !value.token)
-      return;
-    return {
-      version: 1,
-      id: value.id,
-      token: value.token,
-      connectedAt: typeof value.connectedAt === "string" ? value.connectedAt : ""
-    };
-  } catch {
-    return;
-  }
-}
-function readClient(root = dataRoot()) {
-  const file = readClientFile(root);
-  return file ? { id: file.id, token: file.token } : undefined;
-}
-async function saveClient(client, root = dataRoot()) {
-  const value = { version: 1, id: client.id, token: client.token, connectedAt: new Date().toISOString() };
-  await writeJsonFileAtomically(clientFilePath(root), value, { dirMode: 448 });
-}
-function removeClient(root = dataRoot()) {
-  const file = clientFilePath(root);
-  if (!fs.existsSync(file))
-    return false;
-  fs.rmSync(file, { force: true });
-  return true;
-}
-function computedSocketPath(env = process.env) {
-  const nonEmpty = (name) => env[name] ? env[name] : undefined;
-  const deadboltHome = nonEmpty("DEADBOLT_HOME");
-  const suffix = deadboltHome ? `-${blake3Hex(Buffer.from(deadboltHome, "utf8")).slice(0, 8)}` : "";
-  const uid = typeof process.getuid === "function" ? process.getuid() : 0;
-  const runtime = nonEmpty("XDG_RUNTIME_DIR") ?? userRuntimeDir(uid);
-  const directory = runtime ? path.join(runtime, `deadbolt${suffix}`) : path.join(nonEmpty("TMPDIR") ?? os.tmpdir(), `deadbolt${suffix}-${uid}`);
-  return path.join(directory, "agent.sock");
-}
-function userRuntimeDir(uid) {
-  const directory = `/run/user/${uid}`;
-  try {
-    const stat = fs.statSync(directory);
-    return stat.isDirectory() && stat.uid === uid ? directory : undefined;
-  } catch {
-    return;
-  }
-}
-function socketPath(options = {}) {
-  const env = options.env ?? process.env;
-  return env.OPENCODE_BROWSER_DEADBOLT_SOCKET || computedSocketPath(env);
-}
-var requestTimeoutMs = 15000;
-var maxReplyBytes = 4 * 1024 * 1024;
-function errorCode(code) {
-  const normalized = typeof code === "string" ? code.replace(/-/g, "_") : "";
-  switch (normalized) {
-    case "locked":
-    case "not_granted":
-    case "forbidden":
-    case "rate_limited":
-    case "domain_mismatch":
-    case "not_found":
-    case "choose_passkey":
-      return normalized;
-    case "not_initialized":
-      return "locked";
-    default:
-      return "failed";
-  }
-}
-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`.",
-  rate_limited: "Deadbolt is rate-limiting this client; wait before trying again."
-};
-function rawRequest(socket, request, timeoutMs = requestTimeoutMs) {
-  return new Promise((resolve, reject) => {
-    const connection = net.createConnection(socket);
-    let buffer = "";
-    let settled = false;
-    const finish = (error, value) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      connection.destroy();
-      if (error)
-        reject(error);
-      else
-        resolve(value);
-    };
-    const timer = setTimeout(() => finish(new DeadboltError("unavailable", `Deadbolt did not answer ${String(request.cmd)} within ${timeoutMs} ms`)), timeoutMs);
-    connection.setEncoding("utf8");
-    connection.on("connect", () => connection.write(`${JSON.stringify(request)}
-`));
-    connection.on("error", (cause) => {
-      const missing = cause.code === "ENOENT" || cause.code === "ECONNREFUSED";
-      finish(new DeadboltError("unavailable", missing ? "Deadbolt isn't running (no agent socket). Ask the user to start or unlock Deadbolt." : `Could not reach Deadbolt: ${cause.message}`));
-    });
-    connection.on("data", (chunk) => {
-      buffer += chunk;
-      if (buffer.length > maxReplyBytes)
-        return finish(new DeadboltError("failed", "Deadbolt's reply was too large"));
-      let newline;
-      while ((newline = buffer.indexOf(`
-`)) !== -1) {
-        const line = buffer.slice(0, newline).trim();
-        buffer = buffer.slice(newline + 1);
-        if (!line)
-          continue;
-        let message;
-        try {
-          message = JSON.parse(line);
-        } catch {
-          return finish(new DeadboltError("failed", "Deadbolt sent a reply that isn't JSON"));
-        }
-        if (message.type === "ok")
-          return finish(undefined, message.reply ?? {});
-        if (message.type === "error") {
-          const code = errorCode(message.code);
-          const text = typeof message.message === "string" ? message.message : String(message.code);
-          const detail = message.grant ?? {};
-          const choices = passkeyList(message.choices ?? message.passkeys);
-          return finish(new DeadboltError(code, errorHints[code] ? `${text.replace(/[\s.]*$/, ".")} ${errorHints[code]}` : text, {
-            ...typeof detail.site === "string" ? { site: detail.site } : {},
-            ...typeof detail.login === "string" ? { login: detail.login } : {},
-            ...choices.length > 0 ? { choices } : {}
-          }));
-        }
-      }
-    });
-    connection.on("end", () => finish(new DeadboltError("failed", "Deadbolt closed the connection without a reply")));
-  });
-}
-var str = (value) => typeof value === "string" ? value : undefined;
-function passkeyList(value) {
-  if (!Array.isArray(value))
-    return [];
-  return value.filter((entry) => entry !== null && typeof entry === "object").map((entry) => {
-    const username = str(entry.username);
-    const displayName = str(entry.display_name) ?? str(entry.displayName);
-    return { ref: entry.ref ?? entry.login, ...username ? { username } : {}, ...displayName ? { displayName } : {}, granted: entry.granted !== false };
-  });
-}
-function toLogin(raw) {
-  const signIn = raw.sign_in;
-  const fields = Array.isArray(raw.fields) ? raw.fields.filter((field) => typeof field === "string") : undefined;
-  const username = str(raw.username);
-  return {
-    ref: raw.ref ?? raw.login,
-    title: str(raw.title) ?? "",
-    ...username ? { username } : {},
-    hasPassword: raw.has_password === true,
-    hasTotp: raw.has_totp === true || raw.has_otp === true,
-    hasPasskey: raw.has_passkey === true,
-    granted: fields !== undefined && fields.length > 0 || raw.passkeys === true,
-    passkeys: raw.passkeys === true,
-    ...fields ? { fields } : {},
-    ...signIn && typeof signIn.provider === "string" ? { signIn: { provider: signIn.provider, ...str(signIn.account) ? { account: str(signIn.account) } : {} } } : {}
-  };
-}
-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>`.");
-  }
-  const socket = options.socket ?? socketPath();
-  let protocol;
-  const version = async () => {
-    if (protocol === undefined) {
-      const status = await rawRequest(socket, { v: 0, cmd: "status" });
-      protocol = typeof status.protocol === "number" ? status.protocol : 0;
-    }
-    return protocol;
-  };
-  const send = async (cmd, fields) => rawRequest(socket, { v: await version(), cmd, client: { id: client.id, token: client.token }, ...fields });
-  const site = async (origin) => {
-    const reply = await send("agent-logins", { origin });
-    const raw = (Array.isArray(reply.logins) ? reply.logins : []).filter((login) => login !== null && typeof login === "object");
-    const logins = raw.map(toLogin);
-    let passkeys = passkeyList(reply.passkeys);
-    if (!Array.isArray(reply.passkeys)) {
-      passkeys = logins.filter((login) => login.hasPasskey).map((login) => ({ ref: login.ref, ...login.username ? { username: login.username } : {}, granted: login.passkeys }));
-    }
-    return { logins, passkeys };
-  };
-  return {
-    socket,
-    client,
-    status: async () => {
-      const status = await rawRequest(socket, { v: 0, cmd: "status" });
-      protocol = typeof status.protocol === "number" ? status.protocol : 0;
-      return { protocol, unlocked: status.unlocked === true, ...str(status.version) ? { version: str(status.version) } : {} };
-    },
-    logins: async (origin) => (await site(origin)).logins,
-    site: (origin) => site(origin),
-    fill: async (origin, login, want) => {
-      const reply = await send("agent-fill", { origin, login: login.ref, want: [...want] });
-      const values = reply.values ?? reply;
-      return {
-        ...str(values.username) !== undefined ? { username: str(values.username) } : {},
-        ...str(values.password) !== undefined ? { password: str(values.password) } : {},
-        ...str(values.totp) !== undefined ? { totp: str(values.totp) } : {}
-      };
-    },
-    passkeyGet: async (request) => {
-      const reply = await send("agent-passkey-get", {
-        origin: request.origin,
-        ...request.rpId ? { rp_id: request.rpId } : {},
-        challenge: request.challenge,
-        allow_credentials: [...request.allowCredentials],
-        user_verification: request.userVerification,
-        ...request.login !== undefined ? { login: request.login } : {}
-      });
-      if (reply.reply === "choose-passkey") {
-        throw new DeadboltError("choose_passkey", "Several passkeys could sign in here; name one by its username.", { choices: passkeyList(reply.choices ?? reply.passkeys) });
-      }
-      const credentialId = str(reply.credential_id);
-      const clientDataJson = str(reply.client_data_json);
-      const authenticatorData = str(reply.authenticator_data);
-      const signature = str(reply.signature);
-      if (!credentialId || !clientDataJson || !authenticatorData || !signature)
-        throw new DeadboltError("failed", "Deadbolt's passkey assertion is incomplete");
-      return { credentialId, clientDataJson, authenticatorData, signature, ...str(reply.user_handle) ? { userHandle: str(reply.user_handle) } : {} };
-    }
-  };
-}
-var deadboltNamePrefix = "deadbolt:";
-function parseDeadboltName(name) {
-  if (!name.startsWith(deadboltNamePrefix))
-    return;
-  const rest = name.slice(deadboltNamePrefix.length).trim();
-  const origin = /^https?:\/\/[^/]+/i.exec(rest);
-  const site = origin ? origin[0] : rest.split("/")[0];
-  const username = rest.slice(site.length + 1);
-  if (!site)
-    return;
-  return { site: site.toLowerCase(), ...username ? { username } : {} };
-}
-function originOnSite(origin, site) {
-  let url;
-  try {
-    url = new URL(origin);
-  } catch {
-    return false;
-  }
-  if (/^https?:\/\//i.test(site)) {
-    try {
-      return new URL(site).origin === url.origin;
-    } catch {
-      return false;
-    }
-  }
-  const host = url.hostname.toLowerCase();
-  const bare = site.replace(/^\*\./, "").replace(/:\d+$/, "").toLowerCase();
-  const local = host === "localhost" || host === "127.0.0.1" || host === "[::1]" || host.endsWith(".localhost");
-  if (url.protocol !== "https:" && !(url.protocol === "http:" && local))
-    return false;
-  return host === bare || host.endsWith(`.${bare}`);
-}
-function pickLogin(logins, site, username, field) {
-  const granted = logins.filter((login) => login.granted && (field === undefined || login.fields === undefined || login.fields.includes(field)));
-  const candidates = username === undefined ? granted : granted.filter((login) => login.username?.toLowerCase() === username.toLowerCase());
-  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("failed", `Several Deadbolt logins are granted for ${site}; name one: deadbolt:${site}/<username> (${candidates.map((login) => login.username ?? login.title).join(", ")})`);
-}
-function originsFromPatterns(patterns) {
-  const origins = new Set;
-  for (const pattern of patterns) {
-    const scheme = /^(https?):\/\//i.exec(pattern)?.[1]?.toLowerCase() ?? "https";
-    const host = pattern.replace(/^https?:\/\//i, "").replace(/^\*\./, "").replace(/\/$/, "");
-    try {
-      origins.add(new URL(`${scheme}://${host}`).origin);
-    } catch {}
-  }
-  return [...origins];
-}
-async function listLogins(origins, connection) {
-  let deadbolt;
-  try {
-    deadbolt = connection ?? connect();
-  } catch (error) {
-    return { connected: false, logins: [], passkeys: [], error: { code: error instanceof DeadboltError ? error.code : "failed", message: error instanceof Error ? error.message : String(error) } };
-  }
-  const logins = [];
-  const passkeys = [];
-  for (const origin of origins.slice(0, 20)) {
-    try {
-      const found = await deadbolt.site(origin);
-      for (const { ref: _ref, ...login } of found.logins)
-        logins.push({ ...login, origin });
-      for (const { ref: _ref, ...passkey } of found.passkeys)
-        passkeys.push({ ...passkey, origin });
-    } catch (error) {
-      if (error instanceof DeadboltError && (error.code === "domain_mismatch" || error.code === "not_found" || error.code === "not_granted"))
-        continue;
-      return { connected: true, logins, passkeys, error: { code: error instanceof DeadboltError ? error.code : "failed", message: error instanceof Error ? error.message : String(error) } };
-    }
-  }
-  return { connected: true, logins, passkeys };
-}
-function pickPasskey(passkeys, username) {
-  const wanted = username.toLowerCase();
-  const granted = passkeys.filter((passkey) => passkey.granted);
-  return granted.find((passkey) => passkey.username?.toLowerCase() === wanted) ?? granted.find((passkey) => passkey.displayName?.toLowerCase() === wanted);
-}
-async function pair(options = {}) {
-  const command = options.command ?? (process.env.OPENCODE_BROWSER_DEADBOLT_CLI || "deadbolt");
-  const stdout = await new Promise((resolve, reject) => {
-    const child = spawn(command, ["agents", "add-client", options.name ?? "browse", "--json"], { stdio: ["inherit", "pipe", "inherit"] });
-    let output = "";
-    child.stdout.setEncoding("utf8");
-    child.stdout.on("data", (chunk) => {
-      output += chunk;
-    });
-    child.on("error", (cause) => reject(new DeadboltError("unavailable", cause.code === "ENOENT" ? `${command} isn't installed or on PATH. Install Deadbolt first.` : `Could not run ${command}: ${cause.message}`)));
-    child.on("close", (code) => code === 0 ? resolve(output) : reject(new DeadboltError("failed", `deadbolt agents add-client exited with status ${code}`)));
-  });
-  let parsed;
-  try {
-    const line = stdout.trim().split(`
-`).filter(Boolean).at(-1) ?? "";
-    parsed = JSON.parse(line);
-  } catch {
-    throw new DeadboltError("failed", "deadbolt agents add-client --json didn't print a client");
-  }
-  const client = parsed.client ?? parsed;
-  const id = str(client.id);
-  const token = str(client.token) ?? str(parsed.token);
-  if (!id || !token)
-    throw new DeadboltError("failed", "deadbolt agents add-client --json printed no id and token");
-  await saveClient({ id, token }, options.root);
-  return { id };
-}
-function unpair(options = {}) {
-  const client = readClient(options.root);
-  if (!client)
-    return { removed: false, revoked: false };
-  const command = options.command ?? (process.env.OPENCODE_BROWSER_DEADBOLT_CLI || "deadbolt");
-  const result = spawnSync(command, ["agents", "remove-client", client.id], { stdio: ["inherit", "ignore", "inherit"], timeout: 120000 });
-  return { removed: removeClient(options.root), revoked: result.status === 0 };
-}
-function isBase64Url(value, maxLength = 8192) {
-  return typeof value === "string" && value.length <= maxLength && /^[A-Za-z0-9_-]*$/.test(value);
-}
-function randomName(prefix) {
-  return `${prefix}${crypto.randomBytes(12).toString("hex")}`;
-}
-var blake3Iv = [1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924, 528734635, 1541459225];
-var blake3Permutation = [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8];
-function blake3Compress(cv, block, blockLength, flags) {
-  const s = new Uint32Array([...cv, blake3Iv[0], blake3Iv[1], blake3Iv[2], blake3Iv[3], 0, 0, blockLength, flags]);
-  let m = Uint32Array.from(block);
-  const rotr = (x, n) => x >>> n | x << 32 - n;
-  const g = (a, b, c, d, x, y) => {
-    s[a] = s[a] + s[b] + x;
-    s[d] = rotr(s[d] ^ s[a], 16);
-    s[c] = s[c] + s[d];
-    s[b] = rotr(s[b] ^ s[c], 12);
-    s[a] = s[a] + s[b] + y;
-    s[d] = rotr(s[d] ^ s[a], 8);
-    s[c] = s[c] + s[d];
-    s[b] = rotr(s[b] ^ s[c], 7);
-  };
-  for (let round = 0;round < 7; round++) {
-    g(0, 4, 8, 12, m[0], m[1]);
-    g(1, 5, 9, 13, m[2], m[3]);
-    g(2, 6, 10, 14, m[4], m[5]);
-    g(3, 7, 11, 15, m[6], m[7]);
-    g(0, 5, 10, 15, m[8], m[9]);
-    g(1, 6, 11, 12, m[10], m[11]);
-    g(2, 7, 8, 13, m[12], m[13]);
-    g(3, 4, 9, 14, m[14], m[15]);
-    if (round < 6)
-      m = Uint32Array.from(blake3Permutation, (index) => m[index]);
-  }
-  return Array.from({ length: 8 }, (_, index) => (s[index] ^ s[index + 8]) >>> 0);
-}
-function blake3Hex(input) {
-  if (input.length > 1024)
-    throw new Error("blake3Hex handles inputs up to 1024 bytes (DEADBOLT_HOME is longer: set OPENCODE_BROWSER_DEADBOLT_SOCKET)");
-  const blocks = Math.max(1, Math.ceil(input.length / 64));
-  let cv = [...blake3Iv];
-  for (let index = 0;index < blocks; index++) {
-    const bytes = new Uint8Array(64);
-    const chunk = input.subarray(index * 64, index * 64 + 64);
-    bytes.set(chunk);
-    const words = new Uint32Array(16);
-    const view = new DataView(bytes.buffer);
-    for (let word = 0;word < 16; word++)
-      words[word] = view.getUint32(word * 4, true);
-    const flags = (index === 0 ? 1 : 0) | (index === blocks - 1 ? 2 | 8 : 0);
-    cv = blake3Compress(cv, words, chunk.length, flags);
-  }
-  const out = Buffer.alloc(32);
-  cv.forEach((word, index) => out.writeUInt32LE(word, index * 4));
-  return out.toString("hex");
-}
-
 // src/auth/site-secrets.ts
-import crypto2 from "node:crypto";
-import fs3 from "node:fs/promises";
-import path3 from "node:path";
-import { Effect as Effect3, Schema as Schema2 } from "effect";
-
-// src/auth/profile.ts
-import { Effect as Effect2, Schema, Semaphore } from "effect";
-import { spawn as spawn2 } from "node:child_process";
+import crypto from "node:crypto";
 import fs2 from "node:fs/promises";
 import path2 from "node:path";
 
+// src/auth/profile.ts
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+
 // src/update/child-process.ts
 async function terminateChildProcess(options) {
   const isExited = options.isExited ?? (() => options.child.exitCode !== null || options.child.signalCode !== null);
@@ -784,7 +1669,6 @@ function signalChildProcess(child, signal) {
 }
 
 // src/network-capture/redaction.ts
-import { Predicate as Predicate2 } from "effect";
 var secretNamePattern = /auth(?:orization)?|cookie|credential|csrf|xsrf|token|secret|session|password|passwd|pwd|passcode|otp|(?:^|[-_.])code(?:$|[-_.])|(?:api|access|refresh)[-_.]?key|signature|(?:^|[-_.])sig(?:$|[-_.])/i;
 var oneTimeFieldPattern = /pass(?:word|wd|code|phrase)|(?:^|[-_.])pwd(?:$|[-_.])|otp|totp|(?:^|[-_.])(?:mfa_?|2fa_?|verification_?|auth_?)?code(?:$|[-_.])|(?:^|[-_.])pin(?:$|[-_.])/i;
 var referencePattern = String.raw`BC_(?:SECRET|REDACTED)_\d+`;
@@ -891,7 +1775,7 @@ class SecretCollector {
     return redactKnownValue(value, this.redactionSlots());
   }
   redactExactValue(value, minimumLength) {
-    if (!Predicate2.isString(value) && !Predicate2.isNumber(value) && !Predicate2.isBoolean(value))
+    if (!isString(value) && !isNumber(value) && !isBoolean(value))
       return value;
     const serialized = String(value);
     if (serialized.length < minimumLength)
@@ -982,7 +1866,7 @@ class SecretCollector {
     if (Array.isArray(value)) {
       return value.map((item, index) => this.protectJson(item, location, [...path, String(index)], inSecret));
     }
-    if (Predicate2.isObject(value)) {
+    if (isObject(value)) {
       return Object.fromEntries(Object.entries(value).map(([key, item]) => [
         key,
         this.protectJson(item, location, [...path, key], inSecret || secretNamePattern.test(key))
@@ -1176,15 +2060,15 @@ function redactKnownValues(text, slots) {
   return [...slots].sort((left, right) => right.value.length - left.value.length).reduce((output, slot) => replaceOutsideReferences(output, slot.value, `\${${slot.ref}}`), text);
 }
 function redactKnownValue(value, slots) {
-  if (Predicate2.isString(value))
+  if (isString(value))
     return redactKnownValues(value, slots);
-  if (Predicate2.isNumber(value) || Predicate2.isBoolean(value)) {
+  if (isNumber(value) || isBoolean(value)) {
     const slot = slots.find((candidate) => candidate.value === String(value));
     return slot ? `\${${slot.ref}}` : value;
   }
   if (Array.isArray(value))
     return value.map((item) => redactKnownValue(item, slots));
-  if (!Predicate2.isObject(value))
+  if (!isObject(value))
     return value;
   return Object.fromEntries(Object.entries(value).map(([key, item]) => [
     key,
@@ -1194,7 +2078,7 @@ function redactKnownValue(value, slots) {
 function redactSecretValue(value) {
   if (Array.isArray(value))
     return value.map(redactSecretValue);
-  if (Predicate2.isObject(value)) {
+  if (isObject(value)) {
     return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactSecretValue(item)]));
   }
   return value === null || value === "" ? value : "[REDACTED]";
@@ -1219,26 +2103,26 @@ function jwtExpiration(value) {
     return;
   try {
     const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
-    return Predicate2.isNumber(payload.exp) ? new Date(payload.exp * 1000).toISOString() : undefined;
+    return isNumber(payload.exp) ? new Date(payload.exp * 1000).toISOString() : undefined;
   } catch {
     return;
   }
 }
 
 // src/auth/profile.ts
-var StoredCredentialSlot = Schema.Struct({
-  ref: Schema.String.check(Schema.isPattern(/^BC_SECRET_[1-9][0-9]*$/)),
-  value: Schema.String,
-  sources: Schema.Array(Schema.String),
-  expiresAt: Schema.optionalKey(Schema.String)
+var StoredCredentialSlot = Struct({
+  ref: String3.check(isPattern(/^BC_SECRET_[1-9][0-9]*$/)),
+  value: String3,
+  sources: ArraySchema(String3),
+  expiresAt: optionalKey(String3)
 });
-var StoredAuthProfile = Schema.Struct({
-  version: Schema.Literal(1),
-  name: Schema.String,
-  createdAt: Schema.String,
-  updatedAt: Schema.String,
-  slots: Schema.Array(StoredCredentialSlot)
-}).check(Schema.makeFilter((profile) => {
+var StoredAuthProfile = Struct({
+  version: Literal(1),
+  name: String3,
+  createdAt: String3,
+  updatedAt: String3,
+  slots: ArraySchema(StoredCredentialSlot)
+}).check(makeFilter((profile) => {
   const refs = profile.slots.map((slot) => slot.ref);
   if (new Set(refs).size !== refs.length)
     return "Auth profile refs must be unique";
@@ -1246,46 +2130,46 @@ var StoredAuthProfile = Schema.Struct({
   return new Set(sources).size === sources.length ? undefined : "Auth profile sources must be unique";
 }));
 
-class AuthProfileError extends Schema.TaggedError()("AuthProfile.Error", {
-  message: Schema.String,
-  operation: Schema.String,
-  reason: Schema.Literals(["invalid-name", "not-found", "read-failed", "invalid-json", "invalid-profile", "write-failed", "run-failed"]),
-  cause: Schema.optionalKey(Schema.Defect())
+class AuthProfileError extends TaggedError2()("AuthProfile.Error", {
+  message: String3,
+  operation: String3,
+  reason: Literals(["invalid-name", "not-found", "read-failed", "invalid-json", "invalid-profile", "write-failed", "run-failed"]),
+  cause: optionalKey(Defect())
 }) {
 }
-var defaultBaseDir = () => path2.join(dataRoot(), "secrets");
-var writeLock = Semaphore.makeUnsafe(1);
+var defaultBaseDir = () => path.join(dataRoot(), "secrets");
+var writeLock = makeUnsafe(1);
 var profileLockTimeoutMs = 30000;
 var staleProfileLockMs = 60000;
 var maximumRunOutputBytes = 1e7;
 var maximumTimeoutMs = 2147483647;
-var read = Effect2.fn("AuthProfile.read")(function* (name, options = {}) {
+var read = fn("AuthProfile.read")(function* (name, options = {}) {
   const filePath = yield* profilePath(options.baseDir ?? defaultBaseDir(), name);
-  const text = yield* Effect2.tryPromise({
-    try: () => fs2.readFile(filePath, "utf8"),
+  const text = yield* tryPromise({
+    try: () => fs.readFile(filePath, "utf8"),
     catch: (cause) => isNodeError(cause) && cause.code === "ENOENT" ? new AuthProfileError({ message: `Auth profile not found: ${name}`, operation: "read", reason: "not-found", cause }) : new AuthProfileError({ message: `Could not read auth profile: ${name}`, operation: "read", reason: "read-failed", cause })
   });
-  return yield* Schema.decodeUnknownEffect(StoredAuthProfile)(yield* Effect2.try({
+  return yield* decodeUnknownEffect2(StoredAuthProfile)(yield* try_({
     try: () => JSON.parse(text),
     catch: (cause) => new AuthProfileError({ message: `Auth profile is not valid JSON: ${name}`, operation: "read", reason: "invalid-json", cause })
-  })).pipe(Effect2.mapError((cause) => cause instanceof AuthProfileError ? cause : new AuthProfileError({ message: `Auth profile has an invalid shape: ${name}`, operation: "read", reason: "invalid-profile", cause })));
+  })).pipe(mapError((cause) => cause instanceof AuthProfileError ? cause : new AuthProfileError({ message: `Auth profile has an invalid shape: ${name}`, operation: "read", reason: "invalid-profile", cause })));
 });
-var readOptional = Effect2.fn("AuthProfile.readOptional")(function* (name, options = {}) {
-  return yield* read(name, options).pipe(Effect2.catchIf((error) => error.reason === "not-found", () => Effect2.succeed(undefined)));
+var readOptional = fn("AuthProfile.readOptional")(function* (name, options = {}) {
+  return yield* read(name, options).pipe(catchIf((error) => error.reason === "not-found", () => succeed6(undefined)));
 });
 function withLock(name, options, effect) {
   const baseDir = options.baseDir ?? defaultBaseDir();
-  const acquire = Effect2.gen(function* () {
+  const acquire = gen(function* () {
     const filePath = yield* profilePath(baseDir, name);
     const lockPath = `${filePath}.lock`;
-    yield* Effect2.tryPromise({
+    yield* tryPromise({
       try: async () => {
-        await fs2.mkdir(baseDir, { recursive: true, mode: 448 });
-        await fs2.chmod(baseDir, 448);
+        await fs.mkdir(baseDir, { recursive: true, mode: 448 });
+        await fs.chmod(baseDir, 448);
         const deadline = Date.now() + profileLockTimeoutMs;
         while (true) {
           try {
-            const handle = await fs2.open(lockPath, "wx", 384);
+            const handle = await fs.open(lockPath, "wx", 384);
             let written = false;
             try {
               await handle.writeFile(`${process.pid}
@@ -1294,17 +2178,17 @@ function withLock(name, options, effect) {
             } finally {
               await handle.close();
               if (!written)
-                await fs2.unlink(lockPath).catch(() => {});
+                await fs.unlink(lockPath).catch(() => {});
             }
             return;
           } catch (cause) {
             if (!isNodeError(cause) || cause.code !== "EEXIST")
               throw cause;
-            const stat = await fs2.stat(lockPath).catch(() => {
+            const stat = await fs.stat(lockPath).catch(() => {
               return;
             });
             if (stat && Date.now() - stat.mtimeMs > staleProfileLockMs) {
-              await fs2.unlink(lockPath).catch(() => {});
+              await fs.unlink(lockPath).catch(() => {});
               continue;
             }
             if (Date.now() >= deadline)
@@ -1317,12 +2201,12 @@ function withLock(name, options, effect) {
     });
     return lockPath;
   });
-  return Effect2.acquireUseRelease(acquire, () => effect, (lockPath) => Effect2.tryPromise({
-    try: () => fs2.unlink(lockPath).catch(() => {}).then(() => {}),
+  return acquireUseRelease(acquire, () => effect, (lockPath) => tryPromise({
+    try: () => fs.unlink(lockPath).catch(() => {}).then(() => {}),
     catch: (cause) => new AuthProfileError({ message: `Could not release auth profile lock: ${name}`, operation: "lock", reason: "write-failed", cause })
   }));
 }
-var writeProfile = Effect2.fnUntraced(function* (options) {
+var writeProfile = fnUntraced(function* (options) {
   const baseDir = options.baseDir ?? defaultBaseDir();
   const filePath = yield* profilePath(baseDir, options.name);
   const existing = yield* readOptional(options.name, { baseDir });
@@ -1339,22 +2223,22 @@ var writeProfile = Effect2.fnUntraced(function* (options) {
       ...slot.expiresAt ? { expiresAt: slot.expiresAt } : {}
     }))
   };
-  yield* Schema.decodeUnknownEffect(StoredAuthProfile)(profile).pipe(Effect2.mapError((cause) => new AuthProfileError({ message: `Auth profile has an invalid shape: ${options.name}`, operation: "write", reason: "invalid-profile", cause })));
+  yield* decodeUnknownEffect2(StoredAuthProfile)(profile).pipe(mapError((cause) => new AuthProfileError({ message: `Auth profile has an invalid shape: ${options.name}`, operation: "write", reason: "invalid-profile", cause })));
   if (existing && sameSlots(existing.slots, profile.slots))
     return summary(existing);
-  yield* Effect2.tryPromise({
+  yield* tryPromise({
     try: () => writeJsonFileAtomically(filePath, profile, { dirMode: 448 }),
     catch: (cause) => new AuthProfileError({ message: `Could not write auth profile: ${options.name}`, operation: "write", reason: "write-failed", cause })
   });
   return summary(profile);
 });
-var write = Effect2.fn("AuthProfile.write")(function* (options) {
+var write = fn("AuthProfile.write")(function* (options) {
   return yield* writeLock.withPermit(writeProfile(options));
 });
-var status = Effect2.fn("AuthProfile.status")(function* (name, options = {}) {
+var status = fn("AuthProfile.status")(function* (name, options = {}) {
   return summary(yield* read(name, options));
 });
-var run = Effect2.fn("AuthProfile.run")(function* (options) {
+var run = fn("AuthProfile.run")(function* (options) {
   if (!options.command.trim()) {
     return yield* new AuthProfileError({ message: "Auth command must not be empty", operation: "run", reason: "run-failed" });
   }
@@ -1376,7 +2260,7 @@ var run = Effect2.fn("AuthProfile.run")(function* (options) {
     timeoutMs,
     maxOutputBytes: maxOutputBytes + maxSecretBytes,
     env: Object.fromEntries(profile.slots.map((slot) => [slot.ref, slot.value]))
-  }).pipe(Effect2.mapError((cause) => new AuthProfileError({ message: `Could not run command with auth profile ${options.name}`, operation: "run", reason: "run-failed", cause })));
+  }).pipe(mapError((cause) => new AuthProfileError({ message: `Could not run command with auth profile ${options.name}`, operation: "run", reason: "run-failed", cause })));
   const stdout = redactOutput(result.stdout, profile.slots, maxOutputBytes);
   const stderr = redactOutput(result.stderr, profile.slots, maxOutputBytes);
   return {
@@ -1405,7 +2289,7 @@ function summary(profile) {
 }
 var profileNamePattern = /^[a-z0-9][a-z0-9._-]{0,63}$/i;
 function profilePath(baseDir, name) {
-  return profileNamePattern.test(name) ? Effect2.succeed(path2.join(baseDir, `${name}.json`)) : Effect2.fail(new AuthProfileError({ message: `Invalid auth profile name: ${name}`, operation: "path", reason: "invalid-name" }));
+  return profileNamePattern.test(name) ? succeed6(path.join(baseDir, `${name}.json`)) : fail4(new AuthProfileError({ message: `Invalid auth profile name: ${name}`, operation: "path", reason: "invalid-name" }));
 }
 function sameSlots(left, right) {
   return JSON.stringify(left) === JSON.stringify(right);
@@ -1437,8 +2321,8 @@ function redactOutput(text, slots, maxBytes) {
   };
 }
 function runChild(options) {
-  return Effect2.callback((resume) => {
-    const child = spawn2(options.command, [...options.args], {
+  return callback2((resume) => {
+    const child = spawn(options.command, [...options.args], {
       ...options.cwd ? { cwd: options.cwd } : {},
       env: childEnvironment(options.env),
       detached: process.platform !== "win32",
@@ -1483,7 +2367,7 @@ function runChild(options) {
       if (settled)
         return;
       settled = true;
-      resume(Effect2.fail(cause));
+      resume(fail4(cause));
     });
     child.once("close", (code, signal) => {
       clearTimeout(timeout);
@@ -1492,7 +2376,7 @@ function runChild(options) {
       if (settled)
         return;
       settled = true;
-      resume(Effect2.succeed({
+      resume(succeed6({
         exitCode: code ?? 1,
         signal,
         stdout: Buffer.concat(stdout).toString("utf8"),
@@ -1501,7 +2385,7 @@ function runChild(options) {
         stderrTruncated
       }));
     });
-    return Effect2.promise(() => terminateChildProcess({ child, exit: closePromise, graceMs: 1000, isExited: () => closed }));
+    return promise(() => terminateChildProcess({ child, exit: closePromise, graceMs: 1000, isExited: () => closed }));
   });
 }
 function childEnvironment(profile) {
@@ -1511,7 +2395,7 @@ function childEnvironment(profile) {
 
 // src/auth/domain-policy.ts
 import dns from "node:dns/promises";
-import net2 from "node:net";
+import net from "node:net";
 
 class OriginPatternError extends Error {
   name = "OriginPatternError";
@@ -1547,7 +2431,7 @@ function parseOriginPattern(raw) {
     throw new OriginPatternError(`Origin pattern ${JSON.stringify(raw)} must be a host or origin`);
   }
   const host = unbracket(parsed.hostname.toLowerCase());
-  if (wildcard && net2.isIP(host))
+  if (wildcard && net.isIP(host))
     throw new OriginPatternError(`Origin pattern ${JSON.stringify(raw)}: wildcards don't apply to IP addresses`);
   if (wildcard && !host.includes("."))
     throw new OriginPatternError(`Origin pattern ${JSON.stringify(raw)}: "*." needs a domain with a dot, like *.example.com`);
@@ -1592,14 +2476,14 @@ var privateIpv4Ranges = [
 ];
 function isPrivateAddress(address) {
   const ip = unbracket(address.toLowerCase()).replace(/%.*$/, "");
-  if (net2.isIPv4(ip)) {
+  if (net.isIPv4(ip)) {
     const value = ipv4ToNumber(ip);
     return privateIpv4Ranges.some(([base, bits]) => {
       const mask = bits === 0 ? 0 : 4294967295 << 32 - bits >>> 0;
       return (value & mask) >>> 0 === (ipv4ToNumber(base) & mask) >>> 0;
     });
   }
-  if (net2.isIPv6(ip)) {
+  if (net.isIPv6(ip)) {
     if (ip === "::" || ip === "::1")
       return true;
     const mapped = /^(?:0*:)*:?ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(ip) ?? /^::(\d+\.\d+\.\d+\.\d+)$/.exec(ip);
@@ -1625,7 +2509,7 @@ function isLocalhostName(host) {
 }
 function isPrivateHost(host) {
   const bare = unbracket(host.toLowerCase());
-  return isLocalhostName(bare) || net2.isIP(bare) !== 0 && isPrivateAddress(bare);
+  return isLocalhostName(bare) || net.isIP(bare) !== 0 && isPrivateAddress(bare);
 }
 function defaultPort(protocol) {
   return protocol === "https:" ? "443" : "80";
@@ -1676,7 +2560,7 @@ function checkUrl(rawUrl, rules, options = {}) {
 }
 async function resolvesToPrivateAddress(host, timeoutMs = 2000) {
   const bare = unbracket(host);
-  if (net2.isIP(bare) || isLocalhostName(bare))
+  if (net.isIP(bare) || isLocalhostName(bare))
     return isPrivateHost(bare) ? bare : undefined;
   let timer;
   try {
@@ -1706,45 +2590,45 @@ async function checkNavigationUrl(rawUrl, rules) {
 }
 
 // src/auth/site-secrets.ts
-var StoredSiteSecret = Schema2.Struct({
-  version: Schema2.Literal(1),
-  name: Schema2.String,
-  kind: Schema2.Literals(["password", "totp"]),
-  value: Schema2.String,
-  allowedOrigins: Schema2.Array(Schema2.String),
-  createdAt: Schema2.String,
-  updatedAt: Schema2.String
+var StoredSiteSecret = Struct({
+  version: Literal(1),
+  name: String3,
+  kind: Literals(["password", "totp"]),
+  value: String3,
+  allowedOrigins: ArraySchema(String3),
+  createdAt: String3,
+  updatedAt: String3
 });
 
-class SiteSecretError extends Schema2.TaggedError()("SiteSecret.Error", {
-  message: Schema2.String,
-  reason: Schema2.Literals(["invalid-name", "invalid-origins", "invalid-value", "not-found", "read-failed", "write-failed"]),
-  cause: Schema2.optionalKey(Schema2.Defect())
+class SiteSecretError extends TaggedError2()("SiteSecret.Error", {
+  message: String3,
+  reason: Literals(["invalid-name", "invalid-origins", "invalid-value", "not-found", "read-failed", "write-failed"]),
+  cause: optionalKey(Defect())
 }) {
 }
-var defaultSiteSecretsDir = () => path3.join(dataRoot(), "site-secrets");
+var defaultSiteSecretsDir = () => path2.join(dataRoot(), "site-secrets");
 function secretPath(baseDir, name) {
-  return profileNamePattern.test(name) ? Effect3.succeed(path3.join(baseDir, `${name}.json`)) : Effect3.fail(new SiteSecretError({ message: `Invalid secret name: ${name} (letters, digits, ".", "_" and "-", up to 64)`, reason: "invalid-name" }));
+  return profileNamePattern.test(name) ? succeed6(path2.join(baseDir, `${name}.json`)) : fail4(new SiteSecretError({ message: `Invalid secret name: ${name} (letters, digits, ".", "_" and "-", up to 64)`, reason: "invalid-name" }));
 }
 function summary2(secret) {
   return { name: secret.name, kind: secret.kind, allowedOrigins: [...secret.allowedOrigins], createdAt: secret.createdAt, updatedAt: secret.updatedAt };
 }
-var readSecret = Effect3.fn("SiteSecrets.read")(function* (name, options = {}) {
+var readSecret = fn("SiteSecrets.read")(function* (name, options = {}) {
   const filePath = yield* secretPath(options.baseDir ?? defaultSiteSecretsDir(), name);
-  const text = yield* Effect3.tryPromise({
-    try: () => fs3.readFile(filePath, "utf8"),
+  const text = yield* tryPromise({
+    try: () => fs2.readFile(filePath, "utf8"),
     catch: (cause) => isNodeError(cause) && cause.code === "ENOENT" ? new SiteSecretError({ message: `Secret not found: ${name}. Ask the user to add it with \`opencode-browser secrets add ${name} --origin <origin>\`.`, reason: "not-found" }) : new SiteSecretError({ message: `Could not read secret ${name}`, reason: "read-failed", cause })
   });
-  return yield* Effect3.try({
-    try: () => Schema2.decodeUnknownSync(StoredSiteSecret)(JSON.parse(text)),
+  return yield* try_({
+    try: () => decodeUnknownSync(StoredSiteSecret)(JSON.parse(text)),
     catch: (cause) => new SiteSecretError({ message: `Secret ${name} is not a valid secret file`, reason: "read-failed", cause })
   });
 });
-var addSecret = Effect3.fn("SiteSecrets.add")(function* (options) {
+var addSecret = fn("SiteSecrets.add")(function* (options) {
   const baseDir = options.baseDir ?? defaultSiteSecretsDir();
   const filePath = yield* secretPath(baseDir, options.name);
   const kind = options.kind ?? "password";
-  const allowedOrigins = yield* Effect3.try({
+  const allowedOrigins = yield* try_({
     try: () => normalizeOriginPatterns(options.allowedOrigins),
     catch: (cause) => new SiteSecretError({ message: cause instanceof Error ? cause.message : "Invalid origins", reason: "invalid-origins", cause })
   });
@@ -1755,43 +2639,43 @@ var addSecret = Effect3.fn("SiteSecrets.add")(function* (options) {
   if (!value)
     return yield* new SiteSecretError({ message: "The secret value is empty", reason: "invalid-value" });
   if (kind === "totp")
-    yield* Effect3.try({
+    yield* try_({
       try: () => totpCode(value),
       catch: (cause) => new SiteSecretError({ message: `Not a TOTP seed or otpauth:// URI: ${cause instanceof Error ? cause.message : "invalid"}`, reason: "invalid-value", cause })
     });
-  const write = Effect3.gen(function* () {
-    const existing = yield* readSecret(options.name, { baseDir }).pipe(Effect3.catchIf((error) => error.reason === "not-found", () => Effect3.succeed(undefined)));
+  const write = gen(function* () {
+    const existing = yield* readSecret(options.name, { baseDir }).pipe(catchIf((error) => error.reason === "not-found", () => succeed6(undefined)));
     const now = new Date().toISOString();
     const secret = { version: 1, name: options.name, kind, value, allowedOrigins: [...allowedOrigins], createdAt: existing?.createdAt ?? now, updatedAt: now };
-    yield* Effect3.tryPromise({
+    yield* tryPromise({
       try: () => writeJsonFileAtomically(filePath, secret, { dirMode: 448 }),
       catch: (cause) => new SiteSecretError({ message: `Could not write secret ${options.name}`, reason: "write-failed", cause })
     });
     return summary2(secret);
   });
-  return yield* withLock(options.name, { baseDir }, write).pipe(Effect3.mapError((error) => error instanceof SiteSecretError ? error : new SiteSecretError({ message: error.message, reason: "write-failed", cause: error })));
+  return yield* withLock(options.name, { baseDir }, write).pipe(mapError((error) => error instanceof SiteSecretError ? error : new SiteSecretError({ message: error.message, reason: "write-failed", cause: error })));
 });
-var listSecrets = Effect3.fn("SiteSecrets.list")(function* (options = {}) {
+var listSecrets = fn("SiteSecrets.list")(function* (options = {}) {
   const baseDir = options.baseDir ?? defaultSiteSecretsDir();
-  const names = yield* Effect3.tryPromise({
-    try: () => fs3.readdir(baseDir).catch((cause) => isNodeError(cause) && cause.code === "ENOENT" ? [] : Promise.reject(cause)),
+  const names = yield* tryPromise({
+    try: () => fs2.readdir(baseDir).catch((cause) => isNodeError(cause) && cause.code === "ENOENT" ? [] : Promise.reject(cause)),
     catch: (cause) => new SiteSecretError({ message: "Could not list secrets", reason: "read-failed", cause })
   });
   const secrets = [];
   for (const file of names.filter((entry) => entry.endsWith(".json")).sort()) {
-    const secret = yield* readSecret(file.slice(0, -".json".length), { baseDir }).pipe(Effect3.option);
+    const secret = yield* readSecret(file.slice(0, -".json".length), { baseDir }).pipe(option2);
     if (secret._tag === "Some")
       secrets.push(summary2(secret.value));
   }
   return secrets;
 });
-var removeSecret = Effect3.fn("SiteSecrets.remove")(function* (name, options = {}) {
+var removeSecret = fn("SiteSecrets.remove")(function* (name, options = {}) {
   const baseDir = options.baseDir ?? defaultSiteSecretsDir();
   const filePath = yield* secretPath(baseDir, name);
-  return yield* withLock(name, { baseDir }, Effect3.tryPromise({
-    try: () => fs3.rm(filePath).then(() => true, (cause) => isNodeError(cause) && cause.code === "ENOENT" ? false : Promise.reject(cause)),
+  return yield* withLock(name, { baseDir }, tryPromise({
+    try: () => fs2.rm(filePath).then(() => true, (cause) => isNodeError(cause) && cause.code === "ENOENT" ? false : Promise.reject(cause)),
     catch: (cause) => new SiteSecretError({ message: `Could not remove secret ${name}`, reason: "write-failed", cause })
-  })).pipe(Effect3.mapError((error) => error instanceof SiteSecretError ? error : new SiteSecretError({ message: error.message, reason: "write-failed", cause: error })));
+  })).pipe(mapError((error) => error instanceof SiteSecretError ? error : new SiteSecretError({ message: error.message, reason: "write-failed", cause: error })));
 });
 function base32Decode(input) {
   const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
@@ -1831,7 +2715,7 @@ function totpCode(seed, now = Date.now()) {
   const { key, digits, period, algorithm } = totpParameters(seed);
   const counter = Buffer.alloc(8);
   counter.writeBigUInt64BE(BigInt(Math.floor(now / 1000 / period)));
-  const hmac = crypto2.createHmac(algorithm, key).update(counter).digest();
+  const hmac = crypto.createHmac(algorithm, key).update(counter).digest();
   const offset = hmac[hmac.length - 1] & 15;
   const binary = (hmac.readUInt32BE(offset) & 2147483647) % 10 ** digits;
   return String(binary).padStart(digits, "0");
@@ -1840,4 +2724,4 @@ function secretText(secret) {
   return secret.kind === "totp" ? totpCode(secret.value) : secret.value;
 }
 
-export { settingKeys, settingSpecs, securityVariables, SettingsInputError, parseSettingChanges, settingsFromExtension, settingsToExtension, describeSettings, describeChanges, formatSettings, browsersNote2, mcpUpdateNote2, objectSchema, emptyInputSchema, sessionSchemaProperty, sessionAliasSchemaProperty, sessionOnlyInputSchema, ensureSessionExists, parseExecuteArguments, parseAdoptArguments, requiredStringField, optionalStringField, optionalBooleanField, optionalPositiveIntegerField, optionalStringArrayField, requireObject, toolResultForValue2, mcpErrorMessage2, toolResult, DeadboltError, readClient, socketPath, connect, parseDeadboltName, originOnSite, pickLogin, originsFromPatterns, listLogins, pickPasskey, pair, unpair, isBase64Url, randomName, terminateChildProcess, SecretCollector, looksLikeTokenSegment, AuthProfileError, read, readOptional, withLock, write, status, run, OriginPatternError, parseOriginPatterns, normalizeOriginPatterns, isPrivateAddress, explicitlyAllowsHost, checkUrl, checkNavigationUrl, readSecret, addSecret, listSecrets, removeSecret, secretText };
+export { makeUnsafe, make, isStreamSchema, getStreamSchemas, ClientAbort, ServerClient, make2, exitSchema, isWrapper, make3, Implementation, ClientCapabilities, INVALID_REQUEST_ERROR_CODE, METHOD_NOT_FOUND_ERROR_CODE, INVALID_PARAMS_ERROR_CODE, INTERNAL_ERROR_CODE, HEADER_MISMATCH_ERROR_CODE, ParseError, InvalidRequest, MethodNotFound, InvalidParams, InternalError, McpError, Ping, Initialize, CancelledNotification, ProgressNotification, ResourceListChangedNotification, ResourceUpdatedNotification, TextContent, PromptListChangedNotification, Tool, CallToolResult, ToolListChangedNotification, LoggingLevel, LoggingMessageNotification, CreateMessage, ListRootsResult, ListRoots, Elicit, McpReverseOperationUnsupported, McpReverseOperationError, McpRequestContext, McpServerClient, McpServerClientMiddleware, ServerNotificationRpcs, EnabledWhen, settingKeys, settingSpecs, securityVariables, SettingsInputError, parseSettingChanges, settingsFromExtension, settingsToExtension, describeSettings, describeChanges, formatSettings, browsersNote2, mcpUpdateNote2, objectSchema, emptyInputSchema, sessionSchemaProperty, sessionAliasSchemaProperty, sessionOnlyInputSchema, ensureSessionExists, parseExecuteArguments, parseAdoptArguments, requiredStringField, optionalStringField, optionalBooleanField, optionalPositiveIntegerField, optionalStringArrayField, requireObject, toolResultForValue2, mcpErrorMessage2, toolResult, terminateChildProcess, SecretCollector, looksLikeTokenSegment, AuthProfileError, read, readOptional, withLock, write, status, run, OriginPatternError, parseOriginPatterns, normalizeOriginPatterns, isPrivateAddress, explicitlyAllowsHost, checkUrl, checkNavigationUrl, readSecret, addSecret, listSecrets, removeSecret, secretText };