{"version":3,"file":"api.cjs","names":["mapPObjectData","TreeNodeAccessor","isDataInfo","mapDataInfo","throwError","getCfgRenderCtx","legacyColumnSelectorsToPredicate","deriveLabels","withEnrichments","AnchoredIdDeriver","isPlRef","PColumnCollection","mapValueInVOE","ensurePColumn","isPColumnSpec","isPColumn","PColumnName","readAnnotation","getService","ifDef","StagingAccessorName","MainAccessorName","patchInSetFilters","isString","extractAllColumns","allPColumnsReady","mapPTableDef","mapPTableDefV2","getPluginData","parseJson"],"sources":["../../src/render/api.ts"],"sourcesContent":["import type {\n  AnchoredPColumnSelector,\n  AnyFunction,\n  AxisId,\n  DataInfo,\n  ModelServices,\n  Option,\n  PColumn,\n  PColumnSelector,\n  PColumnSpec,\n  PColumnValues,\n  PFrameDef,\n  PFrameHandle,\n  ColumnUniversalId,\n  PObject,\n  PObjectId,\n  PObjectSpec,\n  PTableDef,\n  PTableDefV2,\n  PTableHandle,\n  PTableRecordFilter,\n  PTableSorting,\n  PlRef,\n  ResolveAnchorsOptions,\n  ResultCollection,\n  SUniversalPColumnId,\n  ValueOrError,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  AnchoredIdDeriver,\n  ensurePColumn,\n  parseJson,\n  isDataInfo,\n  isPColumn,\n  isPColumnSpec,\n  isPlRef,\n  mapDataInfo,\n  mapPObjectData,\n  mapPTableDef,\n  mapPTableDefV2,\n  mapValueInVOE,\n  PColumnName,\n  readAnnotation,\n  withEnrichments,\n  legacyColumnSelectorsToPredicate,\n  extractAllColumns,\n  visitDataInfo,\n} from \"@milaboratories/pl-model-common\";\nimport canonicalize from \"canonicalize\";\nimport type { Optional } from \"utility-types\";\nimport { getCfgRenderCtx } from \"../internal\";\nimport { getPluginData } from \"../block_storage\";\nimport type {\n  PluginHandle,\n  PluginFactoryLike,\n  InferFactoryData,\n  InferFactoryParams,\n} from \"../plugin_handle\";\nimport { TreeNodeAccessor, ifDef } from \"./accessor\";\nimport type { FutureRef } from \"./future\";\nimport type { AccessorHandle, GlobalCfgRenderCtx } from \"./internal\";\nimport { MainAccessorName, StagingAccessorName } from \"./internal\";\nimport {\n  PColumnCollection,\n  type AxisLabelProvider,\n  type ColumnProvider,\n} from \"./util/column_collection\";\nimport type { LabelDerivationOps } from \"./util/label\";\nimport { deriveLabels } from \"./util/label\";\nimport type { APColumnSelectorWithSplit } from \"./util/split_selectors\";\nimport { patchInSetFilters } from \"./util/pframe_upgraders\";\nimport type { PColumnDataUniversal } from \"./internal\";\nimport { getService } from \"../services\";\nimport { allPColumnsReady } from \"./util\";\nimport { throwError } from \"@milaboratories/helpers\";\nimport { isString } from \"es-toolkit\";\n\n/**\n * Helper function to match domain objects\n * @param query Optional domain to match against\n * @param target Optional domain to match\n * @returns true if domains match, false otherwise\n */\nfunction matchDomain(query?: Record<string, string>, target?: Record<string, string>) {\n  if (query === undefined) return target === undefined;\n  if (target === undefined) return true;\n  for (const k in target) {\n    if (query[k] !== target[k]) return false;\n  }\n  return true;\n}\n\nexport type UniversalColumnOption = { label: string; value: SUniversalPColumnId };\n\n/**\n * Transforms PColumn data into the internal representation expected by the platform\n * @param column Data from a PColumn to transform\n * @returns Transformed data compatible with platform API\n */\nexport function finalizePColumnData(\n  column: PColumn<PColumnDataUniversal<undefined | TreeNodeAccessor>>,\n): PColumn<PColumnValues | AccessorHandle | DataInfo<AccessorHandle>> {\n  return mapPObjectData(column, (data) => {\n    if (data instanceof TreeNodeAccessor) {\n      return data.handle;\n    } else if (isDataInfo(data)) {\n      let ready = true;\n      visitDataInfo(data, (accessor) => (ready &&= accessor?.getIsReadyOrError() ?? false));\n      if (!ready) return [];\n      return mapDataInfo(\n        data,\n        (accessor) => accessor?.handle ?? throwError(\"Accessor handle is undefined\"),\n      );\n    } else {\n      return data ?? [];\n    }\n  });\n}\n\ntype UniversalPColumnOpts = {\n  labelOps?: LabelDerivationOps;\n  dontWaitAllData?: boolean;\n  exclude?: AnchoredPColumnSelector | AnchoredPColumnSelector[];\n} & ResolveAnchorsOptions;\n\ntype GetOptionsOpts = {\n  /**\n   * If true, references returned by the method will contain `requireEnrichments` flag set to true.\n   * If this reference is added to the block's args, it will communicate to the platform that the block\n   * expects enrichments of the referenced block to be available in the context of the current block.\n   */\n  refsWithEnrichments?: boolean;\n  /**\n   * Label derivation options.\n   * If provided, it will be used to derive labels for the options.\n   * If not provided, labels will be derived using the default logic.\n   */\n  label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps;\n};\n\n/**\n * @deprecated use the direct `ctx.*` methods on `RenderCtxBase` instead.\n *\n * Migration map:\n * - `getSpecs` → `ctx.getSpecs`\n * - `getSpecByRef` / `getPColumnSpecByRef` → `ctx.getSpecByRef` / `ctx.getPColumnSpecByRef`\n * - `getDataByRef` / `getPColumnByRef` → `ctx.getDataByRef` / `ctx.getPColumnByRef`\n * - `getOptions` → `ctx.getOptions`\n *\n * Eager methods `selectColumns` / `getData` / `getDataWithErrors` should be\n * replaced by `ctx.getSpecs` + on-demand `ctx.getStatusByRef` /\n * `ctx.getPColumnByRef` so that the data resource is not subscribed up-front.\n */\nexport class ResultPool implements ColumnProvider, AxisLabelProvider {\n  private readonly ctx: GlobalCfgRenderCtx = getCfgRenderCtx();\n\n  public getOptions(\n    predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[],\n    opts?: GetOptionsOpts,\n  ): Option[];\n  /** @deprecated wrap label ops with { label: <...> } */\n  public getOptions(\n    predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[],\n    label?: ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps,\n  ): Option[];\n  public getOptions(\n    predicateOrSelector: ((spec: PObjectSpec) => boolean) | PColumnSelector | PColumnSelector[],\n    opts?: GetOptionsOpts | ((spec: PObjectSpec, ref: PlRef) => string) | LabelDerivationOps,\n  ): Option[] {\n    const predicate =\n      typeof predicateOrSelector === \"function\"\n        ? predicateOrSelector\n        : legacyColumnSelectorsToPredicate(predicateOrSelector);\n    const filtered = this.getSpecs().entries.filter((s) => predicate(s.obj));\n\n    let labelOps: LabelDerivationOps | ((spec: PObjectSpec, ref: PlRef) => string) = {};\n    let refsWithEnrichments: boolean = false;\n    if (typeof opts !== \"undefined\") {\n      if (typeof opts === \"function\") {\n        labelOps = opts;\n      } else if (typeof opts === \"object\") {\n        if (\"includeNativeLabel\" in opts || \"separator\" in opts || \"addLabelAsSuffix\" in opts) {\n          labelOps = opts;\n        } else {\n          opts = opts as GetOptionsOpts;\n          labelOps = opts.label ?? {};\n          refsWithEnrichments = opts.refsWithEnrichments ?? false;\n        }\n      }\n    }\n\n    if (typeof labelOps === \"object\")\n      return deriveLabels(filtered, (o) => o.obj, labelOps ?? {}).map(\n        ({ value: { ref }, label }) => ({\n          ref: withEnrichments(ref, refsWithEnrichments),\n          label,\n        }),\n      );\n    else\n      return filtered.map(({ ref, obj }) => ({\n        ref: withEnrichments(ref, refsWithEnrichments),\n        label: labelOps(obj, ref),\n      }));\n  }\n\n  public resolveAnchorCtx(\n    anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,\n  ): AnchoredIdDeriver | undefined {\n    if (anchorsOrCtx instanceof AnchoredIdDeriver) return anchorsOrCtx;\n    const resolvedAnchors: Record<string, PColumnSpec> = {};\n    for (const [key, value] of Object.entries(anchorsOrCtx)) {\n      if (isPlRef(value)) {\n        const resolvedSpec = this.getPColumnSpecByRef(value);\n        if (!resolvedSpec) return undefined;\n        resolvedAnchors[key] = resolvedSpec;\n      } else {\n        resolvedAnchors[key] = value;\n      }\n    }\n    return new AnchoredIdDeriver(resolvedAnchors);\n  }\n\n  /**\n   * Returns columns that match the provided anchors and selectors. It applies axis filters and label derivation.\n   *\n   * @param anchorsOrCtx - Anchor context for column selection (same as in getCanonicalOptions)\n   * @param predicateOrSelectors - Predicate or selectors for filtering columns (same as in getCanonicalOptions)\n   * @param opts - Optional configuration for label generation and data waiting\n   * @returns A PFrameHandle for the created PFrame, or undefined if any required data is missing\n   */\n  public getAnchoredPColumns(\n    anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts?: UniversalPColumnOpts,\n  ): undefined | PColumn<undefined | PColumnDataUniversal>[] {\n    const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);\n    if (!anchorCtx) return undefined;\n    return new PColumnCollection()\n      .addColumnProvider(this)\n      .addAxisLabelProvider(this)\n      .getColumns(predicateOrSelectors, {\n        ...opts,\n        anchorCtx,\n      });\n  }\n\n  /**\n   * Calculates anchored identifier options for columns matching a given predicate and returns their\n   * canonicalized representations.\n   *\n   * This function filters column specifications from the result pool that match the provided predicate,\n   * creates a standardized AnchorCtx from the provided anchors, and generates a list of label-value\n   * pairs for UI components (like dropdowns).\n   *\n   * @param anchorsOrCtx - Either:\n   *                     - An existing AnchorCtx instance\n   *                     - A record mapping anchor IDs to PColumnSpec objects\n   *                     - A record mapping anchor IDs to PlRef objects (which will be resolved to PColumnSpec)\n   * @param predicateOrSelectors - Either:\n   *                            - A predicate function that takes a PColumnSpec and returns a boolean.\n   *                              Only specs that return true will be included.\n   *                            - An APColumnSelector object for declarative filtering, which will be\n   *                              resolved against the provided anchors and matched using matchPColumn.\n   *                            - An array of APColumnSelector objects - columns matching ANY selector\n   *                              in the array will be included (OR operation).\n   * @param opts - Optional configuration for label generation:\n   *                 - labelOps: Optional configuration for label generation:\n   *                   - includeNativeLabel: Whether to include native column labels\n   *                   - separator: String to use between label parts (defaults to \" / \")\n   *                   - addLabelAsSuffix: Whether to add labels as suffix instead of prefix\n   *                 - dontWaitAllData: Whether to skip columns that don't have all data (if not set, will return undefined,\n   *                                    if at least one column that requires splitting is missing data)\n   * @returns An array of objects with `label` (display text) and `value` (anchored ID string) properties,\n   *          or undefined if any PlRef resolution fails.\n   */\n  getCanonicalOptions(\n    anchorsOrCtx: AnchoredIdDeriver | Record<string, PColumnSpec | PlRef>,\n    predicateOrSelectors:\n      | ((spec: PColumnSpec) => boolean)\n      | APColumnSelectorWithSplit\n      | APColumnSelectorWithSplit[],\n    opts?: UniversalPColumnOpts,\n  ): { label: string; value: SUniversalPColumnId }[] | undefined {\n    const anchorCtx = this.resolveAnchorCtx(anchorsOrCtx);\n    if (!anchorCtx) return undefined;\n    const entries = new PColumnCollection()\n      .addColumnProvider(this)\n      .addAxisLabelProvider(this)\n      .getUniversalEntries(predicateOrSelectors, {\n        ...opts,\n        anchorCtx,\n      });\n    if (!entries) return undefined;\n    return entries.map((item) => ({\n      value: item.id,\n      label: item.label,\n    }));\n  }\n\n  /**\n   * @deprecated use getData()\n   */\n  public getDataFromResultPool(): ResultCollection<PObject<TreeNodeAccessor>> {\n    return this.getData();\n  }\n\n  public getData(): ResultCollection<PObject<TreeNodeAccessor>> {\n    const result = this.ctx.getDataFromResultPool();\n    return {\n      isComplete: result.isComplete,\n      entries: result.entries.map((e) => ({\n        ref: e.ref,\n        obj: {\n          ...e.obj,\n          data: new TreeNodeAccessor(e.obj.data, [e.ref.blockId, e.ref.name]),\n        },\n      })),\n    };\n  }\n\n  /**\n   * @deprecated use getDataWithErrors()\n   */\n  public getDataWithErrorsFromResultPool(): ResultCollection<\n    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, \"id\">\n  > {\n    return this.getDataWithErrors();\n  }\n\n  public getDataWithErrors(): ResultCollection<\n    Optional<PObject<ValueOrError<TreeNodeAccessor, Error>>, \"id\">\n  > {\n    const result = this.ctx.getDataWithErrorsFromResultPool();\n    return {\n      isComplete: result.isComplete,\n      entries: result.entries.map((e) => ({\n        ref: e.ref,\n        obj: {\n          ...e.obj,\n          data: mapValueInVOE(\n            e.obj.data,\n            (handle) => new TreeNodeAccessor(handle, [e.ref.blockId, e.ref.name]),\n          ),\n        },\n      })),\n    };\n  }\n\n  /**\n   * @deprecated use getSpecs()\n   */\n  public getSpecsFromResultPool(): ResultCollection<PObjectSpec> {\n    return this.getSpecs();\n  }\n\n  public getSpecs(): ResultCollection<PObjectSpec> {\n    return this.ctx.getSpecsFromResultPool();\n  }\n\n  /**\n   * @param ref a Ref\n   * @returns data associated with the ref\n   */\n  public getDataByRef(ref: PlRef): PObject<TreeNodeAccessor> | undefined {\n    const data = this.ctx.getDataFromResultPoolByRef(ref.blockId, ref.name); // Keep original call\n    // Need to handle undefined case before mapping\n    if (!data) return undefined;\n    return mapPObjectData(data, (handle) => new TreeNodeAccessor(handle, [ref.blockId, ref.name]));\n  }\n\n  /**\n   * Returns data associated with the ref ensuring that it is a p-column.\n   * @param ref a Ref\n   * @returns p-column associated with the ref\n   */\n  public getPColumnByRef(ref: PlRef): PColumn<TreeNodeAccessor> | undefined {\n    const data = this.getDataByRef(ref);\n    if (!data) return undefined;\n    return ensurePColumn(data);\n  }\n\n  /**\n   * Returns spec associated with the ref ensuring that it is a p-column spec.\n   * @param ref a Ref\n   * @returns p-column spec associated with the ref\n   */\n  public getPColumnSpecByRef(ref: PlRef): PColumnSpec | undefined {\n    const spec = this.getSpecByRef(ref);\n    if (!spec) return undefined;\n    if (!isPColumnSpec(spec)) throw new Error(`not a PColumn spec (kind = ${spec.kind})`);\n    return spec;\n  }\n\n  /**\n   * @param ref a Ref\n   * @returns object spec associated with the ref\n   */\n  public getSpecByRef(ref: PlRef): PObjectSpec | undefined {\n    return this.ctx.getSpecFromResultPoolByRef(ref.blockId, ref.name);\n  }\n\n  /**\n   * @param spec object specification\n   * @returns array of data objects with compatible specs\n   * @deprecated delete this method after Jan 1, 2025\n   */\n  public findDataWithCompatibleSpec(spec: PColumnSpec): PObject<TreeNodeAccessor>[] {\n    const result: PObject<TreeNodeAccessor>[] = [];\n\n    out: for (const data of this.getData().entries) {\n      if (!isPColumnSpec(data.obj.spec)) {\n        continue;\n      }\n\n      const oth = data.obj.spec;\n\n      if (spec.name !== oth.name) {\n        continue;\n      }\n\n      if (spec.valueType !== oth.valueType) {\n        continue;\n      }\n\n      if (spec.axesSpec.length !== oth.axesSpec.length) {\n        continue;\n      }\n\n      if (!matchDomain(spec.domain, oth.domain)) {\n        continue;\n      }\n\n      if (!matchDomain(spec.contextDomain, oth.contextDomain)) {\n        continue;\n      }\n\n      for (let i = 0; i < spec.axesSpec.length; ++i) {\n        const qAx = spec.axesSpec[i];\n        const tAx = oth.axesSpec[i];\n        if (qAx.name !== tAx.name) {\n          continue out;\n        }\n        if (qAx.type !== tAx.type) {\n          continue out;\n        }\n        if (!matchDomain(qAx.domain, tAx.domain)) {\n          continue out;\n        }\n        if (!matchDomain(qAx.contextDomain, tAx.contextDomain)) {\n          continue out;\n        }\n      }\n\n      result.push(data.obj);\n    }\n    return result;\n  }\n\n  /**\n   * Find labels data for a given axis id. It will search for a label column and return its data as a map.\n   * @returns a map of axis value => label\n   */\n  public findLabels(axis: AxisId): Record<string | number, string> | undefined {\n    const dataPool = this.getData();\n    for (const column of dataPool.entries) {\n      if (!isPColumn(column.obj)) continue;\n\n      const spec = column.obj.spec;\n      if (\n        spec.name === PColumnName.Label &&\n        spec.axesSpec.length === 1 &&\n        spec.axesSpec[0].name === axis.name &&\n        spec.axesSpec[0].type === axis.type &&\n        matchDomain(axis.domain, spec.axesSpec[0].domain) &&\n        matchDomain(axis.contextDomain, spec.axesSpec[0].contextDomain)\n      ) {\n        if (column.obj.data.resourceType.name !== \"PColumnData/Json\") {\n          throw Error(`Expected JSON column for labels, got: ${column.obj.data.resourceType.name}`);\n        }\n        const labels: Record<string | number, string> = Object.fromEntries(\n          Object.entries(\n            column.obj.data.getDataAsJson<{\n              data: Record<string | number, string>;\n            }>().data,\n          ).map((e) => [JSON.parse(e[0])[0], e[1]]),\n        );\n\n        return labels;\n      }\n    }\n    return undefined;\n  }\n\n  /**\n   * Selects columns based on the provided selectors, returning PColumn objects\n   * with lazily loaded data.\n   *\n   * @param selectors - A predicate function, a single selector, or an array of selectors.\n   * @returns An array of PColumn objects matching the selectors. Data is loaded on first access.\n   * @deprecated use `RenderCtxBase.rawResultPool` + `ResultPoolColumnsProvider` +\n   * `discoverColumns` instead. This eager path materializes column data\n   * unnecessarily for callers that only filter by spec.\n   */\n  public selectColumns(\n    selectors: ((spec: PColumnSpec) => boolean) | PColumnSelector | PColumnSelector[],\n  ): PColumn<TreeNodeAccessor | undefined>[] {\n    const predicate =\n      typeof selectors === \"function\" ? selectors : legacyColumnSelectorsToPredicate(selectors);\n\n    const matchedSpecs = this.getSpecs().entries.filter(({ obj: spec }) => {\n      if (!isPColumnSpec(spec)) return false;\n      return predicate(spec);\n    });\n\n    // Map specs to PColumn objects with lazy data loading\n    return matchedSpecs.map(({ ref, obj: spec }) => {\n      // Type assertion needed because filter ensures it's PColumnSpec\n      const pcolumnSpec = spec as PColumnSpec;\n      let _cachedData: TreeNodeAccessor | undefined | null = null; // Use null to distinguish initial state from undefined result\n      // eslint-disable-next-line @typescript-eslint/no-this-alias\n      const self = this; // Capture 'this' for use inside the getter\n\n      return {\n        id: canonicalize(ref) as PObjectId,\n        spec: pcolumnSpec,\n        get data(): TreeNodeAccessor | undefined {\n          if (_cachedData !== null) {\n            return _cachedData; // Return cached data (could be undefined if fetch failed)\n          }\n\n          _cachedData = self.getPColumnByRef(ref)?.data;\n          return _cachedData;\n        },\n      } satisfies PColumn<TreeNodeAccessor | undefined>; // Cast needed because 'data' is a getter\n    });\n  }\n\n  /**\n   * Find labels data for a given axis id of a p-column.\n   * @returns a map of axis value => label\n   */\n  public findLabelsForColumnAxis(\n    column: PColumnSpec,\n    axisIdx: number,\n  ): Record<string | number, string> | undefined {\n    const labels = this.findLabels(column.axesSpec[axisIdx]);\n    if (!labels) return undefined;\n    const axisKeys = readAnnotation(column, `pl7.app/axisKeys/${axisIdx}`);\n    if (axisKeys !== undefined) {\n      const keys = JSON.parse(axisKeys) as string[];\n      return Object.fromEntries(\n        keys.map((key) => {\n          return [key, labels[key] ?? \"Unlabelled\"];\n        }),\n      );\n    } else {\n      return labels;\n    }\n  }\n}\n\n/** Main entry point to the API available within model lambdas (like outputs, sections, etc..) */\nexport abstract class RenderCtxBase<Args = unknown, Data = unknown> {\n  public readonly ctx: GlobalCfgRenderCtx;\n\n  constructor() {\n    this.ctx = getCfgRenderCtx();\n  }\n\n  private dataCache?: { v: Data };\n\n  public get data(): Data {\n    if (this.dataCache === undefined) {\n      const raw = this.ctx.data;\n      const value = typeof raw === \"function\" ? raw() : raw;\n      this.dataCache = { v: value ? JSON.parse(value) : ({} as Data) };\n    }\n    return this.dataCache.v;\n  }\n\n  // lazy rendering because this feature is rarely used\n  private activeArgsCache?: { v?: Args };\n\n  /**\n   * Returns args snapshot the block was executed for (i.e. when \"Run\" button was pressed).\n   * Returns undefined, if block was never executed or stopped mid-way execution, so that the result was cleared.\n   * */\n  public get activeArgs(): Args | undefined {\n    if (this.activeArgsCache === undefined) {\n      const raw = this.ctx.activeArgs;\n      const value = typeof raw === \"function\" ? raw() : raw;\n      this.activeArgsCache = {\n        v: value ? JSON.parse(value) : undefined,\n      };\n    }\n    return this.activeArgsCache.v;\n  }\n\n  public getService<T extends keyof ModelServices>(name: T): ModelServices[T] {\n    return getService(name);\n  }\n\n  // /** Can be used to determine features provided by the desktop instance. */\n  // public get featureFlags() {\n  //   return this.ctx.featureFlags;\n  // }\n\n  private getNamedAccessor(name: string): TreeNodeAccessor | undefined {\n    return ifDef(\n      this.ctx.getAccessorHandleByName(name),\n      (accessor) => new TreeNodeAccessor(accessor, [name]),\n    );\n  }\n\n  public get prerun(): TreeNodeAccessor | undefined {\n    return this.getNamedAccessor(StagingAccessorName);\n  }\n\n  public get outputs(): TreeNodeAccessor | undefined {\n    return this.getNamedAccessor(MainAccessorName);\n  }\n\n  /** @deprecated use `rawResultPool` + `ResultPoolColumnsProvider` instead. */\n  public readonly resultPool = new ResultPool();\n\n  private patchPTableDef(\n    def: PTableDef<PColumn<PColumnDataUniversal>>,\n  ): PTableDef<PColumn<PColumnDataUniversal>> {\n    if (!this.ctx.featureFlags?.pTablePartitionFiltersSupport) {\n      // For old desktop move all partition filters to filters field as it doesn't read partitionFilters field\n      def = {\n        ...def,\n        partitionFilters: [],\n        filters: [...def.partitionFilters, ...def.filters],\n      };\n    }\n    if (!this.ctx.featureFlags?.pFrameInSetFilterSupport) {\n      def = {\n        ...def,\n        partitionFilters: patchInSetFilters(def.partitionFilters),\n        filters: patchInSetFilters(def.filters),\n      };\n    }\n    return def;\n  }\n\n  public createPFrame(\n    def: PFrameDef<PObjectId | SUniversalPColumnId | PColumn<undefined | PColumnDataUniversal>>,\n  ): PFrameHandle | undefined {\n    return this.ctx.createPFrame(def.map((v) => (isString(v) ? v : finalizePColumnData(v))));\n  }\n\n  // TODO remove all non-PColumn fields\n  public createPTable(def: PTableDef<PColumn<PColumnDataUniversal>>): PTableHandle | undefined;\n  public createPTable(def: {\n    columns: PColumn<PColumnDataUniversal>[];\n    filters?: PTableRecordFilter[];\n    /** Table sorting */\n    sorting?: PTableSorting[];\n  }): PTableHandle | undefined;\n  public createPTable(\n    def:\n      | PTableDef<PColumn<PColumnDataUniversal>>\n      | {\n          columns: PColumn<PColumnDataUniversal>[];\n          filters?: PTableRecordFilter[];\n          /** Table sorting */\n          sorting?: PTableSorting[];\n        },\n  ): PTableHandle | undefined {\n    let rawDef: PTableDef<PColumn<PColumnDataUniversal>>;\n    if (\"columns\" in def) {\n      rawDef = this.patchPTableDef({\n        src: {\n          type: \"full\",\n          entries: def.columns.map((c) => ({ type: \"column\", column: c })),\n        },\n        partitionFilters: def.filters ?? [],\n        filters: [],\n        sorting: def.sorting ?? [],\n      });\n    } else {\n      rawDef = this.patchPTableDef(def);\n    }\n    const columns = extractAllColumns(rawDef.src);\n    if (!allPColumnsReady(columns)) return undefined;\n    return this.ctx.createPTable(mapPTableDef(rawDef, finalizePColumnData));\n  }\n\n  public createPTableV2(\n    def: PTableDefV2<ColumnUniversalId | PColumn<undefined | PColumnDataUniversal>>,\n  ): PTableHandle | undefined {\n    return this.ctx.createPTableV2(\n      mapPTableDefV2(def, { column: (v) => (isString(v) ? v : finalizePColumnData(v)) }),\n    );\n  }\n\n  public getCurrentUnstableMarker(): string | undefined {\n    return this.ctx.getCurrentUnstableMarker();\n  }\n\n  public logInfo(msg: string): void {\n    this.ctx.logInfo(msg);\n  }\n\n  public logWarn(msg: string): void {\n    this.ctx.logWarn(msg);\n  }\n\n  public logError(msg: string): void {\n    this.ctx.logError(msg);\n  }\n}\n\n/** Main entry point to the API available within model lambdas (like outputs, sections, etc..) for v3+ blocks */\nexport class BlockRenderCtx<Args = unknown, Data = unknown> extends RenderCtxBase<Args, Data> {\n  private argsCache?: { v: Args | undefined };\n  public get args(): Args | undefined {\n    if (this.argsCache === undefined) {\n      const raw = this.ctx.args;\n      const value = typeof raw === \"function\" ? raw() : raw;\n      this.argsCache = { v: value === undefined ? undefined : JSON.parse(value) };\n    }\n    return this.argsCache.v;\n  }\n}\n\n/**\n * Render context for plugin output functions.\n * Reads plugin data from blockStorage and derives params from pre-wrapped input callbacks.\n *\n * Parameterized on the factory-like phantom F so that getPluginData returns\n * InferFactoryData<F> directly — no casts needed for the data getter.\n *\n * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types\n */\nexport class PluginRenderCtx<F extends PluginFactoryLike = PluginFactoryLike> extends RenderCtxBase<\n  unknown,\n  InferFactoryData<F>\n> {\n  private readonly handle: PluginHandle<F>;\n  private readonly wrappedInputs: Record<string, () => unknown>;\n\n  constructor(handle: PluginHandle<F>, wrappedInputs: Record<string, () => unknown>) {\n    super();\n    this.handle = handle;\n    this.wrappedInputs = wrappedInputs;\n  }\n\n  private pluginDataCache?: { v: InferFactoryData<F> };\n\n  /** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */\n  public override get data(): InferFactoryData<F> {\n    if (this.pluginDataCache === undefined) {\n      const raw = this.ctx.blockStorage();\n      this.pluginDataCache = { v: getPluginData(parseJson(raw), this.handle) };\n    }\n    return this.pluginDataCache.v;\n  }\n\n  private paramsCache?: { v: InferFactoryParams<F> };\n\n  /** Params derived from block context via pre-wrapped input callbacks */\n  public get params(): InferFactoryParams<F> {\n    if (this.paramsCache === undefined) {\n      const result: Record<string, unknown> = {};\n      for (const [key, fn] of Object.entries(this.wrappedInputs)) {\n        result[key] = fn();\n      }\n      this.paramsCache = { v: result as InferFactoryParams<F> };\n    }\n    return this.paramsCache.v;\n  }\n}\n\n/** @deprecated Use BlockRenderCtx instead */\nexport type RenderCtx<Args = unknown, Data = unknown> = BlockRenderCtx<Args, Data>;\n\nexport type RenderFunction<Args = unknown, State = unknown, Ret = unknown> = (\n  rCtx: BlockRenderCtx<Args, State>,\n) => Ret;\n\nexport type UnwrapFutureRef<K> =\n  K extends FutureRef<infer T>\n    ? T\n    : K extends bigint | boolean | null | number | string | symbol | undefined\n      ? K\n      : { [key in keyof K]: UnwrapFutureRef<K[key]> };\n\nexport type InferRenderFunctionReturn<RF extends AnyFunction> = RF extends (...args: any) => infer R\n  ? UnwrapFutureRef<R>\n  : never;\n"],"mappings":"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"}