@platforma-sdk/model 1.61.0 → 1.61.1

package/dist/plugin_model.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"plugin_model.cjs","names":["DATA_MODEL_LEGACY_VERSION","DataModelBuilder"],"sources":["../src/plugin_model.ts"],"sourcesContent":["/**\n * PluginModel - Builder for creating plugin types with data model and outputs.\n *\n * Plugins are UI components with their own model logic and persistent state.\n * Block developers register plugin instances via BlockModelV3.plugin() method.\n *\n * @module plugin_model\n */\n\nimport type { BlockCodeKnownFeatureFlags } from \"@milaboratories/pl-model-common\";\nimport {\n  type DataModel,\n  DataModelBuilder,\n  type DataRecoverFn,\n  type DataVersioned,\n  type TransferTarget,\n} from \"./block_migrations\";\nimport { type PluginName, DATA_MODEL_LEGACY_VERSION } from \"./block_storage\";\nimport type { PluginFactoryLike } from \"./plugin_handle\";\nimport type { PluginRenderCtx } from \"./render\";\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol(\"fromBuilder\");\n\n/** Symbol for internal plugin model creation — not accessible to external consumers */\nexport const CREATE_PLUGIN_MODEL = Symbol(\"createPluginModel\");\n\n/** Sentinel for PluginInstance without transferAt — no transfer possible. */\nconst NO_TRANSFER_VERSION = \"\";\n\nexport type PluginData = Record<string, unknown>;\nexport type PluginParams = undefined | Record<string, unknown>;\nexport type PluginOutputs = Record<string, unknown>;\nexport type PluginConfig = undefined | Record<string, unknown>;\n\n/**\n * Plugin data model with typed migration chain and config-aware initialization.\n *\n * @typeParam Data - Current (latest) plugin data type\n * @typeParam Versions - Map of version keys to their data types (accumulated by the chain)\n * @typeParam Config - Config type passed to init function (undefined if none)\n */\nexport class PluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown> = {},\n  Config = undefined,\n> {\n  readonly dataModel: DataModel<Data>;\n  private readonly configInitFn: (config?: Config) => Data;\n\n  /** @internal Phantom field to anchor the Versions type parameter. */\n  declare readonly __versions?: Versions;\n\n  private constructor(dataModel: DataModel<Data>, configInitFn: (config?: Config) => Data) {\n    this.dataModel = dataModel;\n    this.configInitFn = configInitFn;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>, Config>(\n    dataModel: DataModel<Data>,\n    configInitFn: (config?: Config) => Data,\n  ): PluginDataModel<Data, Versions, Config> {\n    return new PluginDataModel<Data, Versions, Config>(dataModel, configInitFn);\n  }\n\n  /** Create fresh data with optional config. */\n  getDefaultData(config?: Config): DataVersioned<Data> {\n    const data = this.configInitFn(config);\n    return { version: this.dataModel.version, data };\n  }\n}\n\n/** Internal state for plugin data model chain. */\ntype PluginChainState = {\n  initialVersion: string;\n  migrations: Array<{ toVersion: string; fn: (data: unknown) => unknown }>;\n  recoverFn?: (version: string, data: unknown) => unknown;\n  recoverAtIndex?: number;\n};\n\n/**\n * Builder for creating PluginDataModel with type-safe migrations.\n * Mirrors DataModelBuilder — same .from(), .migrate(), .recover(), .init() chain.\n *\n * @example\n * const pluginData = new PluginDataModelBuilder()\n *   .from<TableData>(\"v1\")\n *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n *   .init<TableConfig>((config?) => ({\n *     state: createDefaultState(config?.ops),\n *     filters: [],\n *   }));\n */\nexport class PluginDataModelBuilder {\n  from<Data extends PluginData, const V extends string>(\n    version: V,\n  ): PluginDataModelInitialChain<Data, Record<V, Data>> {\n    return PluginDataModelInitialChain[FROM_BUILDER]<Data, Record<V, Data>>({\n      initialVersion: version,\n      migrations: [],\n    });\n  }\n}\n\n/**\n * Chain returned by .migrate(). Supports .migrate(), .recover(), .init().\n * No .upgradeLegacy() — that is only available on the initial chain.\n */\nexport class PluginDataModelChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  protected constructor(protected readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelChain<Data, Versions> {\n    return new PluginDataModelChain(state);\n  }\n\n  /**\n   * Add a migration step transforming data from the current version to the next.\n   */\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelChain<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelChain[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   * Can only be called once — the returned chain has no recover() method.\n   */\n  recover(fn: DataRecoverFn<Data>): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      recoverFn: fn as (version: string, data: unknown) => unknown,\n      recoverAtIndex: this.state.migrations.length,\n    });\n  }\n\n  /** Finalize the PluginDataModel. */\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Initial chain returned by new PluginDataModelBuilder().from().\n * Extends PluginDataModelChain with .upgradeLegacy() — available only before\n * any .migrate() calls, matching the block's DataModelInitialChain pattern.\n */\nexport class PluginDataModelInitialChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> extends PluginDataModelChain<Data, Versions> {\n  /** @internal */\n  static override [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelInitialChain<Data, Versions> {\n    return new PluginDataModelInitialChain(state);\n  }\n\n  /**\n   * Handle data from a previous plugin type occupying this slot.\n   * Prepends a migration from DATA_MODEL_LEGACY_VERSION to the initial version.\n   * When a plugin type changes, the old data arrives with DATA_MODEL_LEGACY_VERSION —\n   * this function transforms it into the initial version, then the normal chain runs.\n   *\n   * Must be called right after .from() — not available after .migrate().\n   * Mutually exclusive with recover().\n   *\n   * @param fn - Transform from old plugin's raw data to this plugin's initial data type\n   */\n  upgradeLegacy(fn: (data: unknown) => Data): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      migrations: [\n        { toVersion: this.state.initialVersion, fn: fn as (data: unknown) => unknown },\n        ...this.state.migrations,\n      ],\n      initialVersion: DATA_MODEL_LEGACY_VERSION,\n    });\n  }\n}\n\n/**\n * Chain after .recover() — supports .migrate(), .init(). No second recover().\n */\nexport class PluginDataModelWithRecover<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  private constructor(private readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelWithRecover<Data, Versions> {\n    return new PluginDataModelWithRecover(state);\n  }\n\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelWithRecover<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Builds a PluginDataModel by replaying the stored chain state through DataModelBuilder.\n * @internal\n */\nfunction buildPluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n  Config,\n>(\n  state: PluginChainState,\n  configInitFn: (config?: Config) => Data,\n): PluginDataModel<Data, Versions, Config> {\n  // Build inner DataModel by replaying migrations through DataModelBuilder chain.\n  // Uses `any` internally — type safety is maintained by the public chain types.\n  let chain: any = new DataModelBuilder().from(state.initialVersion);\n\n  for (let i = 0; i < state.migrations.length; i++) {\n    if (state.recoverFn !== undefined && state.recoverAtIndex === i) {\n      chain = chain.recover(state.recoverFn);\n    }\n    chain = chain.migrate(state.migrations[i].toVersion, state.migrations[i].fn);\n  }\n\n  // If recover was placed at or after the last migration\n  if (state.recoverFn !== undefined && state.recoverAtIndex === state.migrations.length) {\n    chain = chain.recover(state.recoverFn);\n  }\n\n  const dataModel: DataModel<Data> = chain.init(() => configInitFn());\n\n  return PluginDataModel[FROM_BUILDER]<Data, Versions, Config>(dataModel, configInitFn);\n}\n\n/**\n * A named plugin instance created by `factory.create({ pluginId, ... })`.\n * Passed to both `.transfer()` (on migration chain) and `.plugin()` (on BlockModelV3).\n * Implements TransferTarget so the migration chain can accept it.\n *\n * @typeParam Id - Plugin instance ID literal type\n * @typeParam Data - Plugin data type\n * @typeParam Params - Plugin params type\n * @typeParam Outputs - Plugin outputs type\n * @typeParam TransferData - Type of data entering the plugin via transfer (never if no transfer)\n */\nexport class PluginInstance<\n  Id extends string = string,\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  TransferData = never,\n> implements TransferTarget<Id, TransferData> {\n  readonly id: Id;\n  readonly transferVersion: string;\n  /** @internal */\n  readonly __transferBrand?: TransferData;\n  private readonly factory: PluginModelFactory<Data, Params, Outputs, any, any>;\n  private readonly config: any;\n\n  private constructor(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ) {\n    this.id = id;\n    this.factory = factory;\n    this.transferVersion = transferVersion;\n    this.config = config;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Id extends string,\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    TransferData,\n  >(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ): PluginInstance<Id, Data, Params, Outputs, TransferData> {\n    return new PluginInstance(id, factory, transferVersion, config);\n  }\n\n  /** @internal Create a PluginModel from this instance. Used by BlockModelV3.plugin(). */\n  [CREATE_PLUGIN_MODEL](): PluginModel<Data, Params, Outputs> {\n    return this.factory[CREATE_PLUGIN_MODEL](this.config);\n  }\n}\n\n/**\n * Configured plugin instance returned by PluginModelFactory[CREATE_PLUGIN_MODEL]().\n * Contains the plugin's name, data model, and output definitions.\n */\nexport class PluginModel<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n> {\n  /** Globally unique plugin name */\n  readonly name: PluginName;\n  /** Data model instance for this plugin */\n  readonly dataModel: DataModel<Data>;\n  /** Output definitions - functions that compute outputs from plugin context */\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  /** Feature flags declared by this plugin */\n  readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  /** Create fresh default data. Config (if any) is captured at creation time. */\n  readonly getDefaultData: () => DataVersioned<Data>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }) {\n    this.name = options.name;\n    this.dataModel = options.dataModel;\n    this.outputs = options.outputs;\n    this.featureFlags = options.featureFlags;\n    this.getDefaultData = options.getDefaultData;\n  }\n\n  /**\n   * Internal method for creating PluginModel from factory.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n  >(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }): PluginModel<Data, Params, Outputs> {\n    return new PluginModel<Data, Params, Outputs>(options);\n  }\n\n  /**\n   * Creates a new PluginModelBuilder with a PluginDataModel (supports transfer / config).\n   *\n   * @example\n   * const pluginData = new PluginDataModelBuilder().from<TableData>(\"v1\")\n   *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n   *   .init<TableConfig>((config?) => ({\n   *     state: createDefaultState(config?.ops),\n   *     filters: [],\n   *   }));\n   *\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: pluginData,\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Versions extends Record<string, unknown> = {},\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: PluginDataModel<Data, Versions, Config>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, Versions>;\n  /**\n   * Creates a new PluginModelBuilder with a data model factory function (backward compatible).\n   *\n   * @example\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: (cfg) => dataModelChain.init(() => ({ value: cfg.defaultValue })),\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: (config?: Config) => DataModel<Data>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, {}>;\n  static define(options: {\n    name: PluginName;\n    data: PluginDataModel<any, any, any> | ((config?: any) => DataModel<any>);\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder {\n    if (options.data instanceof PluginDataModel) {\n      const pdm = options.data;\n      return PluginModelBuilder[FROM_BUILDER]({\n        name: options.name,\n        dataFn: () => pdm.dataModel,\n        getDefaultDataFn: (config: any) => pdm.getDefaultData(config),\n        featureFlags: options.featureFlags,\n      });\n    }\n    return PluginModelBuilder[FROM_BUILDER]({\n      name: options.name,\n      dataFn: options.data,\n      featureFlags: options.featureFlags,\n    });\n  }\n}\n\n/** Plugin factory returned by PluginModelBuilder.build(). */\nexport interface PluginFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> extends PluginFactoryLike<Data, Params, Outputs> {\n  /** Create a named plugin instance, optionally with transfer at a specific version. */\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]>;\n\n  /**\n   * @internal Phantom field for structural type extraction.\n   * Enables InferFactoryData/InferFactoryOutputs to work via PluginFactoryLike.\n   */\n  readonly __types?: {\n    data: Data;\n    params: Params;\n    outputs: Outputs;\n    config: Config;\n    versions: Versions;\n  };\n}\n\nclass PluginModelFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> implements PluginFactory<Data, Params, Outputs, Config, Versions> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs = options.outputs;\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown>,\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelFactory<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelFactory(options);\n  }\n\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]> {\n    const transferVersion = options.transferAt ?? NO_TRANSFER_VERSION;\n    return PluginInstance[FROM_BUILDER]<Id, Data, Params, Outputs, Versions[V]>(\n      options.pluginId as Id,\n      this as any,\n      transferVersion,\n      options.config,\n    );\n  }\n\n  /** @internal Create a PluginModel from config. Config is captured in getDefaultData closure. */\n  [CREATE_PLUGIN_MODEL](config?: Config): PluginModel<Data, Params, Outputs> {\n    const dataModel = this.dataFn(config);\n    const getDefaultDataFn = this.getDefaultDataFn;\n    return PluginModel[FROM_BUILDER]<Data, Params, Outputs>({\n      name: this.name,\n      dataModel,\n      outputs: this.outputs,\n      featureFlags: this.featureFlags,\n      getDefaultData: getDefaultDataFn\n        ? () => getDefaultDataFn(config)\n        : () => dataModel.getDefaultData(),\n    });\n  }\n}\n\n/**\n * Builder for creating PluginType with type-safe output definitions.\n *\n * Use `PluginModel.define()` to create a builder instance.\n *\n * @typeParam Data - Plugin's persistent data type\n * @typeParam Params - Params derived from block's RenderCtx (optional)\n * @typeParam Config - Static configuration passed to plugin factory (optional)\n * @typeParam Outputs - Accumulated output types\n * @typeParam Versions - Version map from PluginDataModel (empty for function-based data)\n *\n * @example\n * const dataTable = PluginModel.define({\n *     name: 'dataTable' as PluginName,\n *     data: pluginDataModel,\n *   })\n *   .output('model', (ctx) => createTableModel(ctx))\n *   .build();\n */\nclass PluginModelBuilder<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  private readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs =\n      options.outputs ??\n      ({} as {\n        [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n      });\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown> = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelBuilder(options);\n  }\n\n  /**\n   * Adds an output to the plugin.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new output added\n   *\n   * @example\n   * .output('model', (ctx) => createModel(ctx.params.columns, ctx.data.state))\n   * .output('isReady', (ctx) => ctx.params.columns !== undefined)\n   */\n  output<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions> {\n    return new PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: T })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: T })[K];\n      },\n    });\n  }\n\n  /**\n   * Finalizes the plugin definition and returns a PluginFactory.\n   *\n   * @returns Plugin factory that creates named plugin instances via .create()\n   *\n   * @example\n   * const myPlugin = PluginModel.define({ ... })\n   *   .output('value', (ctx) => ctx.data.value)\n   *   .build();\n   *\n   * // Create a named instance:\n   * const table = myPlugin.create({ pluginId: 'mainTable', config: { ... } });\n   */\n  build(): PluginFactory<Data, Params, Outputs, Config, Versions> {\n    return PluginModelFactory[FROM_BUILDER]<Data, Params, Outputs, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      outputs: this.outputs,\n      featureFlags: this.featureFlags,\n    });\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"plugin_model.cjs","names":["DATA_MODEL_LEGACY_VERSION","DataModelBuilder"],"sources":["../src/plugin_model.ts"],"sourcesContent":["/**\n * PluginModel - Builder for creating plugin types with data model and outputs.\n *\n * Plugins are UI components with their own model logic and persistent state.\n * Block developers register plugin instances via BlockModelV3.plugin() method.\n *\n * @module plugin_model\n */\n\nimport type { BlockCodeKnownFeatureFlags, OutputWithStatus } from \"@milaboratories/pl-model-common\";\nimport {\n  type DataModel,\n  DataModelBuilder,\n  type DataRecoverFn,\n  type DataVersioned,\n  type TransferTarget,\n} from \"./block_migrations\";\nimport { type PluginName, DATA_MODEL_LEGACY_VERSION } from \"./block_storage\";\nimport type { PluginFactoryLike } from \"./plugin_handle\";\nimport type { PluginRenderCtx } from \"./render\";\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol(\"fromBuilder\");\n\n/** Symbol for internal plugin model creation — not accessible to external consumers */\nexport const CREATE_PLUGIN_MODEL = Symbol(\"createPluginModel\");\n\n/** Sentinel for PluginInstance without transferAt — no transfer possible. */\nconst NO_TRANSFER_VERSION = \"\";\n\nexport type PluginData = Record<string, unknown>;\nexport type PluginParams = undefined | Record<string, unknown>;\nexport type PluginOutputs = Record<string, unknown>;\nexport type PluginConfig = undefined | Record<string, unknown>;\n\n/**\n * Plugin data model with typed migration chain and config-aware initialization.\n *\n * @typeParam Data - Current (latest) plugin data type\n * @typeParam Versions - Map of version keys to their data types (accumulated by the chain)\n * @typeParam Config - Config type passed to init function (undefined if none)\n */\nexport class PluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown> = {},\n  Config = undefined,\n> {\n  readonly dataModel: DataModel<Data>;\n  private readonly configInitFn: (config?: Config) => Data;\n\n  /** @internal Phantom field to anchor the Versions type parameter. */\n  declare readonly __versions?: Versions;\n\n  private constructor(dataModel: DataModel<Data>, configInitFn: (config?: Config) => Data) {\n    this.dataModel = dataModel;\n    this.configInitFn = configInitFn;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>, Config>(\n    dataModel: DataModel<Data>,\n    configInitFn: (config?: Config) => Data,\n  ): PluginDataModel<Data, Versions, Config> {\n    return new PluginDataModel<Data, Versions, Config>(dataModel, configInitFn);\n  }\n\n  /** Create fresh data with optional config. */\n  getDefaultData(config?: Config): DataVersioned<Data> {\n    const data = this.configInitFn(config);\n    return { version: this.dataModel.version, data };\n  }\n}\n\n/** Internal state for plugin data model chain. */\ntype PluginChainState = {\n  initialVersion: string;\n  migrations: Array<{ toVersion: string; fn: (data: unknown) => unknown }>;\n  recoverFn?: (version: string, data: unknown) => unknown;\n  recoverAtIndex?: number;\n};\n\n/** Version → persisted data shape for each migration step (third generic of `PluginModel.define` when `data` is a `PluginDataModel`). */\nexport type PluginDataModelVersions<\n  M extends PluginDataModel<PluginData, Record<string, unknown>, unknown>,\n> = M extends PluginDataModel<PluginData, infer Versions, unknown> ? Versions : never;\n\n/**\n * Builder for creating PluginDataModel with type-safe migrations.\n * Mirrors DataModelBuilder — same .from(), .migrate(), .recover(), .init() chain.\n *\n * @example\n * const pluginData = new PluginDataModelBuilder()\n *   .from<TableData>(\"v1\")\n *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n *   .init<TableConfig>((config?) => ({\n *     state: createDefaultState(config?.ops),\n *     filters: [],\n *   }));\n */\nexport class PluginDataModelBuilder {\n  from<Data extends PluginData, const V extends string>(\n    version: V,\n  ): PluginDataModelInitialChain<Data, Record<V, Data>> {\n    return PluginDataModelInitialChain[FROM_BUILDER]<Data, Record<V, Data>>({\n      initialVersion: version,\n      migrations: [],\n    });\n  }\n}\n\n/**\n * Chain returned by .migrate(). Supports .migrate(), .recover(), .init().\n * No .upgradeLegacy() — that is only available on the initial chain.\n */\nexport class PluginDataModelChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  protected constructor(protected readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelChain<Data, Versions> {\n    return new PluginDataModelChain(state);\n  }\n\n  /**\n   * Add a migration step transforming data from the current version to the next.\n   */\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelChain<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelChain[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   * Can only be called once — the returned chain has no recover() method.\n   */\n  recover(fn: DataRecoverFn<Data>): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      recoverFn: fn as (version: string, data: unknown) => unknown,\n      recoverAtIndex: this.state.migrations.length,\n    });\n  }\n\n  /** Finalize the PluginDataModel. */\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Initial chain returned by new PluginDataModelBuilder().from().\n * Extends PluginDataModelChain with .upgradeLegacy() — available only before\n * any .migrate() calls, matching the block's DataModelInitialChain pattern.\n */\nexport class PluginDataModelInitialChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> extends PluginDataModelChain<Data, Versions> {\n  /** @internal */\n  static override [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelInitialChain<Data, Versions> {\n    return new PluginDataModelInitialChain(state);\n  }\n\n  /**\n   * Handle data from a previous plugin type occupying this slot.\n   * Prepends a migration from DATA_MODEL_LEGACY_VERSION to the initial version.\n   * When a plugin type changes, the old data arrives with DATA_MODEL_LEGACY_VERSION —\n   * this function transforms it into the initial version, then the normal chain runs.\n   *\n   * Must be called right after .from() — not available after .migrate().\n   * Mutually exclusive with recover().\n   *\n   * @param fn - Transform from old plugin's raw data to this plugin's initial data type\n   */\n  upgradeLegacy(fn: (data: unknown) => Data): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      migrations: [\n        { toVersion: this.state.initialVersion, fn: fn as (data: unknown) => unknown },\n        ...this.state.migrations,\n      ],\n      initialVersion: DATA_MODEL_LEGACY_VERSION,\n    });\n  }\n}\n\n/**\n * Chain after .recover() — supports .migrate(), .init(). No second recover().\n */\nexport class PluginDataModelWithRecover<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  private constructor(private readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelWithRecover<Data, Versions> {\n    return new PluginDataModelWithRecover(state);\n  }\n\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelWithRecover<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Builds a PluginDataModel by replaying the stored chain state through DataModelBuilder.\n * @internal\n */\nfunction buildPluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n  Config,\n>(\n  state: PluginChainState,\n  configInitFn: (config?: Config) => Data,\n): PluginDataModel<Data, Versions, Config> {\n  // Build inner DataModel by replaying migrations through DataModelBuilder chain.\n  // Uses `any` internally — type safety is maintained by the public chain types.\n  let chain: any = new DataModelBuilder().from(state.initialVersion);\n\n  for (let i = 0; i < state.migrations.length; i++) {\n    if (state.recoverFn !== undefined && state.recoverAtIndex === i) {\n      chain = chain.recover(state.recoverFn);\n    }\n    chain = chain.migrate(state.migrations[i].toVersion, state.migrations[i].fn);\n  }\n\n  // If recover was placed at or after the last migration\n  if (state.recoverFn !== undefined && state.recoverAtIndex === state.migrations.length) {\n    chain = chain.recover(state.recoverFn);\n  }\n\n  const dataModel: DataModel<Data> = chain.init(() => configInitFn());\n\n  return PluginDataModel[FROM_BUILDER]<Data, Versions, Config>(dataModel, configInitFn);\n}\n\n/**\n * A named plugin instance created by `factory.create({ pluginId, ... })`.\n * Passed to both `.transfer()` (on migration chain) and `.plugin()` (on BlockModelV3).\n * Implements TransferTarget so the migration chain can accept it.\n *\n * @typeParam Id - Plugin instance ID literal type\n * @typeParam Data - Plugin data type\n * @typeParam Params - Plugin params type\n * @typeParam Outputs - Plugin outputs type\n * @typeParam TransferData - Type of data entering the plugin via transfer (never if no transfer)\n */\nexport class PluginInstance<\n  Id extends string = string,\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  TransferData = never,\n> implements TransferTarget<Id, TransferData> {\n  readonly id: Id;\n  readonly transferVersion: string;\n  /** @internal Phantom for type inference of Data/Params/Outputs; never set at runtime. */\n  readonly __instanceTypes?: { data: Data; params: Params; outputs: Outputs };\n  private readonly factory: PluginModelFactory<Data, Params, Outputs, any, any>;\n  private readonly config: any;\n\n  private constructor(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ) {\n    this.id = id;\n    this.factory = factory;\n    this.transferVersion = transferVersion;\n    this.config = config;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Id extends string,\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    TransferData,\n  >(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ): PluginInstance<Id, Data, Params, Outputs, TransferData> {\n    return new PluginInstance(id, factory, transferVersion, config);\n  }\n\n  /** @internal Create a PluginModel from this instance. Used by BlockModelV3.plugin(). */\n  [CREATE_PLUGIN_MODEL](): PluginModel<Data, Params, Outputs> {\n    return this.factory[CREATE_PLUGIN_MODEL](this.config);\n  }\n}\n\n/**\n * Configured plugin instance returned by PluginModelFactory[CREATE_PLUGIN_MODEL]().\n * Contains the plugin's name, data model, and output definitions.\n */\nexport class PluginModel<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n> {\n  /** Globally unique plugin name */\n  readonly name: PluginName;\n  /** Data model instance for this plugin */\n  readonly dataModel: DataModel<Data>;\n  /** Output definitions - functions that compute outputs from plugin context */\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  /** Per-output flags (e.g. withStatus) */\n  readonly outputFlags: Record<string, { withStatus: boolean }>;\n  /** Feature flags declared by this plugin */\n  readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  /** Create fresh default data. Config (if any) is captured at creation time. */\n  readonly getDefaultData: () => DataVersioned<Data>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }) {\n    this.name = options.name;\n    this.dataModel = options.dataModel;\n    this.outputs = options.outputs;\n    this.outputFlags = options.outputFlags;\n    this.featureFlags = options.featureFlags;\n    this.getDefaultData = options.getDefaultData;\n  }\n\n  /**\n   * Internal method for creating PluginModel from factory.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n  >(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }): PluginModel<Data, Params, Outputs> {\n    return new PluginModel<Data, Params, Outputs>(options);\n  }\n\n  /**\n   * Creates a new PluginModelBuilder with a PluginDataModel (supports transfer / config).\n   *\n   * @example\n   * const pluginData = new PluginDataModelBuilder().from<TableData>(\"v1\")\n   *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n   *   .init<TableConfig>((config?) => ({\n   *     state: createDefaultState(config?.ops),\n   *     filters: [],\n   *   }));\n   *\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: pluginData,\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Versions extends Record<string, unknown> = {},\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: PluginDataModel<Data, Versions, Config>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, Versions>;\n  /**\n   * Creates a new PluginModelBuilder with a data model factory function (backward compatible).\n   *\n   * @example\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: (cfg) => dataModelChain.init(() => ({ value: cfg.defaultValue })),\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: (config?: Config) => DataModel<Data>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, {}>;\n  static define(options: {\n    name: PluginName;\n    data: PluginDataModel<any, any, any> | ((config?: any) => DataModel<any>);\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder {\n    if (options.data instanceof PluginDataModel) {\n      const pdm = options.data;\n      return PluginModelBuilder[FROM_BUILDER]({\n        name: options.name,\n        dataFn: () => pdm.dataModel,\n        getDefaultDataFn: (config: any) => pdm.getDefaultData(config),\n        featureFlags: options.featureFlags,\n      });\n    }\n    return PluginModelBuilder[FROM_BUILDER]({\n      name: options.name,\n      dataFn: options.data,\n      featureFlags: options.featureFlags,\n    });\n  }\n}\n\n/** Plugin factory returned by PluginModelBuilder.build(). */\nexport interface PluginFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> extends PluginFactoryLike<Data, Params, Outputs> {\n  /** Create a named plugin instance, optionally with transfer at a specific version. */\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]>;\n\n  /**\n   * @internal Phantom field for structural type extraction.\n   * Enables InferFactoryData/InferFactoryOutputs to work via PluginFactoryLike.\n   */\n  readonly __types?: {\n    data: Data;\n    params: Params;\n    outputs: Outputs;\n    config: Config;\n    versions: Versions;\n  };\n}\n\nclass PluginModelFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> implements PluginFactory<Data, Params, Outputs, Config, Versions> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly outputFlags: Record<string, { withStatus: boolean }>;\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs = options.outputs;\n    this.outputFlags = options.outputFlags;\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown>,\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelFactory<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelFactory(options);\n  }\n\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]> {\n    const transferVersion = options.transferAt ?? NO_TRANSFER_VERSION;\n    return PluginInstance[FROM_BUILDER]<Id, Data, Params, Outputs, Versions[V]>(\n      options.pluginId as Id,\n      this as any,\n      transferVersion,\n      options.config,\n    );\n  }\n\n  /** @internal Create a PluginModel from config. Config is captured in getDefaultData closure. */\n  [CREATE_PLUGIN_MODEL](config?: Config): PluginModel<Data, Params, Outputs> {\n    const dataModel = this.dataFn(config);\n    const getDefaultDataFn = this.getDefaultDataFn;\n    return PluginModel[FROM_BUILDER]<Data, Params, Outputs>({\n      name: this.name,\n      dataModel,\n      outputs: this.outputs,\n      outputFlags: this.outputFlags,\n      featureFlags: this.featureFlags,\n      getDefaultData: getDefaultDataFn\n        ? () => getDefaultDataFn(config)\n        : () => dataModel.getDefaultData(),\n    });\n  }\n}\n\n/**\n * Builder for creating PluginType with type-safe output definitions.\n *\n * Use `PluginModel.define()` to create a builder instance.\n *\n * @typeParam Data - Plugin's persistent data type\n * @typeParam Params - Params derived from block's RenderCtx (optional)\n * @typeParam Config - Static configuration passed to plugin factory (optional)\n * @typeParam Outputs - Accumulated output types\n * @typeParam Versions - Version map from PluginDataModel (empty for function-based data)\n *\n * @example\n * const dataTable = PluginModel.define({\n *     name: 'dataTable' as PluginName,\n *     data: pluginDataModel,\n *   })\n *   .output('model', (ctx) => createTableModel(ctx))\n *   .build();\n */\nclass PluginModelBuilder<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  private readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly outputFlags: Record<string, { withStatus: boolean }>;\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags?: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs =\n      options.outputs ??\n      ({} as {\n        [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n      });\n    this.outputFlags = options.outputFlags ?? {};\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown> = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags?: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelBuilder(options);\n  }\n\n  /**\n   * Adds an output to the plugin.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new output added\n   *\n   * @example\n   * .output('model', (ctx) => createModel(ctx.params.columns, ctx.data.state))\n   * .output('isReady', (ctx) => ctx.params.columns !== undefined)\n   */\n  output<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions> {\n    return new PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: T })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: T })[K];\n      },\n      outputFlags: { ...this.outputFlags, [key]: { withStatus: false } },\n    });\n  }\n\n  /**\n   * Adds an output wrapped with status information to the plugin.\n   *\n   * The UI receives the full {@link OutputWithStatus} object instead of an unwrapped value,\n   * allowing it to distinguish between pending, success, and error states.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new status-wrapped output added\n   *\n   * @example\n   * .outputWithStatus('table', (ctx) => {\n   *   const pCols = ctx.params.pFrame?.getPColumns();\n   *   if (pCols === undefined) return undefined;\n   *   return createPlDataTableV2(ctx, pCols, ctx.data.tableState);\n   * })\n   */\n  outputWithStatus<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<\n    Data,\n    Params,\n    Outputs & { [K in Key]: OutputWithStatus<T> },\n    Config,\n    Versions\n  > {\n    return new PluginModelBuilder<\n      Data,\n      Params,\n      Outputs & { [K in Key]: OutputWithStatus<T> },\n      Config,\n      Versions\n    >({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: OutputWithStatus<T> })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: OutputWithStatus<T> })[K];\n      },\n      outputFlags: { ...this.outputFlags, [key]: { withStatus: true } },\n    });\n  }\n\n  /**\n   * Finalizes the plugin definition and returns a PluginFactory.\n   *\n   * @returns Plugin factory that creates named plugin instances via .create()\n   *\n   * @example\n   * const myPlugin = PluginModel.define({ ... })\n   *   .output('value', (ctx) => ctx.data.value)\n   *   .build();\n   *\n   * // Create a named instance:\n   * const table = myPlugin.create({ pluginId: 'mainTable', config: { ... } });\n   */\n  build(): PluginFactory<Data, Params, Outputs, Config, Versions> {\n    return PluginModelFactory[FROM_BUILDER]<Data, Params, Outputs, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      outputs: this.outputs,\n      outputFlags: this.outputFlags,\n      featureFlags: this.featureFlags,\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/plugin_model.d.ts

@@ -3,7 +3,7 @@ import { DataModel, DataRecoverFn, DataVersioned, TransferTarget } from "./block
 import { PluginName } from "./block_storage.js";
 import { PluginRenderCtx } from "./render/api.js";
 import "./render/index.js";
-import { BlockCodeKnownFeatureFlags } from "@milaboratories/pl-model-common";
+import { BlockCodeKnownFeatureFlags, OutputWithStatus } from "@milaboratories/pl-model-common";
 
 //#region src/plugin_model.d.ts
 /** Symbol for internal builder creation method */
@@ -42,6 +42,8 @@ type PluginChainState = {
   recoverFn?: (version: string, data: unknown) => unknown;
   recoverAtIndex?: number;
 };
+/** Version → persisted data shape for each migration step (third generic of `PluginModel.define` when `data` is a `PluginDataModel`). */
+type PluginDataModelVersions<M extends PluginDataModel<PluginData, Record<string, unknown>, unknown>> = M extends PluginDataModel<PluginData, infer Versions, unknown> ? Versions : never;
 /**
  * Builder for creating PluginDataModel with type-safe migrations.
  * Mirrors DataModelBuilder — same .from(), .migrate(), .recover(), .init() chain.
@@ -125,8 +127,12 @@ declare class PluginDataModelWithRecover<Data extends PluginData, Versions exten
 declare class PluginInstance<Id extends string = string, Data extends PluginData = PluginData, Params extends PluginParams = undefined, Outputs extends PluginOutputs = PluginOutputs, TransferData = never> implements TransferTarget<Id, TransferData> {
   readonly id: Id;
   readonly transferVersion: string;
-  /** @internal */
-  readonly __transferBrand?: TransferData;
+  /** @internal Phantom for type inference of Data/Params/Outputs; never set at runtime. */
+  readonly __instanceTypes?: {
+    data: Data;
+    params: Params;
+    outputs: Outputs;
+  };
   private readonly factory;
   private readonly config;
   private constructor();
@@ -146,6 +152,10 @@ declare class PluginModel<Data extends PluginData = PluginData, Params extends P
   readonly dataModel: DataModel<Data>;
   /** Output definitions - functions that compute outputs from plugin context */
   readonly outputs: { [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K] };
+  /** Per-output flags (e.g. withStatus) */
+  readonly outputFlags: Record<string, {
+    withStatus: boolean;
+  }>;
   /** Feature flags declared by this plugin */
   readonly featureFlags?: BlockCodeKnownFeatureFlags;
   /** Create fresh default data. Config (if any) is captured at creation time. */
@@ -160,6 +170,9 @@ declare class PluginModel<Data extends PluginData = PluginData, Params extends P
     name: PluginName;
     dataModel: DataModel<Data>;
     outputs: { [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K] };
+    outputFlags: Record<string, {
+      withStatus: boolean;
+    }>;
     featureFlags?: BlockCodeKnownFeatureFlags;
     getDefaultData: () => DataVersioned<Data>;
   }): PluginModel<Data, Params, Outputs>;
@@ -224,6 +237,7 @@ declare class PluginModelFactory<Data extends PluginData = PluginData, Params ex
   private readonly dataFn;
   private readonly getDefaultDataFn?;
   readonly outputs: { [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K] };
+  private readonly outputFlags;
   private readonly featureFlags?;
   private constructor();
   /** @internal */
@@ -232,6 +246,9 @@ declare class PluginModelFactory<Data extends PluginData = PluginData, Params ex
     dataFn: (config?: Config) => DataModel<Data>;
     getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;
     outputs: { [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K] };
+    outputFlags: Record<string, {
+      withStatus: boolean;
+    }>;
     featureFlags?: BlockCodeKnownFeatureFlags;
   }): PluginModelFactory<Data, Params, Outputs, Config, Versions>;
   create<const Id extends string, const V extends string & keyof Versions = never>(options: {
@@ -266,6 +283,7 @@ declare class PluginModelBuilder<Data extends PluginData = PluginData, Params ex
   private readonly dataFn;
   private readonly getDefaultDataFn?;
   private readonly outputs;
+  private readonly outputFlags;
   private readonly featureFlags?;
   private constructor();
   /** @internal */
@@ -274,6 +292,9 @@ declare class PluginModelBuilder<Data extends PluginData = PluginData, Params ex
     dataFn: (config?: Config) => DataModel<Data>;
     getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;
     outputs?: { [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K] };
+    outputFlags?: Record<string, {
+      withStatus: boolean;
+    }>;
     featureFlags?: BlockCodeKnownFeatureFlags;
   }): PluginModelBuilder<Data, Params, Outputs, Config, Versions>;
   /**
@@ -288,6 +309,24 @@ declare class PluginModelBuilder<Data extends PluginData = PluginData, Params ex
    * .output('isReady', (ctx) => ctx.params.columns !== undefined)
    */
   output<const Key extends string, T>(key: Key, fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions>;
+  /**
+   * Adds an output wrapped with status information to the plugin.
+   *
+   * The UI receives the full {@link OutputWithStatus} object instead of an unwrapped value,
+   * allowing it to distinguish between pending, success, and error states.
+   *
+   * @param key - Output name
+   * @param fn - Function that computes the output value from plugin context
+   * @returns PluginModel with the new status-wrapped output added
+   *
+   * @example
+   * .outputWithStatus('table', (ctx) => {
+   *   const pCols = ctx.params.pFrame?.getPColumns();
+   *   if (pCols === undefined) return undefined;
+   *   return createPlDataTableV2(ctx, pCols, ctx.data.tableState);
+   * })
+   */
+  outputWithStatus<const Key extends string, T>(key: Key, fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: OutputWithStatus<T> }, Config, Versions>;
   /**
    * Finalizes the plugin definition and returns a PluginFactory.
    *
@@ -304,5 +343,5 @@ declare class PluginModelBuilder<Data extends PluginData = PluginData, Params ex
   build(): PluginFactory<Data, Params, Outputs, Config, Versions>;
 }
 //#endregion
-export { PluginConfig, PluginData, PluginDataModel, PluginDataModelBuilder, PluginFactory, PluginInstance, PluginModel, PluginOutputs, PluginParams };
+export { PluginConfig, PluginData, PluginDataModel, PluginDataModelBuilder, PluginDataModelVersions, PluginFactory, PluginInstance, PluginModel, PluginOutputs, PluginParams };
 //# sourceMappingURL=plugin_model.d.ts.map

package/dist/plugin_model.js

@@ -180,8 +180,8 @@ function buildPluginDataModel(state, configInitFn) {
 var PluginInstance = class PluginInstance {
 	id;
 	transferVersion;
-	/** @internal */
-	__transferBrand;
+	/** @internal Phantom for type inference of Data/Params/Outputs; never set at runtime. */
+	__instanceTypes;
 	factory;
 	config;
 	constructor(id, factory, transferVersion, config) {
@@ -210,6 +210,8 @@ var PluginModel = class PluginModel {
 	dataModel;
 	/** Output definitions - functions that compute outputs from plugin context */
 	outputs;
+	/** Per-output flags (e.g. withStatus) */
+	outputFlags;
 	/** Feature flags declared by this plugin */
 	featureFlags;
 	/** Create fresh default data. Config (if any) is captured at creation time. */
@@ -218,6 +220,7 @@ var PluginModel = class PluginModel {
 		this.name = options.name;
 		this.dataModel = options.dataModel;
 		this.outputs = options.outputs;
+		this.outputFlags = options.outputFlags;
 		this.featureFlags = options.featureFlags;
 		this.getDefaultData = options.getDefaultData;
 	}
@@ -251,12 +254,14 @@ var PluginModelFactory = class PluginModelFactory {
 	dataFn;
 	getDefaultDataFn;
 	outputs;
+	outputFlags;
 	featureFlags;
 	constructor(options) {
 		this.name = options.name;
 		this.dataFn = options.dataFn;
 		this.getDefaultDataFn = options.getDefaultDataFn;
 		this.outputs = options.outputs;
+		this.outputFlags = options.outputFlags;
 		this.featureFlags = options.featureFlags;
 	}
 	/** @internal */
@@ -275,6 +280,7 @@ var PluginModelFactory = class PluginModelFactory {
 			name: this.name,
 			dataModel,
 			outputs: this.outputs,
+			outputFlags: this.outputFlags,
 			featureFlags: this.featureFlags,
 			getDefaultData: getDefaultDataFn ? () => getDefaultDataFn(config) : () => dataModel.getDefaultData()
 		});
@@ -304,12 +310,14 @@ var PluginModelBuilder = class PluginModelBuilder {
 	dataFn;
 	getDefaultDataFn;
 	outputs;
+	outputFlags;
 	featureFlags;
 	constructor(options) {
 		this.name = options.name;
 		this.dataFn = options.dataFn;
 		this.getDefaultDataFn = options.getDefaultDataFn;
 		this.outputs = options.outputs ?? {};
+		this.outputFlags = options.outputFlags ?? {};
 		this.featureFlags = options.featureFlags;
 	}
 	/** @internal */
@@ -336,6 +344,43 @@ var PluginModelBuilder = class PluginModelBuilder {
 			outputs: {
 				...this.outputs,
 				[key]: fn
+			},
+			outputFlags: {
+				...this.outputFlags,
+				[key]: { withStatus: false }
+			}
+		});
+	}
+	/**
+	* Adds an output wrapped with status information to the plugin.
+	*
+	* The UI receives the full {@link OutputWithStatus} object instead of an unwrapped value,
+	* allowing it to distinguish between pending, success, and error states.
+	*
+	* @param key - Output name
+	* @param fn - Function that computes the output value from plugin context
+	* @returns PluginModel with the new status-wrapped output added
+	*
+	* @example
+	* .outputWithStatus('table', (ctx) => {
+	*   const pCols = ctx.params.pFrame?.getPColumns();
+	*   if (pCols === undefined) return undefined;
+	*   return createPlDataTableV2(ctx, pCols, ctx.data.tableState);
+	* })
+	*/
+	outputWithStatus(key, fn) {
+		return new PluginModelBuilder({
+			name: this.name,
+			dataFn: this.dataFn,
+			getDefaultDataFn: this.getDefaultDataFn,
+			featureFlags: this.featureFlags,
+			outputs: {
+				...this.outputs,
+				[key]: fn
+			},
+			outputFlags: {
+				...this.outputFlags,
+				[key]: { withStatus: true }
 			}
 		});
 	}
@@ -358,6 +403,7 @@ var PluginModelBuilder = class PluginModelBuilder {
 			dataFn: this.dataFn,
 			getDefaultDataFn: this.getDefaultDataFn,
 			outputs: this.outputs,
+			outputFlags: this.outputFlags,
 			featureFlags: this.featureFlags
 		});
 	}

package/dist/plugin_model.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin_model.js","names":[],"sources":["../src/plugin_model.ts"],"sourcesContent":["/**\n * PluginModel - Builder for creating plugin types with data model and outputs.\n *\n * Plugins are UI components with their own model logic and persistent state.\n * Block developers register plugin instances via BlockModelV3.plugin() method.\n *\n * @module plugin_model\n */\n\nimport type { BlockCodeKnownFeatureFlags } from \"@milaboratories/pl-model-common\";\nimport {\n  type DataModel,\n  DataModelBuilder,\n  type DataRecoverFn,\n  type DataVersioned,\n  type TransferTarget,\n} from \"./block_migrations\";\nimport { type PluginName, DATA_MODEL_LEGACY_VERSION } from \"./block_storage\";\nimport type { PluginFactoryLike } from \"./plugin_handle\";\nimport type { PluginRenderCtx } from \"./render\";\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol(\"fromBuilder\");\n\n/** Symbol for internal plugin model creation — not accessible to external consumers */\nexport const CREATE_PLUGIN_MODEL = Symbol(\"createPluginModel\");\n\n/** Sentinel for PluginInstance without transferAt — no transfer possible. */\nconst NO_TRANSFER_VERSION = \"\";\n\nexport type PluginData = Record<string, unknown>;\nexport type PluginParams = undefined | Record<string, unknown>;\nexport type PluginOutputs = Record<string, unknown>;\nexport type PluginConfig = undefined | Record<string, unknown>;\n\n/**\n * Plugin data model with typed migration chain and config-aware initialization.\n *\n * @typeParam Data - Current (latest) plugin data type\n * @typeParam Versions - Map of version keys to their data types (accumulated by the chain)\n * @typeParam Config - Config type passed to init function (undefined if none)\n */\nexport class PluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown> = {},\n  Config = undefined,\n> {\n  readonly dataModel: DataModel<Data>;\n  private readonly configInitFn: (config?: Config) => Data;\n\n  /** @internal Phantom field to anchor the Versions type parameter. */\n  declare readonly __versions?: Versions;\n\n  private constructor(dataModel: DataModel<Data>, configInitFn: (config?: Config) => Data) {\n    this.dataModel = dataModel;\n    this.configInitFn = configInitFn;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>, Config>(\n    dataModel: DataModel<Data>,\n    configInitFn: (config?: Config) => Data,\n  ): PluginDataModel<Data, Versions, Config> {\n    return new PluginDataModel<Data, Versions, Config>(dataModel, configInitFn);\n  }\n\n  /** Create fresh data with optional config. */\n  getDefaultData(config?: Config): DataVersioned<Data> {\n    const data = this.configInitFn(config);\n    return { version: this.dataModel.version, data };\n  }\n}\n\n/** Internal state for plugin data model chain. */\ntype PluginChainState = {\n  initialVersion: string;\n  migrations: Array<{ toVersion: string; fn: (data: unknown) => unknown }>;\n  recoverFn?: (version: string, data: unknown) => unknown;\n  recoverAtIndex?: number;\n};\n\n/**\n * Builder for creating PluginDataModel with type-safe migrations.\n * Mirrors DataModelBuilder — same .from(), .migrate(), .recover(), .init() chain.\n *\n * @example\n * const pluginData = new PluginDataModelBuilder()\n *   .from<TableData>(\"v1\")\n *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n *   .init<TableConfig>((config?) => ({\n *     state: createDefaultState(config?.ops),\n *     filters: [],\n *   }));\n */\nexport class PluginDataModelBuilder {\n  from<Data extends PluginData, const V extends string>(\n    version: V,\n  ): PluginDataModelInitialChain<Data, Record<V, Data>> {\n    return PluginDataModelInitialChain[FROM_BUILDER]<Data, Record<V, Data>>({\n      initialVersion: version,\n      migrations: [],\n    });\n  }\n}\n\n/**\n * Chain returned by .migrate(). Supports .migrate(), .recover(), .init().\n * No .upgradeLegacy() — that is only available on the initial chain.\n */\nexport class PluginDataModelChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  protected constructor(protected readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelChain<Data, Versions> {\n    return new PluginDataModelChain(state);\n  }\n\n  /**\n   * Add a migration step transforming data from the current version to the next.\n   */\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelChain<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelChain[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   * Can only be called once — the returned chain has no recover() method.\n   */\n  recover(fn: DataRecoverFn<Data>): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      recoverFn: fn as (version: string, data: unknown) => unknown,\n      recoverAtIndex: this.state.migrations.length,\n    });\n  }\n\n  /** Finalize the PluginDataModel. */\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Initial chain returned by new PluginDataModelBuilder().from().\n * Extends PluginDataModelChain with .upgradeLegacy() — available only before\n * any .migrate() calls, matching the block's DataModelInitialChain pattern.\n */\nexport class PluginDataModelInitialChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> extends PluginDataModelChain<Data, Versions> {\n  /** @internal */\n  static override [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelInitialChain<Data, Versions> {\n    return new PluginDataModelInitialChain(state);\n  }\n\n  /**\n   * Handle data from a previous plugin type occupying this slot.\n   * Prepends a migration from DATA_MODEL_LEGACY_VERSION to the initial version.\n   * When a plugin type changes, the old data arrives with DATA_MODEL_LEGACY_VERSION —\n   * this function transforms it into the initial version, then the normal chain runs.\n   *\n   * Must be called right after .from() — not available after .migrate().\n   * Mutually exclusive with recover().\n   *\n   * @param fn - Transform from old plugin's raw data to this plugin's initial data type\n   */\n  upgradeLegacy(fn: (data: unknown) => Data): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      migrations: [\n        { toVersion: this.state.initialVersion, fn: fn as (data: unknown) => unknown },\n        ...this.state.migrations,\n      ],\n      initialVersion: DATA_MODEL_LEGACY_VERSION,\n    });\n  }\n}\n\n/**\n * Chain after .recover() — supports .migrate(), .init(). No second recover().\n */\nexport class PluginDataModelWithRecover<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  private constructor(private readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelWithRecover<Data, Versions> {\n    return new PluginDataModelWithRecover(state);\n  }\n\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelWithRecover<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Builds a PluginDataModel by replaying the stored chain state through DataModelBuilder.\n * @internal\n */\nfunction buildPluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n  Config,\n>(\n  state: PluginChainState,\n  configInitFn: (config?: Config) => Data,\n): PluginDataModel<Data, Versions, Config> {\n  // Build inner DataModel by replaying migrations through DataModelBuilder chain.\n  // Uses `any` internally — type safety is maintained by the public chain types.\n  let chain: any = new DataModelBuilder().from(state.initialVersion);\n\n  for (let i = 0; i < state.migrations.length; i++) {\n    if (state.recoverFn !== undefined && state.recoverAtIndex === i) {\n      chain = chain.recover(state.recoverFn);\n    }\n    chain = chain.migrate(state.migrations[i].toVersion, state.migrations[i].fn);\n  }\n\n  // If recover was placed at or after the last migration\n  if (state.recoverFn !== undefined && state.recoverAtIndex === state.migrations.length) {\n    chain = chain.recover(state.recoverFn);\n  }\n\n  const dataModel: DataModel<Data> = chain.init(() => configInitFn());\n\n  return PluginDataModel[FROM_BUILDER]<Data, Versions, Config>(dataModel, configInitFn);\n}\n\n/**\n * A named plugin instance created by `factory.create({ pluginId, ... })`.\n * Passed to both `.transfer()` (on migration chain) and `.plugin()` (on BlockModelV3).\n * Implements TransferTarget so the migration chain can accept it.\n *\n * @typeParam Id - Plugin instance ID literal type\n * @typeParam Data - Plugin data type\n * @typeParam Params - Plugin params type\n * @typeParam Outputs - Plugin outputs type\n * @typeParam TransferData - Type of data entering the plugin via transfer (never if no transfer)\n */\nexport class PluginInstance<\n  Id extends string = string,\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  TransferData = never,\n> implements TransferTarget<Id, TransferData> {\n  readonly id: Id;\n  readonly transferVersion: string;\n  /** @internal */\n  readonly __transferBrand?: TransferData;\n  private readonly factory: PluginModelFactory<Data, Params, Outputs, any, any>;\n  private readonly config: any;\n\n  private constructor(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ) {\n    this.id = id;\n    this.factory = factory;\n    this.transferVersion = transferVersion;\n    this.config = config;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Id extends string,\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    TransferData,\n  >(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ): PluginInstance<Id, Data, Params, Outputs, TransferData> {\n    return new PluginInstance(id, factory, transferVersion, config);\n  }\n\n  /** @internal Create a PluginModel from this instance. Used by BlockModelV3.plugin(). */\n  [CREATE_PLUGIN_MODEL](): PluginModel<Data, Params, Outputs> {\n    return this.factory[CREATE_PLUGIN_MODEL](this.config);\n  }\n}\n\n/**\n * Configured plugin instance returned by PluginModelFactory[CREATE_PLUGIN_MODEL]().\n * Contains the plugin's name, data model, and output definitions.\n */\nexport class PluginModel<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n> {\n  /** Globally unique plugin name */\n  readonly name: PluginName;\n  /** Data model instance for this plugin */\n  readonly dataModel: DataModel<Data>;\n  /** Output definitions - functions that compute outputs from plugin context */\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  /** Feature flags declared by this plugin */\n  readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  /** Create fresh default data. Config (if any) is captured at creation time. */\n  readonly getDefaultData: () => DataVersioned<Data>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }) {\n    this.name = options.name;\n    this.dataModel = options.dataModel;\n    this.outputs = options.outputs;\n    this.featureFlags = options.featureFlags;\n    this.getDefaultData = options.getDefaultData;\n  }\n\n  /**\n   * Internal method for creating PluginModel from factory.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n  >(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }): PluginModel<Data, Params, Outputs> {\n    return new PluginModel<Data, Params, Outputs>(options);\n  }\n\n  /**\n   * Creates a new PluginModelBuilder with a PluginDataModel (supports transfer / config).\n   *\n   * @example\n   * const pluginData = new PluginDataModelBuilder().from<TableData>(\"v1\")\n   *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n   *   .init<TableConfig>((config?) => ({\n   *     state: createDefaultState(config?.ops),\n   *     filters: [],\n   *   }));\n   *\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: pluginData,\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Versions extends Record<string, unknown> = {},\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: PluginDataModel<Data, Versions, Config>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, Versions>;\n  /**\n   * Creates a new PluginModelBuilder with a data model factory function (backward compatible).\n   *\n   * @example\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: (cfg) => dataModelChain.init(() => ({ value: cfg.defaultValue })),\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: (config?: Config) => DataModel<Data>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, {}>;\n  static define(options: {\n    name: PluginName;\n    data: PluginDataModel<any, any, any> | ((config?: any) => DataModel<any>);\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder {\n    if (options.data instanceof PluginDataModel) {\n      const pdm = options.data;\n      return PluginModelBuilder[FROM_BUILDER]({\n        name: options.name,\n        dataFn: () => pdm.dataModel,\n        getDefaultDataFn: (config: any) => pdm.getDefaultData(config),\n        featureFlags: options.featureFlags,\n      });\n    }\n    return PluginModelBuilder[FROM_BUILDER]({\n      name: options.name,\n      dataFn: options.data,\n      featureFlags: options.featureFlags,\n    });\n  }\n}\n\n/** Plugin factory returned by PluginModelBuilder.build(). */\nexport interface PluginFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> extends PluginFactoryLike<Data, Params, Outputs> {\n  /** Create a named plugin instance, optionally with transfer at a specific version. */\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]>;\n\n  /**\n   * @internal Phantom field for structural type extraction.\n   * Enables InferFactoryData/InferFactoryOutputs to work via PluginFactoryLike.\n   */\n  readonly __types?: {\n    data: Data;\n    params: Params;\n    outputs: Outputs;\n    config: Config;\n    versions: Versions;\n  };\n}\n\nclass PluginModelFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> implements PluginFactory<Data, Params, Outputs, Config, Versions> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs = options.outputs;\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown>,\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelFactory<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelFactory(options);\n  }\n\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]> {\n    const transferVersion = options.transferAt ?? NO_TRANSFER_VERSION;\n    return PluginInstance[FROM_BUILDER]<Id, Data, Params, Outputs, Versions[V]>(\n      options.pluginId as Id,\n      this as any,\n      transferVersion,\n      options.config,\n    );\n  }\n\n  /** @internal Create a PluginModel from config. Config is captured in getDefaultData closure. */\n  [CREATE_PLUGIN_MODEL](config?: Config): PluginModel<Data, Params, Outputs> {\n    const dataModel = this.dataFn(config);\n    const getDefaultDataFn = this.getDefaultDataFn;\n    return PluginModel[FROM_BUILDER]<Data, Params, Outputs>({\n      name: this.name,\n      dataModel,\n      outputs: this.outputs,\n      featureFlags: this.featureFlags,\n      getDefaultData: getDefaultDataFn\n        ? () => getDefaultDataFn(config)\n        : () => dataModel.getDefaultData(),\n    });\n  }\n}\n\n/**\n * Builder for creating PluginType with type-safe output definitions.\n *\n * Use `PluginModel.define()` to create a builder instance.\n *\n * @typeParam Data - Plugin's persistent data type\n * @typeParam Params - Params derived from block's RenderCtx (optional)\n * @typeParam Config - Static configuration passed to plugin factory (optional)\n * @typeParam Outputs - Accumulated output types\n * @typeParam Versions - Version map from PluginDataModel (empty for function-based data)\n *\n * @example\n * const dataTable = PluginModel.define({\n *     name: 'dataTable' as PluginName,\n *     data: pluginDataModel,\n *   })\n *   .output('model', (ctx) => createTableModel(ctx))\n *   .build();\n */\nclass PluginModelBuilder<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  private readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs =\n      options.outputs ??\n      ({} as {\n        [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n      });\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown> = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelBuilder(options);\n  }\n\n  /**\n   * Adds an output to the plugin.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new output added\n   *\n   * @example\n   * .output('model', (ctx) => createModel(ctx.params.columns, ctx.data.state))\n   * .output('isReady', (ctx) => ctx.params.columns !== undefined)\n   */\n  output<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions> {\n    return new PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: T })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: T })[K];\n      },\n    });\n  }\n\n  /**\n   * Finalizes the plugin definition and returns a PluginFactory.\n   *\n   * @returns Plugin factory that creates named plugin instances via .create()\n   *\n   * @example\n   * const myPlugin = PluginModel.define({ ... })\n   *   .output('value', (ctx) => ctx.data.value)\n   *   .build();\n   *\n   * // Create a named instance:\n   * const table = myPlugin.create({ pluginId: 'mainTable', config: { ... } });\n   */\n  build(): PluginFactory<Data, Params, Outputs, Config, Versions> {\n    return PluginModelFactory[FROM_BUILDER]<Data, Params, Outputs, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      outputs: this.outputs,\n      featureFlags: this.featureFlags,\n    });\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"plugin_model.js","names":[],"sources":["../src/plugin_model.ts"],"sourcesContent":["/**\n * PluginModel - Builder for creating plugin types with data model and outputs.\n *\n * Plugins are UI components with their own model logic and persistent state.\n * Block developers register plugin instances via BlockModelV3.plugin() method.\n *\n * @module plugin_model\n */\n\nimport type { BlockCodeKnownFeatureFlags, OutputWithStatus } from \"@milaboratories/pl-model-common\";\nimport {\n  type DataModel,\n  DataModelBuilder,\n  type DataRecoverFn,\n  type DataVersioned,\n  type TransferTarget,\n} from \"./block_migrations\";\nimport { type PluginName, DATA_MODEL_LEGACY_VERSION } from \"./block_storage\";\nimport type { PluginFactoryLike } from \"./plugin_handle\";\nimport type { PluginRenderCtx } from \"./render\";\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol(\"fromBuilder\");\n\n/** Symbol for internal plugin model creation — not accessible to external consumers */\nexport const CREATE_PLUGIN_MODEL = Symbol(\"createPluginModel\");\n\n/** Sentinel for PluginInstance without transferAt — no transfer possible. */\nconst NO_TRANSFER_VERSION = \"\";\n\nexport type PluginData = Record<string, unknown>;\nexport type PluginParams = undefined | Record<string, unknown>;\nexport type PluginOutputs = Record<string, unknown>;\nexport type PluginConfig = undefined | Record<string, unknown>;\n\n/**\n * Plugin data model with typed migration chain and config-aware initialization.\n *\n * @typeParam Data - Current (latest) plugin data type\n * @typeParam Versions - Map of version keys to their data types (accumulated by the chain)\n * @typeParam Config - Config type passed to init function (undefined if none)\n */\nexport class PluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown> = {},\n  Config = undefined,\n> {\n  readonly dataModel: DataModel<Data>;\n  private readonly configInitFn: (config?: Config) => Data;\n\n  /** @internal Phantom field to anchor the Versions type parameter. */\n  declare readonly __versions?: Versions;\n\n  private constructor(dataModel: DataModel<Data>, configInitFn: (config?: Config) => Data) {\n    this.dataModel = dataModel;\n    this.configInitFn = configInitFn;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>, Config>(\n    dataModel: DataModel<Data>,\n    configInitFn: (config?: Config) => Data,\n  ): PluginDataModel<Data, Versions, Config> {\n    return new PluginDataModel<Data, Versions, Config>(dataModel, configInitFn);\n  }\n\n  /** Create fresh data with optional config. */\n  getDefaultData(config?: Config): DataVersioned<Data> {\n    const data = this.configInitFn(config);\n    return { version: this.dataModel.version, data };\n  }\n}\n\n/** Internal state for plugin data model chain. */\ntype PluginChainState = {\n  initialVersion: string;\n  migrations: Array<{ toVersion: string; fn: (data: unknown) => unknown }>;\n  recoverFn?: (version: string, data: unknown) => unknown;\n  recoverAtIndex?: number;\n};\n\n/** Version → persisted data shape for each migration step (third generic of `PluginModel.define` when `data` is a `PluginDataModel`). */\nexport type PluginDataModelVersions<\n  M extends PluginDataModel<PluginData, Record<string, unknown>, unknown>,\n> = M extends PluginDataModel<PluginData, infer Versions, unknown> ? Versions : never;\n\n/**\n * Builder for creating PluginDataModel with type-safe migrations.\n * Mirrors DataModelBuilder — same .from(), .migrate(), .recover(), .init() chain.\n *\n * @example\n * const pluginData = new PluginDataModelBuilder()\n *   .from<TableData>(\"v1\")\n *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n *   .init<TableConfig>((config?) => ({\n *     state: createDefaultState(config?.ops),\n *     filters: [],\n *   }));\n */\nexport class PluginDataModelBuilder {\n  from<Data extends PluginData, const V extends string>(\n    version: V,\n  ): PluginDataModelInitialChain<Data, Record<V, Data>> {\n    return PluginDataModelInitialChain[FROM_BUILDER]<Data, Record<V, Data>>({\n      initialVersion: version,\n      migrations: [],\n    });\n  }\n}\n\n/**\n * Chain returned by .migrate(). Supports .migrate(), .recover(), .init().\n * No .upgradeLegacy() — that is only available on the initial chain.\n */\nexport class PluginDataModelChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  protected constructor(protected readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelChain<Data, Versions> {\n    return new PluginDataModelChain(state);\n  }\n\n  /**\n   * Add a migration step transforming data from the current version to the next.\n   */\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelChain<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelChain[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   * Can only be called once — the returned chain has no recover() method.\n   */\n  recover(fn: DataRecoverFn<Data>): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      recoverFn: fn as (version: string, data: unknown) => unknown,\n      recoverAtIndex: this.state.migrations.length,\n    });\n  }\n\n  /** Finalize the PluginDataModel. */\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Initial chain returned by new PluginDataModelBuilder().from().\n * Extends PluginDataModelChain with .upgradeLegacy() — available only before\n * any .migrate() calls, matching the block's DataModelInitialChain pattern.\n */\nexport class PluginDataModelInitialChain<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> extends PluginDataModelChain<Data, Versions> {\n  /** @internal */\n  static override [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelInitialChain<Data, Versions> {\n    return new PluginDataModelInitialChain(state);\n  }\n\n  /**\n   * Handle data from a previous plugin type occupying this slot.\n   * Prepends a migration from DATA_MODEL_LEGACY_VERSION to the initial version.\n   * When a plugin type changes, the old data arrives with DATA_MODEL_LEGACY_VERSION —\n   * this function transforms it into the initial version, then the normal chain runs.\n   *\n   * Must be called right after .from() — not available after .migrate().\n   * Mutually exclusive with recover().\n   *\n   * @param fn - Transform from old plugin's raw data to this plugin's initial data type\n   */\n  upgradeLegacy(fn: (data: unknown) => Data): PluginDataModelWithRecover<Data, Versions> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Data, Versions>({\n      ...this.state,\n      migrations: [\n        { toVersion: this.state.initialVersion, fn: fn as (data: unknown) => unknown },\n        ...this.state.migrations,\n      ],\n      initialVersion: DATA_MODEL_LEGACY_VERSION,\n    });\n  }\n}\n\n/**\n * Chain after .recover() — supports .migrate(), .init(). No second recover().\n */\nexport class PluginDataModelWithRecover<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n> {\n  private constructor(private readonly state: PluginChainState) {}\n\n  /** @internal */\n  static [FROM_BUILDER]<Data extends PluginData, Versions extends Record<string, unknown>>(\n    state: PluginChainState,\n  ): PluginDataModelWithRecover<Data, Versions> {\n    return new PluginDataModelWithRecover(state);\n  }\n\n  migrate<Next extends PluginData, const NextV extends string>(\n    version: NextV,\n    fn: (current: Data) => Next,\n  ): PluginDataModelWithRecover<Next, Versions & Record<NextV, Next>> {\n    return PluginDataModelWithRecover[FROM_BUILDER]<Next, Versions & Record<NextV, Next>>({\n      ...this.state,\n      migrations: [\n        ...this.state.migrations,\n        { toVersion: version, fn: fn as (data: unknown) => unknown },\n      ],\n    });\n  }\n\n  init<Config = undefined>(fn: (config?: Config) => Data): PluginDataModel<Data, Versions, Config> {\n    return buildPluginDataModel(this.state, fn);\n  }\n}\n\n/**\n * Builds a PluginDataModel by replaying the stored chain state through DataModelBuilder.\n * @internal\n */\nfunction buildPluginDataModel<\n  Data extends PluginData,\n  Versions extends Record<string, unknown>,\n  Config,\n>(\n  state: PluginChainState,\n  configInitFn: (config?: Config) => Data,\n): PluginDataModel<Data, Versions, Config> {\n  // Build inner DataModel by replaying migrations through DataModelBuilder chain.\n  // Uses `any` internally — type safety is maintained by the public chain types.\n  let chain: any = new DataModelBuilder().from(state.initialVersion);\n\n  for (let i = 0; i < state.migrations.length; i++) {\n    if (state.recoverFn !== undefined && state.recoverAtIndex === i) {\n      chain = chain.recover(state.recoverFn);\n    }\n    chain = chain.migrate(state.migrations[i].toVersion, state.migrations[i].fn);\n  }\n\n  // If recover was placed at or after the last migration\n  if (state.recoverFn !== undefined && state.recoverAtIndex === state.migrations.length) {\n    chain = chain.recover(state.recoverFn);\n  }\n\n  const dataModel: DataModel<Data> = chain.init(() => configInitFn());\n\n  return PluginDataModel[FROM_BUILDER]<Data, Versions, Config>(dataModel, configInitFn);\n}\n\n/**\n * A named plugin instance created by `factory.create({ pluginId, ... })`.\n * Passed to both `.transfer()` (on migration chain) and `.plugin()` (on BlockModelV3).\n * Implements TransferTarget so the migration chain can accept it.\n *\n * @typeParam Id - Plugin instance ID literal type\n * @typeParam Data - Plugin data type\n * @typeParam Params - Plugin params type\n * @typeParam Outputs - Plugin outputs type\n * @typeParam TransferData - Type of data entering the plugin via transfer (never if no transfer)\n */\nexport class PluginInstance<\n  Id extends string = string,\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  TransferData = never,\n> implements TransferTarget<Id, TransferData> {\n  readonly id: Id;\n  readonly transferVersion: string;\n  /** @internal Phantom for type inference of Data/Params/Outputs; never set at runtime. */\n  readonly __instanceTypes?: { data: Data; params: Params; outputs: Outputs };\n  private readonly factory: PluginModelFactory<Data, Params, Outputs, any, any>;\n  private readonly config: any;\n\n  private constructor(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ) {\n    this.id = id;\n    this.factory = factory;\n    this.transferVersion = transferVersion;\n    this.config = config;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Id extends string,\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    TransferData,\n  >(\n    id: Id,\n    factory: PluginModelFactory<Data, Params, Outputs, any, any>,\n    transferVersion: string,\n    config?: any,\n  ): PluginInstance<Id, Data, Params, Outputs, TransferData> {\n    return new PluginInstance(id, factory, transferVersion, config);\n  }\n\n  /** @internal Create a PluginModel from this instance. Used by BlockModelV3.plugin(). */\n  [CREATE_PLUGIN_MODEL](): PluginModel<Data, Params, Outputs> {\n    return this.factory[CREATE_PLUGIN_MODEL](this.config);\n  }\n}\n\n/**\n * Configured plugin instance returned by PluginModelFactory[CREATE_PLUGIN_MODEL]().\n * Contains the plugin's name, data model, and output definitions.\n */\nexport class PluginModel<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n> {\n  /** Globally unique plugin name */\n  readonly name: PluginName;\n  /** Data model instance for this plugin */\n  readonly dataModel: DataModel<Data>;\n  /** Output definitions - functions that compute outputs from plugin context */\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  /** Per-output flags (e.g. withStatus) */\n  readonly outputFlags: Record<string, { withStatus: boolean }>;\n  /** Feature flags declared by this plugin */\n  readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  /** Create fresh default data. Config (if any) is captured at creation time. */\n  readonly getDefaultData: () => DataVersioned<Data>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }) {\n    this.name = options.name;\n    this.dataModel = options.dataModel;\n    this.outputs = options.outputs;\n    this.outputFlags = options.outputFlags;\n    this.featureFlags = options.featureFlags;\n    this.getDefaultData = options.getDefaultData;\n  }\n\n  /**\n   * Internal method for creating PluginModel from factory.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n  >(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n  }): PluginModel<Data, Params, Outputs> {\n    return new PluginModel<Data, Params, Outputs>(options);\n  }\n\n  /**\n   * Creates a new PluginModelBuilder with a PluginDataModel (supports transfer / config).\n   *\n   * @example\n   * const pluginData = new PluginDataModelBuilder().from<TableData>(\"v1\")\n   *   .migrate<FilteredTableData>(\"v2\", (v1) => ({ ...v1, filters: [] }))\n   *   .init<TableConfig>((config?) => ({\n   *     state: createDefaultState(config?.ops),\n   *     filters: [],\n   *   }));\n   *\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: pluginData,\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Versions extends Record<string, unknown> = {},\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: PluginDataModel<Data, Versions, Config>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, Versions>;\n  /**\n   * Creates a new PluginModelBuilder with a data model factory function (backward compatible).\n   *\n   * @example\n   * const myPlugin = PluginModel.define({\n   *   name: 'myPlugin' as PluginName,\n   *   data: (cfg) => dataModelChain.init(() => ({ value: cfg.defaultValue })),\n   * }).build();\n   */\n  static define<\n    Data extends PluginData,\n    Params extends PluginParams = undefined,\n    Config extends PluginConfig = undefined,\n  >(options: {\n    name: PluginName;\n    data: (config?: Config) => DataModel<Data>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, {}, Config, {}>;\n  static define(options: {\n    name: PluginName;\n    data: PluginDataModel<any, any, any> | ((config?: any) => DataModel<any>);\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder {\n    if (options.data instanceof PluginDataModel) {\n      const pdm = options.data;\n      return PluginModelBuilder[FROM_BUILDER]({\n        name: options.name,\n        dataFn: () => pdm.dataModel,\n        getDefaultDataFn: (config: any) => pdm.getDefaultData(config),\n        featureFlags: options.featureFlags,\n      });\n    }\n    return PluginModelBuilder[FROM_BUILDER]({\n      name: options.name,\n      dataFn: options.data,\n      featureFlags: options.featureFlags,\n    });\n  }\n}\n\n/** Plugin factory returned by PluginModelBuilder.build(). */\nexport interface PluginFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> extends PluginFactoryLike<Data, Params, Outputs> {\n  /** Create a named plugin instance, optionally with transfer at a specific version. */\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]>;\n\n  /**\n   * @internal Phantom field for structural type extraction.\n   * Enables InferFactoryData/InferFactoryOutputs to work via PluginFactoryLike.\n   */\n  readonly __types?: {\n    data: Data;\n    params: Params;\n    outputs: Outputs;\n    config: Config;\n    versions: Versions;\n  };\n}\n\nclass PluginModelFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> implements PluginFactory<Data, Params, Outputs, Config, Versions> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly outputFlags: Record<string, { withStatus: boolean }>;\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs = options.outputs;\n    this.outputFlags = options.outputFlags;\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown>,\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelFactory<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelFactory(options);\n  }\n\n  create<const Id extends string, const V extends string & keyof Versions = never>(options: {\n    pluginId: Id;\n    transferAt?: V;\n    config?: Config;\n  }): PluginInstance<Id, Data, Params, Outputs, Versions[V]> {\n    const transferVersion = options.transferAt ?? NO_TRANSFER_VERSION;\n    return PluginInstance[FROM_BUILDER]<Id, Data, Params, Outputs, Versions[V]>(\n      options.pluginId as Id,\n      this as any,\n      transferVersion,\n      options.config,\n    );\n  }\n\n  /** @internal Create a PluginModel from config. Config is captured in getDefaultData closure. */\n  [CREATE_PLUGIN_MODEL](config?: Config): PluginModel<Data, Params, Outputs> {\n    const dataModel = this.dataFn(config);\n    const getDefaultDataFn = this.getDefaultDataFn;\n    return PluginModel[FROM_BUILDER]<Data, Params, Outputs>({\n      name: this.name,\n      dataModel,\n      outputs: this.outputs,\n      outputFlags: this.outputFlags,\n      featureFlags: this.featureFlags,\n      getDefaultData: getDefaultDataFn\n        ? () => getDefaultDataFn(config)\n        : () => dataModel.getDefaultData(),\n    });\n  }\n}\n\n/**\n * Builder for creating PluginType with type-safe output definitions.\n *\n * Use `PluginModel.define()` to create a builder instance.\n *\n * @typeParam Data - Plugin's persistent data type\n * @typeParam Params - Params derived from block's RenderCtx (optional)\n * @typeParam Config - Static configuration passed to plugin factory (optional)\n * @typeParam Outputs - Accumulated output types\n * @typeParam Versions - Version map from PluginDataModel (empty for function-based data)\n *\n * @example\n * const dataTable = PluginModel.define({\n *     name: 'dataTable' as PluginName,\n *     data: pluginDataModel,\n *   })\n *   .output('model', (ctx) => createTableModel(ctx))\n *   .build();\n */\nclass PluginModelBuilder<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  private readonly outputs: {\n    [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n  };\n  private readonly outputFlags: Record<string, { withStatus: boolean }>;\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags?: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs =\n      options.outputs ??\n      ({} as {\n        [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n      });\n    this.outputFlags = options.outputFlags ?? {};\n    this.featureFlags = options.featureFlags;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown> = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: {\n      [K in keyof Outputs]: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => Outputs[K];\n    };\n    outputFlags?: Record<string, { withStatus: boolean }>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelBuilder<Data, Params, Outputs, Config, Versions> {\n    return new PluginModelBuilder(options);\n  }\n\n  /**\n   * Adds an output to the plugin.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new output added\n   *\n   * @example\n   * .output('model', (ctx) => createModel(ctx.params.columns, ctx.data.state))\n   * .output('isReady', (ctx) => ctx.params.columns !== undefined)\n   */\n  output<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions> {\n    return new PluginModelBuilder<Data, Params, Outputs & { [K in Key]: T }, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: T })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: T })[K];\n      },\n      outputFlags: { ...this.outputFlags, [key]: { withStatus: false } },\n    });\n  }\n\n  /**\n   * Adds an output wrapped with status information to the plugin.\n   *\n   * The UI receives the full {@link OutputWithStatus} object instead of an unwrapped value,\n   * allowing it to distinguish between pending, success, and error states.\n   *\n   * @param key - Output name\n   * @param fn - Function that computes the output value from plugin context\n   * @returns PluginModel with the new status-wrapped output added\n   *\n   * @example\n   * .outputWithStatus('table', (ctx) => {\n   *   const pCols = ctx.params.pFrame?.getPColumns();\n   *   if (pCols === undefined) return undefined;\n   *   return createPlDataTableV2(ctx, pCols, ctx.data.tableState);\n   * })\n   */\n  outputWithStatus<const Key extends string, T>(\n    key: Key,\n    fn: (ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>) => T,\n  ): PluginModelBuilder<\n    Data,\n    Params,\n    Outputs & { [K in Key]: OutputWithStatus<T> },\n    Config,\n    Versions\n  > {\n    return new PluginModelBuilder<\n      Data,\n      Params,\n      Outputs & { [K in Key]: OutputWithStatus<T> },\n      Config,\n      Versions\n    >({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: {\n        ...this.outputs,\n        [key]: fn,\n      } as {\n        [K in keyof (Outputs & { [P in Key]: OutputWithStatus<T> })]: (\n          ctx: PluginRenderCtx<PluginFactoryLike<Data, Params>>,\n        ) => (Outputs & { [P in Key]: OutputWithStatus<T> })[K];\n      },\n      outputFlags: { ...this.outputFlags, [key]: { withStatus: true } },\n    });\n  }\n\n  /**\n   * Finalizes the plugin definition and returns a PluginFactory.\n   *\n   * @returns Plugin factory that creates named plugin instances via .create()\n   *\n   * @example\n   * const myPlugin = PluginModel.define({ ... })\n   *   .output('value', (ctx) => ctx.data.value)\n   *   .build();\n   *\n   * // Create a named instance:\n   * const table = myPlugin.create({ pluginId: 'mainTable', config: { ... } });\n   */\n  build(): PluginFactory<Data, Params, Outputs, Config, Versions> {\n    return PluginModelFactory[FROM_BUILDER]<Data, Params, Outputs, Config, Versions>({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      outputs: this.outputs,\n      outputFlags: this.outputFlags,\n      featureFlags: this.featureFlags,\n    });\n  }\n}\n"],"mappings":"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"}

package/dist/render/api.cjs

@@ -480,20 +480,19 @@ var RenderCtxLegacy = class extends RenderCtxBase {
 *
 * @typeParam F - PluginFactoryLike phantom carrying data/params/outputs types
 */
-var PluginRenderCtx = class {
-	ctx;
+var PluginRenderCtx = class extends RenderCtxBase {
 	handle;
 	wrappedInputs;
 	constructor(handle, wrappedInputs) {
-		this.ctx = require_internal.getCfgRenderCtx();
+		super();
 		this.handle = handle;
 		this.wrappedInputs = wrappedInputs;
 	}
-	dataCache;
+	pluginDataCache;
 	/** Plugin's persistent data from blockStorage.__plugins.{pluginId}.__data */
 	get data() {
-		if (this.dataCache === void 0) this.dataCache = { v: require_block_storage.getPluginData((0, _milaboratories_pl_model_common.parseJson)(this.ctx.blockStorage()), this.handle) };
-		return this.dataCache.v;
+		if (this.pluginDataCache === void 0) this.pluginDataCache = { v: require_block_storage.getPluginData((0, _milaboratories_pl_model_common.parseJson)(this.ctx.blockStorage()), this.handle) };
+		return this.pluginDataCache.v;
 	}
 	paramsCache;
 	/** Params derived from block context via pre-wrapped input callbacks */
@@ -505,8 +504,6 @@ var PluginRenderCtx = class {
 		}
 		return this.paramsCache.v;
 	}
-	/** Result pool — same as block, from cfgRenderCtx methods */
-	resultPool = new ResultPool();
 };
 
 //#endregion