@opencode/core 0.0.0-reserved → 2.0.0

package/dist/chunks/aisdk-native-gd0e60kd.js

@@ -0,0 +1,323 @@
+import {
+  ID18,
+  isAISDK2,
+  packageName2,
+  loadPackage2,
+  nativeSettings2,
+  mergeOverlay2,
+  mergeHeaders2
+} from "./aisdk-native-33n3bzdy.js";
+import {
+  Service76,
+  node81
+} from "./aisdk-native-qjwa214h.js";
+import {
+  map2
+} from "./aisdk-native-35wynegs.js";
+import {
+  ID13,
+  VariantID2,
+  Ref3
+} from "./aisdk-native-jghsd1wz.js";
+import {
+  ID11,
+  Service66,
+  node70
+} from "./aisdk-native-tpbhnsa4.js";
+import {
+  Service65,
+  node69
+} from "./aisdk-native-r4kwqy5f.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/model-resolver.ts
+var exports_model_resolver = {};
+__export(exports_model_resolver, {
+  InitializationPhase: () => InitializationPhase2,
+  ModelConfigurationError: () => ModelConfigurationError3,
+  ModelInitializationError: () => ModelInitializationError3,
+  ModelResolver: () => exports_model_resolver,
+  Service: () => Service64,
+  UnresolvedProviderVariablesError: () => UnresolvedProviderVariablesError3,
+  UnsupportedCompactionError: () => UnsupportedCompactionError3,
+  UnsupportedPackageError: () => UnsupportedPackageError3,
+  VariantUnavailableError: () => VariantUnavailableError3,
+  fromCatalogModel: () => fromCatalogModel2,
+  hasPackage: () => hasPackage2,
+  layer: () => layer23,
+  node: () => node68,
+  resolveModel: () => resolveModel2,
+  withVariant: () => withVariant2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { LanguageModel, ProviderConfigurationError } from "@opencode/ai";
+import { Auth } from "@opencode/ai/route";
+import { Context, Effect, Layer, Schema, Struct } from "effect";
+import { Npm } from "@opencode/util/npm";
+class VariantUnavailableError3 extends Schema.TaggedError()("SessionRunnerModel.VariantUnavailableError", {
+  providerID: ID18,
+  modelID: ID13,
+  variant: VariantID2
+}) {
+  get message() {
+    return `Variant unavailable for ${this.providerID}/${this.modelID}: ${this.variant}`;
+  }
+}
+
+class UnsupportedPackageError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedPackageError", {
+  providerID: ID18,
+  modelID: ID13,
+  package: Schema.String
+}) {
+  get message() {
+    return `Unsupported package for ${this.providerID}/${this.modelID}: ${this.package}`;
+  }
+}
+var InitializationPhase2 = Schema.Literals(["load", "init", "construct"]);
+
+class ModelConfigurationError3 extends Schema.TaggedError()("SessionRunnerModel.ModelConfigurationError", {
+  providerID: ID18,
+  modelID: ID13,
+  package: Schema.String,
+  detail: Schema.String
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}`;
+  }
+}
+
+class ModelInitializationError3 extends Schema.TaggedError()("SessionRunnerModel.ModelInitializationError", {
+  providerID: ID18,
+  modelID: ID13,
+  package: Schema.String,
+  phase: InitializationPhase2,
+  detail: Schema.String
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.detail}`;
+  }
+}
+
+class UnresolvedProviderVariablesError3 extends Schema.TaggedError()("SessionRunnerModel.UnresolvedProviderVariablesError", {
+  providerID: ID18,
+  modelID: ID13,
+  variables: Schema.Array(Schema.String)
+}) {
+  get message() {
+    return `Cannot initialize ${this.providerID}/${this.modelID}: ${this.variables.join(", ")} ${this.variables.length === 1 ? "is" : "are"} required to resolve the provider endpoint`;
+  }
+}
+
+class UnsupportedCompactionError3 extends Schema.TaggedError()("SessionRunnerModel.UnsupportedCompactionError", {
+  providerID: ID18,
+  modelID: ID13,
+  route: Schema.String
+}) {
+  get message() {
+    return `Provider compaction is not supported by ${this.providerID}/${this.modelID} (${this.route})`;
+  }
+}
+
+class Service64 extends Context.Service()("@opencode/ModelResolver") {
+}
+var withVariant2 = (model, variantID) => {
+  const id = variantID === "default" ? undefined : variantID;
+  const variant = model.variants?.find((item) => item.id === id);
+  if (!variant && id !== undefined)
+    return Effect.fail(new VariantUnavailableError3({
+      providerID: model.providerID,
+      modelID: model.id,
+      variant: id
+    }));
+  return Effect.succeed(variant ? {
+    ...model,
+    settings: mergeOverlay2(model.settings, variant.settings),
+    headers: mergeHeaders2(model.headers, variant.headers),
+    body: mergeOverlay2(model.body, variant.body)
+  } : model);
+};
+var fromCatalogModel2 = (model, credential, dependencies) => resolveCatalogModel(model, credential, dependencies).pipe(Effect.flatMap((resolved) => validateProviderVariables(model, resolved)), Effect.flatMap((resolved) => {
+  if (model.compaction?.mode !== "provider" || resolved.route.compact?.trigger || resolved.route.compact?.endpoint)
+    return Effect.succeed(resolved);
+  return Effect.fail(new UnsupportedCompactionError3({ providerID: model.providerID, modelID: model.id, route: resolved.route.id }));
+}));
+var resolveCatalogModel = Effect.fn("ModelResolver.resolveCatalogModel")(function* (model, credential, dependencies) {
+  const resolved = prepareRuntimeModel(model, credential);
+  const packageName = packageName2(resolved.package);
+  const configuration = credential?.type === "key" ? credential.configuration : undefined;
+  const configured = { ...resolved.settings, ...credential?.metadata, ...configuration };
+  const mapping = isAISDK2(resolved.package) ? map2({
+    packageName,
+    settings: configured,
+    modelID: resolved.modelID ?? resolved.id,
+    providerID: resolved.canonical ?? resolved.providerID
+  }) : undefined;
+  const native = mapping?.package ?? packageName;
+  if (isAISDK2(resolved.package) && !mapping) {
+    const loadAISDK = dependencies?.loadAISDK;
+    if (!loadAISDK)
+      return yield* unsupported(resolved);
+    const settings = yield* prepareProviderSettings(resolved, mergeOverlay2(resolved.settings, {
+      ...nativeCredentialSettings(resolved.package ?? "", credential),
+      ...credential?.metadata,
+      ...configuration
+    }) ?? {});
+    return yield* loadAISDK({ ...resolved, settings }).pipe(Effect.mapError((error) => initialization(resolved, "init", error.cause)));
+  }
+  if (!native)
+    return yield* unsupported(resolved);
+  const specifier = native;
+  const mapped = yield* prepareProviderSettings(resolved, nativeSettings2(mapping?.settings ?? configured));
+  const module = yield* (dependencies?.loadPackage ?? loadPackage2)(specifier).pipe(Effect.mapError((error) => initialization(resolved, "load", error.cause)));
+  const settings = {
+    ...credential ? Struct.omit(mapped, ["accessToken", "apiKey", "authToken"]) : mapped,
+    ...resolved.canonical === undefined ? {} : { provider: resolved.canonical },
+    ...nativeCredentialSettings(specifier, credential),
+    headers: mergeHeaders2(mapping?.headers, resolved.headers),
+    body: mergeOverlay2(mapping?.body, resolved.body)
+  };
+  return yield* Effect.try({
+    try: () => {
+      const runtime = module.model(resolved.modelID ?? resolved.id, settings);
+      return LanguageModel.update(runtime, {
+        provider: resolved.canonical ?? resolved.providerID,
+        compatibility: resolved.compatibility ? Object.assign({}, runtime.compatibility, resolved.compatibility) : runtime.compatibility
+      });
+    },
+    catch: (cause) => cause instanceof ProviderConfigurationError ? new ModelConfigurationError3({
+      providerID: resolved.providerID,
+      modelID: resolved.id,
+      package: resolved.package ?? "unknown",
+      detail: cause.message
+    }) : initialization(resolved, "construct", cause)
+  });
+});
+function prepareRuntimeModel(model, credential) {
+  if (model.settings?.apiKey !== "" && (credential?.type !== "key" || credential.metadata === undefined))
+    return model;
+  return {
+    ...model,
+    ...model.settings?.apiKey === "" ? { settings: Struct.omit(model.settings, ["apiKey"]) } : {},
+    ...credential?.type === "key" && credential.metadata !== undefined ? { body: mergeOverlay2(model.body, credential.metadata) } : {}
+  };
+}
+function validateProviderVariables(model, resolved) {
+  const baseURL = resolved.route.endpoint.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(resolved);
+  const failure = unresolvedProviderVariables(model, baseURL);
+  return failure ? Effect.fail(failure) : Effect.succeed(resolved);
+}
+function prepareProviderSettings(model, settings) {
+  const baseURL = settings.baseURL;
+  if (typeof baseURL !== "string")
+    return Effect.succeed(settings);
+  return prepareProviderURL(model, baseURL).pipe(Effect.map((prepared) => prepared === baseURL ? settings : { ...settings, baseURL: prepared }));
+}
+function prepareProviderURL(model, baseURL) {
+  if (!baseURL.includes("${"))
+    return Effect.succeed(baseURL);
+  const prepared = baseURL.replace(/\$\{([^}]+)\}/g, (placeholder, name) => process.env[name] ?? placeholder);
+  const failure = unresolvedProviderVariables(model, prepared);
+  return failure ? Effect.fail(failure) : Effect.succeed(prepared);
+}
+function unresolvedProviderVariables(model, baseURL) {
+  const variables = new Set(Array.from(baseURL.matchAll(/\$\{([^}]+)\}/g), (match) => match[1]));
+  if (variables.size === 0)
+    return;
+  return new UnresolvedProviderVariablesError3({
+    providerID: model.providerID,
+    modelID: model.id,
+    variables: Array.from(variables)
+  });
+}
+var nativeCredentialSettings = (specifier, credential) => {
+  if (!credential)
+    return {};
+  if (credential.type === "key")
+    return { apiKey: credential.key };
+  if (specifier === "@opencode/ai/providers/anthropic" || specifier === "@opencode/ai/providers/anthropic-compatible")
+    return { authToken: credential.access };
+  if (specifier === "@opencode/ai/providers/google-vertex" || specifier.startsWith("@opencode/ai/providers/google-vertex/"))
+    return { accessToken: credential.access };
+  return { apiKey: credential.access };
+};
+var unsupported = (model) => new UnsupportedPackageError3({
+  providerID: model.providerID,
+  modelID: model.id,
+  package: model.package ?? "unknown"
+});
+var initialization = (model, phase, cause) => new ModelInitializationError3({
+  providerID: model.providerID,
+  modelID: model.id,
+  package: model.package ?? "unknown",
+  phase,
+  detail: causeMessage(cause) ?? `${phase} failed for ${model.package ?? "unknown"}`
+});
+var causeMessage = (cause) => {
+  if (typeof cause === "string")
+    return cause.trim() || undefined;
+  if (!(cause instanceof globalThis.Error))
+    return;
+  const message = cause.message.trim();
+  if (message)
+    return message;
+  return causeMessage(cause.cause);
+};
+var resolveModel2 = (model, variant, credential, dependencies) => withVariant2(model, variant).pipe(Effect.flatMap((model) => fromCatalogModel2(model, credential, dependencies)));
+var hasPackage2 = (model) => Boolean(model.package);
+var layer23 = Layer.effect(Service64, Effect.gen(function* () {
+  const catalog = yield* Service65;
+  const integrations = yield* Service66;
+  const npm = yield* Npm.Service;
+  const aisdk = yield* Service76;
+  const load = Effect.fn("ModelResolver.resolveModel")(function* (selected, variant) {
+    const provider = yield* catalog.provider.get(selected.providerID);
+    const connection = yield* integrations.connection.active(provider?.integrationID ?? ID11.make(selected.providerID));
+    const credential = connection ? yield* integrations.connection.resolve(connection) : undefined;
+    const runtimeInfo = yield* withVariant2(selected, variant);
+    const model = yield* fromCatalogModel2(runtimeInfo, credential, {
+      loadPackage: (specifier) => loadPackage2(specifier, npm),
+      loadAISDK: (model) => aisdk.model(model)
+    });
+    const runtime = provider?.activation === "enabled" && credential === undefined && !hasConfiguredAuth(runtimeInfo) && usesAPIKeyAuth(runtimeInfo.package) ? LanguageModel.update(model, { route: model.route.with({ auth: Auth.none }) }) : model;
+    return {
+      model: runtime,
+      ref: Ref3.make({
+        id: selected.id,
+        providerID: selected.providerID,
+        ...variant === undefined ? {} : { variant }
+      }),
+      capabilities: selected.capabilities,
+      cost: selected.cost,
+      limit: selected.limit,
+      compaction: selected.compaction,
+      websocket: selected.websocket ?? false
+    };
+  });
+  return Service64.of({
+    resolve: Effect.fn("ModelResolver.resolve")(function* (requested) {
+      const selected = requested ? yield* catalog.model.get(requested.providerID, requested.id) : yield* catalog.model.default().pipe(Effect.flatMap((model) => model && hasPackage2(model) ? Effect.succeed(model) : Effect.map(catalog.model.available(), (models) => models.find(hasPackage2))));
+      if (!selected)
+        return;
+      return yield* load(selected, requested?.variant);
+    }),
+    resolveModel: load
+  });
+}));
+function hasConfiguredAuth(model) {
+  return [model.settings?.apiKey, model.settings?.authToken, model.settings?.accessToken].some((value) => typeof value === "string" && value !== "");
+}
+function usesAPIKeyAuth(packageName) {
+  const name = packageName2(packageName);
+  return name === "@ai-sdk/openai" || name === "@ai-sdk/anthropic" || name === "@ai-sdk/cerebras" || name === "@ai-sdk/deepinfra" || name === "@ai-sdk/openai-compatible" || name === "@ai-sdk/google" || name === "@ai-sdk/groq" || name === "@ai-sdk/mistral" || name === "@ai-sdk/togetherai" || name === "@ai-sdk/xai" || name === "@openrouter/ai-sdk-provider" || name === "@ai-sdk/azure" || name === "@opencode/ai/providers/openai" || name?.startsWith("@opencode/ai/providers/openai/") === true || name === "@opencode/ai/providers/anthropic" || name === "@opencode/ai/providers/anthropic-compatible" || name === "@opencode/ai/providers/baseten" || name === "@opencode/ai/providers/cerebras" || name === "@opencode/ai/providers/cloudflare-ai-gateway" || name === "@opencode/ai/providers/cloudflare-workers-ai" || name === "@opencode/ai/providers/deepinfra" || name === "@opencode/ai/providers/deepseek" || name === "@opencode/ai/providers/fireworks" || name === "@opencode/ai/providers/openai-compatible" || name === "@opencode/ai/providers/google" || name === "@opencode/ai/providers/groq" || name === "@opencode/ai/providers/mistral" || name === "@opencode/ai/providers/togetherai" || name === "@opencode/ai/providers/xai" || name === "@opencode/ai/providers/openrouter" || name === "@opencode/ai/providers/azure" || name?.startsWith("@opencode/ai/providers/azure/") === true;
+}
+var node68 = makeLocationNode({
+  service: Service64,
+  layer: layer23,
+  deps: [node69, node70, Npm.node, node81]
+});
+
+export { VariantUnavailableError3, UnsupportedPackageError3, InitializationPhase2, ModelConfigurationError3, ModelInitializationError3, UnresolvedProviderVariablesError3, UnsupportedCompactionError3, Service64, withVariant2, fromCatalogModel2, resolveModel2, hasPackage2, layer23, node68, exports_model_resolver };

package/dist/chunks/aisdk-native-gd4qta3r.js

@@ -0,0 +1,25 @@
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/file-retention.ts
+var exports_file_retention = {};
+__export(exports_file_retention, {
+  FileRetention: () => exports_file_retention,
+  cleanup: () => cleanup3
+});
+import { Duration, Effect, Option } from "effect";
+var cleanup3 = Effect.fn("FileRetention.cleanup")(function* (fs, files, retention) {
+  const cutoff = Date.now() - Duration.toMillis(retention);
+  yield* Effect.forEach(files, (file) => Effect.gen(function* () {
+    const info = yield* fs.stat(file).pipe(Effect.orElseSucceed(() => {
+      return;
+    }));
+    const mtime = info && Option.getOrUndefined(info.mtime);
+    if (!mtime || mtime.getTime() >= cutoff)
+      return;
+    yield* fs.remove(file).pipe(Effect.ignore);
+  }), { concurrency: 8, discard: true });
+});
+
+export { cleanup3, exports_file_retention };

package/dist/chunks/aisdk-native-ge3a0kr9.js

@@ -0,0 +1,88 @@
+import {
+  Key3,
+  removed2,
+  empty3,
+  make20,
+  diffByKey2
+} from "./aisdk-native-rhjbct0v.js";
+import {
+  ID4,
+  Name2,
+  available2,
+  Service50,
+  node53
+} from "./aisdk-native-rd6pz67j.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/skill/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  Service: () => Service23,
+  SkillInstructions: () => exports_instructions2,
+  node: () => node28
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  id: ID4,
+  name: Name2,
+  description: Schema.String
+});
+var entries = (skills) => skills.flatMap((skill) => [
+  "  <skill>",
+  `    <id>${skill.id}</id>`,
+  `    <name>${skill.name}</name>`,
+  `    <description>${skill.description}</description>`,
+  "  </skill>"
+]);
+var render = (skills) => [
+  "Skills provide specialized instructions and workflows for specific tasks.",
+  "Use the skill tool to load a skill when a task matches its description.",
+  ...skills.length === 0 ? ["No skills are currently available."] : ["<available_skills>", ...entries(skills), "</available_skills>"]
+].join(`
+`);
+var update = (previous, current) => {
+  const diff = diffByKey2(previous, current, (skill) => skill.id, (before, after) => before.name !== after.name || before.description !== after.description);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available skills have changed. This list supersedes the previous available skills list.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New skills are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `The following skill IDs are no longer available and must not be used: ${diff.removed.map((skill) => skill.id).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service23 extends Context.Service()("@opencode/SkillInstructions") {
+}
+var layer = Layer.effect(Service23, Effect.gen(function* () {
+  const skills = yield* Service50;
+  return Service23.of({
+    load: Effect.fn("SkillInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return empty3;
+      const available = available2(yield* skills.list(), agent).flatMap((skill) => skill.description === undefined || skill.autoinvoke === false ? [] : [{ id: skill.id, name: skill.name, description: skill.description }]).toSorted((a, b) => a.id.localeCompare(b.id));
+      return make20({
+        key: Key3.make("core/skill-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(available.length === 0 ? removed2 : available),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "Skill guidance is no longer available. Do not use any previously listed skill."
+        }
+      });
+    })
+  });
+}));
+var node28 = makeLocationNode({ service: Service23, layer, deps: [node53] });
+
+export { Service23, node28, exports_instructions2 };

package/dist/chunks/aisdk-native-gebd4c9n.js

@@ -0,0 +1,77 @@
+// src/util/slug.ts
+var Slug2;
+((Slug) => {
+  const ADJECTIVES = [
+    "brave",
+    "calm",
+    "clever",
+    "cosmic",
+    "crisp",
+    "curious",
+    "eager",
+    "gentle",
+    "glowing",
+    "happy",
+    "hidden",
+    "jolly",
+    "kind",
+    "lucky",
+    "mighty",
+    "misty",
+    "neon",
+    "nimble",
+    "playful",
+    "proud",
+    "quick",
+    "quiet",
+    "shiny",
+    "silent",
+    "stellar",
+    "sunny",
+    "swift",
+    "tidy",
+    "witty"
+  ];
+  const NOUNS = [
+    "cabin",
+    "cactus",
+    "canyon",
+    "circuit",
+    "comet",
+    "eagle",
+    "engine",
+    "falcon",
+    "forest",
+    "garden",
+    "harbor",
+    "island",
+    "knight",
+    "lagoon",
+    "meadow",
+    "moon",
+    "mountain",
+    "nebula",
+    "orchid",
+    "otter",
+    "panda",
+    "pixel",
+    "planet",
+    "river",
+    "rocket",
+    "sailor",
+    "squid",
+    "star",
+    "tiger",
+    "wizard",
+    "wolf"
+  ];
+  function create() {
+    return [
+      ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)],
+      NOUNS[Math.floor(Math.random() * NOUNS.length)]
+    ].join("-");
+  }
+  Slug.create = create;
+})(Slug2 ||= {});
+
+export { Slug2 };

package/dist/chunks/aisdk-native-gfewnhh8.js

@@ -0,0 +1,111 @@
+import {
+  Service79,
+  node84
+} from "./aisdk-native-11nvngjf.js";
+import {
+  Service75,
+  node80
+} from "./aisdk-native-7zdm33ac.js";
+import {
+  Service73,
+  node78
+} from "./aisdk-native-6fyvx278.js";
+import {
+  awaitActivation2
+} from "./aisdk-native-1x11rq2a.js";
+import {
+  Service36,
+  node40
+} from "./aisdk-native-39dcxt5x.js";
+import {
+  node22
+} from "./aisdk-native-33f8ypwy.js";
+import {
+  Service12,
+  node15
+} from "./aisdk-native-t0x5rdq8.js";
+import {
+  __export
+} from "./aisdk-native-9rqn6x4v.js";
+
+// src/filesystem/location-watcher.ts
+var exports_location_watcher2 = {};
+__export(exports_location_watcher2, {
+  LocationWatcher: () => exports_location_watcher2,
+  Service: () => Service11,
+  node: () => node14
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { Cause, Context, Effect, Exit, Layer, Scope, Semaphore, Stream } from "effect";
+import { FileSystem } from "@opencode/schema/filesystem";
+import path from "path";
+import { FSUtil } from "@opencode/util/fs-util";
+class Service11 extends Context.Service()("@opencode/LocationWatcher") {
+}
+var layer = Layer.effect(Service11, Effect.gen(function* () {
+  const location = yield* Service73;
+  const watcher = yield* Service36;
+  const bus = yield* Service79;
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service75;
+  const policy = yield* Service12;
+  const publish = (update) => bus.publish(FileSystem.Event.Changed, {
+    file: update.path,
+    event: update.type === "create" ? "add" : update.type === "update" ? "change" : "unlink"
+  });
+  const target = yield* Effect.cached(Effect.gen(function* () {
+    if (location.vcs?.type === "git") {
+      const resolved = (yield* git.repo.discover(location.directory))?.gitDirectory;
+      const vcs = resolved ? yield* fs.realPath(resolved).pipe(Effect.orElseSucceed(() => resolved)) : undefined;
+      if (vcs)
+        return { path: path.join(vcs, "HEAD"), aliases: [".git", vcs, ...resolved ? [resolved] : []] };
+    }
+    if (location.vcs?.type === "hg") {
+      const store = location.vcs.store;
+      const vcs = yield* fs.realPath(store).pipe(Effect.orElseSucceed(() => store));
+      return { path: path.join(vcs, "branch"), aliases: [".hg", vcs] };
+    }
+  }).pipe(Effect.withSpan("LocationWatcher.target", { attributes: { directory: location.directory } }), Effect.catchCause((cause) => Effect.logError("failed to resolve location watcher target", { cause }).pipe(Effect.as(undefined)))));
+  const lock = Semaphore.makeUnsafe(1);
+  let stopped = false;
+  let active;
+  const reconcile = () => lock.withPermit(Effect.gen(function* () {
+    if (stopped)
+      return;
+    const resolved = yield* target;
+    const ignore = policy.current();
+    const next = resolved && !resolved.aliases.some((alias) => ignore.includes(alias)) ? resolved.path : undefined;
+    if (active?.path === next)
+      return;
+    if (active)
+      yield* Scope.close(active.scope, Exit.void);
+    active = undefined;
+    if (!next)
+      return;
+    const scope = yield* Scope.make();
+    active = { path: next, scope };
+    yield* Effect.gen(function* () {
+      const updates = yield* watcher.subscribe({ path: next, type: "file" });
+      yield* Stream.runForEach(updates, publish);
+    }).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("location watcher subscription failed", { path: next, cause })), Effect.forkIn(scope, { startImmediately: true }));
+  }).pipe(Effect.withSpan("LocationWatcher.reconcile", { attributes: { directory: location.directory } })));
+  yield* Effect.addFinalizer(() => lock.withPermit(Effect.gen(function* () {
+    stopped = true;
+    if (active)
+      yield* Scope.close(active.scope, Exit.void);
+    active = undefined;
+  })));
+  yield* policy.observe(reconcile);
+  yield* Effect.gen(function* () {
+    yield* awaitActivation2;
+    yield* reconcile();
+  }).pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logError("failed to start location watcher", { cause })), Effect.forkScoped({ startImmediately: true }));
+  return Service11.of({});
+}));
+var node14 = makeLocationNode({
+  service: Service11,
+  layer,
+  deps: [node40, FSUtil.node, node78, node80, node84, node22, node15]
+});
+
+export { Service11, node14, exports_location_watcher2 };

package/dist/chunks/aisdk-native-gftt206x.js

@@ -0,0 +1,6 @@
+// src/session/message.ts
+import * as SessionMessage2 from "@opencode/schema/session-message";
+
+export * from "@opencode/schema/session-message";
+
+export { SessionMessage2 };