@platforma-sdk/model 1.53.2 → 1.53.4

package/dist/block_migrations.cjs

@@ -152,7 +152,11 @@ class DataModelMigrationChain {
             throw new Error(`Duplicate version '${nextVersion}' in migration chain`);
         }
         const fromVersion = this.versionChain[this.versionChain.length - 1];
-        const step = { fromVersion, toVersion: nextVersion, migrate: fn };
+        const step = {
+            fromVersion,
+            toVersion: nextVersion,
+            migrate: fn,
+        };
         return new DataModelMigrationChain({
             versionChain: [...this.versionChain, nextVersion],
             steps: [...this.migrationSteps, step],
@@ -253,19 +257,21 @@ class DataModelBuilder {
  * DataModel defines the block's data structure, initial values, and migrations.
  * Used by BlockModelV3 to manage data state.
  *
- * Two ways to create a DataModel:
+ * Use `new DataModelBuilder<VersionedData>()` to create a DataModel:
  *
- * 1. **Simple (no migrations)** - Use `DataModel.create()`:
+ * **Simple (no migrations):**
  * @example
- * const dataModel = DataModel.create<BlockData>(() => ({
- *   numbers: [],
- *   labels: [],
- * }));
+ * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });
+ * type VersionedData = { [Version.V1]: BlockData };
  *
- * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:
+ * const dataModel = new DataModelBuilder<VersionedData>()
+ *   .from(Version.V1)
+ *   .init(() => ({ numbers: [], labels: [] }));
+ *
+ * **With migrations:**
  * @example
  * const Version = defineDataVersions({
- *   V1: 'v1',
+ *   V1: DATA_MODEL_DEFAULT_VERSION,
  *   V2: 'v2',
  *   V3: 'v3',
  * });
@@ -302,30 +308,6 @@ class DataModel {
         this.initialDataFn = initialDataFn;
         this.recoverFn = recoverFn;
     }
-    /**
-     * Create a DataModel with just initial data (no migrations).
-     *
-     * Use this for simple blocks that don't need version migrations.
-     * The version will be set to an internal default value.
-     *
-     * @typeParam S - The state type
-     * @param initialData - Factory function returning initial state
-     * @param version - Optional custom version key (defaults to internal version)
-     * @returns Finalized DataModel instance
-     *
-     * @example
-     * const dataModel = DataModel.create<BlockData>(() => ({
-     *   numbers: [],
-     *   labels: [],
-     * }));
-     */
-    static create(initialData, version = block_storage.DATA_MODEL_DEFAULT_VERSION) {
-        return new DataModel({
-            versionChain: [version],
-            steps: [],
-            initialDataFn: initialData,
-        });
-    }
     /**
      * Internal method for creating DataModel from builder.
      * Uses Symbol key to prevent external access.

package/dist/block_migrations.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_migrations.cjs","sources":["../src/block_migrations.ts"],"sourcesContent":["import { tryRegisterCallback } from './internal';\nimport { createBlockStorage, DATA_MODEL_DEFAULT_VERSION } from './block_storage';\n\nexport type DataVersionKey = string;\nexport type DataVersionMap = Record<string, unknown>;\nexport type DataMigrateFn<From, To> = (prev: Readonly<From>) => To;\nexport type DataCreateFn<T> = () => T;\nexport type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;\n\n/**\n * Helper to define version keys with literal type inference and runtime validation.\n * - Validates that all version values are unique\n * - Validates that no version value is empty\n * - Eliminates need for `as const` assertion\n *\n * @throws Error if duplicate or empty version values are found\n *\n * @example\n * const Version = defineDataVersions({\n *   Initial: 'v1',\n *   AddedLabels: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.Initial]: DataV1;\n *   [Version.AddedLabels]: DataV2;\n * };\n */\nexport function defineDataVersions<const T extends Record<string, string>>(versions: T): T {\n  const values = Object.values(versions) as (string & keyof T)[];\n  const keys = Object.keys(versions) as (keyof T)[];\n  const emptyKeys = keys.filter((key) => versions[key] === '');\n  if (emptyKeys.length > 0) {\n    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);\n  }\n  const unique = new Set(values);\n  if (unique.size !== values.length) {\n    const duplicates = values.filter((v, i) => values.indexOf(v) !== i);\n    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);\n  }\n  return versions;\n}\n\n/** Versioned data wrapper for persistence */\nexport type DataVersioned<T> = {\n  version: DataVersionKey;\n  data: T;\n};\n\n/** Create a DataVersioned wrapper with correct shape */\nexport function makeDataVersioned<T>(version: DataVersionKey, data: T): DataVersioned<T> {\n  return { version, data };\n}\n\n/** Result of migration operation, may include warning if migration failed */\nexport type DataMigrationResult<T> = DataVersioned<T> & {\n  warning?: string;\n};\n\n/** Thrown by recover() to signal unrecoverable data. */\nexport class DataUnrecoverableError extends Error {\n  name = 'DataUnrecoverableError';\n  constructor(dataVersion: DataVersionKey) {\n    super(`Unknown version '${dataVersion}'`);\n  }\n}\n\nexport function isDataUnrecoverableError(error: unknown): error is DataUnrecoverableError {\n  return error instanceof Error && error.name === 'DataUnrecoverableError';\n}\n\ntype MigrationStep = {\n  fromVersion: DataVersionKey;\n  toVersion: DataVersionKey;\n  migrate: (data: unknown) => unknown;\n};\n\n/**\n * Default recover function for unknown versions.\n * Use as fallback at the end of custom recover functions.\n *\n * @example\n * .recover((version, data) => {\n *   if (version === 'legacy') {\n *     return transformLegacyData(data);\n *   }\n *   return defaultRecover(version, data);\n * })\n */\nexport const defaultRecover: DataRecoverFn<never> = (version, _data) => {\n  throw new DataUnrecoverableError(version);\n};\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol('fromBuilder');\n\n/** Internal state passed from builder to DataModel */\ntype BuilderState<S> = {\n  versionChain: DataVersionKey[];\n  steps: MigrationStep[];\n  initialDataFn: () => S;\n  recoverFn?: DataRecoverFn<S>;\n};\n\n/**\n * Final builder state after recover() is called.\n * Only allows calling create() to finalize the DataModel.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current (final) version in the chain\n * @internal\n */\nclass DataModelBuilderWithRecover<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n  private readonly recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps,\n    recoverFn,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never ? [] : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n      recoverFn: this.recoverFn,\n    });\n  }\n}\n\n/**\n * Internal builder for constructing DataModel with type-safe migration chains.\n *\n * Tracks the current version through the generic type system, ensuring:\n * - Migration functions receive correctly typed input\n * - Migration functions must return the correct output type\n * - Version keys must exist in the VersionedData map\n * - All versions must be covered before calling init()\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current version in the migration chain\n * @typeParam RemainingVersions - Versions not yet covered by migrations\n * @internal\n */\nclass DataModelMigrationChain<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n  RemainingVersions extends keyof VersionedData & string = Exclude<keyof VersionedData & string, CurrentVersion>,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps = [],\n  }: {\n    versionChain: DataVersionKey[];\n    steps?: MigrationStep[];\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n  }\n\n  /**\n   * Add a migration step to transform data from current version to next version.\n   *\n   * Migration functions:\n   * - Receive data typed as the current version's data type (readonly)\n   * - Must return data matching the target version's data type\n   * - Should be pure functions (no side effects)\n   * - May throw errors (will result in data reset with warning)\n   *\n   * @typeParam NextVersion - The target version key (must be in RemainingVersions)\n   * @param nextVersion - The version key to migrate to\n   * @param fn - Migration function transforming current data to next version\n   * @returns Builder with updated current version\n   *\n   * @example\n   * .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n   */\n  migrate<NextVersion extends RemainingVersions>(\n    nextVersion: NextVersion,\n    fn: DataMigrateFn<VersionedData[CurrentVersion], VersionedData[NextVersion]>,\n  ): DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>> {\n    if (this.versionChain.includes(nextVersion)) {\n      throw new Error(`Duplicate version '${nextVersion}' in migration chain`);\n    }\n    const fromVersion = this.versionChain[this.versionChain.length - 1];\n    const step: MigrationStep = { fromVersion, toVersion: nextVersion, migrate: fn as (data: unknown) => unknown };\n    return new DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>>({\n      versionChain: [...this.versionChain, nextVersion],\n      steps: [...this.migrationSteps, step],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   *\n   * The recover function is called when data has a version not in the migration chain.\n   * It should either:\n   * - Transform the data to the current version's format and return it\n   * - Call `defaultRecover(version, data)` to signal unrecoverable data\n   *\n   * Can only be called once. After calling, only `init()` is available.\n   *\n   * @param fn - Recovery function that transforms unknown data or throws\n   * @returns Builder with only init() method available\n   *\n   * @example\n   * .recover((version, data) => {\n   *   if (version === 'legacy' && isLegacyFormat(data)) {\n   *     return transformLegacy(data);\n   *   }\n   *   return defaultRecover(version, data);\n   * })\n   */\n  recover(\n    fn: DataRecoverFn<VersionedData[CurrentVersion]>,\n  ): DataModelBuilderWithRecover<VersionedData, CurrentVersion> {\n    return new DataModelBuilderWithRecover<VersionedData, CurrentVersion>({\n      versionChain: [...this.versionChain],\n      steps: [...this.migrationSteps],\n      recoverFn: fn,\n    });\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * Can only be called when all versions in VersionedData have been covered\n   * by the migration chain (RemainingVersions is empty).\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    // Compile-time check: RemainingVersions must be empty (all versions covered)\n    this: DataModelMigrationChain<VersionedData, CurrentVersion, never>,\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never ? [] : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n    });\n  }\n}\n\n/**\n * Builder entry point for creating DataModel with type-safe migrations.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n *\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { count: number };\n *   [Version.V2]: { count: number; label: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, label: '' }))\n *   .init(() => ({ count: 0, label: '' }));\n */\nexport class DataModelBuilder<VersionedData extends DataVersionMap> {\n  /**\n   * Start a migration chain from an initial version.\n   *\n   * @typeParam InitialVersion - The starting version key (inferred from argument)\n   * @param initialVersion - The version key to start from\n   * @returns Migration chain builder for adding migrations\n   *\n   * @example\n   * new DataModelBuilder<VersionedData>()\n   *   .from(Version.V1)\n   *   .migrate(Version.V2, (data) => ({ ...data, newField: '' }))\n   */\n  from<InitialVersion extends keyof VersionedData & string>(\n    initialVersion: InitialVersion,\n  ): DataModelMigrationChain<VersionedData, InitialVersion, Exclude<keyof VersionedData & string, InitialVersion>> {\n    return new DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    >({ versionChain: [initialVersion] });\n  }\n}\n\n/**\n * DataModel defines the block's data structure, initial values, and migrations.\n * Used by BlockModelV3 to manage data state.\n *\n * Two ways to create a DataModel:\n *\n * 1. **Simple (no migrations)** - Use `DataModel.create()`:\n * @example\n * const dataModel = DataModel.create<BlockData>(() => ({\n *   numbers: [],\n *   labels: [],\n * }));\n *\n * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n *   V3: 'v3',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { numbers: number[] };\n *   [Version.V2]: { numbers: number[]; labels: string[] };\n *   [Version.V3]: { numbers: number[]; labels: string[]; description: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n *   .migrate(Version.V3, (data) => ({ ...data, description: '' }))\n *   .recover((version, data) => {\n *     if (version === 'legacy' && typeof data === 'object' && data !== null && 'numbers' in data) {\n *       return { numbers: (data as { numbers: number[] }).numbers, labels: [], description: '' };\n *     }\n *     return defaultRecover(version, data);\n *   })\n *   .init(() => ({ numbers: [], labels: [], description: '' }));\n */\nexport class DataModel<State> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly steps: MigrationStep[];\n  private readonly initialDataFn: () => State;\n  private readonly recoverFn: DataRecoverFn<State>;\n\n  private constructor({\n    versionChain,\n    steps,\n    initialDataFn,\n    recoverFn = defaultRecover as DataRecoverFn<State>,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    initialDataFn: () => State;\n    recoverFn?: DataRecoverFn<State>;\n  }) {\n    if (versionChain.length === 0) {\n      throw new Error('DataModel requires at least one version key');\n    }\n    this.versionChain = versionChain;\n    this.steps = steps;\n    this.initialDataFn = initialDataFn;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Create a DataModel with just initial data (no migrations).\n   *\n   * Use this for simple blocks that don't need version migrations.\n   * The version will be set to an internal default value.\n   *\n   * @typeParam S - The state type\n   * @param initialData - Factory function returning initial state\n   * @param version - Optional custom version key (defaults to internal version)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * const dataModel = DataModel.create<BlockData>(() => ({\n   *   numbers: [],\n   *   labels: [],\n   * }));\n   */\n  static create<S>(initialData: () => S, version: DataVersionKey = DATA_MODEL_DEFAULT_VERSION): DataModel<S> {\n    return new DataModel<S>({\n      versionChain: [version],\n      steps: [],\n      initialDataFn: initialData,\n    });\n  }\n\n  /**\n   * Internal method for creating DataModel from builder.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<S>(state: BuilderState<S>): DataModel<S> {\n    return new DataModel<S>(state);\n  }\n\n  /**\n   * The latest (current) version key in the migration chain.\n   */\n  get version(): DataVersionKey {\n    return this.versionChain[this.versionChain.length - 1];\n  }\n\n  /**\n   * Number of migration steps defined.\n   */\n  get migrationCount(): number {\n    return this.steps.length;\n  }\n\n  /**\n   * Get a fresh copy of the initial data.\n   */\n  initialData(): State {\n    return this.initialDataFn();\n  }\n\n  /**\n   * Get initial data wrapped with current version.\n   * Used when creating new blocks or resetting to defaults.\n   */\n  getDefaultData(): DataVersioned<State> {\n    return makeDataVersioned(this.version, this.initialDataFn());\n  }\n\n  private recoverFrom(data: unknown, version: DataVersionKey): DataMigrationResult<State> {\n    try {\n      return { version: this.version, data: this.recoverFn(version, data) };\n    } catch (error) {\n      if (isDataUnrecoverableError(error)) {\n        return { ...this.getDefaultData(), warning: error.message };\n      }\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      return {\n        ...this.getDefaultData(),\n        warning: `Recover failed for version '${version}': ${errorMessage}`,\n      };\n    }\n  }\n\n  /**\n   * Migrate versioned data from any version to the latest.\n   *\n   * - If data is already at latest version, returns as-is\n   * - If version is in chain, applies needed migrations\n   * - If version is unknown, calls recover function\n   * - If migration/recovery fails, returns default data with warning\n   *\n   * @param versioned - Data with version tag\n   * @returns Migration result with data at latest version\n   */\n  migrate(versioned: DataVersioned<unknown>): DataMigrationResult<State> {\n    const { version: fromVersion, data } = versioned;\n\n    if (fromVersion === this.version) {\n      return { version: this.version, data: data as State };\n    }\n\n    const startIndex = this.versionChain.indexOf(fromVersion);\n    if (startIndex < 0) {\n      return this.recoverFrom(data, fromVersion);\n    }\n\n    let currentData: unknown = data;\n    for (let i = startIndex; i < this.steps.length; i++) {\n      const step = this.steps[i];\n      try {\n        currentData = step.migrate(currentData);\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        return {\n          ...this.getDefaultData(),\n          warning: `Migration ${step.fromVersion}→${step.toVersion} failed: ${errorMessage}`,\n        };\n      }\n    }\n\n    return { version: this.version, data: currentData as State };\n  }\n\n  /**\n   * Register callbacks for use in the VM.\n   * Called by BlockModelV3.create() to set up internal callbacks.\n   *\n   * @internal\n   */\n  registerCallbacks(): void {\n    tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());\n    tryRegisterCallback('__pl_data_upgrade', (versioned: DataVersioned<unknown>) => this.migrate(versioned));\n    tryRegisterCallback('__pl_storage_initial', () => {\n      const { version, data } = this.getDefaultData();\n      const storage = createBlockStorage(data, version);\n      return JSON.stringify(storage);\n    });\n  }\n}\n"],"names":["DATA_MODEL_DEFAULT_VERSION","tryRegisterCallback","createBlockStorage"],"mappings":";;;;;AASA;;;;;;;;;;;;;;;;;;AAkBG;AACG,SAAU,kBAAkB,CAAyC,QAAW,EAAA;IACpF,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAyB;IAC9D,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAgB;AACjD,IAAA,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,KAAK,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;AAC5D,IAAA,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;AACxB,QAAA,MAAM,IAAI,KAAK,CAAC,CAAA,iDAAA,EAAoD,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAA,CAAG,CAAC;IAC9F;AACA,IAAA,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC;IAC9B,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,CAAC,MAAM,EAAE;QACjC,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC;AACnE,QAAA,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA,CAAE,CAAC;IACrF;AACA,IAAA,OAAO,QAAQ;AACjB;AAQA;AACM,SAAU,iBAAiB,CAAI,OAAuB,EAAE,IAAO,EAAA;AACnE,IAAA,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE;AAC1B;AAOA;AACM,MAAO,sBAAuB,SAAQ,KAAK,CAAA;IAC/C,IAAI,GAAG,wBAAwB;AAC/B,IAAA,WAAA,CAAY,WAA2B,EAAA;AACrC,QAAA,KAAK,CAAC,CAAA,iBAAA,EAAoB,WAAW,CAAA,CAAA,CAAG,CAAC;IAC3C;AACD;AAEK,SAAU,wBAAwB,CAAC,KAAc,EAAA;IACrD,OAAO,KAAK,YAAY,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,wBAAwB;AAC1E;AAQA;;;;;;;;;;;AAWG;MACU,cAAc,GAAyB,CAAC,OAAO,EAAE,KAAK,KAAI;AACrE,IAAA,MAAM,IAAI,sBAAsB,CAAC,OAAO,CAAC;AAC3C;AAEA;AACA,MAAM,YAAY,GAAG,MAAM,CAAC,aAAa,CAAC;AAU1C;;;;;;;AAOG;AACH,MAAM,2BAA2B,CAAA;AAId,IAAA,YAAY;AACZ,IAAA,cAAc;AACd,IAAA,SAAS;;AAG1B,IAAA,WAAA,CAAY,EACV,YAAY,EACZ,KAAK,EACL,SAAS,GAKV,EAAA;AACC,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY;AAChC,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;AAC3B,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;IAC5B;AAEA;;;;;;;;;;;AAWG;AACH,IAAA,IAAI,CACF,WAA4B;;AAE5B,IAAA,GAAG,YAAgG,EAAA;AAEnG,QAAA,OAAO,SAAS,CAAC,YAAY,CAAC,CAAgC;YAC5D,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,KAAK,EAAE,IAAI,CAAC,cAAc;AAC1B,YAAA,aAAa,EAAE,WAA0D;YACzE,SAAS,EAAE,IAAI,CAAC,SAAS;AAC1B,SAAA,CAAC;IACJ;AACD;AAED;;;;;;;;;;;;;AAaG;AACH,MAAM,uBAAuB,CAAA;AAKV,IAAA,YAAY;AACZ,IAAA,cAAc;;AAG/B,IAAA,WAAA,CAAY,EACV,YAAY,EACZ,KAAK,GAAG,EAAE,GAIX,EAAA;AACC,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY;AAChC,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;IAC7B;AAEA;;;;;;;;;;;;;;;;AAgBG;IACH,OAAO,CACL,WAAwB,EACxB,EAA4E,EAAA;QAE5E,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;AAC3C,YAAA,MAAM,IAAI,KAAK,CAAC,sBAAsB,WAAW,CAAA,oBAAA,CAAsB,CAAC;QAC1E;AACA,QAAA,MAAM,WAAW,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;AACnE,QAAA,MAAM,IAAI,GAAkB,EAAE,WAAW,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,EAAgC,EAAE;QAC9G,OAAO,IAAI,uBAAuB,CAAsE;YACtG,YAAY,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC;YACjD,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC;AACtC,SAAA,CAAC;IACJ;AAEA;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,IAAA,OAAO,CACL,EAAgD,EAAA;QAEhD,OAAO,IAAI,2BAA2B,CAAgC;AACpE,YAAA,YAAY,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC;AACpC,YAAA,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC;AAC/B,YAAA,SAAS,EAAE,EAAE;AACd,SAAA,CAAC;IACJ;AAEA;;;;;;;;;;;;;;AAcG;AACH,IAAA,IAAI,CAGF,WAA4B;;AAE5B,IAAA,GAAG,YAAgG,EAAA;AAEnG,QAAA,OAAO,SAAS,CAAC,YAAY,CAAC,CAAgC;YAC5D,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,KAAK,EAAE,IAAI,CAAC,cAAc;AAC1B,YAAA,aAAa,EAAE,WAA0D;AAC1E,SAAA,CAAC;IACJ;AACD;AAED;;;;;;;;;;;;;;;;;;;;AAoBG;MACU,gBAAgB,CAAA;AAC3B;;;;;;;;;;;AAWG;AACH,IAAA,IAAI,CACF,cAA8B,EAAA;QAE9B,OAAO,IAAI,uBAAuB,CAIhC,EAAE,YAAY,EAAE,CAAC,cAAc,CAAC,EAAE,CAAC;IACvC;AACD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCG;MACU,SAAS,CAAA;AACH,IAAA,YAAY;AACZ,IAAA,KAAK;AACL,IAAA,aAAa;AACb,IAAA,SAAS;IAE1B,WAAA,CAAoB,EAClB,YAAY,EACZ,KAAK,EACL,aAAa,EACb,SAAS,GAAG,cAAsC,GAMnD,EAAA;AACC,QAAA,IAAI,YAAY,CAAC,MAAM,KAAK,CAAC,EAAE;AAC7B,YAAA,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC;QAChE;AACA,QAAA,IAAI,CAAC,YAAY,GAAG,YAAY;AAChC,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;AAClB,QAAA,IAAI,CAAC,aAAa,GAAG,aAAa;AAClC,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;IAC5B;AAEA;;;;;;;;;;;;;;;;AAgBG;AACH,IAAA,OAAO,MAAM,CAAI,WAAoB,EAAE,UAA0BA,wCAA0B,EAAA;QACzF,OAAO,IAAI,SAAS,CAAI;YACtB,YAAY,EAAE,CAAC,OAAO,CAAC;AACvB,YAAA,KAAK,EAAE,EAAE;AACT,YAAA,aAAa,EAAE,WAAW;AAC3B,SAAA,CAAC;IACJ;AAEA;;;;AAIG;AACH,IAAA,QAAQ,YAAY,CAAC,CAAI,KAAsB,EAAA;AAC7C,QAAA,OAAO,IAAI,SAAS,CAAI,KAAK,CAAC;IAChC;AAEA;;AAEG;AACH,IAAA,IAAI,OAAO,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,CAAC;IACxD;AAEA;;AAEG;AACH,IAAA,IAAI,cAAc,GAAA;AAChB,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM;IAC1B;AAEA;;AAEG;IACH,WAAW,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,aAAa,EAAE;IAC7B;AAEA;;;AAGG;IACH,cAAc,GAAA;QACZ,OAAO,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC;IAC9D;IAEQ,WAAW,CAAC,IAAa,EAAE,OAAuB,EAAA;AACxD,QAAA,IAAI;AACF,YAAA,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE;QACvE;QAAE,OAAO,KAAK,EAAE;AACd,YAAA,IAAI,wBAAwB,CAAC,KAAK,CAAC,EAAE;AACnC,gBAAA,OAAO,EAAE,GAAG,IAAI,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE;YAC7D;AACA,YAAA,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;YAC3E,OAAO;gBACL,GAAG,IAAI,CAAC,cAAc,EAAE;AACxB,gBAAA,OAAO,EAAE,CAAA,4BAAA,EAA+B,OAAO,CAAA,GAAA,EAAM,YAAY,CAAA,CAAE;aACpE;QACH;IACF;AAEA;;;;;;;;;;AAUG;AACH,IAAA,OAAO,CAAC,SAAiC,EAAA;QACvC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,SAAS;AAEhD,QAAA,IAAI,WAAW,KAAK,IAAI,CAAC,OAAO,EAAE;YAChC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAa,EAAE;QACvD;QAEA,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,WAAW,CAAC;AACzD,QAAA,IAAI,UAAU,GAAG,CAAC,EAAE;YAClB,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC;QAC5C;QAEA,IAAI,WAAW,GAAY,IAAI;AAC/B,QAAA,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YACnD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;AAC1B,YAAA,IAAI;AACF,gBAAA,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC;YACzC;YAAE,OAAO,KAAK,EAAE;AACd,gBAAA,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,GAAG,KAAK,CAAC,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC;gBAC3E,OAAO;oBACL,GAAG,IAAI,CAAC,cAAc,EAAE;oBACxB,OAAO,EAAE,CAAA,UAAA,EAAa,IAAI,CAAC,WAAW,CAAA,CAAA,EAAI,IAAI,CAAC,SAAS,CAAA,SAAA,EAAY,YAAY,CAAA,CAAE;iBACnF;YACH;QACF;QAEA,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,WAAoB,EAAE;IAC9D;AAEA;;;;;AAKG;IACH,iBAAiB,GAAA;QACfC,4BAAmB,CAAC,mBAAmB,EAAE,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;AACpE,QAAAA,4BAAmB,CAAC,mBAAmB,EAAE,CAAC,SAAiC,KAAK,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AACxG,QAAAA,4BAAmB,CAAC,sBAAsB,EAAE,MAAK;YAC/C,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,cAAc,EAAE;YAC/C,MAAM,OAAO,GAAGC,gCAAkB,CAAC,IAAI,EAAE,OAAO,CAAC;AACjD,YAAA,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;AAChC,QAAA,CAAC,CAAC;IACJ;AACD;;;;;;;;;;"}
+{"version":3,"file":"block_migrations.cjs","sources":["../src/block_migrations.ts"],"sourcesContent":["import { tryRegisterCallback } from './internal';\nimport { createBlockStorage } from './block_storage';\n\nexport type DataVersionKey = string;\nexport type DataVersionMap = Record<string, unknown>;\nexport type DataMigrateFn<From, To> = (prev: Readonly<From>) => To;\nexport type DataCreateFn<T> = () => T;\nexport type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;\n\n/**\n * Helper to define version keys with literal type inference and runtime validation.\n * - Validates that all version values are unique\n * - Validates that no version value is empty\n * - Eliminates need for `as const` assertion\n *\n * @throws Error if duplicate or empty version values are found\n *\n * @example\n * const Version = defineDataVersions({\n *   Initial: 'v1',\n *   AddedLabels: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.Initial]: DataV1;\n *   [Version.AddedLabels]: DataV2;\n * };\n */\nexport function defineDataVersions<const T extends Record<string, string>>(versions: T): T {\n  const values = Object.values(versions) as (string & keyof T)[];\n  const keys = Object.keys(versions) as (keyof T)[];\n  const emptyKeys = keys.filter((key) => versions[key] === '');\n  if (emptyKeys.length > 0) {\n    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);\n  }\n  const unique = new Set(values);\n  if (unique.size !== values.length) {\n    const duplicates = values.filter((v, i) => values.indexOf(v) !== i);\n    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);\n  }\n  return versions;\n}\n\n/** Versioned data wrapper for persistence */\nexport type DataVersioned<T> = {\n  version: DataVersionKey;\n  data: T;\n};\n\n/** Create a DataVersioned wrapper with correct shape */\nexport function makeDataVersioned<T>(version: DataVersionKey, data: T): DataVersioned<T> {\n  return { version, data };\n}\n\n/** Result of migration operation, may include warning if migration failed */\nexport type DataMigrationResult<T> = DataVersioned<T> & {\n  warning?: string;\n};\n\n/** Thrown by recover() to signal unrecoverable data. */\nexport class DataUnrecoverableError extends Error {\n  name = 'DataUnrecoverableError';\n  constructor(dataVersion: DataVersionKey) {\n    super(`Unknown version '${dataVersion}'`);\n  }\n}\n\nexport function isDataUnrecoverableError(error: unknown): error is DataUnrecoverableError {\n  return error instanceof Error && error.name === 'DataUnrecoverableError';\n}\n\ntype MigrationStep = {\n  fromVersion: DataVersionKey;\n  toVersion: DataVersionKey;\n  migrate: (data: unknown) => unknown;\n};\n\n/**\n * Default recover function for unknown versions.\n * Use as fallback at the end of custom recover functions.\n *\n * @example\n * .recover((version, data) => {\n *   if (version === 'legacy') {\n *     return transformLegacyData(data);\n *   }\n *   return defaultRecover(version, data);\n * })\n */\nexport const defaultRecover: DataRecoverFn<never> = (version, _data) => {\n  throw new DataUnrecoverableError(version);\n};\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol('fromBuilder');\n\n/** Internal state passed from builder to DataModel */\ntype BuilderState<S> = {\n  versionChain: DataVersionKey[];\n  steps: MigrationStep[];\n  initialDataFn: () => S;\n  recoverFn?: DataRecoverFn<S>;\n};\n\n/**\n * Final builder state after recover() is called.\n * Only allows calling create() to finalize the DataModel.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current (final) version in the chain\n * @internal\n */\nclass DataModelBuilderWithRecover<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n  private readonly recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps,\n    recoverFn,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never\n      ? []\n      : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n      recoverFn: this.recoverFn,\n    });\n  }\n}\n\n/**\n * Internal builder for constructing DataModel with type-safe migration chains.\n *\n * Tracks the current version through the generic type system, ensuring:\n * - Migration functions receive correctly typed input\n * - Migration functions must return the correct output type\n * - Version keys must exist in the VersionedData map\n * - All versions must be covered before calling init()\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current version in the migration chain\n * @typeParam RemainingVersions - Versions not yet covered by migrations\n * @internal\n */\nclass DataModelMigrationChain<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n  RemainingVersions extends keyof VersionedData & string = Exclude<\n    keyof VersionedData & string,\n    CurrentVersion\n  >,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps = [],\n  }: {\n    versionChain: DataVersionKey[];\n    steps?: MigrationStep[];\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n  }\n\n  /**\n   * Add a migration step to transform data from current version to next version.\n   *\n   * Migration functions:\n   * - Receive data typed as the current version's data type (readonly)\n   * - Must return data matching the target version's data type\n   * - Should be pure functions (no side effects)\n   * - May throw errors (will result in data reset with warning)\n   *\n   * @typeParam NextVersion - The target version key (must be in RemainingVersions)\n   * @param nextVersion - The version key to migrate to\n   * @param fn - Migration function transforming current data to next version\n   * @returns Builder with updated current version\n   *\n   * @example\n   * .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n   */\n  migrate<NextVersion extends RemainingVersions>(\n    nextVersion: NextVersion,\n    fn: DataMigrateFn<VersionedData[CurrentVersion], VersionedData[NextVersion]>,\n  ): DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>> {\n    if (this.versionChain.includes(nextVersion)) {\n      throw new Error(`Duplicate version '${nextVersion}' in migration chain`);\n    }\n    const fromVersion = this.versionChain[this.versionChain.length - 1];\n    const step: MigrationStep = {\n      fromVersion,\n      toVersion: nextVersion,\n      migrate: fn as (data: unknown) => unknown,\n    };\n    return new DataModelMigrationChain<\n      VersionedData,\n      NextVersion,\n      Exclude<RemainingVersions, NextVersion>\n    >({\n      versionChain: [...this.versionChain, nextVersion],\n      steps: [...this.migrationSteps, step],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   *\n   * The recover function is called when data has a version not in the migration chain.\n   * It should either:\n   * - Transform the data to the current version's format and return it\n   * - Call `defaultRecover(version, data)` to signal unrecoverable data\n   *\n   * Can only be called once. After calling, only `init()` is available.\n   *\n   * @param fn - Recovery function that transforms unknown data or throws\n   * @returns Builder with only init() method available\n   *\n   * @example\n   * .recover((version, data) => {\n   *   if (version === 'legacy' && isLegacyFormat(data)) {\n   *     return transformLegacy(data);\n   *   }\n   *   return defaultRecover(version, data);\n   * })\n   */\n  recover(\n    fn: DataRecoverFn<VersionedData[CurrentVersion]>,\n  ): DataModelBuilderWithRecover<VersionedData, CurrentVersion> {\n    return new DataModelBuilderWithRecover<VersionedData, CurrentVersion>({\n      versionChain: [...this.versionChain],\n      steps: [...this.migrationSteps],\n      recoverFn: fn,\n    });\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * Can only be called when all versions in VersionedData have been covered\n   * by the migration chain (RemainingVersions is empty).\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    // Compile-time check: RemainingVersions must be empty (all versions covered)\n    this: DataModelMigrationChain<VersionedData, CurrentVersion, never>,\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never\n      ? []\n      : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n    });\n  }\n}\n\n/**\n * Builder entry point for creating DataModel with type-safe migrations.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n *\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { count: number };\n *   [Version.V2]: { count: number; label: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, label: '' }))\n *   .init(() => ({ count: 0, label: '' }));\n */\nexport class DataModelBuilder<VersionedData extends DataVersionMap> {\n  /**\n   * Start a migration chain from an initial version.\n   *\n   * @typeParam InitialVersion - The starting version key (inferred from argument)\n   * @param initialVersion - The version key to start from\n   * @returns Migration chain builder for adding migrations\n   *\n   * @example\n   * new DataModelBuilder<VersionedData>()\n   *   .from(Version.V1)\n   *   .migrate(Version.V2, (data) => ({ ...data, newField: '' }))\n   */\n  from<InitialVersion extends keyof VersionedData & string>(\n    initialVersion: InitialVersion,\n  ): DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    > {\n    return new DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    >({ versionChain: [initialVersion] });\n  }\n}\n\n/**\n * DataModel defines the block's data structure, initial values, and migrations.\n * Used by BlockModelV3 to manage data state.\n *\n * Use `new DataModelBuilder<VersionedData>()` to create a DataModel:\n *\n * **Simple (no migrations):**\n * @example\n * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });\n * type VersionedData = { [Version.V1]: BlockData };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .init(() => ({ numbers: [], labels: [] }));\n *\n * **With migrations:**\n * @example\n * const Version = defineDataVersions({\n *   V1: DATA_MODEL_DEFAULT_VERSION,\n *   V2: 'v2',\n *   V3: 'v3',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { numbers: number[] };\n *   [Version.V2]: { numbers: number[]; labels: string[] };\n *   [Version.V3]: { numbers: number[]; labels: string[]; description: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n *   .migrate(Version.V3, (data) => ({ ...data, description: '' }))\n *   .recover((version, data) => {\n *     if (version === 'legacy' && typeof data === 'object' && data !== null && 'numbers' in data) {\n *       return { numbers: (data as { numbers: number[] }).numbers, labels: [], description: '' };\n *     }\n *     return defaultRecover(version, data);\n *   })\n *   .init(() => ({ numbers: [], labels: [], description: '' }));\n */\nexport class DataModel<State> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly steps: MigrationStep[];\n  private readonly initialDataFn: () => State;\n  private readonly recoverFn: DataRecoverFn<State>;\n\n  private constructor({\n    versionChain,\n    steps,\n    initialDataFn,\n    recoverFn = defaultRecover as DataRecoverFn<State>,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    initialDataFn: () => State;\n    recoverFn?: DataRecoverFn<State>;\n  }) {\n    if (versionChain.length === 0) {\n      throw new Error('DataModel requires at least one version key');\n    }\n    this.versionChain = versionChain;\n    this.steps = steps;\n    this.initialDataFn = initialDataFn;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Internal method for creating DataModel from builder.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<S>(state: BuilderState<S>): DataModel<S> {\n    return new DataModel<S>(state);\n  }\n\n  /**\n   * The latest (current) version key in the migration chain.\n   */\n  get version(): DataVersionKey {\n    return this.versionChain[this.versionChain.length - 1];\n  }\n\n  /**\n   * Number of migration steps defined.\n   */\n  get migrationCount(): number {\n    return this.steps.length;\n  }\n\n  /**\n   * Get a fresh copy of the initial data.\n   */\n  initialData(): State {\n    return this.initialDataFn();\n  }\n\n  /**\n   * Get initial data wrapped with current version.\n   * Used when creating new blocks or resetting to defaults.\n   */\n  getDefaultData(): DataVersioned<State> {\n    return makeDataVersioned(this.version, this.initialDataFn());\n  }\n\n  private recoverFrom(data: unknown, version: DataVersionKey): DataMigrationResult<State> {\n    try {\n      return { version: this.version, data: this.recoverFn(version, data) };\n    } catch (error) {\n      if (isDataUnrecoverableError(error)) {\n        return { ...this.getDefaultData(), warning: error.message };\n      }\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      return {\n        ...this.getDefaultData(),\n        warning: `Recover failed for version '${version}': ${errorMessage}`,\n      };\n    }\n  }\n\n  /**\n   * Migrate versioned data from any version to the latest.\n   *\n   * - If data is already at latest version, returns as-is\n   * - If version is in chain, applies needed migrations\n   * - If version is unknown, calls recover function\n   * - If migration/recovery fails, returns default data with warning\n   *\n   * @param versioned - Data with version tag\n   * @returns Migration result with data at latest version\n   */\n  migrate(versioned: DataVersioned<unknown>): DataMigrationResult<State> {\n    const { version: fromVersion, data } = versioned;\n\n    if (fromVersion === this.version) {\n      return { version: this.version, data: data as State };\n    }\n\n    const startIndex = this.versionChain.indexOf(fromVersion);\n    if (startIndex < 0) {\n      return this.recoverFrom(data, fromVersion);\n    }\n\n    let currentData: unknown = data;\n    for (let i = startIndex; i < this.steps.length; i++) {\n      const step = this.steps[i];\n      try {\n        currentData = step.migrate(currentData);\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        return {\n          ...this.getDefaultData(),\n          warning: `Migration ${step.fromVersion}→${step.toVersion} failed: ${errorMessage}`,\n        };\n      }\n    }\n\n    return { version: this.version, data: currentData as State };\n  }\n\n  /**\n   * Register callbacks for use in the VM.\n   * Called by BlockModelV3.create() to set up internal callbacks.\n   *\n   * @internal\n   */\n  registerCallbacks(): void {\n    tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());\n    tryRegisterCallback('__pl_data_upgrade', (versioned: DataVersioned<unknown>) =>\n      this.migrate(versioned),\n    );\n    tryRegisterCallback('__pl_storage_initial', () => {\n      const { version, data } = this.getDefaultData();\n      const storage = createBlockStorage(data, version);\n      return JSON.stringify(storage);\n    });\n  }\n}\n"],"names":["tryRegisterCallback","createBlockStorage"],"mappings":"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"}

package/dist/block_migrations.d.ts

@@ -218,19 +218,21 @@ export declare class DataModelBuilder<VersionedData extends DataVersionMap> {
  * DataModel defines the block's data structure, initial values, and migrations.
  * Used by BlockModelV3 to manage data state.
  *
- * Two ways to create a DataModel:
+ * Use `new DataModelBuilder<VersionedData>()` to create a DataModel:
  *
- * 1. **Simple (no migrations)** - Use `DataModel.create()`:
+ * **Simple (no migrations):**
  * @example
- * const dataModel = DataModel.create<BlockData>(() => ({
- *   numbers: [],
- *   labels: [],
- * }));
+ * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });
+ * type VersionedData = { [Version.V1]: BlockData };
  *
- * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:
+ * const dataModel = new DataModelBuilder<VersionedData>()
+ *   .from(Version.V1)
+ *   .init(() => ({ numbers: [], labels: [] }));
+ *
+ * **With migrations:**
  * @example
  * const Version = defineDataVersions({
- *   V1: 'v1',
+ *   V1: DATA_MODEL_DEFAULT_VERSION,
  *   V2: 'v2',
  *   V3: 'v3',
  * });
@@ -259,24 +261,6 @@ export declare class DataModel<State> {
     private readonly initialDataFn;
     private readonly recoverFn;
     private constructor();
-    /**
-     * Create a DataModel with just initial data (no migrations).
-     *
-     * Use this for simple blocks that don't need version migrations.
-     * The version will be set to an internal default value.
-     *
-     * @typeParam S - The state type
-     * @param initialData - Factory function returning initial state
-     * @param version - Optional custom version key (defaults to internal version)
-     * @returns Finalized DataModel instance
-     *
-     * @example
-     * const dataModel = DataModel.create<BlockData>(() => ({
-     *   numbers: [],
-     *   labels: [],
-     * }));
-     */
-    static create<S>(initialData: () => S, version?: DataVersionKey): DataModel<S>;
     /**
      * Internal method for creating DataModel from builder.
      * Uses Symbol key to prevent external access.

package/dist/block_migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block_migrations.d.ts","sourceRoot":"","sources":["../src/block_migrations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"block_migrations.d.ts","sourceRoot":"","sources":["../src/block_migrations.ts"],"names":[],"mappings":"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"}

package/dist/block_migrations.js

@@ -1,5 +1,5 @@
 import { tryRegisterCallback } from './internal.js';
-import { DATA_MODEL_DEFAULT_VERSION, createBlockStorage } from './block_storage.js';
+import { createBlockStorage } from './block_storage.js';
 
 /**
  * Helper to define version keys with literal type inference and runtime validation.
@@ -150,7 +150,11 @@ class DataModelMigrationChain {
             throw new Error(`Duplicate version '${nextVersion}' in migration chain`);
         }
         const fromVersion = this.versionChain[this.versionChain.length - 1];
-        const step = { fromVersion, toVersion: nextVersion, migrate: fn };
+        const step = {
+            fromVersion,
+            toVersion: nextVersion,
+            migrate: fn,
+        };
         return new DataModelMigrationChain({
             versionChain: [...this.versionChain, nextVersion],
             steps: [...this.migrationSteps, step],
@@ -251,19 +255,21 @@ class DataModelBuilder {
  * DataModel defines the block's data structure, initial values, and migrations.
  * Used by BlockModelV3 to manage data state.
  *
- * Two ways to create a DataModel:
+ * Use `new DataModelBuilder<VersionedData>()` to create a DataModel:
  *
- * 1. **Simple (no migrations)** - Use `DataModel.create()`:
+ * **Simple (no migrations):**
  * @example
- * const dataModel = DataModel.create<BlockData>(() => ({
- *   numbers: [],
- *   labels: [],
- * }));
+ * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });
+ * type VersionedData = { [Version.V1]: BlockData };
  *
- * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:
+ * const dataModel = new DataModelBuilder<VersionedData>()
+ *   .from(Version.V1)
+ *   .init(() => ({ numbers: [], labels: [] }));
+ *
+ * **With migrations:**
  * @example
  * const Version = defineDataVersions({
- *   V1: 'v1',
+ *   V1: DATA_MODEL_DEFAULT_VERSION,
  *   V2: 'v2',
  *   V3: 'v3',
  * });
@@ -300,30 +306,6 @@ class DataModel {
         this.initialDataFn = initialDataFn;
         this.recoverFn = recoverFn;
     }
-    /**
-     * Create a DataModel with just initial data (no migrations).
-     *
-     * Use this for simple blocks that don't need version migrations.
-     * The version will be set to an internal default value.
-     *
-     * @typeParam S - The state type
-     * @param initialData - Factory function returning initial state
-     * @param version - Optional custom version key (defaults to internal version)
-     * @returns Finalized DataModel instance
-     *
-     * @example
-     * const dataModel = DataModel.create<BlockData>(() => ({
-     *   numbers: [],
-     *   labels: [],
-     * }));
-     */
-    static create(initialData, version = DATA_MODEL_DEFAULT_VERSION) {
-        return new DataModel({
-            versionChain: [version],
-            steps: [],
-            initialDataFn: initialData,
-        });
-    }
     /**
      * Internal method for creating DataModel from builder.
      * Uses Symbol key to prevent external access.

package/dist/block_migrations.js.map

@@ -1 +1 @@
-{"version":3,"file":"block_migrations.js","sources":["../src/block_migrations.ts"],"sourcesContent":["import { tryRegisterCallback } from './internal';\nimport { createBlockStorage, DATA_MODEL_DEFAULT_VERSION } from './block_storage';\n\nexport type DataVersionKey = string;\nexport type DataVersionMap = Record<string, unknown>;\nexport type DataMigrateFn<From, To> = (prev: Readonly<From>) => To;\nexport type DataCreateFn<T> = () => T;\nexport type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;\n\n/**\n * Helper to define version keys with literal type inference and runtime validation.\n * - Validates that all version values are unique\n * - Validates that no version value is empty\n * - Eliminates need for `as const` assertion\n *\n * @throws Error if duplicate or empty version values are found\n *\n * @example\n * const Version = defineDataVersions({\n *   Initial: 'v1',\n *   AddedLabels: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.Initial]: DataV1;\n *   [Version.AddedLabels]: DataV2;\n * };\n */\nexport function defineDataVersions<const T extends Record<string, string>>(versions: T): T {\n  const values = Object.values(versions) as (string & keyof T)[];\n  const keys = Object.keys(versions) as (keyof T)[];\n  const emptyKeys = keys.filter((key) => versions[key] === '');\n  if (emptyKeys.length > 0) {\n    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);\n  }\n  const unique = new Set(values);\n  if (unique.size !== values.length) {\n    const duplicates = values.filter((v, i) => values.indexOf(v) !== i);\n    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);\n  }\n  return versions;\n}\n\n/** Versioned data wrapper for persistence */\nexport type DataVersioned<T> = {\n  version: DataVersionKey;\n  data: T;\n};\n\n/** Create a DataVersioned wrapper with correct shape */\nexport function makeDataVersioned<T>(version: DataVersionKey, data: T): DataVersioned<T> {\n  return { version, data };\n}\n\n/** Result of migration operation, may include warning if migration failed */\nexport type DataMigrationResult<T> = DataVersioned<T> & {\n  warning?: string;\n};\n\n/** Thrown by recover() to signal unrecoverable data. */\nexport class DataUnrecoverableError extends Error {\n  name = 'DataUnrecoverableError';\n  constructor(dataVersion: DataVersionKey) {\n    super(`Unknown version '${dataVersion}'`);\n  }\n}\n\nexport function isDataUnrecoverableError(error: unknown): error is DataUnrecoverableError {\n  return error instanceof Error && error.name === 'DataUnrecoverableError';\n}\n\ntype MigrationStep = {\n  fromVersion: DataVersionKey;\n  toVersion: DataVersionKey;\n  migrate: (data: unknown) => unknown;\n};\n\n/**\n * Default recover function for unknown versions.\n * Use as fallback at the end of custom recover functions.\n *\n * @example\n * .recover((version, data) => {\n *   if (version === 'legacy') {\n *     return transformLegacyData(data);\n *   }\n *   return defaultRecover(version, data);\n * })\n */\nexport const defaultRecover: DataRecoverFn<never> = (version, _data) => {\n  throw new DataUnrecoverableError(version);\n};\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol('fromBuilder');\n\n/** Internal state passed from builder to DataModel */\ntype BuilderState<S> = {\n  versionChain: DataVersionKey[];\n  steps: MigrationStep[];\n  initialDataFn: () => S;\n  recoverFn?: DataRecoverFn<S>;\n};\n\n/**\n * Final builder state after recover() is called.\n * Only allows calling create() to finalize the DataModel.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current (final) version in the chain\n * @internal\n */\nclass DataModelBuilderWithRecover<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n  private readonly recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps,\n    recoverFn,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never ? [] : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n      recoverFn: this.recoverFn,\n    });\n  }\n}\n\n/**\n * Internal builder for constructing DataModel with type-safe migration chains.\n *\n * Tracks the current version through the generic type system, ensuring:\n * - Migration functions receive correctly typed input\n * - Migration functions must return the correct output type\n * - Version keys must exist in the VersionedData map\n * - All versions must be covered before calling init()\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current version in the migration chain\n * @typeParam RemainingVersions - Versions not yet covered by migrations\n * @internal\n */\nclass DataModelMigrationChain<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n  RemainingVersions extends keyof VersionedData & string = Exclude<keyof VersionedData & string, CurrentVersion>,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps = [],\n  }: {\n    versionChain: DataVersionKey[];\n    steps?: MigrationStep[];\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n  }\n\n  /**\n   * Add a migration step to transform data from current version to next version.\n   *\n   * Migration functions:\n   * - Receive data typed as the current version's data type (readonly)\n   * - Must return data matching the target version's data type\n   * - Should be pure functions (no side effects)\n   * - May throw errors (will result in data reset with warning)\n   *\n   * @typeParam NextVersion - The target version key (must be in RemainingVersions)\n   * @param nextVersion - The version key to migrate to\n   * @param fn - Migration function transforming current data to next version\n   * @returns Builder with updated current version\n   *\n   * @example\n   * .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n   */\n  migrate<NextVersion extends RemainingVersions>(\n    nextVersion: NextVersion,\n    fn: DataMigrateFn<VersionedData[CurrentVersion], VersionedData[NextVersion]>,\n  ): DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>> {\n    if (this.versionChain.includes(nextVersion)) {\n      throw new Error(`Duplicate version '${nextVersion}' in migration chain`);\n    }\n    const fromVersion = this.versionChain[this.versionChain.length - 1];\n    const step: MigrationStep = { fromVersion, toVersion: nextVersion, migrate: fn as (data: unknown) => unknown };\n    return new DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>>({\n      versionChain: [...this.versionChain, nextVersion],\n      steps: [...this.migrationSteps, step],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   *\n   * The recover function is called when data has a version not in the migration chain.\n   * It should either:\n   * - Transform the data to the current version's format and return it\n   * - Call `defaultRecover(version, data)` to signal unrecoverable data\n   *\n   * Can only be called once. After calling, only `init()` is available.\n   *\n   * @param fn - Recovery function that transforms unknown data or throws\n   * @returns Builder with only init() method available\n   *\n   * @example\n   * .recover((version, data) => {\n   *   if (version === 'legacy' && isLegacyFormat(data)) {\n   *     return transformLegacy(data);\n   *   }\n   *   return defaultRecover(version, data);\n   * })\n   */\n  recover(\n    fn: DataRecoverFn<VersionedData[CurrentVersion]>,\n  ): DataModelBuilderWithRecover<VersionedData, CurrentVersion> {\n    return new DataModelBuilderWithRecover<VersionedData, CurrentVersion>({\n      versionChain: [...this.versionChain],\n      steps: [...this.migrationSteps],\n      recoverFn: fn,\n    });\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * Can only be called when all versions in VersionedData have been covered\n   * by the migration chain (RemainingVersions is empty).\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    // Compile-time check: RemainingVersions must be empty (all versions covered)\n    this: DataModelMigrationChain<VersionedData, CurrentVersion, never>,\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never ? [] : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n    });\n  }\n}\n\n/**\n * Builder entry point for creating DataModel with type-safe migrations.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n *\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { count: number };\n *   [Version.V2]: { count: number; label: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, label: '' }))\n *   .init(() => ({ count: 0, label: '' }));\n */\nexport class DataModelBuilder<VersionedData extends DataVersionMap> {\n  /**\n   * Start a migration chain from an initial version.\n   *\n   * @typeParam InitialVersion - The starting version key (inferred from argument)\n   * @param initialVersion - The version key to start from\n   * @returns Migration chain builder for adding migrations\n   *\n   * @example\n   * new DataModelBuilder<VersionedData>()\n   *   .from(Version.V1)\n   *   .migrate(Version.V2, (data) => ({ ...data, newField: '' }))\n   */\n  from<InitialVersion extends keyof VersionedData & string>(\n    initialVersion: InitialVersion,\n  ): DataModelMigrationChain<VersionedData, InitialVersion, Exclude<keyof VersionedData & string, InitialVersion>> {\n    return new DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    >({ versionChain: [initialVersion] });\n  }\n}\n\n/**\n * DataModel defines the block's data structure, initial values, and migrations.\n * Used by BlockModelV3 to manage data state.\n *\n * Two ways to create a DataModel:\n *\n * 1. **Simple (no migrations)** - Use `DataModel.create()`:\n * @example\n * const dataModel = DataModel.create<BlockData>(() => ({\n *   numbers: [],\n *   labels: [],\n * }));\n *\n * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n *   V3: 'v3',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { numbers: number[] };\n *   [Version.V2]: { numbers: number[]; labels: string[] };\n *   [Version.V3]: { numbers: number[]; labels: string[]; description: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n *   .migrate(Version.V3, (data) => ({ ...data, description: '' }))\n *   .recover((version, data) => {\n *     if (version === 'legacy' && typeof data === 'object' && data !== null && 'numbers' in data) {\n *       return { numbers: (data as { numbers: number[] }).numbers, labels: [], description: '' };\n *     }\n *     return defaultRecover(version, data);\n *   })\n *   .init(() => ({ numbers: [], labels: [], description: '' }));\n */\nexport class DataModel<State> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly steps: MigrationStep[];\n  private readonly initialDataFn: () => State;\n  private readonly recoverFn: DataRecoverFn<State>;\n\n  private constructor({\n    versionChain,\n    steps,\n    initialDataFn,\n    recoverFn = defaultRecover as DataRecoverFn<State>,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    initialDataFn: () => State;\n    recoverFn?: DataRecoverFn<State>;\n  }) {\n    if (versionChain.length === 0) {\n      throw new Error('DataModel requires at least one version key');\n    }\n    this.versionChain = versionChain;\n    this.steps = steps;\n    this.initialDataFn = initialDataFn;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Create a DataModel with just initial data (no migrations).\n   *\n   * Use this for simple blocks that don't need version migrations.\n   * The version will be set to an internal default value.\n   *\n   * @typeParam S - The state type\n   * @param initialData - Factory function returning initial state\n   * @param version - Optional custom version key (defaults to internal version)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * const dataModel = DataModel.create<BlockData>(() => ({\n   *   numbers: [],\n   *   labels: [],\n   * }));\n   */\n  static create<S>(initialData: () => S, version: DataVersionKey = DATA_MODEL_DEFAULT_VERSION): DataModel<S> {\n    return new DataModel<S>({\n      versionChain: [version],\n      steps: [],\n      initialDataFn: initialData,\n    });\n  }\n\n  /**\n   * Internal method for creating DataModel from builder.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<S>(state: BuilderState<S>): DataModel<S> {\n    return new DataModel<S>(state);\n  }\n\n  /**\n   * The latest (current) version key in the migration chain.\n   */\n  get version(): DataVersionKey {\n    return this.versionChain[this.versionChain.length - 1];\n  }\n\n  /**\n   * Number of migration steps defined.\n   */\n  get migrationCount(): number {\n    return this.steps.length;\n  }\n\n  /**\n   * Get a fresh copy of the initial data.\n   */\n  initialData(): State {\n    return this.initialDataFn();\n  }\n\n  /**\n   * Get initial data wrapped with current version.\n   * Used when creating new blocks or resetting to defaults.\n   */\n  getDefaultData(): DataVersioned<State> {\n    return makeDataVersioned(this.version, this.initialDataFn());\n  }\n\n  private recoverFrom(data: unknown, version: DataVersionKey): DataMigrationResult<State> {\n    try {\n      return { version: this.version, data: this.recoverFn(version, data) };\n    } catch (error) {\n      if (isDataUnrecoverableError(error)) {\n        return { ...this.getDefaultData(), warning: error.message };\n      }\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      return {\n        ...this.getDefaultData(),\n        warning: `Recover failed for version '${version}': ${errorMessage}`,\n      };\n    }\n  }\n\n  /**\n   * Migrate versioned data from any version to the latest.\n   *\n   * - If data is already at latest version, returns as-is\n   * - If version is in chain, applies needed migrations\n   * - If version is unknown, calls recover function\n   * - If migration/recovery fails, returns default data with warning\n   *\n   * @param versioned - Data with version tag\n   * @returns Migration result with data at latest version\n   */\n  migrate(versioned: DataVersioned<unknown>): DataMigrationResult<State> {\n    const { version: fromVersion, data } = versioned;\n\n    if (fromVersion === this.version) {\n      return { version: this.version, data: data as State };\n    }\n\n    const startIndex = this.versionChain.indexOf(fromVersion);\n    if (startIndex < 0) {\n      return this.recoverFrom(data, fromVersion);\n    }\n\n    let currentData: unknown = data;\n    for (let i = startIndex; i < this.steps.length; i++) {\n      const step = this.steps[i];\n      try {\n        currentData = step.migrate(currentData);\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        return {\n          ...this.getDefaultData(),\n          warning: `Migration ${step.fromVersion}→${step.toVersion} failed: ${errorMessage}`,\n        };\n      }\n    }\n\n    return { version: this.version, data: currentData as State };\n  }\n\n  /**\n   * Register callbacks for use in the VM.\n   * Called by BlockModelV3.create() to set up internal callbacks.\n   *\n   * @internal\n   */\n  registerCallbacks(): void {\n    tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());\n    tryRegisterCallback('__pl_data_upgrade', (versioned: DataVersioned<unknown>) => this.migrate(versioned));\n    tryRegisterCallback('__pl_storage_initial', () => {\n      const { version, data } = this.getDefaultData();\n      const storage = createBlockStorage(data, version);\n      return JSON.stringify(storage);\n    });\n  }\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"block_migrations.js","sources":["../src/block_migrations.ts"],"sourcesContent":["import { tryRegisterCallback } from './internal';\nimport { createBlockStorage } from './block_storage';\n\nexport type DataVersionKey = string;\nexport type DataVersionMap = Record<string, unknown>;\nexport type DataMigrateFn<From, To> = (prev: Readonly<From>) => To;\nexport type DataCreateFn<T> = () => T;\nexport type DataRecoverFn<T> = (version: DataVersionKey, data: unknown) => T;\n\n/**\n * Helper to define version keys with literal type inference and runtime validation.\n * - Validates that all version values are unique\n * - Validates that no version value is empty\n * - Eliminates need for `as const` assertion\n *\n * @throws Error if duplicate or empty version values are found\n *\n * @example\n * const Version = defineDataVersions({\n *   Initial: 'v1',\n *   AddedLabels: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.Initial]: DataV1;\n *   [Version.AddedLabels]: DataV2;\n * };\n */\nexport function defineDataVersions<const T extends Record<string, string>>(versions: T): T {\n  const values = Object.values(versions) as (string & keyof T)[];\n  const keys = Object.keys(versions) as (keyof T)[];\n  const emptyKeys = keys.filter((key) => versions[key] === '');\n  if (emptyKeys.length > 0) {\n    throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);\n  }\n  const unique = new Set(values);\n  if (unique.size !== values.length) {\n    const duplicates = values.filter((v, i) => values.indexOf(v) !== i);\n    throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);\n  }\n  return versions;\n}\n\n/** Versioned data wrapper for persistence */\nexport type DataVersioned<T> = {\n  version: DataVersionKey;\n  data: T;\n};\n\n/** Create a DataVersioned wrapper with correct shape */\nexport function makeDataVersioned<T>(version: DataVersionKey, data: T): DataVersioned<T> {\n  return { version, data };\n}\n\n/** Result of migration operation, may include warning if migration failed */\nexport type DataMigrationResult<T> = DataVersioned<T> & {\n  warning?: string;\n};\n\n/** Thrown by recover() to signal unrecoverable data. */\nexport class DataUnrecoverableError extends Error {\n  name = 'DataUnrecoverableError';\n  constructor(dataVersion: DataVersionKey) {\n    super(`Unknown version '${dataVersion}'`);\n  }\n}\n\nexport function isDataUnrecoverableError(error: unknown): error is DataUnrecoverableError {\n  return error instanceof Error && error.name === 'DataUnrecoverableError';\n}\n\ntype MigrationStep = {\n  fromVersion: DataVersionKey;\n  toVersion: DataVersionKey;\n  migrate: (data: unknown) => unknown;\n};\n\n/**\n * Default recover function for unknown versions.\n * Use as fallback at the end of custom recover functions.\n *\n * @example\n * .recover((version, data) => {\n *   if (version === 'legacy') {\n *     return transformLegacyData(data);\n *   }\n *   return defaultRecover(version, data);\n * })\n */\nexport const defaultRecover: DataRecoverFn<never> = (version, _data) => {\n  throw new DataUnrecoverableError(version);\n};\n\n/** Symbol for internal builder creation method */\nconst FROM_BUILDER = Symbol('fromBuilder');\n\n/** Internal state passed from builder to DataModel */\ntype BuilderState<S> = {\n  versionChain: DataVersionKey[];\n  steps: MigrationStep[];\n  initialDataFn: () => S;\n  recoverFn?: DataRecoverFn<S>;\n};\n\n/**\n * Final builder state after recover() is called.\n * Only allows calling create() to finalize the DataModel.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current (final) version in the chain\n * @internal\n */\nclass DataModelBuilderWithRecover<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n  private readonly recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps,\n    recoverFn,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    recoverFn: DataRecoverFn<VersionedData[CurrentVersion]>;\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never\n      ? []\n      : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n      recoverFn: this.recoverFn,\n    });\n  }\n}\n\n/**\n * Internal builder for constructing DataModel with type-safe migration chains.\n *\n * Tracks the current version through the generic type system, ensuring:\n * - Migration functions receive correctly typed input\n * - Migration functions must return the correct output type\n * - Version keys must exist in the VersionedData map\n * - All versions must be covered before calling init()\n *\n * @typeParam VersionedData - Map of version keys to their data types\n * @typeParam CurrentVersion - The current version in the migration chain\n * @typeParam RemainingVersions - Versions not yet covered by migrations\n * @internal\n */\nclass DataModelMigrationChain<\n  VersionedData extends DataVersionMap,\n  CurrentVersion extends keyof VersionedData & string,\n  RemainingVersions extends keyof VersionedData & string = Exclude<\n    keyof VersionedData & string,\n    CurrentVersion\n  >,\n> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly migrationSteps: MigrationStep[];\n\n  /** @internal */\n  constructor({\n    versionChain,\n    steps = [],\n  }: {\n    versionChain: DataVersionKey[];\n    steps?: MigrationStep[];\n  }) {\n    this.versionChain = versionChain;\n    this.migrationSteps = steps;\n  }\n\n  /**\n   * Add a migration step to transform data from current version to next version.\n   *\n   * Migration functions:\n   * - Receive data typed as the current version's data type (readonly)\n   * - Must return data matching the target version's data type\n   * - Should be pure functions (no side effects)\n   * - May throw errors (will result in data reset with warning)\n   *\n   * @typeParam NextVersion - The target version key (must be in RemainingVersions)\n   * @param nextVersion - The version key to migrate to\n   * @param fn - Migration function transforming current data to next version\n   * @returns Builder with updated current version\n   *\n   * @example\n   * .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n   */\n  migrate<NextVersion extends RemainingVersions>(\n    nextVersion: NextVersion,\n    fn: DataMigrateFn<VersionedData[CurrentVersion], VersionedData[NextVersion]>,\n  ): DataModelMigrationChain<VersionedData, NextVersion, Exclude<RemainingVersions, NextVersion>> {\n    if (this.versionChain.includes(nextVersion)) {\n      throw new Error(`Duplicate version '${nextVersion}' in migration chain`);\n    }\n    const fromVersion = this.versionChain[this.versionChain.length - 1];\n    const step: MigrationStep = {\n      fromVersion,\n      toVersion: nextVersion,\n      migrate: fn as (data: unknown) => unknown,\n    };\n    return new DataModelMigrationChain<\n      VersionedData,\n      NextVersion,\n      Exclude<RemainingVersions, NextVersion>\n    >({\n      versionChain: [...this.versionChain, nextVersion],\n      steps: [...this.migrationSteps, step],\n    });\n  }\n\n  /**\n   * Set a recovery handler for unknown or legacy versions.\n   *\n   * The recover function is called when data has a version not in the migration chain.\n   * It should either:\n   * - Transform the data to the current version's format and return it\n   * - Call `defaultRecover(version, data)` to signal unrecoverable data\n   *\n   * Can only be called once. After calling, only `init()` is available.\n   *\n   * @param fn - Recovery function that transforms unknown data or throws\n   * @returns Builder with only init() method available\n   *\n   * @example\n   * .recover((version, data) => {\n   *   if (version === 'legacy' && isLegacyFormat(data)) {\n   *     return transformLegacy(data);\n   *   }\n   *   return defaultRecover(version, data);\n   * })\n   */\n  recover(\n    fn: DataRecoverFn<VersionedData[CurrentVersion]>,\n  ): DataModelBuilderWithRecover<VersionedData, CurrentVersion> {\n    return new DataModelBuilderWithRecover<VersionedData, CurrentVersion>({\n      versionChain: [...this.versionChain],\n      steps: [...this.migrationSteps],\n      recoverFn: fn,\n    });\n  }\n\n  /**\n   * Finalize the DataModel with initial data factory.\n   *\n   * Can only be called when all versions in VersionedData have been covered\n   * by the migration chain (RemainingVersions is empty).\n   *\n   * The initial data factory is called when creating new blocks or when\n   * migration/recovery fails and data must be reset.\n   *\n   * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)\n   * @returns Finalized DataModel instance\n   *\n   * @example\n   * .init(() => ({ numbers: [], labels: [], description: '' }))\n   */\n  init<S extends VersionedData[CurrentVersion]>(\n    // Compile-time check: RemainingVersions must be empty (all versions covered)\n    this: DataModelMigrationChain<VersionedData, CurrentVersion, never>,\n    initialData: DataCreateFn<S>,\n    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]\n    ..._noExtraKeys: Exclude<keyof S, keyof VersionedData[CurrentVersion]> extends never\n      ? []\n      : [never]\n  ): DataModel<VersionedData[CurrentVersion]> {\n    return DataModel[FROM_BUILDER]<VersionedData[CurrentVersion]>({\n      versionChain: this.versionChain,\n      steps: this.migrationSteps,\n      initialDataFn: initialData as DataCreateFn<VersionedData[CurrentVersion]>,\n    });\n  }\n}\n\n/**\n * Builder entry point for creating DataModel with type-safe migrations.\n *\n * @typeParam VersionedData - Map of version keys to their data types\n *\n * @example\n * const Version = defineDataVersions({\n *   V1: 'v1',\n *   V2: 'v2',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { count: number };\n *   [Version.V2]: { count: number; label: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, label: '' }))\n *   .init(() => ({ count: 0, label: '' }));\n */\nexport class DataModelBuilder<VersionedData extends DataVersionMap> {\n  /**\n   * Start a migration chain from an initial version.\n   *\n   * @typeParam InitialVersion - The starting version key (inferred from argument)\n   * @param initialVersion - The version key to start from\n   * @returns Migration chain builder for adding migrations\n   *\n   * @example\n   * new DataModelBuilder<VersionedData>()\n   *   .from(Version.V1)\n   *   .migrate(Version.V2, (data) => ({ ...data, newField: '' }))\n   */\n  from<InitialVersion extends keyof VersionedData & string>(\n    initialVersion: InitialVersion,\n  ): DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    > {\n    return new DataModelMigrationChain<\n      VersionedData,\n      InitialVersion,\n      Exclude<keyof VersionedData & string, InitialVersion>\n    >({ versionChain: [initialVersion] });\n  }\n}\n\n/**\n * DataModel defines the block's data structure, initial values, and migrations.\n * Used by BlockModelV3 to manage data state.\n *\n * Use `new DataModelBuilder<VersionedData>()` to create a DataModel:\n *\n * **Simple (no migrations):**\n * @example\n * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });\n * type VersionedData = { [Version.V1]: BlockData };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .init(() => ({ numbers: [], labels: [] }));\n *\n * **With migrations:**\n * @example\n * const Version = defineDataVersions({\n *   V1: DATA_MODEL_DEFAULT_VERSION,\n *   V2: 'v2',\n *   V3: 'v3',\n * });\n *\n * type VersionedData = {\n *   [Version.V1]: { numbers: number[] };\n *   [Version.V2]: { numbers: number[]; labels: string[] };\n *   [Version.V3]: { numbers: number[]; labels: string[]; description: string };\n * };\n *\n * const dataModel = new DataModelBuilder<VersionedData>()\n *   .from(Version.V1)\n *   .migrate(Version.V2, (data) => ({ ...data, labels: [] }))\n *   .migrate(Version.V3, (data) => ({ ...data, description: '' }))\n *   .recover((version, data) => {\n *     if (version === 'legacy' && typeof data === 'object' && data !== null && 'numbers' in data) {\n *       return { numbers: (data as { numbers: number[] }).numbers, labels: [], description: '' };\n *     }\n *     return defaultRecover(version, data);\n *   })\n *   .init(() => ({ numbers: [], labels: [], description: '' }));\n */\nexport class DataModel<State> {\n  private readonly versionChain: DataVersionKey[];\n  private readonly steps: MigrationStep[];\n  private readonly initialDataFn: () => State;\n  private readonly recoverFn: DataRecoverFn<State>;\n\n  private constructor({\n    versionChain,\n    steps,\n    initialDataFn,\n    recoverFn = defaultRecover as DataRecoverFn<State>,\n  }: {\n    versionChain: DataVersionKey[];\n    steps: MigrationStep[];\n    initialDataFn: () => State;\n    recoverFn?: DataRecoverFn<State>;\n  }) {\n    if (versionChain.length === 0) {\n      throw new Error('DataModel requires at least one version key');\n    }\n    this.versionChain = versionChain;\n    this.steps = steps;\n    this.initialDataFn = initialDataFn;\n    this.recoverFn = recoverFn;\n  }\n\n  /**\n   * Internal method for creating DataModel from builder.\n   * Uses Symbol key to prevent external access.\n   * @internal\n   */\n  static [FROM_BUILDER]<S>(state: BuilderState<S>): DataModel<S> {\n    return new DataModel<S>(state);\n  }\n\n  /**\n   * The latest (current) version key in the migration chain.\n   */\n  get version(): DataVersionKey {\n    return this.versionChain[this.versionChain.length - 1];\n  }\n\n  /**\n   * Number of migration steps defined.\n   */\n  get migrationCount(): number {\n    return this.steps.length;\n  }\n\n  /**\n   * Get a fresh copy of the initial data.\n   */\n  initialData(): State {\n    return this.initialDataFn();\n  }\n\n  /**\n   * Get initial data wrapped with current version.\n   * Used when creating new blocks or resetting to defaults.\n   */\n  getDefaultData(): DataVersioned<State> {\n    return makeDataVersioned(this.version, this.initialDataFn());\n  }\n\n  private recoverFrom(data: unknown, version: DataVersionKey): DataMigrationResult<State> {\n    try {\n      return { version: this.version, data: this.recoverFn(version, data) };\n    } catch (error) {\n      if (isDataUnrecoverableError(error)) {\n        return { ...this.getDefaultData(), warning: error.message };\n      }\n      const errorMessage = error instanceof Error ? error.message : String(error);\n      return {\n        ...this.getDefaultData(),\n        warning: `Recover failed for version '${version}': ${errorMessage}`,\n      };\n    }\n  }\n\n  /**\n   * Migrate versioned data from any version to the latest.\n   *\n   * - If data is already at latest version, returns as-is\n   * - If version is in chain, applies needed migrations\n   * - If version is unknown, calls recover function\n   * - If migration/recovery fails, returns default data with warning\n   *\n   * @param versioned - Data with version tag\n   * @returns Migration result with data at latest version\n   */\n  migrate(versioned: DataVersioned<unknown>): DataMigrationResult<State> {\n    const { version: fromVersion, data } = versioned;\n\n    if (fromVersion === this.version) {\n      return { version: this.version, data: data as State };\n    }\n\n    const startIndex = this.versionChain.indexOf(fromVersion);\n    if (startIndex < 0) {\n      return this.recoverFrom(data, fromVersion);\n    }\n\n    let currentData: unknown = data;\n    for (let i = startIndex; i < this.steps.length; i++) {\n      const step = this.steps[i];\n      try {\n        currentData = step.migrate(currentData);\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        return {\n          ...this.getDefaultData(),\n          warning: `Migration ${step.fromVersion}→${step.toVersion} failed: ${errorMessage}`,\n        };\n      }\n    }\n\n    return { version: this.version, data: currentData as State };\n  }\n\n  /**\n   * Register callbacks for use in the VM.\n   * Called by BlockModelV3.create() to set up internal callbacks.\n   *\n   * @internal\n   */\n  registerCallbacks(): void {\n    tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());\n    tryRegisterCallback('__pl_data_upgrade', (versioned: DataVersioned<unknown>) =>\n      this.migrate(versioned),\n    );\n    tryRegisterCallback('__pl_storage_initial', () => {\n      const { version, data } = this.getDefaultData();\n      const storage = createBlockStorage(data, version);\n      return JSON.stringify(storage);\n    });\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/block_model.cjs

@@ -28,7 +28,14 @@ class BlockModelV3 {
      * Creates a new BlockModelV3 builder with the specified data model and options.
      *
      * @example
-     * const dataModel = DataModel.create<BlockData>(() => ({ numbers: [], labels: [] }));
+     * const Version = defineDataVersions({ V1: DATA_MODEL_DEFAULT_VERSION });
+     *
+     * type VersionedData = { [Version.V1]: BlockData };
+     *
+     * const dataModel = new DataModelBuilder<VersionedData>()
+     *   .from(Version.V1)
+     *   .init(() => ({ numbers: [], labels: [] }));
+     *
      * BlockModelV3.create({ dataModel })
      *   .args((data) => ({ numbers: data.numbers }))
      *   .sections(() => [{ type: 'link', href: '/', label: 'Main' }])
@@ -60,7 +67,11 @@ class BlockModelV3 {
             ...this.config,
             outputs: {
                 ...this.config.outputs,
-                [key]: internal.createAndRegisterRenderLambda({ handle: `output#${key}`, lambda: () => cfgOrRf(new api.RenderCtx()), ...flags }),
+                [key]: internal.createAndRegisterRenderLambda({
+                    handle: `output#${key}`,
+                    lambda: () => cfgOrRf(new api.RenderCtx()),
+                    ...flags,
+                }),
             },
         });
     }
@@ -114,7 +125,10 @@ class BlockModelV3 {
     prerunArgs(fn) {
         return new BlockModelV3({
             ...this.config,
-            prerunArgs: internal.createAndRegisterRenderLambda({ handle: 'prerunArgs', lambda: fn }),
+            prerunArgs: internal.createAndRegisterRenderLambda({
+                handle: 'prerunArgs',
+                lambda: fn,
+            }),
         });
     }
     /** Sets the lambda to generate list of sections in the left block overviews panel. */
@@ -129,19 +143,28 @@ class BlockModelV3 {
     title(rf) {
         return new BlockModelV3({
             ...this.config,
-            title: internal.createAndRegisterRenderLambda({ handle: 'title', lambda: () => rf(new api.RenderCtx()) }),
+            title: internal.createAndRegisterRenderLambda({
+                handle: 'title',
+                lambda: () => rf(new api.RenderCtx()),
+            }),
         });
     }
     subtitle(rf) {
         return new BlockModelV3({
             ...this.config,
-            subtitle: internal.createAndRegisterRenderLambda({ handle: 'subtitle', lambda: () => rf(new api.RenderCtx()) }),
+            subtitle: internal.createAndRegisterRenderLambda({
+                handle: 'subtitle',
+                lambda: () => rf(new api.RenderCtx()),
+            }),
         });
     }
     tags(rf) {
         return new BlockModelV3({
             ...this.config,
-            tags: internal.createAndRegisterRenderLambda({ handle: 'tags', lambda: () => rf(new api.RenderCtx()) }),
+            tags: internal.createAndRegisterRenderLambda({
+                handle: 'tags',
+                lambda: () => rf(new api.RenderCtx()),
+            }),
         });
     }
     /** Sets or overrides feature flags for the block. */
@@ -158,7 +181,10 @@ class BlockModelV3 {
     enriches(lambda) {
         return new BlockModelV3({
             ...this.config,
-            enrichmentTargets: internal.createAndRegisterRenderLambda({ handle: 'enrichmentTargets', lambda: lambda }),
+            enrichmentTargets: internal.createAndRegisterRenderLambda({
+                handle: 'enrichmentTargets',
+                lambda: lambda,
+            }),
         });
     }
     /** Renders all provided block settings into a pre-configured platforma API
@@ -198,7 +224,10 @@ class BlockModelV3 {
             sdkVersion: version.PlatformaSDKVersion,
             renderingMode: this.config.renderingMode,
             sections: this.config.sections,
-            outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [key, normalization.downgradeCfgOrLambda(value)])),
+            outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [
+                key,
+                normalization.downgradeCfgOrLambda(value),
+            ])),
         };
         globalThis.platformaApiVersion = apiVersion;
         if (!internal.isInUI())
@@ -207,12 +236,17 @@ class BlockModelV3 {
         // normal operation inside the UI
         else
             return {
-                ...internal.getPlatformaInstance({ sdkVersion: version.PlatformaSDKVersion, apiVersion }),
+                ...internal.getPlatformaInstance({
+                    sdkVersion: version.PlatformaSDKVersion,
+                    apiVersion,
+                }),
                 blockModelInfo: {
-                    outputs: Object.fromEntries(Object.entries(this.config.outputs)
-                        .map(([key, value]) => [key, {
+                    outputs: Object.fromEntries(Object.entries(this.config.outputs).map(([key, value]) => [
+                        key,
+                        {
                             withStatus: Boolean(types.isConfigLambda(value) && value.withStatus),
-                        }])),
+                        },
+                    ])),
                 },
             };
     }