@opencode-ai/core 0.0.0-beta-19086 → 0.0.0-beta-19124

package/dist/chunks/{schema-h650edej.js → event-logger-9m7v4qnm.js}

@@ -1,57 +1,58 @@
 import {
-  exports_mime
-} from "./schema-kq3q54gz.js";
+  NonNegativeInt2,
+  PositiveInt2,
+  RelativePath2
+} from "./event-logger-p8qxwesx.js";
 import {
-  exports_filesystem
-} from "./schema-s5c7wyma.js";
+  Service65,
+  node69
+} from "./event-logger-22drdanb.js";
 import {
-  exports_environment1 as exports_environment
-} from "./schema-qa1y9c59.js";
+  Content2
+} from "./event-logger-7vg7b77p.js";
 import {
-  NonNegativeInt,
-  PositiveInt,
-  RelativePath
-} from "./schema-j07kk359.js";
+  detect2
+} from "./event-logger-3smtnn6g.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/read-filesystem.ts
 var exports_read_filesystem = {};
 __export(exports_read_filesystem, {
-  BinaryFileError: () => BinaryFileError,
-  FileContent: () => FileContent,
-  ListEntry: () => ListEntry,
-  ListPage: () => ListPage,
-  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES,
-  MAX_READ_BYTES: () => MAX_READ_BYTES,
-  MAX_READ_LINES: () => MAX_READ_LINES,
-  MEDIA_MIMES: () => MEDIA_MIMES,
-  MediaIngestLimitError: () => MediaIngestLimitError,
-  OffsetOutOfRangeError: () => OffsetOutOfRangeError,
-  PageInput: () => PageInput,
-  PathKindError: () => PathKindError,
+  BinaryFileError: () => BinaryFileError2,
+  FileContent: () => FileContent2,
+  ListEntry: () => ListEntry2,
+  ListPage: () => ListPage2,
+  MAX_MEDIA_INGEST_BYTES: () => MAX_MEDIA_INGEST_BYTES2,
+  MAX_READ_BYTES: () => MAX_READ_BYTES2,
+  MAX_READ_LINES: () => MAX_READ_LINES2,
+  MEDIA_MIMES: () => MEDIA_MIMES2,
+  MediaIngestLimitError: () => MediaIngestLimitError2,
+  OffsetOutOfRangeError: () => OffsetOutOfRangeError2,
+  PageInput: () => PageInput2,
+  PathKindError: () => PathKindError2,
   ReadToolFileSystem: () => exports_read_filesystem,
-  Service: () => Service,
-  TextPage: () => TextPage,
-  node: () => node,
-  read: () => read
+  Service: () => Service7,
+  TextPage: () => TextPage2,
+  node: () => node10,
+  read: () => read2
 });
 import path from "path";
 import { pathToFileURL } from "url";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
 import { Context, Effect, Layer, Schema } from "effect";
 import { lookup } from "mime-types";
-var MAX_READ_LINES = 2000;
-var MAX_READ_BYTES = 50 * 1024;
-var MAX_MEDIA_INGEST_BYTES = 20 * 1024 * 1024;
+var MAX_READ_LINES2 = 2000;
+var MAX_READ_BYTES2 = 50 * 1024;
+var MAX_MEDIA_INGEST_BYTES2 = 20 * 1024 * 1024;
 var FIRST_CHUNK = 256 * 1024;
 var MAX_LINE_LENGTH = 2000;
 var TREE_BASE = 6;
 var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
-var MEDIA_MIMES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
+var MEDIA_MIMES2 = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "application/pdf"]);
 
-class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
+class BinaryFileError2 extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   resource: Schema.String
 }) {
   get message() {
@@ -59,7 +60,7 @@ class BinaryFileError extends Schema.TaggedError()("ReadTool.BinaryFileError", {
   }
 }
 
-class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
+class MediaIngestLimitError2 extends Schema.TaggedError()("ReadTool.MediaIngestLimitError", {
   resource: Schema.String,
   maximumBytes: Schema.Number
 }) {
@@ -68,13 +69,13 @@ class MediaIngestLimitError extends Schema.TaggedError()("ReadTool.MediaIngestLi
   }
 }
 
-class OffsetOutOfRangeError extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
+class OffsetOutOfRangeError2 extends Schema.TaggedError()("ReadTool.OffsetOutOfRangeError", { offset: Schema.Number }) {
   get message() {
     return `Offset ${this.offset} is out of range`;
   }
 }
 
-class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
+class PathKindError2 extends Schema.TaggedError()("ReadTool.PathKindError", {
   resource: Schema.String,
   expected: Schema.Literals(["a file", "a file or directory"])
 }) {
@@ -82,52 +83,52 @@ class PathKindError extends Schema.TaggedError()("ReadTool.PathKindError", {
     return `Path is not ${this.expected}: ${this.resource}`;
   }
 }
-var PageInput = Schema.Struct({
-  offset: Schema.optionalKey(NonNegativeInt),
-  limit: Schema.optionalKey(NonNegativeInt.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES)))
+var PageInput2 = Schema.Struct({
+  offset: Schema.optionalKey(NonNegativeInt2),
+  limit: Schema.optionalKey(NonNegativeInt2.check(Schema.isLessThanOrEqualTo(MAX_READ_LINES2)))
 });
-var FileContent = Schema.Struct({
+var FileContent2 = Schema.Struct({
   type: Schema.Literal("file"),
-  ...exports_filesystem.Content.fields
+  ...Content2.fields
 }).annotate({ identifier: "ReadTool.FileContent" });
 
-class TextPage extends Schema.Class("ReadTool.TextPage")({
+class TextPage2 extends Schema.Class("ReadTool.TextPage")({
   type: Schema.Literal("text-page"),
   content: Schema.String,
   mime: Schema.String,
-  offset: PositiveInt,
+  offset: PositiveInt2,
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
-var ListEntry = Schema.Struct({
-  path: RelativePath,
+var ListEntry2 = Schema.Struct({
+  path: RelativePath2,
   type: Schema.Literals(["file", "directory", "symlink"])
 }).annotate({ identifier: "ReadTool.ListEntry" });
 
-class ListPage extends Schema.Class("ReadTool.ListPage")({
+class ListPage2 extends Schema.Class("ReadTool.ListPage")({
   type: Schema.Literal("list-page"),
-  entries: Schema.Array(ListEntry),
+  entries: Schema.Array(ListEntry2),
   truncated: Schema.Boolean,
-  next: Schema.optionalKey(PositiveInt)
+  next: Schema.optionalKey(PositiveInt2)
 }) {
 }
 
-class Service extends Context.Service()("@opencode/ReadToolFileSystem") {
+class Service7 extends Context.Service()("@opencode/ReadToolFileSystem") {
 }
 var mimeType = (value) => lookup(value) || "application/octet-stream";
-var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
+var read2 = Effect.fn("ReadTool.read")(function* (files, input, resource, page = {}) {
   const first = yield* files.read(input, { offset: 0, length: FIRST_CHUNK }).pipe(Effect.catchTag("Environment.WrongKind", (error) => {
     if (error.actual !== "directory")
-      return Effect.fail(new PathKindError({ resource, expected: "a file or directory" }));
-    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file or directory" }))));
+      return Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }));
+    return files.list(input).pipe(Effect.map((entries) => list(entries, page)), Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file or directory" }))));
   }));
-  if (first instanceof ListPage)
+  if (first instanceof ListPage2)
     return first;
-  const media = exports_mime.detect(first.bytes);
-  if (MEDIA_MIMES.has(media)) {
-    if (first.info.size > MAX_MEDIA_INGEST_BYTES)
-      return yield* new MediaIngestLimitError({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES });
+  const media = detect2(first.bytes);
+  if (MEDIA_MIMES2.has(media)) {
+    if (first.info.size > MAX_MEDIA_INGEST_BYTES2)
+      return yield* new MediaIngestLimitError2({ resource, maximumBytes: MAX_MEDIA_INGEST_BYTES2 });
     const whole = yield* readFile(files, input, resource);
     return {
       type: "file",
@@ -138,10 +139,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       mime: media
     };
   }
-  const paged = first.info.size > MAX_READ_BYTES || page.offset !== undefined || page.limit !== undefined;
+  const paged = first.info.size > MAX_READ_BYTES2 || page.offset !== undefined || page.limit !== undefined;
   if (!paged) {
     if (first.bytes.includes(0))
-      return yield* new BinaryFileError({ resource });
+      return yield* new BinaryFileError2({ resource });
     return {
       type: "file",
       uri: pathToFileURL(input).href,
@@ -158,7 +159,7 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     return yield* makeTextPage(input, resource, result, first.bytes.subarray(0, result.consumed).includes(0));
   }
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const leaves = [textLeaf(first.bytes)];
   let bytes = first.bytes.length;
   let lines = leaves[0].summary.lines;
@@ -169,12 +170,12 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
       const tree = textTree(leaves);
       const start = textOffset(tree, offset - 1);
       let position = 0;
-      const selected = Buffer.concat(leaves.flatMap((leaf2) => {
+      const selected = Buffer.concat(leaves.flatMap((leaf) => {
         const leafStart = position;
-        position += leaf2.summary.bytes;
+        position += leaf.summary.bytes;
         if (position <= start)
           return [];
-        return [leaf2.bytes.subarray(Math.max(0, start - leafStart))];
+        return [leaf.bytes.subarray(Math.max(0, start - leafStart))];
       }));
       const result = textPage(selected, eof, { limit });
       if (result !== undefined) {
@@ -185,10 +186,10 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
         };
         const consumed = start + result.consumed;
         let checked = 0;
-        const binary = leaves.some((leaf2) => {
-          const length = Math.min(leaf2.summary.bytes, consumed - checked);
-          checked += leaf2.summary.bytes;
-          return length > 0 && leaf2.bytes.subarray(0, length).includes(0);
+        const binary = leaves.some((leaf) => {
+          const length = Math.min(leaf.summary.bytes, consumed - checked);
+          checked += leaf.summary.bytes;
+          return length > 0 && leaf.bytes.subarray(0, length).includes(0);
         });
         return yield* makeTextPage(input, resource, translated, binary);
       }
@@ -204,13 +205,13 @@ var read = Effect.fn("ReadTool.read")(function* (files, input, resource, page =
     lines += leaf.summary.lines;
   }
 });
-var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError({ resource, expected: "a file" }))));
+var readFile = (files, input, resource, range) => files.read(input, range).pipe(Effect.catchTag("Environment.WrongKind", () => Effect.fail(new PathKindError2({ resource, expected: "a file" }))));
 var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary) {
   if (binary)
-    return yield* new BinaryFileError({ resource });
+    return yield* new BinaryFileError2({ resource });
   if (result.entries.length === 0 && result.offset !== 1)
-    return yield* new OffsetOutOfRangeError({ offset: result.offset });
-  return new TextPage({
+    return yield* new OffsetOutOfRangeError2({ offset: result.offset });
+  return new TextPage2({
     type: "text-page",
     content: result.entries.join(`
 `),
@@ -222,16 +223,16 @@ var makeTextPage = Effect.fnUntraced(function* (input, resource, result, binary)
 });
 var list = (items, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const visible = items.flatMap((item) => item.type === "other" ? [] : [
-    ListEntry.make({
-      path: RelativePath.make(item.name + (item.type === "directory" ? path.sep : "")),
+    ListEntry2.make({
+      path: RelativePath2.make(item.name + (item.type === "directory" ? path.sep : "")),
       type: item.type
     })
   ]).sort((a, b) => a.type === "directory" ? b.type === "directory" ? a.path.localeCompare(b.path) : -1 : b.type === "directory" ? 1 : a.path.localeCompare(b.path));
   const selected = visible.slice(offset - 1, offset - 1 + limit);
   const truncated = offset - 1 + selected.length < visible.length;
-  return new ListPage({
+  return new ListPage2({
     type: "list-page",
     entries: selected,
     truncated,
@@ -240,7 +241,7 @@ var list = (items, page) => {
 };
 var textPage = (bytes, eof, page) => {
   const offset = page.offset || 1;
-  const limit = Math.min(page.limit || MAX_READ_LINES, MAX_READ_LINES);
+  const limit = Math.min(page.limit || MAX_READ_LINES2, MAX_READ_LINES2);
   const decoded = new TextDecoder().decode(bytes);
   const split = decoded.split(`
 `);
@@ -251,13 +252,13 @@ var textPage = (bytes, eof, page) => {
   let next;
   for (const [index, value] of available.slice(offset - 1).entries()) {
     const line = offset + index;
-    if (entries.length >= limit || size >= MAX_READ_BYTES) {
+    if (entries.length >= limit || size >= MAX_READ_BYTES2) {
       next = line;
       break;
     }
     const text = value.length > MAX_LINE_LENGTH ? value.slice(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX : value;
     const lineSize = Buffer.byteLength(text, "utf-8") + (entries.length > 0 ? 1 : 0);
-    if (size + lineSize > MAX_READ_BYTES) {
+    if (size + lineSize > MAX_READ_BYTES2) {
       next = line;
       break;
     }
@@ -325,13 +326,13 @@ var nthNewline = (bytes, count) => {
       return index + 1;
   }
 };
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const environment = yield* exports_environment.Service;
-  return Service.of({
+var layer = Layer.effect(Service7, Effect.gen(function* () {
+  const environment = yield* Service65;
+  return Service7.of({
     list: environment.files.list,
-    read: (path2, resource, page) => read(environment.files, path2, resource, page)
+    read: (path2, resource, page) => read2(environment.files, path2, resource, page)
   });
 }));
-var node = makeLocationNode({ service: Service, layer, deps: [exports_environment.node] });
+var node10 = makeLocationNode({ service: Service7, layer, deps: [node69] });
 
-export { MAX_READ_LINES, MAX_READ_BYTES, MAX_MEDIA_INGEST_BYTES, MEDIA_MIMES, BinaryFileError, MediaIngestLimitError, OffsetOutOfRangeError, PathKindError, PageInput, FileContent, TextPage, ListEntry, ListPage, Service, read, node, exports_read_filesystem };
+export { MAX_READ_LINES2, MAX_READ_BYTES2, MAX_MEDIA_INGEST_BYTES2, MEDIA_MIMES2, BinaryFileError2, MediaIngestLimitError2, OffsetOutOfRangeError2, PathKindError2, PageInput2, FileContent2, TextPage2, ListEntry2, ListPage2, Service7, read2, node10, exports_read_filesystem };

package/dist/chunks/event-logger-9qm9egsn.js

@@ -0,0 +1,41 @@
+import {
+  absoluteColumn2,
+  absoluteArrayColumn2
+} from "./event-logger-r8dhm0tv.js";
+import {
+  Timestamps2
+} from "./event-logger-qfa1cgps.js";
+
+// src/project/sql.ts
+import { isNotNull, isNull, ne, or } from "drizzle-orm";
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+var ProjectTable2 = sqliteTable("project", {
+  id: text().$type().primaryKey(),
+  worktree: absoluteColumn2().notNull(),
+  vcs: text().$type(),
+  name: text(),
+  icon_url: text(),
+  icon_url_override: text(),
+  icon_color: text(),
+  ...Timestamps2,
+  time_initialized: integer(),
+  sandboxes: absoluteArrayColumn2().notNull(),
+  commands: text({ mode: "json" }).$type()
+});
+var ProjectDirectoryTable2 = sqliteTable("project_directory", {
+  project_id: text().$type().notNull().references(() => ProjectTable2.id, { onDelete: "cascade" }),
+  directory: absoluteColumn2().notNull(),
+  type: text().$type(),
+  strategy: text(),
+  time_created: integer().notNull().$default(() => Date.now())
+}, (table) => [primaryKey({ columns: [table.project_id, table.directory] })]);
+function upsertProject2(db, project) {
+  const vcs = project.vcs?.type;
+  return db.insert(ProjectTable2).values({ id: project.id, worktree: project.canonical, vcs, sandboxes: [] }).onConflictDoUpdate({
+    target: ProjectTable2.id,
+    set: { vcs: vcs ?? null },
+    setWhere: vcs ? or(isNull(ProjectTable2.vcs), ne(ProjectTable2.vcs, vcs)) : isNotNull(ProjectTable2.vcs)
+  }).run();
+}
+
+export { ProjectTable2, ProjectDirectoryTable2, upsertProject2 };

package/dist/chunks/{schema-e7nnc03a.js → event-logger-9r3tzwf8.js}

@@ -1,43 +1,47 @@
 import {
-  exports_mcp
-} from "./schema-kwh3ary7.js";
+  Service79,
+  node84
+} from "./event-logger-jbmjz4v3.js";
 import {
-  exports_tool
-} from "./schema-y71jz153.js";
+  Service40,
+  node43
+} from "./event-logger-2mqy9ydc.js";
 import {
-  exports_permission
-} from "./schema-1nf5m1zv.js";
+  Service71,
+  node76
+} from "./event-logger-yzjhj2th.js";
 import {
-  exports_bus
-} from "./schema-fjb24bmd.js";
+  Service43,
+  node46
+} from "./event-logger-b84bthst.js";
 import {
   __export
-} from "./schema-vpjkya7h.js";
+} from "./event-logger-9rqn6x4v.js";
 
 // src/tool/mcp.ts
-var exports_mcp2 = {};
-__export(exports_mcp2, {
-  McpTool: () => exports_mcp2,
-  Service: () => Service,
-  layer: () => layer,
-  name: () => name,
-  namespace: () => namespace,
-  node: () => node
+var exports_mcp3 = {};
+__export(exports_mcp3, {
+  McpTool: () => exports_mcp3,
+  Service: () => Service36,
+  layer: () => layer14,
+  name: () => name13,
+  namespace: () => namespace2,
+  node: () => node39
 });
 import { ToolFailure } from "@opencode-ai/ai";
 import { McpEvent } from "@opencode-ai/schema/mcp-event";
 import { Context, Effect, Fiber, Layer, PubSub, Semaphore, Stream } from "effect";
 import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
-var namespace = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
-var name = (server, tool) => `${namespace(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
+var namespace2 = (server) => server.replace(/[^a-zA-Z0-9_-]/g, "_");
+var name13 = (server, tool) => `${namespace2(server)}_${tool.replace(/[^a-zA-Z0-9_-]/g, "_")}`;
 
-class Service extends Context.Service()("@opencode/McpTool") {
+class Service36 extends Context.Service()("@opencode/McpTool") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
-  const mcp = yield* exports_mcp.Service;
-  const tools = yield* exports_tool.Service;
-  const bus = yield* exports_bus.Service;
-  const permission = yield* exports_permission.Service;
+var layer14 = Layer.effect(Service36, Effect.gen(function* () {
+  const mcp = yield* Service40;
+  const tools = yield* Service43;
+  const bus = yield* Service79;
+  const permission = yield* Service71;
   const lock = Semaphore.makeUnsafe(1);
   let discovered = [];
   const initial = yield* lock.withPermit(Effect.gen(function* () {
@@ -47,7 +51,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
         const schema = tool.inputSchema ?? {};
         editor.add({
           name: tool.name,
-          options: { namespace: namespace(tool.server), codemode: tool.codemode !== false },
+          options: { namespace: namespace2(tool.server), codemode: tool.codemode !== false },
           description: tool.description ?? "",
           input: {
             ...schema,
@@ -58,7 +62,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
           output: tool.outputSchema ?? {},
           execute: (input, context) => Effect.gen(function* () {
             yield* permission.assert({
-              action: name(tool.server, tool.name),
+              action: name13(tool.server, tool.name),
               resources: ["*"],
               save: ["*"],
               metadata: {},
@@ -95,7 +99,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
               output: result.structured ?? (text === "" ? null : text),
               ...content.length === 0 ? {} : { content }
             };
-          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name(tool.server, tool.name)}` })))
+          }).pipe(Effect.mapError((error) => error instanceof ToolFailure ? error : new ToolFailure({ message: `Unable to execute ${name13(tool.server, tool.name)}` })))
         });
       }
     });
@@ -108,12 +112,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   yield* bus.subscribe(McpEvent.ToolsChanged).pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.forkScoped({ startImmediately: true }));
   const updates = yield* PubSub.subscribe(changes);
   yield* Stream.fromSubscription(updates).pipe(Stream.debounce("100 millis"), Stream.runForEach(() => reconcile), Effect.forkScoped({ startImmediately: true }));
-  return Service.of({ flush: Effect.asVoid(Fiber.await(initial)) });
+  return Service36.of({ flush: Effect.asVoid(Fiber.await(initial)) });
 }));
-var node = makeLocationNode({
-  service: Service,
-  layer,
-  deps: [exports_tool.node, exports_mcp.node, exports_bus.node, exports_permission.node]
+var node39 = makeLocationNode({
+  service: Service36,
+  layer: layer14,
+  deps: [node46, node43, node84, node76]
 });
 
-export { namespace, name, Service, layer, node, exports_mcp2 as exports_mcp };
+export { namespace2, name13, Service36, layer14, node39, exports_mcp3 };

package/dist/chunks/{schema-vpjkya7h.js → event-logger-9rqn6x4v.js}

@@ -1,4 +1,3 @@
-import { createRequire } from "node:module";
 var __defProp = Object.defineProperty;
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -13,7 +12,5 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
-var __require = (specifier) => createRequire(import.meta.url ?? "file:///worker.js")(specifier);
-__require.resolve = (specifier, options) => createRequire(import.meta.url ?? "file:///worker.js").resolve(specifier, options);
 
-export { __export, __require };
+export { __export };