@elaraai/e3-ui-components 1.0.83 → 1.0.85

package/dist/in-memory-call-7_3frW52.js

@@ -0,0 +1,615 @@
+import { checkJq, variant, StructType, fromEastTypeValue, none, some, translateJq, encodeEastIR, runtimeErrorAt, ArrayType, decodeBeast2For, encodeBeast2For, OptionType, printFor, StringType, equalFor, splitJq, decodeEastIR, EastError, sha256Hex, DictType, SortedMap, compareFor, SetType, SortedSet, decodeBeast2, isTypeEqual } from "@elaraai/east";
+import { pathToString, TreePathType, PIECE_SIZES } from "@elaraai/e3-types";
+const JQ_IDENTIFIER = /^[A-Za-z_][A-Za-z_0-9]*$/;
+const printString = printFor(StringType);
+function queryRoot(entries) {
+  const names = /* @__PURE__ */ new Set();
+  for (const { name } of entries) {
+    if (!JQ_IDENTIFIER.test(name)) {
+      throw new Error(`queryRoot: ${printString(name)} is not a jq identifier: a data source's name is a letter or _, then letters, digits and _, so .name reads it`);
+    }
+    if (names.has(name)) throw new Error(`queryRoot: ${printString(name)} is given twice: each data source of a root has a name of its own`);
+    names.add(name);
+  }
+  return {
+    type: StructType(Object.fromEntries(entries.map((entry) => [entry.name, fromEastTypeValue(entry.type)]))),
+    entries: [...entries]
+  };
+}
+const DEFAULT_MAX_OUTPUTS = 1e3;
+const MAX_OUTPUTS = 1e5;
+const DEFAULT_MAX_BYTES = 1048576;
+function programChecks(checked) {
+  return checked.program !== null && checked.elementType !== null && checked.multiplicity !== null;
+}
+function queryLimits(options = {}) {
+  const maxOutputs = Math.min(limitOf(options.maxOutputs, DEFAULT_MAX_OUTPUTS, "maxOutputs"), MAX_OUTPUTS);
+  const maxBytes = limitOf(options.maxBytes, DEFAULT_MAX_BYTES, "maxBytes");
+  const timeoutMs = options.timeoutMs === void 0 ? none : some(BigInt(checkedLimit(options.timeoutMs, "timeoutMs")));
+  return {
+    maxOutputs,
+    limits: some({ timeoutMs, maxResultBytes: some(BigInt(maxBytes)), maxLogBytes: none }),
+    runner: options.runner ?? platformFreeEastC()
+  };
+}
+function prepareQuery(program, root, options = {}) {
+  queryLimits(options);
+  return prepareCheckedQuery(checkJq(program, root.type, { root: true }), root, options);
+}
+function prepareCheckedQuery(checked, root, options = {}) {
+  const { maxOutputs, limits, runner } = queryLimits(options);
+  if (!programChecks(checked)) return { result: { inputs: [], outcome: variant("error", checked.diagnostics) } };
+  const translation = translateJq(checked, checked.multiplicity === "many" ? { maxOutputs } : {});
+  const entries = translation.inputs.map((input) => entryNamed(root, input.name));
+  const request = {
+    bodyIr: encodeEastIR(translation.fn().toIR()),
+    args: entries.map((entry) => variant("dataset", entry.path)),
+    runner,
+    limits
+  };
+  return { prepared: { checked, entries, request, maxOutputs } };
+}
+function limitOf(value, fallback, name) {
+  return value === void 0 ? fallback : checkedLimit(value, name);
+}
+function checkedLimit(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) throw new RangeError(`prepareQuery: ${name} is ${value}, not a whole number of at least 1`);
+  return value;
+}
+function entryNamed(root, name, caller = "prepareQuery") {
+  const entry = root.entries.find((e) => e.name === name);
+  if (entry === void 0) throw new Error(`${caller}: the query reads .${name ?? ""}, which no data source of the root is`);
+  return entry;
+}
+function platformFreeEastC() {
+  return variant("east_c", { platforms: [], decode: variant("lazy", null) });
+}
+function queryResultOf(prepared, result) {
+  const inputs = inputsOf(prepared, result);
+  const outcome = result.outcome;
+  switch (outcome.type) {
+    case "success":
+      return { inputs, outcome: answered(prepared, outcome.value.value) };
+    case "failed":
+      return { inputs, outcome: failed(prepared.checked, outcome.value.exitCode, result.stderr) };
+    case "invalid":
+      return { inputs, outcome: variant("error", outcome.value.diagnostics.map((d) => refused(prepared, d.message))) };
+    case "timed_out":
+      return { inputs, outcome: variant("timed_out", { ms: outcome.value.ms }) };
+    case "too_large":
+      return { inputs, outcome: variant("too_large", { bytes: outcome.value.bytes, limit: outcome.value.limit }) };
+  }
+}
+const samePath$1 = equalFor(TreePathType);
+function inputsOf(prepared, result) {
+  return result.inputs.map((input, i) => {
+    const entry = prepared.entries[i];
+    if (entry === void 0 || !samePath$1(entry.path, input.path)) {
+      throw new Error(`queryResultOf: the call's argument ${i} read ${pathToString(input.path)}, which is not the data source the query reads there`);
+    }
+    return { hash: input.hash, name: entry.name, path: input.path };
+  });
+}
+function answered(prepared, bytes) {
+  const element = prepared.checked.elementType;
+  switch (prepared.checked.multiplicity) {
+    case "one":
+      decodeBeast2For(element)(bytes);
+      return variant("ok", { outputs: 1n, result: bytes, truncated: false });
+    case "maybe": {
+      const answer2 = decodeBeast2For(OptionType(element))(bytes);
+      return variant("ok", { outputs: answer2.type === "some" ? 1n : 0n, result: bytes, truncated: false });
+    }
+    case "many": {
+      const type = ArrayType(element);
+      const answer2 = decodeBeast2For(type)(bytes);
+      if (answer2.length <= prepared.maxOutputs) return variant("ok", { outputs: BigInt(answer2.length), result: bytes, truncated: false });
+      return variant("ok", { outputs: BigInt(prepared.maxOutputs), result: encodeBeast2For(type)(answer2.slice(0, prepared.maxOutputs)), truncated: true });
+    }
+  }
+}
+const FAILURE_LEAD = "Error: ";
+const FAILURE_PLACE = /^ {2}at (.+):(\d+):(\d+)$/;
+function failureOf(stderr) {
+  const lines = stderr.replace(/\r\n?/g, "\n").split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const places = [];
+  let end = lines.length;
+  for (; end > 0; end--) {
+    const place = FAILURE_PLACE.exec(lines[end - 1]);
+    if (place === null) break;
+    places.unshift({ file: place[1], line: Number(place[2]), column: Number(place[3]) });
+  }
+  let start = end - 1;
+  while (start >= 0 && !lines[start].startsWith(FAILURE_LEAD)) start--;
+  if (start < 0) return void 0;
+  return { message: [lines[start].slice(FAILURE_LEAD.length), ...lines.slice(start + 1, end)].join("\n"), places };
+}
+const MISSING_PLATFORM = /Unknown platform function: ([^\s'"]+)|Platform function '([^']+)' (?:not found|is not available)/g;
+function failed(checked, exitCode, stderr) {
+  const failure = failureOf(stderr);
+  const functions = [];
+  for (const match of ((failure == null ? void 0 : failure.message) ?? stderr).matchAll(MISSING_PLATFORM)) {
+    const name = match[1] ?? match[2];
+    if (name !== void 0 && !functions.includes(name)) functions.push(name);
+  }
+  if (functions.length > 0) return variant("needs_platform", { functions });
+  if (failure === void 0) {
+    const said = stderr.split(/\r\n?|\n/).map((line) => line.trim()).filter((line) => line !== "").at(-1);
+    return variant("error", [runtimeErrorAt(checked, said ?? `the run failed with exit code ${exitCode}`)]);
+  }
+  const place = failure.places.find((p) => p.file === "jq");
+  return variant("error", [runtimeErrorAt(checked, failure.message, place)]);
+}
+const UNASSIGNED = /^Dataset argument (\d+) is not assigned\b/;
+function refused(prepared, message) {
+  const unassigned2 = UNASSIGNED.exec(message);
+  const entry = unassigned2 === null ? void 0 : prepared.entries[Number(unassigned2[1])];
+  if (entry !== void 0) return problem("no_value", `no_value: ${entry.name} has no value yet.`, none);
+  return problem("invalid", `invalid: ${message}`, none);
+}
+function problem(code, message, span) {
+  return { code, fixes: [], message, severity: variant("error", null), span, suggestions: [] };
+}
+function pieceBytesOf(options) {
+  const bytes = options.pieceBytes ?? PIECE_SIZES.min;
+  if (!Number.isSafeInteger(bytes) || bytes < 0) throw new RangeError(`planQuery: pieceBytes is ${bytes}, not a whole number of bytes`);
+  return bytes;
+}
+function messageOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function draftPlan(programs, root, options = {}) {
+  const all = typeof programs === "string" ? { query: programs, oneShot: programs, split: programs } : { query: programs.query, oneShot: programs.oneShot ?? programs.query, split: programs.split ?? programs.query };
+  const { maxOutputs } = queryLimits(options);
+  pieceBytesOf(options);
+  const checked = checkJq(all.query, root.type, { root: true });
+  if (checked.program === null) {
+    const refused2 = prepareCheckedQuery(checked, root, options);
+    if ("result" in refused2) return refused2;
+  }
+  let split;
+  try {
+    split = splitJq(checked, checked.multiplicity === "many" ? { maxOutputs } : {});
+  } catch (err) {
+    split = { kind: "failed", message: messageOf(err) };
+  }
+  return {
+    draft: {
+      reads: [...checked.reads],
+      over: split.kind === "split" ? split.over : void 0,
+      weighs: split.kind === "split" ? [.../* @__PURE__ */ new Set([split.over, ...split.copartitioned, ...split.rekey === null ? [] : [split.rekey.name]])] : [],
+      programs: all,
+      root,
+      options,
+      checked,
+      split
+    }
+  };
+}
+function weighPlan(draft, weights) {
+  var _a, _b;
+  const { checked, split, programs, root, options } = draft;
+  const program = checked.source.text;
+  const oneCall = (why, pruning) => {
+    const prepared = programs.oneShot === programs.query ? prepareCheckedQuery(checked, root, options) : prepareQuery(programs.oneShot, root, options);
+    if ("result" in prepared) return prepared;
+    return { plan: { kind: "one_shot", prepared: prepared.prepared, explanation: { program, path: { kind: "one_shot", why }, pruning } } };
+  };
+  if (split.kind === "failed") return oneCall({ kind: "unsplit", over: null, message: split.message }, []);
+  if (split.kind === "whole") return oneCall({ kind: "whole", reason: split.reason }, split.pruning);
+  const pieceBytes = pieceBytesOf(options);
+  let heaviest = split.over;
+  let bytes = -1;
+  for (const name of [split.over, ...split.copartitioned]) {
+    const weighs = (_a = weights.get(name)) == null ? void 0 : _a.bytes;
+    if (weighs === void 0) return oneCall({ kind: "unweighed", over: name }, split.pruning);
+    if (weighs > bytes) [heaviest, bytes] = [name, weighs];
+  }
+  if (bytes <= pieceBytes) return oneCall({ kind: "small", over: heaviest, bytes, pieceBytes }, split.pruning);
+  const joined = split.rekey === null ? void 0 : (_b = weights.get(split.rekey.name)) == null ? void 0 : _b.bytes;
+  const rekey = split.rekey !== null && joined !== void 0 && joined > pieceBytes ? split.rekey : null;
+  let call;
+  try {
+    call = splitCallOf(draft, split, rekey !== null);
+  } catch (err) {
+    return oneCall({ kind: "unsplit", over: split.over, message: messageOf(err) }, split.pruning);
+  }
+  const explanation = {
+    program,
+    path: {
+      kind: "split",
+      over: split.over,
+      heaviest,
+      bytes,
+      pieceBytes,
+      output: split.output.kind,
+      stages: split.stages,
+      // A re-keyed join reads its other side cut at the same keys, not whole.
+      broadcast: rekey === null ? split.broadcast : split.broadcast.filter((name) => name !== rekey.name),
+      copartitioned: split.copartitioned,
+      rekey: rekey === null ? null : { name: rekey.name, key: rekey.key, bytes }
+    },
+    pruning: split.pruning
+  };
+  return { plan: "request" in call ? { kind: "split", ...call, explanation } : { kind: "rekey", ...call, explanation } };
+}
+function planQuery(programs, root, weights, options = {}) {
+  const drafted = draftPlan(programs, root, options);
+  if ("result" in drafted) return drafted;
+  return weighPlan(drafted.draft, weights);
+}
+function splitCallOf(draft, split, rekey) {
+  var _a, _b, _c;
+  const { programs, root, options } = draft;
+  const { maxOutputs } = queryLimits(options);
+  let checked = draft.checked;
+  let call = split;
+  if (programs.split !== programs.query) {
+    checked = checkJq(programs.split, root.type, { root: true });
+    if (checked.program === null) throw new Error(`the run's split program does not check: ${((_a = checked.diagnostics[0]) == null ? void 0 : _a.message) ?? ""}`);
+    const wrapped = splitJq(checked, checked.multiplicity === "many" ? { maxOutputs } : {});
+    const same = wrapped.kind === "split" && wrapped.over === split.over && wrapped.output.kind === split.output.kind && wrapped.copartitioned.join("\n") === split.copartitioned.join("\n") && ((_b = wrapped.rekey) == null ? void 0 : _b.name) === ((_c = split.rekey) == null ? void 0 : _c.name);
+    if (!same) {
+      throw new Error(`the run's split program splits otherwise than the query: ${wrapped.kind === "split" ? `${wrapped.output.kind} over ${wrapped.over}` : wrapped.reason.code}`);
+    }
+    call = wrapped;
+  }
+  if (!programChecks(checked)) throw new Error("the query does not check");
+  const entry = (name) => entryNamed(root, name, "splitCallRequest");
+  if (!rekey) return { request: splitCallRequest(call, root, options), reading: { checked, entries: call.inputs.map((input) => entry(input.name)), maxOutputs } };
+  const joined = call.inputs.filter((input) => input.name !== call.over).map((input) => entry(input.name));
+  return { ...rekeyCallRequests(call, root, options), reading: { checked, entries: [entry(call.over), ...joined], maxOutputs } };
+}
+function splitCallRequest(split, root, options = {}) {
+  const { limits, runner } = queryLimits(options);
+  const then = split.then();
+  return {
+    bodyIr: encodeEastIR(split.piece().toIR()),
+    args: split.inputs.map((input) => ({
+      arg: variant("dataset", entryNamed(root, input.name, "splitCallRequest").path),
+      partition: input.name === split.over || split.copartitioned.includes(input.name) ? some({ by: [] }) : none
+    })),
+    output: outputOf(split.output),
+    then: then === null ? none : some(encodeEastIR(then.toIR())),
+    runner,
+    limits
+  };
+}
+function rekeyCallRequests(split, root, options = {}) {
+  const rekey = split.rekey;
+  if (rekey === null) throw new Error("rekeyCallRequests: the split re-keys no join");
+  const { limits, runner } = queryLimits(options);
+  const path = (name) => entryNamed(root, name, "rekeyCallRequests").path;
+  const first = {
+    bodyIr: encodeEastIR(rekey.piece().toIR()),
+    args: [{ arg: variant("dataset", path(split.over)), partition: some({ by: [] }) }],
+    output: variant("dict", { merge: some(encodeEastIR(rekey.output.merge().toIR())) }),
+    then: none,
+    runner,
+    limits: some({
+      timeoutMs: limits.type === "some" ? limits.value.timeoutMs : none,
+      maxResultBytes: some(1n),
+      maxLogBytes: limits.type === "some" ? limits.value.maxLogBytes : none
+    })
+  };
+  const piece = encodeEastIR(rekey.joinPiece().toIR());
+  const then = rekey.joinThen();
+  const thenIr = then === null ? none : some(encodeEastIR(then.toIR()));
+  return {
+    first,
+    join: (output) => ({
+      bodyIr: piece,
+      args: rekey.inputs.map((input) => input.name === split.over ? { arg: variant("object", output), partition: some({ by: [] }) } : { arg: variant("dataset", path(input.name)), partition: input.name === rekey.name ? some({ by: [] }) : none }),
+      output: outputOf(split.output),
+      then: thenIr,
+      runner,
+      limits
+    }),
+    answer: (firstResult, joinResult) => ({
+      ...joinResult ?? firstResult,
+      inputs: [...firstResult.inputs, ...(joinResult == null ? void 0 : joinResult.inputs) ?? []]
+    })
+  };
+}
+function outputOf(output) {
+  switch (output.kind) {
+    case "array":
+      return variant("array", null);
+    case "set":
+      return variant("set", null);
+    case "dict":
+      return variant("dict", { merge: some(encodeEastIR(output.merge().toIR())) });
+    case "fold":
+      return variant("fold", { combine: encodeEastIR(output.combine().toIR()), zero: encodeBeast2For(output.type)(output.zero) });
+  }
+}
+const samePath = equalFor(TreePathType);
+function hold(datasets) {
+  return datasets.map((dataset) => {
+    let encoded;
+    let hash = dataset.hash;
+    const bytes = () => encoded ?? (encoded = encodeBeast2For(dataset.type)(dataset.value));
+    return { ...dataset, hashOf: () => hash ?? (hash = sha256Hex(bytes())), bytesOf: () => dataset.bytes ?? bytes().length };
+  });
+}
+const QUIET = { stdout: "", stdoutTruncated: false, stderrTruncated: false };
+function invalid(message) {
+  return { ...QUIET, outcome: variant("invalid", { diagnostics: [{ message, filename: none, line: none, column: none }] }), stderr: "", inputs: [] };
+}
+function unassigned(i, path) {
+  return `Dataset argument ${i} is not assigned (ref type: unassigned): nothing in memory at ${pathToString(path)}`;
+}
+function maxResultBytes(limits) {
+  return limits.type === "some" && limits.value.maxResultBytes.type === "some" ? limits.value.maxResultBytes.value : void 0;
+}
+function answer(type, value, limits, inputs) {
+  const bytes = encodeBeast2For(type)(value);
+  const limit = maxResultBytes(limits);
+  if (limit !== void 0 && BigInt(bytes.length) > limit) {
+    return { ...QUIET, outcome: variant("too_large", { bytes: BigInt(bytes.length), limit }), stderr: "", inputs };
+  }
+  return { ...QUIET, outcome: variant("success", { value: bytes }), stderr: "", inputs };
+}
+function raised(err, inputs) {
+  return { ...QUIET, outcome: variant("failed", { exitCode: 1n }), stderr: `Error: ${err.toString()}
+`, inputs };
+}
+function createInMemoryQueryCall(datasets) {
+  const held = hold(datasets);
+  return async (request) => {
+    const read = [];
+    for (const [i, arg] of request.args.entries()) {
+      const found = arg.type === "dataset" ? held.find((d) => samePath(d.path, arg.value)) : void 0;
+      if (found === void 0) {
+        return invalid(arg.type === "dataset" ? unassigned(i, arg.value) : `Argument ${i} is an inline value, which an in-memory call does not take`);
+      }
+      read.push(found);
+    }
+    const inputs = read.map((d) => ({ path: d.path, hash: d.hashOf() }));
+    const body = decodeEastIR(request.bodyIr);
+    const type = fromEastTypeValue(body.ir.value.type);
+    if (type.type !== "Function") throw new Error("createInMemoryQueryCall: a call's body is a function");
+    let value;
+    try {
+      value = body.compile([])(...read.map((d) => d.value));
+    } catch (err) {
+      if (!(err instanceof EastError)) throw err;
+      return raised(err, inputs);
+    }
+    return answer(type.output, value, request.limits, inputs);
+  };
+}
+function compiled(ir, what) {
+  const decoded = decodeEastIR(ir);
+  const type = fromEastTypeValue(decoded.ir.value.type);
+  if (type.type !== "Function") throw new Error(`createInMemorySplitCall: the call's ${what} is a function`);
+  return { fn: decoded.compile([]), inputs: type.inputs, output: type.output };
+}
+function cut(value, type, k) {
+  const t = type.type === "Recursive" ? type.node : type;
+  const runs = (rows) => Array.from({ length: k }, (_, i) => rows.slice(Math.floor(i * rows.length / k), Math.floor((i + 1) * rows.length / k)));
+  switch (t.type) {
+    case "Array":
+      return runs(value);
+    case "Set": {
+      const compare = compareFor(t.key);
+      return runs([...value]).map((rows) => new SortedSet(rows, compare));
+    }
+    case "Dict": {
+      const compare = compareFor(t.key);
+      return runs([...value.entries()]).map((rows) => new SortedMap(rows, compare));
+    }
+    default:
+      throw new Error(`createInMemorySplitCall: a partitioned argument is an Array, a Set or a Dict, not ${t.type}`);
+  }
+}
+function opened(type) {
+  return type.type === "Recursive" ? type.node : type;
+}
+function cutAt(value, type, fences, k) {
+  const compare = compareFor(opened(type).key);
+  const entries = [...value.entries()];
+  return Array.from({ length: k }, (_, i) => {
+    if (i > fences.length) return new SortedMap([], compare);
+    const lo = i === 0 ? void 0 : fences[i - 1];
+    const hi = i === fences.length ? void 0 : fences[i];
+    return new SortedMap(entries.filter(([key]) => (lo === void 0 || compare(key, lo) >= 0) && (hi === void 0 || compare(key, hi) < 0)), compare);
+  });
+}
+function cutTogether(values, types, partitioned, k) {
+  if (partitioned.length === 1) return { pieces: /* @__PURE__ */ new Map([[partitioned[0], cut(values[partitioned[0]], types[partitioned[0]], k)]]), over: partitioned[0] };
+  const keys = partitioned.map((i) => opened(types[i]));
+  const first = keys[0];
+  if (!keys.every((t) => t.type === "Dict" && first.type === "Dict" && isTypeEqual(t.key, first.key))) {
+    return "arguments partitioned together are dicts keyed by one type: their pieces are cut at the same keys";
+  }
+  let heaviest = partitioned[0];
+  let most = -1;
+  for (const i of partitioned) {
+    const bytes = encodeBeast2For(types[i])(values[i]).length;
+    if (bytes > most) [heaviest, most] = [i, bytes];
+  }
+  const runs = cut(values[heaviest], types[heaviest], k);
+  const fences = [];
+  for (const run of runs.slice(1)) {
+    const start = run.keys().next();
+    if (start.done === true) break;
+    fences.push(start.value);
+  }
+  return { pieces: new Map(partitioned.map((i) => [i, cutAt(values[i], types[i], fences, k)])), over: heaviest };
+}
+function progress(phase, done, units) {
+  return { phase: variant(phase, null), done: BigInt(done), units: BigInt(units) };
+}
+function createInMemorySplitCall(datasets, options) {
+  const pieces = options.pieces;
+  if (!Number.isSafeInteger(pieces) || pieces < 1) throw new RangeError(`createInMemorySplitCall: pieces is ${pieces}, not a whole number of at least 1`);
+  const held = hold(datasets);
+  const stored = /* @__PURE__ */ new Map();
+  const argumentsOf = (request) => {
+    const values = [];
+    const weights = [];
+    const inputs = [];
+    const partitioned = [];
+    for (const [i, { arg, partition }] of request.args.entries()) {
+      if (partition.type === "some") partitioned.push(i);
+      if (arg.type === "dataset") {
+        const found = held.find((d) => samePath(d.path, arg.value));
+        if (found === void 0) return unassigned(i, arg.value);
+        values.push(found.value);
+        weights.push(found.bytesOf());
+        inputs.push({ path: found.path, hash: found.hashOf() });
+      } else if (arg.type === "value") {
+        values.push(decodeBeast2(arg.value).value);
+        weights.push(arg.value.length);
+      } else {
+        const output = stored.get(arg.value);
+        if (output === void 0) return `Object argument ${i} names ${arg.value}, which the repository does not hold`;
+        values.push(output.value);
+        weights.push(output.bytes);
+      }
+    }
+    if (partitioned.length === 0) return "a split call partitions at least one of its arguments: its pieces are cut from it";
+    return { values, weights, inputs, partitioned };
+  };
+  const call = async (request, { signal, onProgress }) => {
+    const refused2 = (message) => ({ result: invalid(message), output: null });
+    const resolved = argumentsOf(request);
+    if (typeof resolved === "string") return refused2(resolved);
+    const { values, inputs, partitioned } = resolved;
+    const body = compiled(request.bodyIr, "body");
+    const emitType = body.inputs.at(-1);
+    if ((emitType == null ? void 0 : emitType.type) !== "Function") throw new Error("createInMemorySplitCall: the body's last parameter is its emit function");
+    const emitted = emitType.inputs;
+    const then = request.then.type === "some" ? compiled(request.then.value, "final function") : void 0;
+    const output = request.output;
+    const cut2 = cutTogether(values, body.inputs, partitioned, pieces);
+    if (typeof cut2 === "string") return refused2(cut2);
+    const cuts = cut2.pieces;
+    let hash = null;
+    try {
+      const outputs = [];
+      onProgress(progress("partition", 0, pieces));
+      for (let p = 0; p < pieces; p++) {
+        signal.throwIfAborted();
+        const args = values.map((value, i) => {
+          var _a;
+          return ((_a = cuts.get(i)) == null ? void 0 : _a[p]) ?? value;
+        });
+        const out = [];
+        body.fn(...args, (...emit) => {
+          out.push(emit);
+          return null;
+        });
+        outputs.push(out);
+        onProgress(progress("partition", p + 1, pieces));
+        await Promise.resolve();
+      }
+      signal.throwIfAborted();
+      let assembled;
+      let type;
+      switch (output.type) {
+        case "array":
+          type = ArrayType(emitted[0]);
+          assembled = outputs.flatMap((out) => out.map(([row]) => row));
+          break;
+        case "set": {
+          const key = emitted[0];
+          type = SetType(key);
+          onProgress(progress("merge", 0, 1));
+          assembled = new SortedSet(outputs.flatMap((out) => out.map(([row]) => row)), compareFor(key));
+          onProgress(progress("merge", 1, 1));
+          break;
+        }
+        case "dict": {
+          const [key, value] = [emitted[0], emitted[1]];
+          type = DictType(key, value);
+          const merge = output.value.merge.type === "some" ? compiled(output.value.merge.value, "merge").fn : void 0;
+          const printKey = printFor(key);
+          const into = (dict, k, v) => {
+            if (!dict.has(k)) {
+              dict.set(k, v);
+              return;
+            }
+            if (merge === void 0) throw new EastError(`the key ${printKey(k)} is emitted twice, and the dict output has no merge`);
+            dict.set(k, merge(k, dict.get(k), v));
+          };
+          const perPiece = outputs.map((out) => {
+            const dict = new SortedMap([], compareFor(key));
+            for (const [k, v] of out) into(dict, k, v);
+            return dict;
+          });
+          onProgress(progress("merge", 0, 1));
+          const all = new SortedMap([], compareFor(key));
+          for (const dict of perPiece) for (const [k, v] of dict) into(all, k, v);
+          onProgress(progress("merge", 1, 1));
+          assembled = all;
+          break;
+        }
+        case "fold": {
+          type = emitted[0];
+          const combine = compiled(output.value.combine, "combine").fn;
+          const zero = decodeBeast2For(type)(output.value.zero);
+          const partials = outputs.map((out) => out.reduce((acc, [v]) => combine(acc, v), zero));
+          onProgress(progress("combine", 0, 1));
+          assembled = partials.reduce((acc, v) => combine(acc, v), zero);
+          onProgress(progress("combine", 1, 1));
+          break;
+        }
+      }
+      const bytes = encodeBeast2For(type)(assembled);
+      hash = sha256Hex(bytes);
+      stored.set(hash, { value: assembled, bytes: bytes.length });
+      if (then === void 0) return { result: answer(type, assembled, request.limits, inputs), output: hash };
+      return { result: answer(then.output, then.fn(assembled, ...values), request.limits, inputs), output: hash };
+    } catch (err) {
+      if (!(err instanceof EastError)) throw err;
+      return { result: raised(err, inputs), output: hash };
+    }
+  };
+  const explain = async (request, { signal }) => {
+    signal.throwIfAborted();
+    const args = argumentsOf(request);
+    if (typeof args === "string") throw new Error(`Split call explain refused: ${args}`);
+    const cut2 = cutTogether(args.values, compiled(request.bodyIr, "body").inputs, args.partitioned, pieces);
+    if (typeof cut2 === "string") throw new Error(`Split call explain refused: ${cut2}`);
+    return { pieces: BigInt(pieces), over: BigInt(cut2.over), bytes: BigInt(args.weights[cut2.over]) };
+  };
+  return Object.assign(call, { explain });
+}
+function createInMemorySourceStatus(datasets) {
+  const held = hold(datasets);
+  return async (path) => {
+    const found = held.find((d) => samePath(d.path, path));
+    if (found === void 0) throw new Error(`createInMemorySourceStatus: nothing in memory at ${pathToString(path)}`);
+    return { rows: rowsOf(found), hash: found.hashOf(), bytes: found.bytesOf() };
+  };
+}
+function rowsOf(dataset) {
+  switch (dataset.type.type) {
+    case "Array":
+      return dataset.value.length;
+    case "Set":
+      return dataset.value.size;
+    case "Dict":
+      return dataset.value.size;
+    default:
+      return void 0;
+  }
+}
+export {
+  createInMemorySourceStatus as a,
+  createInMemorySplitCall as b,
+  createInMemoryQueryCall as c,
+  draftPlan as d,
+  prepareQuery as e,
+  programChecks as f,
+  queryRoot as g,
+  planQuery as p,
+  queryResultOf as q,
+  rekeyCallRequests as r,
+  splitCallRequest as s,
+  weighPlan as w
+};
+//# sourceMappingURL=in-memory-call-7_3frW52.js.map