@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-1gnhqkth.js

@@ -0,0 +1,453 @@
+import {
+  AbsolutePath2,
+  RelativePath2
+} from "./repository-922hggd3.js";
+import {
+  makeUnsafe2
+} from "./repository-y71avatq.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/git.ts
+var exports_git3 = {};
+__export(exports_git3, {
+  Git: () => exports_git3,
+  OperationError: () => OperationError3,
+  Repository: () => Repository2,
+  Service: () => Service68,
+  TreeID: () => TreeID2,
+  Worktree: () => Worktree2,
+  WorktreeError: () => WorktreeError2,
+  node: () => node72
+});
+import path from "path";
+import { Context, Effect, Layer, Schema } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+class Repository2 extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath2,
+  gitDirectory: AbsolutePath2,
+  commonDirectory: AbsolutePath2
+}) {
+}
+var snapshotConfigFile = "opencode.gitconfig";
+var snapshotConfigInclude = `[include]
+	path = ${snapshotConfigFile}
+`;
+var snapshotConfig = `[core]
+	autocrlf = false
+	longpaths = true
+	symlinks = true
+	fsmonitor = false
+	untrackedCache = true
+[feature]
+	manyFiles = true
+[index]
+	version = 4
+	threads = true
+`;
+var TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
+
+class OperationError3 extends Schema.TaggedError()("Git.OperationError", {
+  operation: Schema.Literals([
+    "clone",
+    "fetch",
+    "checkout",
+    "reset",
+    "create",
+    "refresh",
+    "write_tree",
+    "list_files",
+    "diff",
+    "restore"
+  ]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath2),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Worktree2 extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath2,
+  kind: Schema.Literals(["main", "linked"])
+}) {
+}
+
+class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
+  operation: Schema.Literals(["create", "remove", "list"]),
+  message: Schema.String,
+  directory: Schema.optional(AbsolutePath2),
+  forceRequired: Schema.optional(Schema.Boolean),
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+
+class Service68 extends Context.Service()("@opencode/Git") {
+}
+var layer = Layer.effect(Service68, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const proc = yield* AppProcess.Service;
+  const locks = makeUnsafe2();
+  const locked = (repository, effect) => locks.withLock(repository.gitDirectory)(effect);
+  const discover = Effect.fn("Git.repo.discover")(function* (input) {
+    const dotgit = yield* fs.up({ targets: [".git"], start: input, mode: "first" }).pipe(Effect.map((matches) => matches[0]), Effect.orElseSucceed(() => {
+      return;
+    }));
+    if (!dotgit)
+      return;
+    const cwd = path.dirname(dotgit);
+    const result = yield* run(cwd, proc, ["rev-parse", "--git-dir", "--git-common-dir", "--show-toplevel"]);
+    const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
+    if (!gitDir || !commonDir)
+      return;
+    return new Repository2({
+      worktree: AbsolutePath2.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
+      gitDirectory: AbsolutePath2.make(resolvePath(cwd, gitDir)),
+      commonDirectory: AbsolutePath2.make(resolvePath(cwd, commonDir))
+    });
+  });
+  const remote = Effect.fn("Git.remote.get")(function* (repository, name = "origin") {
+    const result = yield* run(repository.worktree, proc, ["remote", "get-url", name]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const roots = Effect.fn("Git.history.rootCommits")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["rev-list", "--max-parents=0", "HEAD"]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text.split(`
+`).map((item) => item.trim()).filter(Boolean).toSorted();
+  });
+  const head = Effect.fn("Git.history.head")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["rev-parse", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const branch = Effect.fn("Git.history.branch")(function* (repository) {
+    const result = yield* run(repository.worktree, proc, ["symbolic-ref", "--quiet", "--short", "HEAD"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim() || undefined;
+  });
+  const remoteHead = Effect.fn("Git.history.defaultRemoteBranch")(function* (repository, remoteName = "origin") {
+    const result = yield* run(repository.worktree, proc, ["symbolic-ref", `refs/remotes/${remoteName}/HEAD`]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
+  });
+  const operation = Effect.fnUntraced(function* (operation, directory, args) {
+    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError3({ operation, directory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return;
+    return yield* new OperationError3({
+      operation,
+      directory,
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
+    });
+  });
+  const clone = Effect.fn("Git.repo.clone")(function* (input) {
+    yield* operation("clone", AbsolutePath2.make(path.dirname(input.directory)), [
+      "clone",
+      "--depth",
+      String(input.depth ?? 100),
+      ...input.branch ? ["--branch", input.branch] : [],
+      "--",
+      input.remote,
+      input.directory
+    ]);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new OperationError3({
+      operation: "clone",
+      directory: input.directory,
+      message: "Cloned repository could not be opened"
+    });
+  });
+  const fetch = Effect.fn("Git.sync.fetchRemotes")(function* (repository, input = {}) {
+    yield* operation("fetch", repository.worktree, ["fetch", "--all", ...input.prune === false ? [] : ["--prune"]]);
+  });
+  const fetchBranch = Effect.fn("Git.sync.fetchBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    const spec = `refs/heads/${input.branch}:refs/remotes/${remoteName}/${input.branch}`;
+    yield* operation("fetch", repository.worktree, ["fetch", remoteName, input.force === false ? spec : `+${spec}`]);
+  });
+  const checkout = Effect.fn("Git.sync.checkoutRemoteBranch")(function* (repository, input) {
+    const remoteName = input.remote ?? "origin";
+    yield* operation("checkout", repository.worktree, [
+      "checkout",
+      ...input.reset === false ? [input.branch] : ["-B", input.branch, `${remoteName}/${input.branch}`]
+    ]);
+  });
+  const reset = Effect.fn("Git.sync.resetHard")(function* (repository, revision) {
+    yield* operation("reset", repository.worktree, ["reset", "--hard", revision]);
+  });
+  const repositoryArgs = (repository, args) => [
+    "--git-dir",
+    repository.gitDirectory,
+    "--work-tree",
+    repository.worktree,
+    ...args
+  ];
+  const repositoryOperation = Effect.fnUntraced(function* (operationName, repository, args, options) {
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(repository, args), {
+      cwd: repository.worktree,
+      env: options?.env,
+      extendEnv: true
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: operationName,
+      directory: repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    const text = result.stdout.toString("utf8");
+    if (result.exitCode === 0)
+      return { text, stderr: result.stderr.toString("utf8") };
+    return yield* new OperationError3({
+      operation: operationName,
+      directory: repository.worktree,
+      message: result.stderr.toString("utf8").trim() || text.trim() || `Git ${operationName} failed`
+    });
+  });
+  const create = Effect.fn("Git.repo.create")(function* (input) {
+    const operationError = (message) => (cause) => new OperationError3({ operation: "create", directory: input.gitDirectory, message, cause });
+    yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
+    const repository = new Repository2({
+      worktree: input.worktree,
+      gitDirectory: input.gitDirectory,
+      commonDirectory: input.gitDirectory
+    });
+    yield* repositoryOperation("create", repository, ["init"]);
+    yield* Effect.gen(function* () {
+      yield* fs.writeFileString(path.join(input.gitDirectory, snapshotConfigFile), snapshotConfig);
+      const config = path.join(input.gitDirectory, "config");
+      const current = yield* fs.readFileString(config);
+      if (current.includes(snapshotConfigInclude))
+        return;
+      yield* fs.writeFileString(config, `${current.endsWith(`
+`) ? `
+` : `
+
+`}${snapshotConfigInclude}`, {
+        flag: "a"
+      });
+    }).pipe(Effect.mapError(operationError("Failed to configure Git storage")));
+    if (!input.seed)
+      return repository;
+    yield* fs.ensureDir(path.join(input.gitDirectory, "objects", "info")).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
+    yield* fs.writeFileString(path.join(input.gitDirectory, "objects", "info", "alternates"), path.join(input.seed.commonDirectory, "objects") + `
+`).pipe(Effect.mapError(operationError("Failed to configure shared Git objects")));
+    yield* fs.copyFile(path.join(input.seed.gitDirectory, "index"), path.join(input.gitDirectory, "index")).pipe(Effect.ignore);
+    return repository;
+  });
+  const refresh = Effect.fn("Git.index.refresh")(function* (input) {
+    const list = (args) => repositoryOperation("refresh", input.repository, args).pipe(Effect.map((result) => result.text.split("\x00").filter(Boolean)));
+    const [tracked, untracked] = yield* Effect.all([
+      list(["diff-files", "--name-only", "-z", "--", input.scope]),
+      list(["ls-files", "--others", "--exclude-standard", "-z", "--", input.scope])
+    ], { concurrency: 2 });
+    const candidates = Array.from(new Set([...tracked, ...untracked])).map((file) => RelativePath2.make(file));
+    if (!candidates.length)
+      return { skipped: [] };
+    const excluded = input.ignores ? yield* ignored({ repository: input.ignores, paths: candidates }) : new Set;
+    const allowed = candidates.filter((item) => !excluded.has(item));
+    const maximum = input.maximumUntrackedFileBytes;
+    const skipped = maximum ? (yield* Effect.forEach(untracked.filter((item) => allowed.includes(RelativePath2.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath2.make(item) : undefined), Effect.orElseSucceed(() => {
+      return;
+    })), { concurrency: 8 })).filter((item) => item !== undefined) : [];
+    const stage = allowed.filter((item) => !skipped.includes(item));
+    const remove = [...excluded, ...skipped];
+    if (remove.length)
+      yield* repositoryOperation("refresh", input.repository, ["rm", "--cached", "-f", "--ignore-unmatch", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: remove.join("\x00") + "\x00" });
+    if (stage.length)
+      yield* repositoryOperation("refresh", input.repository, ["add", "--all", "--sparse", "--pathspec-from-file=-", "--pathspec-file-nul"], { stdin: stage.join("\x00") + "\x00" });
+    return { skipped };
+  });
+  const ignored = Effect.fn("Git.index.ignored")(function* (input) {
+    if (!input.paths.length)
+      return new Set;
+    const result = yield* proc.run(ChildProcess.make("git", repositoryArgs(input.repository, ["check-ignore", "--no-index", "--stdin", "-z"]), {
+      cwd: input.repository.worktree,
+      extendEnv: true
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: "list_files",
+      directory: input.repository.worktree,
+      message: cause.message,
+      cause
+    })));
+    if (result.exitCode !== 0 && result.exitCode !== 1)
+      return yield* new OperationError3({
+        operation: "list_files",
+        directory: input.repository.worktree,
+        message: result.stderr.toString("utf8").trim() || "Failed to check ignored paths"
+      });
+    return new Set(result.stdout.toString("utf8").split("\x00").filter(Boolean).map((file) => RelativePath2.make(file)));
+  });
+  const writeTree = Effect.fn("Git.tree.write")(function* (repository) {
+    return TreeID2.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+  });
+  const captureTree = Effect.fn("Git.tree.capture")((input) => locked(input.repository, Effect.gen(function* () {
+    yield* Effect.forEach(input.scopes, (scope) => refresh({ ...input, scope }), { discard: true });
+    return yield* writeTree(input.repository);
+  })));
+  const treeFiles = Effect.fn("Git.tree.files")(function* (input) {
+    return (yield* repositoryOperation("list_files", input.repository, [
+      "diff",
+      "--name-only",
+      "--no-renames",
+      "-z",
+      input.from,
+      input.to
+    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath2.make(file));
+  });
+  const treeDiff = Effect.fn("Git.tree.diff")(function* (input) {
+    const paths = input.paths ?? (yield* treeFiles(input));
+    return yield* Effect.forEach(paths, (file) => Effect.gen(function* () {
+      const statusText = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--name-status",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.trim();
+      const status = statusText.startsWith("A") ? "added" : statusText.startsWith("D") ? "deleted" : "modified";
+      const stats = (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        "--numstat",
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text.split("\t");
+      const binary = stats[0] === "-" || stats[1] === "-";
+      const patch = binary ? "" : (yield* repositoryOperation("diff", input.repository, [
+        "diff",
+        `--unified=${input.context ?? 3}`,
+        "--no-renames",
+        input.from,
+        input.to,
+        "--",
+        file
+      ])).text;
+      return {
+        file,
+        status,
+        additions: binary ? 0 : Number(stats[0] ?? 0),
+        deletions: binary ? 0 : Number(stats[1] ?? 0),
+        patch
+      };
+    }));
+  });
+  const hasEntry = Effect.fnUntraced(function* (repository, tree, file) {
+    const text = (yield* repositoryOperation("restore", repository, [
+      "ls-tree",
+      "-z",
+      tree,
+      "--",
+      file
+    ])).text.replace(/\0$/, "");
+    if (!text)
+      return false;
+    if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
+      return yield* new OperationError3({
+        operation: "restore",
+        directory: repository.worktree,
+        message: `Invalid tree entry for ${file}`
+      });
+    return true;
+  });
+  const restore = Effect.fn("Git.tree.restore")((input) => locked(input.repository, Effect.forEach(input.files, ([file, tree]) => Effect.gen(function* () {
+    if (yield* hasEntry(input.repository, tree, file)) {
+      yield* repositoryOperation("restore", input.repository, ["checkout", tree, "--", file]);
+      return;
+    }
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError3({
+      operation: "restore",
+      directory: input.repository.worktree,
+      message: `Failed to remove ${file}`,
+      cause
+    })));
+  }), { discard: true })));
+  const worktreeRun = Effect.fnUntraced(function* (operation, repository, args, worktreeDirectory, cwd = repository.worktree) {
+    const result = yield* proc.run(ChildProcess.make("git", args, { cwd, extendEnv: true, stdin: "ignore" })).pipe(Effect.mapError((cause) => new WorktreeError2({ operation, directory: worktreeDirectory, message: cause.message, cause })));
+    if (result.exitCode === 0)
+      return result.stdout.toString("utf8");
+    const message = result.stderr.toString("utf8").trim() || result.stdout.toString("utf8").trim() || "Git failed";
+    return yield* new WorktreeError2({
+      operation,
+      directory: worktreeDirectory,
+      message,
+      forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+    });
+  });
+  const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
+    yield* worktreeRun("create", input.repository, ["worktree", "add", "--detach", "--", input.directory, input.ref ?? "HEAD"], input.directory);
+    const repository = yield* discover(input.directory);
+    if (repository)
+      return repository;
+    return yield* new WorktreeError2({
+      operation: "create",
+      directory: input.directory,
+      message: "Created worktree could not be opened"
+    });
+  });
+  const worktreeRemove = Effect.fn("Git.worktree.remove")(function* (input) {
+    yield* worktreeRun("remove", input.repository, ["worktree", "remove", ...input.force ? ["--force"] : [], input.directory], input.directory, input.repository.commonDirectory);
+  });
+  const worktreeList = Effect.fn("Git.worktree.list")(function* (repository) {
+    return (yield* worktreeRun("list", repository, ["worktree", "list", "--porcelain"])).split(`
+`).filter((line) => line.startsWith("worktree ")).map((line, index) => new Worktree2({
+      directory: AbsolutePath2.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+      kind: index === 0 ? "main" : "linked"
+    }));
+  });
+  return Service68.of({
+    repo: { discover, clone, create },
+    remote: { get: remote },
+    history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
+    sync: { fetchRemotes: fetch, fetchBranch, checkoutRemoteBranch: checkout, resetHard: reset },
+    worktree: { create: worktreeCreate, remove: worktreeRemove, list: worktreeList },
+    index: { refresh, ignored },
+    tree: {
+      capture: captureTree,
+      write: writeTree,
+      files: treeFiles,
+      diff: treeDiff,
+      restore
+    }
+  });
+}));
+var node72 = makeGlobalNode({ service: Service68, layer, deps: [FSUtil.node, AppProcess.node] });
+function run(cwd, proc, args) {
+  return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
+}
+function execute(cwd, proc, args) {
+  return proc.run(ChildProcess.make("git", args, {
+    cwd,
+    extendEnv: true,
+    stdin: "ignore"
+  })).pipe(Effect.map((result) => ({
+    exitCode: result.exitCode,
+    text: result.stdout.toString("utf8"),
+    stderr: result.stderr.toString("utf8")
+  })));
+}
+function resolvePath(cwd, value) {
+  const trimmed = value.replace(/[\r\n]+$/, "");
+  if (!trimmed)
+    return cwd;
+  const normalized = FSUtil.windowsPath(trimmed);
+  if (path.isAbsolute(normalized))
+    return path.normalize(normalized);
+  return path.resolve(cwd, normalized);
+}
+
+export { Repository2, TreeID2, OperationError3, Worktree2, WorktreeError2, Service68, node72, exports_git3 };

package/dist/chunks/repository-1j4qb6e1.js

@@ -0,0 +1,105 @@
+import {
+  fromPromise2
+} from "./repository-zr2ceqn5.js";
+import {
+  Service45
+} from "./repository-shg3amz7.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/module.ts
+var exports_module = {};
+__export(exports_module, {
+  LoadError: () => LoadError2,
+  PluginModule: () => exports_module,
+  make: () => make6
+});
+import { Host } from "@opencode/plugin/host";
+import { createPluginSources } from "@opencode/plugin/source";
+import { Npm } from "@opencode/util/npm";
+import { Deferred, Effect, FiberSet, PubSub, Schema, Stream } from "effect";
+import path from "path";
+import { stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "url";
+var make6 = Effect.fn("PluginModule.make")(function* () {
+  const watcher = yield* Service45;
+  const scope = yield* Effect.scope;
+  const runPromise = yield* FiberSet.makeRuntimePromise();
+  const changes = yield* PubSub.unbounded();
+  const watched = new Set;
+  const watch = Effect.fn("PluginModule.watch")(function* (file) {
+    if (watched.has(file))
+      return;
+    watched.add(file);
+    const ready = yield* Deferred.make();
+    const target = yield* Effect.promise(() => watchTarget(file));
+    const updates = yield* watcher.subscribe(target, Deferred.succeed(ready, undefined));
+    yield* updates.pipe(Stream.runForEach(() => PubSub.publish(changes, undefined)), Effect.ensuring(Deferred.succeed(ready, undefined)), Effect.forkIn(scope, { startImmediately: true }));
+    yield* Deferred.await(ready);
+  });
+  const sources = yield* Effect.acquireRelease(Effect.sync(() => createPluginSources((file) => runPromise(watch(file)))), (sources) => Effect.sync(() => sources.dispose()));
+  return {
+    load: (operation, options) => load(operation, sources, options),
+    changes: () => Stream.fromPubSub(changes)
+  };
+});
+function watchTarget(file) {
+  return stat(file).then((info) => ({ path: file, type: info.isDirectory() ? "directory" : "file" }), (cause) => {
+    if (path.dirname(file) === file)
+      throw cause;
+    return watchTarget(path.dirname(file));
+  });
+}
+var Module = Schema.Struct({
+  default: Schema.Union([
+    Schema.Struct({
+      id: Schema.String,
+      effect: Schema.declare((input) => typeof input === "function")
+    }),
+    Schema.Struct({
+      id: Schema.String,
+      setup: Schema.declare((input) => typeof input === "function")
+    })
+  ])
+});
+
+class LoadError2 extends Schema.TaggedError()("PluginModule.LoadError", {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect())
+}) {
+}
+var load = Effect.fn("PluginModule.load")(function* (operation, sources, options) {
+  const local = path.isAbsolute(operation.target);
+  const npm = yield* Npm.Service;
+  const installed = local ? undefined : options?.install === false ? yield* npm.resolve(operation.target) : yield* npm.add(operation.target);
+  const entrypoints = local && (yield* Effect.promise(() => stat(operation.target))).isFile() ? { server: pathToFileURL(operation.target).href } : yield* Effect.sync(() => Host.resolve(installed ?? { directory: operation.target }));
+  const entrypoint = entrypoints.server;
+  if (!local && options?.install === false && !entrypoint)
+    return { pending: true };
+  if (!entrypoint)
+    return yield* new LoadError2({ message: `Plugin entrypoint not found: ${operation.target}` });
+  yield* Effect.log({ msg: "loading plugin", id: operation.target, entrypoint });
+  const loaded = yield* Effect.promise(() => local ? sources.read(entrypoint) : Host.load(entrypoint).then((module) => ({ module, version: installed?.revision })));
+  const value = (yield* Schema.decodeUnknownEffect(Module)(loaded.module).pipe(Effect.mapError((cause) => new LoadError2({
+    message: "Plugin must export a default definition with an id and an effect or setup function.",
+    cause
+  })))).default;
+  const plugin = "effect" in value ? value : fromPromise2(value);
+  return {
+    id: plugin.id,
+    features: {
+      ...entrypoints.tui ? { tui: true } : {},
+      ...entrypoints.rpc ? { rpc: true } : {}
+    },
+    revision: JSON.stringify([operation, loaded.version]),
+    source: path.isAbsolute(operation.target) ? { type: "local", path: fileURLToPath(entrypoint) } : {
+      type: "package",
+      target: operation.target,
+      ...installed?.version ? { version: installed.version } : {}
+    },
+    effect: (host) => plugin.effect({ ...host, options: operation.options })
+  };
+});
+
+export { make6, LoadError2, exports_module };