@milaboratories/pl-middle-layer 1.10.12

package/dist/index.mjs

@@ -0,0 +1,3587 @@
+var Kt = Object.defineProperty;
+var Mt = (o, e, t) => e in o ? Kt(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var d = (o, e, t) => Mt(o, typeof e != "symbol" ? e + "" : e, t);
+import { executePSpecPredicate as $t, mapPObjectData as z, mapValueInVOE as Ut, mapPTableDef as ct, isFunctionHandle as ut, normalizeBlockConfig as xe, DefaultNavigationState as Gt } from "@platforma-sdk/model";
+export * from "@platforma-sdk/model";
+export * from "@milaboratories/pl-model-middle-layer";
+import { request as ne } from "undici";
+import { RegistryV1 as U, tryLoadPackDescription as lt, loadPackDescription as He } from "@platforma-sdk/block-tools";
+import T from "node:fs";
+import I from "node:path";
+import Ht from "yaml";
+import { assertNever as D, notEmpty as w, HmacSha256Signer as dt, ConsoleLoggerAdapter as _t } from "@milaboratories/ts-helpers";
+import * as Wt from "node:fs/promises";
+import { resourceTypesEqual as K, field as S, Pl as y, PlClient as zt, isNullResourceId as ce, ensureResourceIdNotNull as we, isResource as qt, isResourceRef as Yt, isNotNullResourceId as _e, resourceType as X, resourceTypeToString as Qt, resourceIdToString as pt, isNotFoundError as Zt, isTimeoutOrCancelError as Xt, toGlobalResourceId as er } from "@milaboratories/pl-client";
+export * from "@milaboratories/pl-client";
+import { FieldType as Xs, ResourceType as en } from "@milaboratories/pl-client";
+import { SynchronizedTreeState as ht, PlError as tr } from "@milaboratories/pl-tree";
+import { Computable as P, ChangeSource as We, PollComputablePool as rr, WatchableValue as or } from "@milaboratories/computable";
+import { randomUUID as Y, createHash as he } from "node:crypto";
+import ft from "denque";
+import { Templates as sr } from "@platforma-sdk/workflow-tengo";
+import Ee from "canonicalize";
+import nr from "node:assert";
+import { Scope as Se, getQuickJS as ir } from "quickjs-emscripten";
+import { setTimeout as ar } from "node:timers/promises";
+import * as gt from "node:os";
+import { createDownloadClient as cr, createLogsClient as ur, createUploadBlobClient as lr, createUploadProgressClient as dr, createLsFilesClient as pr, DownloadDriver as hr, UploadDriver as fr, LogsStreamDriver as gr, LogsDriver as mr, LsDriver as vr, DownloadUrlDriver as yr } from "@milaboratories/pl-drivers";
+async function ze(o) {
+  try {
+    return await Wt.stat(o, { bigint: !0 });
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+}
+const br = [U.PlPackageYamlConfigFile], wr = [U.PlPackageJsonConfigFile], je = ["backend", "dist", "tengo", "tpl", "main.plj.gz"], Te = ["config", "dist", "config.json"], mt = ["frontend", "dist"], qe = "block-model/dist/config.json", Sr = "block-ui/package.json", kr = [
+  je,
+  Te,
+  br,
+  wr,
+  mt
+];
+async function Cr(o) {
+  return await ze(I.join(o, ...Te)) !== void 0 || await ze(I.join(o, ...je)) !== void 0;
+}
+function Pr(o, e) {
+  try {
+    return require.resolve(e, {
+      paths: [o]
+    });
+  } catch (t) {
+    if (t.code !== "MODULE_NOT_FOUND") throw t;
+  }
+}
+function me(o, e) {
+  const t = Pr(o, e);
+  if (t === void 0) throw new Error(`Can't resolve ${e} against ${o}`);
+  return t;
+}
+async function Ye(o, e) {
+  if (I.isAbsolute(o) || (o = I.resolve(o)), await Cr(o))
+    return {
+      workflow: I.join(o, ...je),
+      config: I.join(o, ...Te),
+      ui: I.join(o, ...mt)
+    };
+  {
+    const t = me(o, qe), r = me(o, qe), s = me(o, Sr);
+    return { workflow: t, config: r, ui: I.resolve(s, "..", "dist") };
+  }
+}
+async function Fr(o) {
+  try {
+    return await T.promises.readFile(o, "utf8");
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+}
+async function Br(o) {
+  try {
+    return await T.promises.stat(o, { bigint: !0 });
+  } catch (e) {
+    if (e.code === "ENOENT")
+      return;
+    throw e;
+  }
+}
+async function vt(o) {
+  let e = 0n;
+  for (const t of kr) {
+    const r = I.join(o, ...t), s = await Br(r);
+    s !== void 0 && e < s.mtimeNs && (e = s.mtimeNs);
+  }
+  return e.toString();
+}
+async function Ae(o) {
+  const e = await T.promises.stat(o.components.workflow.file, { bigint: !0 }), t = await T.promises.stat(o.components.model.file, { bigint: !0 });
+  return (e.mtimeNs > t.mtimeNs ? e.mtimeNs : t.mtimeNs).toString();
+}
+class Hs {
+  constructor(e, t) {
+    this.registrySpecs = e, this.http = t;
+  }
+  async getPackagesForRoot(e) {
+    const t = [];
+    switch (e.type) {
+      case "remote_v1":
+        const r = this.http !== void 0 ? { dispatcher: this.http } : {}, n = await (await ne(
+          `${e.url}/${U.GlobalOverviewPath}`,
+          r
+        )).body.json();
+        for (const i of n) {
+          const { organization: a, package: u, latestMeta: c, latestVersion: l } = i;
+          t.push({
+            organization: a,
+            package: u,
+            name: u,
+            latestVersion: l,
+            latestMeta: c,
+            registryLabel: e.label,
+            latestSpec: {
+              type: "from-registry-v1",
+              registryUrl: e.url,
+              organization: a,
+              package: u,
+              version: l
+              // `${regSpec.url}/${packageContentPrefix({ organization, package: pkg, version: latestVersion })}`
+            },
+            otherVersions: i.allVersions
+          });
+        }
+        return t;
+      case "folder_with_dev_packages":
+        for (const i of await T.promises.readdir(e.path, { withFileTypes: !0 })) {
+          if (!i.isDirectory()) continue;
+          const a = I.join(e.path, i.name), u = await Fr(
+            I.join(a, U.PlPackageYamlConfigFile)
+          );
+          if (u !== void 0) {
+            const l = U.PlPackageConfigData.parse(Ht.parse(u)), p = await vt(a);
+            t.push({
+              organization: l.organization,
+              package: l.package,
+              // TODO delete
+              name: l.package,
+              latestVersion: "DEV",
+              latestMeta: l.meta,
+              registryLabel: e.label,
+              latestSpec: {
+                type: "dev-v1",
+                folder: a,
+                mtime: p
+              },
+              otherVersions: []
+            });
+          }
+          const c = await lt(a);
+          if (c !== void 0) {
+            const l = await Ae(c);
+            t.push({
+              organization: c.id.organization,
+              package: c.id.name,
+              // TODO delete
+              name: c.id.name,
+              latestVersion: `${c.id.version}-DEV`,
+              latestMeta: c.meta,
+              registryLabel: e.label,
+              latestSpec: {
+                type: "dev-v2",
+                folder: a,
+                mtime: l
+              },
+              otherVersions: []
+            });
+          }
+        }
+        return t;
+      default:
+        return D(e);
+    }
+  }
+  async getPackagesOverview() {
+    const e = [];
+    for (const t of this.registrySpecs)
+      e.push(...await this.getPackagesForRoot(t));
+    return e;
+  }
+}
+const _s = {
+  type: "remote_v1",
+  label: "Central Release Registry",
+  url: "https://block.registry.platforma.bio/releases"
+}, Ws = {
+  type: "remote_v1",
+  label: "Central Dev Snapshot registry",
+  url: "https://block.registry.platforma.bio/dev"
+}, Rr = {
+  groups: [{ id: "default", label: "Default", blocks: [] }]
+}, Or = {
+  stagingRefreshTimestamp: 0,
+  blocksInLimbo: []
+}, Dr = {
+  label: "New Project"
+}, xr = { name: "UserProject", version: "2" }, yt = "SchemaVersion", bt = "1", Ie = "ProjectCreated", Q = "ProjectLastModified", Z = "ProjectMeta", G = "ProjectStructure", ue = "BlockRenderingState", Er = "BlockFrontendState/", jr = /^BlockFrontendState\/(?<blockid>.*)$/;
+function ke(o) {
+  return `${Er}${o}`;
+}
+const Tr = "BlockArgsAuthor/";
+function Ce(o) {
+  return `${Tr}${o}`;
+}
+const Pe = "ProjectStructureAuthor";
+function Ar(o) {
+  const e = o.match(jr);
+  if (e !== null)
+    return e.groups.blockid;
+}
+const Ir = "__serviceTemplate_";
+function Fe(o) {
+  return `${Ir}${o}`;
+}
+function C(o, e) {
+  return `${o}-${e}`;
+}
+const Vr = /^(?<blockId>.*)-(?<fieldName>blockPack|prodArgs|currentArgs|prodCtx|prodUiCtx|prodOutput|prodCtxPrevious|prodUiCtxPrevious|prodOutputPrevious|stagingCtx|stagingUiCtx|stagingOutput|stagingCtxPrevious|stagingUiCtxPrevious|stagingOutputPrevious)$/;
+function Nr(o) {
+  const e = o.match(Vr);
+  if (e === null) return;
+  const { blockId: t, fieldName: r } = e.groups;
+  return { blockId: t, fieldName: r };
+}
+const Lr = "projects", wt = { name: "Projects", version: "1" }, Jr = (o) => K(o.type, wt) ? o.fields : [];
+async function Kr(o, e, t, r) {
+  const s = await ht.init(o, e, {
+    ...r.ops.defaultTreeOptions,
+    pruning: Jr
+  });
+  return { computable: P.make((i) => {
+    const a = i.accessor(s.entry()).node(), u = t.getValue(i);
+    if (a === void 0) return;
+    const c = [];
+    for (const l of a.listDynamicFields()) {
+      const p = a.traverse(l);
+      if (p === void 0) continue;
+      const h = w(p.getKeyValueAsJson(Z)), g = w(p.getKeyValueAsJson(Ie)), b = w(p.getKeyValueAsJson(Q));
+      c.push({
+        id: l,
+        rid: p.id,
+        created: new Date(g),
+        lastModified: new Date(b),
+        opened: u.indexOf(p.id) >= 0,
+        meta: h
+      });
+    }
+    return c.sort((l) => -l.lastModified.valueOf()), c;
+  }).withStableType(), tree: s };
+}
+const Mr = {
+  name: "EphRenderTemplate",
+  version: "1"
+}, $r = {
+  name: "RenderTemplate",
+  version: "1"
+};
+function St(o, e, t, r, s) {
+  if (s.length === 0) throw new Error("Zero output names provided");
+  const n = t ? o.createEphemeral(Mr) : o.createStruct($r), i = S(n, "template"), a = S(n, "inputs");
+  return o.createField(i, "Input", e), o.createField(a, "Input", y.createPlMap(o, r, t)), o.lockInputs(n), y.futureRecord(o, n, s, "Output", "outputs/");
+}
+const Ur = { name: "BContextEnd", version: "1" }, Gr = { name: "BContext", version: "1" }, Hr = "id", _r = "parent/", Wr = ["context", "result"];
+function Qe(o, e, t) {
+  return St(o, e, !0, t, Wr);
+}
+function zr(o) {
+  const e = o.createEphemeral(Ur);
+  return o.lock(e), e;
+}
+function qr(o, e) {
+  if (e.length === 0) return zr(o);
+  if (e.length === 1) return e[0];
+  const t = o.createEphemeral(Gr);
+  o.createField(S(t, Hr), "Input", y.createPlString(o, Y()));
+  for (let r = 0; r < e.length; r++)
+    o.createField(S(t, `${_r}${r}`), "Input", e[r]);
+  return o.lock(t), t;
+}
+const Yr = { name: "TengoTemplateGet", version: "1" }, Qr = "registry", Zr = "templateURI", Xr = "template", eo = { name: "TengoTemplatePack", version: "1" }, to = {
+  name: "TengoTemplatePackConvert",
+  version: "1"
+}, ro = "templatePack", oo = "template";
+async function so(o) {
+  switch (o.type) {
+    case "from-file":
+      return {
+        type: "explicit",
+        content: await T.promises.readFile(o.path)
+      };
+    case "from-registry":
+    case "explicit":
+      return o;
+    default:
+      return D(o);
+  }
+}
+function no(o, e) {
+  const t = o.createStruct(Yr), r = S(t, Qr), s = S(t, Zr), n = S(t, Xr);
+  return o.setField(r, o.createValue(y.JsonString, Buffer.from(JSON.stringify(e.registry)))), o.setField(s, o.createValue(y.JsonString, Buffer.from(JSON.stringify(e.path)))), n;
+}
+function io(o, e) {
+  const t = o.createValue(eo, e.content), r = o.createStruct(to), s = S(r, ro), n = S(r, oo);
+  return o.setField(s, t), n;
+}
+function Ve(o, e) {
+  switch (e.type) {
+    case "from-registry":
+      return no(o, e);
+    case "explicit":
+      return io(o, e);
+    default:
+      return D(e);
+  }
+}
+const kt = { name: "Frontend/FromUrl", version: "1" }, Ct = {
+  name: "Frontend/FromFolder",
+  version: "1"
+};
+function ao(o, e) {
+  switch (e.type) {
+    case "url":
+      return o.createValue(
+        kt,
+        JSON.stringify({ url: e.url })
+      );
+    case "local":
+      return o.createValue(
+        Ct,
+        JSON.stringify({
+          path: e.path,
+          signature: e.signature
+        })
+      );
+    default:
+      return D(e);
+  }
+}
+const co = { name: "BlockPackCustom", version: "1" }, Pt = "template", Ft = "frontend";
+function Ze(o) {
+  return o.endsWith("/") ? o : `${o}/`;
+}
+class uo {
+  constructor(e, t) {
+    this.signer = e, this.http = t;
+  }
+  async getBlockConfig(e) {
+    switch (e.type) {
+      case "explicit":
+        return e.config;
+      case "dev":
+      case "dev-v1": {
+        const t = await Ye(e.folder), r = await T.promises.readFile(t.config, { encoding: "utf-8" });
+        return JSON.parse(r);
+      }
+      case "dev-v2": {
+        const t = await He(e.folder), r = await T.promises.readFile(t.components.model.file, {
+          encoding: "utf-8"
+        });
+        return JSON.parse(r);
+      }
+      case "from-registry-v1": {
+        const t = this.http !== void 0 ? { dispatcher: this.http } : {}, r = `${Ze(e.registryUrl)}${U.packageContentPrefix(e)}`;
+        return await (await ne(`${r}/config.json`, t)).body.json();
+      }
+      default:
+        return D(e);
+    }
+  }
+  async prepare(e) {
+    switch (e.type) {
+      case "explicit":
+        return e;
+      case "dev":
+      case "dev-v1": {
+        const t = await Ye(e.folder), r = await T.promises.readFile(t.workflow), s = JSON.parse(
+          await T.promises.readFile(t.config, "utf-8")
+        ), n = t.ui;
+        return {
+          type: "explicit",
+          template: {
+            type: "explicit",
+            content: r
+          },
+          config: s,
+          frontend: {
+            type: "local",
+            path: n,
+            signature: this.signer.sign(n)
+          },
+          source: e
+        };
+      }
+      case "dev-v2": {
+        const t = await He(e.folder), r = JSON.parse(
+          await T.promises.readFile(t.components.model.file, {
+            encoding: "utf-8"
+          })
+        ), s = await T.promises.readFile(t.components.workflow.file), n = t.components.ui.folder, i = { ...e };
+        return e.mtime === void 0 && (i.mtime = await Ae(t)), {
+          type: "explicit",
+          template: {
+            type: "explicit",
+            content: s
+          },
+          config: r,
+          frontend: {
+            type: "local",
+            path: n,
+            signature: this.signer.sign(n)
+          },
+          source: i
+        };
+      }
+      case "from-registry-v1": {
+        const t = this.http !== void 0 ? { dispatcher: this.http } : {}, r = `${Ze(e.registryUrl)}${U.packageContentPrefix(e)}`, s = `${r}/template.plj.gz`, n = await ne(s, t);
+        if (n.statusCode !== 200)
+          throw new Error(
+            `Block not found in registry (url = ${s} ; code = ${n.statusCode}): ` + JSON.stringify(e)
+          );
+        const i = new Uint8Array(await n.body.arrayBuffer()), u = await (await ne(`${r}/config.json`, t)).body.json();
+        return {
+          type: "explicit",
+          template: {
+            type: "explicit",
+            content: i
+          },
+          config: u,
+          frontend: {
+            type: "url",
+            url: `${r}/frontend.tgz`
+          },
+          source: e
+        };
+      }
+      default:
+        return D(e);
+    }
+  }
+}
+function lo(o, e) {
+  const t = { config: e.config, source: e.source }, r = o.createStruct(co, JSON.stringify(t));
+  return o.createField(S(r, Pt), "Input", Ve(o, e.template)), o.createField(S(r, Ft), "Input", ao(o, e.frontend)), o.lock(r), r;
+}
+function Xe(o, e) {
+  switch (e.type) {
+    case "explicit":
+      return lo(o, e);
+    default:
+      return D(e.type);
+  }
+}
+function se(o, e) {
+  return { __isRef: !0, blockId: o, name: e };
+}
+function po(o) {
+  return typeof o == "object" && o !== null && o.__isRef === !0 && "blockId" in o && "name" in o;
+}
+function Be(o, e, t) {
+  const r = typeof e;
+  switch (r) {
+    case "function":
+    case "bigint":
+    case "number":
+    case "string":
+    case "boolean":
+    case "symbol":
+    case "undefined":
+      return;
+    case "object":
+      if (e === null) return;
+      if (po(e))
+        t === void 0 || t.has(e.blockId) ? o.upstreams.add(e.blockId) : o.missingReferences = !0;
+      else if (Array.isArray(e))
+        for (const s of e) Be(o, s, t);
+      else
+        for (const [, s] of Object.entries(e))
+          Be(o, s, t);
+      return;
+    default:
+      D(r);
+  }
+}
+function ho(o, e) {
+  const t = { upstreams: /* @__PURE__ */ new Set(), missingReferences: !1 };
+  return Be(t, o, e), t;
+}
+function V(o) {
+  return {
+    *[Symbol.iterator]() {
+      for (const e of o.groups) for (const t of e.blocks) yield t;
+    }
+  };
+}
+class Bt {
+  constructor(e) {
+    /** Nodes are stored in the map in topological order */
+    d(this, "nodes");
+    this.nodes = e;
+  }
+  traverseIds(e, ...t) {
+    const r = /* @__PURE__ */ new Set();
+    return this.traverse(e, t, (s) => r.add(s.id)), r;
+  }
+  traverseIdsExcludingRoots(e, ...t) {
+    const r = this.traverseIds(e, ...t);
+    for (const s of t) r.delete(s);
+    return r;
+  }
+  traverse(e, t, r) {
+    let s = [...t];
+    const n = new Set(s);
+    for (; s.length > 0; ) {
+      let i = [];
+      for (const a of s) {
+        const u = this.nodes.get(a);
+        r(u), u[e].forEach((c) => {
+          n.has(c) || (n.add(c), i.push(c));
+        });
+      }
+      s = i;
+    }
+  }
+}
+function Re(o) {
+  const e = /* @__PURE__ */ new Map();
+  let t;
+  for (const { id: r } of V(o)) {
+    const s = {
+      id: r,
+      missingReferences: !1
+    };
+    e.set(r, s), t === void 0 ? s.upstream = /* @__PURE__ */ new Set() : (s.upstream = /* @__PURE__ */ new Set([t.id]), t.downstream = /* @__PURE__ */ new Set([s.id])), t = s;
+  }
+  return t !== void 0 && (t.downstream = /* @__PURE__ */ new Set()), new Bt(e);
+}
+function ie(o, e) {
+  const t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set();
+  for (const { id: s } of V(o)) {
+    const n = e(s);
+    if (n === void 0) continue;
+    const i = ho(n, r), a = {
+      id: s,
+      missingReferences: i.missingReferences,
+      upstream: i.upstreams,
+      downstream: /* @__PURE__ */ new Set()
+      // will be populated from downstream blocks
+    };
+    t.set(s, a), i.upstreams.forEach((u) => t.get(u).downstream.add(s)), r.add(s);
+  }
+  return new Bt(t);
+}
+function fo(o, e) {
+  if (o.size !== e.size) return !1;
+  for (const t of o) if (!e.has(t)) return !1;
+  return !0;
+}
+function Oe(o, e) {
+  if (o.size > e.size) return Oe(e, o);
+  for (const t of o) if (e.has(t)) return !0;
+  return !1;
+}
+function et(o, e) {
+  const t = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  return o.nodes.forEach((n) => {
+    const i = e.nodes.get(n.id);
+    i === void 0 ? t.add(n.id) : (!fo(n.upstream, i.upstream) || Oe(n.upstream, s)) && s.add(n.id);
+  }), e.nodes.forEach((n) => {
+    o.nodes.has(n.id) ? Oe(n.upstream, s) && s.add(n.id) : r.add(n.id);
+  }), { onlyInA: t, onlyInB: r, different: s };
+}
+let ve;
+async function Rt() {
+  if (ve === void 0) {
+    const o = await so(sr["pframes.export-pframe"]);
+    if (o.type !== "explicit") throw new Error("Unexpected prepared template type.");
+    const e = he("sha256").update(o.content).digest("hex");
+    ve = { spec: o, hash: e };
+  }
+  return ve;
+}
+function go(o, e, t) {
+  return St(o, e, !0, { pf: t }, ["result"]).result;
+}
+function ye(o, e) {
+  let t = !1, r, s;
+  return () => {
+    if (!t)
+      return t = !0, r = o(), s = e(), s;
+    const n = o();
+    return r !== n && (r = n, s = e()), e();
+  };
+}
+class tt {
+  constructor(e, t) {
+    d(this, "currentInputsC", ye(
+      () => this.fields.currentArgs.modCount,
+      () => JSON.parse(Buffer.from(this.fields.currentArgs.value).toString())
+    ));
+    d(this, "actualProductionInputsC", ye(
+      () => {
+        var e;
+        return (e = this.fields.prodArgs) == null ? void 0 : e.modCount;
+      },
+      () => {
+        var t;
+        const e = (t = this.fields.prodArgs) == null ? void 0 : t.value;
+        if (e !== void 0)
+          return JSON.parse(Buffer.from(e).toString());
+      }
+    ));
+    d(this, "productionStaleC", ye(
+      () => {
+        var e;
+        return `${this.fields.currentArgs.modCount}_${(e = this.fields.prodArgs) == null ? void 0 : e.modCount}`;
+      },
+      () => this.fields.prodArgs === void 0 || Buffer.compare(this.fields.currentArgs.value, this.fields.prodArgs.value) !== 0
+    ));
+    this.id = e, this.fields = t;
+  }
+  check() {
+    if (this.fields.prodOutput === void 0 != (this.fields.prodCtx === void 0))
+      throw new Error("inconsistent prod fields");
+    if (this.fields.stagingOutput === void 0 != (this.fields.stagingCtx === void 0))
+      throw new Error("inconsistent stage fields");
+    if (this.fields.prodOutputPrevious === void 0 != (this.fields.prodCtxPrevious === void 0))
+      throw new Error("inconsistent prod cache fields");
+    if (this.fields.stagingOutputPrevious === void 0 != (this.fields.stagingCtxPrevious === void 0))
+      throw new Error("inconsistent stage cache fields");
+    if (this.fields.blockPack === void 0) throw new Error("no block pack field");
+    if (this.fields.currentArgs === void 0) throw new Error("no current args field");
+  }
+  get currentInputs() {
+    return this.currentInputsC();
+  }
+  get stagingRendered() {
+    return this.fields.stagingCtx !== void 0;
+  }
+  get productionRendered() {
+    return this.fields.prodCtx !== void 0;
+  }
+  get productionStale() {
+    return this.productionRendered && this.productionStaleC();
+  }
+  get requireProductionRendering() {
+    return !this.productionRendered || this.productionStaleC();
+  }
+  get actualProductionInputs() {
+    return this.actualProductionInputsC();
+  }
+  getTemplate(e) {
+    return e.getFutureFieldValue(
+      y.unwrapHolder(e, this.fields.blockPack.ref),
+      Pt,
+      "Input"
+    );
+  }
+}
+const mo = (o) => {
+  throw new Error(`No new block info for ${o}`);
+};
+class le {
+  constructor(e, t, r, s, n, i, a, u, c, l, p, h) {
+    d(this, "globalModCount", 0);
+    d(this, "fieldsChanged", !1);
+    //
+    // Change trackers
+    //
+    d(this, "lastModifiedChanged", !1);
+    d(this, "structureChanged", !1);
+    d(this, "metaChanged", !1);
+    d(this, "renderingStateChanged", !1);
+    d(this, "changedBlockFrontendStates", /* @__PURE__ */ new Set());
+    /** Set blocks will be assigned current mutator author marker on save */
+    d(this, "blocksWithChangedInputs", /* @__PURE__ */ new Set());
+    //
+    // Graph calculation
+    //
+    d(this, "stagingGraph");
+    d(this, "pendingProductionGraph");
+    d(this, "actualProductionGraph");
+    this.rid = e, this.tx = t, this.author = r, this.schema = s, this.lastModified = n, this.meta = i, this.struct = a, this.renderingState = u, this.blocksInLimbo = c, this.blockInfos = l, this.blockFrontendStates = p, this.ctxExportTplHolder = h;
+  }
+  fixProblems() {
+    this.blockInfos.forEach((e) => {
+      (e.fields.prodArgs === void 0 || e.fields.prodOutput === void 0 || e.fields.prodCtx === void 0) && this.deleteBlockFields(e.id, "prodArgs", "prodOutput", "prodCtx");
+    });
+  }
+  get wasModified() {
+    return this.lastModifiedChanged || this.structureChanged || this.fieldsChanged || this.metaChanged || this.renderingStateChanged || this.changedBlockFrontendStates.size > 0;
+  }
+  get structure() {
+    return JSON.parse(JSON.stringify(this.struct));
+  }
+  getStagingGraph() {
+    return this.stagingGraph === void 0 && (this.stagingGraph = Re(this.struct)), this.stagingGraph;
+  }
+  getPendingProductionGraph() {
+    return this.pendingProductionGraph === void 0 && (this.pendingProductionGraph = ie(
+      this.struct,
+      (e) => this.getBlockInfo(e).currentInputs
+    )), this.pendingProductionGraph;
+  }
+  getActualProductionGraph() {
+    return this.actualProductionGraph === void 0 && (this.actualProductionGraph = ie(
+      this.struct,
+      (e) => this.getBlockInfo(e).actualProductionInputs
+    )), this.actualProductionGraph;
+  }
+  //
+  // Generic helpers to interact with project state
+  //
+  getBlockInfo(e) {
+    return w(this.blockInfos.get(e));
+  }
+  getBlock(e) {
+    for (const t of V(this.struct)) if (t.id === e) return t;
+    throw new Error("block not found");
+  }
+  setBlockFieldObj(e, t, r) {
+    const s = S(this.rid, C(e, t));
+    if (r.ref === void 0) throw new Error("Can't set value with empty ref");
+    this.getBlockInfo(e).fields[t] === void 0 ? this.tx.createField(s, "Dynamic", r.ref) : this.tx.setField(s, r.ref), this.getBlockInfo(e).fields[t] = {
+      modCount: this.globalModCount++,
+      ...r
+    }, this.fieldsChanged = !0;
+  }
+  setBlockField(e, t, r, s, n) {
+    this.setBlockFieldObj(e, t, { ref: r, status: s, value: n });
+  }
+  deleteBlockFields(e, ...t) {
+    let r = !1;
+    const s = this.getBlockInfo(e);
+    for (const n of t) {
+      const i = s.fields;
+      n in i && (this.tx.removeField(S(this.rid, C(e, n))), delete i[n], this.fieldsChanged = !0, r = !0);
+    }
+    return r;
+  }
+  updateLastModified() {
+    this.lastModified = Date.now(), this.lastModifiedChanged = !0;
+  }
+  //
+  // Main project actions
+  //
+  resetStagingRefreshTimestamp() {
+    this.renderingState.stagingRefreshTimestamp = Date.now(), this.renderingStateChanged = !0;
+  }
+  resetStaging(e) {
+    var r, s, n;
+    const t = this.getBlockInfo(e).fields;
+    ((r = t.stagingOutput) == null ? void 0 : r.status) === "Ready" && ((s = t.stagingCtx) == null ? void 0 : s.status) === "Ready" && ((n = t.stagingUiCtx) == null ? void 0 : n.status) === "Ready" && (this.setBlockFieldObj(e, "stagingOutputPrevious", t.stagingOutput), this.setBlockFieldObj(e, "stagingCtxPrevious", t.stagingCtx), this.setBlockFieldObj(e, "stagingUiCtxPrevious", t.stagingUiCtx)), this.deleteBlockFields(e, "stagingOutput", "stagingCtx", "stagingUiCtx") && this.resetStagingRefreshTimestamp();
+  }
+  resetProduction(e) {
+    var r, s, n;
+    const t = this.getBlockInfo(e).fields;
+    ((r = t.prodOutput) == null ? void 0 : r.status) === "Ready" && ((s = t.prodCtx) == null ? void 0 : s.status) === "Ready" && ((n = t.prodUiCtx) == null ? void 0 : n.status) === "Ready" && (this.setBlockFieldObj(e, "prodOutputPrevious", t.prodOutput), this.setBlockFieldObj(e, "prodCtxPrevious", t.prodCtx), this.setBlockFieldObj(e, "prodUiCtxPrevious", t.prodUiCtx)), this.deleteBlockFields(e, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs");
+  }
+  /** Running blocks are reset, already computed moved to limbo. Returns if
+   * either of the actions were actually performed. */
+  resetOrLimboProduction(e) {
+    var r, s;
+    const t = this.getBlockInfo(e).fields;
+    return ((r = t.prodOutput) == null ? void 0 : r.status) === "Ready" && ((s = t.prodCtx) == null ? void 0 : s.status) === "Ready" ? this.blocksInLimbo.has(e) ? !1 : (this.blocksInLimbo.add(e), this.renderingStateChanged = !0, this.deleteBlockFields(e, "prodOutputPrevious", "prodCtxPrevious", "prodUiCtxPrevious"), !0) : this.deleteBlockFields(e, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs");
+  }
+  /** Optimally sets inputs for multiple blocks in one go */
+  setArgs(e) {
+    const t = [];
+    for (const { blockId: r, args: s } of e) {
+      const n = this.getBlockInfo(r);
+      JSON.parse(s);
+      const i = Buffer.from(s);
+      if (Buffer.compare(n.fields.currentArgs.value, i) === 0) continue;
+      const a = this.tx.createValue(y.JsonObject, i);
+      this.setBlockField(r, "currentArgs", a, "Ready", i), this.blocksWithChangedInputs.add(r), t.push(r);
+    }
+    this.getStagingGraph().traverse("downstream", t, ({ id: r }) => this.resetStaging(r)), t.length > 0 && this.updateLastModified();
+  }
+  setUiState(e, t) {
+    if (this.blockInfos.get(e) === void 0) throw new Error("no such block");
+    this.blockFrontendStates.get(e) !== t && (t === void 0 ? this.blockFrontendStates.delete(e) : this.blockFrontendStates.set(e, t), this.changedBlockFrontendStates.add(e), this.blocksWithChangedInputs.add(e), this.updateLastModified());
+  }
+  /** Update block label */
+  setBlockLabel(e, t) {
+    const r = this.structure;
+    let s = !1;
+    for (const n of V(r))
+      if (n.id === e) {
+        n.label = t, s = !0;
+        break;
+      }
+    if (!s) throw new Error(`block ${e} not found`);
+    this.updateStructure(r), this.updateLastModified();
+  }
+  createCtx(e, t) {
+    const r = [];
+    return e.forEach((s) => {
+      const n = this.getBlockInfo(s);
+      if (n.fields[t] === void 0 || n.fields[t].ref === void 0)
+        throw new Error("One of the upstreams staging is not rendered.");
+      r.push(y.unwrapHolder(this.tx, n.fields[t].ref));
+    }), qr(this.tx, r);
+  }
+  exportCtx(e) {
+    return go(this.tx, y.unwrapHolder(this.tx, this.ctxExportTplHolder), e);
+  }
+  renderStagingFor(e) {
+    this.resetStaging(e);
+    const t = this.getBlockInfo(e), r = this.createCtx(this.getStagingGraph().nodes.get(e).upstream, "stagingCtx");
+    if (this.getBlock(e).renderingMode !== "Heavy") throw new Error("not supported yet");
+    const s = t.getTemplate(this.tx), n = Qe(this.tx, s, {
+      args: t.fields.currentArgs.ref,
+      blockId: this.tx.createValue(y.JsonString, JSON.stringify(e)),
+      isProduction: this.tx.createValue(y.JsonBool, JSON.stringify(!1)),
+      context: r
+    });
+    this.setBlockField(
+      e,
+      "stagingCtx",
+      y.wrapInEphHolder(this.tx, n.context),
+      "NotReady"
+    ), this.setBlockField(e, "stagingUiCtx", this.exportCtx(n.context), "NotReady"), this.setBlockField(e, "stagingOutput", n.result, "NotReady");
+  }
+  renderProductionFor(e) {
+    this.resetProduction(e);
+    const t = this.getBlockInfo(e), r = this.createCtx(
+      this.getPendingProductionGraph().nodes.get(e).upstream,
+      "prodCtx"
+    );
+    if (this.getBlock(e).renderingMode === "Light")
+      throw new Error("Can't render production for light block.");
+    const s = t.getTemplate(this.tx), n = Qe(this.tx, s, {
+      args: t.fields.currentArgs.ref,
+      blockId: this.tx.createValue(y.JsonString, JSON.stringify(e)),
+      isProduction: this.tx.createValue(y.JsonBool, JSON.stringify(!0)),
+      context: r
+    });
+    this.setBlockField(
+      e,
+      "prodCtx",
+      y.wrapInEphHolder(this.tx, n.context),
+      "NotReady"
+    ), this.setBlockField(e, "prodUiCtx", this.exportCtx(n.context), "NotReady"), this.setBlockField(e, "prodOutput", n.result, "NotReady"), this.setBlockFieldObj(e, "prodArgs", t.fields.currentArgs), this.blocksInLimbo.delete(e) && (this.renderingStateChanged = !0);
+  }
+  //
+  // Structure changes
+  //
+  /** Very generic method, better check for more specialized case-specific methods first. */
+  updateStructure(e, t = mo) {
+    const r = this.getStagingGraph(), s = this.getActualProductionGraph(), n = Re(e), i = ie(
+      e,
+      (c) => {
+        var l;
+        return (l = this.blockInfos.get(c)) == null ? void 0 : l.actualProductionInputs;
+      }
+    ), a = et(r, n), u = et(s, i);
+    for (const c of a.onlyInA) {
+      const { fields: l } = this.getBlockInfo(c);
+      this.deleteBlockFields(c, ...Object.keys(l)), this.blockInfos.delete(c), this.blocksInLimbo.delete(c) && (this.renderingStateChanged = !0), this.blockFrontendStates.delete(c) && this.changedBlockFrontendStates.add(c);
+    }
+    for (const c of a.onlyInB) {
+      const l = new tt(c, {});
+      this.blockInfos.set(c, l);
+      const p = t(c), h = Xe(this.tx, p.blockPack);
+      this.setBlockField(c, "blockPack", y.wrapInHolder(this.tx, h), "NotReady");
+      const g = Buffer.from(p.args), b = this.tx.createValue(y.JsonObject, g);
+      this.setBlockField(c, "currentArgs", b, "Ready", g), l.check();
+    }
+    for (const c of a.different) this.resetStaging(c);
+    s.traverse("downstream", [...u.different], (c) => {
+      this.resetOrLimboProduction(c.id);
+    }), (a.onlyInB.size > 0 || a.onlyInA.size > 0 || a.different.size > 0) && this.resetStagingRefreshTimestamp(), this.struct = e, this.structureChanged = !0, this.stagingGraph = void 0, this.pendingProductionGraph = void 0, this.actualProductionGraph = void 0, this.updateLastModified();
+  }
+  //
+  // Structure change helpers
+  //
+  addBlock(e, t, r) {
+    const s = this.structure;
+    if (r === void 0)
+      s.groups[s.groups.length - 1].blocks.push(e);
+    else {
+      let n = !1;
+      for (const i of s.groups) {
+        const a = i.blocks.findIndex((u) => u.id === r);
+        if (!(a < 0)) {
+          i.blocks.splice(a, 0, e), n = !0;
+          break;
+        }
+      }
+      if (!n) throw new Error(`Can't find element with id: ${r}`);
+    }
+    this.updateStructure(s, (n) => {
+      if (n !== e.id) throw new Error("Unexpected");
+      return t;
+    });
+  }
+  deleteBlock(e) {
+    const t = this.structure;
+    let r = !1;
+    for (const s of t.groups) {
+      const n = s.blocks.findIndex((i) => i.id === e);
+      if (!(n < 0)) {
+        s.blocks.splice(n, 1), r = !0;
+        break;
+      }
+    }
+    if (!r) throw new Error(`Can't find element with id: ${e}`);
+    this.updateStructure(t);
+  }
+  //
+  // Block-pack migration
+  //
+  migrateBlockPack(e, t, r) {
+    const s = this.getBlockInfo(e);
+    this.setBlockField(
+      e,
+      "blockPack",
+      y.wrapInHolder(this.tx, Xe(this.tx, t)),
+      "NotReady"
+    ), r !== void 0 ? (this.setArgs([{ blockId: e, args: r }]), this.setUiState(e, void 0)) : this.getStagingGraph().traverse("downstream", [e], ({ id: n }) => this.resetStaging(n)), s.productionRendered && this.getActualProductionGraph().traverse(
+      "downstream",
+      [e],
+      ({ id: n }) => this.resetOrLimboProduction(n)
+    ), this.updateLastModified();
+  }
+  //
+  // Render
+  //
+  renderProduction(e, t = !1) {
+    const r = new Set(e), s = this.getPendingProductionGraph();
+    if (t)
+      s.traverse("upstream", e, (i) => {
+        r.add(i.id);
+      });
+    else
+      for (const i of r) {
+        const a = s.nodes.get(i);
+        if (a === void 0) throw new Error(`Can't find block with id: ${i}`);
+        for (const u of a.upstream)
+          if (!r.has(u))
+            throw new Error("Can't render blocks not including all upstreams.");
+      }
+    const n = /* @__PURE__ */ new Set();
+    for (const i of V(this.structure)) {
+      if (!r.has(i.id)) continue;
+      let a = this.getBlockInfo(i.id).requireProductionRendering || this.blocksInLimbo.has(i.id);
+      if (!a) {
+        for (const u of s.nodes.get(i.id).upstream)
+          if (n.has(u)) {
+            a = !0;
+            break;
+          }
+      }
+      a && (this.renderProductionFor(i.id), n.add(i.id));
+    }
+    return s.traverse("downstream", [...n], (i) => {
+      n.has(i.id) || this.resetOrLimboProduction(i.id);
+    }), n.size > 0 && this.updateLastModified(), n;
+  }
+  /** Stops running blocks from the list and modify states of other blocks
+   * accordingly */
+  stopProduction(...e) {
+    var i, a;
+    const t = this.getActualProductionGraph(), r = new ft(e), s = new Set(e), n = [];
+    for (; !r.isEmpty(); ) {
+      const u = r.shift(), c = this.getBlockInfo(u).fields;
+      if (!(((i = c.prodOutput) == null ? void 0 : i.status) === "Ready" && ((a = c.prodCtx) == null ? void 0 : a.status) === "Ready") && this.deleteBlockFields(u, "prodOutput", "prodCtx", "prodUiCtx", "prodArgs")) {
+        n.push(u);
+        for (const l of t.traverseIdsExcludingRoots("downstream", u))
+          s.has(l) || (r.push(l), s.add(l));
+      }
+    }
+    for (const u of t.traverseIdsExcludingRoots("downstream", ...n))
+      this.resetOrLimboProduction(u);
+  }
+  traverseWithStagingLag(e) {
+    const t = /* @__PURE__ */ new Map();
+    this.getStagingGraph().nodes.forEach((s) => {
+      let i = this.getBlockInfo(s.id).stagingRendered ? 0 : 1;
+      s.upstream.forEach((a) => {
+        const u = t.get(a);
+        u !== 0 && (i = Math.max(u + 1, i));
+      }), e(s.id, i), t.set(s.id, i);
+    });
+  }
+  /** @param stagingRenderingRate rate in blocks per second */
+  refreshStagings(e) {
+    const t = Date.now() - this.renderingState.stagingRefreshTimestamp, r = e === void 0 ? void 0 : 1 + Math.max(0, t * e / 1e3);
+    let s = 0;
+    this.traverseWithStagingLag((n, i) => {
+      i !== 0 && (r === void 0 || i <= r) && (this.renderStagingFor(n), s++);
+    }), s > 0 && this.resetStagingRefreshTimestamp();
+  }
+  //
+  // Meta
+  //
+  /** Updates project metadata */
+  setMeta(e) {
+    this.meta = e, this.metaChanged = !0, this.updateLastModified();
+  }
+  //
+  // Maintenance
+  //
+  /** @param stagingRenderingRate rate in blocks per second */
+  doRefresh(e) {
+    this.refreshStagings(e), this.blockInfos.forEach((t) => {
+      var r, s, n, i;
+      ((r = t.fields.prodCtx) == null ? void 0 : r.status) === "Ready" && ((s = t.fields.prodOutput) == null ? void 0 : s.status) === "Ready" && this.deleteBlockFields(
+        t.id,
+        "prodOutputPrevious",
+        "prodCtxPrevious",
+        "prodUiCtxPrevious"
+      ), ((n = t.fields.stagingCtx) == null ? void 0 : n.status) === "Ready" && ((i = t.fields.stagingOutput) == null ? void 0 : i.status) === "Ready" && this.deleteBlockFields(
+        t.id,
+        "stagingOutputPrevious",
+        "stagingCtxPrevious",
+        "stagingUiCtxPrevious"
+      );
+    });
+  }
+  assignAuthorMarkers() {
+    const e = this.author ? JSON.stringify(this.author) : void 0;
+    for (const t of this.blocksWithChangedInputs)
+      e === void 0 ? this.tx.deleteKValue(this.rid, Ce(t)) : this.tx.setKValue(this.rid, Ce(t), e);
+    (this.metaChanged || this.structureChanged) && (e === void 0 ? this.tx.deleteKValue(this.rid, Pe) : this.tx.setKValue(this.rid, Pe, e));
+  }
+  save() {
+    if (this.wasModified) {
+      this.lastModifiedChanged && this.tx.setKValue(this.rid, Q, JSON.stringify(this.lastModified)), this.structureChanged && this.tx.setKValue(this.rid, G, JSON.stringify(this.struct)), this.renderingStateChanged && this.tx.setKValue(
+        this.rid,
+        ue,
+        JSON.stringify({
+          ...this.renderingState,
+          blocksInLimbo: [...this.blocksInLimbo]
+        })
+      ), this.metaChanged && this.tx.setKValue(this.rid, Z, JSON.stringify(this.meta));
+      for (const e of this.changedBlockFrontendStates) {
+        const t = this.blockFrontendStates.get(e);
+        t === void 0 ? this.tx.deleteKValue(this.rid, ke(e)) : this.tx.setKValue(this.rid, ke(e), t);
+      }
+      this.assignAuthorMarkers();
+    }
+  }
+  static async load(e, t, r) {
+    const s = e.getResourceData(t, !0), n = e.getKValueJson(t, yt), i = e.getKValueJson(t, Q), a = e.getKValueJson(t, Z), u = e.getKValueJson(t, G), c = e.getKValueJson(t, ue), l = e.listKeyValuesString(t), [
+      p,
+      h,
+      g,
+      b,
+      B,
+      { stagingRefreshTimestamp: M, blocksInLimbo: ee },
+      te
+    ] = await Promise.all([
+      s,
+      n,
+      i,
+      a,
+      u,
+      c,
+      l
+    ]);
+    if (h !== bt)
+      throw new Error(
+        `Can't act on this project resource because it has a wrong schema version: ${h}`
+      );
+    const $ = /* @__PURE__ */ new Map();
+    for (const v of p.fields) {
+      const O = Nr(v.name);
+      if (O === void 0) continue;
+      let F = $.get(O.blockId);
+      F === void 0 && (F = {
+        id: O.blockId,
+        fields: {}
+      }, $.set(O.blockId, F)), F.fields[O.fieldName] = ce(v.value) ? { modCount: 0 } : { modCount: 0, ref: v.value };
+    }
+    const H = await Rt(), re = Fe(H.hash), k = p.fields.find(
+      (v) => v.name === re
+    );
+    let L;
+    k !== void 0 ? L = we(k.value) : (L = y.wrapInHolder(e, Ve(e, H.spec)), e.createField(
+      S(t, Fe(H.hash)),
+      "Dynamic",
+      L
+    ));
+    const _ = { stagingRefreshTimestamp: M }, j = new Set(ee), x = /* @__PURE__ */ new Map();
+    for (const v of te) {
+      const O = Ar(v.key);
+      O !== void 0 && x.set(O, v.value);
+    }
+    const R = [];
+    $.forEach(({ id: v, fields: O }) => {
+      for (const [, F] of Object.entries(O))
+        if (F.ref !== void 0) {
+          if (!qt(F.ref) || Yt(F.ref))
+            throw new Error("unexpected behaviour");
+          R.push([F, e.getResourceData(F.ref, !1)]);
+        }
+    });
+    for (const [v, O] of R) {
+      const F = await O;
+      v.value = F.data, _e(F.error) ? v.status = "Error" : F.resourceReady || _e(F.originalResourceId) ? v.status = "Ready" : v.status = "NotReady";
+    }
+    const J = /* @__PURE__ */ new Map();
+    $.forEach(({ id: v, fields: O }) => J.set(v, new tt(v, O)));
+    const N = /* @__PURE__ */ new Set();
+    for (const v of V(B)) {
+      if (!J.has(v.id))
+        throw new Error(`Inconsistent project structure: no inputs for ${v.id}`);
+      N.add(v.id);
+    }
+    J.forEach((v) => {
+      if (!N.has(v.id))
+        throw new Error(`Inconsistent project structure: no structure entry for ${v.id}`);
+      v.check();
+    });
+    const oe = new le(
+      t,
+      e,
+      r,
+      h,
+      g,
+      b,
+      B,
+      _,
+      j,
+      J,
+      x,
+      L
+    );
+    return oe.fixProblems(), oe;
+  }
+}
+async function vo(o, e = Dr) {
+  const t = o.createEphemeral(xr);
+  o.lock(t);
+  const r = String(Date.now());
+  o.setKValue(t, yt, JSON.stringify(bt)), o.setKValue(t, Ie, r), o.setKValue(t, Q, r), o.setKValue(t, Z, JSON.stringify(e)), o.setKValue(t, G, JSON.stringify(Rr)), o.setKValue(t, ue, JSON.stringify(Or));
+  const s = await Rt();
+  return o.createField(
+    S(t, Fe(s.hash)),
+    "Dynamic",
+    y.wrapInHolder(o, Ve(o, s.spec))
+  ), t;
+}
+async function be(o, e, t) {
+  return A(o, e, void 0, t);
+}
+async function A(o, e, t, r) {
+  if (o instanceof zt)
+    return await o.withWriteTx("ProjectAction", async (s) => {
+      const n = await le.load(s, e, t), i = await r(n);
+      return n.wasModified && (n.save(), await s.commit()), i;
+    });
+  {
+    const s = await le.load(o, e, t), n = await r(s);
+    return s.save(), n;
+  }
+}
+function* yo(o) {
+  switch (o.type) {
+    case "Json":
+      return;
+    case "JsonPartitioned":
+      for (const [, e] of Object.entries(o.parts)) yield e;
+      return;
+    case "BinaryPartitioned":
+      for (const [, { index: e, values: t }] of Object.entries(o.parts))
+        yield e, yield t;
+      return;
+    default:
+      D(o);
+  }
+}
+function rt(o, e) {
+  return Object.fromEntries(
+    Object.entries(o).map(([t, r]) => [t, e(r, t)])
+  );
+}
+function bo(o, e) {
+  switch (o.type) {
+    case "Json":
+      return { ...o };
+    case "JsonPartitioned":
+      return { ...o, parts: rt(o.parts, e) };
+    case "BinaryPartitioned":
+      return {
+        ...o,
+        parts: rt(o.parts, (t) => ({
+          index: e(t.index),
+          values: e(t.values)
+        }))
+      };
+    default:
+      D(o);
+  }
+}
+const wo = X("PColumnData/JsonPartitioned", "1"), So = X(
+  "PColumnData/Partitioned/JsonPartitioned",
+  "1"
+), ko = X("PColumnData/BinaryPartitioned", "1"), Co = X(
+  "PColumnData/Partitioned/BinaryPartitioned",
+  "1"
+), Po = X("PColumnData/Json", "1");
+function Fo(o) {
+  if (!o.getIsReadyOrError()) throw new Error("Data not ready.");
+  const e = o.getDataAsJson();
+  if (e === void 0)
+    throw new Error("unexpected data info structure, no resource data");
+  if (K(o.resourceType, Po)) {
+    const t = e;
+    return {
+      type: "Json",
+      keyLength: t.keyLength,
+      data: t.data
+    };
+  } else if (K(o.resourceType, wo)) {
+    const t = e, r = Object.fromEntries(
+      o.listInputFields().map((s) => [s, o.traverse({ field: s, errorIfFieldNotSet: !0 }).resourceInfo])
+    );
+    return {
+      type: "JsonPartitioned",
+      partitionKeyLength: t.partitionKeyLength,
+      parts: r
+    };
+  } else if (K(o.resourceType, So)) {
+    const t = e, r = {};
+    for (const s of o.listInputFields()) {
+      const n = o.traverse({ field: s, errorIfFieldNotSet: !0 }), i = n.listInputFields();
+      if (i === void 0) throw new Error(`no partition keys for super key ${s}`);
+      for (const a of i) {
+        const u = s.slice(0, s.length - 1) + "," + a.slice(1, a.length);
+        r[u] = n.traverse({ field: a, errorIfFieldNotSet: !0 }).resourceInfo;
+      }
+    }
+    return {
+      type: "JsonPartitioned",
+      partitionKeyLength: t.superPartitionKeyLength + t.partitionKeyLength,
+      parts: r
+    };
+  } else if (K(o.resourceType, ko)) {
+    const t = e, r = {};
+    for (const s of o.listInputFields())
+      if (s.endsWith(".index")) {
+        const n = s.slice(0, s.length - 6);
+        let i = r[n];
+        i === void 0 && (i = {}, r[n] = i), i.index = o.traverse({ field: s, errorIfFieldNotSet: !0 }).resourceInfo;
+      } else if (s.endsWith(".values")) {
+        const n = s.slice(0, s.length - 7);
+        let i = r[n];
+        i === void 0 && (i = {}, r[n] = i), i.values = o.traverse({ field: s, errorIfFieldNotSet: !0 }).resourceInfo;
+      } else throw new Error(`unrecognized part field name: ${s}`);
+    for (const [s, n] of Object.entries(r)) {
+      if (n.index === void 0) throw new Error(`no index for part ${s}`);
+      if (n.values === void 0) throw new Error(`no values for part ${s}`);
+    }
+    return {
+      type: "BinaryPartitioned",
+      partitionKeyLength: t.partitionKeyLength,
+      parts: r
+    };
+  } else if (K(o.resourceType, Co)) {
+    const t = e, r = {};
+    for (const s of o.listInputFields()) {
+      const n = o.traverse({ field: s, errorIfFieldNotSet: !0 }), i = n.listInputFields();
+      if (i === void 0) throw new Error(`no partition keys for super key ${s}`);
+      for (const a of i)
+        if (a.endsWith(".index")) {
+          const u = a.slice(0, a.length - 6), c = s.slice(0, s.length - 1) + "," + u.slice(1, u.length);
+          let l = r[c];
+          l === void 0 && (l = {}, r[c] = l), r[c].index = n.traverse({
+            field: a,
+            errorIfFieldNotSet: !0
+          }).resourceInfo;
+        } else if (a.endsWith(".values")) {
+          const u = a.slice(0, a.length - 7), c = s.slice(0, s.length - 1) + "," + u.slice(1, u.length);
+          let l = r[c];
+          l === void 0 && (l = {}, r[c] = l), r[c].values = n.traverse({
+            field: a,
+            errorIfFieldNotSet: !0
+          }).resourceInfo;
+        } else throw new Error(`unrecognized part field name: ${a}`);
+    }
+    return {
+      type: "BinaryPartitioned",
+      partitionKeyLength: t.superPartitionKeyLength + t.partitionKeyLength,
+      parts: r
+    };
+  }
+  throw new Error(`unsupported resource type: ${Qt(o.resourceType)}`);
+}
+function Ot(o, e) {
+  const t = he("sha256");
+  return t.update(Ee(o)), t.update(String(ce(e.originalId) ? e.id : e.originalId)), t.digest().toString("hex");
+}
+function Dt(o, e = !0, t = !1, r = "") {
+  var a, u, c;
+  const s = /^(?<name>.*)\.(?<type>spec|data)$/, n = /* @__PURE__ */ new Map();
+  for (const l of o.listInputFields()) {
+    const p = l.match(s);
+    if (!p) {
+      if (e) throw new Error(`unexpected field name ${l}`);
+      continue;
+    }
+    let h = w((a = p.groups) == null ? void 0 : a.name);
+    if (!h.startsWith(r)) {
+      if (e) throw new Error(`unexpected field name ${l}`);
+      continue;
+    }
+    h = h.slice(r.length);
+    const g = w((u = p.groups) == null ? void 0 : u.type);
+    let b = n.get(h);
+    switch (b === void 0 && (b = {}, n.set(h, b)), g) {
+      case "spec":
+        b.spec = (c = o.traverse({
+          field: l,
+          ignoreError: t,
+          pureFieldErrorToUndefined: t
+        })) == null ? void 0 : c.getDataAsJson();
+        break;
+      case "data":
+        b.hasData = !0, b.data = () => o.traverseOrError({
+          field: l,
+          ignoreError: t
+        });
+      default:
+        continue;
+    }
+  }
+  const i = o.getInputsLocked();
+  if (i)
+    for (const [, l] of n) l.data === void 0 && (l.hasData = !1);
+  return { locked: i, results: n };
+}
+function Bo(o, e = !0, t = "") {
+  if (!o.getIsReadyOrError()) throw new Error("resource is not ready");
+  const r = Dt(o, e, !1, t);
+  nr(r.locked);
+  const s = {};
+  for (const [n, i] of r.results) {
+    if (i.spec === void 0) throw new Error(`no spec for key ${n}`);
+    if (i.hasData !== !0 || i.data === void 0)
+      throw new Error(`no data for key ${n}`);
+    const a = i.data();
+    if (a === void 0) throw new Error(`no data for key ${n}`);
+    if (!a.ok) throw new tr(a.error);
+    s[n] = {
+      id: Ot(i.spec, a.value),
+      spec: i.spec,
+      data: a.value
+    };
+  }
+  return s;
+}
+class Ne {
+  constructor(e, t) {
+    d(this, "allSpecsAvailable");
+    this.ctx = e, this.blocks = t;
+    let r = !0;
+    e: for (const s of t.values())
+      for (const n of [s.prod, s.staging])
+        if (n !== void 0) {
+          if (!n.locked) {
+            r = !1;
+            break e;
+          }
+          for (const i of n.results.values())
+            if (i.spec === void 0) {
+              r = !1;
+              break e;
+            }
+        }
+    this.allSpecsAvailable = r;
+  }
+  getBlockLabel(e) {
+    var t, r;
+    return w((r = (t = this.blocks.get(e)) == null ? void 0 : t.info) == null ? void 0 : r.label, `block "${e}" not found`);
+  }
+  getData() {
+    const e = this.getDataWithErrors(), t = [];
+    for (const r of e.entries)
+      r.obj.id !== void 0 && r.obj.data.ok && t.push({
+        ref: r.ref,
+        obj: {
+          id: r.obj.id,
+          spec: r.obj.spec,
+          data: r.obj.data.value
+        }
+      });
+    return {
+      entries: t,
+      isComplete: e.isComplete,
+      instabilityMarker: e.instabilityMarker
+    };
+  }
+  getDataWithErrors() {
+    const e = [];
+    let t = !0, r;
+    const s = (i) => {
+      r === void 0 && (r = i), t = !1;
+    }, n = (i, a, u) => {
+      if (u.spec !== void 0 && u.hasData === !0 && u.data !== void 0) {
+        const c = u.data();
+        c !== void 0 ? e.push({
+          ref: se(i, a),
+          obj: {
+            id: c.ok ? Ot(u.spec, c.value) : void 0,
+            spec: u.spec,
+            data: c
+          }
+        }) : s(`no_data:${i}:${a}`);
+      }
+    };
+    for (const [i, a] of this.blocks) {
+      const u = /* @__PURE__ */ new Set();
+      if (a.prod !== void 0) {
+        a.prod.locked || s(`prod_not_locked:${i}`);
+        for (const [c, l] of a.prod.results)
+          u.add(c), n(i, c, l);
+      }
+      if (a.staging !== void 0) {
+        a.staging.locked || s(`staging_not_locked:${i}`);
+        for (const [c, l] of a.staging.results)
+          u.has(c) || n(i, c, l);
+      }
+    }
+    return { entries: e, isComplete: t, instabilityMarker: r };
+  }
+  getSpecs() {
+    const e = [];
+    let t = !0, r;
+    const s = (n) => {
+      r === void 0 && (r = n), t = !1;
+    };
+    for (const [n, i] of this.blocks) {
+      const a = /* @__PURE__ */ new Set();
+      if (i.staging !== void 0) {
+        i.staging.locked || s(`staging_not_locked:${n}`);
+        for (const [u, c] of i.staging.results)
+          c.spec !== void 0 && (e.push({
+            ref: se(n, u),
+            obj: c.spec
+          }), a.add(u));
+      } else s(`staging_not_rendered:${n}`);
+      if (i.prod !== void 0) {
+        i.prod.locked || s(`prod_not_locked:${n}`);
+        for (const [u, c] of i.prod.results)
+          a.has(u) || c.spec !== void 0 && e.push({
+            ref: se(n, u),
+            obj: c.spec
+          });
+      }
+    }
+    return { entries: e, isComplete: t, instabilityMarker: r };
+  }
+  calculateOptions(e) {
+    const t = [];
+    for (const r of this.blocks.values()) {
+      const s = /* @__PURE__ */ new Set(), n = (i) => {
+        for (const [a, u] of i.results)
+          s.has(a) || u.spec === void 0 || (s.add(a), $t(e, u.spec) && t.push({
+            label: r.info.label + " / " + a,
+            ref: se(r.info.id, a),
+            spec: u.spec
+          }));
+      };
+      r.staging !== void 0 && n(r.staging), r.prod !== void 0 && n(r.prod);
+    }
+    return t;
+  }
+  static create(e, t, r) {
+    const s = e.accessor(t).node(), n = w(s.getKeyValueAsJson(G)), a = Re(n).traverseIds("upstream", r), u = /* @__PURE__ */ new Map();
+    for (const c of V(n)) {
+      if (!a.has(c.id)) continue;
+      const l = ot(
+        s.traverse({
+          field: C(c.id, "prodCtx"),
+          ignoreError: !0,
+          pureFieldErrorToUndefined: !0,
+          stableIfNotFound: !0
+        }) !== void 0,
+        s.traverseOrError({
+          field: C(c.id, "prodUiCtx"),
+          stableIfNotFound: !0
+        })
+      ), p = ot(
+        s.traverse({
+          field: C(c.id, "stagingCtx"),
+          ignoreError: !0,
+          pureFieldErrorToUndefined: !0
+        }) !== void 0,
+        s.traverseOrError({
+          field: C(c.id, "stagingUiCtx")
+        })
+      );
+      u.set(c.id, { info: c, prod: l, staging: p });
+    }
+    return new Ne(e, u);
+  }
+}
+function ot(o, e) {
+  if (e === void 0)
+    return o ? { locked: !1, results: /* @__PURE__ */ new Map() } : void 0;
+  if (e.ok) return Dt(e.value, !1, !0);
+}
+function Le(o, e) {
+  const t = o.persist(), r = w(
+    o.traverse({
+      field: C(e, "currentArgs"),
+      errorIfFieldNotSet: !0
+    }).getDataAsString()
+  ), s = o.getKeyValueAsString(ke(e));
+  return {
+    blockId: e,
+    args: r,
+    uiState: s,
+    blockMeta: (n) => {
+      const i = n.accessor(t).node(), a = w(i.getKeyValueAsJson(G)), u = /* @__PURE__ */ new Map();
+      for (const c of V(a)) u.set(c.id, c);
+      return u;
+    }
+  };
+}
+function xt(o, e) {
+  const t = o.persist();
+  return {
+    ...Le(o, e),
+    prod: (r) => {
+      var s;
+      return (s = r.accessor(t).node({ ignoreError: !0 }).traverse({
+        field: C(e, "prodOutput"),
+        stableIfNotFound: !0,
+        ignoreError: !0
+      })) == null ? void 0 : s.persist();
+    },
+    staging: (r) => {
+      var n;
+      const s = (n = r.accessor(t).node({ ignoreError: !0 }).traverse({
+        field: C(e, "stagingOutput"),
+        ignoreError: !0
+      })) == null ? void 0 : n.persist();
+      return s === void 0 && r.markUnstable("staging_not_rendered"), s;
+    },
+    getResultsPool: (r) => Ne.create(r, t, e)
+  };
+}
+function* E(o, e) {
+  switch (yield o, o.type) {
+    case "GetFromCtx":
+    case "Immediate":
+      return;
+    case "Isolate":
+      yield* E(o.cfg);
+      return;
+    case "MakeObject":
+      for (const [, t] of Object.entries(o.template)) yield* E(t);
+      return;
+    case "MakeArray":
+      for (const t of o.template) yield* E(t);
+      return;
+    case "GetJsonField":
+    case "GetResourceField":
+      yield* E(o.source), yield* E(o.field);
+      return;
+    case "MapRecordValues":
+    case "MapArrayValues":
+    case "MapResourceFields":
+      yield* E(o.source), yield* E(o.mapping);
+      return;
+    case "Flatten":
+    case "GetResourceValueAsJson":
+    case "GetBlobContent":
+    case "GetBlobContentAsString":
+    case "GetBlobContentAsJson":
+    case "GetDownloadedBlobContent":
+    case "GetOnDemandBlobContent":
+    case "GetImportProgress":
+    case "GetLastLogs":
+    case "GetProgressLog":
+    case "GetLogHandle":
+      yield* E(o.source);
+      return;
+    case "IsEmpty":
+      yield* E(o.arg);
+      return;
+    case "Not":
+      yield* E(o.operand);
+      return;
+    case "And":
+    case "Or":
+      yield* E(o.operand1), yield* E(o.operand2);
+      return;
+    default:
+      D(o);
+  }
+}
+function Ro(o, e) {
+  const t = {};
+  for (const [r, s] of Object.entries(o)) t[r] = e(s);
+  return t;
+}
+function de(o, e) {
+  return o === void 0 ? void 0 : e(o);
+}
+function Oo(o) {
+  switch (o.type) {
+    case "GetImportProgress":
+      return !0;
+    default:
+      return !1;
+  }
+}
+function Do(o) {
+  for (const e of E(o)) if (Oo(e)) return !0;
+  return !1;
+}
+function fe(o) {
+  return {
+    type: "ReturnResult",
+    result: o
+  };
+}
+function f(o) {
+  return () => fe(o);
+}
+const xo = (o) => {
+  const e = {};
+  for (const [t, r] of Object.entries(o)) e[t] = r;
+  return f(e);
+}, Eo = (o) => {
+  const e = o.source;
+  if (e === void 0) return f(void 0);
+  const t = [];
+  for (const r of e)
+    r instanceof Array ? t.push(...r) : t.push(r);
+  return f(t);
+}, jo = (o) => {
+  const e = o.source, t = o.field;
+  return e === void 0 || t === void 0 ? f(void 0) : ({ cCtx: r }) => {
+    var s;
+    return fe((s = r.accessor(e).node().traverse(t)) == null ? void 0 : s.persist());
+  };
+};
+function Et(o, e) {
+  const t = {}, r = o.length;
+  for (let s = 0; s < r; s++) t[String(s)] = e(o[s]);
+  return t;
+}
+function To(o, e) {
+  return (t) => {
+    const r = t.source;
+    return r === void 0 ? f(void 0) : () => ({
+      type: "ScheduleSubroutine",
+      subroutine: jt(r.length),
+      args: Et(r, (s) => m({ ...o, [e.itVar]: s }, e.mapping))
+    });
+  };
+}
+function jt(o) {
+  return (e) => {
+    const t = [];
+    for (let r = 0; r < o; r++) t.push(e[String(r)]);
+    return f(t);
+  };
+}
+function Ao(o, e) {
+  return (t) => {
+    const r = t.source;
+    if (r === void 0) return f(void 0);
+    const s = {};
+    for (const [n, i] of Object.entries(r)) {
+      const a = { ...o, [e.itVar]: i };
+      s[n] = m(a, e.mapping);
+    }
+    return () => ({
+      type: "ScheduleSubroutine",
+      subroutine: Io,
+      args: s
+    });
+  };
+}
+const Io = (o) => f(o), Vo = (o) => {
+  const e = o.arg;
+  return f(e === void 0 ? void 0 : e.length === 0);
+}, No = (o) => {
+  const e = o.operand;
+  return f(e === void 0 ? void 0 : !e);
+}, Lo = (o) => {
+  const e = o.operand1, t = o.operand2;
+  return f(e === void 0 || t === void 0 ? void 0 : e && t);
+}, Jo = (o) => {
+  const e = o.operand1, t = o.operand2;
+  return f(e === void 0 || t === void 0 ? void 0 : e || t);
+}, Ko = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ cCtx: t }) => {
+    var r;
+    return fe((r = t.accessor(e).node()) == null ? void 0 : r.getDataAsJson());
+  };
+}, Mo = (o) => {
+  const e = o.source, t = o.field;
+  return f(e === void 0 || t === void 0 ? void 0 : e[t]);
+};
+function $o(o, e) {
+  return (t) => {
+    const r = t.source;
+    return r === void 0 ? f(void 0) : ({ cCtx: s }) => {
+      const n = s.accessor(r).node(), i = {};
+      for (const a of n.listInputFields()) {
+        const u = n.traverse(a);
+        if (u === void 0) i[a] = f(void 0);
+        else {
+          const c = { ...o, [e.itVar]: u.persist() };
+          i[a] = m(c, e.mapping);
+        }
+      }
+      return {
+        type: "ScheduleSubroutine",
+        subroutine: Uo,
+        args: i
+      };
+    };
+  };
+}
+const Uo = (o) => f(o), Go = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: P.make(
+      (r) => t.blobDriver.getDownloadedBlob(r.accessor(e).node().resourceInfo),
+      {
+        postprocessValue: async (r) => {
+          if (r !== void 0)
+            return await t.blobDriver.getContent(r.handle);
+        }
+      }
+    )
+  });
+}, Ho = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ cCtx: t, drivers: r }) => {
+    const s = t.accessor(e).node().resourceInfo;
+    return {
+      type: "ScheduleComputable",
+      computable: P.make(() => r.blobDriver.getDownloadedBlob(s), {
+        postprocessValue: async (n) => n === void 0 ? void 0 : (await r.blobDriver.getContent(n.handle)).toString()
+      })
+    };
+  };
+}, _o = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: P.make(
+      (r) => t.blobDriver.getDownloadedBlob(r.accessor(e).node().resourceInfo),
+      {
+        postprocessValue: async (r) => {
+          if (r == null) return;
+          const s = await t.blobDriver.getContent(r.handle);
+          if (s != null)
+            return JSON.parse(Buffer.from(s).toString());
+        }
+      }
+    )
+  });
+}, Wo = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: t.blobDriver.getDownloadedBlob(e)
+  });
+}, zo = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: t.blobDriver.getOnDemandBlob(e)
+  });
+}, qo = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: t.uploadDriver.getProgressId(e)
+  });
+}, Yo = (o) => (e) => {
+  const t = e.source;
+  return t === void 0 ? f(void 0) : ({ drivers: r }) => ({
+    type: "ScheduleComputable",
+    computable: r.logDriver.getLastLogs(t, o)
+  });
+}, Qo = (o) => (e) => {
+  const t = e.source;
+  return t === void 0 ? f(void 0) : ({ drivers: r }) => ({
+    type: "ScheduleComputable",
+    computable: r.logDriver.getProgressLog(t, o)
+  });
+}, Zo = (o) => {
+  const e = o.source;
+  return e === void 0 ? f(void 0) : ({ drivers: t }) => ({
+    type: "ScheduleComputable",
+    computable: t.logDriver.getLogHandle(e)
+  });
+};
+function m(o, e) {
+  switch (e.type) {
+    case "GetFromCtx":
+      const t = o[e.variable];
+      return typeof t == "function" ? (r) => fe(t(r.cCtx)) : (t === void 0 && console.log("asdasd"), f(t));
+    case "Isolate":
+      return ({ drivers: r }) => ({
+        type: "ScheduleComputable",
+        computable: Vt(r, o, e.cfg)
+      });
+    case "Immediate":
+      return f(e.value);
+    case "GetJsonField":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Mo,
+        args: {
+          source: m(o, e.source),
+          field: m(o, e.field)
+        }
+      });
+    case "MapArrayValues":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: To(o, e),
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "MapRecordValues":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Ao(o, e),
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "MakeObject":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: xo,
+        args: Ro(e.template, (r) => m(o, r))
+      });
+    case "MakeArray":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: jt(e.template.length),
+        args: Et(e.template, (r) => m(o, r))
+      });
+    case "Flatten":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Eo,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "IsEmpty":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Vo,
+        args: {
+          arg: m(o, e.arg)
+        }
+      });
+    case "Not":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: No,
+        args: {
+          operand: m(o, e.operand)
+        }
+      });
+    case "And":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Lo,
+        args: {
+          operand1: m(o, e.operand1),
+          operand2: m(o, e.operand2)
+        }
+      });
+    case "Or":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Jo,
+        args: {
+          operand1: m(o, e.operand1),
+          operand2: m(o, e.operand2)
+        }
+      });
+    case "MapResourceFields":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: $o(o, e),
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetResourceField":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: jo,
+        args: {
+          source: m(o, e.source),
+          field: m(o, e.field)
+        }
+      });
+    case "GetResourceValueAsJson":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Ko,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetBlobContent":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Go,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetBlobContentAsString":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Ho,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetBlobContentAsJson":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: _o,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetDownloadedBlobContent":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Wo,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetOnDemandBlobContent":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: zo,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetImportProgress":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: qo,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetLastLogs":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Yo(e.lines),
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetProgressLog":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Qo(e.patternToSearch),
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    case "GetLogHandle":
+      return () => ({
+        type: "ScheduleSubroutine",
+        subroutine: Zo,
+        args: {
+          source: m(o, e.source)
+        }
+      });
+    default:
+      return D(e);
+  }
+}
+const Xo = ["$prod", "$staging"];
+function es(o) {
+  return {
+    $blockId: o.blockId,
+    $args: JSON.parse(o.args),
+    $ui: o.uiState !== void 0 ? JSON.parse(o.uiState) : void 0,
+    $prod: o.prod,
+    $staging: o.staging
+  };
+}
+const Tt = Symbol(), At = "return", ts = { op: Tt, arg: At };
+function rs(o) {
+  return o.op == Tt && o.arg == At;
+}
+function os() {
+  return { pendingSubroutines: /* @__PURE__ */ new Map() };
+}
+function st(o, e, t, r) {
+  const s = new ft(t), n = (a, u) => {
+    if (rs(a))
+      return e.result = u, !1;
+    const c = w(e.pendingSubroutines.get(a.op));
+    if (a.arg in c.args) throw new Error("argument already set");
+    return c.args[a.arg] = u, c.argCounter--, c.argCounter === 0 && (e.pendingSubroutines.delete(a.op), s.push({
+      destination: c.destination,
+      operation: c.subroutine(c.args)
+    })), !0;
+  }, i = [];
+  e: for (; s.length > 0; ) {
+    const a = s.shift(), u = a.operation(o);
+    switch (u.type) {
+      case "ReturnResult":
+        if (!n(a.destination, u.result)) break e;
+        break;
+      case "ScheduleSubroutine":
+        const c = Symbol(), l = Object.entries(u.args), p = l.length;
+        if (p === 0)
+          s.push({
+            destination: a.destination,
+            operation: u.subroutine({})
+          });
+        else {
+          for (const [h, g] of l)
+            s.push({
+              destination: { op: c, arg: h },
+              operation: g
+            });
+          e.pendingSubroutines.set(c, {
+            argCounter: p,
+            args: {},
+            subroutine: u.subroutine,
+            destination: a.destination
+          });
+        }
+        break;
+      case "ScheduleComputable":
+        if (!r)
+          throw new Error("asynchronous operations are forbidden in this context");
+        i.push({
+          destination: a.destination,
+          computable: u.computable
+        });
+        break;
+      default:
+        D(u);
+    }
+  }
+  return i;
+}
+function It(o, e, t, r = {}) {
+  return Vt(o, es(e), t, r);
+}
+function Vt(o, e, t, r = {}) {
+  const s = Ee({
+    ctx: Object.fromEntries(Object.entries(e).filter(([n]) => Xo.indexOf(n) === -1)),
+    cfg: t
+  });
+  return P.makeRaw(
+    (n) => {
+      const i = { drivers: o, cCtx: n }, a = os();
+      return {
+        ir: st(
+          i,
+          a,
+          [
+            {
+              destination: ts,
+              operation: m(e, t)
+            }
+          ],
+          !0
+        ),
+        async postprocessValue(c, l) {
+          const p = [];
+          for (const B of c)
+            p.push({ destination: B.destination, operation: f(B.computable) });
+          const h = {
+            drivers: o,
+            get cCtx() {
+              throw new Error("asynchronous operations are forbidden in this context");
+            }
+          }, g = /* @__PURE__ */ new Map();
+          for (const [B, M] of a.pendingSubroutines)
+            g.set(B, { ...M, args: { ...M.args } });
+          const b = {
+            result: a.result,
+            pendingSubroutines: g
+          };
+          if (st(h, b, p, !1), !("result" in b))
+            throw new Error("illegal cfg rendering stack state, no result");
+          return b.result;
+        }
+      };
+    },
+    { ...r, key: s }
+  );
+}
+function ss(o) {
+  return o instanceof ArrayBuffer || ArrayBuffer.isView(o);
+}
+function nt(o) {
+  return o !== void 0 ? Buffer.from(o).toString("base64") : void 0;
+}
+class pe {
+  constructor(e, t, r, s, n) {
+    d(this, "callbackRegistry");
+    d(this, "fnJSONStringify");
+    d(this, "fnJSONParse");
+    d(this, "computablesToResolve", {});
+    d(this, "computableCtx");
+    d(this, "accessors", /* @__PURE__ */ new Map());
+    d(this, "meta");
+    //
+    // Result Pool
+    //
+    d(this, "_resultPool");
+    if (this.scope = e, this.vm = t, this.blockCtx = r, this.env = s, this.computableCtx = n, this.callbackRegistry = this.scope.manage(this.vm.newObject()), this.fnJSONStringify = e.manage(
+      t.getProp(t.global, "JSON").consume((i) => t.getProp(i, "stringify"))
+    ), t.typeof(this.fnJSONStringify) !== "function")
+      throw new Error("JSON.stringify() not found.");
+    if (this.fnJSONParse = e.manage(
+      t.getProp(t.global, "JSON").consume((i) => t.getProp(i, "parse"))
+    ), t.typeof(this.fnJSONParse) !== "function") throw new Error("JSON.parse() not found.");
+    this.meta = r.blockMeta(n), this.injectCtx();
+  }
+  resetComputableCtx() {
+    this.computableCtx = void 0, this.accessors.clear();
+  }
+  static cleanErrorContext(e) {
+    typeof e == "object" && e !== null && "context" in e && delete e.context;
+  }
+  evaluateBundle(e) {
+    try {
+      this.vm.unwrapResult(this.vm.evalCode(e, "bundle.js", { type: "global" })).dispose();
+    } catch (t) {
+      throw pe.cleanErrorContext(t), t;
+    }
+  }
+  runCallback(e, ...t) {
+    try {
+      return Se.withScope((r) => {
+        const s = r.manage(this.vm.getProp(this.callbackRegistry, e));
+        if (this.vm.typeof(s) !== "function")
+          throw new Error(`No such callback: ${e}`);
+        return this.scope.manage(
+          this.vm.unwrapResult(
+            this.vm.callFunction(
+              s,
+              this.vm.undefined,
+              ...t.map((n) => this.exportObjectUniversal(n, r))
+            )
+          )
+        );
+      });
+    } catch (r) {
+      throw pe.cleanErrorContext(r), r;
+    }
+  }
+  //
+  // Methods for injected ctx object
+  //
+  getAccessorHandleByName(e) {
+    if (this.computableCtx === void 0)
+      throw new Error("Accessors can't be used in this context");
+    const t = (r, s) => {
+      if (!this.accessors.has(r)) {
+        const n = this.blockCtx[s];
+        if (n === void 0) throw new Error("Staging context not available");
+        const i = n(this.computableCtx);
+        i ? this.accessors.set(r, this.computableCtx.accessor(i).node({ ignoreError: !0 })) : this.accessors.set(r, void 0);
+      }
+      return this.accessors.get(r) ? r : void 0;
+    };
+    if (e === "staging") return t("staging", "staging");
+    if (e === "main") return t("main", "prod");
+  }
+  //
+  // Accessors
+  //
+  resolveWithCommon(e, t, ...r) {
+    return this.wrapAccessor(this.getAccessor(e).traverseWithCommon(t, ...r));
+  }
+  getResourceType(e) {
+    return this.getAccessor(e).resourceType;
+  }
+  getInputsLocked(e) {
+    return this.getAccessor(e).getInputsLocked();
+  }
+  getOutputsLocked(e) {
+    return this.getAccessor(e).getOutputsLocked();
+  }
+  getIsReadyOrError(e) {
+    return this.getAccessor(e).getIsReadyOrError();
+  }
+  getIsFinal(e) {
+    return this.getAccessor(e).getIsFinal();
+  }
+  getError(e) {
+    return this.wrapAccessor(this.getAccessor(e).getError());
+  }
+  listInputFields(e) {
+    return this.getAccessor(e).listInputFields();
+  }
+  listOutputFields(e) {
+    return this.getAccessor(e).listOutputFields();
+  }
+  listDynamicFields(e) {
+    return this.getAccessor(e).listDynamicFields();
+  }
+  getKeyValueBase64(e, t) {
+    return nt(this.getAccessor(e).getKeyValue(t));
+  }
+  getKeyValueAsString(e, t) {
+    return this.getAccessor(e).getKeyValueAsString(t);
+  }
+  getDataBase64(e) {
+    return nt(this.getAccessor(e).getData());
+  }
+  getDataAsString(e) {
+    return this.getAccessor(e).getDataAsString();
+  }
+  //
+  // Accessor helpers
+  //
+  parsePObjectCollection(e, t, r) {
+    const s = this.getAccessor(e);
+    if (!s.getIsReadyOrError()) return;
+    const n = Bo(s, t, r), i = {};
+    for (const [a, u] of Object.entries(n))
+      i[a] = z(u, (c) => this.wrapAccessor(c));
+    return i;
+  }
+  //
+  // Blobs
+  //
+  registerComputable(e, t) {
+    const r = `${e}_${Y()}`;
+    return this.computablesToResolve[r] = t, r;
+  }
+  getBlobContentAsString(e) {
+    const t = this.getAccessor(e).resourceInfo;
+    return this.registerComputable(
+      "getBlobContentAsString",
+      P.make((r) => this.env.driverKit.blobDriver.getDownloadedBlob(t, r), {
+        postprocessValue: async (r) => {
+          if (r !== void 0)
+            return Buffer.from(await this.env.driverKit.blobDriver.getContent(r.handle)).toString(
+              "utf-8"
+            );
+        }
+      })
+    );
+  }
+  getBlobContentAsBase64(e) {
+    const t = this.getAccessor(e).resourceInfo;
+    return this.registerComputable(
+      "getBlobContentAsBase64",
+      P.make((r) => this.env.driverKit.blobDriver.getDownloadedBlob(t, r), {
+        postprocessValue: async (r) => {
+          if (r !== void 0)
+            return Buffer.from(await this.env.driverKit.blobDriver.getContent(r.handle)).toString(
+              "base64"
+            );
+        }
+      })
+    );
+  }
+  getDownloadedBlobContentHandle(e) {
+    const t = this.getAccessor(e).resourceInfo;
+    return this.registerComputable(
+      "getDownloadedBlobContentHandle",
+      this.env.driverKit.blobDriver.getDownloadedBlob(t)
+    );
+  }
+  getOnDemandBlobContentHandle(e) {
+    const t = this.getAccessor(e).persist();
+    return this.registerComputable(
+      "getOnDemandBlobContentHandle",
+      this.env.driverKit.blobDriver.getOnDemandBlob(t)
+    );
+  }
+  //
+  // Import progress
+  //
+  getImportProgress(e) {
+    const t = this.getAccessor(e).persist();
+    return this.registerComputable(
+      "getImportProgress",
+      this.env.driverKit.uploadDriver.getProgressId(t)
+    );
+  }
+  //
+  // Logs
+  //
+  getLastLogs(e, t) {
+    const r = this.getAccessor(e).persist();
+    return this.registerComputable(
+      "getLastLogs",
+      this.env.driverKit.logDriver.getLastLogs(r, t)
+    );
+  }
+  getProgressLog(e, t) {
+    const r = this.getAccessor(e).persist();
+    return this.registerComputable(
+      "getProgressLog",
+      this.env.driverKit.logDriver.getProgressLog(r, t)
+    );
+  }
+  getLogHandle(e) {
+    const t = this.getAccessor(e).persist();
+    return this.registerComputable(
+      "getLogHandle",
+      this.env.driverKit.logDriver.getLogHandle(t)
+    );
+  }
+  //
+  // Blocks
+  //
+  getBlockLabel(e) {
+    const t = this.meta.get(e);
+    if (t === void 0) throw new Error(`Block ${e} not found.`);
+    return t.label;
+  }
+  get resultPool() {
+    if (this._resultPool === void 0) {
+      if (this.computableCtx === void 0)
+        throw new Error(
+          "can't use result pool in this context (most porbably called from the future mapper)"
+        );
+      this._resultPool = w(
+        this.blockCtx.getResultsPool,
+        "getResultsPool"
+      )(this.computableCtx);
+    }
+    return this._resultPool;
+  }
+  calculateOptions(e) {
+    return this.resultPool.calculateOptions(e);
+  }
+  getDataFromResultPool() {
+    const e = this.resultPool.getData();
+    return e.instabilityMarker !== void 0 && this.computableCtx.markUnstable(`incomplete_result_pool:${e.instabilityMarker}`), {
+      isComplete: e.isComplete,
+      entries: e.entries.map((t) => ({
+        ref: t.ref,
+        obj: z(t.obj, (r) => this.wrapAccessor(r))
+      }))
+    };
+  }
+  getDataWithErrorsFromResultPool() {
+    const e = this.resultPool.getDataWithErrors();
+    return e.instabilityMarker !== void 0 && this.computableCtx.markUnstable(`incomplete_result_pool:${e.instabilityMarker}`), {
+      isComplete: e.isComplete,
+      entries: e.entries.map((t) => ({
+        ref: t.ref,
+        obj: {
+          id: t.obj.id,
+          spec: t.obj.spec,
+          data: Ut(t.obj.data, (r) => this.wrapAccessor(r))
+        }
+      }))
+    };
+  }
+  getSpecsFromResultPool() {
+    const e = this.resultPool.getSpecs();
+    return e.instabilityMarker !== void 0 && this.computableCtx.markUnstable(`specs_from_pool_incomplete:${e.instabilityMarker}`), e;
+  }
+  //
+  // PFrames / PTables
+  //
+  createPFrame(e) {
+    if (this.computableCtx === void 0)
+      throw new Error(
+        "can't instantiate PFrames from this context (most porbably called from the future mapper)"
+      );
+    return this.env.driverKit.pFrameDriver.createPFrame(
+      e.map((t) => z(t, (r) => this.getAccessor(r))),
+      this.computableCtx
+    );
+  }
+  createPTable(e) {
+    if (this.computableCtx === void 0)
+      throw new Error(
+        "can't instantiate PTable from this context (most porbably called from the future mapper)"
+      );
+    return this.env.driverKit.pFrameDriver.createPTable(
+      ct(e, (t) => z(t, (r) => this.getAccessor(r))),
+      this.computableCtx
+    );
+  }
+  //
+  // Helpers
+  //
+  getAccessor(e) {
+    const t = this.accessors.get(e);
+    if (t === void 0) throw new Error("No such accessor");
+    return t;
+  }
+  wrapAccessor(e) {
+    if (e !== void 0) {
+      const t = Y();
+      return this.accessors.set(t, e), t;
+    }
+  }
+  //
+  // QuickJS Helpers
+  //
+  exportSingleValue(e, t) {
+    const r = this.tryExportSingleValue(e, t);
+    if (r === void 0) throw new Error(`Can't export value: ${e}`);
+    return r;
+  }
+  tryExportSingleValue(e, t) {
+    let r, s = !1;
+    switch (typeof e) {
+      case "string":
+        r = this.vm.newString(e), s = !0;
+        break;
+      case "number":
+        r = this.vm.newNumber(e), s = !0;
+        break;
+      case "undefined":
+        r = this.vm.undefined;
+        break;
+      case "boolean":
+        r = e ? this.vm.true : this.vm.false;
+        break;
+      default:
+        if (e === null) {
+          r = this.vm.null;
+          break;
+        }
+        if (ss(e)) {
+          r = this.vm.newArrayBuffer(e), s = !0;
+          break;
+        }
+        return;
+    }
+    return s && t != null ? t.manage(r) : r;
+  }
+  exportObjectUniversal(e, t) {
+    const r = this.tryExportSingleValue(e, t);
+    return r !== void 0 ? r : this.exportObjectViaJson(e, t);
+  }
+  exportObjectViaJson(e, t) {
+    const r = this.vm.newString(JSON.stringify(e)).consume(
+      (s) => this.vm.unwrapResult(this.vm.callFunction(this.fnJSONParse, this.vm.undefined, s))
+    );
+    return t !== void 0 ? t.manage(r) : r;
+  }
+  importObjectUniversal(e) {
+    switch (this.vm.typeof(e)) {
+      case "undefined":
+        return;
+      case "boolean":
+      case "number":
+      case "string":
+        return this.vm.dump(e);
+      default:
+        return this.importObjectViaJson(e);
+    }
+  }
+  importObjectViaJson(e) {
+    const t = this.vm.unwrapResult(this.vm.callFunction(this.fnJSONStringify, this.vm.undefined, e)).consume((r) => this.vm.getString(r));
+    if (t !== "undefined")
+      return JSON.parse(t);
+  }
+  injectCtx() {
+    Se.withScope((e) => {
+      const t = e.manage(this.vm.newObject());
+      this.vm.setProp(t, "args", e.manage(this.vm.newString(this.blockCtx.args))), this.blockCtx.uiState !== void 0 && this.vm.setProp(
+        t,
+        "uiState",
+        e.manage(this.vm.newString(this.blockCtx.uiState))
+      ), this.vm.setProp(t, "callbackRegistry", this.callbackRegistry);
+      const r = (s, n) => {
+        this.vm.newFunction(s, n).consume((i) => this.vm.setProp(t, s, i));
+      };
+      r("getAccessorHandleByName", (s) => this.exportSingleValue(
+        this.getAccessorHandleByName(this.vm.getString(s)),
+        void 0
+      )), r("resolveWithCommon", (s, n, ...i) => this.exportSingleValue(
+        this.resolveWithCommon(
+          this.vm.getString(s),
+          this.importObjectViaJson(n),
+          ...i.map(
+            (a) => this.importObjectViaJson(a)
+          )
+        ),
+        void 0
+      )), r("getResourceType", (s) => this.exportObjectViaJson(this.getResourceType(this.vm.getString(s)), void 0)), r("getInputsLocked", (s) => this.exportSingleValue(this.getInputsLocked(this.vm.getString(s)), void 0)), r("getOutputsLocked", (s) => this.exportSingleValue(this.getOutputsLocked(this.vm.getString(s)), void 0)), r("getIsReadyOrError", (s) => this.exportSingleValue(this.getIsReadyOrError(this.vm.getString(s)), void 0)), r("getIsFinal", (s) => this.exportSingleValue(this.getIsFinal(this.vm.getString(s)), void 0)), r("getError", (s) => this.exportSingleValue(this.getError(this.vm.getString(s)), void 0)), r("listInputFields", (s) => this.exportObjectViaJson(this.listInputFields(this.vm.getString(s)), void 0)), r("listOutputFields", (s) => this.exportObjectViaJson(this.listInputFields(this.vm.getString(s)), void 0)), r("listDynamicFields", (s) => this.exportObjectViaJson(this.listInputFields(this.vm.getString(s)), void 0)), r("getKeyValueBase64", (s, n) => this.exportSingleValue(
+        this.getKeyValueBase64(this.vm.getString(s), this.vm.getString(n)),
+        void 0
+      )), r("getKeyValueAsString", (s, n) => this.exportSingleValue(
+        this.getKeyValueAsString(this.vm.getString(s), this.vm.getString(n)),
+        void 0
+      )), r("getDataBase64", (s) => this.exportSingleValue(this.getDataBase64(this.vm.getString(s)), void 0)), r("getDataAsString", (s) => this.exportSingleValue(this.getDataAsString(this.vm.getString(s)), void 0)), r("parsePObjectCollection", (s, n, i) => this.exportObjectUniversal(
+        this.parsePObjectCollection(
+          this.vm.getString(s),
+          this.vm.dump(n),
+          this.vm.getString(i)
+        ),
+        void 0
+      )), r("getBlobContentAsBase64", (s) => this.exportSingleValue(
+        this.getBlobContentAsBase64(this.vm.getString(s)),
+        void 0
+      )), r("getBlobContentAsString", (s) => this.exportSingleValue(
+        this.getBlobContentAsString(this.vm.getString(s)),
+        void 0
+      )), r("getDownloadedBlobContentHandle", (s) => this.exportSingleValue(
+        this.getDownloadedBlobContentHandle(this.vm.getString(s)),
+        void 0
+      )), r("getOnDemandBlobContentHandle", (s) => this.exportSingleValue(
+        this.getOnDemandBlobContentHandle(this.vm.getString(s)),
+        void 0
+      )), r("getImportProgress", (s) => this.exportSingleValue(this.getImportProgress(this.vm.getString(s)), void 0)), r("getLastLogs", (s, n) => this.exportSingleValue(
+        this.getLastLogs(this.vm.getString(s), this.vm.getNumber(n)),
+        void 0
+      )), r("getProgressLog", (s, n) => this.exportSingleValue(
+        this.getProgressLog(this.vm.getString(s), this.vm.getString(n)),
+        void 0
+      )), r("getLogHandle", (s) => this.exportSingleValue(this.getLogHandle(this.vm.getString(s)), void 0)), r("getBlockLabel", (s) => this.exportSingleValue(this.getBlockLabel(this.vm.getString(s)), void 0)), r("getDataFromResultPool", (s) => this.exportObjectUniversal(this.getDataFromResultPool(), void 0)), r("getDataWithErrorsFromResultPool", (s) => this.exportObjectUniversal(this.getDataWithErrorsFromResultPool(), void 0)), r("getSpecsFromResultPool", (s) => this.exportObjectUniversal(this.getSpecsFromResultPool(), void 0)), r("calculateOptions", (s) => this.exportObjectUniversal(
+        this.calculateOptions(this.importObjectViaJson(s)),
+        void 0
+      )), r("createPFrame", (s) => this.exportSingleValue(
+        this.createPFrame(this.importObjectViaJson(s)),
+        void 0
+      )), r("createPTable", (s) => this.exportSingleValue(
+        this.createPTable(this.importObjectViaJson(s)),
+        void 0
+      )), this.vm.setProp(this.vm.global, "cfgRenderCtx", t);
+    });
+  }
+}
+function ns(o, e, t, r, s = {}) {
+  return P.makeRaw((n) => {
+    const i = new Se();
+    n.addOnDestroy(() => i.dispose());
+    const a = i.manage(o.quickJs.newRuntime());
+    a.setMemoryLimit(1024 * 640), a.setMaxStackSize(1024 * 320);
+    const u = i.manage(a.newContext()), c = new pe(i, u, e, o, n);
+    c.evaluateBundle(r.content);
+    const l = c.runCallback(t);
+    return c.resetComputableCtx(), {
+      ir: c.computablesToResolve,
+      postprocessValue: async (p) => {
+        for (const [h, g] of Object.entries(p)) c.runCallback(h, g);
+        return c.importObjectUniversal(l);
+      }
+    };
+  }, s);
+}
+function De(o, e, t, r, s = {}) {
+  if (ut(t)) {
+    if (r === void 0) throw new Error("No code bundle.");
+    return ns(o, e, t, r, s);
+  } else return It(o.driverKit, e, t, s);
+}
+function is(o, e, t) {
+  return P.make(
+    (r) => {
+      var b, B, M, ee, te, $, H, re;
+      const s = r.accessor(o).node(), n = w(s.getKeyValueAsJson(Ie)), i = w(s.getKeyValueAsJson(Q)), a = w(s.getKeyValueAsJson(Z)), u = w(s.getKeyValueAsJson(G)), c = w(
+        s.getKeyValueAsJson(ue)
+      ), l = /* @__PURE__ */ new Map();
+      for (const { id: k } of V(u)) {
+        const L = s.traverse({
+          field: C(k, "currentArgs"),
+          assertFieldType: "Dynamic",
+          errorIfFieldNotSet: !0
+        });
+        let _;
+        const j = s.traverse({
+          field: C(k, "prodArgs"),
+          assertFieldType: "Dynamic",
+          stableIfNotFound: !0
+        });
+        if (j !== void 0) {
+          const x = s.getField({
+            field: C(k, "prodOutput"),
+            assertFieldType: "Dynamic",
+            errorIfFieldNotFound: !0
+          }), R = s.getField({
+            field: C(k, "prodUiCtx"),
+            assertFieldType: "Dynamic",
+            errorIfFieldNotFound: !0
+          });
+          _ = {
+            arguments: j.getDataAsJson(),
+            stale: L.id !== j.id,
+            outputError: x.error !== void 0 || R.error !== void 0 || ((b = x.value) == null ? void 0 : b.getError()) !== void 0 || ((B = R.value) == null ? void 0 : B.getError()) !== void 0,
+            outputsError: ((M = x.error) == null ? void 0 : M.getDataAsString()) ?? ((te = (ee = x.value) == null ? void 0 : ee.getError()) == null ? void 0 : te.getDataAsString()),
+            exportsError: (($ = R.error) == null ? void 0 : $.getDataAsString()) ?? ((re = (H = R.value) == null ? void 0 : H.getError()) == null ? void 0 : re.getDataAsString()),
+            finished: (x.value !== void 0 && x.value.getIsReadyOrError() || x.error !== void 0 && x.error.getIsReadyOrError()) && (R.value !== void 0 && R.value.getIsReadyOrError() || R.error !== void 0 && R.error.getIsReadyOrError())
+          };
+        }
+        l.set(k, { currentArguments: L.getDataAsJson(), prod: _ });
+      }
+      const p = ie(u, (k) => l.get(k).currentArguments), h = new Set(c.blocksInLimbo), g = [...V(u)].map(({ id: k, label: L, renderingMode: _ }) => {
+        var Ke, Me, $e, Ue;
+        const j = w(l.get(k)), x = w(p.nodes.get(k));
+        let R = "NotCalculated";
+        j.prod !== void 0 && (h.has(k) ? R = "Limbo" : R = j.prod.finished ? "Done" : "Running");
+        const J = s.traverse(
+          {
+            field: C(k, "blockPack"),
+            assertFieldType: "Dynamic",
+            errorIfFieldNotSet: !0
+          },
+          { field: y.HolderRefField, assertFieldType: "Input", errorIfFieldNotFound: !0 }
+        ), N = J == null ? void 0 : J.getDataAsJson(), { sections: oe, inputsValid: v, sdkVersion: O } = de(N == null ? void 0 : N.config, (ge) => {
+          const W = xe(ge), Ge = Le(s, k);
+          return {
+            sections: De(
+              t,
+              Ge,
+              W.sections,
+              W.code
+            ),
+            inputsValid: De(
+              t,
+              Ge,
+              W.inputsValid,
+              W.code
+            ),
+            sdkVersion: W.sdkVersion
+          };
+        }) || {}, F = de(
+          N,
+          (ge) => t.blockUpdateWatcher.get(ge.source, r)
+        );
+        return {
+          id: k,
+          label: L,
+          renderingMode: _,
+          stale: ((Ke = j.prod) == null ? void 0 : Ke.stale) !== !1 || R === "Limbo",
+          missingReference: x.missingReferences,
+          upstreams: [...p.traverseIdsExcludingRoots("upstream", k)],
+          downstreams: [...p.traverseIdsExcludingRoots("downstream", k)],
+          calculationStatus: R,
+          outputErrors: ((Me = j.prod) == null ? void 0 : Me.outputError) === !0,
+          outputsError: ($e = j.prod) == null ? void 0 : $e.outputsError,
+          exportsError: (Ue = j.prod) == null ? void 0 : Ue.exportsError,
+          sections: oe,
+          inputsValid: v,
+          currentBlockPack: N == null ? void 0 : N.source,
+          updatedBlockPack: F,
+          sdkVersion: O,
+          navigationState: e.getState(k)
+        };
+      });
+      return {
+        meta: a,
+        created: new Date(n),
+        lastModified: new Date(i),
+        authorMarker: s.getKeyValueAsJson(Pe),
+        blocks: g
+      };
+    },
+    {
+      postprocessValue: (r) => {
+        const s = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+        return {
+          ...r,
+          blocks: r.blocks.map((i) => {
+            i.inputsValid || s.add(i.id), i.stale && n.add(i.id);
+            const a = i.stale || i.upstreams.findIndex((c) => n.has(c)) !== -1, u = a && !!i.inputsValid && !i.missingReference && i.upstreams.findIndex((c) => s.has(c)) === -1;
+            return { ...i, canRun: u, stale: a };
+          })
+        };
+      }
+    }
+  ).withStableType();
+}
+function Nt(o, e) {
+  var t, r;
+  return de(
+    (r = (t = o.traverse(
+      {
+        field: C(e, "blockPack"),
+        assertFieldType: "Dynamic",
+        errorIfFieldNotSet: !0
+      },
+      { field: y.HolderRefField, assertFieldType: "Input", errorIfFieldNotFound: !0 }
+    )) == null ? void 0 : t.getDataAsJson()) == null ? void 0 : r.config,
+    (s) => xe(s)
+  );
+}
+function as(o, e) {
+  const t = o.node();
+  if (K(t.resourceType, kt)) {
+    const r = t.getDataAsJson();
+    if (r === void 0) throw new Error("No resource data.");
+    return e.frontendDownloadDriver.getPath(new URL(r.url)).withStableType();
+  } else if (K(t.resourceType, Ct)) {
+    const r = t.getDataAsJson();
+    if (r === void 0) throw new Error("No resource data.");
+    return e.signer.verify(
+      r.path,
+      r.signature,
+      `Frontend path signature mismatch for: ${r.path}`
+    ), r.path;
+  } else
+    throw new Error(`Unsupported resource type: ${JSON.stringify(t.resourceType)}`);
+}
+function cs(o, e) {
+  if (o !== void 0)
+    return P.make(
+      (t) => as(t.accessor(o), e),
+      {
+        postprocessValue: (t) => {
+          if (t !== void 0) {
+            if (typeof t == "string") return t;
+            if (t.error !== void 0) throw new Error(t.error);
+            return t.path;
+          }
+        }
+      }
+    ).withStableType();
+}
+function us(o, e, t) {
+  return P.make(
+    (r) => {
+      var a;
+      const s = r.accessor(o).node(), n = Nt(s, e), i = (a = s.traverse(
+        {
+          field: C(e, "blockPack"),
+          assertFieldType: "Dynamic"
+        },
+        { field: y.HolderRefField, assertFieldType: "Input", errorIfFieldNotFound: !0 },
+        { field: Ft, assertFieldType: "Input" }
+      )) == null ? void 0 : a.persist();
+      return { path: cs(i, t), sdkVersion: n == null ? void 0 : n.sdkVersion };
+    },
+    { mode: "StableOnlyLive" }
+  );
+}
+function ls(o, e, t) {
+  return P.make(
+    (r) => {
+      const s = r.accessor(o).node(), n = Le(s, e);
+      return {
+        author: s.getKeyValueAsJson(Ce(e)),
+        args: JSON.parse(n.args),
+        ui: n.uiState !== void 0 ? JSON.parse(n.uiState) : void 0
+      };
+    },
+    { key: "inputs#" + pt(o.rid) + e }
+  );
+}
+function ds(o, e, t) {
+  return P.make(
+    (r) => {
+      const s = r.accessor(o).node(), n = xt(s, e), i = Nt(s, e);
+      return de(i, (a) => {
+        const u = {};
+        for (const [c, l] of Object.entries(a.outputs))
+          u[c] = P.wrapError(
+            De(t, n, l, a.code)
+          );
+        return u;
+      });
+    },
+    { key: "outputs#" + pt(o.rid) + e }
+  ).withStableType();
+}
+function ps(o, e) {
+  return P.make((t) => {
+    const r = t.accessor(o).node(), s = w(r.getKeyValueAsJson(G)), n = [];
+    for (const { id: i, renderingMode: a } of V(s)) {
+      const u = r.traverse(
+        {
+          field: C(i, "blockPack"),
+          assertFieldType: "Dynamic",
+          errorIfFieldNotSet: !0
+        },
+        { field: y.HolderRefField, assertFieldType: "Input", errorIfFieldNotFound: !0 }
+      ), c = u == null ? void 0 : u.getDataAsJson();
+      if ((c == null ? void 0 : c.config) === void 0) continue;
+      const l = xe(c.config), p = Object.entries(l.outputs).map(([, g]) => g).filter((g) => !ut(g) && Do(g)).map((g) => g);
+      if (p.length === 0) continue;
+      const h = xt(r, i);
+      for (const g of p)
+        n.push(P.wrapError(It(e.driverKit, h, g)));
+    }
+    return n;
+  });
+}
+class hs {
+  constructor() {
+    d(this, "states", /* @__PURE__ */ new Map());
+  }
+  setState(e, t) {
+    const r = this.states.get(e);
+    if (r === void 0) {
+      this.states.set(e, { state: t, change: new We() });
+      return;
+    }
+    r.state = { ...t }, r.change.markChanged();
+  }
+  readState(e, t) {
+    let r = this.states.get(t);
+    return r === void 0 && (r = { state: { ...Gt }, change: new We() }, this.states.set(t, r)), r.change.attachWatcher(e.watcher), r.state;
+  }
+  getState(e) {
+    return P.make(
+      (t) => this.readState(t, e),
+      { key: `navigationState#${e}` }
+    );
+  }
+  deleteBlock(e) {
+    const t = this.states.get(e);
+    t !== void 0 && (this.states.delete(e), t.change.markChanged());
+  }
+}
+class Je {
+  constructor(e, t, r) {
+    /** Underlying pl resource id */
+    d(this, "rid");
+    /** Data for the left panel, contain basic information about block status. */
+    d(this, "overview");
+    d(this, "navigationStates", new hs());
+    d(this, "blockComputables", /* @__PURE__ */ new Map());
+    d(this, "blockFrontends", /* @__PURE__ */ new Map());
+    d(this, "activeConfigs");
+    d(this, "refreshLoopResult");
+    d(this, "abortController", new AbortController());
+    d(this, "destroyed", !1);
+    this.env = e, this.projectTree = r, this.overview = is(
+      r.entry(),
+      this.navigationStates,
+      e
+    ).withPreCalculatedValueTree(), this.rid = t, this.refreshLoopResult = this.refreshLoop(), this.activeConfigs = ps(r.entry(), e);
+  }
+  async refreshLoop() {
+    for (; !this.destroyed; )
+      try {
+        await be(this.env.pl, this.rid, (e) => {
+          e.doRefresh(this.env.ops.stagingRenderingRate);
+        }), await this.activeConfigs.getValue(), await ar(this.env.ops.projectRefreshInterval, this.abortController.signal);
+      } catch (e) {
+        if (Zt(e)) {
+          console.warn(
+            "project refresh routine terminated, because project was externally deleted"
+          );
+          break;
+        } else if (!Xt(e))
+          throw new Error("Unexpected exception", { cause: e });
+      }
+  }
+  /**
+   * Adds new block to the project.
+   *
+   * @param blockLabel block label / title visible to the user
+   * @param blockPackSpec object describing the "block type", read more in the type docs
+   * @param before id of the block to insert new block before
+   * @param blockId internal id to be assigned for the block, this arg can be omitted
+   *                 then, randomly generated UUID will be assigned automatically
+   *
+   * @return returns newly created block id
+   * */
+  async addBlock(e, t, r, s = void 0, n = Y()) {
+    const i = await this.env.bpPreparer.prepare(t), a = await this.env.bpPreparer.getBlockConfig(t);
+    return await A(
+      this.env.pl,
+      this.rid,
+      s,
+      (u) => u.addBlock(
+        {
+          id: n,
+          label: e,
+          renderingMode: a.renderingMode
+        },
+        {
+          args: JSON.stringify(a.initialArgs),
+          blockPack: i
+        },
+        r
+      )
+    ), await this.projectTree.refreshState(), n;
+  }
+  /**
+   * Update block to new block pack, optionally resetting args and ui state to
+   * initial values
+   * */
+  async updateBlockPack(e, t, r = !1, s) {
+    const n = await this.env.bpPreparer.prepare(t), i = await this.env.bpPreparer.getBlockConfig(t);
+    await A(
+      this.env.pl,
+      this.rid,
+      s,
+      (a) => a.migrateBlockPack(
+        e,
+        n,
+        r ? JSON.stringify(i.initialArgs) : void 0
+      )
+    ), await this.projectTree.refreshState();
+  }
+  /** Deletes a block with all associated data. */
+  async deleteBlock(e, t) {
+    await A(this.env.pl, this.rid, t, (r) => r.deleteBlock(e)), this.navigationStates.deleteBlock(e), await this.projectTree.refreshState();
+  }
+  /**
+   * Updates block order according to the given array of block ids.
+   *
+   * Provided array must contain exactly the same set of ids current project cosists of,
+   * an error will be thrown instead.
+   */
+  async reorderBlocks(e, t) {
+    await A(this.env.pl, this.rid, t, (r) => {
+      const s = r.structure;
+      if (s.groups.length !== 1)
+        throw new Error("Unexpected project structure, non-sinular block group");
+      const n = s.groups[0];
+      if (n.blocks.length !== e.length)
+        throw new Error(`Lengh mismatch: ${n.blocks.length} !== ${e.length}`);
+      if (new Set(e).size !== e.length) throw new Error("Repeated block ids");
+      const i = {
+        groups: [
+          {
+            id: n.id,
+            label: n.label,
+            blocks: e.map((a) => {
+              const u = n.blocks.find((c) => c.id === a);
+              if (u === void 0) throw new Error(`Can't find block: ${a}`);
+              return u;
+            })
+          }
+        ]
+      };
+      r.updateStructure(i);
+    }), await this.projectTree.refreshState();
+  }
+  /**
+   * Renders production part of the block starting all connected heavy computations.
+   * Upstream blocks of the specified block will be started automatically if in
+   * stale state.
+   * */
+  async runBlock(e) {
+    await be(this.env.pl, this.rid, (t) => t.renderProduction([e], !0)), await this.projectTree.refreshState();
+  }
+  /**
+   * Stops the block if it is running by destroying its production state. All
+   * its downstreams will also be destroyed or moved to limbo if already
+   * calculated.
+   * */
+  async stopBlock(e) {
+    await be(this.env.pl, this.rid, (t) => t.stopProduction(e)), await this.projectTree.refreshState();
+  }
+  /** Update block label. */
+  async setBlockLabel(e, t, r) {
+    await A(this.env.pl, this.rid, r, (s) => {
+      s.setBlockLabel(e, t);
+    }), await this.projectTree.refreshState();
+  }
+  /**
+   * Sets block args, and changes whole project state accordingly.
+   * Along with setting arguments one can specify author marker, that will be
+   * transactionally associated with the block, to facilitate conflict resolution
+   * in collaborative editing scenario.
+   * */
+  async setBlockArgs(e, t, r) {
+    await A(
+      this.env.pl,
+      this.rid,
+      r,
+      (s) => s.setArgs([{ blockId: e, args: JSON.stringify(t) }])
+    ), await this.projectTree.refreshState();
+  }
+  /**
+   * Sets ui block state associated with the block.
+   * Along with setting arguments one can specify author marker, that will be
+   * transactionally associated with the block, to facilitate conflict resolution
+   * in collaborative editing scenario.
+   * */
+  async setUiState(e, t, r) {
+    await A(
+      this.env.pl,
+      this.rid,
+      r,
+      (s) => s.setUiState(e, t === void 0 ? void 0 : JSON.stringify(t))
+    ), await this.projectTree.refreshState();
+  }
+  /**
+   * Sets navigation state.
+   * */
+  async setNavigationState(e, t) {
+    this.navigationStates.setState(e, t);
+  }
+  /**
+   * Sets block args and ui state, and changes the whole project state accordingly.
+   * Along with setting arguments one can specify author marker, that will be
+   * transactionally associated with the block, to facilitate conflict resolution
+   * in collaborative editing scenario.
+   * */
+  async setBlockArgsAndUiState(e, t, r, s) {
+    await A(this.env.pl, this.rid, s, (n) => {
+      n.setArgs([{ blockId: e, args: JSON.stringify(t) }]), n.setUiState(e, JSON.stringify(r));
+    }), await this.projectTree.refreshState();
+  }
+  /** Resets arguments and ui state of the block to initial state */
+  async resetBlockArgsAndUiState(e, t) {
+    await this.env.pl.withWriteTx("BlockInputsReset", async (r) => {
+      const s = we(
+        (await r.getField(S(this.rid, C(e, "blockPack")))).value
+      ), n = we(
+        (await r.getField(S(s, y.HolderRefField))).value
+      ), i = await r.getResourceData(n, !1), a = JSON.parse(
+        Buffer.from(w(i.data)).toString("utf-8")
+      );
+      await A(r, this.rid, t, (u) => {
+        u.setArgs([{ blockId: e, args: JSON.stringify(a.config.initialArgs) }]), u.setUiState(e, void 0);
+      }), await r.commit();
+    }), await this.projectTree.refreshState();
+  }
+  getBlockComputables(e) {
+    const t = this.blockComputables.get(e);
+    if (t === void 0) {
+      const r = ds(this.projectTree.entry(), e, this.env), n = {
+        fullState: P.make(
+          (i) => ({
+            argsAndUiState: ls(this.projectTree.entry(), e),
+            outputs: r,
+            navigationState: this.navigationStates.getState(e)
+          }),
+          {
+            postprocessValue: (i) => ({
+              ...i.argsAndUiState,
+              outputs: i.outputs,
+              navigationState: i.navigationState
+            })
+          }
+        ).withPreCalculatedValueTree()
+      };
+      return this.blockComputables.set(e, n), n;
+    }
+    return t;
+  }
+  /**
+   * Returns a computable, that can be used to retrieve and watch full block state,
+   * including outputs, arguments, ui state.
+   * */
+  getBlockState(e) {
+    return this.getBlockComputables(e).fullState;
+  }
+  /**
+   * Returns a computable, that can be used to retrieve and watch path of the
+   * folder containing frontend code.
+   * */
+  getBlockFrontend(e) {
+    const t = this.blockFrontends.get(e);
+    if (t === void 0) {
+      const r = us(
+        this.projectTree.entry(),
+        e,
+        this.env
+      ).withPreCalculatedValueTree();
+      return this.blockFrontends.set(e, r), r;
+    }
+    return t;
+  }
+  /** Called by middle layer on close */
+  async destroy() {
+    this.destroyed = !0, this.abortController.abort(), await this.refreshLoopResult, await this.projectTree.terminate(), this.overview.resetState(), this.blockFrontends.forEach((e) => e.resetState()), this.blockComputables.forEach((e) => {
+      e.fullState.resetState();
+    }), this.activeConfigs.resetState();
+  }
+  /** @deprecated */
+  async destroyAndAwaitTermination() {
+    await this.destroy();
+  }
+  static async init(e, t) {
+    const r = await ht.init(e.pl, t, e.ops.defaultTreeOptions);
+    return new Je(e, t, r);
+  }
+}
+const Lt = {
+  platformLocalStorageNameToPath: {},
+  localStorageNameToPath: { local: gt.homedir() },
+  blobDriverOps: {
+    cacheSoftSizeBytes: 100 * 1024 * 1024,
+    // 100MB
+    nConcurrentDownloads: 10
+  },
+  uploadDriverOps: {
+    nConcurrentPartUploads: 10,
+    nConcurrentGetProgresses: 10,
+    pollingInterval: 1e3,
+    stopPollingDelay: 1e3
+  },
+  logStreamDriverOps: {
+    nConcurrentGetLogs: 10,
+    pollingInterval: 1e3,
+    stopPollingDelay: 1e3
+  }
+}, fs = {
+  ...Lt,
+  defaultTreeOptions: {
+    pollingInterval: 350,
+    stopPollingDelay: 2500
+  },
+  devBlockUpdateRecheckInterval: 1e3,
+  projectRefreshInterval: 700,
+  stagingRenderingRate: 5
+}, gs = {
+  minDelay: 1500
+}, ms = "__no_updates__";
+class vs extends rr {
+  constructor(t = {}) {
+    super({ ...t, ...gs });
+    d(this, "http");
+    this.http = t.http;
+  }
+  getKey(t) {
+    switch (t.type) {
+      case "dev":
+      case "dev-v1":
+        return `dev_1_${t.folder}_${t.mtime}`;
+      case "dev-v2":
+        return `dev_2_${t.folder}_${t.mtime}`;
+      default:
+        return ms;
+    }
+  }
+  async readValue(t) {
+    try {
+      switch (t.type) {
+        case "dev":
+        case "dev-v1": {
+          const r = await vt(t.folder);
+          return r === t.mtime ? void 0 : { ...t, mtime: r };
+        }
+        case "dev-v2": {
+          const r = await lt(t.folder);
+          if (r === void 0) return;
+          const s = await Ae(r);
+          return s === t.mtime ? void 0 : { ...t, mtime: s };
+        }
+        default:
+          return;
+      }
+    } catch {
+      return;
+    }
+  }
+  resultsEqual(t, r) {
+    if (t === void 0 && r === void 0) return !0;
+    if (t === void 0 || r === void 0) return !1;
+    if (t.type === "from-registry-v1" || r.type === "from-registry-v1")
+      throw new Error("Unexpected, not yet supported.");
+    return t.folder === r.folder && t.mtime === r.mtime;
+  }
+}
+class it {
+  constructor() {
+    d(this, "resources", /* @__PURE__ */ new Map());
+  }
+  check(e) {
+    const t = this.resources.get(e);
+    if (t === void 0) throw new Error("Unexpected state.");
+    if (t.refCount === 0) {
+      this.resources.delete(e);
+      const r = t.resource;
+      r != null && typeof r[Symbol.dispose] == "function" && r[Symbol.dispose]();
+    }
+  }
+  acquire(e) {
+    const t = this.calculateParamsKey(e);
+    let r = this.resources.get(t);
+    r === void 0 && (r = { refCount: 0, resource: this.createNewResource(e) }, this.resources.set(t, r)), r.refCount++;
+    let s = !1;
+    return {
+      resource: r.resource,
+      key: t,
+      unref: () => {
+        s || (r.refCount--, s = !0, this.check(t));
+      }
+    };
+  }
+  getByKey(e) {
+    if (!this.resources.has(e)) throw new Error(`resource not found, key = ${e}`);
+    return this.resources.get(e).resource;
+  }
+  tryGetByKey(e) {
+    var t;
+    return (t = this.resources.get(e)) == null ? void 0 : t.resource;
+  }
+}
+const ys = require("@milaboratories/pframes-node");
+function at(o) {
+  return String(o.id);
+}
+class bs {
+  constructor(e, t) {
+    d(this, "pFrame", new ys.PFrame());
+    d(this, "blobIdToResource", /* @__PURE__ */ new Map());
+    d(this, "blobHandleComputables", /* @__PURE__ */ new Map());
+    d(this, "preloadBlob", async (e) => {
+      const t = e.map((r) => this.getOrCreateComputableForBlob(r));
+      for (const r of t) await r.awaitStableFullValue();
+    });
+    d(this, "resolveBlob", async (e) => {
+      const t = this.getOrCreateComputableForBlob(e);
+      return this.blobDriver.getLocalPath((await t.awaitStableValue()).handle);
+    });
+    this.blobDriver = e, this.columns = t, this.pFrame.setDataSource(this);
+    for (const r of t) {
+      for (const n of yo(r.data)) this.blobIdToResource.set(at(n), n);
+      const s = bo(r.data, at);
+      try {
+        this.pFrame.addColumnSpec(r.id, r.spec), this.pFrame.setColumnData(r.id, s);
+      } catch (n) {
+        throw new Error(
+          `Adding column ${r.id} to PFrame failed: ${n}; Spec: ${r.spec}, DataInfo: ${s}.`
+        );
+      }
+    }
+  }
+  getOrCreateComputableForBlob(e) {
+    let t = this.blobHandleComputables.get(e);
+    if (t !== void 0) return t;
+    const r = this.blobIdToResource.get(e);
+    if (r === void 0) throw new Error(`Blob with id ${e} not found.`);
+    return t = this.blobDriver.getDownloadedBlob(r).withPreCalculatedValueTree(), this.blobHandleComputables.set(e, t), t;
+  }
+  [Symbol.dispose]() {
+    for (const e of this.blobHandleComputables.values()) e.resetState();
+    this.pFrame.dispose();
+  }
+}
+class ws {
+  constructor(e) {
+    d(this, "pFrames");
+    d(this, "pTables");
+    this.blobDriver = e, this.pFrames = new class extends it {
+      constructor(t) {
+        super(), this.blobDriver = t;
+      }
+      createNewResource(t) {
+        return new bs(this.blobDriver, t);
+      }
+      calculateParamsKey(t) {
+        return ks(t);
+      }
+    }(this.blobDriver), this.pTables = new class extends it {
+      constructor(t) {
+        super(), this.pFrames = t;
+      }
+      async createNewResource(t) {
+        const s = await this.pFrames.getByKey(t.pFrameHandle).pFrame.createTable({
+          src: q(t.def.src),
+          filters: t.def.filters
+        });
+        return t.def.sorting.length !== 0 ? s.sort(t.def.sorting) : s;
+      }
+      calculateParamsKey(t) {
+        return Ss(t);
+      }
+    }(this.pFrames);
+  }
+  //
+  // Internal / Config API Methods
+  //
+  createPFrame(e, t) {
+    const r = e.map((n) => z(n, (i) => Fo(i))), s = this.pFrames.acquire(r);
+    return t.addOnDestroy(s.unref), s.key;
+  }
+  createPTable(e, t) {
+    const r = this.createPFrame(Cs(e.src), t), s = ct(e, (i) => i.id), n = this.pTables.acquire({ def: s, pFrameHandle: r });
+    return t.addOnDestroy(n.unref), n.key;
+  }
+  //
+  // PFrame istance methods
+  //
+  async findColumns(e, t) {
+    const r = {
+      ...t,
+      compatibleWith: t.compatibleWith.length !== 0 ? [{ axesSpec: t.compatibleWith, qualifications: [] }] : []
+    };
+    return {
+      hits: (await this.pFrames.getByKey(e).pFrame.findColumns(r)).hits.map(
+        (s) => s.hit
+      )
+    };
+  }
+  async getColumnSpec(e, t) {
+    return this.pFrames.getByKey(e).pFrame.getColumnSpec(t);
+  }
+  async listColumns(e) {
+    return this.pFrames.getByKey(e).pFrame.listColumns();
+  }
+  async calculateTableData(e, t) {
+    let r = await this.pFrames.getByKey(e).pFrame.createTable({
+      src: q(t.src),
+      filters: t.filters
+    });
+    if (t.sorting.length > 0) {
+      const i = await r.sort(t.sorting);
+      r.dispose(), r = i;
+    }
+    const s = r.getSpec(), n = await r.getData([...s.keys()]);
+    return r.dispose(), s.map((i, a) => ({
+      spec: i,
+      data: n[a]
+    }));
+  }
+  async getUniqueValues(e, t) {
+    return await this.pFrames.getByKey(e).pFrame.getUniqueValues(t);
+  }
+  //
+  // PTable istance methods
+  //
+  async getShape(e) {
+    return (await this.pTables.getByKey(e)).getShape();
+  }
+  async getSpec(e) {
+    return (await this.pTables.getByKey(e)).getSpec();
+  }
+  async getData(e, t, r) {
+    return (await this.pTables.getByKey(e)).getData(t, r);
+  }
+}
+function q(o) {
+  switch (o.type) {
+    case "column":
+      return {
+        type: "column",
+        columnId: o.column,
+        qualifications: []
+      };
+    case "inner":
+    case "full":
+      return {
+        type: o.type,
+        entries: o.entries.map((e) => q(e))
+      };
+    case "outer":
+      return {
+        type: "outer",
+        primary: q(o.primary),
+        secondary: o.secondary.map((e) => q(e))
+      };
+    default:
+      D(o);
+  }
+}
+function Ss(o) {
+  const e = he("sha256");
+  return e.update(o.pFrameHandle), e.update(Ee(o.def)), e.digest().toString("hex");
+}
+function ks(o) {
+  const e = o.map((s) => s.id).sort(), t = he("sha256");
+  let r = "";
+  for (const s of e)
+    r !== s && (t.update(s), r = s);
+  return t.digest().toString("hex");
+}
+function Cs(o) {
+  const e = /* @__PURE__ */ new Map();
+  return ae(o, e), [...e.values()];
+}
+function ae(o, e) {
+  switch (o.type) {
+    case "column":
+      e.set(o.column.id, o.column);
+      return;
+    case "full":
+    case "inner":
+      for (const t of o.entries) ae(t, e);
+      return;
+    case "outer":
+      ae(o.primary, e);
+      for (const t of o.secondary) ae(t, e);
+      return;
+    default:
+      D(o);
+  }
+}
+async function Ps(o, e, t) {
+  const r = { ...Lt, ...t };
+  Fs(e, r);
+  const s = new dt(r.localSecret), n = cr(e, o, r.platformLocalStorageNameToPath), i = ur(o, e), a = lr(o, e), u = dr(o, e), c = pr(o, e), l = new hr(
+    e,
+    n,
+    i,
+    r.blobDownloadPath,
+    s,
+    r.blobDriverOps
+  ), p = new fr(
+    e,
+    s,
+    a,
+    u,
+    r.uploadDriverOps
+  ), h = new gr(i, r.logStreamDriverOps), g = new mr(h, l), b = new vr(e, c, o, s, r.localStorageNameToPath), B = new ws(l);
+  return {
+    blobDriver: l,
+    logDriver: g,
+    lsDriver: b,
+    signer: s,
+    uploadDriver: p,
+    pFrameDriver: B
+  };
+}
+function Fs(o, e) {
+  e.localStorageNameToPath.local != gt.homedir() && o.warn(`'local' storage with homedir was overwrote: ${e.localStorageNameToPath.local}`);
+  const t = Object.keys(e.platformLocalStorageNameToPath), r = Object.keys(e.localStorageNameToPath).find(
+    (s) => t.includes(s)
+  );
+  if (r)
+    throw new Error(
+      `Platform local storages include one or more local storages:  ${r}. Note that we automatically included 'local' storage with user's home directory.`
+    );
+}
+class Jt {
+  constructor(e, t, r, s, n, i, a) {
+    d(this, "pl");
+    /** Contains a reactive list of projects along with their meta information. */
+    d(this, "projectList");
+    //
+    // Projects
+    //
+    d(this, "openedProjectsByRid", /* @__PURE__ */ new Map());
+    this.env = e, this.driverKit = t, this.signer = r, this.projectListResourceId = s, this.openedProjectsList = n, this.projectListTree = i, this.projectList = a, this.pl = this.env.pl;
+  }
+  /** Returns extended API driver kit used internally by middle layer. */
+  get internalDriverKit() {
+    return this.env.driverKit;
+  }
+  //
+  // Project List Manipulation
+  //
+  /** Creates a project with initial state and adds it to project list. */
+  async createProject(e, t = Y()) {
+    const r = await this.pl.withWriteTx("MLCreateProject", async (s) => {
+      const n = await vo(s, e);
+      return s.createField(S(this.projectListResourceId, t), "Dynamic", n), await s.commit(), await er(n);
+    });
+    return await this.projectListTree.refreshState(), r;
+  }
+  /** Updates project metadata */
+  async setProjectMeta(e, t, r) {
+    await A(this.pl, e, r, async (s) => {
+      s.setMeta(t);
+    }), await this.projectListTree.refreshState();
+  }
+  /** Permanently deletes project from the project list, this will result in
+   * destruction of all attached objects, like files, analysis results etc. */
+  async deleteProject(e) {
+    await this.pl.withWriteTx("MLRemoveProject", async (t) => {
+      t.removeField(S(this.projectListResourceId, e)), await t.commit();
+    }), await this.projectListTree.refreshState();
+  }
+  async projectIdToResourceId(e) {
+    return await this.pl.withReadTx("Project id to resource id", async (t) => {
+      const r = (await t.getField(S(this.projectListResourceId, e))).value;
+      if (ce(r)) throw new Error("Unexpected project list structure.");
+      return r;
+    });
+  }
+  async ensureProjectRid(e) {
+    return typeof e == "string" ? await this.projectIdToResourceId(e) : e;
+  }
+  /** Opens a project, and starts corresponding project maintenance loop. */
+  async openProject(e) {
+    const t = await this.ensureProjectRid(e);
+    if (this.openedProjectsByRid.has(t)) throw new Error(`Project ${t} already opened`);
+    this.openedProjectsByRid.set(t, await Je.init(this.env, t)), this.openedProjectsList.setValue([...this.openedProjectsByRid.keys()]);
+  }
+  /** Closes the project, and deallocate all corresponding resources. */
+  async closeProject(e) {
+    const t = this.openedProjectsByRid.get(e);
+    if (t === void 0) throw new Error(`Project ${e} not found among opened projects`);
+    this.openedProjectsByRid.delete(e), await t.destroy(), this.openedProjectsList.setValue([...this.openedProjectsByRid.keys()]);
+  }
+  /** Returns a project access object for opened project, for the given project
+   * resource id. */
+  getOpenedProject(e) {
+    const t = this.openedProjectsByRid.get(e);
+    if (t === void 0) throw new Error(`Project ${e} not found among opened projects`);
+    return t;
+  }
+  /** Deallocates all runtime resources consumed by this object and awaits
+   * actual termination of event loops and other processes associated with
+   * them. */
+  async close() {
+    await Promise.all([...this.openedProjectsByRid.values()].map((e) => e.destroy())), this.env.quickJs, await this.projectListTree.terminate();
+  }
+  /** @deprecated */
+  async closeAndAwaitTermination() {
+    await this.close();
+  }
+  /** Generates sufficiently random string to be used as local secret for the
+   * middle layer */
+  static generateLocalSecret() {
+    return dt.generateSecret();
+  }
+  /** Initialize middle layer */
+  static async init(e, t) {
+    const r = { ...fs, ...t }, s = await e.withWriteTx("MLInitialization", async (h) => {
+      const g = S(h.clientRoot, Lr);
+      h.createField(g, "Dynamic");
+      const b = await h.getField(g);
+      if (ce(b.value)) {
+        const B = h.createEphemeral(wt);
+        return h.lock(B), h.setField(g, B), await h.commit(), await B.globalId;
+      } else
+        return b.value;
+    }), n = new _t(console), i = await Ps(e, n, r), a = new uo(i.signer), u = new yr(
+      n,
+      e.httpDispatcher,
+      r.frontendDownloadPath
+    ), c = {
+      pl: e,
+      signer: i.signer,
+      ops: r,
+      bpPreparer: a,
+      frontendDownloadDriver: u,
+      driverKit: i,
+      blockUpdateWatcher: new vs({
+        minDelay: r.devBlockUpdateRecheckInterval,
+        http: e.httpDispatcher
+      }),
+      quickJs: await ir()
+    }, l = new or([]), p = await Kr(e, s, l, c);
+    return new Jt(
+      c,
+      i,
+      i.signer,
+      s,
+      l,
+      p.tree,
+      p.computable
+    );
+  }
+}
+export {
+  Hs as BlockPackRegistry,
+  Ws as CentralDevSnapshotRegistry,
+  _s as CentralRegistry,
+  Lt as DefaultDriverKitOps,
+  fs as DefaultMiddleLayerOps,
+  Xs as FieldType,
+  Ct as FrontendFromFolderResourceType,
+  kt as FrontendFromUrlResourceType,
+  Jt as MiddleLayer,
+  Je as Project,
+  en as ResourceType,
+  Yr as TengoTemplateGet,
+  Qr as TengoTemplateGetRegistry,
+  Xr as TengoTemplateGetTemplate,
+  Zr as TengoTemplateGetTemplateURI,
+  eo as TengoTemplatePack,
+  to as TengoTemplatePackConvert,
+  oo as TengoTemplatePackConvertTemplate,
+  ro as TengoTemplatePackConvertTemplatePack,
+  St as createRenderTemplate,
+  vt as getDevV1PacketMtime,
+  Ae as getDevV2PacketMtime,
+  Ps as initDriverKit,
+  Ve as loadTemplate,
+  so as prepareTemplateSpec
+};
+//# sourceMappingURL=index.mjs.map