@platforma-sdk/model 1.79.27 → 1.80.2

package/src/columns/column_recipes/index.ts

@@ -0,0 +1,127 @@
+import {
+  isColumnDiscoveredKey,
+  isColumnOverriddenKey,
+  parseColumnIdSafely,
+  type ColumnUniversalId,
+  type PObjectId,
+  isPObjectKey,
+  isColumnFilteredKey,
+} from "@milaboratories/pl-model-common";
+import type { GlobalCfgRenderCtx } from "../../render/internal";
+import { ColumnLazyImpl } from "../column_lazy";
+import { ColumnDiscoveredRecipe } from "./column_discovered_recipe";
+import { ColumnFilteredRecipe } from "./column_filtered_recipe";
+import { ColumnOverriddenRecipe } from "./column_overrided_recipe";
+import type {
+  ColumnRecipe as ColumnRecipeBase,
+  ColumnRecipeId,
+  ColumnResolutionStatus,
+} from "./types";
+
+export type { ColumnFieldStatus, ColumnRecipeId, ColumnResolutionStatus, SpecQuery } from "./types";
+export { ColumnAbsentError } from "../column_lazy";
+export { ColumnDiscoveredRecipe } from "./column_discovered_recipe";
+export { ColumnFilteredRecipe } from "./column_filtered_recipe";
+export { ColumnOverriddenRecipe } from "./column_overrided_recipe";
+
+// Re-declare the interface locally so the name can merge with the dispatcher
+// value declared below: a single name `ColumnRecipe` resolves to the
+// interface in type position and to the factory function (`Object.assign`d
+// with `.getStatus`) in value position.
+// (Type-only re-exports do not participate in TS declaration merging.)
+export interface ColumnRecipe<
+  ID extends ColumnRecipeId = ColumnRecipeId,
+> extends ColumnRecipeBase<ID> {}
+
+/**
+ * Build a `ColumnRecipe` from a stringified id. Dispatches to the matching
+ * concrete recipe variant based on the id's encoding and recurses on
+ * wrappers' inner `source`:
+ *
+ *   - bare {@link PObjectId} (non-JSON)               → `ColumnLazy.fromId`
+ *   - `ColumnDiscoveredKey`                          → {@link ColumnDiscoveredRecipe}
+ *   - `ColumnOverriddenKey { source, specOverrides }` → recurse on `source`,
+ *                                                       then {@link ColumnOverriddenRecipe.wrap}
+ *   - `ColumnFilteredKey { source, axisFilters }`     → recurse on `source`,
+ *                                                       then {@link ColumnFilteredRecipe.wrap}
+ *
+ * Returns `undefined` for unsupported variants (e.g. AnchoredPColumnId,
+ * which needs an anchor map to resolve) or when a nested source itself
+ * cannot be built.
+ */
+function ColumnRecipeBuild(
+  id: ColumnUniversalId,
+  opts: { ctx?: GlobalCfgRenderCtx } = {},
+): undefined | ColumnRecipe {
+  const parsed = parseColumnIdSafely(id);
+
+  if (isPObjectKey(parsed)) {
+    return ColumnLazyImpl.fromId(id as PObjectId, opts);
+  }
+
+  if (isColumnDiscoveredKey(parsed)) {
+    return ColumnDiscoveredRecipe.fromKey(parsed, opts);
+  }
+
+  if (isColumnOverriddenKey(parsed)) {
+    const inner = ColumnRecipe(parsed.source, opts);
+    if (inner === undefined) return undefined;
+    return ColumnOverriddenRecipe.wrap(inner, parsed.specOverrides);
+  }
+
+  if (isColumnFilteredKey(parsed)) {
+    // ColumnFilteredKey.source is a stringified ColumnUniversalId (leaf or
+    // any nested wrapper). Legacy `FilteredPColumnId` with an AnchoredPColumnId
+    // (object) source is not supported here — guard against it explicitly.
+    if (typeof parsed.source !== "string") {
+      throw new Error(
+        `Unsupported ColumnRecipe id variant: filtered column with non-string source (${JSON.stringify(parsed.source)})`,
+      );
+    }
+    const inner = ColumnRecipe(parsed.source, opts);
+    if (inner === undefined) return undefined;
+    return ColumnFilteredRecipe.wrap(inner, parsed.axisFilters);
+  }
+
+  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+
+/**
+ * Resolution status counterpart to {@link ColumnRecipeBuild}. Dispatches on
+ * the parsed id shape to the matching `getStatusBy*` static — never
+ * constructs the recipe. Use this at boundaries (resolver, filter/sort
+ * targets) to throw early on `absent` instead of silently producing an empty
+ * recipe via {@link ColumnRecipeBuild}.
+ */
+function ColumnRecipeGetStatus(
+  id: ColumnUniversalId,
+  opts: { ctx?: GlobalCfgRenderCtx } = {},
+): ColumnResolutionStatus {
+  const parsed = parseColumnIdSafely(id);
+  if (isPObjectKey(parsed)) return ColumnLazyImpl.getStatusById(id as PObjectId, opts);
+  if (isColumnDiscoveredKey(parsed)) return ColumnDiscoveredRecipe.getStatusByKey(parsed, opts);
+  if (isColumnOverriddenKey(parsed)) return ColumnOverriddenRecipe.getStatusByKey(parsed, opts);
+  if (isColumnFilteredKey(parsed)) return ColumnFilteredRecipe.getStatusByKey(parsed, opts);
+  throw new Error(`Unsupported ColumnRecipe id variant: ${id}`);
+}
+
+export const ColumnRecipe: typeof ColumnRecipeBuild & {
+  readonly getStatus: typeof ColumnRecipeGetStatus;
+} = Object.assign(ColumnRecipeBuild, {
+  getStatus: ColumnRecipeGetStatus,
+});
+
+/**
+ * Type-guard for any recipe class — leaf {@link ColumnLazyImpl} or any of the
+ * wrapper recipes ({@link ColumnDiscoveredRecipe}, {@link ColumnFilteredRecipe},
+ * {@link ColumnOverriddenRecipe}). Use when a value may be a raw id, a `PColumn`,
+ * or a recipe and you want to branch on the recipe case.
+ */
+export function isColumnRecipe(value: unknown): value is ColumnRecipe {
+  return (
+    value instanceof ColumnLazyImpl ||
+    value instanceof ColumnDiscoveredRecipe ||
+    value instanceof ColumnFilteredRecipe ||
+    value instanceof ColumnOverriddenRecipe
+  );
+}

package/src/columns/column_recipes/leaf_rebrand.ts

@@ -0,0 +1,28 @@
+import {
+  mapSpecQueryColumns,
+  type ColumnUniversalId,
+  type SpecQuery,
+} from "@milaboratories/pl-model-common";
+
+/**
+ * Replace every column leaf whose id equals `fromId` with `toId`, leaving
+ * other column refs (linkers, sub-anchors) intact. Wrapper recipes
+ * (Overridden / Filtered) and Discovered use this to lift their own id onto
+ * the hit leaf, so per-variant uniqueness propagates to the engine and
+ * resolver-emitted ids match leaves in the emitted SpecQuery.
+ *
+ * Generic over all SpecQuery node shapes — including `linkerJoin`, which
+ * occurs when a wrapper sits over a {@link ColumnDiscoveredRecipe}: only
+ * the deepest hit leaf carries `fromId`, every linker leaf has a different
+ * id and is left untouched.
+ */
+export function rebrandLeafId(
+  node: SpecQuery,
+  fromId: ColumnUniversalId,
+  toId: ColumnUniversalId,
+): SpecQuery {
+  if (fromId === toId) return node;
+  return mapSpecQueryColumns(node, {
+    column: (id) => (id === fromId ? toId : id),
+  });
+}

package/src/columns/column_recipes/types.ts

@@ -0,0 +1,113 @@
+import type {
+  ColumnUniversalId,
+  PColumnSpec,
+  PObjectId,
+  SpecOverrides,
+  SpecQuery,
+} from "@milaboratories/pl-model-common";
+
+export type { SpecQuery };
+
+/**
+ * Stable identifier of a recipe: either the canonical {@link PObjectId} of a
+ * leaf or a {@link ColumnUniversalId} encoding `Overridden / Discovered /
+ * Filtered` layers on top of it.
+ *
+ * Recipes are equivalent as value-objects iff their `id`s match (structurally,
+ * after canonicalization).
+ */
+export type ColumnRecipeId = ColumnUniversalId;
+
+/**
+ * Aggregate data status of a recipe: the "worst" status across every
+ * PObjectId the recipe references (the leaf itself plus any refs inside
+ * overrides/discovery).
+ *
+ * "All or nothing" semantics: spec/query built from a recipe are meaningful
+ * only when every referenced column is `present`.
+ */
+export type ColumnFieldStatus = "resolving" | "absent" | "present";
+
+/**
+ * Resolution status of a recipe — whether the recipe is meaningful in the
+ * active render ctx. Aggregates spec readiness (the recipe can be
+ * constructed/used) and data readiness (the underlying leaves can be read).
+ *
+ *  - `present`:  spec + data readable end-to-end.
+ *  - `resolving`: more accessor inputs may still arrive — recheck later.
+ *  - `absent`:   every relevant accessor is `inputsLocked`; nothing more will
+ *                appear. Used at boundaries to throw early instead of silently
+ *                producing an empty/broken recipe.
+ *
+ * Distinct from {@link ColumnFieldStatus}: that one is the leaf's data field
+ * status only. {@link ColumnResolutionStatus} also folds in spec/registry
+ * readiness, so the recipe interface exposes both.
+ */
+export type ColumnResolutionStatus = "present" | "resolving" | "absent";
+
+/**
+ * Base contract of a column recipe — an immutable description of HOW to
+ * obtain a column, not the column itself.
+ *
+ * A recipe is a value-object. The only transformation exposed via the
+ * interface is {@link withSpecs}: it overlays overrides on the spec.
+ * `withDiscovery` / `withAxisFilters` are intentionally absent — discovered
+ * and filtered recipes are built only via their own factory constructors
+ * from a leaf recipe; nothing further can be stacked on top of Discovered
+ * or Filtered.
+ *
+ * Invariant: `withSpecs` never nests. A recipe is either bare or wrapped
+ * in exactly one Overridden layer. Repeated `withSpecs` merges the new
+ * overrides into the existing ones, keeping the same depth.
+ *
+ * A recipe intentionally exposes no `getSpecOverrides / getDiscovery /
+ * getAxisFilters` getters: those encoding pieces are details of the id.
+ * Consumers that need to decompose call utilities from `pl-model-common`
+ * over `recipe.id`.
+ */
+export interface ColumnRecipe<ID extends ColumnRecipeId = ColumnRecipeId> {
+  /** Canonical recipe identifier. */
+  readonly id: ID;
+
+  /** PObjectIds referenced by this recipe (leaf + any nested refs). */
+  getReferencedIds(): PObjectId[];
+
+  /**
+   * Final spec — built via `pframespec` from id + base spec of the source.
+   * No partial JS logic: the result matches what the engine returns when
+   * executing {@link getQuery}.
+   *
+   * Always returns a value: the recipe factories validate all referenced
+   * specs at construction time and return `undefined` from the factory if
+   * anything is missing. A constructed recipe is by contract spec-complete.
+   */
+  getSpec(): PColumnSpec;
+
+  /**
+   * IR describing how to obtain the column — a {@link SpecQuery} from
+   * `pl-model-common`. The recipe builds the description; execution belongs
+   * to the layer above (pframespec/engine).
+   *
+   * The return is parameterized with default `C = PObjectId`. Concrete
+   * recipes may narrow the parameter (e.g. `SpecQuery<ColumnRecipeId>`) if
+   * they need to thread nested id variants.
+   */
+  getQuery(): SpecQuery;
+
+  /**
+   * Aggregate status across ALL PObjectIds this recipe reaches: own leaf +
+   * refs from overrides + the parent chain of discovery.
+   *
+   * Rule: `absent ▸ resolving ▸ present` ("worst wins").
+   */
+  getDataStatus(): ColumnFieldStatus;
+
+  /**
+   * Apply overrides on the spec. Always returns a new recipe.
+   *
+   * Flat-merge invariant: if `self` is already Overridden, the implementation
+   * merges `overrides` with the existing ones and returns the same depth
+   * (one Overridden wrapper). No `Overridden<Overridden<...>>`.
+   */
+  withSpecs(overrides: SpecOverrides): ColumnRecipe;
+}

package/src/columns/columns_collection.test.ts

@@ -0,0 +1,164 @@
+import type { AxisSpec, PColumnSpec, PObjectId } from "@milaboratories/pl-model-common";
+import { createGlobalPObjectId } from "@milaboratories/pl-model-common";
+
+import { afterEach, beforeEach, describe, expect, test } from "vitest";
+import { ColumnsCollection } from "./columns_collection";
+import {
+  createTestCollectionDriver,
+  type TestCollectionDriverHandle,
+} from "./__test_helpers__/collection_driver";
+
+let handle: TestCollectionDriverHandle;
+
+beforeEach(() => {
+  handle = createTestCollectionDriver();
+});
+
+afterEach(async () => {
+  await handle.dispose();
+});
+
+const DEFAULT_AXIS: AxisSpec = { name: "id", type: "String" } as AxisSpec;
+
+function gid(name: string): PObjectId {
+  return createGlobalPObjectId("test-block", name);
+}
+
+function spec(name: string, axesSpec: AxisSpec[] = [DEFAULT_AXIS]): PColumnSpec {
+  return { kind: "PColumn", name, valueType: "Int", axesSpec, annotations: {} } as PColumnSpec;
+}
+
+function makeCollection(
+  cols: ReadonlyArray<{ id: PObjectId; spec: PColumnSpec }>,
+  options?: { isFinal?: boolean },
+): ColumnsCollection {
+  handle.register(cols);
+  return ColumnsCollection(
+    [
+      {
+        columns: cols.map((c) => ({ id: c.id, spec: c.spec, data: undefined })) as never,
+        isFinal: options?.isFinal ?? true,
+      },
+    ],
+    { driver: handle.driver },
+  );
+}
+
+describe("ColumnsCollection constructor", () => {
+  test("accepts column array source", () => {
+    const c = { id: gid("c1"), spec: spec("col1") };
+    expect(makeCollection([c]).getColumnIds()).toEqual([c.id]);
+  });
+
+  test("merges multiple sources", () => {
+    const c1 = { id: gid("c1"), spec: spec("col1") };
+    const c2 = { id: gid("c2"), spec: spec("col2") };
+    handle.register([c1, c2]);
+    const ids = ColumnsCollection(
+      [
+        { columns: [{ id: c1.id, spec: c1.spec, data: undefined }] as never, isFinal: true },
+        { columns: [{ id: c2.id, spec: c2.spec, data: undefined }] as never, isFinal: true },
+      ],
+      { driver: handle.driver },
+    ).getColumnIds();
+    expect(ids).toEqual([c1.id, c2.id]);
+  });
+
+  test("empty sources array yields empty collection", () => {
+    const coll = ColumnsCollection([], { driver: handle.driver });
+    expect(coll.getColumnIds()).toEqual([]);
+  });
+});
+
+describe("ColumnsCollection.isEmpty", () => {
+  test("true when no columns", () => {
+    expect(ColumnsCollection([], { driver: handle.driver }).isEmpty()).toBe(true);
+  });
+
+  test("false when at least one column", () => {
+    const c = { id: gid("c1"), spec: spec("col1") };
+    expect(makeCollection([c]).isEmpty()).toBe(false);
+  });
+});
+
+describe("ColumnsCollection.isFinal", () => {
+  test("true when all sources final", () => {
+    const c = { id: gid("c1"), spec: spec("col1") };
+    expect(makeCollection([c], { isFinal: true }).isFinal()).toBe(true);
+  });
+
+  test("false when any source incomplete", () => {
+    const c = { id: gid("c1"), spec: spec("col1") };
+    expect(makeCollection([c], { isFinal: false }).isFinal()).toBe(false);
+  });
+
+  test("true with no sources (vacuous)", () => {
+    expect(ColumnsCollection([], { driver: handle.driver }).isFinal()).toBe(true);
+  });
+});
+
+describe("ColumnsCollection.getColumnIds", () => {
+  test("deduplicates by id across sources (first wins)", () => {
+    const id = gid("c1");
+    const c1 = { id, spec: spec("col1") };
+    const c2 = { id, spec: spec("col1-dup") };
+    handle.register([c1]);
+    const ids = ColumnsCollection(
+      [
+        { columns: [{ id: c1.id, spec: c1.spec, data: undefined }] as never, isFinal: true },
+        { columns: [{ id: c2.id, spec: c2.spec, data: undefined }] as never, isFinal: true },
+      ],
+      { driver: handle.driver },
+    ).getColumnIds();
+    expect(ids).toEqual([id]);
+  });
+});
+
+describe("ColumnsCollection.addSource", () => {
+  test("returns new instance, original unchanged", () => {
+    const c1 = { id: gid("c1"), spec: spec("col1") };
+    const c2 = { id: gid("c2"), spec: spec("col2") };
+    handle.register([c1, c2]);
+    const base = makeCollection([c1]);
+    const next = base.addSource({
+      columns: [{ id: c2.id, spec: c2.spec, data: undefined } as never],
+      isFinal: true,
+    });
+
+    expect(next).not.toBe(base);
+    expect(base.getColumnIds()).toEqual([c1.id]);
+    expect(next.getColumnIds()).toEqual([c1.id, c2.id]);
+  });
+
+  test("isFinal reflects appended source", () => {
+    const c1 = { id: gid("c1"), spec: spec("col1") };
+    const c2 = { id: gid("c2"), spec: spec("col2") };
+    handle.register([c1, c2]);
+    const base = makeCollection([c1], { isFinal: true });
+    expect(base.isFinal()).toBe(true);
+
+    const next = base.addSource({
+      columns: [{ id: c2.id, spec: c2.spec, data: undefined } as never],
+      isFinal: false,
+    });
+    expect(next.isFinal()).toBe(false);
+  });
+});
+
+describe("ColumnsCollection.filter", () => {
+  test("returns collection with filtered ids", () => {
+    const c1 = { id: gid("c1"), spec: spec("col1") };
+    const c2 = { id: gid("c2"), spec: spec("col2") };
+    const ids = makeCollection([c1, c2])
+      .filter({ exclude: { name: "col1" } })
+      .getColumnIds();
+    expect(ids).toEqual([c2.id]);
+  });
+
+  test("no filters returns all ids", () => {
+    const c1 = { id: gid("c1"), spec: spec("col1") };
+    const c2 = { id: gid("c2"), spec: spec("col2") };
+    const ids = makeCollection([c1, c2]).filter({}).getColumnIds();
+    expect(ids).toEqual([c1.id, c2.id]);
+  });
+});

package/src/columns/columns_collection.ts

@@ -0,0 +1,170 @@
+import type {
+  CollectionHandle,
+  ColumnUniversalId,
+  ColumnsCollectionDriverModel,
+  ColumnsDiscoverOptions,
+  ColumnsFilterOptions,
+  SerializedColumnsSource,
+} from "@milaboratories/pl-model-common";
+import type { GlobalCfgRenderCtx } from "../render/internal";
+import { MainAccessorName, StagingAccessorName } from "../render/internal";
+import type { ColumnsSource } from "./column_providers";
+import { isColumnProvider } from "./column_providers";
+import { TreeNodeAccessor } from "../render/accessor";
+import { getService } from "../services/get_services";
+import { getCfgRenderCtx } from "../internal";
+import { ColumnRecipe } from "./column_recipes";
+import { isNil } from "es-toolkit";
+
+export interface ColumnsCollectionDeps {
+  /** Render ctx used both for service resolution and for default ctx sources. */
+  readonly ctx?: GlobalCfgRenderCtx;
+  /** Override the resolved `columnsCollection` service — primarily for tests. */
+  readonly driver?: ColumnsCollectionDriverModel;
+}
+
+/**
+ * Shorthand literals accepted inside `ColumnsCollection`'s `sources`
+ * array, expanded against the active render ctx:
+ *
+ * - `"result_pool"`  – fan-out into the host's upstream-block result pool.
+ * - `"current_block"` – main outputs + prerun (staging) accessors of the
+ *   current block, when present.
+ */
+export type ColumnsSourceShorthand = "result_pool" | "current_block";
+
+/**
+ * Build a {@link ColumnsCollection} from sandbox-side source descriptors.
+ * Resolves the `columnsCollection` driver (either from `deps.driver` or via
+ * `getService("columnsCollection")`) and asks the host to mint a fresh
+ * handle covering the supplied sources. Pass `sources === undefined` to
+ * fall back to the active render ctx (main outputs + prerun + result pool).
+ *
+ * `sources` accepts {@link ColumnsSourceShorthand} string literals
+ * (`"result_pool"`, `"current_block"`) for the common ctx-derived sources.
+ */
+export function ColumnsCollection(
+  sources?: (ColumnsCollection | ColumnsSource | ColumnsSourceShorthand)[],
+  deps?: ColumnsCollectionDeps,
+): ColumnsCollection {
+  const driver = deps?.driver ?? getService("columnsCollection", { ctx: deps?.ctx });
+  const serialized: SerializedColumnsSource[] = sources
+    ? sources.flatMap((s) => toSerializedSources(s, deps?.ctx))
+    : defaultCtxSources(deps?.ctx);
+  return new ColumnsCollectionImpl(driver.create(serialized), driver);
+}
+
+export function isColumnsCollection(value: unknown): value is ColumnsCollection {
+  return value instanceof ColumnsCollectionImpl;
+}
+
+/**
+ * Sandbox proxy over the host-side `ColumnsCollection` driver. The driver
+ * owns all column-set state; this object only carries an opaque
+ * {@link CollectionHandle} plus a reference to the driver service.
+ *
+ * Construct via {@link ColumnsCollection} — the bare constructor is a
+ * trivial `(handle, driver)` pair so that `addSource` / `discover` / `filter`
+ * can rebind a freshly-minted handle without going through source
+ * serialisation again.
+ *
+ * Every method returning a `ColumnsCollection` mints a fresh handle on the
+ * host — the host VM bridge pins it to the active render ctx, so the sandbox
+ * never has to manage refcounts.
+ */
+export class ColumnsCollectionImpl {
+  constructor(
+    public readonly handle: CollectionHandle,
+    private readonly driver: ColumnsCollectionDriverModel,
+  ) {}
+
+  isEmpty(): boolean {
+    return this.driver.isEmpty(this.handle);
+  }
+
+  isFinal(): boolean {
+    return this.driver.isFinal(this.handle);
+  }
+
+  getColumnIds(): ColumnUniversalId[] {
+    return this.driver.getColumns(this.handle);
+  }
+
+  getColumns(): ColumnRecipe[] {
+    return this.getColumnIds()
+      .map((id) => ColumnRecipe(id))
+      .filter((c): c is ColumnRecipe => !isNil(c));
+  }
+
+  addSource(source: ColumnsSource | ColumnsCollection): ColumnsCollection {
+    return new ColumnsCollectionImpl(
+      this.driver.addSource(this.handle, toSerializedSources(source)),
+      this.driver,
+    );
+  }
+
+  discover(options: ColumnsDiscoverOptions): ColumnsCollection {
+    return new ColumnsCollectionImpl(this.driver.discover(this.handle, options), this.driver);
+  }
+
+  filter(options: ColumnsFilterOptions): ColumnsCollection {
+    return new ColumnsCollectionImpl(this.driver.filter(this.handle, options), this.driver);
+  }
+}
+
+/** Public type alias — value of the same name is the factory function above. */
+export type ColumnsCollection = ColumnsCollectionImpl;
+
+function toSerializedSources(
+  source: ColumnsCollection | ColumnsSource | ColumnsSourceShorthand,
+  ctx?: GlobalCfgRenderCtx,
+): SerializedColumnsSource[] {
+  if (source === "result_pool") {
+    return [{ kind: "result_pool" }];
+  }
+  if (source === "current_block") {
+    return currentBlockSources(ctx);
+  }
+  if (source instanceof ColumnsCollectionImpl) {
+    return [{ kind: "collection", handle: source.handle }];
+  }
+  if (source instanceof TreeNodeAccessor) {
+    return [{ kind: "accessor", accessor: source.handle, path: source.resolvePath }];
+  }
+  if (isColumnArray(source)) {
+    return [{ kind: "ids", ids: source.columns.map((c) => c.id), isFinal: source.isFinal }];
+  }
+  if (isColumnProvider(source)) {
+    return [{ kind: "ids", ids: source.getColumns().map((c) => c.id), isFinal: source.isFinal() }];
+  }
+  throw new Error("ColumnsCollection: unrecognised ColumnsSource shape");
+}
+
+function isColumnArray(source: unknown): source is {
+  columns: ReadonlyArray<{ id: ColumnUniversalId; spec?: unknown; data?: unknown }>;
+  isFinal: boolean;
+} {
+  if (typeof source !== "object" || source === null) return false;
+  const s = source as { columns?: unknown; isFinal?: unknown };
+  return Array.isArray(s.columns) && typeof s.isFinal === "boolean";
+}
+
+function currentBlockSources(ctx?: GlobalCfgRenderCtx): SerializedColumnsSource[] {
+  const renderCtx = ctx ?? getCfgRenderCtx();
+  const sources: SerializedColumnsSource[] = [];
+
+  const outputs = renderCtx.getAccessorHandleByName(MainAccessorName);
+  if (outputs !== undefined) {
+    sources.push({ kind: "accessor", accessor: outputs, path: [MainAccessorName] });
+  }
+  const prerun = renderCtx.getAccessorHandleByName(StagingAccessorName);
+  if (prerun !== undefined) {
+    sources.push({ kind: "accessor", accessor: prerun, path: [StagingAccessorName] });
+  }
+
+  return sources;
+}
+
+function defaultCtxSources(ctx?: GlobalCfgRenderCtx): SerializedColumnsSource[] {
+  return [...currentBlockSources(ctx), { kind: "result_pool" }];
+}