@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-sm236kpq.js

@@ -0,0 +1,193 @@
+import {
+  ID16,
+  aisdk2,
+  mergeOverlay2
+} from "./repository-pye8sh6e.js";
+import {
+  ID14,
+  VariantID2,
+  Family2,
+  Info29
+} from "./repository-nxamnhdf.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/github-copilot/models.ts
+var exports_models = {};
+__export(exports_models, {
+  CopilotModels: () => exports_models,
+  get: () => get2
+});
+import { Money } from "@opencode/schema/money";
+import { Option, Schema } from "effect";
+var RemoteModel = Schema.Struct({
+  model_picker_enabled: Schema.Boolean,
+  id: Schema.String,
+  name: Schema.String,
+  version: Schema.String,
+  supported_endpoints: Schema.optional(Schema.Array(Schema.String)),
+  policy: Schema.optional(Schema.Struct({ state: Schema.optional(Schema.String) })),
+  billing: Schema.optional(Schema.Struct({
+    token_prices: Schema.optional(Schema.Struct({
+      batch_size: Schema.Number,
+      default: Schema.Struct({
+        cache_price: Schema.optional(Schema.Number),
+        cache_read_price: Schema.optional(Schema.Number),
+        input_price: Schema.Number,
+        output_price: Schema.Number
+      })
+    }))
+  })),
+  capabilities: Schema.Struct({
+    family: Schema.String,
+    limits: Schema.optional(Schema.Struct({
+      max_context_window_tokens: Schema.optional(Schema.Number),
+      max_output_tokens: Schema.optional(Schema.Number),
+      max_prompt_tokens: Schema.optional(Schema.Number),
+      vision: Schema.optional(Schema.Struct({
+        max_prompt_image_size: Schema.Number,
+        max_prompt_images: Schema.Number,
+        supported_media_types: Schema.Array(Schema.String)
+      }))
+    })),
+    supports: Schema.Struct({
+      adaptive_thinking: Schema.optional(Schema.Boolean),
+      max_thinking_budget: Schema.optional(Schema.Number),
+      min_thinking_budget: Schema.optional(Schema.Number),
+      reasoning_effort: Schema.optional(Schema.Array(Schema.String)),
+      streaming: Schema.optional(Schema.Boolean),
+      structured_outputs: Schema.optional(Schema.Boolean),
+      tool_calls: Schema.optional(Schema.Boolean),
+      vision: Schema.optional(Schema.Boolean)
+    })
+  })
+});
+var Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) });
+var decodeResponse = Schema.decodeUnknownSync(Response);
+var decodeModel = Schema.decodeUnknownOption(RemoteModel);
+async function get2(baseURL, headers, existing) {
+  const response = await fetch(`${baseURL}/models`, {
+    headers,
+    signal: AbortSignal.timeout(5000)
+  });
+  if (!response.ok)
+    throw new Error(`Failed to fetch Copilot models: ${response.status}`);
+  const remote = new Map(decodeResponse(await response.json()).data.flatMap((raw) => {
+    const model = Option.getOrUndefined(decodeModel(raw));
+    return model && usable(model) ? [[model.id, model]] : [];
+  }));
+  const result = new Map(existing.map((model) => [model.id, model]));
+  for (const [id, model] of result) {
+    const current = remote.get(model.modelID);
+    if (!current) {
+      result.delete(id);
+      continue;
+    }
+    result.set(id, build(id, current, baseURL, model));
+  }
+  for (const [id, model] of remote) {
+    const key = ID14.make(id);
+    if (result.has(key))
+      continue;
+    result.set(key, build(key, model, baseURL));
+  }
+  return result;
+}
+function usable(model) {
+  return model.policy?.state !== "disabled" && model.capabilities.limits?.max_output_tokens !== undefined && model.capabilities.limits.max_prompt_tokens !== undefined && model.capabilities.supports.tool_calls !== undefined;
+}
+function build(id, remote, baseURL, previous) {
+  const messages = remote.supported_endpoints?.includes("/v1/messages") ?? false;
+  const endpoint = messages ? "messages" : remote.supported_endpoints?.includes("/responses") ? "responses" : remote.supported_endpoints?.includes("/chat/completions") ? "chat" : undefined;
+  const image = (remote.capabilities.supports.vision ?? false) || (remote.capabilities.limits.vision?.supported_media_types ?? []).some((item) => item.startsWith("image/"));
+  const pdf = (remote.capabilities.supports.vision ?? false) && (remote.capabilities.limits.vision?.supported_media_types.includes("application/pdf") ?? false);
+  const input = ["text"];
+  if (image)
+    input.push("image");
+  if (pdf)
+    input.push("pdf");
+  const prices = remote.billing?.token_prices;
+  const usdPerMillion = prices && prices.batch_size > 0 ? 1e4 / prices.batch_size : 0;
+  const version = remote.version.startsWith(`${remote.id}-`) ? remote.version.slice(remote.id.length + 1) : remote.version;
+  const released = previous?.time.released || Date.parse(version);
+  return Info29.make({
+    ...Info29.default(ID16.githubCopilot, id),
+    id,
+    modelID: ID14.make(remote.id),
+    providerID: ID16.githubCopilot,
+    family: previous?.family ?? Family2.make(remote.capabilities.family),
+    name: previous?.name ?? remote.name,
+    package: aisdk2(messages ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot"),
+    settings: mergeOverlay2(previous?.settings, {
+      baseURL: messages ? `${baseURL}/v1` : baseURL,
+      ...endpoint ? { endpoint } : {}
+    }),
+    headers: previous?.headers,
+    body: previous?.body,
+    capabilities: {
+      tools: remote.capabilities.supports.tool_calls,
+      input,
+      output: ["text"]
+    },
+    variants: variants(remote, messages),
+    time: { released: Number.isFinite(released) ? released : 0 },
+    cost: [
+      {
+        input: Money.USDPerMillionTokens.make((prices?.default.input_price ?? 0) * usdPerMillion),
+        output: Money.USDPerMillionTokens.make((prices?.default.output_price ?? 0) * usdPerMillion),
+        cache: {
+          read: Money.USDPerMillionTokens.make((prices?.default.cache_read_price ?? prices?.default.cache_price ?? 0) * usdPerMillion),
+          write: Money.USDPerMillionTokens.zero
+        }
+      }
+    ],
+    status: "active",
+    enabled: remote.model_picker_enabled,
+    limit: {
+      context: remote.capabilities.limits.max_context_window_tokens ?? remote.capabilities.limits.max_prompt_tokens,
+      input: remote.capabilities.limits.max_prompt_tokens,
+      output: remote.capabilities.limits.max_output_tokens
+    }
+  });
+}
+function variants(remote, messages) {
+  const efforts = remote.capabilities.supports.reasoning_effort ?? [];
+  if (!messages && efforts.length) {
+    return efforts.map((effort) => ({
+      id: VariantID2.make(effort),
+      settings: {
+        reasoningEffort: effort,
+        reasoningSummary: "auto",
+        include: ["reasoning.encrypted_content"]
+      }
+    }));
+  }
+  if (efforts.length && remote.capabilities.supports.adaptive_thinking) {
+    return efforts.map((effort) => ({
+      id: VariantID2.make(effort),
+      settings: {
+        thinking: {
+          type: "adaptive",
+          display: "summarized"
+        },
+        effort
+      }
+    }));
+  }
+  const max = remote.capabilities.supports.max_thinking_budget;
+  if (max === undefined)
+    return [];
+  return [
+    {
+      id: VariantID2.make("max"),
+      settings: { thinking: { type: "enabled", budgetTokens: max - 1 } }
+    },
+    {
+      id: VariantID2.make("high"),
+      settings: { thinking: { type: "enabled", budgetTokens: Math.floor(max / 2) } }
+    }
+  ];
+}
+
+export { get2, exports_models };

package/dist/chunks/repository-smnv2tch.js

@@ -0,0 +1,254 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Event19,
+  Service75,
+  node79
+} from "./repository-sztg2hv4.js";
+import {
+  Service45,
+  node50
+} from "./repository-shg3amz7.js";
+import {
+  AbsolutePath2
+} from "./repository-922hggd3.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  substitute2
+} from "./repository-yrznvahk.js";
+import {
+  normalize2
+} from "./repository-mqsc2h20.js";
+import {
+  names4,
+  discover3
+} from "./repository-kkdm9ajw.js";
+import {
+  plan2
+} from "./repository-j56e64zr.js";
+import {
+  Service46,
+  Event11,
+  node51
+} from "./repository-bkhh0yw4.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/config.ts
+var exports_config = {};
+__export(exports_config, {
+  Config: () => exports_config,
+  Options: () => Options7,
+  Service: () => Service44,
+  Test: () => Test2,
+  configured: () => configured8,
+  latest: () => latest2,
+  layer: () => layer18,
+  node: () => node49,
+  testLayer: () => testLayer2
+});
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import path from "path";
+import { isDeepStrictEqual } from "node:util";
+import { parse } from "jsonc-parser";
+import { Context, Effect, FiberMap, Layer, Option, PubSub, Ref, Schema, Semaphore, Stream } from "effect";
+import {
+  AgentsDirectory,
+  ClaudeDirectory,
+  Directory,
+  Document,
+  Info,
+  Event
+} from "@opencode/schema/config";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+function latest2(entries, key) {
+  return entries.findLast((entry) => entry.type === "document" && entry.info[key] !== undefined)?.info[key];
+}
+var Options7 = Schema.Struct({
+  project: Schema.optional(Schema.Boolean),
+  global: Schema.optional(Schema.Boolean),
+  file: Schema.optional(Schema.String),
+  content: Schema.optional(Schema.String)
+});
+
+class Service44 extends Context.Service()("@opencode/Config") {
+}
+
+class Test2 extends Context.Service()("@opencode/Config/Test") {
+}
+var testLayer2 = (initial = []) => Layer.effectContext(Effect.gen(function* () {
+  const entries = yield* Ref.make(initial);
+  const updates = yield* PubSub.unbounded();
+  const service = Test2.of({
+    entries: () => Ref.get(entries),
+    changes: () => Stream.fromPubSub(updates),
+    setEntries: (next) => Ref.set(entries, next),
+    emitChange: (update) => PubSub.publish(updates, update).pipe(Effect.asVoid)
+  });
+  return Context.empty().pipe(Context.add(Service44, service), Context.add(Test2, service));
+}));
+var layer18 = (options) => Layer.effect(Service44, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service66;
+  const watcher = yield* Service45;
+  const bus = yield* Service78;
+  const credentials = yield* Service75;
+  const wellknown = yield* Service46;
+  const reloadLock = Semaphore.makeUnsafe(1);
+  const decodeOptions = { errors: "all", onExcessProperty: "ignore", propertyOrder: "original" };
+  const decodeInfo = Schema.decodeUnknownOption(Info, decodeOptions);
+  const parseInfo = Effect.fn("Config.parseInfo")(function* (text, source) {
+    const errors = [];
+    const input = parse(text, errors, { allowTrailingComma: true });
+    if (errors.length) {
+      yield* Effect.logWarning("configuration normalization diagnostic", {
+        source,
+        path: "$",
+        kind: "invalid",
+        action: "rejected malformed JSON or JSONC document"
+      });
+      return;
+    }
+    const result = normalize2(input);
+    yield* Effect.forEach(result.diagnostics, (diagnostic) => Effect.logWarning("configuration normalization diagnostic", {
+      source,
+      path: diagnostic.path[0] === "$" ? "$" : `$.${diagnostic.path.join(".")}`,
+      kind: diagnostic.kind,
+      action: diagnostic.message
+    }));
+    if (result.type === "rejected")
+      return;
+    const info = Option.getOrUndefined(decodeInfo(result.encoded));
+    if (info)
+      return info;
+    yield* Effect.logWarning("configuration normalization diagnostic", {
+      source,
+      path: "$",
+      kind: "invalid",
+      action: "rejected canonical configuration after final validation"
+    });
+  });
+  const loadFile = Effect.fnUntraced(function* (filepath) {
+    const text = yield* fs.readFileStringSafe(filepath);
+    if (text === undefined)
+      return;
+    const substituted = yield* substitute2({ type: "path", path: filepath, text });
+    const info = yield* parseInfo(substituted, filepath);
+    if (!info)
+      return;
+    return new Document({ type: "document", path: AbsolutePath2.make(filepath), info });
+  });
+  const loadWellknownEntry = Effect.fnUntraced(function* (entry) {
+    const auth = entry.manifest.auth;
+    if (!auth)
+      return [];
+    const credential = (yield* credentials.list(entry.integrationID)).at(-1);
+    if (!credential || credential.value.type !== "key")
+      return [];
+    const variables = { [auth.env]: credential.value.key };
+    const configs = yield* wellknown.resolve(entry, variables).pipe(Effect.catch(() => Effect.logWarning("failed to load wellknown config", { source: entry.origin }).pipe(Effect.as([]))));
+    return yield* Effect.forEach(configs, (config) => substitute2({
+      type: "virtual",
+      source: entry.origin,
+      dir: entry.origin,
+      text: JSON.stringify(config),
+      env: variables
+    }).pipe(Effect.flatMap((text) => parseInfo(text, entry.origin)), Effect.map((info) => info ? new Document({ type: "document", info }) : undefined))).pipe(Effect.map((documents) => documents.filter((document) => document !== undefined)));
+  });
+  const loadWellknown = Effect.fn("Config.loadWellknown")(function* () {
+    const entries = yield* wellknown.entries().pipe(Effect.catch((error) => Effect.logWarning("failed to discover wellknown config", { error }).pipe(Effect.as([]))));
+    return yield* Effect.forEach(entries, loadWellknownEntry).pipe(Effect.map((documents) => documents.flat()));
+  });
+  const loadDirectory = Effect.fnUntraced(function* (directory) {
+    return [
+      ...yield* Effect.forEach(names4, (file) => loadFile(path.join(directory, file))).pipe(Effect.map((configs) => configs.filter((config) => config !== undefined))),
+      new Directory({ type: "directory", path: directory })
+    ];
+  });
+  const load = Effect.fn("Config.load")(function* (sources) {
+    const claude = yield* Effect.filter(sources.claude, (path2) => fs.isDir(path2));
+    const agents = yield* Effect.filter(sources.agents, (path2) => fs.isDir(path2));
+    const direct = yield* Effect.forEach(sources.direct, (filepath) => loadFile(filepath)).pipe(Effect.orDie, Effect.map((entries) => entries.filter((entry) => entry !== undefined)));
+    const explicit = sources.explicit ? yield* loadFile(sources.explicit).pipe(Effect.map((config) => config ? [config] : []), Effect.orDie) : [];
+    const content = options?.content !== undefined ? yield* substitute2({
+      type: "virtual",
+      source: "OPENCODE_CONFIG_CONTENT",
+      dir: location.directory,
+      text: options.content
+    }).pipe(Effect.flatMap((text) => parseInfo(text, "OPENCODE_CONFIG_CONTENT")), Effect.map((info) => info ? [new Document({ type: "document", info })] : []), Effect.orDie) : [];
+    const globalSupplementary = sources.global ? yield* loadDirectory(sources.global).pipe(Effect.orDie) : [];
+    const projectSupplementary = yield* Effect.forEach(sources.project.filter((root) => root.present), (root) => loadDirectory(root.path)).pipe(Effect.orDie, Effect.map((entries) => entries.flat()));
+    return [
+      ...yield* loadWellknown().pipe(Effect.orDie),
+      ...claude.map((path2) => new ClaudeDirectory({ type: "claude", path: path2 })),
+      ...agents.map((path2) => new AgentsDirectory({ type: "agents", path: path2 })),
+      ...globalSupplementary,
+      ...explicit,
+      ...direct,
+      ...projectSupplementary,
+      ...content
+    ];
+  });
+  const initial = yield* discover3(options);
+  let configs = yield* load(initial);
+  const updates = yield* PubSub.unbounded();
+  const reloads = yield* PubSub.sliding(1);
+  const requestReload = PubSub.publish(reloads, undefined).pipe(Effect.asVoid);
+  const watched = yield* FiberMap.make();
+  const reconcile = Effect.fn("Config.reconcileWatches")(function* (sources) {
+    const plan = plan2(sources);
+    for (const key of Array.from(watched, ([key]) => key)) {
+      if (!plan.has(key))
+        yield* FiberMap.remove(watched, key);
+    }
+    for (const [key, target] of plan) {
+      yield* watcher.subscribe(target, requestReload).pipe(Effect.flatMap(Stream.runForEach((update) => PubSub.publish(updates, update).pipe(Effect.andThen(requestReload)))), FiberMap.run(watched, key, { onlyIfMissing: true, startImmediately: true }));
+    }
+  });
+  const reload = Effect.fn("Config.reload")(function* () {
+    const sources = yield* discover3(options);
+    const next = yield* load(sources);
+    yield* reconcile(sources);
+    if (isDeepStrictEqual(configs, next))
+      return;
+    configs = next;
+    yield* bus.publish(Event.Updated, {});
+  }, (effect) => reloadLock.withPermit(effect));
+  const pendingReloads = yield* PubSub.subscribe(reloads);
+  yield* Stream.fromSubscription(pendingReloads).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload config", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* bus.subscribe(Event19.Switched).pipe(Stream.filterEffect((event) => wellknown.entries().pipe(Effect.map((entries) => entries.some((entry) => entry.integrationID === event.data.integrationID)), Effect.orElseSucceed(() => false))), Stream.runForEach(() => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown config", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* bus.subscribe(Event11.Updated).pipe(Stream.runForEach(() => reload().pipe(Effect.catchCause((cause) => Effect.logError("failed to reload wellknown sources", { cause })))), Effect.forkScoped({ startImmediately: true }));
+  yield* Effect.sleep("10 minutes").pipe(Effect.andThen(Effect.suspend(() => {
+    if (!wellknown.snapshot().length)
+      return Effect.void;
+    return Effect.gen(function* () {
+      const changed = yield* wellknown.refresh().pipe(Effect.catch((error) => Effect.logWarning("failed to refresh wellknown manifests", { error }).pipe(Effect.as(false))));
+      if (!changed)
+        yield* reload();
+    }).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to refresh wellknown config", { cause })));
+  })), Effect.forever, Effect.forkScoped({ startImmediately: true }));
+  yield* reloadLock.withPermit(reconcile(initial));
+  return Service44.of({
+    entries: Effect.fnUntraced(function* () {
+      return configs;
+    }),
+    changes: () => Stream.fromPubSub(updates)
+  });
+}));
+function configured8(options) {
+  return makeLocationNode({
+    service: Service44,
+    layer: layer18(options),
+    deps: [node50, node83, FSUtil.node, Global.node, node70, node79, node51]
+  });
+}
+var node49 = configured8();
+
+export { latest2, Options7, Service44, Test2, testLayer2, layer18, configured8, node49, exports_config };

package/dist/chunks/repository-ssg3fenm.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260602182828_add_project_directories.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602182828_add_project_directories",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260602182828_add_project_directories_default = migration;
+
+export { _20260602182828_add_project_directories_default };

package/dist/chunks/repository-sztg2hv4.js

@@ -0,0 +1,198 @@
+import {
+  Service79,
+  node84
+} from "./repository-8m31s27t.js";
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  CredentialTable2
+} from "./repository-pknna89w.js";
+import {
+  from2
+} from "./repository-0q0f95c6.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/credential.ts
+var exports_credential = {};
+__export(exports_credential, {
+  Credential: () => exports_credential,
+  Event: () => Event19,
+  ID: () => ID15,
+  Info: () => Info30,
+  Key: () => Key4,
+  OAuth: () => OAuth3,
+  Service: () => Service75,
+  Value: () => Value2,
+  node: () => node79
+});
+import { asc, desc, eq } from "drizzle-orm";
+import { Cause, Context, Effect, Layer, Schema } from "effect";
+import { Credential } from "@opencode/schema/credential";
+import { Integration } from "@opencode/schema/integration";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+var ID15 = Credential.ID;
+var OAuth3 = Credential.OAuth;
+var Key4 = Credential.Key;
+var Value2 = Credential.Value;
+var Event19 = Credential.Event;
+
+class Info30 extends Schema.Class("Credential.Info")({
+  id: ID15,
+  integrationID: Integration.ID,
+  label: Schema.String,
+  value: Value2
+}) {
+}
+
+class Service75 extends Context.Service()("@opencode/Credential") {
+}
+var layer = Layer.effect(Service75, Effect.gen(function* () {
+  const db = (yield* Service79).db;
+  const bus = yield* Service78;
+  const decode = Schema.decodeUnknownSync(Value2);
+  const stored = (row) => {
+    if (!row.integration_id)
+      return;
+    return new Info30({
+      id: row.id,
+      integrationID: row.integration_id,
+      label: row.label,
+      value: decode(row.value)
+    });
+  };
+  const storedRows = (rows) => rows.flatMap((row) => {
+    const credential = stored(row);
+    return credential ? [credential] : [];
+  });
+  return Service75.of({
+    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable2).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
+    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable2).where(eq(CredentialTable2.integration_id, integrationID)).orderBy(asc(CredentialTable2.active), asc(CredentialTable2.time_created), asc(CredentialTable2.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
+    get: Effect.fn("Credential.get")(function* (id) {
+      const row = yield* db.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get().pipe(Effect.orDie);
+      return row ? stored(row) : undefined;
+    }),
+    create: Effect.fn("Credential.create")(function* (input) {
+      const credential = new Info30({
+        id: ID15.create(),
+        integrationID: input.integrationID,
+        label: input.label ?? "default",
+        value: input.value
+      });
+      yield* db.transaction((tx) => Effect.gen(function* () {
+        yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integrationID)).run();
+        yield* tx.insert(CredentialTable2).values({
+          id: credential.id,
+          integration_id: credential.integrationID,
+          label: credential.label,
+          value: credential.value,
+          active: true
+        }).run();
+      })).pipe(Effect.onError((cause) => Effect.logError("credential create failed", {
+        credentialID: credential.id,
+        integrationID: credential.integrationID,
+        errors: from2(Cause.squash(cause))
+      })), Effect.orDie);
+      yield* Effect.logInfo("credential created", {
+        credentialID: credential.id,
+        integrationID: credential.integrationID,
+        type: credential.value.type
+      });
+      yield* bus.publish(Event19.Updated, {}, { global: true });
+      yield* bus.publish(Event19.Switched, { integrationID: credential.integrationID, credentialID: credential.id }, { global: true });
+      return credential;
+    }),
+    activate: Effect.fn("Credential.activate")(function* (id) {
+      const integrationID = yield* db.transaction((tx) => Effect.gen(function* () {
+        const credential = yield* tx.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get();
+        if (!credential?.integration_id)
+          return;
+        const active = yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.active), desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get();
+        if (active?.id === id)
+          return;
+        yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integration_id)).run();
+        yield* tx.update(CredentialTable2).set({ active: true }).where(eq(CredentialTable2.id, id)).run();
+        return credential.integration_id;
+      })).pipe(Effect.onError((cause) => Effect.logError("credential activate failed", {
+        credentialID: id,
+        errors: from2(Cause.squash(cause))
+      })), Effect.orDie);
+      if (integrationID) {
+        yield* Effect.logInfo("credential activated", { integrationID, credentialID: id });
+        yield* bus.publish(Event19.Switched, { integrationID, credentialID: id }, { global: true });
+      }
+    }),
+    update: Effect.fn("Credential.update")(function* (id, updates) {
+      if (updates.label === undefined && updates.value === undefined)
+        return;
+      const credential = yield* db.select({ integrationID: CredentialTable2.integration_id, label: CredentialTable2.label }).from(CredentialTable2).where(eq(CredentialTable2.id, id)).get().pipe(Effect.onError((cause) => Effect.logError("credential update lookup failed", {
+        credentialID: id,
+        errors: from2(Cause.squash(cause))
+      })), Effect.orDie);
+      if (!credential?.integrationID) {
+        yield* Effect.logWarning("credential update skipped", { credentialID: id, reason: "credential_missing" });
+        return;
+      }
+      if (updates.label === credential.label && updates.value === undefined)
+        return;
+      const updated = yield* db.update(CredentialTable2).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable2.id, id)).returning({ id: CredentialTable2.id }).get().pipe(Effect.onError((cause) => Effect.logError("credential update failed", {
+        credentialID: id,
+        integrationID: credential.integrationID,
+        errors: from2(Cause.squash(cause))
+      })), Effect.orDie);
+      if (!updated) {
+        yield* Effect.logWarning("credential update skipped", { credentialID: id, reason: "credential_removed" });
+        return;
+      }
+      yield* Effect.logInfo("credential updated", {
+        credentialID: id,
+        integrationID: credential.integrationID,
+        valueChanged: updates.value !== undefined,
+        labelChanged: updates.label !== undefined && updates.label !== credential.label
+      });
+      if (updates.label !== undefined && updates.label !== credential.label)
+        yield* bus.publish(Event19.Updated, {}, { global: true });
+    }),
+    remove: Effect.fn("Credential.remove")(function* (id) {
+      const removed = yield* db.transaction((tx) => Effect.gen(function* () {
+        const credential = yield* tx.select().from(CredentialTable2).where(eq(CredentialTable2.id, id)).get();
+        if (!credential)
+          return;
+        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.active), desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get() : undefined;
+        yield* tx.delete(CredentialTable2).where(eq(CredentialTable2.id, id)).run();
+        if (!credential.integration_id || active?.id !== id)
+          return { switched: false, integrationID: credential.integration_id };
+        const replacement = yield* tx.select({ id: CredentialTable2.id }).from(CredentialTable2).where(eq(CredentialTable2.integration_id, credential.integration_id)).orderBy(desc(CredentialTable2.time_created), desc(CredentialTable2.id)).get();
+        if (replacement) {
+          yield* tx.update(CredentialTable2).set({ active: false }).where(eq(CredentialTable2.integration_id, credential.integration_id)).run();
+          yield* tx.update(CredentialTable2).set({ active: true }).where(eq(CredentialTable2.id, replacement.id)).run();
+        }
+        return {
+          switched: true,
+          integrationID: credential.integration_id,
+          credentialID: replacement?.id ?? null
+        };
+      })).pipe(Effect.onError((cause) => Effect.logError("credential remove failed", {
+        credentialID: id,
+        errors: from2(Cause.squash(cause))
+      })), Effect.orDie);
+      if (!removed)
+        return;
+      yield* Effect.logInfo("credential removed", {
+        credentialID: id,
+        integrationID: removed.integrationID,
+        active: removed.switched,
+        ...removed.switched ? { replacementID: removed.credentialID } : {}
+      });
+      yield* bus.publish(Event19.Updated, {}, { global: true });
+      if (removed.switched)
+        yield* bus.publish(Event19.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
+    })
+  });
+}));
+var node79 = makeGlobalNode({ service: Service75, layer, deps: [node84, node83] });
+
+export { ID15, OAuth3, Key4, Value2, Event19, Info30, Service75, node79, exports_credential };