{"version":3,"file":"block_model.cjs","names":["REQUIRES_PFRAMES_VERSION","BLOCK_SERVICE_FLAGS","formatKindRef","createAndRegisterRenderLambda","BlockRenderCtx","CREATE_PLUGIN_MODEL","BlockStorageFacadeCallbacks","applyStorageUpdate","getStorageDebugView","migrateStorage","createInitialStorage","deriveArgsFromStorage","derivePrerunArgsFromStorage","deriveTemplateParamsFromStorage","createInitialStorageFromParams","validateTemplateParamsJson","pluginOutputKey","PluginRenderCtx","isInUI","PlatformaSDKVersion","BlockStorageFacadeHandles","downgradeCfgOrLambda","getPlatformaInstance","isConfigLambda"],"sources":["../src/block_model.ts"],"sourcesContent":["import type {\n  BlockRenderingMode,\n  BlockSection,\n  OutputWithStatus,\n  PlRef,\n  BlockCodeKnownFeatureFlags,\n  BlockConfigContainer,\n  BlockKindReference,\n  ArgsIssue,\n} from \"@milaboratories/pl-model-common\";\nimport { REQUIRES_PFRAMES_VERSION, formatKindRef } from \"@milaboratories/pl-model-common\";\nimport { getPlatformaInstance, isInUI, createAndRegisterRenderLambda } from \"./internal\";\nimport type { BlockKind, DataModel } from \"./block_migrations\";\nimport type { PlatformaV3 } from \"./platforma\";\nimport type { BlockDefaultUiServices } from \"./services/service_resolve\";\nimport { BLOCK_SERVICE_FLAGS } from \"./services/block_services\";\nimport type { InferRenderFunctionReturn, RenderFunction } from \"./render\";\nimport { BlockRenderCtx, PluginRenderCtx } from \"./render\";\nimport type {\n  PluginData,\n  PluginModel,\n  PluginOutputs,\n  PluginParams,\n  PluginPublicOutputs,\n} from \"./plugin_model\";\nimport { PluginInstance as PluginInstanceClass, CREATE_PLUGIN_MODEL } from \"./plugin_model\";\nimport { type PluginHandle, pluginOutputKey } from \"./plugin_handle\";\nimport type { RenderCtxBase } from \"./render\";\nimport { PlatformaSDKVersion } from \"./version\";\nimport {\n  applyStorageUpdate,\n  getStorageDebugView,\n  migrateStorage,\n  createInitialStorage,\n  createInitialStorageFromParams,\n  validateTemplateParamsJson,\n  deriveArgsFromStorage,\n  derivePrerunArgsFromStorage,\n  deriveTemplateParamsFromStorage,\n} from \"./block_storage_callbacks\";\nimport { type PluginName } from \"./block_storage\";\nimport type {\n  ConfigRenderLambda,\n  DeriveHref,\n  ConfigRenderLambdaFlags,\n  InferOutputsFromLambdas,\n} from \"./bconfig\";\nimport { downgradeCfgOrLambda, isConfigLambda } from \"./bconfig\";\nimport type { PlatformaExtended } from \"./platforma\";\nimport {\n  BLOCK_STORAGE_FACADE_VERSION,\n  BlockStorageFacadeCallbacks,\n  BlockStorageFacadeHandles,\n  registerFacadeCallbacks,\n} from \"./block_storage_facade\";\n\ntype SectionsExpectedType = readonly BlockSection[];\n\ntype NoOb = Record<string, never>;\n\n/**\n * Per-property lambdas for deriving plugin params from block render context.\n * Each property is a function that receives the block's RenderCtxBase and returns the param value.\n */\nexport type ParamsInput<Params, BArgs = unknown, BData = unknown> = {\n  [K in keyof Params]: (ctx: RenderCtxBase<BArgs, BData>) => Params[K];\n};\n\n/**\n * Type-erased version of ParamsInput for internal storage.\n */\ntype ParamsInputErased = Record<string, (ctx: RenderCtxBase) => unknown>;\n\n/**\n * Merges two feature flag objects with type-aware logic:\n * - `supports*` (boolean): OR — `true` if either side is `true`\n * - `requires*` (numeric): MAX — take the higher version requirement\n */\nfunction mergeFeatureFlags(\n  base: BlockCodeKnownFeatureFlags,\n  override: BlockCodeKnownFeatureFlags,\n): BlockCodeKnownFeatureFlags {\n  const result: Record<string, boolean | number | undefined> = { ...base };\n  for (const [key, value] of Object.entries(override)) {\n    if (value === undefined) continue;\n    const existing = result[key];\n    if (typeof value === \"boolean\") {\n      result[key] = (typeof existing === \"boolean\" && existing) || value;\n    } else if (typeof value === \"number\") {\n      result[key] = Math.max(typeof existing === \"number\" ? existing : 0, value);\n    }\n  }\n  return result as BlockCodeKnownFeatureFlags;\n}\n\n/**\n * Plugin record: model + param derivation lambdas.\n */\nexport type PluginRecord<\n  Data extends PluginData = PluginData,\n  Params extends PluginParams = undefined,\n  Outputs extends PluginOutputs = PluginOutputs,\n  PublicOutputs extends PluginPublicOutputs = PluginPublicOutputs,\n  ModelServices = unknown,\n  UiServices = unknown,\n> = {\n  readonly model: PluginModel<Data, Params, Outputs, PublicOutputs, ModelServices, UiServices>;\n  readonly inputs: ParamsInputErased;\n};\n\ninterface BlockModelV3Config<\n  OutputsCfg extends Record<string, ConfigRenderLambda>,\n  Data,\n  Plugins extends Record<string, PluginRecord> = {},\n  Transfers extends Record<string, unknown> = {},\n  Params = unknown,\n> {\n  renderingMode: BlockRenderingMode;\n  dataModel: DataModel<Data, Params, Transfers>;\n  /** Reference to the block kind this model implements, in `{name}@{version}` form. */\n  // @todo: use blockKind, `kind` super comman word\n  kind: BlockKindReference | undefined;\n  outputs: OutputsCfg;\n  sections: ConfigRenderLambda;\n  title: ConfigRenderLambda | undefined;\n  subtitle: ConfigRenderLambda | undefined;\n  tags: ConfigRenderLambda | undefined;\n  enrichmentTargets: ConfigRenderLambda | undefined;\n  featureFlags: BlockCodeKnownFeatureFlags;\n  deriveArgs: ((data: unknown) => unknown) | undefined;\n  /** Finds what keeps the derived args from running; set only together with `deriveArgs`. */\n  argsIssues: ((input: { args: unknown; data: unknown }) => ArgsIssue[]) | undefined;\n  derivePrerunArgs: ((data: unknown) => unknown) | undefined;\n  /** Finds what keeps the prerun args from staging; set only together with `derivePrerunArgs`. */\n  prerunArgsIssues: ((input: { prerunArgs: unknown; data: unknown }) => ArgsIssue[]) | undefined;\n  /** Projects block data back to this kind's params for template export. */\n  deriveTemplateParams: ((data: Data) => Params) | undefined;\n  /**\n   * The kind's runtime check for params supplied by a template. Read off the compiled\n   * kind rather than declared per block: the params contract belongs to the kind, and\n   * two blocks implementing it must not be able to disagree about what a valid params\n   * object is. Always present — a kind cannot omit it, and a block cannot omit a kind.\n   */\n  parseInitializationParams: (value: unknown) => unknown;\n  plugins: Plugins;\n}\n\n/** Main entry point that each block should use in it's \"config\" module. Don't forget\n * to call {@link done()} at the end of configuration. Value returned by this builder must be\n * exported as constant with name \"platforma\" from the \"config\" module.\n * API version is 3 (for UI) and 2 (for model) */\nexport class BlockModelV3<\n  Args,\n  OutputsCfg extends Record<string, ConfigRenderLambda>,\n  Data extends Record<string, unknown> = Record<string, unknown>,\n  Href extends `/${string}` = \"/\",\n  Plugins extends Record<string, PluginRecord> = {},\n  Transfers extends Record<string, unknown> = {},\n  Params = unknown,\n  PrerunArgs = unknown,\n> {\n  private constructor(\n    private readonly config: BlockModelV3Config<OutputsCfg, Data, Plugins, Transfers, Params>,\n  ) {}\n\n  public static readonly FEATURE_FLAGS = {\n    supportsLazyState: true,\n    supportsPframeQueryRanking: true,\n    supportsColumnLinks: true,\n    requiresUIAPIVersion: 3,\n    requiresModelAPIVersion: BLOCK_STORAGE_FACADE_VERSION,\n    requiresCreatePTable: 2,\n    requiresPFramesVersion: REQUIRES_PFRAMES_VERSION,\n    requiresArgsIssues: true,\n    ...BLOCK_SERVICE_FLAGS,\n  } satisfies BlockCodeKnownFeatureFlags;\n\n  /** @deprecated Use FEATURE_FLAGS */\n  public static readonly INITIAL_BLOCK_FEATURE_FLAGS = BlockModelV3.FEATURE_FLAGS;\n\n  /**\n   * Creates a new BlockModelV3 builder bound to a data model and a block kind.\n   *\n   * The `kind` argument is cross-checked against the kind handed to the\n   * builder: its `Params` type must match at compile time (via\n   * `BlockKind<Params>`), and its reference value must match at runtime. The\n   * reference is baked into the config so the published manifest can advertise\n   * which kind the block implements.\n   *\n   * @example\n   * const dataModel = new DataModelBuilder({ kind })\n   *   .from<BlockData>(\"v1\")\n   *   .init(({ params }) => params ?? { numbers: [], labels: [] });\n   *\n   * BlockModelV3.create({ dataModel, kind })\n   *   .args((data) => ({ numbers: data.numbers }))\n   *   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])\n   *   .done();\n   */\n  public static create<\n    Data extends Record<string, unknown>,\n    Params = never,\n    Transfers extends Record<string, unknown> = {},\n  >(args: {\n    dataModel: DataModel<Data, Params, Transfers>;\n    kind: BlockKind<Params>;\n  }): BlockModelV3<NoOb, {}, Data, \"/\", {}, Transfers, Params> {\n    const { dataModel, kind } = args;\n    // Derive the on-wire reference from the compiled kind; the kind object has\n    // no reference field of its own.\n    const kindRef = formatKindRef(kind);\n\n    // Runtime guard: the kind handed to the builder must match the kind handed to\n    // create(). Nothing ties them together at the type level — they arrive as two\n    // separately-passed objects — so a mismatch is only visible here. The builder's own\n    // reference is still optional, because a PLUGIN data model is built without a kind\n    // and has none to compare.\n    if (dataModel.kindRef && dataModel.kindRef !== kindRef) {\n      throw new Error(\n        `Block kind mismatch: data model built for '${dataModel.kindRef}' but create() got '${kindRef}'`,\n      );\n    }\n\n    return new BlockModelV3<NoOb, {}, Data, \"/\", {}, Transfers, Params>({\n      renderingMode: \"Heavy\",\n      dataModel,\n      kind: kindRef,\n      // Read off the kind, which cannot omit it — not off the data model. The two\n      // are cross-checked above, so there is one source, not a precedence order.\n      parseInitializationParams: kind.parseInitializationParams,\n      outputs: {},\n      sections: createAndRegisterRenderLambda({ handle: \"sections\", lambda: () => [] }, true),\n      title: undefined,\n      subtitle: undefined,\n      tags: undefined,\n      enrichmentTargets: undefined,\n      featureFlags: { ...BlockModelV3.FEATURE_FLAGS },\n      deriveArgs: undefined,\n      argsIssues: undefined,\n      derivePrerunArgs: undefined,\n      prerunArgsIssues: undefined,\n      deriveTemplateParams: undefined,\n      plugins: {},\n    });\n  }\n\n  /**\n   * Add output cell wrapped with additional status information to the configuration\n   *\n   * @param key output cell name, that can be later used to retrieve the rendered value\n   * @param rf  callback calculating output value using context, that allows to access\n   *            workflows outputs and interact with platforma drivers\n   * @param flags additional flags that may alter lambda rendering procedure\n   * */\n  public output<const Key extends string, const RF extends RenderFunction<Args, Data, unknown>>(\n    key: Key,\n    rf: RF,\n    flags: ConfigRenderLambdaFlags & { withStatus: true },\n  ): BlockModelV3<\n    Args,\n    OutputsCfg & {\n      [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>> & {\n        withStatus: true;\n      };\n    },\n    Data,\n    Href,\n    Plugins,\n    Transfers,\n    Params,\n    PrerunArgs\n  >;\n  /**\n   * Add output cell to the configuration\n   *\n   * @param key output cell name, that can be later used to retrieve the rendered value\n   * @param rf  callback calculating output value using context, that allows to access\n   *            workflows outputs and interact with platforma drivers\n   * @param flags additional flags that may alter lambda rendering procedure\n   * */\n  public output<const Key extends string, const RF extends RenderFunction<Args, Data, unknown>>(\n    key: Key,\n    rf: RF,\n    flags?: ConfigRenderLambdaFlags,\n  ): BlockModelV3<\n    Args,\n    OutputsCfg & {\n      [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>>;\n    },\n    Data,\n    Href,\n    Plugins,\n    Transfers,\n    Params,\n    PrerunArgs\n  >;\n  public output(\n    key: string,\n    cfgOrRf: RenderFunction<Args, Data, unknown>,\n    flags: ConfigRenderLambdaFlags = {},\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3({\n      ...this.config,\n      outputs: {\n        ...this.config.outputs,\n        [key]: createAndRegisterRenderLambda({\n          handle: `block-output#${key}`,\n          lambda: () => cfgOrRf(new BlockRenderCtx<Args, Data>()),\n          ...flags,\n        }),\n      },\n    });\n  }\n\n  /** Shortcut for {@link output} with retentive flag set to true. */\n  public retentiveOutput<\n    const Key extends string,\n    const RF extends RenderFunction<Args, Data, unknown>,\n  >(\n    key: Key,\n    rf: RF,\n  ): BlockModelV3<\n    Args,\n    OutputsCfg & {\n      [K in Key]: ConfigRenderLambda<InferRenderFunctionReturn<RF>>;\n    },\n    Data,\n    Href,\n    Plugins,\n    Transfers,\n    Params,\n    PrerunArgs\n  > {\n    return this.output(key, rf, { retentive: true });\n  }\n\n  /** Shortcut for {@link output} with withStatus flag set to true. */\n  public outputWithStatus<\n    const Key extends string,\n    const RF extends RenderFunction<Args, Data, unknown>,\n  >(key: Key, rf: RF) {\n    return this.output(key, rf, { withStatus: true });\n  }\n\n  /**\n   * Sets a function to derive block args from data.\n   * This is called during setData to compute the args that will be used for block execution.\n   *\n   * Build args even from incomplete data, and say what keeps the block from running in\n   * {@link argsIssues}: args that exist let the platform see what the block references\n   * before it is ready to run. Throwing here still works, and means there are no args at all.\n   *\n   * Setting args again drops a {@link argsIssues} set before, since it checked other args.\n   *\n   * @example\n   * .args<BlockArgs>((data) => ({ numbers: data.numbers }))\n   *\n   * @example\n   * .args<BlockArgs>((data) => ({ numbers: data.numbers }))\n   * .argsIssues(({ args }) =>\n   *   args.numbers.length === 0 ? [{ severity: 'error', message: 'Numbers required' }] : [],\n   * )\n   */\n  public args<A>(\n    lambda: (data: Data) => A,\n  ): BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<A, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      deriveArgs: lambda as (data: unknown) => unknown,\n      argsIssues: undefined,\n    });\n  }\n\n  /**\n   * Sets a function that finds what keeps the block from running with the args {@link args}\n   * derived (optional). It is called after `args()`, with its result and the data it was built\n   * from.\n   *\n   * An issue of severity `\"error\"` keeps the block from running; a `\"warning\"` does not. A throw,\n   * or a result that is not a list of issues, counts as one error carrying the thrown or parser\n   * message. Without this function, args that `args()` returns are always runnable.\n   *\n   * A block without its own {@link prerunArgs} is staged with its args, and only while this\n   * function finds no errors in them.\n   *\n   * Must be set after `.args()`, and is dropped when `.args()` is set again.\n   *\n   * @example\n   * .args((data) => ({ dataset: data.dataset, threshold: data.threshold }))\n   * .argsIssues(({ args }) => {\n   *   const issues: ArgsIssue[] = [];\n   *   if (args.dataset === undefined) issues.push({ severity: 'error', message: 'Select a dataset' });\n   *   if (args.threshold > 0.5) issues.push({ severity: 'warning', message: 'Threshold is high' });\n   *   return issues;\n   * })\n   */\n  public argsIssues(\n    fn: (input: { args: Args; data: Data }) => ArgsIssue[],\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    if (this.config.deriveArgs === undefined) {\n      throw new Error(\"argsIssues() must be set after args(): it checks the args they derive.\");\n    }\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      argsIssues: fn as (input: { args: unknown; data: unknown }) => ArgsIssue[],\n    });\n  }\n\n  /**\n   * Sets a function to derive pre-run args from data (optional).\n   * This is called during setData to compute the args that will be used for staging/pre-run phase.\n   *\n   * If not defined, defaults to using the args() function result.\n   * If defined, uses its return value for the staging / prerun phase.\n   *\n   * The staging / prerun phase runs only if currentPrerunArgs differs from the executed\n   * version of prerunArgs (same comparison logic as currentArgs vs prodArgs).\n   *\n   * Setting prerun args again drops a {@link prerunArgsIssues} set before, since it checked other\n   * args.\n   *\n   * @example\n   * .prerunArgs((data) => ({ numbers: data.numbers }))\n   *\n   * @example\n   * .prerunArgs((data) => {\n   *   // Return undefined to skip staging for this block\n   *   if (!data.isReady) return undefined;\n   *   return { numbers: data.numbers };\n   * })\n   */\n  public prerunArgs<P>(\n    fn: (data: Data) => P,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, P> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, P>({\n      ...this.config,\n      derivePrerunArgs: fn as (data: unknown) => unknown,\n      prerunArgsIssues: undefined,\n    });\n  }\n\n  /**\n   * Sets a function that finds what keeps the block from being staged with the args\n   * {@link prerunArgs} derived (optional). It is called after `prerunArgs()`, with its result\n   * and the data it was built from; not when `prerunArgs()` returned `undefined`, which skips\n   * staging anyway.\n   *\n   * An issue of severity `\"error\"` keeps the block from being staged; a `\"warning\"` does not. A\n   * throw, or a result that is not a list of issues, counts as one error carrying the thrown or\n   * parser message. {@link argsIssues} is not consulted for a block with its own prerun args.\n   *\n   * Must be set after `.prerunArgs()`, and is dropped when `.prerunArgs()` is set again.\n   *\n   * @example\n   * .prerunArgs((data) => ({ dataset: data.dataset }))\n   * .prerunArgsIssues(({ prerunArgs }) =>\n   *   prerunArgs.dataset === undefined ? [{ severity: 'error', message: 'Select a dataset' }] : [],\n   * )\n   */\n  public prerunArgsIssues(\n    fn: (input: { prerunArgs: Exclude<PrerunArgs, undefined>; data: Data }) => ArgsIssue[],\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    if (this.config.derivePrerunArgs === undefined) {\n      throw new Error(\n        \"prerunArgsIssues() must be set after prerunArgs(): it checks the prerun args they derive.\",\n      );\n    }\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      prerunArgsIssues: fn as (input: { prerunArgs: unknown; data: unknown }) => ArgsIssue[],\n    });\n  }\n\n  /**\n   * Sets the function that projects block data back to this kind's params, for\n   * exporting the project as a template.\n   *\n   * The inverse of the data model's `init`: `init` builds data from `params`, this\n   * recovers the `params` that would rebuild the current data. Return only params\n   * — runtime and derived state is dropped, and the exporter supplies the rest of\n   * the entry (`id`, `kind`), which this lambda cannot set.\n   *\n   * References are returned as ordinary `PlRef`s; the SDK rewrites them into\n   * template-local form on the way out, so a block never deals with the file\n   * representation.\n   *\n   * Required: `done()` throws without it. A block whose state cannot be reduced to\n   * params returns `{}` and says so explicitly, rather than exporting an entry with\n   * no params that silently applies as a default-initialized block.\n   *\n   * The return type is the kind's `Params`, so a block whose projection drifts\n   * from its own init contract fails to compile. Available only on a\n   * kind-carrying model — `create(dataModel)` without a kind leaves `Params` as\n   * `unknown` and this method cannot be type-checked against anything.\n   *\n   * @example\n   * BlockModelV3.create({ dataModel, kind })\n   *   .args((data) => ({ numbers: data.numbers }))\n   *   .templateParams((data) => ({ sources: data.sources }))\n   *   .done();\n   */\n  public templateParams(\n    fn: (data: Data) => Params,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      deriveTemplateParams: fn,\n    });\n  }\n\n  /** Sets the lambda to generate list of sections in the left block overviews panel. */\n  public sections<\n    const Ret extends SectionsExpectedType,\n    const RF extends RenderFunction<Args, Data, Ret>,\n  >(\n    rf: RF,\n  ): BlockModelV3<\n    Args,\n    OutputsCfg,\n    Data,\n    DeriveHref<ReturnType<RF>>,\n    Plugins,\n    Transfers,\n    Params,\n    PrerunArgs\n  > {\n    return new BlockModelV3<\n      Args,\n      OutputsCfg,\n      Data,\n      DeriveHref<ReturnType<RF>>,\n      Plugins,\n      Transfers,\n      Params,\n      PrerunArgs\n    >({\n      ...this.config,\n      // Replace the default sections callback with the user-provided one\n      sections: createAndRegisterRenderLambda(\n        {\n          handle: \"sections\",\n          lambda: () => rf(new BlockRenderCtx<Args, Data>()),\n        },\n        true,\n      ),\n    });\n  }\n\n  /** Sets a rendering function to derive block title, shown for the block in the left blocks-overview panel. */\n  public title(\n    rf: RenderFunction<Args, Data, string>,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      title: createAndRegisterRenderLambda({\n        handle: \"title\",\n        lambda: () => rf(new BlockRenderCtx<Args, Data>()),\n      }),\n    });\n  }\n\n  /**\n   * Sets a rendering function to derive block subtitle, shown below the title in the left\n   * blocks-overview panel. Unlike the title, it can read the result pool, so it can name the\n   * inputs the block reads (e.g. through `ctx.resultPool.getPColumnSpecByRef`).\n   */\n  public subtitle(\n    rf: RenderFunction<Args, Data, string>,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      subtitle: createAndRegisterRenderLambda({\n        handle: \"subtitle\",\n        lambda: () => rf(new BlockRenderCtx<Args, Data>()),\n      }),\n    });\n  }\n\n  public tags(\n    rf: RenderFunction<Args, Data, string[]>,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      tags: createAndRegisterRenderLambda({\n        handle: \"tags\",\n        lambda: () => rf(new BlockRenderCtx<Args, Data>()),\n      }),\n    });\n  }\n\n  /** Sets or overrides feature flags for the block. */\n  public withFeatureFlags(\n    flags: Partial<BlockCodeKnownFeatureFlags>,\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      featureFlags: { ...this.config.featureFlags, ...flags },\n    });\n  }\n\n  /**\n   * Defines how to derive list of upstream references this block is meant to enrich with its exports from block args.\n   * Influences dependency graph construction.\n   */\n  public enriches(\n    lambda: (args: Args) => PlRef[],\n  ): BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs> {\n    return new BlockModelV3<Args, OutputsCfg, Data, Href, Plugins, Transfers, Params, PrerunArgs>({\n      ...this.config,\n      enrichmentTargets: createAndRegisterRenderLambda({\n        handle: \"enrichmentTargets\",\n        lambda: lambda,\n      }),\n    });\n  }\n\n  /**\n   * Registers a plugin instance with the block.\n   * Consumes a transfer if one was defined for this plugin ID in the migration chain.\n   *\n   * Type checks:\n   * - If Transfers[Id] exists, verifies it extends PTransferData (transfer type compatibility)\n   * - If no Transfers[Id], rejects plugins with transferAt set (missing .transfer() in data model)\n   * - Rejects duplicate plugin IDs (Id already in keyof Plugins)\n   *\n   * @param instance - PluginInstance created via factory.create({ pluginId, ... })\n   * @param params - Per-property lambdas deriving plugin params from block RenderCtx\n   *\n   * @example\n   * .plugin(mainTable, {\n   *   columns: (ctx) => ctx.outputs?.resolve(\"data\")?.getPColumns(),\n   *   sourceId: (ctx) => ctx.data.selectedSource,\n   * })\n   */\n  public plugin<\n    const PluginId extends string,\n    PData extends PluginData,\n    PParams extends PluginParams,\n    POutputs extends PluginOutputs,\n    PPublicOutputs extends PluginPublicOutputs,\n    PTransferData,\n    PluginModelServices,\n    PluginUiServices,\n  >(\n    instance: PluginInstanceClass<\n      PluginId &\n        (PluginId extends keyof Transfers\n          ? Transfers[PluginId] extends PTransferData\n            ? string\n            : never\n          : [PTransferData] extends [never]\n            ? string\n            : never) &\n        (PluginId extends keyof Plugins ? never : string),\n      PData,\n      PParams,\n      POutputs,\n      PPublicOutputs,\n      PTransferData,\n      PluginModelServices,\n      PluginUiServices\n    >,\n    params?: ParamsInput<PParams, Args, Data>,\n  ): BlockModelV3<\n    Args,\n    OutputsCfg,\n    Data,\n    Href,\n    Plugins & {\n      [K in PluginId]: PluginRecord<\n        PData,\n        PParams,\n        POutputs,\n        PPublicOutputs,\n        PluginModelServices,\n        PluginUiServices\n      >;\n    },\n    Omit<Transfers, PluginId>,\n    Params,\n    PrerunArgs\n  >;\n  public plugin(\n    instance: PluginInstanceClass,\n    params?: ParamsInput<Record<string, unknown>, unknown, unknown>,\n  ): BlockModelV3<\n    Args,\n    OutputsCfg,\n    Data,\n    Href,\n    Record<string, PluginRecord>,\n    Record<string, unknown>,\n    Params,\n    PrerunArgs\n  > {\n    const pluginId = instance.id;\n    const plugin = instance[CREATE_PLUGIN_MODEL]();\n    const resolvedParams = (params ?? {}) as ParamsInputErased;\n\n    if (pluginId in this.config.plugins) {\n      throw new Error(`Plugin '${pluginId}' already registered`);\n    }\n\n    const registered: PluginRecord = {\n      model: plugin,\n      inputs: resolvedParams,\n    };\n\n    return new BlockModelV3({\n      ...this.config,\n      plugins: {\n        ...this.config.plugins,\n        [pluginId]: registered,\n      },\n      featureFlags: mergeFeatureFlags(this.config.featureFlags, plugin.featureFlags ?? {}),\n    });\n  }\n\n  /** Renders all provided block settings into a pre-configured platforma API\n   * instance, that can be used in frontend to interact with block data, and\n   * other features provided by the platforma to the block.\n   *\n   * Type-level check: if there are unconsumed transfers (from `.transfer()` calls\n   * in the migration chain), this method requires an impossible `never` argument,\n   * producing a compile error. Register all transferred plugins via `.plugin(instance)`\n   * before calling `.done()`.\n   */\n  public done(\n    ..._: keyof Transfers extends never ? [] : [never]\n  ): PlatformaExtended<\n    PlatformaV3<\n      Data,\n      Args,\n      InferOutputsFromLambdas<OutputsCfg>,\n      Href,\n      Plugins,\n      BlockDefaultUiServices\n    >\n  > {\n    if (this.config.deriveArgs === undefined) throw new Error(\"Args rendering function not set.\");\n    if (this.config.deriveTemplateParams === undefined)\n      throw new Error(\n        \"templateParams() not set. Every block must project its state back to its kind's params, \" +\n          \"so a project can be exported as a template and re-applied; a block whose state carries \" +\n          \"nothing worth restoring returns {}.\",\n      );\n\n    const apiVersion = 3;\n\n    // Build plugin registry\n    const { plugins } = this.config;\n    const pluginRegistry: Record<string, PluginName> = {};\n    const pluginHandles = Object.keys(plugins) as PluginHandle[];\n    for (const handle of pluginHandles) {\n      pluginRegistry[handle] = plugins[handle].model.name;\n    }\n\n    const {\n      dataModel,\n      deriveArgs,\n      argsIssues,\n      derivePrerunArgs,\n      prerunArgsIssues,\n      deriveTemplateParams,\n      parseInitializationParams,\n    } = this.config;\n\n    function getPlugin(handle: PluginHandle): PluginRecord {\n      const plugin = plugins[handle];\n      if (!plugin) throw new Error(`Plugin model not found for '${handle}'`);\n      return plugin;\n    }\n\n    // Register ALL facade callbacks here, with dependencies captured via closures\n    registerFacadeCallbacks({\n      [BlockStorageFacadeCallbacks.StorageApplyUpdate]: applyStorageUpdate,\n      [BlockStorageFacadeCallbacks.StorageDebugView]: getStorageDebugView,\n      [BlockStorageFacadeCallbacks.StorageMigrate]: (currentStorageJson) =>\n        migrateStorage(currentStorageJson, {\n          migrateBlockData: (v) => dataModel.migrate(v),\n          getPluginRegistry: () => pluginRegistry,\n          migratePluginData: (handle, v) => getPlugin(handle).model.dataModel.migrate(v),\n          createPluginData: (handle, transfer) => {\n            if (transfer) return transfer;\n            return getPlugin(handle).model.getDefaultData();\n          },\n        }),\n      [BlockStorageFacadeCallbacks.StorageInitial]: () =>\n        createInitialStorage({\n          getDefaultBlockData: () => dataModel.getDefaultData(),\n          getPluginRegistry: () => pluginRegistry,\n          createPluginData: (handle) => getPlugin(handle).model.getDefaultData(),\n        }),\n      [BlockStorageFacadeCallbacks.ArgsDerive]: (storageJson) =>\n        deriveArgsFromStorage(storageJson, { deriveArgs, argsIssues }),\n      [BlockStorageFacadeCallbacks.PrerunArgsDerive]: (storageJson) =>\n        derivePrerunArgsFromStorage(storageJson, {\n          deriveArgs,\n          argsIssues,\n          ownPrerunArgs:\n            derivePrerunArgs === undefined ? undefined : { derivePrerunArgs, prerunArgsIssues },\n        }),\n      [BlockStorageFacadeCallbacks.InitializationParamsDerive]: (storageJson) =>\n        deriveTemplateParamsFromStorage(\n          storageJson,\n          deriveTemplateParams as (data: unknown) => unknown,\n        ),\n      [BlockStorageFacadeCallbacks.StorageInitialFromParams]: (paramsJson, blockIdsJson) =>\n        createInitialStorageFromParams(paramsJson, blockIdsJson, {\n          getBlockDataFromParams: (params) => dataModel.getDataFromParams(params),\n          getPluginRegistry: () => pluginRegistry,\n          createPluginData: (handle) => getPlugin(handle).model.getDefaultData(),\n          parseInitializationParams,\n        }),\n      [BlockStorageFacadeCallbacks.InitializationParamsValidate]: (paramsJson) =>\n        validateTemplateParamsJson(paramsJson, parseInitializationParams),\n    });\n\n    // Register plugin input and output lambdas\n    const pluginOutputs: Record<string, ConfigRenderLambda> = {};\n    for (const handle of pluginHandles) {\n      const { model, inputs } = plugins[handle];\n      // Wrap plugin param lambdas: close over BlockRenderCtx creation\n      const wrappedInputs: Record<string, () => unknown> = {};\n      for (const [paramKey, paramFn] of Object.entries(inputs)) {\n        wrappedInputs[paramKey] = () => paramFn(new BlockRenderCtx());\n      }\n\n      // Register plugin outputs (in config pack, evaluated by middle layer)\n      const outputs = model.outputs as Record<string, (ctx: PluginRenderCtx) => unknown>;\n      for (const [outputKey, outputFn] of Object.entries(outputs)) {\n        const key = pluginOutputKey(handle, outputKey);\n        pluginOutputs[key] = createAndRegisterRenderLambda({\n          handle: key,\n          lambda: () => outputFn(new PluginRenderCtx(handle, wrappedInputs)),\n          withStatus: true,\n        });\n      }\n    }\n    const allOutputs = { ...this.config.outputs, ...pluginOutputs };\n\n    globalThis.platformaApiVersion = apiVersion;\n\n    if (!isInUI()) {\n      const blockConfig: BlockConfigContainer = {\n        v4: {\n          configVersion: 4,\n          modelAPIVersion: BLOCK_STORAGE_FACADE_VERSION,\n          sdkVersion: PlatformaSDKVersion,\n          renderingMode: this.config.renderingMode,\n          sections: this.config.sections,\n          title: this.config.title,\n          subtitle: this.config.subtitle,\n          tags: this.config.tags,\n          outputs: allOutputs,\n          enrichmentTargets: this.config.enrichmentTargets,\n          featureFlags: this.config.featureFlags,\n          blockLifecycleCallbacks: { ...BlockStorageFacadeHandles },\n        },\n\n        // Block-kind identity, baked at the container level beside `code`\n        // (orthogonal to which render envelope applies). Rides into model.json\n        // via the JSON.stringify(config) in build-model.ts — no write-path change.\n        kind: this.config.kind,\n\n        // fields below are added to allow previous desktop versions read generated configs\n        sdkVersion: PlatformaSDKVersion,\n        renderingMode: this.config.renderingMode,\n        sections: this.config.sections,\n        outputs: Object.fromEntries(\n          Object.entries(this.config.outputs).map(([key, value]) => [\n            key,\n            downgradeCfgOrLambda(value),\n          ]),\n        ),\n      };\n      // we are in the configuration rendering routine, not in actual UI\n      return { config: blockConfig } as any;\n      // normal operation inside the UI\n    } else {\n      return {\n        ...getPlatformaInstance({\n          sdkVersion: PlatformaSDKVersion,\n          apiVersion,\n        }),\n        blockModelInfo: {\n          outputs: Object.fromEntries(\n            Object.entries(allOutputs).map(([key, value]) => [\n              key,\n              {\n                withStatus: Boolean(isConfigLambda(value) && value.withStatus),\n              },\n            ]),\n          ),\n          pluginIds: pluginHandles,\n          featureFlags: this.config.featureFlags,\n          pluginPublicOutputs: Object.fromEntries(\n            pluginHandles.map((handle) => [handle, plugins[handle].model.publicOutputDef]),\n          ),\n        },\n      } as any;\n    }\n  }\n}\n\n// Type tests for BlockModelV3\n\nexport type Expect<T extends true> = T;\n\nexport type Equal<X, Y> =\n  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;\n\nexport type Merge<A, B> = {\n  [K in keyof A | keyof B]: K extends keyof B ? B[K] : K extends keyof A ? A[K] : never;\n};\n\n// Helper types for testing\ntype _TestArgs = { inputFile: string; threshold: number };\ntype _TestData = { selectedTab: string };\ntype _TestOutputs = {\n  result: ConfigRenderLambda<string>;\n  count: ConfigRenderLambda<number>;\n};\n\n// Test: Merge type works correctly\ntype _MergeTest1 = Expect<Equal<Merge<{ a: 1 }, { b: 2 }>, { a: 1; b: 2 }>>;\ntype _MergeTest2 = Expect<Equal<Merge<{ a: 1 }, { a: 2 }>, { a: 2 }>>;\ntype _MergeTest3 = Expect<Equal<Merge<{ a: 1; b: 1 }, { b: 2; c: 3 }>, { a: 1; b: 2; c: 3 }>>;\n\n// Test: create() returns a BlockModelV3 instance\n// Note: Due to function overloads, ReturnType uses the last overload signature.\n// We verify the structure is correct using a simpler assignability test.\ntype _CreateResult = ReturnType<typeof BlockModelV3.create>;\ntype _CreateIsBlockModelV3 =\n  _CreateResult extends BlockModelV3<infer _A, infer _O, infer _S> ? true : false;\ntype _CreateTest = Expect<_CreateIsBlockModelV3>;\n\n// Test: BlockModelV3Config interface structure (default generics)\ntype _ConfigTest = Expect<\n  Equal<\n    BlockModelV3Config<_TestOutputs, _TestData>,\n    {\n      renderingMode: BlockRenderingMode;\n      deriveArgs: ((data: unknown) => unknown) | undefined;\n      argsIssues: ((input: { args: unknown; data: unknown }) => ArgsIssue[]) | undefined;\n      derivePrerunArgs: ((data: unknown) => unknown) | undefined;\n      prerunArgsIssues:\n        | ((input: { prerunArgs: unknown; data: unknown }) => ArgsIssue[])\n        | undefined;\n      deriveTemplateParams: ((data: _TestData) => unknown) | undefined;\n      parseInitializationParams: (value: unknown) => unknown;\n      dataModel: DataModel<_TestData, unknown, {}>;\n      kind: BlockKindReference | undefined;\n      outputs: _TestOutputs;\n      sections: ConfigRenderLambda;\n      title: ConfigRenderLambda | undefined;\n      subtitle: ConfigRenderLambda | undefined;\n      tags: ConfigRenderLambda | undefined;\n      enrichmentTargets: ConfigRenderLambda | undefined;\n      featureFlags: BlockCodeKnownFeatureFlags;\n      plugins: {};\n    }\n  >\n>;\n\n// Test: Default Href is '/'\ntype _HrefDefaultTest =\n  BlockModelV3<_TestArgs, {}, _TestData> extends BlockModelV3<_TestArgs, {}, _TestData, \"/\">\n    ? true\n    : false;\ntype _VerifyHrefDefault = Expect<_HrefDefaultTest>;\n\n// Test: Custom Href can be specified\ntype _CustomHref = \"/settings\" | \"/main\";\ntype _HrefCustomBuilder = BlockModelV3<_TestArgs, {}, _TestData, _CustomHref>;\ntype _HrefCustomTest =\n  _HrefCustomBuilder extends BlockModelV3<_TestArgs, {}, _TestData, _CustomHref> ? true : false;\ntype _VerifyHrefCustom = Expect<_HrefCustomTest>;\n\n// Test: Output type accumulation with & intersection\ntype _OutputsAccumulation = { a: ConfigRenderLambda<string> } & {\n  b: ConfigRenderLambda<number>;\n};\ntype _VerifyOutputsHaveKeys = Expect<Equal<keyof _OutputsAccumulation, \"a\" | \"b\">>;\n\n// Test: Builder with all type parameters specified compiles\ntype _FullBuilder = BlockModelV3<_TestArgs, _TestOutputs, _TestData, \"/main\">;\ntype _FullBuilderTest =\n  _FullBuilder extends BlockModelV3<_TestArgs, _TestOutputs, _TestData, \"/main\"> ? true : false;\ntype _VerifyFullBuilder = Expect<_FullBuilderTest>;\n\n// Test: InferOutputsFromLambdas maps outputs correctly\ntype _InferOutputsTest = InferOutputsFromLambdas<{\n  myOutput: ConfigRenderLambda<number>;\n}>;\ntype _VerifyInferOutputs = Expect<\n  Equal<_InferOutputsTest, { myOutput: OutputWithStatus<number> & { __unwrap: true } }>\n>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA8EA,SAAS,kBACP,MACA,UAC4B;CAC5B,MAAM,SAAuD,EAAE,GAAG,KAAK;CACvE,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,GAAG;EACnD,IAAI,UAAU,KAAA,GAAW;EACzB,MAAM,WAAW,OAAO;EACxB,IAAI,OAAO,UAAU,WACnB,OAAO,OAAQ,OAAO,aAAa,aAAa,YAAa;OACxD,IAAI,OAAO,UAAU,UAC1B,OAAO,OAAO,KAAK,IAAI,OAAO,aAAa,WAAW,WAAW,GAAG,KAAK;CAE7E;CACA,OAAO;AACT;;;;;AA0DA,IAAa,eAAb,MAAa,aASX;CAEmB;CADnB,YACE,QACA;EADiB,KAAA,SAAA;CAChB;CAEH,OAAuB,gBAAgB;EACrC,mBAAmB;EACnB,4BAA4B;EAC5B,qBAAqB;EACrB,sBAAsB;EACtB,yBAAA;EACA,sBAAsB;EACtB,wBAAwBA,gCAAAA;EACxB,oBAAoB;EACpB,GAAGC,uBAAAA;CACL;;CAGA,OAAuB,8BAA8B,aAAa;;;;;;;;;;;;;;;;;;;;CAqBlE,OAAc,OAIZ,MAG2D;EAC3D,MAAM,EAAE,WAAW,SAAS;EAG5B,MAAM,WAAA,GAAUC,gCAAAA,cAAAA,CAAc,IAAI;EAOlC,IAAI,UAAU,WAAW,UAAU,YAAY,SAC7C,MAAM,IAAI,MACR,8CAA8C,UAAU,QAAQ,sBAAsB,QAAQ,EAChG;EAGF,OAAO,IAAI,aAAyD;GAClE,eAAe;GACf;GACA,MAAM;GAGN,2BAA2B,KAAK;GAChC,SAAS,CAAC;GACV,UAAUC,iBAAAA,8BAA8B;IAAE,QAAQ;IAAY,cAAc,CAAC;GAAE,GAAG,IAAI;GACtF,OAAO,KAAA;GACP,UAAU,KAAA;GACV,MAAM,KAAA;GACN,mBAAmB,KAAA;GACnB,cAAc,EAAE,GAAG,aAAa,cAAc;GAC9C,YAAY,KAAA;GACZ,YAAY,KAAA;GACZ,kBAAkB,KAAA;GAClB,kBAAkB,KAAA;GAClB,sBAAsB,KAAA;GACtB,SAAS,CAAC;EACZ,CAAC;CACH;CAoDA,OACE,KACA,SACA,QAAiC,CAAC,GACkD;EACpF,OAAO,IAAI,aAAa;GACtB,GAAG,KAAK;GACR,SAAS;IACP,GAAG,KAAK,OAAO;KACd,MAAMA,iBAAAA,8BAA8B;KACnC,QAAQ,gBAAgB;KACxB,cAAc,QAAQ,IAAIC,YAAAA,eAA2B,CAAC;KACtD,GAAG;IACL,CAAC;GACH;EACF,CAAC;CACH;;CAGA,gBAIE,KACA,IAYA;EACA,OAAO,KAAK,OAAO,KAAK,IAAI,EAAE,WAAW,KAAK,CAAC;CACjD;;CAGA,iBAGE,KAAU,IAAQ;EAClB,OAAO,KAAK,OAAO,KAAK,IAAI,EAAE,YAAY,KAAK,CAAC;CAClD;;;;;;;;;;;;;;;;;;;;CAqBA,KACE,QACiF;EACjF,OAAO,IAAI,aAAgF;GACzF,GAAG,KAAK;GACR,YAAY;GACZ,YAAY,KAAA;EACd,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;CAyBA,WACE,IACoF;EACpF,IAAI,KAAK,OAAO,eAAe,KAAA,GAC7B,MAAM,IAAI,MAAM,wEAAwE;EAE1F,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,YAAY;EACd,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;CAyBA,WACE,IAC2E;EAC3E,OAAO,IAAI,aAA0E;GACnF,GAAG,KAAK;GACR,kBAAkB;GAClB,kBAAkB,KAAA;EACpB,CAAC;CACH;;;;;;;;;;;;;;;;;;;CAoBA,iBACE,IACoF;EACpF,IAAI,KAAK,OAAO,qBAAqB,KAAA,GACnC,MAAM,IAAI,MACR,2FACF;EAEF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,kBAAkB;EACpB,CAAC;CACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BA,eACE,IACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,sBAAsB;EACxB,CAAC;CACH;;CAGA,SAIE,IAUA;EACA,OAAO,IAAI,aAST;GACA,GAAG,KAAK;GAER,UAAUD,iBAAAA,8BACR;IACE,QAAQ;IACR,cAAc,GAAG,IAAIC,YAAAA,eAA2B,CAAC;GACnD,GACA,IACF;EACF,CAAC;CACH;;CAGA,MACE,IACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,OAAOD,iBAAAA,8BAA8B;IACnC,QAAQ;IACR,cAAc,GAAG,IAAIC,YAAAA,eAA2B,CAAC;GACnD,CAAC;EACH,CAAC;CACH;;;;;;CAOA,SACE,IACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,UAAUD,iBAAAA,8BAA8B;IACtC,QAAQ;IACR,cAAc,GAAG,IAAIC,YAAAA,eAA2B,CAAC;GACnD,CAAC;EACH,CAAC;CACH;CAEA,KACE,IACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,MAAMD,iBAAAA,8BAA8B;IAClC,QAAQ;IACR,cAAc,GAAG,IAAIC,YAAAA,eAA2B,CAAC;GACnD,CAAC;EACH,CAAC;CACH;;CAGA,iBACE,OACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,cAAc;IAAE,GAAG,KAAK,OAAO;IAAc,GAAG;GAAM;EACxD,CAAC;CACH;;;;;CAMA,SACE,QACoF;EACpF,OAAO,IAAI,aAAmF;GAC5F,GAAG,KAAK;GACR,mBAAmBD,iBAAAA,8BAA8B;IAC/C,QAAQ;IACA;GACV,CAAC;EACH,CAAC;CACH;CAoEA,OACE,UACA,QAUA;EACA,MAAM,WAAW,SAAS;EAC1B,MAAM,SAAS,SAASE,qBAAAA,oBAAoB,CAAC;EAC7C,MAAM,iBAAkB,UAAU,CAAC;EAEnC,IAAI,YAAY,KAAK,OAAO,SAC1B,MAAM,IAAI,MAAM,WAAW,SAAS,qBAAqB;EAG3D,MAAM,aAA2B;GAC/B,OAAO;GACP,QAAQ;EACV;EAEA,OAAO,IAAI,aAAa;GACtB,GAAG,KAAK;GACR,SAAS;IACP,GAAG,KAAK,OAAO;KACd,WAAW;GACd;GACA,cAAc,kBAAkB,KAAK,OAAO,cAAc,OAAO,gBAAgB,CAAC,CAAC;EACrF,CAAC;CACH;;;;;;;;;;CAWA,KACE,GAAG,GAUH;EACA,IAAI,KAAK,OAAO,eAAe,KAAA,GAAW,MAAM,IAAI,MAAM,kCAAkC;EAC5F,IAAI,KAAK,OAAO,yBAAyB,KAAA,GACvC,MAAM,IAAI,MACR,oNAGF;EAEF,MAAM,aAAa;EAGnB,MAAM,EAAE,YAAY,KAAK;EACzB,MAAM,iBAA6C,CAAC;EACpD,MAAM,gBAAgB,OAAO,KAAK,OAAO;EACzC,KAAK,MAAM,UAAU,eACnB,eAAe,UAAU,QAAQ,OAAO,CAAC,MAAM;EAGjD,MAAM,EACJ,WACA,YACA,YACA,kBACA,kBACA,sBACA,8BACE,KAAK;EAET,SAAS,UAAU,QAAoC;GACrD,MAAM,SAAS,QAAQ;GACvB,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,+BAA+B,OAAO,EAAE;GACrE,OAAO;EACT;EAGA,6BAAA,wBAAwB;IACrBC,6BAAAA,4BAA4B,qBAAqBC,gCAAAA;IACjDD,6BAAAA,4BAA4B,mBAAmBE,gCAAAA;IAC/CF,6BAAAA,4BAA4B,kBAAkB,uBAC7CG,gCAAAA,eAAe,oBAAoB;IACjC,mBAAmB,MAAM,UAAU,QAAQ,CAAC;IAC5C,yBAAyB;IACzB,oBAAoB,QAAQ,MAAM,UAAU,MAAM,CAAC,CAAC,MAAM,UAAU,QAAQ,CAAC;IAC7E,mBAAmB,QAAQ,aAAa;KACtC,IAAI,UAAU,OAAO;KACrB,OAAO,UAAU,MAAM,CAAC,CAAC,MAAM,eAAe;IAChD;GACF,CAAC;IACFH,6BAAAA,4BAA4B,uBAC3BI,gCAAAA,qBAAqB;IACnB,2BAA2B,UAAU,eAAe;IACpD,yBAAyB;IACzB,mBAAmB,WAAW,UAAU,MAAM,CAAC,CAAC,MAAM,eAAe;GACvE,CAAC;IACFJ,6BAAAA,4BAA4B,cAAc,gBACzCK,gCAAAA,sBAAsB,aAAa;IAAE;IAAY;GAAW,CAAC;IAC9DL,6BAAAA,4BAA4B,oBAAoB,gBAC/CM,gCAAAA,4BAA4B,aAAa;IACvC;IACA;IACA,eACE,qBAAqB,KAAA,IAAY,KAAA,IAAY;KAAE;KAAkB;IAAiB;GACtF,CAAC;IACFN,6BAAAA,4BAA4B,8BAA8B,gBACzDO,gCAAAA,gCACE,aACA,oBACF;IACDP,6BAAAA,4BAA4B,4BAA4B,YAAY,iBACnEQ,gCAAAA,+BAA+B,YAAY,cAAc;IACvD,yBAAyB,WAAW,UAAU,kBAAkB,MAAM;IACtE,yBAAyB;IACzB,mBAAmB,WAAW,UAAU,MAAM,CAAC,CAAC,MAAM,eAAe;IACrE;GACF,CAAC;IACFR,6BAAAA,4BAA4B,gCAAgC,eAC3DS,gCAAAA,2BAA2B,YAAY,yBAAyB;EACpE,CAAC;EAGD,MAAM,gBAAoD,CAAC;EAC3D,KAAK,MAAM,UAAU,eAAe;GAClC,MAAM,EAAE,OAAO,WAAW,QAAQ;GAElC,MAAM,gBAA+C,CAAC;GACtD,KAAK,MAAM,CAAC,UAAU,YAAY,OAAO,QAAQ,MAAM,GACrD,cAAc,kBAAkB,QAAQ,IAAIX,YAAAA,eAAe,CAAC;GAI9D,MAAM,UAAU,MAAM;GACtB,KAAK,MAAM,CAAC,WAAW,aAAa,OAAO,QAAQ,OAAO,GAAG;IAC3D,MAAM,MAAMY,sBAAAA,gBAAgB,QAAQ,SAAS;IAC7C,cAAc,OAAOb,iBAAAA,8BAA8B;KACjD,QAAQ;KACR,cAAc,SAAS,IAAIc,YAAAA,gBAAgB,QAAQ,aAAa,CAAC;KACjE,YAAY;IACd,CAAC;GACH;EACF;EACA,MAAM,aAAa;GAAE,GAAG,KAAK,OAAO;GAAS,GAAG;EAAc;EAE9D,WAAW,sBAAsB;EAEjC,IAAI,CAACC,iBAAAA,OAAO,GAkCV,OAAO,EAAE,QAAQ;GAhCf,IAAI;IACF,eAAe;IACf,iBAAA;IACA,YAAYC,gBAAAA;IACZ,eAAe,KAAK,OAAO;IAC3B,UAAU,KAAK,OAAO;IACtB,OAAO,KAAK,OAAO;IACnB,UAAU,KAAK,OAAO;IACtB,MAAM,KAAK,OAAO;IAClB,SAAS;IACT,mBAAmB,KAAK,OAAO;IAC/B,cAAc,KAAK,OAAO;IAC1B,yBAAyB,EAAE,GAAGC,6BAAAA,0BAA0B;GAC1D;GAKA,MAAM,KAAK,OAAO;GAGlB,YAAYD,gBAAAA;GACZ,eAAe,KAAK,OAAO;GAC3B,UAAU,KAAK,OAAO;GACtB,SAAS,OAAO,YACd,OAAO,QAAQ,KAAK,OAAO,OAAO,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CACxD,KACAE,sBAAAA,qBAAqB,KAAK,CAC5B,CAAC,CACH;EAGyB,EAAE;OAG7B,OAAO;GACL,GAAGC,iBAAAA,qBAAqB;IACtB,YAAYH,gBAAAA;IACZ;GACF,CAAC;GACD,gBAAgB;IACd,SAAS,OAAO,YACd,OAAO,QAAQ,UAAU,CAAC,CAAC,KAAK,CAAC,KAAK,WAAW,CAC/C,KACA,EACE,YAAY,QAAQI,cAAAA,eAAe,KAAK,KAAK,MAAM,UAAU,EAC/D,CACF,CAAC,CACH;IACA,WAAW;IACX,cAAc,KAAK,OAAO;IAC1B,qBAAqB,OAAO,YAC1B,cAAc,KAAK,WAAW,CAAC,QAAQ,QAAQ,OAAO,CAAC,MAAM,eAAe,CAAC,CAC/E;GACF;EACF;CAEJ;AACF"}