@opencode-ai/core 0.0.0-dev-19092 → 0.0.0-dev-19094

package/dist/chunks/{integration-qz5gwjr7.js → command-mhsg1yty.js}

@@ -1,25 +1,25 @@
 import {
-  AbsolutePath,
-  RelativePath
-} from "./integration-j07kk359.js";
+  AbsolutePath2,
+  RelativePath2
+} from "./command-p8qxwesx.js";
 import {
-  exports_keyed_mutex
-} from "./integration-66mds5ht.js";
+  makeUnsafe2
+} from "./command-jwcy2c2z.js";
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/git.ts
-var exports_git = {};
-__export(exports_git, {
-  Git: () => exports_git,
-  OperationError: () => OperationError,
-  Repository: () => Repository,
-  Service: () => Service,
-  TreeID: () => TreeID,
-  Worktree: () => Worktree,
-  WorktreeError: () => WorktreeError,
-  node: () => node
+var exports_git3 = {};
+__export(exports_git3, {
+  Git: () => exports_git3,
+  OperationError: () => OperationError2,
+  Repository: () => Repository2,
+  Service: () => Service70,
+  TreeID: () => TreeID2,
+  Worktree: () => Worktree2,
+  WorktreeError: () => WorktreeError2,
+  node: () => node73
 });
 import path from "path";
 import { Context, Effect, Layer, Schema } from "effect";
@@ -27,10 +27,10 @@ import { ChildProcess } from "effect/unstable/process";
 import { FSUtil } from "@opencode-ai/util/fs-util";
 import { AppProcess } from "@opencode-ai/util/process";
 import { makeGlobalNode } from "@opencode-ai/util/effect/app-node";
-class Repository extends Schema.Class("Git.Repository")({
-  worktree: AbsolutePath,
-  gitDirectory: AbsolutePath,
-  commonDirectory: AbsolutePath
+class Repository2 extends Schema.Class("Git.Repository")({
+  worktree: AbsolutePath2,
+  gitDirectory: AbsolutePath2,
+  commonDirectory: AbsolutePath2
 }) {
 }
 var snapshotConfigFile = "opencode.gitconfig";
@@ -49,9 +49,9 @@ var snapshotConfig = `[core]
 	version = 4
 	threads = true
 `;
-var TreeID = Schema.String.pipe(Schema.brand("Git.TreeID"));
+var TreeID2 = Schema.String.pipe(Schema.brand("Git.TreeID"));
 
-class OperationError extends Schema.TaggedError()("Git.OperationError", {
+class OperationError2 extends Schema.TaggedError()("Git.OperationError", {
   operation: Schema.Literals([
     "clone",
     "fetch",
@@ -65,32 +65,32 @@ class OperationError extends Schema.TaggedError()("Git.OperationError", {
     "restore"
   ]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Worktree extends Schema.Class("Git.Worktree")({
-  directory: AbsolutePath,
+class Worktree2 extends Schema.Class("Git.Worktree")({
+  directory: AbsolutePath2,
   kind: Schema.Literals(["main", "linked"])
 }) {
 }
 
-class WorktreeError extends Schema.TaggedError()("Git.WorktreeError", {
+class WorktreeError2 extends Schema.TaggedError()("Git.WorktreeError", {
   operation: Schema.Literals(["create", "remove", "list"]),
   message: Schema.String,
-  directory: Schema.optional(AbsolutePath),
+  directory: Schema.optional(AbsolutePath2),
   forceRequired: Schema.optional(Schema.Boolean),
   cause: Schema.optional(Schema.Defect())
 }) {
 }
 
-class Service extends Context.Service()("@opencode/Git") {
+class Service70 extends Context.Service()("@opencode/Git") {
 }
-var layer = Layer.effect(Service, Effect.gen(function* () {
+var layer = Layer.effect(Service70, Effect.gen(function* () {
   const fs = yield* FSUtil.Service;
   const proc = yield* AppProcess.Service;
-  const locks = exports_keyed_mutex.makeUnsafe();
+  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(() => {
@@ -103,10 +103,10 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/);
     if (!gitDir || !commonDir)
       return;
-    return new Repository({
-      worktree: AbsolutePath.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
-      gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir)),
-      commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir))
+    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") {
@@ -140,18 +140,18 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       return;
     return result.text.trim().replace(new RegExp(`^refs/remotes/${remoteName}/`), "") || undefined;
   });
-  const operation = Effect.fnUntraced(function* (operation2, directory, args) {
-    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError({ operation: operation2, directory, message: cause.message, cause })));
+  const operation = Effect.fnUntraced(function* (operation, directory, args) {
+    const result = yield* execute(directory, proc, args).pipe(Effect.mapError((cause) => new OperationError2({ operation, directory, message: cause.message, cause })));
     if (result.exitCode === 0)
       return;
-    return yield* new OperationError({
-      operation: operation2,
+    return yield* new OperationError2({
+      operation,
       directory,
-      message: result.stderr.trim() || result.text.trim() || `Git ${operation2} failed`
+      message: result.stderr.trim() || result.text.trim() || `Git ${operation} failed`
     });
   });
   const clone = Effect.fn("Git.repo.clone")(function* (input) {
-    yield* operation("clone", AbsolutePath.make(path.dirname(input.directory)), [
+    yield* operation("clone", AbsolutePath2.make(path.dirname(input.directory)), [
       "clone",
       "--depth",
       String(input.depth ?? 100),
@@ -163,7 +163,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new OperationError({
+    return yield* new OperationError2({
       operation: "clone",
       directory: input.directory,
       message: "Cloned repository could not be opened"
@@ -199,7 +199,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       cwd: repository.worktree,
       env: options?.env,
       extendEnv: true
-    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError({
+    }), { stdin: options?.stdin }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: operationName,
       directory: repository.worktree,
       message: cause.message,
@@ -208,16 +208,16 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const text = result.stdout.toString("utf8");
     if (result.exitCode === 0)
       return { text, stderr: result.stderr.toString("utf8") };
-    return yield* new OperationError({
+    return yield* new OperationError2({
       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 OperationError({ operation: "create", directory: input.gitDirectory, message, cause });
+    const operationError = (message) => (cause) => new OperationError2({ operation: "create", directory: input.gitDirectory, message, cause });
     yield* fs.ensureDir(input.gitDirectory).pipe(Effect.mapError(operationError("Failed to create Git storage")));
-    const repository = new Repository({
+    const repository = new Repository2({
       worktree: input.worktree,
       gitDirectory: input.gitDirectory,
       commonDirectory: input.gitDirectory
@@ -251,13 +251,13 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       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) => RelativePath.make(file));
+    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(RelativePath.make(item))), (item) => fs.stat(path.join(input.repository.worktree, item)).pipe(Effect.map((info) => info.type === "File" && Number(info.size) > maximum ? RelativePath.make(item) : undefined), Effect.orElseSucceed(() => {
+    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));
@@ -274,22 +274,22 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     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 OperationError({
+    }), { stdin: input.paths.join("\x00") + "\x00" }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: "list_files",
       directory: input.repository.worktree,
       message: cause.message,
       cause
     })));
     if (result.exitCode !== 0 && result.exitCode !== 1)
-      return yield* new OperationError({
+      return yield* new OperationError2({
         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) => RelativePath.make(file)));
+    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 TreeID.make((yield* repositoryOperation("write_tree", repository, ["write-tree"])).text.trim());
+    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 });
@@ -303,7 +303,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       "-z",
       input.from,
       input.to
-    ])).text.split("\x00").filter(Boolean).map((file) => RelativePath.make(file));
+    ])).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));
@@ -357,7 +357,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     if (!text)
       return false;
     if (!/^\d+\s+\w+\s+[0-9a-f]+\t/.test(text))
-      return yield* new OperationError({
+      return yield* new OperationError2({
         operation: "restore",
         directory: repository.worktree,
         message: `Invalid tree entry for ${file}`
@@ -369,23 +369,23 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
       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 OperationError({
+    yield* fs.remove(path.join(input.repository.worktree, file), { recursive: true, force: true }).pipe(Effect.mapError((cause) => new OperationError2({
       operation: "restore",
       directory: input.repository.worktree,
       message: `Failed to remove ${file}`,
       cause
     })));
   }), { discard: true })));
-  const worktreeRun = Effect.fnUntraced(function* (operation2, 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 WorktreeError({ operation: operation2, directory: worktreeDirectory, message: cause.message, cause })));
+  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 WorktreeError({
-      operation: operation2,
+    return yield* new WorktreeError2({
+      operation,
       directory: worktreeDirectory,
       message,
-      forceRequired: operation2 === "remove" && /contains modified or untracked files|is dirty/i.test(message)
+      forceRequired: operation === "remove" && /contains modified or untracked files|is dirty/i.test(message)
     });
   });
   const worktreeCreate = Effect.fn("Git.worktree.create")(function* (input) {
@@ -393,7 +393,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     const repository = yield* discover(input.directory);
     if (repository)
       return repository;
-    return yield* new WorktreeError({
+    return yield* new WorktreeError2({
       operation: "create",
       directory: input.directory,
       message: "Created worktree could not be opened"
@@ -404,12 +404,12 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
   });
   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 Worktree({
-      directory: AbsolutePath.make(resolvePath(repository.worktree, line.slice("worktree ".length).trim())),
+`).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 Service.of({
+  return Service70.of({
     repo: { discover, clone, create },
     remote: { get: remote },
     history: { head, branch, defaultRemoteBranch: remoteHead, rootCommits: roots },
@@ -425,7 +425,7 @@ var layer = Layer.effect(Service, Effect.gen(function* () {
     }
   });
 }));
-var node = makeGlobalNode({ service: Service, layer, deps: [FSUtil.node, AppProcess.node] });
+var node73 = makeGlobalNode({ service: Service70, layer, deps: [FSUtil.node, AppProcess.node] });
 function run(cwd, proc, args) {
   return execute(cwd, proc, args).pipe(Effect.orElseSucceed(() => ({ exitCode: 1, text: "", stderr: "" })));
 }
@@ -450,4 +450,4 @@ function resolvePath(cwd, value) {
   return path.resolve(cwd, normalized);
 }
 
-export { Repository, TreeID, OperationError, Worktree, WorktreeError, Service, node, exports_git };
+export { Repository2, TreeID2, OperationError2, Worktree2, WorktreeError2, Service70, node73, exports_git3 };

package/dist/chunks/command-mntxs535.js

@@ -0,0 +1,5 @@
+// src/session/event.ts
+export * from "@opencode-ai/schema/session-event";
+import * as SessionEvent2 from "@opencode-ai/schema/session-event";
+
+export { SessionEvent2 };

package/dist/chunks/{integration-c54e84vp.js → command-mtcjf44p.js}

@@ -1,56 +1,56 @@
 import {
   __export
-} from "./integration-vpjkya7h.js";
+} from "./command-9rqn6x4v.js";
 
 // src/instructions/index.ts
-var exports_instructions = {};
-__export(exports_instructions, {
-  Delta: () => Delta,
-  DuplicateKeyError: () => DuplicateKeyError,
-  Hash: () => Hash,
-  InitializationBlocked: () => InitializationBlocked,
-  Instructions: () => exports_instructions,
-  Key: () => Key,
-  Values: () => Values,
-  applyHashDelta: () => applyHashDelta,
-  combine: () => combine,
-  diff: () => diff,
-  diffByKey: () => diffByKey,
-  empty: () => empty,
-  hash: () => hash,
-  make: () => make,
-  read: () => read,
-  removed: () => removed,
-  renderInitial: () => renderInitial,
-  renderUpdate: () => renderUpdate,
-  unavailable: () => unavailable
+var exports_instructions6 = {};
+__export(exports_instructions6, {
+  Delta: () => Delta2,
+  DuplicateKeyError: () => DuplicateKeyError2,
+  Hash: () => Hash2,
+  InitializationBlocked: () => InitializationBlocked2,
+  Instructions: () => exports_instructions6,
+  Key: () => Key3,
+  Values: () => Values2,
+  applyHashDelta: () => applyHashDelta2,
+  combine: () => combine2,
+  diff: () => diff2,
+  diffByKey: () => diffByKey2,
+  empty: () => empty3,
+  hash: () => hash2,
+  make: () => make18,
+  read: () => read3,
+  removed: () => removed2,
+  renderInitial: () => renderInitial2,
+  renderUpdate: () => renderUpdate2,
+  unavailable: () => unavailable3
 });
 import { createHash } from "crypto";
 import { Instruction } from "@opencode-ai/schema/instruction";
 import { Data, Effect, Option, Schema } from "effect";
-var Key = Instruction.Key;
-var Hash = Instruction.Hash;
-var Values = Instruction.Values;
-var Delta = Instruction.Delta;
+var Key3 = Instruction.Key;
+var Hash2 = Instruction.Hash;
+var Values2 = Instruction.Values;
+var Delta2 = Instruction.Delta;
 var NonValue = Data.taggedEnum();
-var unavailable = NonValue.Unavailable();
-var removed = NonValue.Removed();
+var unavailable3 = NonValue.Unavailable();
+var removed2 = NonValue.Removed();
 
-class InitializationBlocked extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key) }) {
+class InitializationBlocked2 extends Schema.TaggedError()("Instructions.InitializationBlocked", { keys: Schema.Array(Key3) }) {
   get message() {
     return `Instruction initialization blocked by unavailable sources: ${this.keys.join(", ")}`;
   }
 }
 
-class DuplicateKeyError extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
-  key: Key
+class DuplicateKeyError2 extends Schema.TaggedError()("Instructions.DuplicateKeyError", {
+  key: Key3
 }) {
   get message() {
     return `Duplicate instruction key: ${this.key}`;
   }
 }
-var empty = [];
-function make(source) {
+var empty3 = [];
+function make18(source) {
   const decode = Schema.decodeUnknownOption(source.codec);
   const encode = Schema.encodeSync(source.codec);
   const initial = (value) => requireText(source.key, "initial", source.render.initial(value));
@@ -60,9 +60,9 @@ function make(source) {
       key: source.key,
       read: source.read.pipe(Effect.map((value) => {
         if (isUnavailable(value))
-          return unavailable;
+          return unavailable3;
         if (isRemoved(value))
-          return removed;
+          return removed2;
         return encode(value);
       })),
       initial: (value) => {
@@ -85,23 +85,23 @@ function make(source) {
     }
   ];
 }
-function combine(values) {
+function combine2(values) {
   const sources = values.flat();
   const keys = new Set;
   for (const source of sources) {
     if (keys.has(source.key))
-      throw new DuplicateKeyError({ key: source.key });
+      throw new DuplicateKeyError2({ key: source.key });
     keys.add(source.key);
   }
   return sources;
 }
-function read(value) {
+function read3(value) {
   return Effect.forEach(value, (source) => source.read.pipe(Effect.map((observed) => ({ key: source.key, value: observed }))), { concurrency: "unbounded" });
 }
-function diff(observed, previous) {
+function diff2(observed, previous) {
   const blocked = previous ? [] : observed.flatMap((entry) => isUnavailable(entry.value) ? [entry.key] : []);
   if (blocked.length > 0)
-    return Effect.fail(new InitializationBlocked({ keys: blocked }));
+    return Effect.fail(new InitializationBlocked2({ keys: blocked }));
   const delta = {};
   const blobs = {};
   for (const entry of observed) {
@@ -112,7 +112,7 @@ function diff(observed, previous) {
         delta[entry.key] = Instruction.removed;
       continue;
     }
-    const next = hash(entry.value);
+    const next = hash2(entry.value);
     if (previous?.[entry.key] === next)
       continue;
     delta[entry.key] = next;
@@ -120,7 +120,7 @@ function diff(observed, previous) {
   }
   return Effect.succeed({ delta, blobs });
 }
-function renderInitial(value, values) {
+function renderInitial2(value, values) {
   return render(value.flatMap((source) => {
     if (!Object.hasOwn(values, source.key))
       return [];
@@ -128,7 +128,7 @@ function renderInitial(value, values) {
     return text === undefined ? [] : [text];
   }));
 }
-function renderUpdate(value, previous, delta) {
+function renderUpdate2(value, previous, delta) {
   return render(value.flatMap((source) => {
     if (!Object.hasOwn(delta, source.key))
       return [];
@@ -136,18 +136,18 @@ function renderUpdate(value, previous, delta) {
     if (Option.isNone(current)) {
       if (!Object.hasOwn(previous, source.key))
         return [];
-      const text2 = source.removed(previous[source.key]);
-      return text2 === undefined ? [] : [text2];
+      const text = source.removed(previous[source.key]);
+      return text === undefined ? [] : [text];
     }
     const next = current.value;
     const text = Object.hasOwn(previous, source.key) ? source.changed(previous[source.key], next) : source.initial(next);
     return text === undefined ? [] : [text];
   }));
 }
-function hash(value) {
-  return Hash.make(createHash("sha256").update(canonical(value)).digest("hex"));
+function hash2(value) {
+  return Hash2.make(createHash("sha256").update(canonical(value)).digest("hex"));
 }
-function applyHashDelta(values, delta) {
+function applyHashDelta2(values, delta) {
   const result = { ...values };
   for (const [key, value] of Object.entries(delta)) {
     if (value === Instruction.removed)
@@ -157,7 +157,7 @@ function applyHashDelta(values, delta) {
   }
   return result;
 }
-function diffByKey(previous, current, key, changed) {
+function diffByKey2(previous, current, key, changed) {
   const currentKeys = new Set(current.map(key));
   const previousByKey = new Map(previous.map((value) => [key(value), value]));
   return {
@@ -175,10 +175,10 @@ function render(parts) {
 `);
 }
 function isUnavailable(value) {
-  return value === unavailable;
+  return value === unavailable3;
 }
 function isRemoved(value) {
-  return value === removed;
+  return value === removed2;
 }
 function canonical(value) {
   if (Array.isArray(value))
@@ -193,4 +193,4 @@ function requireText(key, kind, text) {
   return text;
 }
 
-export { Key, Hash, Values, Delta, unavailable, removed, InitializationBlocked, DuplicateKeyError, empty, make, combine, read, diff, renderInitial, renderUpdate, hash, applyHashDelta, diffByKey, exports_instructions };
+export { Key3, Hash2, Values2, Delta2, unavailable3, removed2, InitializationBlocked2, DuplicateKeyError2, empty3, make18, combine2, read3, diff2, renderInitial2, renderUpdate2, hash2, applyHashDelta2, diffByKey2, exports_instructions6 };