@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-67ww7a6n.js

@@ -0,0 +1,585 @@
+import {
+  exports_form
+} from "./location-mutation-w6yb7hdq.js";
+import {
+  exports_state
+} from "./location-mutation-wt193r4g.js";
+import {
+  exports_credential
+} from "./location-mutation-xvc235nh.js";
+import {
+  exports_bus
+} from "./location-mutation-zz41wrms.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/integration.ts
+var exports_integration = {};
+__export(exports_integration, {
+  node: () => node,
+  Service: () => Service,
+  Ref: () => Ref,
+  OAuthMethod: () => OAuthMethod,
+  MethodID: () => MethodID,
+  Method: () => Method,
+  KeyMethod: () => KeyMethod,
+  Integration: () => exports_integration,
+  Info: () => Info,
+  ID: () => ID,
+  Event: () => Event,
+  EnvMethod: () => EnvMethod,
+  CommandMethod: () => CommandMethod,
+  CommandAttemptStatus: () => CommandAttemptStatus,
+  CommandAttempt: () => CommandAttempt,
+  CodeRequiredError: () => CodeRequiredError,
+  AuthorizationError: () => AuthorizationError,
+  AttemptStatus: () => AttemptStatus,
+  AttemptID: () => AttemptID,
+  Attempt: () => Attempt
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import {
+  Cause,
+  Clock,
+  Context,
+  Duration,
+  Effect,
+  Exit,
+  Fiber,
+  Layer,
+  Schedule,
+  Schema,
+  Scope,
+  Stream,
+  SynchronizedRef
+} from "effect";
+import { Integration } from "@opencode-ai/schema/integration";
+import { AppProcess } from "@opencode-ai/util/process";
+import { ChildProcess } from "effect/unstable/process";
+import { Event } from "@opencode-ai/schema/integration";
+var ID = Integration.ID;
+var MethodID = Integration.MethodID;
+var AttemptID = Integration.AttemptID;
+var OAuthMethod = Integration.OAuthMethod;
+var CommandMethod = Integration.CommandMethod;
+var KeyMethod = Integration.KeyMethod;
+var EnvMethod = Integration.EnvMethod;
+var Method = Integration.Method;
+var Info = Integration.Info;
+var Attempt = Integration.Attempt;
+var AttemptStatus = Integration.AttemptStatus;
+var CommandAttempt = Integration.CommandAttempt;
+var CommandAttemptStatus = Integration.CommandAttemptStatus;
+
+class CodeRequiredError extends Schema.TaggedErrorClass()("Integration.CodeRequired", {
+  attemptID: AttemptID
+}) {
+}
+
+class AuthorizationError extends Schema.TaggedErrorClass()("Integration.Authorization", {
+  cause: Schema.Defect()
+}) {
+}
+var Ref = Integration.Ref;
+
+class Service extends Context.Service()("@opencode/Integration") {
+}
+var attemptLifetime = Duration.toMillis(Duration.minutes(10));
+var terminalRetention = Duration.toMillis(Duration.minutes(1));
+var scrubInterval = Duration.seconds(30);
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const credentials = yield* exports_credential.Service;
+  const bus = yield* exports_bus.Service;
+  const processes = yield* AppProcess.Service;
+  const scope = yield* Scope.Scope;
+  const attempts = SynchronizedRef.makeUnsafe(new Map);
+  const commandAttempts = SynchronizedRef.makeUnsafe(new Map);
+  const state = exports_state.create({
+    name: "integration",
+    initial: () => ({ integrations: new Map }),
+    draft: (draft) => ({
+      list: () => Array.from(draft.integrations.values(), (entry) => entry.ref),
+      get: (id) => draft.integrations.get(id)?.ref,
+      update: (id, update) => {
+        const current = draft.integrations.get(id) ?? {
+          ref: { id, name: id },
+          methods: [],
+          implementations: new Map
+        };
+        if (!draft.integrations.has(id))
+          draft.integrations.set(id, current);
+        update(current.ref);
+        current.ref.id = id;
+      },
+      remove: (id) => draft.integrations.delete(id),
+      method: {
+        list: (integrationID) => draft.integrations.get(integrationID)?.methods ?? [],
+        update: (implementation) => {
+          const current = draft.integrations.get(implementation.integrationID) ?? {
+            ref: {
+              id: implementation.integrationID,
+              name: implementation.integrationID
+            },
+            methods: [],
+            implementations: new Map
+          };
+          if (!draft.integrations.has(implementation.integrationID)) {
+            draft.integrations.set(implementation.integrationID, current);
+          }
+          const index = current.methods.findIndex((method) => {
+            if (method.type !== implementation.method.type)
+              return false;
+            if (method.type === "oauth" && implementation.method.type === "oauth")
+              return method.id === implementation.method.id;
+            if (method.type === "command" && implementation.method.type === "command")
+              return method.id === implementation.method.id;
+            return true;
+          });
+          if (index === -1)
+            current.methods.push(implementation.method);
+          else
+            current.methods[index] = implementation.method;
+          if (implementation.method.type === "oauth") {
+            current.implementations.set(implementation.method.id, implementation);
+          }
+        },
+        remove: (integrationID, method) => {
+          const current = draft.integrations.get(integrationID);
+          if (!current)
+            return;
+          const index = current.methods.findIndex((candidate) => {
+            if (candidate.type !== method.type)
+              return false;
+            if (candidate.type === "oauth" && method.type === "oauth")
+              return candidate.id === method.id;
+            if (candidate.type === "command" && method.type === "command")
+              return candidate.id === method.id;
+            return true;
+          });
+          if (index !== -1)
+            current.methods.splice(index, 1);
+          if (method.type === "oauth")
+            current.implementations.delete(method.id);
+        }
+      }
+    }),
+    finalize: () => bus.publish(Integration.Event.Updated, {}).pipe(Effect.asVoid)
+  });
+  const resolveConnections = (entry, saved) => {
+    const credentials2 = saved.map((credential) => ({
+      type: "credential",
+      id: credential.id,
+      label: credential.label
+    })).toReversed();
+    const env = (entry?.methods ?? []).filter((method) => method.type === "env").flatMap((method) => method.names.filter((name) => process.env[name])).map((name) => ({ type: "env", name }));
+    return [...credentials2, ...env];
+  };
+  const project = (entry, connections) => Info.make({
+    id: entry.ref.id,
+    name: entry.ref.name,
+    methods: entry.methods,
+    connections
+  });
+  const authorize = (effect) => effect.pipe(Effect.mapError((cause) => new AuthorizationError({ cause })));
+  const close = (attemptScope) => Scope.close(attemptScope, Exit.void).pipe(Effect.forkIn(scope, { startImmediately: true }), Effect.asVoid);
+  const message = (cause) => {
+    const error = Cause.squash(cause);
+    return error instanceof Error ? error.message : String(error);
+  };
+  const settle = Effect.fnUntraced(function* (attemptID, exit) {
+    return yield* Effect.uninterruptible(Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+        const match = current.get(attemptID);
+        if (!match || match.status !== "pending" || match.persisting)
+          return [undefined, current];
+        const next = Exit.isSuccess(exit) ? { ...match, persisting: true } : {
+          status: "failed",
+          integrationID: match.integrationID,
+          message: message(exit.cause),
+          time: match.time,
+          removeAt: now + terminalRetention
+        };
+        return [match, new Map(current).set(attemptID, next)];
+      });
+      if (!attempt)
+        return;
+      if (Exit.isFailure(exit)) {
+        yield* close(attempt.scope);
+        return;
+      }
+      yield* Effect.gen(function* () {
+        const implementation = state.get().integrations.get(attempt.integrationID)?.implementations.get(attempt.methodID);
+        const persistence = yield* Effect.sync(() => attempt.label ?? implementation?.label?.(exit.value)).pipe(Effect.flatMap((label) => credentials.create({
+          integrationID: attempt.integrationID,
+          label,
+          value: exit.value
+        })), Effect.asVoid, Effect.exit);
+        const settledAt = yield* Clock.currentTimeMillis;
+        const terminal = Exit.isSuccess(persistence) ? {
+          status: "complete",
+          integrationID: attempt.integrationID,
+          time: attempt.time,
+          removeAt: settledAt + terminalRetention
+        } : {
+          status: "failed",
+          integrationID: attempt.integrationID,
+          message: message(persistence.cause),
+          time: attempt.time,
+          removeAt: settledAt + terminalRetention
+        };
+        yield* SynchronizedRef.update(attempts, (current) => new Map(current).set(attemptID, terminal));
+        if (Exit.isFailure(persistence))
+          yield* Effect.failCause(persistence.cause);
+        yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: attempt.integrationID });
+        yield* bus.publish(Integration.Event.Updated, {});
+      }).pipe(Effect.ensuring(close(attempt.scope)));
+    }));
+  });
+  const settleCommand = Effect.fnUntraced(function* (attemptID, exit) {
+    return yield* Effect.uninterruptible(Effect.gen(function* () {
+      const now = yield* Clock.currentTimeMillis;
+      const attempt = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+        const match = current.get(attemptID);
+        if (!match || match.status !== "pending" || match.persisting)
+          return [undefined, current];
+        const next = Exit.isSuccess(exit) ? { ...match, persisting: true } : {
+          status: "failed",
+          integrationID: match.integrationID,
+          message: message(exit.cause),
+          time: match.time,
+          removeAt: now + terminalRetention
+        };
+        return [match, new Map(current).set(attemptID, next)];
+      });
+      if (!attempt)
+        return;
+      if (Exit.isFailure(exit)) {
+        yield* close(attempt.scope);
+        return;
+      }
+      const persistence = yield* credentials.create({
+        integrationID: attempt.integrationID,
+        label: attempt.label,
+        value: exports_credential.Key.make({ type: "key", key: exit.value })
+      }).pipe(Effect.asVoid, Effect.exit);
+      const settledAt = yield* Clock.currentTimeMillis;
+      const terminal = Exit.isSuccess(persistence) ? {
+        status: "complete",
+        integrationID: attempt.integrationID,
+        time: attempt.time,
+        removeAt: settledAt + terminalRetention
+      } : {
+        status: "failed",
+        integrationID: attempt.integrationID,
+        message: message(persistence.cause),
+        time: attempt.time,
+        removeAt: settledAt + terminalRetention
+      };
+      yield* SynchronizedRef.update(commandAttempts, (current) => new Map(current).set(attemptID, terminal));
+      yield* close(attempt.scope);
+      if (Exit.isFailure(persistence))
+        return;
+      yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: attempt.integrationID });
+      yield* bus.publish(Integration.Event.Updated, {});
+    }));
+  });
+  const scrub = Effect.fnUntraced(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const expired = yield* SynchronizedRef.modify(attempts, (current) => {
+      const next = new Map(current);
+      const scopes = [];
+      for (const [id, attempt] of current) {
+        if (attempt.status === "pending" && !attempt.persisting && attempt.time.expires <= now) {
+          scopes.push(attempt.scope);
+          next.set(id, {
+            status: "expired",
+            integrationID: attempt.integrationID,
+            time: attempt.time,
+            removeAt: now + terminalRetention
+          });
+          continue;
+        }
+        if (attempt.status !== "pending" && attempt.removeAt <= now)
+          next.delete(id);
+      }
+      return [scopes, next];
+    });
+    yield* Effect.forEach(expired, close, { discard: true });
+  });
+  const scrubCommands = Effect.fnUntraced(function* () {
+    const now = yield* Clock.currentTimeMillis;
+    const expired = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+      const next = new Map(current);
+      const scopes = [];
+      for (const [id, attempt] of current) {
+        if (attempt.status === "pending" && !attempt.persisting && attempt.time.expires <= now) {
+          scopes.push(attempt.scope);
+          next.set(id, {
+            status: "expired",
+            integrationID: attempt.integrationID,
+            time: attempt.time,
+            removeAt: now + terminalRetention
+          });
+          continue;
+        }
+        if (attempt.status !== "pending" && attempt.removeAt <= now)
+          next.delete(id);
+      }
+      return [scopes, next];
+    });
+    yield* Effect.forEach(expired, close, { discard: true });
+  });
+  yield* scrub().pipe(Effect.repeat(Schedule.spaced(scrubInterval)), Effect.forkIn(scope));
+  yield* scrubCommands().pipe(Effect.repeat(Schedule.spaced(scrubInterval)), Effect.forkIn(scope));
+  const connectOAuth = Effect.fn("Integration.oauth.connect")(function* (input) {
+    const method = state.get().integrations.get(input.integrationID)?.implementations.get(input.methodID);
+    if (!method) {
+      return yield* Effect.die(new Error(`OAuth method not found: ${input.integrationID}/${input.methodID}`));
+    }
+    const answer = input.answer ?? {};
+    if (method.method.form) {
+      const invalid = exports_form.validateFields(method.method.form) ?? exports_form.validateAnswer(method.method.form, answer);
+      if (invalid)
+        return yield* new AuthorizationError({ cause: new Error(invalid) });
+    }
+    const attemptScope = yield* Scope.fork(scope);
+    const authorization = yield* authorize(method.authorize(answer)).pipe(Scope.provide(attemptScope), Effect.onExit((exit) => Exit.isFailure(exit) ? Scope.close(attemptScope, exit) : Effect.void));
+    const id = AttemptID.create();
+    const created = yield* Clock.currentTimeMillis;
+    const time = { created, expires: authorization.expiresAt ?? created + attemptLifetime };
+    yield* SynchronizedRef.update(attempts, (current) => new Map(current).set(id, {
+      status: "pending",
+      completing: authorization.mode === "auto",
+      persisting: false,
+      authorization,
+      integrationID: input.integrationID,
+      methodID: input.methodID,
+      label: input.label,
+      scope: attemptScope,
+      time
+    }));
+    if (authorization.mode === "auto") {
+      yield* authorization.callback.pipe(Effect.exit, Effect.flatMap((exit) => settle(id, exit)), Effect.forkIn(attemptScope, { startImmediately: true }));
+    }
+    return new Attempt({
+      attemptID: id,
+      url: authorization.url,
+      instructions: authorization.instructions,
+      mode: authorization.mode,
+      time
+    });
+  });
+  const connectCommand = Effect.fn("Integration.command.connect")(function* (input) {
+    const method = state.get().integrations.get(input.integrationID)?.methods.find((method2) => method2.type === "command" && method2.id === input.methodID);
+    if (!method || method.type !== "command" || !method.command[0]) {
+      return yield* Effect.die(new Error(`Command method not found: ${input.integrationID}/${input.methodID}`));
+    }
+    const attemptScope = yield* Scope.fork(scope);
+    const attemptID = AttemptID.create();
+    const created = yield* Clock.currentTimeMillis;
+    const time = { created, expires: created + attemptLifetime };
+    yield* SynchronizedRef.update(commandAttempts, (current) => new Map(current).set(attemptID, {
+      status: "pending",
+      integrationID: input.integrationID,
+      label: input.label,
+      persisting: false,
+      scope: attemptScope,
+      time
+    }));
+    yield* Effect.gen(function* () {
+      const handle = yield* processes.spawn(ChildProcess.make(method.command[0], method.command.slice(1), {
+        extendEnv: true,
+        stdin: "ignore"
+      }));
+      const stdout = yield* AppProcess.collectStream(handle.stdout, undefined).pipe(Effect.forkScoped);
+      yield* handle.stderr.pipe(Stream.decodeText, Stream.tap((chunk) => SynchronizedRef.update(commandAttempts, (current) => {
+        const attempt = current.get(attemptID);
+        if (!attempt || attempt.status !== "pending")
+          return current;
+        const message2 = (attempt.message ?? "") + chunk;
+        return new Map(current).set(attemptID, { ...attempt, message: message2 });
+      })), Stream.runDrain);
+      const exitCode = yield* handle.exitCode;
+      if (exitCode !== 0) {
+        const attempt = (yield* SynchronizedRef.get(commandAttempts)).get(attemptID);
+        return yield* Effect.fail(new Error(attempt?.message?.trim() || `Authentication command exited ${exitCode}`));
+      }
+      const credential = (yield* Fiber.join(stdout)).buffer.toString("utf8").trim();
+      if (!credential)
+        return yield* Effect.fail(new Error("Authentication command returned no credential"));
+      return credential;
+    }).pipe(Scope.provide(attemptScope), Effect.exit, Effect.flatMap((exit) => settleCommand(attemptID, exit)), Effect.forkIn(attemptScope, { startImmediately: true }));
+    return CommandAttempt.make({ attemptID, time });
+  });
+  return Service.of({
+    transform: state.transform,
+    reload: state.reload,
+    get: Effect.fn("Integration.get")(function* (id) {
+      const entry = state.get().integrations.get(id);
+      if (!entry)
+        return;
+      return project(entry, resolveConnections(entry, yield* credentials.list(id)));
+    }),
+    list: Effect.fn("Integration.list")(function* () {
+      const saved = Map.groupBy(yield* credentials.all(), (credential) => credential.integrationID);
+      return Array.from(state.get().integrations.values(), (entry) => project(entry, resolveConnections(entry, saved.get(entry.ref.id) ?? []))).toSorted((a, b) => a.name.localeCompare(b.name));
+    }),
+    connection: {
+      active: Effect.fn("Integration.connection.active")(function* (id) {
+        const entry = state.get().integrations.get(id);
+        return resolveConnections(entry, yield* credentials.list(id))[0];
+      }),
+      resolve: Effect.fn("Integration.connection.resolve")(function* (connection) {
+        if (connection.type === "env") {
+          const key = process.env[connection.name];
+          return key ? exports_credential.Key.make({ type: "key", key }) : undefined;
+        }
+        const credential = yield* credentials.get(connection.id);
+        if (!credential)
+          return;
+        if (credential.value.type === "key")
+          return credential.value;
+        const implementation = state.get().integrations.get(credential.integrationID)?.implementations.get(credential.value.methodID);
+        if (!implementation?.refresh)
+          return credential.value;
+        const now = yield* Clock.currentTimeMillis;
+        if (credential.value.expires > now + Duration.toMillis(Duration.minutes(5)))
+          return credential.value;
+        const value = yield* authorize(implementation.refresh(credential.value));
+        yield* credentials.update(credential.id, { value });
+        return value;
+      }),
+      key: Effect.fn("Integration.connection.key")(function* (input) {
+        const method = state.get().integrations.get(input.integrationID)?.methods.find((method2) => method2.type === "key");
+        if (!method)
+          return yield* Effect.die(new Error(`Key method not found: ${input.integrationID}`));
+        const answer = input.answer ?? {};
+        if (method.type === "key" && method.form) {
+          const invalid = exports_form.validateFields(method.form) ?? exports_form.validateAnswer(method.form, answer);
+          if (invalid)
+            return yield* new AuthorizationError({ cause: new Error(invalid) });
+        }
+        if (method.type === "key" && !method.form && Object.keys(answer).length > 0) {
+          return yield* new AuthorizationError({ cause: new Error("Key method does not accept a form answer") });
+        }
+        yield* credentials.create({
+          integrationID: input.integrationID,
+          label: input.label,
+          value: exports_credential.Key.make({
+            type: "key",
+            key: input.key,
+            ...Object.keys(answer).length > 0 ? { configuration: answer } : {}
+          })
+        });
+        yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: input.integrationID });
+        yield* bus.publish(Integration.Event.Updated, {});
+      }),
+      update: Effect.fn("Integration.connection.update")(function* (credentialID, updates) {
+        const credential = yield* credentials.get(credentialID);
+        yield* credentials.update(credentialID, updates);
+        if (credential) {
+          yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: credential.integrationID });
+        }
+        yield* bus.publish(Integration.Event.Updated, {});
+      }),
+      remove: Effect.fn("Integration.connection.remove")(function* (credentialID) {
+        const credential = yield* credentials.get(credentialID);
+        yield* credentials.remove(credentialID);
+        if (credential) {
+          yield* bus.publish(Integration.Event.ConnectionUpdated, { integrationID: credential.integrationID });
+        }
+        yield* bus.publish(Integration.Event.Updated, {});
+      })
+    },
+    oauth: {
+      connect: connectOAuth,
+      status: Effect.fn("Integration.oauth.status")(function* (input) {
+        const attempt = (yield* SynchronizedRef.get(attempts)).get(input.attemptID);
+        if (!attempt || attempt.integrationID !== input.integrationID)
+          return yield* Effect.die(new Error(`OAuth attempt not found: ${input.attemptID}`));
+        if (attempt.status === "failed") {
+          return { status: attempt.status, message: attempt.message ?? "Authorization failed", time: attempt.time };
+        }
+        return { status: attempt.status, time: attempt.time };
+      }),
+      complete: Effect.fn("Integration.oauth.complete")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID)
+            return [undefined, current];
+          if (match.status !== "pending" || match.completing)
+            return [match, current];
+          if (match.authorization.mode === "code" && input.code === undefined)
+            return [match, current];
+          return [match, new Map(current).set(input.attemptID, { ...match, completing: true })];
+        });
+        if (!attempt)
+          return yield* Effect.die(new Error(`OAuth attempt not found: ${input.attemptID}`));
+        if (attempt.status !== "pending")
+          return;
+        if (attempt.authorization.mode === "code" && input.code === undefined) {
+          return yield* new CodeRequiredError({ attemptID: input.attemptID });
+        }
+        if (attempt.completing)
+          return yield* Effect.die(new Error(`OAuth attempt already completing: ${input.attemptID}`));
+        const callback = attempt.authorization.mode === "auto" ? attempt.authorization.callback : attempt.authorization.callback(input.code);
+        const exit = yield* authorize(callback).pipe(Effect.exit);
+        yield* settle(input.attemptID, exit);
+        if (Exit.isFailure(exit))
+          return yield* exit;
+      }),
+      cancel: Effect.fn("Integration.oauth.cancel")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(attempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID || match.status !== "pending" || match.persisting)
+            return [undefined, current];
+          const next = new Map(current);
+          next.delete(input.attemptID);
+          return [match, next];
+        });
+        if (attempt)
+          yield* Scope.close(attempt.scope, Exit.void);
+      })
+    },
+    command: {
+      connect: connectCommand,
+      status: Effect.fn("Integration.command.status")(function* (input) {
+        const attempt = (yield* SynchronizedRef.get(commandAttempts)).get(input.attemptID);
+        if (!attempt || attempt.integrationID !== input.integrationID)
+          return yield* Effect.die(new Error(`Command attempt not found: ${input.attemptID}`));
+        if (attempt.status === "pending") {
+          return {
+            status: attempt.status,
+            ...attempt.message ? { message: attempt.message } : {},
+            time: attempt.time
+          };
+        }
+        if (attempt.status === "failed") {
+          return { status: attempt.status, message: attempt.message ?? "Authentication failed", time: attempt.time };
+        }
+        return { status: attempt.status, time: attempt.time };
+      }),
+      cancel: Effect.fn("Integration.command.cancel")(function* (input) {
+        const attempt = yield* SynchronizedRef.modify(commandAttempts, (current) => {
+          const match = current.get(input.attemptID);
+          if (!match || match.integrationID !== input.integrationID || match.status !== "pending" || match.persisting)
+            return [undefined, current];
+          const next = new Map(current);
+          next.delete(input.attemptID);
+          return [match, next];
+        });
+        if (attempt)
+          yield* Scope.close(attempt.scope, Exit.void);
+      })
+    }
+  });
+}));
+var node = makeLocationNode({
+  service: Service,
+  layer,
+  deps: [exports_credential.node, exports_bus.node, AppProcess.node]
+});
+
+export { ID, MethodID, AttemptID, OAuthMethod, CommandMethod, KeyMethod, EnvMethod, Method, Info, Attempt, AttemptStatus, CommandAttempt, CommandAttemptStatus, CodeRequiredError, AuthorizationError, Ref, Service, node, exports_integration, Event };

package/dist/chunks/location-mutation-69qrqpw0.js

@@ -0,0 +1,15 @@
+// src/database/migration/20260622142730_simplify_session_context_epoch.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260622142730_simplify_session_context_epoch",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`agent\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`replacement_seq\`;`);
+      yield* tx.run(`ALTER TABLE \`session_context_epoch\` DROP COLUMN \`revision\`;`);
+    });
+  }
+};
+var _20260622142730_simplify_session_context_epoch_default = migration;
+
+export { _20260622142730_simplify_session_context_epoch_default };