@opencode-ai/core 0.0.0-dev-18198 → 0.0.0-dev-18202

package/dist/chunks/{event-logger-j53rmh5t.js → location-activity-gh464jwx.js}

@@ -1,15 +1,15 @@
 import {
   exports_location
-} from "./event-logger-0rcvyp4a.js";
+} from "./location-activity-6881712a.js";
 import {
   exports_project
-} from "./event-logger-5nqnca1c.js";
+} from "./location-activity-b51wcekd.js";
 import {
   AbsolutePath
-} from "./event-logger-j07kk359.js";
+} from "./location-activity-j07kk359.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/location-mutation.ts
 var exports_location_mutation = {};

package/dist/chunks/{event-logger-15tdz33e.js → location-activity-gmttfvrv.js}

@@ -1,9 +1,9 @@
 import {
   exports_environment1 as exports_environment
-} from "./event-logger-vchntzt0.js";
+} from "./location-activity-h2zfj7w1.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/mcp/stdio.ts
 var exports_stdio = {};

package/dist/chunks/location-activity-gqn2zsfg.js

@@ -0,0 +1,429 @@
+// src/persistent-pty/daemon.ts
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+import { Data, Duration, Effect, Schema, Semaphore } from "effect";
+var ProtocolVersion = 6;
+var MaxFrameBytes = 8 * 1024 * 1024;
+var Lifecycle = Schema.Union([
+  Schema.Struct({ status: Schema.Literal("running") }),
+  Schema.Struct({ status: Schema.Literal("exited"), exit_code: Schema.NullOr(Schema.Number) }),
+  Schema.Struct({ status: Schema.Literal("failed"), message: Schema.String })
+]);
+var WireTerminal = Schema.Struct({
+  id: Schema.Number,
+  pid: Schema.NullOr(Schema.Number),
+  title: Schema.String,
+  foreground_process: Schema.NullOr(Schema.String),
+  group_id: Schema.String,
+  command: Schema.Array(Schema.String),
+  cwd: Schema.String,
+  cols: Schema.Number,
+  rows: Schema.Number,
+  lifecycle: Lifecycle,
+  output_head: Schema.Number,
+  output_tail: Schema.Number
+});
+var Registration = Schema.Struct({
+  instance_id: Schema.String,
+  pid: Schema.Number,
+  protocol: Schema.Number,
+  socket: Schema.String,
+  token: Schema.String
+});
+var WireResponse = Schema.Union([
+  Schema.Struct({
+    type: Schema.Literal("pong"),
+    instance_id: Schema.String,
+    pid: Schema.Number,
+    protocol: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("created"), terminal: WireTerminal }),
+  Schema.Struct({ type: Schema.Literal("terminals"), terminals: Schema.Array(WireTerminal) }),
+  Schema.Struct({ type: Schema.Literal("ok") }),
+  Schema.Struct({
+    type: Schema.Literal("snapshot"),
+    terminal: WireTerminal,
+    text: Schema.String,
+    checkpoint_base64: Schema.String,
+    cursor_x: Schema.Number,
+    cursor_y: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("attached"),
+    terminal: WireTerminal,
+    role: Schema.Literals(["controller", "observer"]),
+    generation: Schema.Number,
+    requested_offset: Schema.Number,
+    available_offset: Schema.Number,
+    end_offset: Schema.Number,
+    truncated: Schema.Boolean,
+    replay_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("resized"),
+    cols: Schema.Number,
+    rows: Schema.Number,
+    generation: Schema.Number,
+    checkpoint_base64: Schema.String
+  }),
+  Schema.Struct({
+    type: Schema.Literal("exited"),
+    exit_code: Schema.NullOr(Schema.Number),
+    final_offset: Schema.Number
+  }),
+  Schema.Struct({
+    type: Schema.Literal("controller_changed"),
+    attachment_id: Schema.NullOr(Schema.String),
+    generation: Schema.Number
+  }),
+  Schema.Struct({ type: Schema.Literal("title_changed"), title: Schema.String }),
+  Schema.Struct({ type: Schema.Literal("foreground_process_changed"), process: Schema.NullOr(Schema.String) }),
+  Schema.Struct({ type: Schema.Literal("error"), message: Schema.String })
+]);
+
+class DaemonError extends Data.TaggedError("PersistentPty.DaemonError") {
+}
+var makeDaemonTransport = Effect.fn("PersistentPty.makeDaemonTransport")(function* (directory, binary = () => Promise.resolve(process.env.OPENCODE_PTY_BIN || "opencode-pty")) {
+  const startup = Semaphore.makeUnsafe(1);
+  let registration;
+  const discover = Effect.fn("PersistentPty.daemon.discover")(function* () {
+    const value = yield* Effect.tryPromise({
+      try: () => readFile(path.join(directory, "service.json"), "utf8"),
+      catch: (cause) => failure("connect", cause)
+    });
+    const decoded = yield* Effect.try({
+      try: () => Schema.decodeUnknownSync(Registration)(JSON.parse(value)),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (decoded.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError({
+        kind: "protocol",
+        message: `opencode-pty protocol mismatch: daemon=${decoded.protocol}, client=${ProtocolVersion}`,
+        pid: decoded.pid
+      }));
+    const response = yield* oneShot(decoded, { op: "ping" });
+    if (response.type !== "pong" || response.instance_id !== decoded.instance_id || response.pid !== decoded.pid || response.protocol !== ProtocolVersion)
+      return yield* Effect.fail(new DaemonError({ kind: "protocol", message: "opencode-pty registration mismatch" }));
+    return decoded;
+  });
+  const start = Effect.fn("PersistentPty.daemon.start")(function* () {
+    const executable = yield* Effect.tryPromise({ try: binary, catch: (cause) => failure("spawn", cause) });
+    yield* Effect.tryPromise({
+      try: () => new Promise((resolve, reject) => {
+        const child = spawn(executable, ["daemon"], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, OPENCODE_PTY_RUNTIME_DIR: directory }
+        });
+        child.once("spawn", () => {
+          child.unref();
+          resolve();
+        });
+        child.once("error", reject);
+      }),
+      catch: (cause) => failure("spawn", cause)
+    });
+    const deadline = Date.now() + 5000;
+    let last;
+    while (Date.now() < deadline) {
+      const found = yield* discover().pipe(Effect.map((value) => ({ value })), Effect.catch((error) => {
+        last = error;
+        return Effect.succeed(undefined);
+      }));
+      if (found)
+        return found.value;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(last ?? new DaemonError({ kind: "connect", message: "opencode-pty did not become ready" }));
+  });
+  const connect = Effect.fn("PersistentPty.daemon.connect")(function* (shouldStart) {
+    if (registration)
+      return registration;
+    return yield* startup.withPermit(Effect.gen(function* () {
+      if (registration)
+        return registration;
+      const found = yield* discover().pipe(Effect.catch((error) => {
+        if (!shouldStart)
+          return Effect.fail(error);
+        if (error.kind === "connect")
+          return start();
+        if (error.kind !== "protocol" || error.pid === undefined)
+          return Effect.fail(error);
+        return terminate(error.pid).pipe(Effect.andThen(start()));
+      }));
+      registration = found;
+      return found;
+    }));
+  });
+  const attempt = Effect.fn("PersistentPty.daemon.request-attempt")(function* (value, shouldStart) {
+    const current = yield* connect(shouldStart);
+    return yield* oneShot(current, value).pipe(Effect.catch((error) => {
+      if (error.kind === "registration" && registration === current)
+        registration = undefined;
+      return Effect.fail(error);
+    }));
+  });
+  const request = Effect.fn("PersistentPty.daemon.request")(function* (value, shouldStart = false) {
+    return yield* attempt(value, shouldStart).pipe(Effect.catch((error) => {
+      if (error.kind === "registration")
+        return attempt(value, shouldStart);
+      if (error.kind !== "connect")
+        return Effect.fail(error);
+      registration = undefined;
+      if (!shouldStart)
+        return Effect.fail(error);
+      return attempt(value, true);
+    }));
+  });
+  const requestIfRunning = (value) => request(value).pipe(Effect.catch((error) => error.kind === "connect" ? Effect.succeed(undefined) : Effect.fail(error)));
+  const shutdown = Effect.gen(function* () {
+    const response = yield* requestIfRunning({ op: "shutdown" });
+    registration = undefined;
+    if (!response)
+      return;
+    const deadline = Date.now() + 5000;
+    while (Date.now() < deadline) {
+      const running = yield* discover().pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+      if (!running)
+        return response;
+      yield* Effect.sleep(50);
+    }
+    return yield* Effect.fail(new DaemonError({ kind: "connect", message: "opencode-pty did not stop" }));
+  });
+  const subscribe = Effect.fn("PersistentPty.daemon.subscribe")(function* (id, input) {
+    const attempt2 = Effect.gen(function* () {
+      const current = yield* connect(false);
+      return yield* Effect.tryPromise({
+        try: () => subscribePromise(current, id, input),
+        catch: (cause) => cause instanceof DaemonError ? cause : failure("connect", cause)
+      }).pipe(Effect.catch((error) => {
+        if (error.kind === "registration" && registration === current)
+          registration = undefined;
+        return Effect.fail(error);
+      }));
+    });
+    return yield* attempt2.pipe(Effect.catch((error) => error.kind === "registration" ? attempt2 : Effect.fail(error)));
+  });
+  return { request, requestIfRunning, shutdown, subscribe };
+});
+var oneShot = Effect.fn("PersistentPty.daemon.oneShot")(function* (registration, request) {
+  const payload = yield* Effect.try({
+    try: () => encode({ token: registration.token, request }),
+    catch: (cause) => failure("protocol", cause)
+  });
+  let dispatched = false;
+  return yield* Effect.acquireUseRelease(Effect.tryPromise({
+    try: (signal) => new Promise((resolve, reject) => {
+      const socket = net.createConnection({ path: registration.socket, signal });
+      socket.once("connect", () => resolve(socket));
+      socket.once("error", reject);
+    }),
+    catch: (cause) => failure("connect", cause)
+  }), (socket) => Effect.gen(function* () {
+    yield* Effect.try({
+      try: () => {
+        dispatched = true;
+        socket.write(payload);
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const first = yield* Effect.tryPromise({
+      try: async (signal) => {
+        const frames = decoder(socket);
+        const abort = () => socket.destroy();
+        signal.addEventListener("abort", abort, { once: true });
+        try {
+          const frame = await frames.next();
+          if (frame.done)
+            throw new Error("opencode-pty closed without response");
+          return frame.value;
+        } finally {
+          signal.removeEventListener("abort", abort);
+        }
+      },
+      catch: (cause) => failure("response", cause)
+    });
+    const response = yield* Effect.try({
+      try: () => decode(first),
+      catch: (cause) => failure("protocol", cause)
+    });
+    if (response.type === "error")
+      return yield* Effect.fail(new DaemonError({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      }));
+    return response;
+  }), (socket) => Effect.sync(() => socket.destroy())).pipe(Effect.timeoutOrElse({
+    duration: Duration.seconds(5),
+    orElse: () => Effect.fail(new DaemonError({
+      kind: dispatched ? "response" : "connect",
+      message: "opencode-pty request timed out"
+    }))
+  }));
+});
+async function subscribePromise(registration, id, input) {
+  const socket = net.createConnection(registration.socket);
+  const frames = decoder(socket);
+  try {
+    await new Promise((resolve, reject) => {
+      socket.once("connect", resolve);
+      socket.once("error", reject);
+    });
+    socket.write(encode({
+      token: registration.token,
+      request: {
+        op: "subscribe",
+        id,
+        offset: input.cursor,
+        attachment_id: input.attachmentID,
+        role: input.role,
+        takeover: input.takeover ?? false
+      }
+    }));
+    const initial = await frames.next();
+    if (initial.done)
+      throw new Error("opencode-pty closed before attachment");
+    const response = decode(initial.value);
+    if (response.type === "error")
+      throw new DaemonError({
+        kind: response.message === "authentication failed" ? "registration" : "protocol",
+        message: response.message
+      });
+    if (response.type !== "attached")
+      throw new Error(`unexpected opencode-pty response: ${response.type}`);
+    let detached = false;
+    const pump = async () => {
+      try {
+        for await (const frame of frames) {
+          if (frame[0] === 0) {
+            if (frame.length < 17)
+              throw new Error("invalid opencode-pty output frame");
+            input.onEvent({
+              type: "output",
+              start: Number(frame.readBigUInt64BE(1)),
+              end: Number(frame.readBigUInt64BE(9)),
+              data: frame.subarray(17)
+            });
+            continue;
+          }
+          const event = decode(frame);
+          if (event.type === "resized")
+            input.onEvent({
+              type: "resized",
+              cols: event.cols,
+              rows: event.rows,
+              generation: event.generation,
+              checkpoint: Buffer.from(event.checkpoint_base64, "base64")
+            });
+          if (event.type === "controller_changed")
+            input.onEvent({
+              type: "controller_changed",
+              attachmentID: event.attachment_id ?? undefined,
+              generation: event.generation
+            });
+          if (event.type === "title_changed")
+            input.onEvent({ type: "title_changed", title: event.title });
+          if (event.type === "foreground_process_changed")
+            input.onEvent({ type: "foreground_process_changed", process: event.process });
+          if (event.type === "exited") {
+            input.onEvent({
+              type: "exited",
+              exitCode: event.exit_code ?? undefined,
+              finalOffset: event.final_offset
+            });
+            return;
+          }
+        }
+      } finally {
+        if (!detached)
+          input.onEnd();
+      }
+    };
+    let activated = false;
+    return {
+      terminal: response.terminal,
+      role: response.role,
+      generation: response.generation,
+      replay: {
+        requestedOffset: response.requested_offset,
+        availableOffset: response.available_offset,
+        endOffset: response.end_offset,
+        truncated: response.truncated,
+        data: Buffer.from(response.replay_base64, "base64")
+      },
+      activate() {
+        if (activated || detached)
+          return;
+        activated = true;
+        pump().catch(() => {});
+      },
+      detach() {
+        if (detached)
+          return;
+        detached = true;
+        socket.destroy();
+      }
+    };
+  } catch (error) {
+    socket.destroy();
+    throw error;
+  }
+}
+function encode(value) {
+  const payload = Buffer.from(JSON.stringify(value));
+  if (payload.length > MaxFrameBytes)
+    throw new Error("opencode-pty frame too large");
+  const output = Buffer.allocUnsafe(payload.length + 4);
+  output.writeUInt32BE(payload.length);
+  payload.copy(output, 4);
+  return output;
+}
+async function* decoder(socket) {
+  let pending = Buffer.alloc(0);
+  for await (const value of socket) {
+    const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+    pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+    while (pending.length >= 4) {
+      const length = pending.readUInt32BE(0);
+      if (length > MaxFrameBytes)
+        throw new Error("opencode-pty frame too large");
+      if (pending.length < length + 4)
+        break;
+      yield pending.subarray(4, length + 4);
+      pending = pending.subarray(length + 4);
+    }
+  }
+  if (pending.length !== 0)
+    throw new Error("opencode-pty truncated frame");
+}
+function decode(payload) {
+  return Schema.decodeUnknownSync(WireResponse)(JSON.parse(Buffer.from(payload).toString("utf8")));
+}
+function failure(kind, cause) {
+  return new DaemonError({ kind, message: cause instanceof Error ? cause.message : String(cause) });
+}
+var terminate = Effect.fn("PersistentPty.daemon.terminate-incompatible")(function* (pid) {
+  yield* Effect.logWarning("replacing incompatible opencode-pty daemon", { pid });
+  yield* Effect.try({ try: () => process.kill(pid, "SIGTERM"), catch: (cause) => failure("spawn", cause) }).pipe(Effect.catch((error) => isMissingProcess(error) ? Effect.void : Effect.fail(error)));
+  const deadline = Date.now() + 2000;
+  while (Date.now() < deadline && processRunning(pid))
+    yield* Effect.sleep(25);
+  if (!processRunning(pid))
+    return;
+  yield* Effect.try({ try: () => process.kill(pid, "SIGKILL"), catch: (cause) => failure("spawn", cause) }).pipe(Effect.catch((error) => isMissingProcess(error) ? Effect.void : Effect.fail(error)));
+});
+function processRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isMissingProcess(error) {
+  return error.message.includes("ESRCH") || error.message.includes("no such process");
+}
+
+export { WireTerminal, WireResponse, DaemonError, makeDaemonTransport };

package/dist/chunks/{event-logger-vchntzt0.js → location-activity-h2zfj7w1.js}

@@ -1,27 +1,27 @@
 import {
   makeLocalDriver
-} from "./event-logger-zxe9jjhn.js";
+} from "./location-activity-zxe9jjhn.js";
 import {
   makeMemoryDriver
-} from "./event-logger-yf0knd5z.js";
+} from "./location-activity-yf0knd5z.js";
 import {
   execDefaults
-} from "./event-logger-3g8vftxb.js";
+} from "./location-activity-3g8vftxb.js";
 import {
   Failed,
   NotFound,
   WrongKind,
   typeFollowing
-} from "./event-logger-xczfw7dq.js";
+} from "./location-activity-xczfw7dq.js";
 import {
   exports_workspace
-} from "./event-logger-tzkxcjh0.js";
+} from "./location-activity-p9js2tea.js";
 import {
   exports_location
-} from "./event-logger-0rcvyp4a.js";
+} from "./location-activity-6881712a.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/environment/environment.ts
 var exports_environment2 = {};

package/dist/chunks/{event-logger-p2dn98px.js → location-activity-hhmrdrdy.js}

@@ -1,18 +1,18 @@
 import {
   exports_store
-} from "./event-logger-t6dw1t76.js";
+} from "./location-activity-cf0spt3s.js";
 import {
   SessionEvent
-} from "./event-logger-a83yvq99.js";
+} from "./location-activity-a83yvq99.js";
 import {
   exports_location
-} from "./event-logger-0rcvyp4a.js";
+} from "./location-activity-6881712a.js";
 import {
   exports_bus
-} from "./event-logger-kz7trtnm.js";
+} from "./location-activity-s66wndr8.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/session/instructions.ts
 var exports_instructions = {};

package/dist/chunks/{event-logger-hhxt27np.js → location-activity-hhxt27np.js}

@@ -1,9 +1,9 @@
 import {
   exports_provider
-} from "./event-logger-djkt4gex.js";
+} from "./location-activity-djkt4gex.js";
 import {
   __require
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/plugin/provider/amazon-bedrock.ts
 import { Effect } from "effect";

package/dist/chunks/{event-logger-hp6rpdnc.js → location-activity-hp6rpdnc.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/file-retention.ts
 var exports_file_retention = {};

package/dist/chunks/{event-logger-v8agn3a5.js → location-activity-hpya0egq.js}

@@ -1,15 +1,15 @@
 import {
   exports_mcp
-} from "./event-logger-t2xjsfv5.js";
+} from "./location-activity-q5x0t4qj.js";
 import {
   exports_location
-} from "./event-logger-0rcvyp4a.js";
+} from "./location-activity-6881712a.js";
 import {
   exports_bus
-} from "./event-logger-kz7trtnm.js";
+} from "./location-activity-s66wndr8.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/plugin/command.ts
 var exports_command = {};

package/dist/chunks/{event-logger-hqh8yks9.js → location-activity-hqh8yks9.js}

@@ -1,13 +1,13 @@
 import {
   DirectoryUnavailableError,
   canonical
-} from "./event-logger-mnb85w6b.js";
+} from "./location-activity-mnb85w6b.js";
 import {
   exports_git
-} from "./event-logger-se1aqaya.js";
+} from "./location-activity-se1aqaya.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/worktree/git.ts
 var exports_git2 = {};

package/dist/chunks/{event-logger-hsyk7kfz.js → location-activity-hsyk7kfz.js}

@@ -1,11 +1,11 @@
 import {
   buildSQLiteMigrationBackfillStatements,
   prepareSQLiteMigrationBackfill
-} from "./event-logger-4zg0gww9.js";
+} from "./location-activity-4zg0gww9.js";
 import {
   GET_VERSION_FOR,
   MIGRATIONS_TABLE_VERSIONS
-} from "./event-logger-f84sxdqn.js";
+} from "./location-activity-f84sxdqn.js";
 
 // src/database/drizzle/up-migrations/effect-sqlite.ts
 import * as Effect from "effect/Effect";

package/dist/chunks/{event-logger-z8z35ztk.js → location-activity-hycpe58n.js}

@@ -1,12 +1,12 @@
 import {
   exports_mcp
-} from "./event-logger-t2xjsfv5.js";
+} from "./location-activity-q5x0t4qj.js";
 import {
   exports_config
-} from "./event-logger-w391sh6k.js";
+} from "./location-activity-ts1p36t0.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/config/plugin/mcp.ts
 var exports_mcp2 = {};

package/dist/chunks/{event-logger-9zg1qdvw.js → location-activity-j25sw0mt.js}

@@ -1,28 +1,28 @@
+import {
+  exports_agent
+} from "./location-activity-trd9da3a.js";
 import {
   SessionSchema
-} from "./event-logger-bjwj8hwv.js";
+} from "./location-activity-bjwj8hwv.js";
 import {
-  exports_agent
-} from "./event-logger-7zmypx6g.js";
+  exports_model
+} from "./location-activity-1a3a2s70.js";
+import {
+  exports_provider
+} from "./location-activity-djkt4gex.js";
 import {
   exports_workspace
-} from "./event-logger-tzkxcjh0.js";
+} from "./location-activity-p9js2tea.js";
 import {
   exports_location
-} from "./event-logger-0rcvyp4a.js";
+} from "./location-activity-6881712a.js";
 import {
   exports_project
-} from "./event-logger-5nqnca1c.js";
-import {
-  exports_model
-} from "./event-logger-1a3a2s70.js";
-import {
-  exports_provider
-} from "./event-logger-djkt4gex.js";
+} from "./location-activity-b51wcekd.js";
 import {
   AbsolutePath,
   RelativePath
-} from "./event-logger-j07kk359.js";
+} from "./location-activity-j07kk359.js";
 
 // src/session/info.ts
 import { DateTime, Schema } from "effect";

package/dist/chunks/{event-logger-j2rwtkhe.js → location-activity-j2rwtkhe.js}

@@ -1,15 +1,15 @@
 import {
   exports_repository
-} from "./event-logger-y198y2ra.js";
+} from "./location-activity-y198y2ra.js";
 import {
   exports_git
-} from "./event-logger-se1aqaya.js";
+} from "./location-activity-se1aqaya.js";
 import {
   AbsolutePath
-} from "./event-logger-j07kk359.js";
+} from "./location-activity-j07kk359.js";
 import {
   __export
-} from "./event-logger-rvfvac9x.js";
+} from "./location-activity-rvfvac9x.js";
 
 // src/repository-cache.ts
 var exports_repository_cache = {};