{"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 type { ResolveModelServices, ResolveUiServices } from \"./services/service_resolve\";\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/** Output function signature for plugin render context. */\ntype PluginOutputFn<\n  Data extends PluginData,\n  Params extends PluginParams,\n  ModelServices,\n  UiServices,\n  T,\n> = (\n  ctx: PluginRenderCtx<\n    PluginFactoryLike<Data, Params, Record<string, unknown>, ModelServices, UiServices>\n  >,\n) => T;\n\n/** Mapped output functions for a plugin's outputs. */\ntype PluginOutputFns<\n  Data extends PluginData,\n  Params extends PluginParams,\n  Outputs extends PluginOutputs,\n  ModelServices,\n  UiServices,\n> = {\n  [K in keyof Outputs]: PluginOutputFn<Data, Params, ModelServices, UiServices, Outputs[K]>;\n};\n\n/** Internal plugin↔block handshake. `Symbol.for` (not `Symbol`) so it stays\n * identical across multiple `@platforma-sdk/model` copies in one process. */\nexport const CREATE_PLUGIN_MODEL = Symbol.for(\"@platforma-sdk/model:createPluginModel\");\n\n/** Sentinel for PluginInstance without transferAt — no transfer possible. */\nconst NO_TRANSFER_VERSION = \"\";\n\n/**\n * Runtime definition for a single public output field.\n * Stored in PluginModel and passed through BlockModelInfo to the UI layer.\n */\nexport type PublicOutputFieldDef = {\n  readonly getter: (data: unknown) => unknown;\n};\n\nexport type PublicOutputDef<PublicOutputs extends PluginPublicOutputs> = {\n  [K in keyof PublicOutputs]: PublicOutputFieldDef;\n};\n\nexport type PluginData = Record<string, unknown>;\nexport type PluginParams = undefined | Record<string, unknown>;\nexport type PluginOutputs = Record<string, unknown>;\nexport type PluginPublicOutputs = 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  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  TransferData = never,\n  ModelServices = unknown,\n  UiServices = unknown,\n> implements TransferTarget<Id, TransferData> {\n  readonly id: Id;\n  readonly transferVersion: string;\n  /** @internal Phantom for type inference; never set at runtime. */\n  readonly __instanceTypes?: {\n    data: Data;\n    params: Params;\n    outputs: Outputs;\n    modelServices: ModelServices;\n    uiServices: UiServices;\n    publicOutputs: PublicOutputs;\n  };\n  /** Bound closure that creates the PluginModel. Config is captured at factory.create() time. */\n  private readonly createPluginModel: () => PluginModel<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    ModelServices,\n    UiServices\n  >;\n\n  private constructor(\n    id: Id,\n    createPluginModel: () => PluginModel<\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs,\n      ModelServices,\n      UiServices\n    >,\n    transferVersion: string,\n  ) {\n    this.id = id;\n    this.createPluginModel = createPluginModel;\n    this.transferVersion = transferVersion;\n  }\n\n  /** @internal Accepts concrete Config — binds it into a closure, avoiding Config variance issues. */\n  static [FROM_BUILDER]<\n    Id extends string,\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n    TransferData = never,\n    Config extends PluginConfig = PluginConfig,\n    ModelServices = unknown,\n    UiServices = unknown,\n  >(\n    id: Id,\n    factory: PluginModelFactory<\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs,\n      Config,\n      Record<string, unknown>,\n      ModelServices,\n      UiServices\n    >,\n    transferVersion: string,\n    config?: Config,\n  ): PluginInstance<\n    Id,\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    TransferData,\n    ModelServices,\n    UiServices\n  > {\n    return new PluginInstance(id, () => factory[CREATE_PLUGIN_MODEL](config), transferVersion);\n  }\n\n  /** @internal Create a PluginModel from this instance. Used by BlockModelV3.plugin(). */\n  [CREATE_PLUGIN_MODEL](): PluginModel<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    ModelServices,\n    UiServices\n  > {\n    return this.createPluginModel();\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  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  ModelServices = {},\n  UiServices = {},\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: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\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  /** Public output definitions — accessible without usePlugin() via app.plugins */\n  readonly publicOutputDef: PublicOutputDef<PublicOutputs>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\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    this.publicOutputDef = options.publicOutputDef;\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    PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n    ModelServices = {},\n    UiServices = {},\n  >(options: {\n    name: PluginName;\n    dataModel: DataModel<Data>;\n    outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    getDefaultData: () => DataVersioned<Data>;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\n  }): PluginModel<Data, Params, Outputs, PublicOutputs, ModelServices, UiServices> {\n    return new PluginModel<Data, Params, Outputs, PublicOutputs, ModelServices, UiServices>(\n      options,\n    );\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    Flags extends BlockCodeKnownFeatureFlags = {},\n  >(options: {\n    name: PluginName;\n    data: PluginDataModel<Data, Versions, Config>;\n    featureFlags?: Flags;\n  }): PluginModelInitialBuilder<\n    Data,\n    Params,\n    Config,\n    Versions,\n    ResolveModelServices<Flags>,\n    ResolveUiServices<Flags>\n  >;\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    Flags extends BlockCodeKnownFeatureFlags = {},\n  >(options: {\n    name: PluginName;\n    data: (config?: Config) => DataModel<Data>;\n    featureFlags?: Flags;\n  }): PluginModelInitialBuilder<\n    Data,\n    Params,\n    Config,\n    {},\n    ResolveModelServices<Flags>,\n    ResolveUiServices<Flags>\n  >;\n  static define(options: {\n    name: PluginName;\n    data: PluginDataModel<any, any, any> | ((config?: any) => DataModel<any>);\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelInitialBuilder {\n    if (options.data instanceof PluginDataModel) {\n      const pdm = options.data;\n      return PluginModelInitialBuilder.create({\n        name: options.name,\n        dataFn: () => pdm.dataModel,\n        getDefaultDataFn: (config: any) => pdm.getDefaultData(config),\n        featureFlags: options.featureFlags,\n      });\n    }\n    return PluginModelInitialBuilder.create({\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  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n  ModelServices = {},\n  UiServices = {},\n> extends PluginFactoryLike<Data, Params, Outputs, ModelServices, UiServices> {\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<\n    Id,\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    Versions[V],\n    ModelServices,\n    UiServices\n  >;\n\n  /** Public output field definitions declared via .publicOutput(). */\n  readonly publicOutputDef: PublicOutputDef<PublicOutputs>;\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    modelServices: ModelServices;\n    uiServices: UiServices;\n    config: Config;\n    versions: Versions;\n    publicOutputs: PublicOutputs;\n  };\n}\n\nclass PluginModelFactory<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n  ModelServices = {},\n  UiServices = {},\n> implements PluginFactory<\n  Data,\n  Params,\n  Outputs,\n  PublicOutputs,\n  Config,\n  Versions,\n  ModelServices,\n  UiServices\n> {\n  private readonly name: PluginName;\n  private readonly dataFn: (config?: Config) => DataModel<Data>;\n  private readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  readonly outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n  private readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  readonly publicOutputDef: PublicOutputDef<PublicOutputs>;\n\n  private constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\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    this.publicOutputDef = options.publicOutputDef;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n    Config extends PluginConfig = undefined,\n    Versions extends Record<string, unknown> = {},\n    ModelServices = {},\n    UiServices = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\n  }): PluginModelFactory<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\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<\n    Id,\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    Versions[V],\n    ModelServices,\n    UiServices\n  > {\n    const transferVersion = options.transferAt ?? NO_TRANSFER_VERSION;\n    return PluginInstance[FROM_BUILDER]<\n      Id,\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs,\n      Versions[V],\n      Config,\n      ModelServices,\n      UiServices\n    >(options.pluginId as Id, this, transferVersion, options.config);\n  }\n\n  /** @internal Create a PluginModel from config. Config is captured in getDefaultData closure. */\n  [CREATE_PLUGIN_MODEL](\n    config?: Config,\n  ): PluginModel<Data, Params, Outputs, PublicOutputs, ModelServices, UiServices> {\n    const dataModel = this.dataFn(config);\n    const getDefaultDataFn = this.getDefaultDataFn;\n    return PluginModel[FROM_BUILDER]<\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs,\n      ModelServices,\n      UiServices\n    >({\n      name: this.name,\n      dataModel,\n      outputs: this.outputs,\n      featureFlags: this.featureFlags,\n      getDefaultData: getDefaultDataFn\n        ? () => getDefaultDataFn(config)\n        : () => dataModel.getDefaultData(),\n      publicOutputDef: this.publicOutputDef,\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  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n  ModelServices = {},\n  UiServices = {},\n> {\n  protected readonly name: PluginName;\n  protected readonly dataFn: (config?: Config) => DataModel<Data>;\n  protected readonly getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n  private readonly outputs: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n  protected readonly featureFlags?: BlockCodeKnownFeatureFlags;\n  private readonly publicOutputDef: PublicOutputDef<PublicOutputs>;\n\n  protected constructor(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\n  }) {\n    this.name = options.name;\n    this.dataFn = options.dataFn;\n    this.getDefaultDataFn = options.getDefaultDataFn;\n    this.outputs =\n      options.outputs ?? ({} as PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>);\n    this.featureFlags = options.featureFlags;\n    this.publicOutputDef = options.publicOutputDef;\n  }\n\n  /** @internal */\n  static [FROM_BUILDER]<\n    Data extends PluginData,\n    Params extends PluginParams,\n    Outputs extends PluginOutputs,\n    PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n    Config extends PluginConfig = undefined,\n    Versions extends Record<string, unknown> = {},\n    ModelServices = {},\n    UiServices = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    outputs?: PluginOutputFns<Data, Params, Outputs, ModelServices, UiServices>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n    publicOutputDef: PublicOutputDef<PublicOutputs>;\n  }): PluginModelBuilder<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\n    return new PluginModelBuilder(options);\n  }\n\n  /**\n   * Adds an output to the plugin.\n   * All plugin outputs are always wrapped with status — the UI receives\n   * {@link OutputWithStatus} for every output, allowing it to distinguish\n   * 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 Builder with the new output added\n   *\n   * @example\n   * .output('model', (ctx) => createModel(ctx.params.columns, ctx.data.state))\n   * .output('pFrame', (ctx) => ctx.createPFrame([...]))\n   */\n  output<const Key extends string, T>(\n    key: Key,\n    fn: (\n      ctx: PluginRenderCtx<\n        PluginFactoryLike<Data, Params, Record<string, unknown>, ModelServices, UiServices>\n      >,\n    ) => T,\n  ): PluginModelBuilder<\n    Data,\n    Params,\n    Outputs & { [K in Key]: OutputWithStatus<T> },\n    PublicOutputs,\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\n    return new PluginModelBuilder<\n      Data,\n      Params,\n      Outputs & { [K in Key]: OutputWithStatus<T> },\n      PublicOutputs,\n      Config,\n      Versions,\n      ModelServices,\n      UiServices\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 unknown as PluginOutputFns<\n        Data,\n        Params,\n        Outputs & { [P in Key]: OutputWithStatus<T> },\n        ModelServices,\n        UiServices\n      >,\n      publicOutputDef: this.publicOutputDef,\n    });\n  }\n\n  /**\n   * Exposes a plugin data field as a public output — accessible without `usePlugin()`\n   * via `app.plugins.pluginName.publicOutputs.key`.\n   *\n   * The getter runs against the plugin's reactive data object.\n   * Public outputs are read-only.\n   *\n   * @param key - Name of the public output field\n   * @param getter - Function deriving the value from plugin data\n   *\n   * @example\n   * .publicOutput('selection', (d) => d.selection)\n   */\n  publicOutput<const Key extends string, T>(\n    key: Key,\n    getter: (data: Data) => T,\n  ): PluginModelBuilder<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs & { [K in Key]: T },\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\n    return new PluginModelBuilder<\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs & { [K in Key]: T },\n      Config,\n      Versions,\n      ModelServices,\n      UiServices\n    >({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      outputs: this.outputs,\n      publicOutputDef: {\n        ...this.publicOutputDef,\n        [key]: { getter: getter as (data: unknown) => unknown },\n      } as PublicOutputDef<PublicOutputs & { [K in Key]: T }>,\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<\n    Data,\n    Params,\n    Outputs,\n    PublicOutputs,\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\n    return PluginModelFactory[FROM_BUILDER]<\n      Data,\n      Params,\n      Outputs,\n      PublicOutputs,\n      Config,\n      Versions,\n      ModelServices,\n      UiServices\n    >({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      outputs: this.outputs,\n      publicOutputDef: this.publicOutputDef,\n      featureFlags: this.featureFlags,\n    });\n  }\n}\n\n/**\n * Initial builder returned by PluginModel.define(). Extends PluginModelBuilder with .params().\n * Once .params() or .output() is called, transitions to PluginModelBuilder (no second .params()).\n */\nclass PluginModelInitialBuilder<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Config extends PluginConfig = undefined,\n  Versions extends Record<string, unknown> = {},\n  ModelServices = {},\n  UiServices = {},\n> extends PluginModelBuilder<Data, Params, {}, {}, Config, Versions, ModelServices, UiServices> {\n  /** @internal */\n  static create<\n    Data extends PluginData,\n    Config extends PluginConfig,\n    Versions extends Record<string, unknown> = {},\n    ModelServices = {},\n    UiServices = {},\n  >(options: {\n    name: PluginName;\n    dataFn: (config?: Config) => DataModel<Data>;\n    getDefaultDataFn?: (config?: Config) => DataVersioned<Data>;\n    featureFlags?: BlockCodeKnownFeatureFlags;\n  }): PluginModelInitialBuilder<Data, undefined, Config, Versions, ModelServices, UiServices> {\n    return new PluginModelInitialBuilder({ ...options, publicOutputDef: {} });\n  }\n\n  /**\n   * Sets the Params type for this plugin — the shape of data derived from the block's\n   * render context and passed into plugin output functions via `ctx.params`.\n   * Must be called before .output(). Available only on the initial builder.\n   *\n   * @example\n   * .params<{ title: string }>()\n   * .output('displayText', (ctx) => ctx.params.title)\n   */\n  params<P extends PluginParams>(): PluginModelBuilder<\n    Data,\n    P,\n    {},\n    {},\n    Config,\n    Versions,\n    ModelServices,\n    UiServices\n  > {\n    return PluginModelBuilder[FROM_BUILDER]<\n      Data,\n      P,\n      {},\n      {},\n      Config,\n      Versions,\n      ModelServices,\n      UiServices\n    >({\n      name: this.name,\n      dataFn: this.dataFn,\n      getDefaultDataFn: this.getDefaultDataFn,\n      featureFlags: this.featureFlags,\n      publicOutputDef: {},\n    });\n  }\n}\n"],"mappings":"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"}