opencode-secrets-obfuscation 0.1.0 → 0.1.2

package/plugin.mjs

@@ -0,0 +1,3847 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@opencode/plugin/dist/effect/plugin.js
+var plugin_exports = {};
+__export(plugin_exports, {
+  define: () => define
+});
+function define(plugin2) {
+  return plugin2;
+}
+
+// node_modules/@opencode/schema/dist/agent.js
+var agent_exports = {};
+__export(agent_exports, {
+  Agent: () => agent_exports,
+  Color: () => Color,
+  Event: () => Event7,
+  ID: () => ID8,
+  Info: () => Info7,
+  Name: () => Name
+});
+import { Schema as Schema17 } from "effect";
+
+// node_modules/@opencode/schema/dist/event.js
+var event_exports = {};
+__export(event_exports, {
+  Event: () => event_exports,
+  ID: () => ID,
+  Seq: () => Seq,
+  Version: () => Version,
+  durable: () => durable,
+  durableMap: () => durableMap,
+  ephemeral: () => ephemeral,
+  inventory: () => inventory,
+  latest: () => latest,
+  versionedType: () => versionedType
+});
+import { Schema as Schema5, SchemaTransformation } from "effect";
+
+// node_modules/@opencode/schema/dist/schema.js
+import { DateTime, Option, Schema, SchemaGetter } from "effect";
+var PositiveInt = Schema.Int.check(Schema.isGreaterThan(0));
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var RelativePath = Schema.String.pipe(Schema.brand("RelativePath"), Schema.annotate({ identifier: "RelativePath" }));
+var AbsolutePath = Schema.String.pipe(Schema.brand("AbsolutePath"), Schema.annotate({ identifier: "AbsolutePath" }));
+var optional = (schema) => Schema.optionalKey(schema).pipe(Schema.decodeTo(Schema.optional(Schema.toType(schema)), {
+  decode: SchemaGetter.passthrough({ strict: false }),
+  encode: SchemaGetter.transformOptional(Option.filter((value) => value !== void 0))
+}));
+var withStatics = (schema, methods) => Object.defineProperties(schema, Object.getOwnPropertyDescriptors(methods));
+var statics = (methods) => (schema) => withStatics(schema, methods(schema));
+var DateTimeUtcFromMillis = Schema.Finite.pipe(Schema.decodeTo(Schema.DateTimeUtc, {
+  decode: SchemaGetter.transform((value) => DateTime.makeUnsafe(value)),
+  encode: SchemaGetter.transform((value) => DateTime.toEpochMillis(value))
+}));
+
+// node_modules/@opencode/schema/dist/identifier.js
+var length = 26;
+var chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var lastTimestamp = 0;
+var counter = 0;
+function ascending() {
+  return create(false);
+}
+function descending() {
+  return create(true);
+}
+function create(descending2, timestamp = Date.now()) {
+  if (timestamp !== lastTimestamp) {
+    lastTimestamp = timestamp;
+    counter = 0;
+  }
+  counter++;
+  const current = BigInt(timestamp) * 0x1000n + BigInt(counter);
+  const value = descending2 ? ~current : current;
+  const time = Array.from({ length: 6 }, (_, index) => Number(value >> BigInt(40 - 8 * index) & 0xffn).toString(16).padStart(2, "0")).join("");
+  const bytes2 = crypto.getRandomValues(new Uint8Array(length - 12));
+  return time + Array.from(bytes2, (byte) => chars[byte % 62]).join("");
+}
+
+// node_modules/@opencode/schema/dist/location.js
+var location_exports = {};
+__export(location_exports, {
+  Info: () => Info,
+  Location: () => location_exports,
+  PublicInfo: () => PublicInfo,
+  PublicRef: () => PublicRef,
+  Ref: () => Ref,
+  response: () => response
+});
+import { Schema as Schema4, Struct } from "effect";
+
+// node_modules/@opencode/schema/dist/project-id.js
+import { Schema as Schema2 } from "effect";
+var ProjectID = Schema2.String.pipe(Schema2.brand("Project.ID"), Schema2.annotate({ identifier: "Project.ID" }), statics((schema) => ({ global: schema.make("global") })));
+
+// node_modules/@opencode/schema/dist/workspace-id.js
+import { Schema as Schema3 } from "effect";
+var WorkspaceID = Schema3.String.check(Schema3.isStartingWith("wrk")).pipe(Schema3.brand("Workspace.ID"), Schema3.annotate({ identifier: "Workspace.ID" }), statics((schema) => {
+  const create2 = () => schema.make("wrk_" + ascending());
+  return {
+    ascending: (id) => {
+      if (!id)
+        return create2();
+      if (!id.startsWith("wrk"))
+        throw new Error(`ID ${id} does not start with wrk`);
+      return schema.make(id);
+    },
+    create: create2
+  };
+}));
+
+// node_modules/@opencode/schema/dist/location.js
+var Ref = Schema4.Struct({
+  directory: AbsolutePath,
+  workspaceID: optional(WorkspaceID)
+}).annotate({ identifier: "Location.Ref" });
+var PublicRef = Schema4.Struct(Struct.omit(Ref.fields, ["workspaceID"])).annotate({
+  identifier: "Location.PublicRef"
+});
+var Info = class extends Schema4.Class("Location.Info")({
+  directory: AbsolutePath,
+  workspaceID: optional(WorkspaceID),
+  project: Schema4.Struct({
+    id: ProjectID,
+    directory: AbsolutePath,
+    canonical: AbsolutePath
+  })
+}) {
+};
+var PublicInfo = Schema4.Struct(Struct.omit(Info.fields, ["workspaceID"])).annotate({
+  identifier: "Location.PublicInfo"
+});
+function response(data) {
+  return Schema4.Struct({ location: PublicRef, data });
+}
+
+// node_modules/@opencode/schema/dist/event.js
+var ID = Schema5.String.check(Schema5.isStartingWith("evt_")).pipe(Schema5.brand("Event.ID"), Schema5.annotate({ identifier: "Event.ID" }), statics((schema) => ({ create: () => schema.make("evt_" + ascending()) })));
+var Seq = Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(0)).pipe(Schema5.brand("Event.Seq"), Schema5.annotate({ identifier: "Event.Seq" }));
+var Version = Schema5.Int.check(Schema5.isGreaterThanOrEqualTo(1)).pipe(Schema5.brand("Event.Version"), Schema5.annotate({ identifier: "Event.Version" }));
+var DurableEnvelope = Schema5.Struct({ aggregateID: Schema5.String, seq: Seq, version: Version });
+function durable(input) {
+  const data = Schema5.Struct(input.schema);
+  const durable2 = Schema5.Struct({
+    aggregateID: DurableEnvelope.fields.aggregateID,
+    seq: DurableEnvelope.fields.seq,
+    version: Schema5.Literal(input.durable.version).pipe(Schema5.decodeTo(Schema5.toType(Version), SchemaTransformation.transform({
+      decode: () => Version.make(input.durable.version),
+      encode: () => input.durable.version
+    })))
+  });
+  return Schema5.Struct({
+    id: ID,
+    created: Schema5.Finite,
+    metadata: optional(Schema5.Record(Schema5.String, Schema5.Unknown)),
+    type: Schema5.Literal(input.type),
+    durable: durable2,
+    location: optional(location_exports.Ref),
+    data
+  }).annotate({ identifier: input.identifier ?? input.type }).pipe(statics(() => ({
+    type: input.type,
+    durability: "durable",
+    durable: input.durable,
+    data
+  })));
+}
+function ephemeral(input) {
+  const data = Schema5.Struct(input.schema);
+  return Schema5.Struct({
+    id: ID,
+    created: Schema5.Finite,
+    metadata: optional(Schema5.Record(Schema5.String, Schema5.Unknown)),
+    type: Schema5.Literal(input.type),
+    location: optional(location_exports.Ref),
+    data
+  }).annotate({ identifier: input.identifier ?? input.type }).pipe(statics(() => ({
+    type: input.type,
+    durability: "ephemeral",
+    durable: void 0,
+    data
+  })));
+}
+function inventory(...definitions) {
+  return Object.freeze(definitions);
+}
+function latest(definitions) {
+  return readonlyMap(definitions.reduce((result, definition) => {
+    const existing = result.get(definition.type);
+    if (!existing) {
+      result.set(definition.type, definition);
+      return result;
+    }
+    if (definition.durable && existing.durable && definition.durable.version !== existing.durable.version) {
+      if (definition.durable.version > existing.durable.version)
+        result.set(definition.type, definition);
+      return result;
+    }
+    if (definition !== existing)
+      throw new Error(`Duplicate latest event definition for ${definition.type}`);
+    return result;
+  }, /* @__PURE__ */ new Map()));
+}
+function versionedType(type, version) {
+  return `${type}.${version}`;
+}
+function durableMap(definitions) {
+  return readonlyMap(definitions.reduce((result, definition) => {
+    if (definition.durability !== "durable")
+      return result;
+    const key = versionedType(definition.type, definition.durable.version);
+    if (result.has(key))
+      throw new Error(`Duplicate durable event definition for ${key}`);
+    result.set(key, definition);
+    return result;
+  }, /* @__PURE__ */ new Map()));
+}
+function readonlyMap(map) {
+  const result = Object.freeze({
+    get size() {
+      return map.size;
+    },
+    entries: () => map.entries(),
+    forEach: (callback, thisArg) => map.forEach((value, key) => callback.call(thisArg, value, key, result)),
+    get: (key) => map.get(key),
+    has: (key) => map.has(key),
+    keys: () => map.keys(),
+    values: () => map.values(),
+    [Symbol.iterator]: () => map[Symbol.iterator]()
+  });
+  return result;
+}
+
+// node_modules/@opencode/schema/dist/model.js
+var model_exports = {};
+__export(model_exports, {
+  Capabilities: () => Capabilities,
+  Compatibility: () => Compatibility,
+  Cost: () => Cost,
+  Event: () => Event5,
+  Family: () => Family,
+  ID: () => ID6,
+  Info: () => Info6,
+  MaxTokensField: () => MaxTokensField,
+  Model: () => model_exports,
+  Overlays: () => Overlays2,
+  ReasoningField: () => ReasoningField,
+  Ref: () => Ref3,
+  Settings: () => Settings2,
+  Variant: () => Variant,
+  VariantID: () => VariantID
+});
+import { Schema as Schema14 } from "effect";
+
+// node_modules/@opencode/schema/dist/provider.js
+var provider_exports = {};
+__export(provider_exports, {
+  Activation: () => Activation,
+  Compaction: () => Compaction,
+  Encoding: () => Encoding,
+  Event: () => Event4,
+  ID: () => ID5,
+  Info: () => Info5,
+  Overlays: () => Overlays,
+  Package: () => Package,
+  Provider: () => provider_exports,
+  Request: () => Request2,
+  Settings: () => Settings,
+  Transport: () => Transport
+});
+import { Effect, Schema as Schema12 } from "effect";
+
+// node_modules/@opencode/schema/dist/integration.js
+var integration_exports = {};
+__export(integration_exports, {
+  Attempt: () => Attempt,
+  AttemptID: () => AttemptID,
+  AttemptStatus: () => AttemptStatus,
+  CommandAttempt: () => CommandAttempt,
+  CommandAttemptStatus: () => CommandAttemptStatus,
+  CommandMethod: () => CommandMethod,
+  EnvMethod: () => EnvMethod,
+  Event: () => Event3,
+  ExternalMethod: () => ExternalMethod,
+  ID: () => ID4,
+  Info: () => Info4,
+  Integration: () => integration_exports,
+  KeyMethod: () => KeyMethod,
+  Method: () => Method,
+  MethodID: () => MethodID,
+  OAuthMethod: () => OAuthMethod,
+  Ref: () => Ref2
+});
+import { Schema as Schema10 } from "effect";
+
+// node_modules/@opencode/schema/dist/connection.js
+var connection_exports = {};
+__export(connection_exports, {
+  Connection: () => connection_exports,
+  CredentialInfo: () => CredentialInfo,
+  EnvInfo: () => EnvInfo,
+  Info: () => Info3,
+  Status: () => Status
+});
+import { Schema as Schema9 } from "effect";
+
+// node_modules/@opencode/schema/dist/credential.js
+var credential_exports = {};
+__export(credential_exports, {
+  CreateInput: () => CreateInput,
+  Credential: () => credential_exports,
+  Entry: () => Entry,
+  Event: () => Event2,
+  External: () => External,
+  ID: () => ID3,
+  Key: () => Key,
+  OAuth: () => OAuth,
+  Value: () => Value2
+});
+import { Schema as Schema8 } from "effect";
+
+// node_modules/@opencode/schema/dist/integration-id.js
+import { Schema as Schema6 } from "effect";
+var IntegrationID = Schema6.String.pipe(Schema6.brand("Integration.ID"), Schema6.annotate({ identifier: "Integration.ID" }));
+var IntegrationMethodID = Schema6.String.pipe(Schema6.brand("Integration.MethodID"), Schema6.annotate({ identifier: "Integration.MethodID" }));
+
+// node_modules/@opencode/schema/dist/form.js
+var form_exports = {};
+__export(form_exports, {
+  Answer: () => Answer,
+  BooleanField: () => BooleanField,
+  Detail: () => Detail,
+  Event: () => Event,
+  ExternalField: () => ExternalField,
+  Field: () => Field,
+  Fields: () => Fields,
+  Form: () => form_exports,
+  ID: () => ID2,
+  Info: () => Info2,
+  IntegerField: () => IntegerField,
+  Metadata: () => Metadata,
+  MultiselectField: () => MultiselectField,
+  NumberField: () => NumberField,
+  Option: () => Option2,
+  Reply: () => Reply,
+  State: () => State,
+  StringField: () => StringField,
+  Value: () => Value,
+  When: () => When
+});
+import { Schema as Schema7 } from "effect";
+var IDSchema = Schema7.String.check(Schema7.isStartingWith("frm_")).pipe(Schema7.brand("Form.ID"), Schema7.annotate({ identifier: "Form.ID" }));
+var ID2 = IDSchema.pipe(statics((schema) => ({ create: (id) => schema.make(id ?? "frm_" + ascending()) })));
+var Metadata = Schema7.Record(Schema7.String, Schema7.Unknown).annotate({ identifier: "Form.Metadata" });
+var Option2 = Schema7.Struct({
+  value: Schema7.String,
+  label: Schema7.String,
+  description: Schema7.String.pipe(optional)
+}).annotate({ identifier: "Form.Option" });
+var When = Schema7.Struct({
+  key: Schema7.String,
+  op: Schema7.Literals(["eq", "neq"]),
+  value: Schema7.Union([Schema7.String, Schema7.Number, Schema7.Boolean])
+}).annotate({ identifier: "Form.When" });
+var FieldBase = {
+  key: Schema7.String,
+  title: Schema7.String.pipe(optional),
+  description: Schema7.String.pipe(optional),
+  required: Schema7.Boolean.pipe(optional),
+  hidden: Schema7.Boolean.pipe(optional).annotate({
+    description: "Skip the interactive authentication prompt and use the default unless an answer is supplied"
+  }),
+  when: Schema7.Array(When).pipe(optional)
+};
+var StringField = Schema7.Struct({
+  ...FieldBase,
+  type: Schema7.Literal("string"),
+  format: Schema7.Literals(["email", "uri", "date", "date-time"]).pipe(optional),
+  minLength: NonNegativeInt.pipe(optional),
+  maxLength: NonNegativeInt.pipe(optional),
+  pattern: Schema7.String.pipe(optional),
+  placeholder: Schema7.String.pipe(optional),
+  default: Schema7.String.pipe(optional),
+  options: Schema7.Array(Option2).pipe(optional),
+  custom: Schema7.Boolean.pipe(optional)
+}).annotate({ identifier: "Form.StringField" });
+var NumberField = Schema7.Struct({
+  ...FieldBase,
+  type: Schema7.Literal("number"),
+  minimum: Schema7.Number.pipe(optional),
+  maximum: Schema7.Number.pipe(optional),
+  default: Schema7.Number.pipe(optional)
+}).annotate({ identifier: "Form.NumberField" });
+var IntegerField = Schema7.Struct({
+  ...FieldBase,
+  type: Schema7.Literal("integer"),
+  minimum: Schema7.Number.pipe(optional),
+  maximum: Schema7.Number.pipe(optional),
+  default: Schema7.Number.pipe(optional)
+}).annotate({ identifier: "Form.IntegerField" });
+var BooleanField = Schema7.Struct({
+  ...FieldBase,
+  type: Schema7.Literal("boolean"),
+  default: Schema7.Boolean.pipe(optional)
+}).annotate({ identifier: "Form.BooleanField" });
+var MultiselectField = Schema7.Struct({
+  ...FieldBase,
+  type: Schema7.Literal("multiselect"),
+  options: Schema7.Array(Option2),
+  minItems: NonNegativeInt.pipe(optional),
+  maxItems: NonNegativeInt.pipe(optional),
+  custom: Schema7.Boolean.pipe(optional),
+  default: Schema7.Array(Schema7.String).pipe(optional)
+}).annotate({ identifier: "Form.MultiselectField" });
+var ExternalField = Schema7.Struct({
+  key: Schema7.String,
+  type: Schema7.Literal("external"),
+  url: Schema7.String,
+  title: Schema7.String.pipe(optional),
+  description: Schema7.String.pipe(optional)
+}).annotate({ identifier: "Form.ExternalField" });
+var Field = Schema7.Union([
+  StringField,
+  NumberField,
+  IntegerField,
+  BooleanField,
+  MultiselectField,
+  ExternalField
+]).pipe(Schema7.toTaggedUnion("type"), Schema7.annotate({ identifier: "Form.Field" }));
+var Fields = Schema7.NonEmptyArray(Field).annotate({ identifier: "Form.Fields" });
+var InfoBase = {
+  id: ID2,
+  // This should be typed as SessionID. It is a plain string only because MCP elicitation
+  // temporarily needs the `"global"` sentinel owner, which is not a real session. Once
+  // elicitations can be attributed to real sessions, revert this to SessionID. Do not rely
+  // on non-session owners anywhere else.
+  sessionID: Schema7.String,
+  title: Schema7.String,
+  metadata: Metadata.pipe(optional)
+};
+var Info2 = Schema7.Struct({
+  ...InfoBase,
+  fields: Fields
+}).annotate({ identifier: "Form.Info" });
+var Value = Schema7.Union([Schema7.String, Schema7.Number, Schema7.Boolean, Schema7.Array(Schema7.String)]).annotate({
+  identifier: "Form.Value"
+});
+var Answer = Schema7.Record(Schema7.String, Value).annotate({ identifier: "Form.Answer" });
+var State = Schema7.Union([
+  Schema7.Struct({ status: Schema7.Literal("pending") }),
+  Schema7.Struct({ status: Schema7.Literal("answered"), answer: Answer }),
+  // A message tells the asker why nobody answered, e.g. a non-interactive client.
+  Schema7.Struct({ status: Schema7.Literal("cancelled"), message: Schema7.String.pipe(optional) })
+]).pipe(Schema7.toTaggedUnion("status")).annotate({ identifier: "Form.State" });
+var Detail = Schema7.Struct({
+  ...Info2.fields,
+  state: State
+}).annotate({ identifier: "Form.Detail" });
+var Reply = Schema7.Struct({
+  answer: Answer
+}).annotate({ identifier: "Form.Reply" });
+var Created = ephemeral({ type: "form.created", schema: { form: Info2 } });
+var Replied = ephemeral({ type: "form.replied", schema: { id: ID2, sessionID: Schema7.String, answer: Answer } });
+var Cancelled = ephemeral({ type: "form.cancelled", schema: { id: ID2, sessionID: Schema7.String } });
+var Event = { Created, Replied, Cancelled, Definitions: inventory(Created, Replied, Cancelled) };
+
+// node_modules/@opencode/schema/dist/credential.js
+var ID3 = Schema8.String.pipe(Schema8.brand("Credential.ID"), Schema8.annotate({ identifier: "Credential.ID" }), statics((schema) => ({ create: () => schema.make("cred_" + ascending()) })));
+var Updated = ephemeral({
+  type: "credential.updated",
+  schema: {}
+});
+var Switched = ephemeral({
+  type: "credential.switched",
+  schema: { integrationID: IntegrationID, credentialID: Schema8.NullOr(ID3) }
+});
+var Event2 = {
+  Updated,
+  Switched,
+  Definitions: inventory(Updated, Switched)
+};
+var OAuth = Schema8.Struct({
+  type: Schema8.Literal("oauth"),
+  methodID: IntegrationMethodID,
+  refresh: Schema8.String,
+  access: Schema8.String,
+  expires: NonNegativeInt,
+  metadata: optional(Schema8.Record(Schema8.String, Schema8.Unknown))
+}).annotate({ identifier: "Credential.OAuth" });
+var Key = Schema8.Struct({
+  type: Schema8.Literal("key"),
+  key: Schema8.String,
+  metadata: optional(Schema8.Record(Schema8.String, Schema8.Unknown)),
+  configuration: optional(form_exports.Answer)
+}).annotate({ identifier: "Credential.Key" });
+var External = Schema8.Struct({
+  type: Schema8.Literal("external"),
+  methodID: IntegrationMethodID,
+  metadata: optional(Schema8.Record(Schema8.String, Schema8.Unknown))
+}).annotate({ identifier: "Credential.External" });
+var Value2 = Schema8.Union([OAuth, Key, External]).pipe(Schema8.toTaggedUnion("type")).annotate({ identifier: "Credential.Value" });
+var Entry = Schema8.Struct({
+  id: ID3,
+  integrationID: IntegrationID,
+  label: Schema8.String,
+  active: Schema8.Boolean,
+  value: Value2
+}).annotate({ identifier: "Credential.Entry" });
+var CreateInput = Schema8.Struct({
+  id: optional(ID3),
+  integrationID: IntegrationID,
+  label: optional(Schema8.String),
+  value: Value2,
+  activate: optional(Schema8.Boolean)
+}).annotate({ identifier: "Credential.CreateInput" });
+
+// node_modules/@opencode/schema/dist/connection.js
+var Status = Schema9.Struct({
+  status: Schema9.Literals(["needs_auth"]),
+  message: Schema9.String,
+  url: optional(Schema9.String)
+}).annotate({ identifier: "Connection.Status" });
+var CredentialInfo = Schema9.Struct({
+  type: Schema9.Literal("credential"),
+  id: credential_exports.ID,
+  label: Schema9.String,
+  /** Whether the connection stores a key, an OAuth grant, or an external credential-source reference. */
+  method: Schema9.Literals(["key", "oauth", "external"]),
+  status: optional(Status)
+}).annotate({ identifier: "Connection.CredentialInfo" });
+var EnvInfo = Schema9.Struct({
+  type: Schema9.Literal("env"),
+  name: Schema9.String,
+  status: optional(Status)
+}).annotate({ identifier: "Connection.EnvInfo" });
+var Info3 = Schema9.Union([CredentialInfo, EnvInfo]).pipe(Schema9.toTaggedUnion("type")).annotate({ identifier: "Connection.Info" });
+
+// node_modules/@opencode/schema/dist/integration.js
+var ID4 = IntegrationID;
+var MethodID = IntegrationMethodID;
+var OAuthMethod = Schema10.Struct({
+  id: MethodID,
+  type: Schema10.Literal("oauth"),
+  label: Schema10.String,
+  form: optional(form_exports.Fields)
+}).annotate({ identifier: "Integration.OAuthMethod" });
+var CommandMethod = Schema10.Struct({
+  id: MethodID,
+  type: Schema10.Literal("command"),
+  label: Schema10.String,
+  command: Schema10.Array(Schema10.String)
+}).annotate({ identifier: "Integration.CommandMethod" });
+var KeyMethod = Schema10.Struct({
+  type: Schema10.Literal("key"),
+  label: optional(Schema10.String),
+  form: optional(form_exports.Fields)
+}).annotate({ identifier: "Integration.KeyMethod" });
+var ExternalMethod = Schema10.Struct({
+  id: MethodID,
+  type: Schema10.Literal("external"),
+  label: Schema10.String,
+  form: optional(form_exports.Fields)
+}).annotate({ identifier: "Integration.ExternalMethod" });
+var EnvMethod = Schema10.Struct({
+  type: Schema10.Literal("env"),
+  names: Schema10.Array(Schema10.String)
+}).annotate({ identifier: "Integration.EnvMethod" });
+var Method = Schema10.Union([OAuthMethod, CommandMethod, KeyMethod, ExternalMethod, EnvMethod]).pipe(Schema10.toTaggedUnion("type")).annotate({ identifier: "Integration.Method" });
+var Updated2 = ephemeral({
+  type: "integration.updated",
+  schema: {}
+});
+var Event3 = { Updated: Updated2, Definitions: inventory(Updated2) };
+var Ref2 = Schema10.Struct({
+  id: ID4,
+  name: Schema10.String,
+  metadata: optional(Schema10.Record(Schema10.String, Schema10.Any))
+}).annotate({ identifier: "Integration.Ref" });
+var Info4 = Schema10.Struct({
+  id: ID4,
+  name: Schema10.String,
+  metadata: optional(Schema10.Record(Schema10.String, Schema10.Any)),
+  methods: Schema10.Array(Method),
+  connections: Schema10.Array(connection_exports.Info)
+}).annotate({ identifier: "Integration.Info" });
+var AttemptID = Schema10.String.pipe(Schema10.brand("Integration.AttemptID"), Schema10.annotate({ identifier: "Integration.AttemptID" }), statics((schema) => ({ create: () => schema.make("con_" + ascending()) })));
+var AttemptTime = Schema10.Struct({
+  created: Schema10.Number,
+  expires: Schema10.Number
+});
+var Attempt = class extends Schema10.Class("Integration.Attempt")({
+  attemptID: AttemptID,
+  url: Schema10.String,
+  instructions: Schema10.String,
+  mode: Schema10.Literals(["auto", "code"]),
+  time: AttemptTime
+}) {
+};
+var AttemptStatus = Schema10.Union([
+  Schema10.Struct({ status: Schema10.Literal("pending"), time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("complete"), time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("failed"), message: Schema10.String, time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("expired"), time: AttemptTime })
+]).pipe(Schema10.toTaggedUnion("status")).annotate({ identifier: "Integration.AttemptStatus" });
+var CommandAttempt = Schema10.Struct({
+  attemptID: AttemptID,
+  time: AttemptTime
+}).annotate({ identifier: "Integration.CommandAttempt" });
+var CommandAttemptStatus = Schema10.Union([
+  Schema10.Struct({ status: Schema10.Literal("pending"), message: optional(Schema10.String), time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("complete"), time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("failed"), message: Schema10.String, time: AttemptTime }),
+  Schema10.Struct({ status: Schema10.Literal("expired"), time: AttemptTime })
+]).pipe(Schema10.toTaggedUnion("status")).annotate({ identifier: "Integration.CommandAttemptStatus" });
+
+// node_modules/@opencode/schema/dist/model-compatibility.js
+import { Schema as Schema11, Struct as Struct2 } from "effect";
+var ReasoningField = Schema11.Union([
+  Schema11.Literals(["reasoning", "reasoning_content", "reasoning_text"]),
+  Schema11.String
+]).annotate({ identifier: "Model.ReasoningField" });
+var MaxTokensField = Schema11.Literals(["max_completion_tokens", "max_tokens"]).annotate({
+  identifier: "Model.MaxTokensField"
+});
+var CacheFormat = Schema11.Literals(["anthropic", "alibaba"]).annotate({ identifier: "Model.CacheFormat" });
+var Compatibility = Schema11.Struct({
+  reasoningField: ReasoningField.pipe(optional),
+  /** Require every assistant message to include its reasoning field, even when empty. */
+  requireReasoning: Schema11.Boolean.pipe(optional),
+  maxTokensField: MaxTokensField.pipe(optional),
+  requireFinishReason: Schema11.Boolean.pipe(optional),
+  requireAssistantAfterTool: Schema11.Boolean.pipe(optional),
+  supportsPromptCacheKey: Schema11.Boolean.pipe(optional),
+  /** Prompt-cache marker syntax the endpoint accepts. Overrides the route default; both send `cache_control`, and `alibaba` skips tool definitions. */
+  cacheFormat: CacheFormat.pipe(optional),
+  /** Supports Anthropic's thinking-prefix mismatch controls. Overrides model-ID detection. */
+  supportsThinkingBlockBinding: Schema11.Boolean.pipe(optional),
+  /** Supports per-message effort updates. Overrides model-ID detection. */
+  supportsEffortUpdates: Schema11.Boolean.pipe(optional)
+}).annotate({ identifier: "Model.Compatibility" });
+var ProviderCompatibility = Schema11.Struct(Struct2.omit(Compatibility.fields, ["supportsThinkingBlockBinding", "supportsEffortUpdates"])).annotate({ identifier: "Provider.Compatibility" });
+
+// node_modules/@opencode/schema/dist/provider.js
+var ID5 = Schema12.String.pipe(Schema12.brand("Provider.ID"), Schema12.annotate({ identifier: "Provider.ID" }), statics((schema) => ({
+  opencode: schema.make("opencode"),
+  anthropic: schema.make("anthropic"),
+  openai: schema.make("openai"),
+  google: schema.make("google"),
+  googleVertex: schema.make("google-vertex"),
+  githubCopilot: schema.make("github-copilot"),
+  amazonBedrock: schema.make("amazon-bedrock"),
+  azure: schema.make("azure"),
+  openrouter: schema.make("openrouter"),
+  mistral: schema.make("mistral"),
+  gitlab: schema.make("gitlab")
+})));
+var Updated3 = ephemeral({ type: "provider.updated", schema: {} });
+var Event4 = { Updated: Updated3, Definitions: inventory(Updated3) };
+var Package = Schema12.String;
+var Activation = Schema12.Literals(["auto", "enabled", "disabled"]);
+var Compaction = Schema12.Union([
+  Schema12.Struct({ type: Schema12.Literal("summary") }),
+  Schema12.Struct({ type: Schema12.Literal("native") })
+]).pipe(Schema12.toTaggedUnion("type")).annotate({ identifier: "Provider.Compaction" });
+var Transport = Schema12.Literals(["http", "websocket"]).annotate({ identifier: "Provider.Transport" });
+var Encoding = Schema12.Literals(["zstd", "gzip", "none"]).annotate({ identifier: "Provider.Encoding" });
+var Settings = Schema12.StructWithRest(Schema12.Struct({
+  timeout: Schema12.Union([Schema12.Finite, Schema12.Literal(false)]).pipe(optional),
+  headerTimeout: Schema12.Union([Schema12.Finite, Schema12.Literal(false)]).pipe(optional),
+  chunkTimeout: Schema12.Union([Schema12.Finite, Schema12.Literal(false)]).pipe(optional),
+  compaction: Compaction.pipe(optional),
+  transport: Transport.pipe(optional),
+  encoding: Encoding.pipe(optional)
+}), [Schema12.Record(Schema12.String, Schema12.Any)]).annotate({ identifier: "Provider.Settings" });
+var Overlays = {
+  settings: Settings.pipe(optional),
+  headers: Schema12.Record(Schema12.String, Schema12.String).pipe(optional),
+  body: Schema12.Record(Schema12.String, Schema12.Any).pipe(optional)
+};
+var Request2 = Schema12.Struct({
+  settings: Settings.pipe(Schema12.withConstructorDefault(Effect.succeed({}))),
+  headers: Schema12.Record(Schema12.String, Schema12.String),
+  body: Schema12.Record(Schema12.String, Schema12.Any)
+}).annotate({ identifier: "Provider.Request" });
+var Info5 = Schema12.Struct({
+  id: ID5,
+  canonical: ID5.pipe(optional),
+  integrationID: integration_exports.ID.pipe(optional),
+  name: Schema12.String,
+  activation: Activation,
+  package: Package,
+  /** Inherited by every model of this provider; model compatibility overrides individual fields. */
+  compatibility: ProviderCompatibility.pipe(optional),
+  ...Overlays
+}).annotate({ identifier: "Provider.Info" }).pipe(statics(() => ({
+  empty: (id) => ({ id, name: id, activation: "auto", package: "" })
+})));
+
+// node_modules/@opencode/schema/dist/money.js
+var money_exports = {};
+__export(money_exports, {
+  Money: () => money_exports,
+  USD: () => USD,
+  USDPerMillionTokens: () => USDPerMillionTokens
+});
+import { Schema as Schema13 } from "effect";
+var USD = Schema13.Finite.pipe(Schema13.brand("Money.USD"), Schema13.annotate({ identifier: "Money.USD" }), statics((schema) => ({ zero: schema.make(0) })));
+var USDPerMillionTokens = Schema13.Finite.pipe(Schema13.brand("Money.USDPerMillionTokens"), Schema13.annotate({ identifier: "Money.USDPerMillionTokens" }), statics((schema) => ({ zero: schema.make(0) })));
+
+// node_modules/@opencode/schema/dist/model.js
+var ID6 = Schema14.String.pipe(Schema14.brand("Model.ID"));
+var Updated4 = ephemeral({ type: "model.updated", schema: {} });
+var Event5 = { Updated: Updated4, Definitions: inventory(Updated4) };
+var VariantID = Schema14.String.pipe(Schema14.brand("Model.VariantID"));
+var Ref3 = Schema14.Struct({
+  id: ID6,
+  providerID: provider_exports.ID,
+  variant: VariantID.pipe(optional)
+}).annotate({ identifier: "Model.Ref" }).pipe(statics((schema) => ({
+  parse: (input) => {
+    const providerEnd = input.indexOf("/");
+    if (providerEnd <= 0)
+      throw new Error(`Invalid model reference: ${input}`);
+    const providerID = input.slice(0, providerEnd);
+    const variantStart = input.indexOf("#", providerEnd + 1);
+    const id = input.slice(providerEnd + 1, variantStart === -1 ? void 0 : variantStart);
+    const variant = variantStart === -1 ? void 0 : input.slice(variantStart + 1);
+    if (!id || providerID.includes("#") || variant !== void 0 && (!variant || variant.includes("#")))
+      throw new Error(`Invalid model reference: ${input}`);
+    return schema.make({
+      providerID: provider_exports.ID.make(providerID),
+      id: ID6.make(id),
+      ...variant ? { variant: VariantID.make(variant) } : {}
+    });
+  }
+})));
+var Family = Schema14.String.pipe(Schema14.brand("Model.Family"));
+var Settings2 = Schema14.StructWithRest(
+  Schema14.Struct({
+    compaction: provider_exports.Compaction.pipe(optional),
+    encoding: provider_exports.Encoding.pipe(optional)
+  }),
+  // Provider packages may define arbitrary model-level options beyond OpenCode's shared compaction policy.
+  [Schema14.Record(Schema14.String, Schema14.Any)]
+).annotate({ identifier: "Model.Settings" });
+var Overlays2 = {
+  settings: Settings2.pipe(optional),
+  headers: Schema14.Record(Schema14.String, Schema14.String).pipe(optional),
+  body: Schema14.Record(Schema14.String, Schema14.Any).pipe(optional)
+};
+var Capabilities = Schema14.Struct({
+  tools: Schema14.Boolean,
+  input: Schema14.Array(Schema14.String),
+  output: Schema14.Array(Schema14.String)
+}).annotate({ identifier: "Model.Capabilities" }).pipe(statics(() => ({
+  default: () => ({ tools: true, input: ["text", "image"], output: ["text"] })
+})));
+var Cost = Schema14.Struct({
+  tier: Schema14.Struct({
+    type: Schema14.tag("context"),
+    size: Schema14.Int
+  }).pipe(optional),
+  input: money_exports.USDPerMillionTokens,
+  output: money_exports.USDPerMillionTokens,
+  cache: Schema14.Struct({
+    read: money_exports.USDPerMillionTokens,
+    write: money_exports.USDPerMillionTokens
+  })
+}).annotate({ identifier: "Model.Cost" });
+var Variant = Schema14.Struct({
+  id: VariantID,
+  ...Overlays2
+}).annotate({ identifier: "Model.Variant" });
+var Info6 = Schema14.Struct({
+  id: ID6,
+  modelID: ID6,
+  providerID: provider_exports.ID,
+  canonical: provider_exports.ID.pipe(optional),
+  family: Family.pipe(optional),
+  name: Schema14.String,
+  compatibility: Compatibility.pipe(optional),
+  package: provider_exports.Package.pipe(optional),
+  ...Overlays2,
+  capabilities: Capabilities,
+  variants: Schema14.Array(Variant),
+  time: Schema14.Struct({
+    released: Schema14.Finite
+  }),
+  cost: Schema14.Array(Cost),
+  status: Schema14.Literals(["alpha", "beta", "deprecated", "active"]),
+  enabled: Schema14.Boolean,
+  limit: Schema14.Struct({
+    context: Schema14.Int,
+    input: Schema14.Int.pipe(optional),
+    output: Schema14.Int
+  })
+}).annotate({ identifier: "Model.Info" }).pipe(statics(() => ({
+  default: (providerID, id) => ({
+    id,
+    modelID: id,
+    providerID,
+    name: id,
+    capabilities: Capabilities.default(),
+    variants: [],
+    time: { released: 0 },
+    cost: [],
+    status: "active",
+    enabled: true,
+    limit: { context: 2e5, output: 32e3 }
+  })
+})));
+
+// node_modules/@opencode/schema/dist/permission.js
+var permission_exports = {};
+__export(permission_exports, {
+  Effect: () => Effect2,
+  Event: () => Event6,
+  ID: () => ID7,
+  Permission: () => permission_exports,
+  Reply: () => Reply2,
+  Request: () => Request3,
+  Rule: () => Rule,
+  Ruleset: () => Ruleset,
+  Source: () => Source
+});
+import { Schema as Schema16 } from "effect";
+
+// node_modules/@opencode/schema/dist/session-id.js
+import { Schema as Schema15 } from "effect";
+var SessionID = Schema15.String.check(Schema15.isStartingWith("ses")).pipe(Schema15.brand("SessionID"), Schema15.annotate({ identifier: "Session.ID" }), statics((schema) => {
+  const create2 = () => schema.make("ses_" + descending());
+  return {
+    create: create2,
+    descending: (id) => id === void 0 ? create2() : schema.make(id)
+  };
+}));
+
+// node_modules/@opencode/schema/dist/permission.js
+var ID7 = Schema16.String.check(Schema16.isStartingWith("per")).pipe(Schema16.brand("Permission.ID"), Schema16.annotate({ identifier: "Permission.ID" }), statics((schema) => ({ create: (id) => schema.make(id ?? "per_" + ascending()) })));
+var Source = Schema16.Union([
+  Schema16.Struct({
+    type: Schema16.Literal("tool"),
+    messageID: Schema16.String,
+    id: Schema16.String
+  })
+]).annotate({ identifier: "Permission.Source" });
+var RequestFields = {
+  sessionID: SessionID,
+  action: Schema16.String,
+  resources: Schema16.Array(Schema16.String),
+  save: Schema16.Array(Schema16.String).pipe(optional),
+  metadata: Schema16.Record(Schema16.String, Schema16.Unknown).pipe(optional),
+  source: Source.pipe(optional),
+  message: Schema16.String.pipe(optional)
+};
+var Request3 = Schema16.Struct({
+  id: ID7,
+  ...RequestFields
+}).annotate({ identifier: "Permission.Request" });
+var Reply2 = Schema16.Literals(["once", "always", "reject"]).annotate({ identifier: "Permission.Reply" });
+var Asked = ephemeral({ type: "permission.asked", schema: Request3.fields });
+var Replied2 = ephemeral({
+  type: "permission.replied",
+  schema: {
+    sessionID: SessionID,
+    requestID: ID7,
+    reply: Reply2
+  }
+});
+var Event6 = { Asked, Replied: Replied2, Definitions: inventory(Asked, Replied2) };
+var Effect2 = Schema16.Literals(["allow", "deny", "ask"]).annotate({ identifier: "Permission.Effect" });
+var Rule = Schema16.Struct({
+  action: Schema16.String,
+  resource: Schema16.String,
+  effect: Effect2
+}).annotate({ identifier: "Permission.Rule" });
+var Ruleset = Schema16.Array(Rule).annotate({ identifier: "Permission.Ruleset" });
+
+// node_modules/@opencode/schema/dist/agent.js
+var Updated5 = ephemeral({ type: "agent.updated", schema: {} });
+var ID8 = Schema17.String.pipe(Schema17.brand("Agent.ID"), Schema17.annotate({ identifier: "Agent.ID" }));
+var Name = Schema17.String.pipe(Schema17.brand("Agent.Name"));
+var Color = Schema17.String.annotate({ identifier: "Agent.Color" });
+var Info7 = Schema17.Struct({
+  id: ID8,
+  name: Name,
+  model: model_exports.Ref.pipe(optional),
+  request: provider_exports.Request,
+  system: Schema17.String.pipe(optional),
+  description: Schema17.String.pipe(optional),
+  mode: Schema17.Literals(["subagent", "primary", "all"]),
+  hidden: Schema17.Boolean,
+  color: Color.pipe(optional),
+  steps: PositiveInt.pipe(optional),
+  permissions: permission_exports.Ruleset
+}).annotate({ identifier: "Agent.Info" }).pipe(statics(() => ({
+  default: (id) => ({
+    id,
+    name: Name.make(id),
+    request: { settings: {}, headers: {}, body: {} },
+    mode: "primary",
+    hidden: false,
+    permissions: [
+      { action: "*", resource: "*", effect: "allow" },
+      { action: "read", resource: "*.env", effect: "ask" },
+      { action: "read", resource: "*.env.*", effect: "ask" },
+      { action: "read", resource: "*.env.example", effect: "allow" }
+    ]
+  })
+})));
+var Event7 = {
+  Updated: Updated5,
+  Definitions: inventory(Updated5)
+};
+
+// node_modules/@opencode/schema/dist/command.js
+import { Schema as Schema18 } from "effect";
+var Updated6 = ephemeral({ type: "command.updated", schema: {} });
+var Info8 = Schema18.Struct({
+  name: Schema18.String,
+  description: Schema18.String.pipe(optional)
+}).annotate({ identifier: "Command.Info" });
+var Event8 = {
+  Updated: Updated6,
+  Definitions: inventory(Updated6)
+};
+
+// node_modules/@opencode/schema/dist/mcp.js
+import { Schema as Schema19 } from "effect";
+var TimeoutConfig = class extends Schema19.Class("Mcp.TimeoutConfig")({
+  startup: PositiveInt.pipe(optional).annotate({
+    description: "Maximum time in milliseconds to establish and initialize the MCP server."
+  }),
+  catalog: PositiveInt.pipe(optional).annotate({
+    description: "Maximum time in milliseconds to wait for MCP discovery requests such as tools/list and prompts/list."
+  }),
+  execution: PositiveInt.pipe(optional).annotate({
+    description: "Maximum time in milliseconds to wait for MCP tool and prompt execution."
+  })
+}) {
+};
+var Protocol = Schema19.Literals(["legacy", "auto", "2026-07-28"]).annotate({
+  identifier: "Mcp.Protocol",
+  description: 'MCP protocol negotiation. "legacy" (default) opens with the initialize handshake and speaks protocol revisions up to 2025-11-25. "auto" probes for the 2026-07-28 revision and falls back to legacy when the server does not support it. "2026-07-28" requires that revision and fails otherwise.'
+});
+var LocalConfig = class extends Schema19.Class("Mcp.LocalConfig")({
+  type: Schema19.Literal("local"),
+  command: Schema19.String.pipe(Schema19.Array),
+  cwd: Schema19.String.pipe(optional).annotate({
+    description: "Working directory for the MCP server process. Relative paths resolve from the workspace directory."
+  }),
+  environment: Schema19.Record(Schema19.String, Schema19.String).pipe(optional),
+  disabled: Schema19.Boolean.pipe(optional),
+  codemode: Schema19.Boolean.pipe(optional).annotate({
+    description: "Expose this server's tools through Code Mode. Defaults to true."
+  }),
+  timeout: TimeoutConfig.pipe(optional),
+  protocol: Protocol.pipe(optional)
+}) {
+};
+var OAuthConfig = class extends Schema19.Class("Mcp.OAuthConfig")({
+  client_id: Schema19.String.pipe(optional),
+  client_secret: Schema19.String.pipe(optional),
+  scope: Schema19.String.pipe(optional),
+  callback_port: Schema19.Int.check(Schema19.isBetween({ minimum: 1, maximum: 65535 })).pipe(optional),
+  redirect_uri: Schema19.String.pipe(optional),
+  auth_server_metadata_url: Schema19.String.pipe(optional).annotate({
+    description: "URL of the OAuth or OpenID Connect authorization server metadata document. Set when the MCP server does not publish protected resource metadata that names its authorization server."
+  })
+}) {
+};
+var RemoteConfig = class extends Schema19.Class("Mcp.RemoteConfig")({
+  type: Schema19.Literal("remote"),
+  url: Schema19.String,
+  headers: Schema19.Record(Schema19.String, Schema19.String).pipe(optional),
+  oauth: Schema19.Union([OAuthConfig, Schema19.Literal(false)]).pipe(optional),
+  disabled: Schema19.Boolean.pipe(optional),
+  codemode: Schema19.Boolean.pipe(optional).annotate({
+    description: "Expose this server's tools through Code Mode. Defaults to true."
+  }),
+  timeout: TimeoutConfig.pipe(optional),
+  protocol: Protocol.pipe(optional)
+}) {
+};
+var ServerConfig = Schema19.Union([LocalConfig, RemoteConfig]).pipe(Schema19.toTaggedUnion("type"));
+var Connected = Schema19.Struct({ status: Schema19.Literal("connected") }).annotate({
+  identifier: "Mcp.Status.Connected"
+});
+var Pending = Schema19.Struct({ status: Schema19.Literal("pending") }).annotate({
+  identifier: "Mcp.Status.Pending"
+});
+var Disabled = Schema19.Struct({ status: Schema19.Literal("disabled") }).annotate({
+  identifier: "Mcp.Status.Disabled"
+});
+var Failed = Schema19.Struct({ status: Schema19.Literal("failed"), error: Schema19.String }).annotate({
+  identifier: "Mcp.Status.Failed"
+});
+var NeedsAuth = Schema19.Struct({ status: Schema19.Literal("needs_auth"), error: Schema19.String }).annotate({
+  identifier: "Mcp.Status.NeedsAuth"
+});
+var Status2 = Schema19.Union([Connected, Pending, Disabled, Failed, NeedsAuth]).pipe(Schema19.toTaggedUnion("status"));
+var Server = Schema19.Struct({
+  name: Schema19.String,
+  status: Status2,
+  // Set for remote servers registered as OAuth integrations; lets clients act on the right integration
+  // without matching by name, which could collide with provider or plugin integrations.
+  integrationID: optional(IntegrationID)
+}).annotate({ identifier: "Mcp.Server" });
+var Resource = Schema19.Struct({
+  server: Schema19.String,
+  name: Schema19.String,
+  uri: Schema19.String,
+  description: optional(Schema19.String),
+  mimeType: optional(Schema19.String)
+}).annotate({ identifier: "Mcp.Resource" });
+var ResourceTemplate = Schema19.Struct({
+  server: Schema19.String,
+  name: Schema19.String,
+  uriTemplate: Schema19.String,
+  description: optional(Schema19.String),
+  mimeType: optional(Schema19.String)
+}).annotate({ identifier: "Mcp.ResourceTemplate" });
+var ResourceCatalog = Schema19.Struct({
+  resources: Schema19.Array(Resource),
+  templates: Schema19.Array(ResourceTemplate)
+}).annotate({ identifier: "Mcp.ResourceCatalog" });
+var ResourceContentPart = Schema19.Union([
+  Schema19.Struct({
+    type: Schema19.Literal("text"),
+    uri: Schema19.String,
+    text: Schema19.String,
+    mimeType: optional(Schema19.String)
+  }),
+  Schema19.Struct({
+    type: Schema19.Literal("blob"),
+    uri: Schema19.String,
+    blob: Schema19.String,
+    mimeType: optional(Schema19.String)
+  })
+]).pipe(Schema19.toTaggedUnion("type"), Schema19.annotate({ identifier: "Mcp.ResourceContentPart" }));
+var ResourceContent = Schema19.Struct({
+  server: Schema19.String,
+  uri: Schema19.String,
+  contents: Schema19.Array(ResourceContentPart)
+}).annotate({ identifier: "Mcp.ResourceContent" });
+
+// node_modules/@opencode/schema/dist/persistent-pty.js
+import { Schema as Schema41 } from "effect";
+
+// node_modules/@opencode/schema/dist/pty.js
+var pty_exports = {};
+__export(pty_exports, {
+  CreateInput: () => CreateInput2,
+  Event: () => Event9,
+  ID: () => ID9,
+  Info: () => Info9,
+  Pty: () => pty_exports,
+  UpdateInput: () => UpdateInput
+});
+import { Schema as Schema20 } from "effect";
+var IDSchema2 = Schema20.String.check(Schema20.isStartingWith("pty")).pipe(Schema20.brand("PtyID"), Schema20.annotate({ identifier: "Pty.ID" }));
+var ID9 = IDSchema2.pipe(statics((schema) => {
+  const create2 = () => schema.make("pty_" + ascending());
+  return {
+    create: create2,
+    ascending: (id) => id === void 0 ? create2() : schema.make(id)
+  };
+}));
+var Info9 = Schema20.Struct({
+  id: ID9,
+  title: Schema20.String,
+  command: Schema20.String,
+  args: Schema20.Array(Schema20.String),
+  cwd: Schema20.String,
+  status: Schema20.Literals(["running", "exited"]),
+  pid: NonNegativeInt,
+  exitCode: optional(NonNegativeInt)
+}).annotate({ identifier: "Pty" });
+var Created2 = ephemeral({ type: "pty.created", schema: { info: Info9 } });
+var Updated7 = ephemeral({ type: "pty.updated", schema: { info: Info9 } });
+var Exited = ephemeral({ type: "pty.exited", schema: { id: ID9, exitCode: NonNegativeInt } });
+var Deleted = ephemeral({ type: "pty.deleted", schema: { id: ID9 } });
+var Event9 = { Created: Created2, Updated: Updated7, Exited, Deleted, Definitions: inventory(Created2, Updated7, Exited, Deleted) };
+var CreateInput2 = Schema20.Struct({
+  command: optional(Schema20.String),
+  args: optional(Schema20.Array(Schema20.String)),
+  cwd: optional(Schema20.String),
+  title: optional(Schema20.String),
+  env: optional(Schema20.Record(Schema20.String, Schema20.String))
+});
+var UpdateInput = Schema20.Struct({
+  title: optional(Schema20.String),
+  size: optional(Schema20.Struct({
+    rows: PositiveInt,
+    cols: PositiveInt
+  }))
+});
+
+// node_modules/@opencode/schema/dist/session.js
+var session_exports = {};
+__export(session_exports, {
+  Event: () => Event13,
+  ForkBoundary: () => ForkBoundary,
+  ID: () => ID15,
+  Info: () => Info19,
+  ListAnchor: () => ListAnchor,
+  Metadata: () => Metadata3,
+  Revert: () => Revert,
+  Session: () => session_exports
+});
+import { Schema as Schema40 } from "effect";
+
+// node_modules/@opencode/schema/dist/project.js
+var project_exports = {};
+__export(project_exports, {
+  Commands: () => Commands,
+  Current: () => Current,
+  Event: () => Event10,
+  ID: () => ID10,
+  Icon: () => Icon,
+  Info: () => Info10,
+  Project: () => project_exports,
+  Time: () => Time,
+  UpdateInput: () => UpdateInput2,
+  Vcs: () => Vcs
+});
+import { Schema as Schema21 } from "effect";
+var ID10 = ProjectID;
+var Vcs = Schema21.String.check(Schema21.isPattern(/^[a-z][a-z0-9._-]*$/u)).annotate({
+  identifier: "Project.Vcs"
+});
+var Current = Schema21.Struct({
+  id: ID10,
+  directory: AbsolutePath,
+  canonical: AbsolutePath
+}).annotate({ identifier: "Project.Current" });
+var Icon = Schema21.Struct({
+  url: optional(Schema21.String),
+  override: optional(Schema21.String),
+  color: optional(Schema21.String)
+}).annotate({ identifier: "Project.Icon" });
+var Commands = Schema21.Struct({
+  start: optional(Schema21.String.annotate({ description: "Startup script to run when creating a new workspace (worktree)" }))
+}).annotate({ identifier: "Project.Commands" });
+var Time = Schema21.Struct({
+  created: NonNegativeInt,
+  updated: NonNegativeInt,
+  active: NonNegativeInt,
+  archived: optional(NonNegativeInt)
+}).annotate({ identifier: "Project.Time" });
+var Info10 = Schema21.Struct({
+  id: ID10,
+  canonical: AbsolutePath,
+  vcs: optional(Vcs),
+  name: optional(Schema21.String),
+  icon: optional(Icon),
+  commands: optional(Commands),
+  time: Time,
+  sandboxes: Schema21.Array(Schema21.String)
+}).annotate({ identifier: "Project" });
+var UpdateInput2 = Schema21.Struct({
+  projectID: ID10,
+  canonical: optional(AbsolutePath),
+  name: optional(Schema21.String),
+  icon: optional(Icon),
+  commands: optional(Commands)
+}).annotate({ identifier: "Project.UpdateInput" });
+var Updated8 = ephemeral({ type: "project.updated", schema: Info10.fields });
+var Event10 = { Updated: Updated8, Definitions: inventory(Updated8) };
+
+// node_modules/@opencode/schema/dist/session-event.js
+var session_event_exports = {};
+__export(session_event_exports, {
+  AgentSelected: () => AgentSelected2,
+  All: () => All,
+  Compaction: () => Compaction4,
+  Created: () => Created4,
+  Definitions: () => Definitions,
+  Deleted: () => Deleted3,
+  Durable: () => Durable,
+  DurableDefinitions: () => DurableDefinitions,
+  EphemeralDefinitions: () => EphemeralDefinitions,
+  Execution: () => Execution,
+  Forked: () => Forked,
+  InboxCancelled: () => InboxCancelled,
+  InboxDelivered: () => InboxDelivered,
+  InboxDeliveryChanged: () => InboxDeliveryChanged,
+  InboxEnqueued: () => InboxEnqueued,
+  InstructionsUpdated: () => InstructionsUpdated,
+  MessageContentUpdated: () => MessageContentUpdated,
+  MetadataUpdated: () => MetadataUpdated,
+  ModelSelected: () => ModelSelected2,
+  Moved: () => Moved,
+  Permissions: () => Permissions,
+  Reasoning: () => Reasoning,
+  Renamed: () => Renamed,
+  RetryScheduled: () => RetryScheduled,
+  RevertEvent: () => RevertEvent,
+  SessionEvent: () => session_event_exports,
+  Shell: () => Shell2,
+  Skill: () => Skill2,
+  Source: () => Source3,
+  Step: () => Step,
+  Synthetic: () => Synthetic3,
+  Text: () => Text,
+  Tool: () => Tool,
+  UsageRecorded: () => UsageRecorded,
+  UsageUpdated: () => UsageUpdated,
+  Viewed: () => Viewed
+});
+import { Schema as Schema39 } from "effect";
+
+// node_modules/@opencode/schema/dist/llm.js
+import { Schema as Schema22 } from "effect";
+var FinishReason = Schema22.Literals(["stop", "length", "tool-calls", "content-filter", "error", "unknown"]);
+
+// node_modules/@opencode/schema/dist/tool.js
+var tool_exports = {};
+__export(tool_exports, {
+  CallID: () => CallID,
+  Content: () => Content,
+  Error: () => Error2,
+  FileContent: () => FileContent,
+  TextContent: () => TextContent,
+  Tool: () => tool_exports
+});
+import { Effect as Effect3, JsonSchema, Schema as Schema23 } from "effect";
+var CallID = Schema23.String.pipe(Schema23.brand("Tool.CallID"));
+var Error2 = class extends Schema23.TaggedError()("Tool.Error", {
+  message: Schema23.String,
+  error: Schema23.optional(Schema23.Defect()),
+  metadata: Schema23.optional(Schema23.Record(Schema23.String, Schema23.Unknown))
+}) {
+};
+var TextContent = Schema23.Struct({
+  type: Schema23.Literal("text"),
+  text: Schema23.String
+}).annotate({ identifier: "Tool.TextContent" });
+var FileContent = Schema23.Struct({
+  type: Schema23.Literal("file"),
+  uri: Schema23.String,
+  mime: Schema23.String,
+  name: Schema23.optional(Schema23.String)
+}).annotate({ identifier: "Tool.FileContent" });
+var Content = Schema23.Union([TextContent, FileContent]).pipe(Schema23.toTaggedUnion("type")).annotate({ identifier: "Tool.Content" });
+
+// node_modules/@opencode/schema/dist/session-metadata.js
+import { Schema as Schema24 } from "effect";
+var SessionMetadata = Schema24.Record(Schema24.String, Schema24.Json).annotate({
+  identifier: "Session.Metadata"
+});
+
+// node_modules/@opencode/schema/dist/session-message.js
+var session_message_exports = {};
+__export(session_message_exports, {
+  AgentSelected: () => AgentSelected,
+  Assistant: () => Assistant,
+  AssistantContent: () => AssistantContent,
+  AssistantContentEncoded: () => AssistantContentEncoded,
+  AssistantReasoning: () => AssistantReasoning,
+  AssistantRetry: () => AssistantRetry,
+  AssistantText: () => AssistantText,
+  AssistantTool: () => AssistantTool,
+  Compaction: () => Compaction2,
+  CompactionCompleted: () => CompactionCompleted,
+  CompactionFailed: () => CompactionFailed,
+  CompactionRunning: () => CompactionRunning,
+  ID: () => ID14,
+  Idle: () => Idle,
+  Info: () => Info15,
+  LocationSwitched: () => LocationSwitched,
+  ModelSelected: () => ModelSelected,
+  ProviderState: () => ProviderState,
+  SessionMessage: () => session_message_exports,
+  Shell: () => Shell,
+  Skill: () => Skill,
+  Synthetic: () => Synthetic,
+  System: () => System,
+  ToolState: () => ToolState,
+  ToolStateCompleted: () => ToolStateCompleted,
+  ToolStateError: () => ToolStateError,
+  ToolStateRunning: () => ToolStateRunning,
+  ToolStateStreaming: () => ToolStateStreaming,
+  User: () => User
+});
+import { Schema as Schema32 } from "effect";
+
+// node_modules/@opencode/schema/dist/session-provider-context.js
+var session_provider_context_exports = {};
+__export(session_provider_context_exports, {
+  Info: () => Info11,
+  Provenance: () => Provenance,
+  SessionProviderContext: () => session_provider_context_exports
+});
+import { Schema as Schema25 } from "effect";
+var Provenance = Schema25.Struct({
+  providerID: provider_exports.ID,
+  provider: Schema25.String,
+  modelID: Schema25.String,
+  route: Schema25.String,
+  protocol: Schema25.String,
+  /** Digest of the configured endpoint; raw URLs and query values are not persisted. */
+  endpoint: Schema25.String
+}).annotate({ identifier: "Session.ProviderContext.Provenance" });
+var Info11 = Schema25.Struct({
+  version: Schema25.Literal(1),
+  provenance: Provenance,
+  messages: Schema25.Json
+}).annotate({ identifier: "Session.ProviderContext" });
+
+// node_modules/@opencode/schema/dist/prompt.js
+import { Schema as Schema27 } from "effect";
+
+// node_modules/@opencode/schema/dist/skill.js
+var skill_exports = {};
+__export(skill_exports, {
+  DirectorySource: () => DirectorySource,
+  EmbeddedSource: () => EmbeddedSource,
+  Event: () => Event11,
+  ID: () => ID11,
+  Info: () => Info12,
+  Name: () => Name2,
+  Skill: () => skill_exports,
+  Source: () => Source2,
+  UrlSource: () => UrlSource
+});
+import { Schema as Schema26 } from "effect";
+var ID11 = Schema26.String.pipe(Schema26.brand("Skill.ID"), Schema26.annotate({ identifier: "Skill.ID" }));
+var Name2 = Schema26.String.pipe(Schema26.brand("Skill.Name"), Schema26.annotate({ identifier: "Skill.Name" }));
+var DirectorySource = Schema26.Struct({
+  type: Schema26.tag("directory"),
+  path: AbsolutePath
+}).annotate({ identifier: "Skill.DirectorySource" });
+var UrlSource = Schema26.Struct({
+  type: Schema26.tag("url"),
+  url: Schema26.String
+}).annotate({ identifier: "Skill.UrlSource" });
+var Info12 = Schema26.Struct({
+  id: ID11,
+  name: Name2,
+  description: Schema26.String.pipe(optional),
+  autoinvoke: Schema26.Boolean.pipe(optional),
+  path: AbsolutePath,
+  content: Schema26.String
+}).annotate({ identifier: "Skill.Info" });
+var Updated9 = ephemeral({ type: "skill.updated", schema: {} });
+var Event11 = { Updated: Updated9, Definitions: inventory(Updated9) };
+var EmbeddedSource = Schema26.Struct({
+  type: Schema26.tag("embedded"),
+  skill: Schema26.suspend(() => Info12)
+}).annotate({ identifier: "Skill.EmbeddedSource" });
+var Source2 = Object.assign(Schema26.Union([DirectorySource, UrlSource, EmbeddedSource]).pipe(Schema26.toTaggedUnion("type"), Schema26.annotate({ identifier: "Skill.Source" })), {
+  equals: (a, b) => {
+    if (a.type !== b.type)
+      return false;
+    if (a.type === "directory" && b.type === "directory")
+      return a.path === b.path;
+    if (a.type === "url" && b.type === "url")
+      return a.url === b.url;
+    if (a.type === "embedded" && b.type === "embedded")
+      return a.skill.id === b.skill.id;
+    return false;
+  },
+  key: (source) => source.type === "directory" ? `directory:${source.path}` : source.type === "url" ? `url:${source.url}` : `embedded:${source.skill.id}`
+});
+
+// node_modules/@opencode/schema/dist/prompt.js
+var PromptMention = Schema27.Struct({
+  start: Schema27.Finite,
+  end: Schema27.Finite,
+  text: Schema27.String
+}).annotate({ identifier: "Prompt.Mention" });
+var FileSource = Schema27.Union([
+  Schema27.Struct({ type: Schema27.Literal("inline") }),
+  Schema27.Struct({ type: Schema27.Literal("uri"), uri: Schema27.String })
+]).pipe(Schema27.toTaggedUnion("type")).annotate({ identifier: "Prompt.FileSource" });
+var Base64 = Schema27.String.check(Schema27.isPattern(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u)).annotate({ identifier: "Prompt.Base64" });
+var FileAttachment = Schema27.Struct({
+  data: Base64,
+  mime: Schema27.String,
+  source: FileSource,
+  name: Schema27.String.pipe(optional),
+  description: Schema27.String.pipe(optional),
+  mention: PromptMention.pipe(optional)
+}).annotate({ identifier: "Prompt.FileAttachment" }).pipe(statics((schema) => ({
+  create: (input) => schema.make({
+    data: input.data,
+    mime: input.mime,
+    source: input.source,
+    name: input.name,
+    description: input.description,
+    mention: input.mention
+  })
+})));
+var AgentAttachment = Schema27.Struct({
+  name: Schema27.String,
+  mention: PromptMention.pipe(optional)
+}).annotate({ identifier: "Prompt.AgentAttachment" });
+var SkillAttachment = Schema27.Struct({
+  id: skill_exports.ID,
+  name: skill_exports.Name,
+  text: Schema27.String.pipe(optional),
+  mention: PromptMention.pipe(optional)
+}).annotate({ identifier: "Prompt.SkillAttachment" });
+var Prompt = Schema27.Struct({
+  text: Schema27.String,
+  files: Schema27.Array(FileAttachment).pipe(optional),
+  agents: Schema27.Array(AgentAttachment).pipe(optional),
+  skills: Schema27.Array(SkillAttachment).pipe(optional)
+}).annotate({ identifier: "Prompt" }).pipe(statics((schema) => ({
+  equivalence: Schema27.toEquivalence(schema),
+  fromUserMessage: (input) => schema.make({
+    text: input.text,
+    ...input.files === void 0 ? {} : { files: input.files },
+    ...input.agents === void 0 ? {} : { agents: input.agents },
+    ...input.skills === void 0 ? {} : { skills: input.skills }
+  })
+})));
+
+// node_modules/@opencode/schema/dist/shell.js
+var shell_exports = {};
+__export(shell_exports, {
+  CreateInput: () => CreateInput3,
+  Event: () => Event12,
+  ID: () => ID12,
+  Info: () => Info13,
+  Metadata: () => Metadata2,
+  Output: () => Output,
+  OutputInput: () => OutputInput,
+  Shell: () => shell_exports,
+  Status: () => Status3,
+  Time: () => Time2
+});
+import { Schema as Schema28 } from "effect";
+var IDSchema3 = Schema28.String.check(Schema28.isStartingWith("sh_")).pipe(Schema28.brand("Shell.ID"), Schema28.annotate({ identifier: "Shell.ID" }));
+var ID12 = IDSchema3.pipe(statics((schema) => {
+  const create2 = () => schema.make("sh_" + ascending());
+  return {
+    create: create2,
+    ascending: (id) => id === void 0 ? create2() : schema.make(id)
+  };
+}));
+var Status3 = Schema28.Literals(["running", "exited", "timeout", "killed"]);
+var Time2 = Schema28.Struct({
+  started: Schema28.Finite.annotate({ description: "Start time in milliseconds since the Unix epoch" }),
+  completed: optional(Schema28.Finite).annotate({
+    description: "Completion time in milliseconds since the Unix epoch"
+  })
+});
+var Metadata2 = Schema28.Record(Schema28.String, Schema28.Unknown);
+var Info13 = Schema28.Struct({
+  id: ID12,
+  status: Status3,
+  command: Schema28.String,
+  cwd: Schema28.String,
+  shell: Schema28.String,
+  // Absolute path of the file capturing combined stdout/stderr. Page through it via `output`.
+  file: Schema28.String,
+  pid: optional(NonNegativeInt),
+  exit: optional(Schema28.Finite),
+  signal: optional(Schema28.String),
+  // Always present; defaults to an empty object when the creator supplies no metadata.
+  metadata: Metadata2,
+  time: Time2
+}).annotate({ identifier: "Shell.Info" });
+var Created3 = ephemeral({ type: "shell.created", schema: { info: Info13 } });
+var Exited2 = ephemeral({ type: "shell.exited", schema: { id: ID12, exit: optional(Schema28.Finite), status: Status3 } });
+var Deleted2 = ephemeral({ type: "shell.deleted", schema: { id: ID12 } });
+var Event12 = { Created: Created3, Exited: Exited2, Deleted: Deleted2, Definitions: inventory(Created3, Exited2, Deleted2) };
+var CreateInput3 = Schema28.Struct({
+  command: Schema28.String,
+  cwd: optional(Schema28.String),
+  timeout: optional(NonNegativeInt),
+  metadata: optional(Metadata2)
+});
+var OutputInput = Schema28.Struct({
+  cursor: optional(NonNegativeInt),
+  limit: optional(NonNegativeInt)
+});
+var Output = Schema28.Struct({
+  output: Schema28.String,
+  // Absolute cursor after this page. Equals `size` once fully caught up.
+  cursor: NonNegativeInt,
+  // Total bytes captured so far. A consumer has more to page while `cursor < size`.
+  size: NonNegativeInt,
+  truncated: Schema28.Boolean
+});
+
+// node_modules/@opencode/schema/dist/session-error.js
+var session_error_exports = {};
+__export(session_error_exports, {
+  Error: () => Error3,
+  SessionError: () => session_error_exports
+});
+import { Schema as Schema29 } from "effect";
+var Error3 = Schema29.Struct({
+  type: Schema29.String,
+  message: Schema29.String,
+  status: Schema29.Int.check(Schema29.isBetween({ minimum: 100, maximum: 599 })).pipe(optional),
+  response: Schema29.Struct({ body: Schema29.String }).pipe(optional)
+}).annotate({ identifier: "Session.StructuredError" });
+
+// node_modules/@opencode/schema/dist/snapshot.js
+var snapshot_exports = {};
+__export(snapshot_exports, {
+  ID: () => ID13,
+  Snapshot: () => snapshot_exports
+});
+import { Schema as Schema30 } from "effect";
+var ID13 = Schema30.String.pipe(Schema30.brand("Snapshot.ID"), Schema30.annotate({ identifier: "Snapshot.ID" }));
+
+// node_modules/@opencode/schema/dist/token-usage.js
+var token_usage_exports = {};
+__export(token_usage_exports, {
+  Info: () => Info14,
+  TokenUsage: () => token_usage_exports,
+  total: () => total
+});
+import { Schema as Schema31 } from "effect";
+var Info14 = Schema31.Struct({
+  input: Schema31.Finite,
+  output: Schema31.Finite,
+  reasoning: Schema31.Finite,
+  cache: Schema31.Struct({
+    read: Schema31.Finite,
+    write: Schema31.Finite
+  })
+}).annotate({ identifier: "TokenUsage.Info" });
+function total(tokens) {
+  return tokens.input + tokens.output + tokens.reasoning + tokens.cache.read + tokens.cache.write;
+}
+
+// node_modules/@opencode/schema/dist/session-message.js
+var ID14 = Schema32.String.check(Schema32.isStartingWith("msg_")).pipe(Schema32.brand("Session.Message.ID"), Schema32.annotate({ identifier: "Session.Message.ID" }), statics((schema) => ({
+  create: () => schema.make("msg_" + ascending()),
+  fromEvent: (eventID) => schema.make(eventID.replace(/^evt_/, "msg_"))
+})));
+var Base = {
+  id: ID14,
+  metadata: Schema32.Record(Schema32.String, Schema32.Unknown).pipe(optional),
+  time: Schema32.Struct({ created: DateTimeUtcFromMillis })
+};
+var ProviderState = Schema32.Record(Schema32.String, Schema32.Unknown).annotate({
+  identifier: "Session.Message.ProviderState"
+});
+var AgentSelected = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("agent-switched"),
+  agent: agent_exports.ID,
+  previous: agent_exports.ID.pipe(optional)
+}).annotate({ identifier: "Session.Message.AgentSelected" });
+var ModelSelected = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("model-switched"),
+  model: model_exports.Ref,
+  previous: model_exports.Ref.pipe(optional)
+}).annotate({ identifier: "Session.Message.ModelSelected" });
+var LocationSwitched = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("location-switched"),
+  location: location_exports.Ref,
+  projectID: project_exports.ID.pipe(optional),
+  subpath: RelativePath.pipe(optional),
+  previous: Schema32.Struct({
+    location: location_exports.Ref,
+    projectID: project_exports.ID.pipe(optional),
+    subpath: RelativePath.pipe(optional)
+  }).pipe(optional)
+}).annotate({ identifier: "Session.Message.LocationSwitched" });
+var User = Schema32.Struct({
+  ...Base,
+  text: Prompt.fields.text,
+  files: Prompt.fields.files,
+  agents: Prompt.fields.agents,
+  skills: Prompt.fields.skills,
+  type: Schema32.tag("user")
+}).annotate({ identifier: "Session.Message.User" });
+var Synthetic = Schema32.Struct({
+  ...Base,
+  text: Schema32.String,
+  description: Schema32.String.pipe(optional),
+  type: Schema32.tag("synthetic")
+}).annotate({ identifier: "Session.Message.Synthetic" });
+var System = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("system"),
+  /** The model-facing update text, frozen at emit time. */
+  text: Schema32.String,
+  /** A short human-readable summary for transcript display. */
+  description: Schema32.String.pipe(optional)
+}).annotate({ identifier: "Session.Message.System" });
+var Skill = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("skill"),
+  skill: skill_exports.ID,
+  name: skill_exports.Name,
+  text: Schema32.String
+}).annotate({ identifier: "Session.Message.Skill" });
+var Shell = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("shell"),
+  shellID: shell_exports.ID,
+  command: Schema32.String,
+  status: shell_exports.Status,
+  exit: Schema32.Number.pipe(optional),
+  output: shell_exports.Output.pipe(optional),
+  time: Schema32.Struct({
+    created: DateTimeUtcFromMillis,
+    completed: DateTimeUtcFromMillis.pipe(optional)
+  })
+}).annotate({ identifier: "Session.Message.Shell" });
+var ToolStateStreaming = Schema32.Struct({
+  status: Schema32.tag("streaming"),
+  input: Schema32.String
+}).annotate({ identifier: "Session.Message.ToolState.Streaming" });
+var ToolStateRunning = Schema32.Struct({
+  status: Schema32.tag("running"),
+  input: Schema32.Record(Schema32.String, Schema32.Unknown),
+  metadata: Schema32.Record(Schema32.String, Schema32.Json)
+}).annotate({ identifier: "Session.Message.ToolState.Running" });
+var ToolStateCompleted = Schema32.Struct({
+  status: Schema32.tag("completed"),
+  input: Schema32.Record(Schema32.String, Schema32.Unknown),
+  content: Schema32.NonEmptyArray(Content),
+  metadata: Schema32.Record(Schema32.String, Schema32.Json).pipe(optional)
+}).annotate({ identifier: "Session.Message.ToolState.Completed" });
+var ToolStateError = Schema32.Struct({
+  status: Schema32.tag("error"),
+  input: Schema32.Record(Schema32.String, Schema32.Unknown),
+  error: session_error_exports.Error,
+  content: Schema32.NonEmptyArray(Content).pipe(optional),
+  metadata: Schema32.Record(Schema32.String, Schema32.Json).pipe(optional)
+}).annotate({ identifier: "Session.Message.ToolState.Error" });
+var ToolState = Schema32.Union([ToolStateStreaming, ToolStateRunning, ToolStateCompleted, ToolStateError]).pipe(Schema32.toTaggedUnion("status"));
+var AssistantTool = Schema32.Struct({
+  type: Schema32.tag("tool"),
+  id: Schema32.String,
+  name: Schema32.String,
+  executed: Schema32.Boolean.pipe(optional),
+  providerState: ProviderState.pipe(optional),
+  providerResultState: ProviderState.pipe(optional),
+  state: ToolState,
+  time: Schema32.Struct({
+    created: DateTimeUtcFromMillis,
+    ran: DateTimeUtcFromMillis.pipe(optional),
+    completed: DateTimeUtcFromMillis.pipe(optional)
+  })
+}).annotate({ identifier: "Session.Message.Assistant.Tool" });
+var AssistantText = Schema32.Struct({
+  type: Schema32.tag("text"),
+  text: Schema32.String,
+  state: ProviderState.pipe(optional)
+}).annotate({ identifier: "Session.Message.Assistant.Text" });
+var AssistantReasoning = Schema32.Struct({
+  type: Schema32.tag("reasoning"),
+  text: Schema32.String,
+  state: ProviderState.pipe(optional),
+  time: Schema32.Struct({
+    created: DateTimeUtcFromMillis,
+    completed: DateTimeUtcFromMillis.pipe(optional)
+  }).pipe(optional)
+}).annotate({ identifier: "Session.Message.Assistant.Reasoning" });
+var AssistantContent = Schema32.Union([AssistantText, AssistantReasoning, AssistantTool]).pipe(Schema32.toTaggedUnion("type"));
+var AssistantContentEncoded = Schema32.toEncoded(AssistantContent).annotate({
+  identifier: "Session.Message.AssistantContent.Encoded"
+});
+var AssistantRetry = Schema32.Struct({
+  attempt: PositiveInt,
+  at: DateTimeUtcFromMillis,
+  error: session_error_exports.Error
+}).annotate({ identifier: "Session.Message.Assistant.Retry" });
+var Assistant = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("assistant"),
+  agent: agent_exports.ID,
+  model: model_exports.Ref,
+  content: AssistantContent.pipe(Schema32.Array),
+  snapshot: Schema32.Struct({
+    start: snapshot_exports.ID.pipe(optional),
+    end: snapshot_exports.ID.pipe(optional),
+    files: Schema32.Array(RelativePath).pipe(optional)
+  }).pipe(optional),
+  finish: FinishReason.pipe(optional),
+  rawFinish: Schema32.String.pipe(optional),
+  providerState: ProviderState.pipe(optional),
+  cost: money_exports.USD.pipe(optional),
+  tokens: token_usage_exports.Info.pipe(optional),
+  error: session_error_exports.Error.pipe(optional),
+  retry: AssistantRetry.pipe(optional),
+  time: Schema32.Struct({
+    created: DateTimeUtcFromMillis,
+    /** When the provider response body ended, before tool settlement. */
+    streamed: DateTimeUtcFromMillis.pipe(optional),
+    completed: DateTimeUtcFromMillis.pipe(optional)
+  })
+}).annotate({ identifier: "Session.Message.Assistant" });
+var CompactionBase = { type: Schema32.tag("compaction"), ...Base };
+var CompactionUsage = {
+  cost: money_exports.USD.pipe(optional),
+  tokens: token_usage_exports.Info.pipe(optional)
+};
+var CompactionRunning = Schema32.Struct({
+  ...CompactionBase,
+  status: Schema32.tag("running"),
+  reason: Schema32.Literals(["auto", "manual"]),
+  summary: Schema32.String,
+  recent: Schema32.String
+}).annotate({ identifier: "Session.Message.Compaction.Running" });
+var CompactionCompleted = Schema32.Struct({
+  ...CompactionBase,
+  status: Schema32.tag("completed"),
+  reason: Schema32.Literals(["auto", "manual"]),
+  model: model_exports.Ref.pipe(optional),
+  providerState: ProviderState.pipe(optional),
+  summary: Schema32.String,
+  recent: Schema32.String,
+  providerContext: session_provider_context_exports.Info.pipe(optional),
+  ...CompactionUsage
+}).annotate({ identifier: "Session.Message.Compaction.Completed" });
+var CompactionFailed = Schema32.Struct({
+  ...CompactionBase,
+  status: Schema32.tag("failed"),
+  reason: Schema32.Literals(["auto", "manual"]),
+  error: session_error_exports.Error,
+  ...CompactionUsage
+}).annotate({ identifier: "Session.Message.Compaction.Failed" });
+var Compaction2 = Schema32.Union([CompactionRunning, CompactionCompleted, CompactionFailed]).pipe(Schema32.toTaggedUnion("status"), Schema32.annotate({ identifier: "Session.Message.Compaction" }));
+var Idle = Schema32.Struct({
+  ...Base,
+  type: Schema32.tag("idle"),
+  outcome: Schema32.Literals(["succeeded", "failed", "interrupted"]),
+  error: session_error_exports.Error.pipe(optional)
+}).annotate({ identifier: "Session.Message.Idle" });
+var Info15 = Schema32.Union([
+  AgentSelected,
+  ModelSelected,
+  LocationSwitched,
+  User,
+  Synthetic,
+  System,
+  Skill,
+  Shell,
+  Assistant,
+  Compaction2,
+  Idle
+]).annotate({ identifier: "Session.Message.Info" });
+
+// node_modules/@opencode/schema/dist/session-revert.js
+import { Schema as Schema34, SchemaTransformation as SchemaTransformation2 } from "effect";
+
+// node_modules/@opencode/schema/dist/file-diff.js
+var file_diff_exports = {};
+__export(file_diff_exports, {
+  FileDiff: () => file_diff_exports,
+  Info: () => Info16,
+  LegacyInfo: () => LegacyInfo
+});
+import { Schema as Schema33 } from "effect";
+var Info16 = Schema33.Struct({
+  file: Schema33.String,
+  patch: Schema33.String,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt,
+  status: Schema33.Literals(["added", "deleted", "modified"])
+}).annotate({ identifier: "FileDiff.Info" });
+var LegacyInfo = Schema33.Struct({
+  file: Schema33.String.pipe(optional),
+  patch: Schema33.String.pipe(optional),
+  additions: Schema33.Finite,
+  deletions: Schema33.Finite,
+  status: Schema33.Literals(["added", "deleted", "modified"]).pipe(optional)
+}).annotate({ identifier: "FileDiff.LegacyInfo" });
+
+// node_modules/@opencode/schema/dist/session-revert.js
+var Revert = Schema34.Struct({
+  messageID: session_message_exports.ID,
+  /** Legacy V1 compatibility state. */
+  partID: Schema34.String.pipe(optional),
+  snapshot: snapshot_exports.ID.pipe(optional),
+  files: Schema34.Array(file_diff_exports.Info).pipe(optional)
+}).annotate({ identifier: "Session.Revert" });
+var FileDiffV1 = Schema34.Struct({
+  path: Schema34.String,
+  status: Schema34.Literals(["added", "modified", "deleted"]),
+  additions: Schema34.Finite,
+  deletions: Schema34.Finite,
+  patch: Schema34.String
+});
+var RevertV1 = Schema34.Struct({
+  messageID: session_message_exports.ID,
+  partID: Schema34.String.pipe(optional),
+  snapshot: Schema34.String.pipe(optional),
+  diff: Schema34.String.pipe(optional),
+  files: Schema34.Array(FileDiffV1).pipe(optional)
+}).annotate({ identifier: "Session.RevertV1" });
+var PersistedCurrent = Revert.pipe(Schema34.decodeTo(Schema34.Struct({ source: Schema34.tag("current"), revert: Schema34.toType(Revert) }), SchemaTransformation2.transform({
+  decode: (revert) => ({
+    source: "current",
+    revert
+  }),
+  encode: (value) => value.revert
+})));
+var PersistedLegacy = RevertV1.pipe(Schema34.decodeTo(Schema34.Struct({ source: Schema34.tag("legacy"), revert: Schema34.toType(RevertV1) }), SchemaTransformation2.transform({
+  decode: (revert) => ({
+    source: "legacy",
+    revert
+  }),
+  encode: (value) => value.revert
+})));
+var PersistedRevert = Schema34.Union([PersistedCurrent, PersistedLegacy]).pipe(Schema34.toTaggedUnion("source"), Schema34.decodeTo(Schema34.toType(Revert), SchemaTransformation2.transform({
+  decode: (persisted) => {
+    if (persisted.source === "current")
+      return persisted.revert;
+    return Revert.make({
+      messageID: persisted.revert.messageID,
+      partID: persisted.revert.partID,
+      snapshot: persisted.revert.snapshot ? snapshot_exports.ID.make(persisted.revert.snapshot) : void 0,
+      files: persisted.revert.files?.map((file) => ({
+        file: file.path,
+        status: file.status,
+        additions: file.additions,
+        deletions: file.deletions,
+        patch: file.patch
+      }))
+    });
+  },
+  encode: (revert) => ({
+    source: "current",
+    revert
+  })
+})), Schema34.annotate({ identifier: "Session.Revert.Persisted" }));
+
+// node_modules/@opencode/schema/dist/instruction.js
+var instruction_exports = {};
+__export(instruction_exports, {
+  Delta: () => Delta,
+  Hash: () => Hash,
+  Instruction: () => instruction_exports,
+  Key: () => Key2,
+  Removed: () => Removed,
+  Values: () => Values,
+  removed: () => removed
+});
+import { Schema as Schema35 } from "effect";
+var Key2 = Schema35.String.check(Schema35.isPattern(/^[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._/-]*$/u)).pipe(Schema35.brand("Instruction.Key"), Schema35.annotate({ identifier: "Instruction.Key" }));
+var Hash = Schema35.String.check(Schema35.isPattern(/^[a-f0-9]{64}$/u)).pipe(Schema35.brand("Instruction.Hash"), Schema35.annotate({ identifier: "Instruction.Hash" }));
+var Values = Schema35.Record(Key2, Hash);
+var Removed = Schema35.Literal("removed");
+var removed = Removed.make("removed");
+var Delta = Schema35.Record(Schema35.String, Schema35.Union([Hash, Removed]));
+
+// node_modules/@opencode/schema/dist/instruction-entry.js
+var instruction_entry_exports = {};
+__export(instruction_entry_exports, {
+  Info: () => Info17,
+  InstructionEntry: () => instruction_entry_exports,
+  Key: () => Key3,
+  MaxValueBytes: () => MaxValueBytes,
+  Snapshot: () => Snapshot,
+  ValueTooLargeError: () => ValueTooLargeError
+});
+import { Schema as Schema36 } from "effect";
+var Key3 = Schema36.String.check(Schema36.isPattern(/^[a-z0-9][a-z0-9._-]*$/u)).annotate({
+  identifier: "InstructionEntry.Key",
+  description: "Instruction entry key (lowercase alphanumerics plus . _ -)"
+});
+var Info17 = Schema36.Struct({
+  key: Key3,
+  value: Schema36.Json.annotate({ description: "JSON value attached to the session's instructions" })
+}).annotate({ identifier: "InstructionEntry.Info" });
+var Snapshot = Schema36.Array(Schema36.Struct({
+  ...Info17.fields,
+  removed: Schema36.Boolean
+})).annotate({ identifier: "InstructionEntry.Snapshot" });
+var MaxValueBytes = 256 * 1024;
+var ValueTooLargeError = class extends Schema36.TaggedError()("InstructionEntryValueTooLargeError", {
+  actualBytes: Schema36.Int,
+  maxBytes: Schema36.Int,
+  message: Schema36.String
+}, { httpApiStatus: 413 }) {
+};
+
+// node_modules/@opencode/schema/dist/session-inbox.js
+var session_inbox_exports = {};
+__export(session_inbox_exports, {
+  Compaction: () => Compaction3,
+  CompactionPayload: () => CompactionPayload,
+  Delivery: () => Delivery,
+  Info: () => Info18,
+  Item: () => Item,
+  Move: () => Move,
+  MovePayload: () => MovePayload,
+  SessionInbox: () => session_inbox_exports,
+  Synthetic: () => Synthetic2,
+  SyntheticPayload: () => SyntheticPayload,
+  User: () => User2,
+  UserPayload: () => UserPayload
+});
+import { Schema as Schema37 } from "effect";
+var Delivery = Schema37.Literals(["steer", "queue"]).annotate({ identifier: "Session.Inbox.Delivery" });
+var UserPayload = Schema37.Struct({
+  ...Prompt.fields,
+  metadata: Schema37.Record(Schema37.String, Schema37.Unknown).pipe(optional)
+}).annotate({ identifier: "Session.Inbox.UserPayload" });
+var SyntheticPayload = Schema37.Struct({
+  text: Schema37.String,
+  description: Schema37.String.pipe(optional),
+  metadata: Schema37.Record(Schema37.String, Schema37.Unknown).pipe(optional)
+}).annotate({ identifier: "Session.Inbox.SyntheticPayload" });
+var CompactionPayload = Schema37.Struct({}).annotate({ identifier: "Session.Inbox.CompactionPayload" });
+var MovePayload = Schema37.Struct({
+  location: location_exports.Ref,
+  projectID: project_exports.ID,
+  subpath: RelativePath.pipe(optional)
+}).annotate({ identifier: "Session.Inbox.MovePayload" });
+var UserItem = Schema37.Struct({ type: Schema37.tag("user"), payload: UserPayload, delivery: Delivery });
+var SyntheticItem = Schema37.Struct({ type: Schema37.tag("synthetic"), payload: SyntheticPayload, delivery: Delivery });
+var CompactionItem = Schema37.Struct({
+  type: Schema37.tag("compaction"),
+  payload: CompactionPayload,
+  delivery: Delivery
+});
+var MoveItem = Schema37.Struct({ type: Schema37.tag("move"), payload: MovePayload, delivery: Delivery });
+var Item = Schema37.Union([UserItem, SyntheticItem, CompactionItem, MoveItem]).pipe(Schema37.toTaggedUnion("type"), Schema37.annotate({ identifier: "Session.Inbox.Item" }));
+var Enqueued = {
+  id: session_message_exports.ID,
+  sessionID: SessionID,
+  time: Schema37.Struct({ created: DateTimeUtcFromMillis })
+};
+var User2 = Schema37.Struct({ ...Enqueued, ...UserItem.fields }).annotate({ identifier: "Session.Inbox.User" });
+var Synthetic2 = Schema37.Struct({ ...Enqueued, ...SyntheticItem.fields }).annotate({
+  identifier: "Session.Inbox.Synthetic"
+});
+var Compaction3 = Schema37.Struct({ ...Enqueued, ...CompactionItem.fields }).annotate({
+  identifier: "Session.Inbox.Compaction"
+});
+var Move = Schema37.Struct({ ...Enqueued, ...MoveItem.fields }).annotate({ identifier: "Session.Inbox.Move" });
+var Info18 = Schema37.Union([User2, Synthetic2, Compaction3, Move]).pipe(Schema37.toTaggedUnion("type"), Schema37.annotate({ identifier: "Session.Inbox.Info" }));
+
+// node_modules/@opencode/schema/dist/session-fork.js
+var session_fork_exports = {};
+__export(session_fork_exports, {
+  Boundary: () => Boundary,
+  SessionFork: () => session_fork_exports
+});
+import { Schema as Schema38 } from "effect";
+var Boundary = Schema38.Union([
+  Schema38.Struct({ type: Schema38.Literal("before"), messageID: session_message_exports.ID }),
+  Schema38.Struct({ type: Schema38.Literal("through"), messageID: session_message_exports.ID })
+]).annotate({ identifier: "Session.ForkBoundary" });
+
+// node_modules/@opencode/schema/dist/session-event.js
+var Source3 = Schema39.Struct({
+  start: NonNegativeInt,
+  end: NonNegativeInt,
+  text: Schema39.String
+}).annotate({
+  identifier: "Session.Event.Source"
+});
+var Base2 = {
+  sessionID: SessionID
+};
+var options = {
+  durable: {
+    aggregate: "sessionID",
+    version: 1
+  }
+};
+var Created4 = event_exports.durable({
+  type: "session.created",
+  ...options,
+  schema: {
+    ...Base2,
+    projectID: project_exports.ID,
+    location: location_exports.Ref,
+    subpath: RelativePath.pipe(optional),
+    parentID: SessionID.pipe(optional),
+    slug: Schema39.String,
+    title: Schema39.String.pipe(optional),
+    agent: agent_exports.ID.pipe(optional),
+    model: model_exports.Ref.pipe(optional),
+    /** Host-supplied annotations resolved at creation, including any inherited from a parent. */
+    metadata: SessionMetadata.pipe(optional),
+    permissions: permission_exports.Ruleset.pipe(optional),
+    version: Schema39.String
+  }
+});
+var AgentSelected2 = event_exports.durable({
+  type: "session.agent.selected",
+  ...options,
+  schema: {
+    ...Base2,
+    agent: agent_exports.ID,
+    previous: agent_exports.ID.pipe(optional)
+  }
+});
+var ModelSelected2 = event_exports.durable({
+  type: "session.model.selected",
+  ...options,
+  schema: {
+    ...Base2,
+    model: model_exports.Ref,
+    previous: model_exports.Ref.pipe(optional)
+  }
+});
+var Moved = event_exports.durable({
+  type: "session.moved",
+  ...options,
+  schema: {
+    ...Base2,
+    ...session_inbox_exports.MovePayload.fields
+  }
+});
+var Renamed = event_exports.durable({
+  type: "session.renamed",
+  ...options,
+  schema: {
+    ...Base2,
+    title: Schema39.String
+  }
+});
+var MetadataUpdated = event_exports.durable({
+  type: "session.metadata.updated",
+  ...options,
+  schema: {
+    ...Base2,
+    metadata: SessionMetadata
+  }
+});
+var Permissions = event_exports.durable({
+  type: "session.permissions",
+  ...options,
+  schema: {
+    ...Base2,
+    permissions: permission_exports.Ruleset
+  }
+});
+var Viewed = event_exports.durable({
+  type: "session.viewed",
+  ...options,
+  schema: {
+    ...Base2,
+    /** Epoch-millisecond idle watermark the viewer observed; projection never marks a newer idle transition viewed. */
+    idle: Schema39.Finite
+  }
+});
+var MessageContentUpdated = event_exports.durable({
+  type: "session.message.content.updated",
+  ...options,
+  schema: {
+    ...Base2,
+    messageID: session_message_exports.ID,
+    // Public events are framed directly, so timestamps must already be encoded.
+    content: Schema39.Array(session_message_exports.AssistantContentEncoded)
+  }
+});
+var UsageRecorded = event_exports.durable({
+  type: "session.usage.recorded",
+  ...options,
+  schema: {
+    ...Base2,
+    source: Schema39.Literals(["title", "compaction"]),
+    cost: money_exports.USD,
+    tokens: token_usage_exports.Info
+  }
+});
+var UsageUpdated = event_exports.ephemeral({
+  type: "session.usage.updated",
+  schema: {
+    ...Base2,
+    cost: money_exports.USD,
+    tokens: token_usage_exports.Info
+  }
+});
+var Deleted3 = event_exports.durable({
+  type: "session.deleted",
+  durable: {
+    aggregate: "sessionID",
+    version: 2
+  },
+  schema: Base2
+});
+var Forked = event_exports.durable({
+  type: "session.forked",
+  durable: {
+    aggregate: "sessionID",
+    version: 2
+  },
+  schema: {
+    ...Base2,
+    parentID: SessionID,
+    boundary: session_fork_exports.Boundary,
+    instructions: instruction_exports.Values.pipe(optional),
+    instructionEntries: instruction_entry_exports.Snapshot.pipe(optional)
+  }
+});
+var InboxRef = {
+  ...Base2,
+  inboxID: session_message_exports.ID
+};
+var InboxDelivered = event_exports.durable({
+  type: "session.inbox.delivered",
+  ...options,
+  schema: InboxRef
+});
+var InboxEnqueued = event_exports.durable({
+  type: "session.inbox.enqueued",
+  ...options,
+  schema: {
+    ...InboxRef,
+    item: session_inbox_exports.Item
+  }
+});
+var InboxCancelled = event_exports.durable({
+  type: "session.inbox.cancelled",
+  ...options,
+  schema: InboxRef
+});
+var InboxDeliveryChanged = event_exports.durable({
+  type: "session.inbox.delivery.changed",
+  ...options,
+  schema: { ...InboxRef, delivery: session_inbox_exports.Delivery }
+});
+var Execution;
+(function(Execution2) {
+  Execution2.Started = event_exports.durable({ type: "session.execution.started", ...options, schema: Base2 });
+  Execution2.Succeeded = event_exports.durable({ type: "session.execution.succeeded", ...options, schema: Base2 });
+  Execution2.Failed = event_exports.durable({
+    type: "session.execution.failed",
+    ...options,
+    schema: { ...Base2, error: session_error_exports.Error }
+  });
+  Execution2.Interrupted = event_exports.durable({
+    type: "session.execution.interrupted",
+    ...options,
+    schema: { ...Base2, reason: Schema39.Literals(["user", "shutdown", "superseded", "inactivity"]) }
+  });
+})(Execution || (Execution = {}));
+var InstructionsUpdated = event_exports.durable({
+  type: "session.instructions.updated",
+  durable: {
+    aggregate: "sessionID",
+    version: 2
+  },
+  schema: {
+    ...Base2,
+    delta: instruction_exports.Delta,
+    /**
+     * The rendered chronological update shown to the model, frozen at emit time.
+     * Absent for the initial baseline observation and for deltas that render empty.
+     */
+    text: Schema39.String.pipe(optional)
+  }
+});
+var Synthetic3 = event_exports.durable({
+  type: "session.synthetic",
+  ...options,
+  schema: {
+    ...Base2,
+    text: Schema39.String,
+    description: Schema39.String.pipe(optional),
+    metadata: Schema39.Record(Schema39.String, Schema39.Unknown).pipe(optional)
+  }
+});
+var Skill2;
+(function(Skill3) {
+  Skill3.Activated = event_exports.durable({
+    type: "session.skill.activated",
+    ...options,
+    schema: {
+      ...Base2,
+      id: skill_exports.ID,
+      name: skill_exports.Name,
+      text: Schema39.String
+    }
+  });
+})(Skill2 || (Skill2 = {}));
+var Shell2;
+(function(Shell3) {
+  Shell3.Started = event_exports.durable({
+    type: "session.shell.started",
+    ...options,
+    schema: {
+      ...Base2,
+      shell: shell_exports.Info
+    }
+  });
+  Shell3.Ended = event_exports.durable({
+    type: "session.shell.ended",
+    ...options,
+    schema: {
+      ...Base2,
+      shell: shell_exports.Info,
+      output: shell_exports.Output
+    }
+  });
+})(Shell2 || (Shell2 = {}));
+var Step;
+(function(Step2) {
+  Step2.Started = event_exports.durable({
+    type: "session.step.started",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      agent: agent_exports.ID,
+      model: model_exports.Ref,
+      snapshot: snapshot_exports.ID.pipe(optional),
+      /** Request dispatch time, before waiting for provider output. */
+      started: NonNegativeInt
+    }
+  });
+  Step2.Streamed = event_exports.durable({
+    type: "session.step.streamed",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID
+    }
+  });
+  Step2.Ended = event_exports.durable({
+    type: "session.step.ended",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      finish: FinishReason,
+      rawFinish: Schema39.String.pipe(optional),
+      providerState: session_message_exports.ProviderState.pipe(optional),
+      cost: money_exports.USD,
+      tokens: token_usage_exports.Info,
+      snapshot: snapshot_exports.ID.pipe(optional),
+      files: Schema39.Array(RelativePath).pipe(optional)
+    }
+  });
+  Step2.Failed = event_exports.durable({
+    type: "session.step.failed",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      error: session_error_exports.Error,
+      finish: Schema39.Literals(["content-filter"]).pipe(optional),
+      rawFinish: Schema39.String.pipe(optional),
+      providerState: session_message_exports.ProviderState.pipe(optional),
+      cost: money_exports.USD.pipe(optional),
+      tokens: token_usage_exports.Info.pipe(optional),
+      snapshot: snapshot_exports.ID.pipe(optional),
+      files: Schema39.Array(RelativePath).pipe(optional)
+    }
+  });
+})(Step || (Step = {}));
+var Text;
+(function(Text2) {
+  Text2.Started = event_exports.durable({
+    type: "session.text.started",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt
+    }
+  });
+  Text2.Delta = event_exports.ephemeral({
+    type: "session.text.delta",
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt,
+      delta: Schema39.String
+    }
+  });
+  Text2.Ended = event_exports.durable({
+    type: "session.text.ended",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt,
+      text: Schema39.String,
+      state: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+})(Text || (Text = {}));
+var Reasoning;
+(function(Reasoning2) {
+  Reasoning2.Started = event_exports.durable({
+    type: "session.reasoning.started",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt,
+      state: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+  Reasoning2.Delta = event_exports.ephemeral({
+    type: "session.reasoning.delta",
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt,
+      delta: Schema39.String
+    }
+  });
+  Reasoning2.Ended = event_exports.durable({
+    type: "session.reasoning.ended",
+    ...options,
+    schema: {
+      ...Base2,
+      assistantMessageID: session_message_exports.ID,
+      ordinal: NonNegativeInt,
+      text: Schema39.String,
+      state: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+})(Reasoning || (Reasoning = {}));
+var Tool;
+(function(Tool3) {
+  const ToolBase = {
+    ...Base2,
+    assistantMessageID: session_message_exports.ID,
+    id: Schema39.String
+  };
+  let Input2;
+  (function(Input3) {
+    Input3.Started = event_exports.durable({
+      type: "session.tool.input.started",
+      ...options,
+      schema: {
+        ...ToolBase,
+        name: Schema39.String
+      }
+    });
+    Input3.Delta = event_exports.ephemeral({
+      type: "session.tool.input.delta",
+      schema: {
+        ...ToolBase,
+        delta: Schema39.String
+      }
+    });
+    Input3.Ended = event_exports.durable({
+      type: "session.tool.input.ended",
+      ...options,
+      schema: {
+        ...ToolBase,
+        text: Schema39.String
+      }
+    });
+  })(Input2 = Tool3.Input || (Tool3.Input = {}));
+  Tool3.Called = event_exports.durable({
+    type: "session.tool.called",
+    ...options,
+    schema: {
+      ...ToolBase,
+      input: Schema39.Record(Schema39.String, Schema39.Unknown),
+      executed: Schema39.Boolean,
+      state: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+  Tool3.Progress = event_exports.ephemeral({
+    type: "session.tool.progress",
+    schema: {
+      ...ToolBase,
+      metadata: Schema39.Record(Schema39.String, Schema39.Json)
+    }
+  });
+  Tool3.Success = event_exports.durable({
+    type: "session.tool.success",
+    durable: {
+      aggregate: "sessionID",
+      version: 2
+    },
+    schema: {
+      ...ToolBase,
+      content: Schema39.NonEmptyArray(Content),
+      metadata: Schema39.Record(Schema39.String, Schema39.Json).pipe(optional),
+      executed: Schema39.Boolean,
+      resultState: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+  Tool3.Failed = event_exports.durable({
+    type: "session.tool.failed",
+    durable: {
+      aggregate: "sessionID",
+      version: 2
+    },
+    schema: {
+      ...ToolBase,
+      error: session_error_exports.Error,
+      content: Schema39.NonEmptyArray(Content).pipe(optional),
+      metadata: Schema39.Record(Schema39.String, Schema39.Json).pipe(optional),
+      executed: Schema39.Boolean,
+      resultState: session_message_exports.ProviderState.pipe(optional)
+    }
+  });
+})(Tool || (Tool = {}));
+var RetryScheduled = event_exports.durable({
+  type: "session.retry.scheduled",
+  ...options,
+  schema: {
+    ...Base2,
+    assistantMessageID: session_message_exports.ID,
+    attempt: PositiveInt,
+    at: NonNegativeInt,
+    error: session_error_exports.Error
+  }
+});
+var Compaction4;
+(function(Compaction5) {
+  Compaction5.Started = event_exports.durable({
+    type: "session.compaction.started",
+    ...options,
+    schema: {
+      ...Base2,
+      reason: Schema39.Literals(["auto", "manual"]),
+      recent: Schema39.String,
+      inputID: session_message_exports.ID.pipe(optional)
+    }
+  });
+  Compaction5.Delta = event_exports.ephemeral({
+    type: "session.compaction.delta",
+    schema: {
+      ...Base2,
+      text: Schema39.String
+    }
+  });
+  Compaction5.Ended = event_exports.durable({
+    type: "session.compaction.ended",
+    ...options,
+    schema: {
+      ...Base2,
+      reason: Compaction5.Started.data.fields.reason,
+      model: session_message_exports.CompactionCompleted.fields.model,
+      providerState: session_message_exports.CompactionCompleted.fields.providerState,
+      providerContext: session_message_exports.CompactionCompleted.fields.providerContext,
+      text: Schema39.String,
+      recent: Schema39.String,
+      // Repeats the internal `session.usage.recorded` figures: that event never reaches clients, and it
+      // stays the accounting source for session totals and stats.
+      cost: session_message_exports.CompactionCompleted.fields.cost,
+      tokens: session_message_exports.CompactionCompleted.fields.tokens
+    }
+  });
+  Compaction5.Failed = event_exports.durable({
+    type: "session.compaction.failed",
+    ...options,
+    schema: {
+      ...Base2,
+      reason: Compaction5.Started.data.fields.reason,
+      error: session_error_exports.Error,
+      inputID: session_message_exports.ID.pipe(optional),
+      cost: session_message_exports.CompactionFailed.fields.cost,
+      tokens: session_message_exports.CompactionFailed.fields.tokens
+    }
+  });
+})(Compaction4 || (Compaction4 = {}));
+var RevertEvent;
+(function(RevertEvent2) {
+  RevertEvent2.Staged = event_exports.durable({
+    type: "session.revert.staged",
+    ...options,
+    schema: { ...Base2, revert: Revert }
+  });
+  RevertEvent2.Cleared = event_exports.durable({ type: "session.revert.cleared", ...options, schema: Base2 });
+  RevertEvent2.Committed = event_exports.durable({
+    type: "session.revert.committed",
+    ...options,
+    schema: { ...Base2, to: session_message_exports.ID }
+  });
+})(RevertEvent || (RevertEvent = {}));
+var Definitions = event_exports.inventory(Created4, AgentSelected2, ModelSelected2, Moved, Renamed, MetadataUpdated, Permissions, Viewed, UsageUpdated, Deleted3, Forked, InboxDelivered, InboxEnqueued, InboxCancelled, InboxDeliveryChanged, Execution.Started, Execution.Succeeded, Execution.Failed, Execution.Interrupted, InstructionsUpdated, Synthetic3, Skill2.Activated, Shell2.Started, Shell2.Ended, Step.Started, Step.Streamed, Step.Ended, Step.Failed, Text.Started, Text.Delta, Text.Ended, Reasoning.Started, Reasoning.Delta, Reasoning.Ended, Tool.Input.Started, Tool.Input.Delta, Tool.Input.Ended, Tool.Called, Tool.Progress, Tool.Success, Tool.Failed, RetryScheduled, Compaction4.Started, Compaction4.Delta, Compaction4.Ended, Compaction4.Failed, RevertEvent.Staged, RevertEvent.Cleared, RevertEvent.Committed);
+var DurableDefinitions = event_exports.inventory(...Definitions.filter((definition) => definition.durability === "durable"), UsageRecorded, MessageContentUpdated);
+var EphemeralDefinitions = event_exports.inventory(...Definitions.filter((definition) => definition.durability === "ephemeral"));
+var Durable = Schema39.Union(DurableDefinitions, { mode: "oneOf" }).pipe(Schema39.toTaggedUnion("type")).annotate({ identifier: "Session.Event.Durable" });
+var All = Schema39.Union([Durable, ...EphemeralDefinitions], { mode: "oneOf" }).pipe(Schema39.toTaggedUnion("type"));
+
+// node_modules/@opencode/schema/dist/session.js
+var ID15 = SessionID;
+var Metadata3 = SessionMetadata;
+var Event13 = session_event_exports;
+var ForkBoundary = session_fork_exports.Boundary;
+var Info19 = Schema40.Struct({
+  id: ID15,
+  parentID: ID15.pipe(optional),
+  fork: Schema40.Struct({
+    sessionID: ID15,
+    boundary: ForkBoundary
+  }).pipe(optional),
+  projectID: project_exports.ID,
+  agent: agent_exports.ID.pipe(optional),
+  model: model_exports.Ref.pipe(optional),
+  cost: money_exports.USD,
+  tokens: token_usage_exports.Info,
+  /** Outcome of the last completed execution, recorded at `time.idle`. Absent until a run reaches a terminal transition. */
+  outcome: Schema40.Literals(["succeeded", "failed", "interrupted"]).pipe(optional),
+  time: Schema40.Struct({
+    created: DateTimeUtcFromMillis,
+    updated: DateTimeUtcFromMillis,
+    idle: DateTimeUtcFromMillis.pipe(optional),
+    viewed: DateTimeUtcFromMillis.pipe(optional),
+    archived: DateTimeUtcFromMillis.pipe(optional)
+  }),
+  title: Schema40.String.pipe(optional),
+  location: location_exports.Ref,
+  subpath: RelativePath.pipe(optional),
+  metadata: Metadata3.pipe(optional),
+  /** Evaluated after the agent's rules; the last matching rule wins. */
+  permissions: permission_exports.Ruleset.pipe(optional),
+  revert: Revert.pipe(optional)
+}).annotate({ identifier: "Session.Info" });
+var ListAnchor = Schema40.Struct({
+  id: ID15,
+  time: Schema40.Finite,
+  direction: Schema40.Literals(["previous", "next"])
+}).annotate({ identifier: "Session.ListAnchor" });
+
+// node_modules/@opencode/schema/dist/persistent-pty.js
+var Info20 = Schema41.Struct({
+  ...pty_exports.Info.fields,
+  sessionID: session_exports.ID,
+  foregroundProcess: Schema41.NullOr(Schema41.String),
+  size: Schema41.Struct({ cols: PositiveInt, rows: PositiveInt }),
+  output: Schema41.Struct({ head: NonNegativeInt, tail: NonNegativeInt })
+}).annotate({ identifier: "PersistentPty.Info" });
+var Handoff = Schema41.Struct({
+  directory: Schema41.String,
+  instanceID: Schema41.String,
+  ticket: Schema41.String,
+  expiresAt: Schema41.Number
+}).annotate({ identifier: "PersistentPty.Handoff" });
+var CreateInput4 = Schema41.Struct({
+  command: optional(Schema41.String),
+  args: Schema41.Array(Schema41.String),
+  cwd: optional(Schema41.String),
+  title: Schema41.String,
+  env: Schema41.Record(Schema41.String, Schema41.String),
+  size: optional(Schema41.Struct({ cols: PositiveInt, rows: PositiveInt }))
+}).annotate({ identifier: "PersistentPty.CreateInput" });
+var UpdateInput3 = Schema41.Struct({
+  attachmentID: optional(Schema41.String),
+  size: Schema41.Struct({ cols: PositiveInt, rows: PositiveInt })
+}).annotate({ identifier: "PersistentPty.UpdateInput" });
+var Snapshot2 = Schema41.Struct({
+  info: Info20,
+  text: Schema41.String,
+  checkpoint: Schema41.Uint8Array,
+  cursor: Schema41.Struct({ x: NonNegativeInt, y: NonNegativeInt })
+}).annotate({ identifier: "PersistentPty.Snapshot" });
+var ReadLines = PositiveInt.check(Schema41.isLessThanOrEqualTo(65535)).annotate({
+  identifier: "PersistentPty.ReadLines"
+});
+var ReadResult = Schema41.Struct({
+  ptyID: pty_exports.ID,
+  title: Schema41.String,
+  cwd: Schema41.String,
+  foregroundProcess: Schema41.NullOr(Schema41.String),
+  screen: Schema41.Struct({
+    text: Schema41.String,
+    cols: PositiveInt,
+    rows: PositiveInt,
+    cursor: Snapshot2.fields.cursor
+  })
+}).annotate({ identifier: "PersistentPty.ReadResult" });
+var Added = ephemeral({ type: "persistent-pty.added", schema: { sessionID: session_exports.ID, terminal: Info20 } });
+var Removed2 = ephemeral({ type: "persistent-pty.removed", schema: { sessionID: session_exports.ID, ptyID: pty_exports.ID } });
+var Event14 = { Added, Removed: Removed2, Definitions: inventory(Added, Removed2) };
+
+// node_modules/@opencode/schema/dist/reference.js
+import { Schema as Schema42 } from "effect";
+var Updated10 = ephemeral({ type: "reference.updated", schema: {} });
+var Event15 = { Updated: Updated10, Definitions: inventory(Updated10) };
+var LocalSource = Schema42.Struct({
+  type: Schema42.Literal("local"),
+  path: AbsolutePath,
+  description: Schema42.String.pipe(optional),
+  hidden: Schema42.Boolean.pipe(optional)
+}).annotate({ identifier: "Reference.LocalSource" });
+var GitSource = Schema42.Struct({
+  type: Schema42.Literal("git"),
+  repository: Schema42.String,
+  branch: Schema42.String.pipe(optional),
+  description: Schema42.String.pipe(optional),
+  hidden: Schema42.Boolean.pipe(optional)
+}).annotate({ identifier: "Reference.GitSource" });
+var Source4 = Schema42.Union([LocalSource, GitSource]).pipe(Schema42.toTaggedUnion("type")).annotate({ identifier: "Reference.Source" });
+var Info21 = Schema42.Struct({
+  name: Schema42.String,
+  path: AbsolutePath,
+  description: Schema42.String.pipe(optional),
+  hidden: Schema42.Boolean.pipe(optional),
+  source: Source4
+}).annotate({ identifier: "Reference.Info" });
+
+// node_modules/@opencode/schema/dist/vcs.js
+import { Schema as Schema43 } from "effect";
+var Branch = Schema43.Struct({
+  current: optional(Schema43.String),
+  default: optional(Schema43.String)
+}).annotate({ identifier: "Vcs.Branch" });
+var Info22 = Schema43.Struct({
+  provider: optional(Schema43.String),
+  branch: Branch
+}).annotate({ identifier: "Vcs.Info" });
+var BranchList = Schema43.Array(Schema43.String).annotate({ identifier: "Vcs.BranchList" });
+var Base3 = Schema43.Struct({
+  name: Schema43.String,
+  ref: Schema43.String,
+  source: Schema43.Literals(["reflog", "default"])
+}).annotate({ identifier: "Vcs.Base" });
+var Mode = Schema43.Literals(["working", "branch", "committed"]).annotate({ identifier: "Vcs.Mode" });
+var FileStatus = Schema43.Struct({
+  file: Schema43.String,
+  additions: NonNegativeInt,
+  deletions: NonNegativeInt,
+  status: Schema43.Literals(["added", "deleted", "modified"])
+}).annotate({ identifier: "Vcs.FileStatus" });
+
+// node_modules/@opencode/schema/dist/websearch.js
+import { Schema as Schema44 } from "effect";
+var ID16 = Schema44.String.pipe(Schema44.brand("WebSearch.ID"), Schema44.annotate({ identifier: "WebSearch.ID" }));
+var Provider = Schema44.Struct({
+  id: ID16,
+  name: Schema44.String
+}).annotate({ identifier: "WebSearch.Provider" });
+var Input = Schema44.Struct({
+  query: Schema44.String,
+  providerID: ID16.pipe(optional)
+}).annotate({ identifier: "WebSearch.Input" });
+var Result = Schema44.Struct({
+  url: Schema44.String,
+  title: Schema44.String.pipe(optional),
+  content: Schema44.String.pipe(optional),
+  time: Schema44.Struct({
+    published: Schema44.Finite.pipe(optional).annotate({
+      description: "Publication time in milliseconds since the Unix epoch"
+    })
+  })
+}).annotate({ identifier: "WebSearch.Result" });
+var Response2 = class extends Schema44.Class("WebSearch.Response")({
+  providerID: ID16,
+  results: Schema44.Array(Result)
+}) {
+};
+var Updated11 = ephemeral({
+  type: "websearch.updated",
+  schema: {}
+});
+var Event16 = { Updated: Updated11, Definitions: inventory(Updated11) };
+
+// node_modules/@opencode/schema/dist/worktree.js
+import { Schema as Schema45 } from "effect";
+var StrategyID = Schema45.Trim.pipe(Schema45.check(Schema45.isNonEmpty()), Schema45.brand("Worktree.StrategyID"));
+var CreateInput5 = Schema45.Struct({
+  projectID: project_exports.ID,
+  from: optional(AbsolutePath),
+  branch: optional(Schema45.Trim.pipe(Schema45.check(Schema45.isNonEmpty()))),
+  directory: optional(AbsolutePath).annotate({
+    description: "Parent directory for the new worktree. Uses the project's canonical configuration, then defaults to the server's data directory under worktree/<first six project ID characters>."
+  }),
+  name: optional(Schema45.String)
+}).annotate({ identifier: "Worktree.CreateInput" });
+var RemoveInput = Schema45.Struct({
+  projectID: project_exports.ID,
+  directory: AbsolutePath,
+  force: Schema45.Boolean
+}).annotate({ identifier: "Worktree.RemoveInput" });
+var Info23 = Schema45.Struct({
+  directory: AbsolutePath
+}).annotate({ identifier: "Worktree.Info" });
+var Directory = Schema45.Struct({
+  directory: AbsolutePath,
+  strategy: optional(Schema45.String)
+}).annotate({ identifier: "Worktree.Directory" });
+var ListEntry = Schema45.Struct({
+  directory: AbsolutePath,
+  type: Schema45.Literals(["root", "worktree"])
+}).annotate({ identifier: "Worktree.ListEntry" });
+var OperationError = class extends Schema45.TaggedError()("Worktree.OperationError", {
+  message: Schema45.String,
+  forceRequired: optional(Schema45.Boolean)
+}) {
+};
+var List = Schema45.Array(Directory).annotate({ identifier: "Worktree.List" });
+var Updated12 = ephemeral({
+  type: "worktree.updated",
+  schema: { projectID: project_exports.ID }
+});
+var Resolved = durable({
+  type: "worktree.resolved",
+  durable: { aggregate: "projectID", version: 1 },
+  schema: {
+    projectID: project_exports.ID,
+    directory: AbsolutePath,
+    previous: project_exports.ID,
+    adopted: optional(Schema45.Array(project_exports.ID))
+  }
+});
+var Event17 = { Updated: Updated12, Resolved, Definitions: inventory(Updated12, Resolved) };
+
+// src/opencode/v2/index.ts
+import { Effect as Effect5 } from "effect";
+
+// src/config/options.ts
+var OptionsError = class extends Error {
+  code = "CONFIG_INVALID";
+  path;
+  constructor(path3 = "options") {
+    super("CONFIG_INVALID");
+    this.name = "OptionsError";
+    this.path = path3;
+  }
+};
+var ceilings = {
+  sourceBytes: 1048576,
+  totalSourceBytes: 2097152,
+  sourceCount: 4,
+  secretCount: 1e3,
+  secretBytes: 16384,
+  indexBytes: 8388608,
+  inputBytes: 1048576,
+  outputBytes: 2097152,
+  traversalDepth: 32,
+  traversalNodes: 5e4,
+  workingBytes: 33554432
+};
+var DEFAULT_LIMITS = {
+  sourceBytes: 65536,
+  totalSourceBytes: 131072,
+  sourceCount: 2,
+  secretCount: 50,
+  secretBytes: 4096,
+  indexBytes: 1048576,
+  inputBytes: 32768,
+  outputBytes: 65536,
+  traversalDepth: 8,
+  traversalNodes: 1e3,
+  workingBytes: 1048576
+};
+var keys = (value, allowed, path3) => {
+  for (const key of Object.keys(value)) if (!allowed.includes(key)) throw new OptionsError(`${path3}.${key}`);
+};
+function checked(value, path3, seen) {
+  if (typeof value !== "object" || value === null || !Array.isArray(value) && Object.getPrototypeOf(value) !== Object.prototype || Array.isArray(value) && Object.getPrototypeOf(value) !== Array.prototype) throw new OptionsError(path3);
+  if (seen.has(value)) throw new OptionsError(path3);
+  seen.add(value);
+  for (const key of Object.keys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) throw new OptionsError(`${path3}.${key}`);
+    if (typeof descriptor.value === "object" && descriptor.value !== null) checked(descriptor.value, `${path3}.${key}`, seen);
+  }
+  seen.delete(value);
+  return value;
+}
+var string = (value, path3, pattern) => {
+  if (typeof value !== "string" || value.length === 0 || value.length > 256 || pattern && !pattern.test(value) || /\$\{(?:env|file):/i.test(value)) throw new OptionsError(path3);
+  return value;
+};
+var list = (value, path3) => {
+  if (!Array.isArray(value)) throw new OptionsError(path3);
+  return value;
+};
+function parseOptionsUnsafe(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const options2 = checked(input, "options", seen);
+  keys(options2, ["version", "sources", "limits"], "options");
+  if (options2.version !== 1) throw new OptionsError("options.version");
+  const sources = list(options2.sources, "options.sources").map((raw, i) => {
+    const source = checked(raw, `sources[${i}]`, seen);
+    keys(source, ["id", "type", "format", "path", "required", "keys"], `sources[${i}]`);
+    const path3 = string(source.path, `sources[${i}].path`);
+    if (path3.includes("\0") || path3.startsWith("/") || path3.startsWith("\\") || /^[A-Za-z]:/.test(path3) || path3.split(/[\\/]/).some((segment) => segment === "." || segment === "..")) throw new OptionsError(`sources[${i}].path`);
+    if (source.type !== "file" || source.format !== "dotenv" || typeof source.required !== "boolean") throw new OptionsError(`sources[${i}]`);
+    const sourceKeys = list(source.keys, `sources[${i}].keys`).map((key, keyIndex) => string(key, `sources[${i}].keys[${keyIndex}]`, /^[A-Za-z_][A-Za-z0-9_]*$/));
+    if (sourceKeys.length === 0 || new Set(sourceKeys).size !== sourceKeys.length) throw new OptionsError(`sources[${i}].keys`);
+    return { id: string(source.id, `sources[${i}].id`, /^[A-Za-z][A-Za-z0-9._-]*$/), type: "file", format: "dotenv", path: path3, required: source.required, keys: sourceKeys };
+  });
+  if (sources.length === 0 || sources.length > ceilings.sourceCount || new Set(sources.map((s) => s.id)).size !== sources.length) throw new OptionsError("sources");
+  const configuredLimits = checked(options2.limits === void 0 ? DEFAULT_LIMITS : options2.limits, "options.limits", seen);
+  keys(configuredLimits, Object.keys(ceilings), "limits");
+  const limits = {};
+  for (const key of Object.keys(ceilings)) {
+    const value = configuredLimits[key];
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value <= 0 || value > ceilings[key]) throw new OptionsError(`limits.${key}`);
+    limits[key] = value;
+  }
+  return { version: 1, sources, limits };
+}
+function parseOptions(input) {
+  try {
+    return parseOptionsUnsafe(input);
+  } catch (error) {
+    if (error instanceof OptionsError) throw error;
+    throw new OptionsError();
+  }
+}
+
+// src/opencode/v2/runtime.ts
+import { Effect as Effect4 } from "effect";
+import { randomBytes } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/store/index.ts
+import { randomBytes as systemRandomBytes } from "node:crypto";
+
+// src/budgets/index.ts
+var dimensions = /* @__PURE__ */ new Set(["sourceCount", "sourceBytes", "totalSourceBytes", "secretCount", "secretBytes", "indexBytes", "inputBytes", "outputBytes", "traversalDepth", "traversalNodes", "workingBytes", "calls", "nodes", "depth", "sessions", "handles"]);
+var BudgetLedger = class {
+  used = /* @__PURE__ */ new Map();
+  limits;
+  constructor(limits) {
+    const values = inspect(limits);
+    if (!values) throw new Error("invalid");
+    for (const [key, value] of values) if (!dimensions.has(key) || typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) throw new Error("invalid");
+    this.limits = Object.fromEntries(values);
+  }
+  reserve(request) {
+    try {
+      const values = inspect(request);
+      if (!values) return { ok: false };
+      for (const [key, value] of values) {
+        if (!dimensions.has(key) || typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) return { ok: false };
+        const limit = this.limits[key];
+        const current = this.used.get(key) ?? 0;
+        if (value > Number.MAX_SAFE_INTEGER - current) return { ok: false };
+        if (limit !== void 0 && current + value > limit) return { ok: false };
+      }
+      const committed = values;
+      for (const [key, value] of committed) this.used.set(key, (this.used.get(key) ?? 0) + value);
+      let disposed = false;
+      return { ok: true, value: { dispose: () => {
+        if (disposed) return;
+        disposed = true;
+        for (const [key, value] of committed) this.used.set(key, (this.used.get(key) ?? 0) - value);
+      } } };
+    } catch {
+      return { ok: false };
+    }
+  }
+};
+function inspect(value) {
+  try {
+    if (!value || typeof value !== "object") return void 0;
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) return void 0;
+    const keys2 = Reflect.ownKeys(value);
+    if (keys2.some((key) => typeof key !== "string")) return void 0;
+    const result = [];
+    for (const key of keys2) {
+      if (typeof key !== "string") return void 0;
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (!descriptor || !descriptor.enumerable || !("value" in descriptor)) return void 0;
+      result.push([key, descriptor.value]);
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/store/index.ts
+var ActivationStore = class {
+  entries = /* @__PURE__ */ new Map();
+  redactions = /* @__PURE__ */ new Map();
+  budget;
+  random;
+  active = true;
+  constructor(options2) {
+    if (!options2 || typeof options2.location?.directory !== "string" || !Number.isInteger(options2.generation) || options2.generation < 0) throw new Error("invalid");
+    this.budget = options2.budget ?? new BudgetLedger({ handles: 65536, secretCount: 65536, secretBytes: 128 * 1024 * 1024, indexBytes: 128 * 1024 * 1024, workingBytes: 128 * 1024 * 1024 });
+    this.random = options2.randomBytes ?? (() => new Uint8Array(systemRandomBytes(16)));
+  }
+  register(value) {
+    if (!this.active || typeof value !== "string" || value.length === 0) throw new Error("denied");
+    const existing = this.redactions.get(value);
+    if (existing !== void 0) return existing;
+    const reservation = this.reserve({ handles: 1, secretCount: 1, secretBytes: Buffer.byteLength(value), indexBytes: Buffer.byteLength(value), workingBytes: Buffer.byteLength(value) });
+    if (reservation === void 0) throw new Error("denied");
+    const handle = this.newHandle();
+    this.entries.set(handle, reservation);
+    this.redactions.set(value, handle);
+    return handle;
+  }
+  teardown() {
+    this.active = false;
+    for (const reservation of this.entries.values()) reservation.dispose();
+    this.entries.clear();
+    this.redactions.clear();
+  }
+  reserve(request) {
+    const result = this.budget.reserve(request);
+    return result.ok ? result.value : void 0;
+  }
+  newHandle() {
+    for (let attempt = 0; attempt < 32; attempt += 1) {
+      const bytes2 = this.random();
+      if (!(bytes2 instanceof Uint8Array) || bytes2.length !== 16) throw new Error("denied");
+      const copy = new Uint8Array(bytes2);
+      copy[6] = copy[6] & 15 | 64;
+      copy[8] = copy[8] & 63 | 128;
+      const hex = Buffer.from(copy).toString("hex");
+      const handle = `secret-${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+      if (!this.entries.has(handle)) return handle;
+    }
+    throw new Error("denied");
+  }
+};
+
+// src/sources/dotenv.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+var SourceParseError = class extends Error {
+  code = "SOURCE_INVALID";
+  constructor() {
+    super("SOURCE_INVALID");
+    this.name = "SourceParseError";
+  }
+};
+function parseDotenv(source, options2 = {}) {
+  try {
+    const limits = normalizeOptions(options2);
+    if (typeof source !== "string") throw new SourceParseError();
+    const bytes2 = Buffer.byteLength(source, "utf8");
+    if (bytes2 > limits.maxBytes) throw new SourceParseError();
+    const entries = [];
+    const names = /* @__PURE__ */ new Set();
+    let index = 0;
+    while (index < source.length) {
+      const lineStart = index;
+      const end = source.indexOf("\n", index);
+      const lineEnd = end < 0 ? source.length : end;
+      let line = source.slice(index, lineEnd);
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      index = end < 0 ? source.length : end + 1;
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) continue;
+      const assignment = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*/.exec(line);
+      if (!assignment) throw new SourceParseError();
+      const key = assignment[1];
+      if (names.has(key)) throw new SourceParseError();
+      names.add(key);
+      let rest = line.slice(assignment[0].length);
+      let lexical = rest;
+      let value;
+      if (rest.startsWith("'") || rest.startsWith('"')) {
+        const quote = rest[0];
+        let content = rest.slice(1);
+        let close = quotedClose(content, quote);
+        while (close < 0) {
+          if (index >= source.length) throw new SourceParseError();
+          const nextEnd = source.indexOf("\n", index);
+          const nextLineEnd = nextEnd < 0 ? source.length : nextEnd;
+          let next = source.slice(index, nextLineEnd);
+          if (next.endsWith("\r")) next = next.slice(0, -1);
+          content += "\n" + next;
+          index = nextEnd < 0 ? source.length : nextEnd + 1;
+          close = quotedClose(content, quote);
+        }
+        const body = content.slice(0, close);
+        const after = content.slice(close + 1).trim();
+        if (after !== "" && !after.startsWith("#")) throw new SourceParseError();
+        value = quote === '"' ? decodeDouble(body) : body;
+        lexical = quote + body + quote;
+      } else {
+        const comment = rest.indexOf("#");
+        if (comment >= 0) rest = rest.slice(0, comment);
+        value = rest.trimEnd();
+        lexical = value;
+      }
+      if (Buffer.byteLength(value, "utf8") > limits.maxValueBytes || entries.length >= limits.maxEntries) throw new SourceParseError();
+      entries.push(Object.freeze({ key, value, lexicalValue: lexical }));
+      void lineStart;
+    }
+    return Object.freeze({ entries: Object.freeze(entries), bytes: bytes2 });
+  } catch (error) {
+    if (error instanceof SourceParseError) throw error;
+    throw new SourceParseError();
+  }
+}
+function normalizeOptions(options2) {
+  if (options2 === null || typeof options2 !== "object" || Array.isArray(options2)) throw new SourceParseError();
+  const prototype = Object.getPrototypeOf(options2);
+  if (prototype !== Object.prototype && prototype !== null) throw new SourceParseError();
+  const names = Object.getOwnPropertyNames(options2);
+  if (Object.getOwnPropertySymbols(options2).length !== 0 || names.some((name) => !["maxBytes", "maxEntries", "maxValueBytes"].includes(name))) throw new SourceParseError();
+  const values = {};
+  for (const name of names) {
+    const descriptor = Object.getOwnPropertyDescriptor(options2, name);
+    if (!descriptor || !("value" in descriptor)) throw new SourceParseError();
+    values[name] = descriptor.value;
+  }
+  const result = {
+    maxBytes: values.maxBytes === void 0 ? 1048576 : values.maxBytes,
+    maxEntries: values.maxEntries === void 0 ? 1e3 : values.maxEntries,
+    maxValueBytes: values.maxValueBytes === void 0 ? 16384 : values.maxValueBytes
+  };
+  if (![result.maxBytes, result.maxEntries, result.maxValueBytes].every((value) => typeof value === "number" && Number.isSafeInteger(value) && value > 0)) throw new SourceParseError();
+  return result;
+}
+function decodeDouble(value) {
+  return value.replace(/\\([\\"nrt])/g, (_match, escaped) => ({ "\\": "\\", '"': '"', n: "\n", r: "\r", t: "	" })[escaped] ?? escaped);
+}
+function quotedClose(value, quote) {
+  for (let i = 0; i < value.length; i++) {
+    if (value[i] === quote) return i;
+    if (value[i] !== "\\") continue;
+    const escaped = value[++i];
+    if (escaped === void 0) throw new SourceParseError();
+    const valid = quote === '"' ? '\\"nrt'.includes(escaped) : escaped === quote || escaped === "\\";
+    if (!valid) throw new SourceParseError();
+  }
+  return -1;
+}
+function loadDotenvFile(filePath, options2 = {}) {
+  try {
+    const resolved = path.resolve(filePath);
+    const stat = fs.lstatSync(resolved);
+    if (!stat.isFile() || stat.isSymbolicLink()) throw new SourceParseError();
+    const noFollow = fs.constants.O_NOFOLLOW ?? 0;
+    const descriptor = fs.openSync(resolved, fs.constants.O_RDONLY | noFollow);
+    try {
+      const opened = fs.fstatSync(descriptor);
+      if (!opened.isFile()) throw new SourceParseError();
+      const raw = fs.readFileSync(descriptor, "utf8");
+      return parseDotenv(raw, options2);
+    } finally {
+      fs.closeSync(descriptor);
+    }
+  } catch (e) {
+    throw new SourceParseError();
+  }
+}
+
+// src/sanitize/index.ts
+var DEFAULT_MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_DEPTH = 32;
+var DEFAULT_MAX_NODES = 5e4;
+var DEFAULT_MAX_MATCHES = 5e4;
+var MAX_OUTPUT_BYTES = DEFAULT_MAX_OUTPUT_BYTES;
+var MAX_DEPTH = DEFAULT_MAX_DEPTH;
+var MAX_NODES = DEFAULT_MAX_NODES;
+var MAX_MATCHES = DEFAULT_MAX_MATCHES;
+var MAX_PATTERN_COUNT = 4096;
+var MAX_PATTERN_TEXT = 65536;
+var MAX_REPRESENTATIONS = 16;
+var MAX_INDEX_ENTRIES = 65536;
+var MAX_IDENTITY_ENTRIES = 5e4;
+var MAX_PATTERN_BYTES = 4 * 1024 * 1024;
+var MAX_TEMP_BYTES = 8 * 1024 * 1024;
+var reservedPatternBytes = 0;
+var reservedIndexEntries = 0;
+var reservedIdentityEntries = 0;
+var reservedTempBytes = 0;
+function reserveOperation(patterns, inputBytes) {
+  try {
+    if (patterns !== void 0 && !Array.isArray(patterns)) return null;
+    const count = patterns?.length ?? 0;
+    if (count > MAX_PATTERN_COUNT) return null;
+    let patternBytes = 0;
+    for (const item of patterns ?? []) {
+      const text = typeof item === "string" ? item : (() => {
+        if (item === null || typeof item !== "object") return null;
+        const descriptor = Object.getOwnPropertyDescriptor(item, "text");
+        return descriptor && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : null;
+      })();
+      if (text === null) return null;
+      patternBytes += encoder.encode(text).byteLength;
+      if (patternBytes > MAX_PATTERN_BYTES) return null;
+    }
+    const indexEntries = count * MAX_REPRESENTATIONS;
+    const identityEntries = count;
+    const tempBytes = inputBytes + patternBytes;
+    if (!Number.isSafeInteger(inputBytes) || inputBytes < 0 || indexEntries > MAX_INDEX_ENTRIES || identityEntries > MAX_IDENTITY_ENTRIES || tempBytes > MAX_TEMP_BYTES) return null;
+    if (reservedPatternBytes > MAX_PATTERN_BYTES - patternBytes || reservedIndexEntries > MAX_INDEX_ENTRIES - indexEntries || reservedIdentityEntries > MAX_IDENTITY_ENTRIES - identityEntries || reservedTempBytes > MAX_TEMP_BYTES - tempBytes) return null;
+    reservedPatternBytes += patternBytes;
+    reservedIndexEntries += indexEntries;
+    reservedIdentityEntries += identityEntries;
+    reservedTempBytes += tempBytes;
+    let released = false;
+    return { release: () => {
+      if (released) return;
+      released = true;
+      reservedPatternBytes -= patternBytes;
+      reservedIndexEntries -= indexEntries;
+      reservedIdentityEntries -= identityEntries;
+      reservedTempBytes -= tempBytes;
+    } };
+  } catch {
+    return null;
+  }
+}
+var RESERVED_OUTPUT_INVENTORY = Object.freeze([
+  "true",
+  "false",
+  "null",
+  "REDACTED",
+  "SANITIZATION_UNAVAILABLE",
+  "INVALID_CREDENTIAL",
+  "ACCESS_DENIED",
+  "UNAVAILABLE",
+  "error",
+  "content",
+  "text"
+]);
+function base64(bytes2) {
+  let binary = "";
+  for (const byte of bytes2) binary += String.fromCharCode(byte);
+  return Buffer.from(binary, "binary").toString("base64");
+}
+function representationsFor(value) {
+  const reservation = typeof value === "string" ? reserveOperation(void 0, encoder.encode(value).byteLength) : null;
+  try {
+    if (typeof value !== "string" || value.length > MAX_PATTERN_TEXT) return null;
+    const bytes2 = encoder.encode(value);
+    if (bytes2.byteLength > MAX_PATTERN_TEXT * 3) return null;
+    const encoded = Array.from(bytes2, (byte) => {
+      const character = String.fromCharCode(byte);
+      return /[A-Za-z0-9\-_.!~*'()]/u.test(character) ? character : `%${byte.toString(16).padStart(2, "0")}`;
+    }).join("");
+    const percentUpper = encoded.replace(/%[0-9a-f]{2}/g, (part) => part.toUpperCase());
+    const padded = base64(bytes2);
+    const url = padded.replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+    const doubleQuoted = `"${value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("\r", "\\r").replaceAll("	", "\\t")}"`;
+    const singleQuoted = `'${value}'`;
+    const dotenv = [doubleQuoted, singleQuoted];
+    if (/^[^\s#'"\\\r\n]+$/u.test(value)) dotenv.push(value);
+    const result = {
+      semantic: value,
+      dotenv,
+      json: JSON.stringify(value).slice(1, -1),
+      percent: [encoded, percentUpper],
+      base64: [padded, padded.replace(/=+$/u, ""), url]
+    };
+    return result.dotenv.length + result.percent.length + result.base64.length > MAX_REPRESENTATIONS ? null : result;
+  } catch {
+    return null;
+  } finally {
+    reservation?.release();
+  }
+}
+function patternRepresentations(pattern) {
+  const reservation = reserveOperation([pattern], 0);
+  try {
+    if (typeof pattern?.text !== "string") return null;
+    const derived = representationsFor(pattern.text);
+    if (derived === null) return null;
+    const result = [.../* @__PURE__ */ new Set([pattern.text, ...derived.dotenv, derived.json, ...derived.percent, ...derived.base64])];
+    return result.length > MAX_REPRESENTATIONS ? null : result;
+  } catch {
+    return null;
+  } finally {
+    reservation?.release();
+  }
+}
+var encoder = new TextEncoder();
+var REDACTION = "[REDACTED]";
+var UUID_TEMPLATE = [
+  ..."secret-",
+  ...Array.from({ length: 8 }, () => "h"),
+  "-",
+  ...Array.from({ length: 4 }, () => "h"),
+  "-",
+  "4",
+  ...Array.from({ length: 3 }, () => "h"),
+  "-",
+  "v",
+  ...Array.from({ length: 3 }, () => "h"),
+  "-",
+  ...Array.from({ length: 12 }, () => "h")
+];
+function uuidLanguageContains(value) {
+  if (value.length === 0 || value.length > UUID_TEMPLATE.length) return false;
+  const hex = /^[0-9a-f]$/i;
+  for (let start = 0; start <= UUID_TEMPLATE.length - value.length; start++) {
+    let fits = true;
+    for (let i = 0; i < value.length; i++) {
+      const slot = UUID_TEMPLATE[start + i];
+      const character = value[i];
+      const slotMatches = slot === "h" ? hex.test(character ?? "") : slot === "v" ? /^[89ab]$/i.test(character ?? "") : slot === character;
+      if (slot === void 0 || character === void 0 || !slotMatches) {
+        fits = false;
+        break;
+      }
+    }
+    if (fits) return true;
+  }
+  return false;
+}
+function admitPatterns(patterns) {
+  const reservation = reserveOperation(patterns, 0);
+  if (reservation === null) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+  try {
+    for (const pattern of patterns) {
+      if (pattern === null || typeof pattern !== "object" || Array.isArray(pattern)) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+      const prototype = Object.getPrototypeOf(pattern);
+      if (prototype !== Object.prototype && prototype !== null) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+      const names = Object.getOwnPropertyNames(pattern);
+      if (Object.getOwnPropertySymbols(pattern).length !== 0 || names.some((name) => !["text", "replacement", "entry", "representations"].includes(name))) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+      for (const name of names) {
+        const descriptor = Object.getOwnPropertyDescriptor(pattern, name);
+        if (descriptor === void 0 || !("value" in descriptor)) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+      }
+      const representations = patternRepresentations(pattern);
+      if (representations === null) return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+      for (const representation of representations) {
+        if (representation.length === 0 || uuidLanguageContains(representation) || RESERVED_OUTPUT_INVENTORY.some((item) => item.includes(representation))) {
+          return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+        }
+      }
+    }
+    return { ok: true };
+  } catch {
+    return { ok: false, code: "SANITIZATION_UNAVAILABLE" };
+  } finally {
+    reservation.release();
+  }
+}
+function normalizedBudget(budget) {
+  try {
+    if (budget === null || typeof budget !== "object" || Array.isArray(budget)) return null;
+    const prototype = Object.getPrototypeOf(budget);
+    if (prototype !== Object.prototype && prototype !== null) return null;
+    const names = Object.getOwnPropertyNames(budget);
+    if (Object.getOwnPropertySymbols(budget).length !== 0 || names.some((name) => !["maxOutputBytes", "maxDepth", "maxNodes", "maxMatches"].includes(name))) return null;
+    const data = {};
+    for (const name of names) {
+      const descriptor = Object.getOwnPropertyDescriptor(budget, name);
+      if (descriptor === void 0 || !("value" in descriptor)) return null;
+      data[name] = descriptor.value;
+    }
+    const values = {
+      maxOutputBytes: data.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+      maxDepth: data.maxDepth ?? DEFAULT_MAX_DEPTH,
+      maxNodes: data.maxNodes ?? DEFAULT_MAX_NODES,
+      maxMatches: data.maxMatches ?? DEFAULT_MAX_MATCHES
+    };
+    const valid = typeof values.maxOutputBytes === "number" && Number.isSafeInteger(values.maxOutputBytes) && values.maxOutputBytes >= 0 && values.maxOutputBytes <= MAX_OUTPUT_BYTES && typeof values.maxDepth === "number" && Number.isSafeInteger(values.maxDepth) && values.maxDepth >= 0 && values.maxDepth <= MAX_DEPTH && typeof values.maxNodes === "number" && Number.isSafeInteger(values.maxNodes) && values.maxNodes >= 0 && values.maxNodes <= MAX_NODES && typeof values.maxMatches === "number" && Number.isSafeInteger(values.maxMatches) && values.maxMatches >= 0 && values.maxMatches <= MAX_MATCHES;
+    return valid ? values : null;
+  } catch {
+    return null;
+  }
+}
+function collectIntervalsBounded(input, patterns, budget) {
+  if (typeof input !== "string" || !Array.isArray(patterns) || patterns.length > MAX_PATTERN_COUNT) return null;
+  const found = [];
+  let matchCount = 0;
+  for (const item of patterns) {
+    const texts = typeof item === "string" ? [item] : patternRepresentations(item);
+    if (texts === null) return null;
+    for (const text of texts) {
+      if (text.length === 0) continue;
+      let at = input.indexOf(text);
+      while (at !== -1) {
+        matchCount++;
+        if (matchCount > budget.maxMatches) return null;
+        found.push({ start: at, end: at + text.length, pattern: text });
+        at = input.indexOf(text, at + 1);
+      }
+    }
+  }
+  found.sort((a, b) => a.start - b.start || a.end - b.end);
+  const result = [];
+  for (const match of found) {
+    const previous = result[result.length - 1];
+    if (previous !== void 0 && match.start <= previous.end) {
+      previous.end = Math.max(previous.end, match.end);
+      if (!previous.patterns.includes(match.pattern)) previous.patterns.push(match.pattern);
+    } else {
+      result.push({ start: match.start, end: match.end, patterns: [match.pattern] });
+    }
+  }
+  return result;
+}
+function withinBytes(value, budget) {
+  return encoder.encode(value).byteLength <= budget.maxOutputBytes;
+}
+function bytes(value) {
+  return encoder.encode(value).byteLength;
+}
+function sanitizeText(input, patterns, budget = {}) {
+  const reservation = typeof input === "string" ? reserveOperation(patterns, encoder.encode(input).byteLength) : null;
+  if (reservation === null) return null;
+  try {
+    if (typeof input !== "string") return null;
+    const normalized = normalizedBudget(budget);
+    if (normalized === null || !withinBytes(input, normalized)) return null;
+    const intervals = collectIntervalsBounded(input, patterns, normalized);
+    if (intervals === null) return null;
+    let output = "";
+    let cursor = 0;
+    for (const interval of intervals) {
+      const prefix = input.slice(cursor, interval.start);
+      const matches = patterns.filter((pattern) => {
+        const representations = patternRepresentations(pattern);
+        return representations !== null && representations.some((text) => interval.patterns.includes(text));
+      });
+      const entries = new Set(matches.map((pattern) => pattern.entry ?? pattern.text));
+      const replacement = entries.size === 1 && matches[0]?.replacement !== void 0 ? matches[0].replacement : REDACTION;
+      if (bytes(output) + bytes(prefix) + bytes(replacement) > normalized.maxOutputBytes) return null;
+      const next = output + prefix + replacement;
+      if (!withinBytes(next, normalized)) return null;
+      output = next;
+      cursor = interval.end;
+    }
+    const suffix = input.slice(cursor);
+    if (bytes(output) + bytes(suffix) > normalized.maxOutputBytes) return null;
+    const final = output + suffix;
+    if (!withinBytes(final, normalized) || collectIntervalsBounded(final, patterns, normalized)?.length !== 0) return null;
+    return final;
+  } catch {
+    return null;
+  } finally {
+    reservation.release();
+  }
+}
+function scanForSecrets(input, patterns, budget = {}) {
+  try {
+    if (typeof input !== "string" || input.length > MAX_TEMP_BYTES) return "unverifiable";
+    const reservation = reserveOperation(patterns, encoder.encode(input).byteLength);
+    if (reservation === null) return "unverifiable";
+    try {
+      const normalized = normalizedBudget(budget);
+      if (normalized === null || !Array.isArray(patterns) || patterns.length > MAX_PATTERN_COUNT) return "unverifiable";
+      for (const item of patterns) {
+        const texts = patternRepresentations(item);
+        if (texts === null) return "unverifiable";
+        for (const text of texts) {
+          if (text.length > 0 && input.indexOf(text) !== -1) return "match";
+        }
+      }
+      return "clean";
+    } finally {
+      reservation.release();
+    }
+  } catch {
+    return "unverifiable";
+  }
+}
+function verifyCeilingBytes(patterns) {
+  try {
+    if (!Array.isArray(patterns)) return 0;
+    let patternBytes = 0;
+    for (const item of patterns) {
+      if (item === null || typeof item !== "object" || typeof item.text !== "string") return 0;
+      patternBytes += encoder.encode(item.text).byteLength;
+      if (patternBytes > MAX_PATTERN_BYTES) return 0;
+    }
+    return MAX_TEMP_BYTES - patternBytes;
+  } catch {
+    return 0;
+  }
+}
+
+// src/opencode/v2/filter.ts
+var WITHHELD = "SANITIZATION_UNAVAILABLE";
+var encoder2 = new TextEncoder();
+var decoder = new TextDecoder();
+var AUTH_CHANNEL = /* @__PURE__ */ new Set(["authorization", "api-key", "x-api-key", "proxy-authorization"]);
+var NULL_BODY_STATUS = /* @__PURE__ */ new Set([101, 204, 205, 304]);
+var hasSecrets = (state) => state.patterns.length > 0;
+function redactNode(current, depth, state, counters) {
+  counters.nodes++;
+  if (counters.nodes > state.budget.maxNodes || depth > state.budget.maxDepth) return { value: WITHHELD, changed: true };
+  if (typeof current === "string") {
+    if (current.length === 0) return { value: current, changed: false };
+    const safe = sanitizeText(current, state.patterns, state.budget);
+    if (safe === null) return { value: WITHHELD, changed: true };
+    return { value: safe, changed: safe !== current };
+  }
+  if (current === null || typeof current !== "object") return { value: current, changed: false };
+  if (Array.isArray(current)) {
+    let changed2 = false;
+    for (let index = 0; index < current.length; index++) {
+      const result = redactNode(current[index], depth + 1, state, counters);
+      if (result.changed) {
+        current[index] = result.value;
+        changed2 = true;
+      }
+    }
+    return { value: current, changed: changed2 };
+  }
+  const prototype = Object.getPrototypeOf(current);
+  if (prototype !== Object.prototype && prototype !== null) return { value: current, changed: false };
+  const record = current;
+  let changed = false;
+  for (const key of Object.keys(record)) {
+    const descriptor = Object.getOwnPropertyDescriptor(record, key);
+    if (!descriptor || !("value" in descriptor)) continue;
+    const safeKey = redactString(key, state);
+    if (safeKey === null) return { value: WITHHELD, changed: true };
+    const result = redactNode(descriptor.value, depth + 1, state, counters);
+    if (result.changed || safeKey !== key) {
+      if (safeKey !== key) {
+        if (Object.prototype.hasOwnProperty.call(record, safeKey)) return { value: WITHHELD, changed: true };
+        delete record[key];
+        record[safeKey] = result.value;
+      } else {
+        record[key] = result.value;
+      }
+      changed = true;
+    }
+  }
+  return { value: current, changed };
+}
+function redactTree(root, state) {
+  if (!hasSecrets(state)) return false;
+  return redactNode(root, 0, state, { nodes: 0 }).changed;
+}
+function redactString(value, state) {
+  if (!hasSecrets(state)) return value;
+  if (encoder2.encode(value).byteLength > state.maxInputBytes) return null;
+  return sanitizeText(value, state.patterns, state.budget);
+}
+function containsSecret(value, state) {
+  if (!hasSecrets(state)) return false;
+  return scanForSecrets(value, state.patterns, state.budget) !== "clean";
+}
+function redactHeaders(headers, state, options2) {
+  if (!hasSecrets(state)) return;
+  for (const name of Object.keys(headers)) {
+    if (options2.skipAuth && AUTH_CHANNEL.has(name.toLowerCase())) continue;
+    const value = headers[name];
+    if (typeof value !== "string") {
+      if (options2.strict) return "withheld";
+      delete headers[name];
+      continue;
+    }
+    const safeValue = redactString(value, state);
+    const safeName = redactString(name, state);
+    if (safeValue === null || safeName === null) {
+      if (options2.strict) return "withheld";
+      delete headers[name];
+      continue;
+    }
+    if (safeValue !== value) headers[name] = safeValue;
+    if (safeName !== name) {
+      delete headers[name];
+      headers[safeName] = safeValue;
+    }
+  }
+}
+function redactBody(text, state) {
+  if (!hasSecrets(state)) return text;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(text);
+      const result = redactNode(parsed, 0, state, { nodes: 0 });
+      if (!result.changed) return text;
+      const serialized = JSON.stringify(result.value);
+      if (serialized === void 0) return null;
+      if (encoder2.encode(serialized).byteLength > state.maxInputBytes) return null;
+      if (containsSecret(serialized, state)) return null;
+      return serialized;
+    } catch {
+    }
+  }
+  return redactString(text, state);
+}
+function redactEventStream(text, state) {
+  const lines = text.split(/(\r?\n)/u);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (!line.startsWith("data:") || line.endsWith("\n") || line.endsWith("\r")) continue;
+    const payload = line.slice(5).trimStart();
+    if (payload === "[DONE]" || payload.length === 0) continue;
+    try {
+      const parsed = JSON.parse(payload);
+      if (!redactTree(parsed, state)) continue;
+      const serialized = JSON.stringify(parsed);
+      if (serialized === void 0 || containsSecret(serialized, state)) return null;
+      lines[index] = `data: ${serialized}`;
+    } catch {
+      return null;
+    }
+  }
+  return lines.join("");
+}
+async function readBoundedBody(body, limit) {
+  if (body === null) return { text: "", bytes: 0 };
+  try {
+    const reader = body.getReader();
+    const chunks = [];
+    let total2 = 0;
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (value === void 0 || value.byteLength === 0) continue;
+      total2 += value.byteLength;
+      if (total2 > limit) return null;
+      chunks.push(value);
+    }
+    const merged = new Uint8Array(total2);
+    let offset = 0;
+    for (const chunk of chunks) {
+      merged.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return { text: decoder.decode(merged), bytes: total2 };
+  } catch {
+    return null;
+  }
+}
+async function redactRequest(request, state) {
+  if (!hasSecrets(state)) return request;
+  const verifyCeiling = verifyCeilingBytes(state.patterns);
+  const declared = Number(request.headers.get("content-length") ?? Number.NaN);
+  if (Number.isFinite(declared) && declared > verifyCeiling) return "withheld";
+  const record = {};
+  request.headers.forEach((value, name) => {
+    record[name] = value;
+  });
+  if (redactHeaders(record, state, { skipAuth: true, strict: true }) === "withheld") return "withheld";
+  delete record["content-length"];
+  let body;
+  if (request.body !== null) {
+    const read = await readBoundedBody(request.clone().body, verifyCeiling);
+    if (read === null) return "withheld";
+    if (read.bytes > state.maxInputBytes) {
+      if (scanForSecrets(read.text, state.patterns, state.budget) !== "clean") return "withheld";
+    } else {
+      const safe = redactBody(read.text, state);
+      if (safe === null) return "withheld";
+      if (safe !== read.text) body = safe;
+    }
+  }
+  try {
+    return new Request(request, {
+      headers: record,
+      ...body === void 0 ? {} : { body },
+      signal: request.signal
+    });
+  } catch {
+    return "withheld";
+  }
+}
+async function redactResponse(response2, state) {
+  if (!hasSecrets(state)) return response2;
+  const headers = {};
+  response2.headers.forEach((value, name) => {
+    headers[name] = value;
+  });
+  redactHeaders(headers, state, { skipAuth: false, strict: false });
+  const status = response2.status;
+  const nullBody = NULL_BODY_STATUS.has(status);
+  if (nullBody) {
+    try {
+      return new Response(null, { status, headers });
+    } catch {
+      return new Response(null, { status: 502 });
+    }
+  }
+  const verifyCeiling = verifyCeilingBytes(state.patterns);
+  const declared = Number(response2.headers.get("content-length") ?? Number.NaN);
+  if (Number.isFinite(declared) && declared > verifyCeiling) {
+    try {
+      return new Response(null, { status, headers });
+    } catch {
+      return new Response(null, { status: 502 });
+    }
+  }
+  const read = await readBoundedBody(response2.clone().body, verifyCeiling);
+  if (read === null) {
+    try {
+      return new Response(null, { status, headers });
+    } catch {
+      return new Response(null, { status: 502 });
+    }
+  }
+  let body;
+  if (read.bytes > state.maxInputBytes) {
+    body = scanForSecrets(read.text, state.patterns, state.budget) === "clean" ? read.text : "";
+  } else if ((headers["content-type"] ?? "").toLowerCase().includes("text/event-stream")) {
+    body = redactEventStream(read.text, state) ?? "";
+  } else {
+    const safe = redactBody(read.text, state);
+    body = safe === null ? "" : safe;
+  }
+  try {
+    return new Response(body, { status, headers });
+  } catch {
+    return new Response(null, { status: 502 });
+  }
+}
+function dropMentions(root) {
+  const walk = (node, depth, counters) => {
+    counters.nodes++;
+    if (counters.nodes > 1e4 || depth > 32) return;
+    if (Array.isArray(node)) {
+      for (const item of node) walk(item, depth + 1, counters);
+      return;
+    }
+    if (!node || typeof node !== "object") return;
+    const prototype = Object.getPrototypeOf(node);
+    if (prototype !== Object.prototype && prototype !== null) return;
+    const record = node;
+    for (const key of Object.keys(record)) {
+      if (key === "mention" && record[key] && typeof record[key] === "object") {
+        delete record[key];
+        continue;
+      }
+      walk(record[key], depth + 1, counters);
+    }
+  };
+  walk(root, 0, { nodes: 0 });
+}
+
+// src/opencode/v2/runtime.ts
+var GENERATION = 1;
+var SOURCE_TOOLS = /* @__PURE__ */ new Set(["read", "write", "edit", "patch"]);
+var PATH_KEYS = ["filePath", "file_path", "path"];
+var realRuntimeFactory = (options2, location) => {
+  const locationDir = location.directory;
+  let locationReal;
+  try {
+    locationReal = fs2.realpathSync(locationDir);
+  } catch {
+    throw new Error("SOURCE_INVALID");
+  }
+  const entries = [];
+  let totalBytes = 0;
+  for (const descriptor of options2.sources) {
+    const resolved = path2.resolve(locationDir, descriptor.path);
+    let sourceReal;
+    try {
+      sourceReal = fs2.realpathSync(resolved);
+    } catch {
+      if (descriptor.required) throw new Error("SOURCE_INVALID");
+      continue;
+    }
+    const relativeSource = path2.relative(locationReal, sourceReal);
+    if (relativeSource === ".." || relativeSource.startsWith(`..${path2.sep}`) || path2.isAbsolute(relativeSource)) {
+      if (descriptor.required) throw new Error("SOURCE_INVALID");
+      continue;
+    }
+    let snapshot;
+    try {
+      snapshot = loadDotenvFile(resolved, {
+        maxBytes: options2.limits.sourceBytes,
+        maxEntries: options2.limits.secretCount,
+        maxValueBytes: options2.limits.secretBytes
+      });
+    } catch {
+      if (descriptor.required) throw new Error("SOURCE_INVALID");
+      continue;
+    }
+    for (const entry of snapshot.entries) {
+      if (!descriptor.keys.includes(entry.key) || entry.value.length === 0) continue;
+      totalBytes += Buffer.byteLength(entry.value, "utf8");
+      if (totalBytes > options2.limits.totalSourceBytes || entries.length >= options2.limits.secretCount) throw new Error("SOURCE_INVALID");
+      entries.push({ sourceId: descriptor.id, key: entry.key, value: entry.value });
+    }
+  }
+  const budget = new BudgetLedger({
+    handles: options2.limits.secretCount,
+    secretCount: options2.limits.secretCount,
+    secretBytes: options2.limits.secretBytes,
+    indexBytes: options2.limits.indexBytes,
+    workingBytes: options2.limits.workingBytes
+  });
+  const store = new ActivationStore({
+    location: { directory: locationDir },
+    generation: GENERATION,
+    budget,
+    randomBytes: () => new Uint8Array(randomBytes(16))
+  });
+  const handles = /* @__PURE__ */ new Map();
+  for (const entry of entries) if (!handles.has(entry.value)) handles.set(entry.value, store.register(entry.value));
+  const patterns = [];
+  for (const entry of entries) {
+    if (patterns.some((pattern) => pattern.text === entry.value)) continue;
+    const replacement = handles.get(entry.value);
+    if (replacement === void 0) throw new Error("SANITIZATION_UNAVAILABLE");
+    patterns.push({ text: entry.value, replacement, entry: entry.value });
+  }
+  if (!admitPatterns(patterns).ok) throw new Error("SANITIZATION_UNAVAILABLE");
+  const filter = {
+    patterns,
+    budget: {
+      maxOutputBytes: Math.min(options2.limits.outputBytes, 2 * 1024 * 1024),
+      maxDepth: Math.min(options2.limits.traversalDepth, 32),
+      maxNodes: Math.min(options2.limits.traversalNodes, 5e4),
+      maxMatches: Math.min(options2.limits.traversalNodes, 5e4)
+    },
+    maxInputBytes: options2.limits.inputBytes
+  };
+  const scanCeiling = Math.min(filter.maxInputBytes, filter.budget.maxOutputBytes);
+  const sourcePaths = new Set(options2.sources.map((descriptor) => {
+    const resolved = path2.resolve(locationDir, descriptor.path);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+  }));
+  const pathInput = (input) => {
+    if (!input || typeof input !== "object") return void 0;
+    const record = input;
+    for (const key of PATH_KEYS) {
+      const value = record[key];
+      if (typeof value === "string" && value.length > 0 && value.length <= 4096) return value;
+    }
+    return void 0;
+  };
+  const isSourcePath = (candidate) => {
+    const resolved = path2.resolve(locationDir, candidate);
+    return sourcePaths.has(process.platform === "win32" ? resolved.toLowerCase() : resolved);
+  };
+  const inputHasSecret = (input) => {
+    if (!hasSecrets(filter) || input === void 0 || input === null) return false;
+    let serialized;
+    try {
+      serialized = JSON.stringify(input);
+    } catch {
+      return false;
+    }
+    return serialized !== void 0 && Buffer.byteLength(serialized, "utf8") <= scanCeiling && containsSecret(serialized, filter);
+  };
+  const redactToolError = (event) => {
+    const original = event.error;
+    const message = typeof original.message === "string" ? redactString(original.message, filter) : null;
+    event.error = new tool_exports.Error({ message: message ?? WITHHELD });
+  };
+  const sanitizeValue = (value) => {
+    if (typeof value === "string") return redactString(value, filter) ?? WITHHELD;
+    redactTree(value, filter);
+    return value;
+  };
+  const sanitizeRequestContext = (event) => {
+    event.system = sanitizeValue(event.system);
+    redactTree(event.messages, filter);
+    event.options = sanitizeValue(event.options);
+    if (event.tools !== void 0) event.tools = sanitizeValue(event.tools);
+  };
+  const runtime = {
+    close: () => Effect4.sync(() => store.teardown()),
+    session: {
+      prompt: (event) => Effect4.sync(() => {
+        if (!hasSecrets(filter)) return;
+        let changed = redactTree(event.prompt, filter);
+        if (event.metadata !== void 0) changed = redactTree(event.metadata, filter) || changed;
+        if (changed) dropMentions(event.prompt);
+      }),
+      context: (event) => Effect4.sync(() => {
+        if (hasSecrets(filter)) sanitizeRequestContext(event);
+      }),
+      compaction: (event) => Effect4.sync(() => {
+        if (!hasSecrets(filter)) return;
+        sanitizeRequestContext(event);
+        if (event.result !== void 0) event.result = sanitizeValue(event.result);
+      }),
+      generate: (event) => Effect4.sync(() => {
+        if (hasSecrets(filter)) sanitizeRequestContext(event);
+      }),
+      title: (event) => Effect4.sync(() => {
+        if (!hasSecrets(filter)) return;
+        sanitizeRequestContext(event);
+        if (event.result !== void 0) event.result = redactString(event.result, filter) ?? WITHHELD;
+      }),
+      modelRequest: (event) => Effect4.gen(function* () {
+        if (!hasSecrets(filter)) return;
+        if (redactHeaders(event.headers, filter, { skipAuth: true, strict: true }) === "withheld") yield* Effect4.die(new Error(WITHHELD));
+        if (event.baseURL !== void 0) event.baseURL = redactString(event.baseURL, filter) ?? WITHHELD;
+      }),
+      httpRequest: (event) => Effect4.promise(async () => {
+        if (!hasSecrets(filter)) return;
+        const replacement = await redactRequest(event.request, filter).catch(() => "withheld");
+        if (replacement === "withheld") throw new Error(WITHHELD);
+        event.request = replacement;
+      }),
+      httpResponse: (event) => Effect4.promise(async () => {
+        if (!hasSecrets(filter)) return;
+        try {
+          event.response = await redactResponse(event.response, filter);
+        } catch {
+          event.response = new Response(null, { status: 502 });
+        }
+      })
+    },
+    tool: {
+      before: (event) => Effect4.gen(function* () {
+        if (SOURCE_TOOLS.has(event.tool)) {
+          const candidate = pathInput(event.input);
+          if (candidate !== void 0 && isSourcePath(candidate)) yield* Effect4.fail(new tool_exports.Error({ message: "ACCESS_DENIED" }));
+        }
+        if (inputHasSecret(event.input)) yield* Effect4.fail(new tool_exports.Error({ message: "ACCESS_DENIED" }));
+      }),
+      after: (event) => Effect4.sync(() => {
+        if (!hasSecrets(filter)) return;
+        if (event.status === "completed") event.result = sanitizeValue(event.result);
+        else redactToolError(event);
+      })
+    }
+  };
+  return Effect4.succeed(runtime);
+};
+
+// src/opencode/v2/index.ts
+var unavailableRuntime = {
+  close: () => Effect5.void,
+  session: {
+    prompt: () => Effect5.void,
+    context: () => Effect5.void,
+    compaction: () => Effect5.void,
+    generate: () => Effect5.void,
+    title: () => Effect5.void,
+    modelRequest: () => Effect5.void,
+    httpRequest: () => Effect5.void,
+    httpResponse: () => Effect5.void
+  },
+  tool: {
+    before: () => Effect5.void,
+    after: () => Effect5.void
+  }
+};
+var unavailableRuntimeFactory = () => Effect5.succeed(unavailableRuntime);
+var makeEffect = (factory = unavailableRuntimeFactory) => (ctx) => Effect5.gen(function* () {
+  const runtime = yield* Effect5.suspend(() => {
+    try {
+      return factory(parseOptions(ctx.options), ctx.location);
+    } catch {
+      return Effect5.succeed(unavailableRuntime);
+    }
+  });
+  yield* Effect5.addFinalizer(() => runtime.close());
+  yield* ctx.session.hook("prompt", (event) => runtime.session.prompt(event));
+  yield* ctx.session.hook("context", (event) => runtime.session.context(event));
+  yield* ctx.session.hook("compaction", (event) => runtime.session.compaction(event));
+  yield* ctx.session.hook("generate", (event) => runtime.session.generate(event));
+  yield* ctx.session.hook("title", (event) => runtime.session.title(event));
+  yield* ctx.session.hook("model.request", (event) => runtime.session.modelRequest(event));
+  yield* ctx.session.hook("http.request", (event) => runtime.session.httpRequest(event));
+  yield* ctx.session.hook("http.response", (event) => runtime.session.httpResponse(event));
+  yield* ctx.tool.hook("execute.before", (event) => runtime.tool.before(event));
+  yield* ctx.tool.hook("execute.after", (event) => runtime.tool.after(event));
+});
+var plugin = plugin_exports.define({
+  id: "opencode-secrets-obfuscation",
+  effect: makeEffect(realRuntimeFactory)
+});
+var index_default = plugin;
+export {
+  index_default as default,
+  makeEffect,
+  unavailableRuntime,
+  unavailableRuntimeFactory
+};