@opencode-ai/core 0.0.0-dev-19087 → 0.0.0-dev-19093

package/dist/chunks/instance-273erafq.js

@@ -1,386 +0,0 @@
-import {
-  SessionMessage
-} from "./instance-8rpfd2h6.js";
-import {
-  __export
-} from "./instance-vpjkya7h.js";
-
-// src/session/message-updater.ts
-var exports_message_updater = {};
-__export(exports_message_updater, {
-  SessionMessageUpdater: () => exports_message_updater,
-  update: () => update
-});
-import { castDraft, produce } from "immer";
-import { DateTime, Effect, Match, pipe, Schema } from "effect";
-var projectTerminalSnapshot = (draft, event) => {
-  if (event.data.snapshot || event.data.files)
-    draft.snapshot = {
-      ...draft.snapshot,
-      end: event.data.snapshot,
-      files: event.data.files ? Array.from(event.data.files) : undefined
-    };
-};
-function update(adapter, event) {
-  const created = DateTime.makeUnsafe(event.created);
-  const latestTool = (assistant, id) => assistant.content.findLast((item) => item.type === "tool" && item.id === id);
-  const latestText = (assistant) => assistant.content.findLast((item) => item.type === "text");
-  const latestReasoning = (assistant) => assistant.content.findLast((item) => item.type === "reasoning" && !item.time?.completed);
-  const updateOwnedAssistant = (messageID, recipe) => Effect.gen(function* () {
-    const assistant = yield* adapter.getAssistant(messageID);
-    if (!assistant)
-      return;
-    yield* adapter.updateAssistant(produce(assistant, recipe));
-  });
-  const clearCurrentRetry = Effect.gen(function* () {
-    const assistant = yield* adapter.getCurrentAssistant();
-    if (!assistant?.retry)
-      return;
-    yield* adapter.updateAssistant(produce(assistant, (draft) => {
-      draft.retry = undefined;
-    }));
-  });
-  const project = pipe(Match.type(), Match.discriminatorsExhaustive("type")({
-    "session.created": () => Effect.void,
-    "session.viewed": () => Effect.void,
-    "session.message.content.updated": (event2) => updateOwnedAssistant(event2.data.messageID, (draft) => {
-      draft.content = castDraft(Schema.decodeUnknownSync(Schema.Array(SessionMessage.AssistantContent))(event2.data.content));
-    }),
-    "session.usage.recorded": () => Effect.void,
-    "session.agent.selected": (event2) => Effect.gen(function* () {
-      const previous = event2.data.previous ?? (yield* adapter.getAgent());
-      yield* adapter.appendMessage(SessionMessage.AgentSelected.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "agent-switched",
-        metadata: event2.metadata,
-        agent: event2.data.agent,
-        previous,
-        time: { created }
-      }));
-    }),
-    "session.model.selected": (event2) => Effect.gen(function* () {
-      const previous = event2.data.previous ?? (yield* adapter.getModel());
-      yield* adapter.appendMessage(SessionMessage.ModelSelected.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "model-switched",
-        metadata: event2.metadata,
-        model: event2.data.model,
-        previous,
-        time: { created }
-      }));
-    }),
-    "session.moved": (event2) => Effect.gen(function* () {
-      yield* adapter.appendMessage(SessionMessage.LocationSwitched.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "location-switched",
-        metadata: event2.metadata,
-        location: event2.data.location,
-        projectID: event2.data.projectID,
-        subpath: event2.data.subpath,
-        previous: yield* adapter.getLocation(),
-        time: { created }
-      }));
-    }),
-    "session.renamed": () => Effect.void,
-    "session.deleted": () => Effect.void,
-    "session.forked": () => Effect.void,
-    "session.inbox.delivered": () => Effect.void,
-    "session.inbox.enqueued": () => Effect.void,
-    "session.inbox.cancelled": () => Effect.void,
-    "session.inbox.delivery.changed": () => Effect.void,
-    "session.execution.started": () => Effect.void,
-    "session.execution.succeeded": () => clearCurrentRetry,
-    "session.execution.failed": () => clearCurrentRetry,
-    "session.execution.interrupted": () => clearCurrentRetry,
-    "session.instructions.updated": (event2) => {
-      if (event2.data.text === undefined)
-        return Effect.void;
-      return adapter.appendMessage(SessionMessage.System.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "system",
-        text: event2.data.text,
-        description: `Instructions updated: ${Object.keys(event2.data.delta).join(", ")}`,
-        metadata: event2.metadata,
-        time: { created }
-      }));
-    },
-    "session.synthetic": (event2) => {
-      return adapter.appendMessage(SessionMessage.Synthetic.make({
-        text: event2.data.text,
-        description: event2.data.description,
-        metadata: event2.data.metadata,
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "synthetic",
-        time: { created }
-      }));
-    },
-    "session.skill.activated": (event2) => {
-      return adapter.appendMessage(SessionMessage.Skill.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "skill",
-        skill: event2.data.id,
-        name: event2.data.name,
-        text: event2.data.text,
-        metadata: event2.metadata,
-        time: { created }
-      }));
-    },
-    "session.shell.started": (event2) => {
-      return adapter.appendMessage(SessionMessage.Shell.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "shell",
-        metadata: event2.data.shell.metadata.background === true ? { ...event2.metadata, background: true } : event2.metadata,
-        shellID: event2.data.shell.id,
-        command: event2.data.shell.command,
-        status: event2.data.shell.status,
-        time: { created }
-      }));
-    },
-    "session.shell.ended": (event2) => Effect.gen(function* () {
-      const currentShell = yield* adapter.getShell(event2.data.shell.id);
-      if (currentShell) {
-        yield* adapter.updateShell(produce(currentShell, (draft) => {
-          draft.status = event2.data.shell.status;
-          draft.exit = event2.data.shell.exit;
-          draft.output = event2.data.output;
-          draft.time.completed = created;
-        }));
-      }
-    }),
-    "session.step.started": (event2) => Effect.gen(function* () {
-      const existing = yield* adapter.getAssistant(event2.data.assistantMessageID);
-      if (existing) {
-        yield* adapter.updateAssistant(produce(existing, (draft) => {
-          draft.agent = event2.data.agent;
-          draft.model = castDraft(event2.data.model);
-          draft.retry = undefined;
-          draft.error = undefined;
-          draft.finish = undefined;
-          draft.rawFinish = undefined;
-          draft.providerState = undefined;
-          draft.time.streamed = undefined;
-          draft.time.completed = undefined;
-          if (event2.data.snapshot)
-            draft.snapshot = { ...draft.snapshot, start: event2.data.snapshot };
-        }));
-        return;
-      }
-      const currentAssistant = yield* adapter.getCurrentAssistant();
-      if (currentAssistant) {
-        yield* adapter.updateAssistant(produce(currentAssistant, (draft) => {
-          draft.retry = undefined;
-          draft.time.completed = created;
-        }));
-      }
-      yield* adapter.appendMessage(SessionMessage.Assistant.make({
-        id: event2.data.assistantMessageID,
-        type: "assistant",
-        agent: event2.data.agent,
-        model: event2.data.model,
-        metadata: event2.metadata,
-        time: { created },
-        content: [],
-        snapshot: event2.data.snapshot ? { start: event2.data.snapshot } : undefined
-      }));
-    }),
-    "session.step.streamed": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.time.streamed = created;
-      });
-    },
-    "session.step.ended": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.time.completed = created;
-        draft.finish = event2.data.finish;
-        draft.rawFinish = event2.data.rawFinish;
-        draft.providerState = castDraft(event2.data.providerState);
-        draft.cost = event2.data.cost;
-        draft.tokens = event2.data.tokens;
-        projectTerminalSnapshot(draft, event2);
-      });
-    },
-    "session.step.failed": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.time.completed = created;
-        draft.finish = event2.data.finish ?? "error";
-        draft.rawFinish = event2.data.rawFinish;
-        draft.providerState = castDraft(event2.data.providerState);
-        draft.error = castDraft(event2.data.error);
-        draft.retry = undefined;
-        if (event2.data.cost !== undefined && event2.data.tokens !== undefined) {
-          draft.cost = event2.data.cost;
-          draft.tokens = castDraft(event2.data.tokens);
-        }
-        projectTerminalSnapshot(draft, event2);
-      });
-    },
-    "session.text.started": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.content.push(castDraft(SessionMessage.AssistantText.make({ type: "text", text: "" })));
-      });
-    },
-    "session.text.ended": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestText(draft);
-        if (match) {
-          match.text = event2.data.text;
-          match.state = castDraft(event2.data.state);
-        }
-      });
-    },
-    "session.tool.input.started": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.content.push(castDraft(SessionMessage.AssistantTool.make({
-          type: "tool",
-          id: event2.data.id,
-          name: event2.data.name,
-          time: { created },
-          state: SessionMessage.ToolStateStreaming.make({ status: "streaming", input: "" })
-        })));
-      });
-    },
-    "session.tool.input.ended": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestTool(draft, event2.data.id);
-        if (match && match.state.status === "streaming")
-          match.state.input = event2.data.text;
-      });
-    },
-    "session.tool.called": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestTool(draft, event2.data.id);
-        if (match) {
-          match.executed = event2.data.executed;
-          match.providerState = event2.data.state;
-          match.time.ran = created;
-          match.state = castDraft(SessionMessage.ToolStateRunning.make({
-            status: "running",
-            input: event2.data.input,
-            metadata: {}
-          }));
-        }
-      });
-    },
-    "session.tool.success": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestTool(draft, event2.data.id);
-        if (match && match.state.status === "running") {
-          match.executed = event2.data.executed || match.executed === true;
-          match.providerResultState = event2.data.resultState;
-          match.time.completed = created;
-          match.state = castDraft(SessionMessage.ToolStateCompleted.make({
-            status: "completed",
-            input: match.state.input,
-            content: event2.data.content,
-            ...event2.data.metadata === undefined ? {} : { metadata: event2.data.metadata }
-          }));
-        }
-      });
-    },
-    "session.tool.failed": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestTool(draft, event2.data.id);
-        if (match && (match.state.status === "streaming" || match.state.status === "running")) {
-          match.executed = event2.data.executed || match.executed === true;
-          match.providerResultState = event2.data.resultState;
-          match.time.completed = created;
-          match.state = castDraft(SessionMessage.ToolStateError.make({
-            status: "error",
-            error: event2.data.error,
-            input: typeof match.state.input === "string" ? {} : match.state.input,
-            ...event2.data.content === undefined ? {} : { content: event2.data.content },
-            ...event2.data.metadata === undefined ? {} : { metadata: event2.data.metadata }
-          }));
-        }
-      });
-    },
-    "session.reasoning.started": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.content.push(castDraft(SessionMessage.AssistantReasoning.make({
-          type: "reasoning",
-          text: "",
-          state: event2.data.state,
-          time: { created }
-        })));
-      });
-    },
-    "session.reasoning.ended": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        const match = latestReasoning(draft);
-        if (match) {
-          match.text = event2.data.text;
-          match.time = { created: match.time?.created ?? created, completed: created };
-          if (event2.data.state !== undefined)
-            match.state = event2.data.state;
-        }
-      });
-    },
-    "session.retry.scheduled": (event2) => {
-      return updateOwnedAssistant(event2.data.assistantMessageID, (draft) => {
-        draft.retry = {
-          attempt: event2.data.attempt,
-          at: DateTime.makeUnsafe(event2.data.at),
-          error: castDraft(event2.data.error)
-        };
-      });
-    },
-    "session.compaction.started": (event2) => adapter.appendMessage(SessionMessage.CompactionRunning.make({
-      id: event2.data.inputID ?? SessionMessage.ID.fromEvent(event2.id),
-      type: "compaction",
-      status: "running",
-      metadata: event2.metadata,
-      reason: event2.data.reason,
-      summary: "",
-      recent: event2.data.recent ?? "",
-      time: { created }
-    })),
-    "session.compaction.ended": (event2) => Effect.gen(function* () {
-      const current = yield* adapter.getCompaction();
-      if (current?.status === "running") {
-        yield* adapter.updateCompaction({
-          ...current,
-          status: "completed",
-          reason: event2.data.reason,
-          model: event2.data.model,
-          providerState: event2.data.providerState,
-          summary: event2.data.text,
-          recent: event2.data.recent
-        });
-        return;
-      }
-      yield* adapter.appendMessage(SessionMessage.Compaction.make({
-        id: SessionMessage.ID.fromEvent(event2.id),
-        type: "compaction",
-        status: "completed",
-        metadata: event2.metadata,
-        reason: event2.data.reason,
-        model: event2.data.model,
-        providerState: event2.data.providerState,
-        summary: event2.data.text,
-        recent: event2.data.recent,
-        time: { created }
-      }));
-    }),
-    "session.compaction.failed": (event2) => Effect.gen(function* () {
-      const current = yield* adapter.getCompaction();
-      const failed = SessionMessage.CompactionFailed.make({
-        id: current?.id ?? event2.data.inputID ?? SessionMessage.ID.fromEvent(event2.id),
-        type: "compaction",
-        status: "failed",
-        metadata: current?.metadata ?? event2.metadata,
-        reason: event2.data.reason,
-        error: event2.data.error,
-        time: current?.time ?? { created }
-      });
-      if (current?.status === "running")
-        return yield* adapter.updateCompaction(failed);
-      yield* adapter.appendMessage(failed);
-    }),
-    "session.revert.staged": () => Effect.void,
-    "session.revert.cleared": () => Effect.void,
-    "session.revert.committed": () => Effect.void
-  }));
-  return project(event);
-}
-
-export { update, exports_message_updater };

package/dist/chunks/instance-2sqw2jjm.js

@@ -1,147 +0,0 @@
-import {
-  SessionMessage
-} from "./instance-8rpfd2h6.js";
-import {
-  SessionSchema
-} from "./instance-bjwj8hwv.js";
-import {
-  __export
-} from "./instance-vpjkya7h.js";
-
-// src/session/error.ts
-var exports_error = {};
-__export(exports_error, {
-  AgentNotFoundError: () => AgentNotFoundError,
-  AttachmentError: () => AttachmentError,
-  BusyError: () => BusyError,
-  CompactionConflictError: () => CompactionConflictError,
-  ForkEmptyError: () => ForkEmptyError,
-  InboxConflictError: () => InboxConflictError,
-  MessageDecodeError: () => MessageDecodeError,
-  MessageIncompleteError: () => MessageIncompleteError,
-  MessageNotAssistantError: () => MessageNotAssistantError,
-  MessageNotFoundError: () => MessageNotFoundError,
-  MessageToolIncompleteError: () => MessageToolIncompleteError,
-  NotFoundError: () => NotFoundError,
-  PromptConflictError: () => PromptConflictError,
-  SessionErrors: () => exports_error,
-  SkillNotFoundError: () => SkillNotFoundError,
-  StepFailedError: () => StepFailedError,
-  SyntheticConflictError: () => SyntheticConflictError,
-  UserInterruptedError: () => UserInterruptedError
-});
-import { Schema } from "effect";
-import { Agent } from "@opencode-ai/schema/agent";
-import { Skill } from "@opencode-ai/schema/skill";
-import { SessionError } from "@opencode-ai/schema/session-error";
-
-class NotFoundError extends Schema.TaggedError()("Session.NotFoundError", {
-  sessionID: SessionSchema.ID
-}) {
-}
-
-class MessageNotFoundError extends Schema.TaggedError()("Session.MessageNotFoundError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class MessageNotAssistantError extends Schema.TaggedError()("Session.MessageNotAssistantError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class MessageIncompleteError extends Schema.TaggedError()("Session.MessageIncompleteError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class MessageToolIncompleteError extends Schema.TaggedError()("Session.MessageToolIncompleteError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class ForkEmptyError extends Schema.TaggedError()("Session.ForkEmptyError", {
-  sessionID: SessionSchema.ID
-}) {
-  get message() {
-    return `Cannot fork empty session: ${this.sessionID}`;
-  }
-}
-
-class MessageDecodeError extends Schema.TaggedError()("Session.MessageDecodeError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-  get message() {
-    return `Failed to decode message ${this.messageID} in session ${this.sessionID}`;
-  }
-}
-
-class AgentNotFoundError extends Schema.TaggedError()("Session.AgentNotFoundError", {
-  sessionID: SessionSchema.ID,
-  agent: Agent.ID
-}) {
-  get message() {
-    return `Agent not found: "${this.agent}"`;
-  }
-}
-
-class StepFailedError extends Schema.TaggedError()("Session.StepFailedError", {
-  error: SessionError.Error
-}) {
-  get message() {
-    return this.error.message;
-  }
-}
-
-class UserInterruptedError extends Schema.TaggedError()("Session.UserInterruptedError", {}) {
-  get message() {
-    return "Session interrupted by user";
-  }
-}
-
-class PromptConflictError extends Schema.TaggedError()("Session.PromptConflictError", {
-  sessionID: SessionSchema.ID,
-  messageID: SessionMessage.ID
-}) {
-}
-
-class SyntheticConflictError extends Schema.TaggedError()("Session.SyntheticConflictError", {
-  sessionID: SessionSchema.ID,
-  inputID: SessionMessage.ID
-}) {
-}
-
-class AttachmentError extends Schema.TaggedError()("Session.AttachmentError", {
-  uri: Schema.String,
-  message: Schema.String
-}) {
-}
-
-class CompactionConflictError extends Schema.TaggedError()("Session.CompactionConflictError", {
-  sessionID: SessionSchema.ID,
-  inputID: SessionMessage.ID
-}) {
-}
-
-class BusyError extends Schema.TaggedError()("Session.BusyError", {
-  sessionID: SessionSchema.ID
-}) {
-}
-
-class InboxConflictError extends Schema.TaggedError()("Session.InboxConflictError", {
-  sessionID: SessionSchema.ID,
-  inboxID: SessionMessage.ID
-}) {
-}
-
-class SkillNotFoundError extends Schema.TaggedError()("Session.SkillNotFoundError", {
-  skill: Skill.ID
-}) {
-}
-
-export { NotFoundError, MessageNotFoundError, MessageNotAssistantError, MessageIncompleteError, MessageToolIncompleteError, ForkEmptyError, MessageDecodeError, AgentNotFoundError, StepFailedError, UserInterruptedError, PromptConflictError, SyntheticConflictError, AttachmentError, CompactionConflictError, BusyError, InboxConflictError, SkillNotFoundError, exports_error };

package/dist/chunks/instance-2zq6hdwh.js

@@ -1,151 +0,0 @@
-import {
-  CredentialTable
-} from "./instance-mf0hyk7z.js";
-import {
-  exports_bus
-} from "./instance-3dwd52hd.js";
-import {
-  exports_database
-} from "./instance-5ez4e7fn.js";
-import {
-  __export
-} from "./instance-vpjkya7h.js";
-
-// src/credential.ts
-var exports_credential = {};
-__export(exports_credential, {
-  Credential: () => exports_credential,
-  Event: () => Event,
-  ID: () => ID,
-  Info: () => Info,
-  Key: () => Key,
-  OAuth: () => OAuth,
-  Service: () => Service,
-  Value: () => Value,
-  node: () => node
-});
-import { asc, desc, eq } from "drizzle-orm";
-import { Context, Effect, Layer, Schema } from "effect";
-import { Credential } from "@opencode-ai/schema/credential";
-import { Integration } from "@opencode-ai/schema/integration";
-import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-var ID = Credential.ID;
-var OAuth = Credential.OAuth;
-var Key = Credential.Key;
-var Value = Credential.Value;
-var Event = Credential.Event;
-
-class Info extends Schema.Class("Credential.Info")({
-  id: ID,
-  integrationID: Integration.ID,
-  label: Schema.String,
-  value: Value
-}) {
-}
-
-class Service extends Context.Service()("@opencode/Credential") {
-}
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const db = (yield* exports_database.Service).db;
-  const bus = yield* exports_bus.Service;
-  const decode = Schema.decodeUnknownSync(Value);
-  const stored = (row) => {
-    if (!row.integration_id)
-      return;
-    return new Info({
-      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 Service.of({
-    all: Effect.fn("Credential.all")(() => db.select().from(CredentialTable).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    list: Effect.fn("Credential.list")((integrationID) => db.select().from(CredentialTable).where(eq(CredentialTable.integration_id, integrationID)).orderBy(asc(CredentialTable.active), asc(CredentialTable.time_created), asc(CredentialTable.id)).all().pipe(Effect.orDie, Effect.map(storedRows))),
-    get: Effect.fn("Credential.get")(function* (id) {
-      const row = yield* db.select().from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      return row ? stored(row) : undefined;
-    }),
-    create: Effect.fn("Credential.create")(function* (input) {
-      const credential = new Info({
-        id: ID.create(),
-        integrationID: input.integrationID,
-        label: input.label ?? "default",
-        value: input.value
-      });
-      yield* db.transaction((tx) => Effect.gen(function* () {
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integrationID)).run();
-        yield* tx.insert(CredentialTable).values({
-          id: credential.id,
-          integration_id: credential.integrationID,
-          label: credential.label,
-          value: credential.value,
-          active: true
-        }).run();
-      })).pipe(Effect.orDie);
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      yield* bus.publish(Event.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(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential?.integration_id)
-          return;
-        const active = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (active?.id === id)
-          return;
-        yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-        yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, id)).run();
-        return credential.integration_id;
-      })).pipe(Effect.orDie);
-      if (integrationID)
-        yield* bus.publish(Event.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: CredentialTable.integration_id, label: CredentialTable.label }).from(CredentialTable).where(eq(CredentialTable.id, id)).get().pipe(Effect.orDie);
-      if (!credential?.integrationID)
-        return;
-      if (updates.label === credential.label && updates.value === undefined)
-        return;
-      yield* db.update(CredentialTable).set({ label: updates.label, value: updates.value }).where(eq(CredentialTable.id, id)).run().pipe(Effect.orDie);
-      if (updates.label !== undefined && updates.label !== credential.label)
-        yield* bus.publish(Event.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(CredentialTable).where(eq(CredentialTable.id, id)).get();
-        if (!credential)
-          return;
-        const active = credential.integration_id ? yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.active), desc(CredentialTable.time_created), desc(CredentialTable.id)).get() : undefined;
-        yield* tx.delete(CredentialTable).where(eq(CredentialTable.id, id)).run();
-        if (!credential.integration_id || active?.id !== id)
-          return { switched: false };
-        const replacement = yield* tx.select({ id: CredentialTable.id }).from(CredentialTable).where(eq(CredentialTable.integration_id, credential.integration_id)).orderBy(desc(CredentialTable.time_created), desc(CredentialTable.id)).get();
-        if (replacement) {
-          yield* tx.update(CredentialTable).set({ active: false }).where(eq(CredentialTable.integration_id, credential.integration_id)).run();
-          yield* tx.update(CredentialTable).set({ active: true }).where(eq(CredentialTable.id, replacement.id)).run();
-        }
-        return {
-          switched: true,
-          integrationID: credential.integration_id,
-          credentialID: replacement?.id ?? null
-        };
-      })).pipe(Effect.orDie);
-      if (!removed)
-        return;
-      yield* bus.publish(Event.Updated, {}, { global: true });
-      if (removed.switched)
-        yield* bus.publish(Event.Switched, { integrationID: removed.integrationID, credentialID: removed.credentialID }, { global: true });
-    })
-  });
-}));
-var node = makeGlobalNode({ service: Service, layer, deps: [exports_database.node, exports_bus.node] });
-
-export { ID, OAuth, Key, Value, Event, Info, Service, node, exports_credential };