@platforma-sdk/model 1.53.0 → 1.53.2

package/dist/block_migrations.cjs

@@ -3,112 +3,408 @@
 var internal = require('./internal.cjs');
 var block_storage = require('./block_storage.cjs');
 
-/** Internal builder for chaining migrations */
-class DataModelBuilder {
+/**
+ * Helper to define version keys with literal type inference and runtime validation.
+ * - Validates that all version values are unique
+ * - Validates that no version value is empty
+ * - Eliminates need for `as const` assertion
+ *
+ * @throws Error if duplicate or empty version values are found
+ *
+ * @example
+ * const Version = defineDataVersions({
+ *   Initial: 'v1',
+ *   AddedLabels: 'v2',
+ * });
+ *
+ * type VersionedData = {
+ *   [Version.Initial]: DataV1;
+ *   [Version.AddedLabels]: DataV2;
+ * };
+ */
+function defineDataVersions(versions) {
+    const values = Object.values(versions);
+    const keys = Object.keys(versions);
+    const emptyKeys = keys.filter((key) => versions[key] === '');
+    if (emptyKeys.length > 0) {
+        throw new Error(`Version values must be non-empty strings (empty: ${emptyKeys.join(', ')})`);
+    }
+    const unique = new Set(values);
+    if (unique.size !== values.length) {
+        const duplicates = values.filter((v, i) => values.indexOf(v) !== i);
+        throw new Error(`Duplicate version values: ${[...new Set(duplicates)].join(', ')}`);
+    }
+    return versions;
+}
+/** Create a DataVersioned wrapper with correct shape */
+function makeDataVersioned(version, data) {
+    return { version, data };
+}
+/** Thrown by recover() to signal unrecoverable data. */
+class DataUnrecoverableError extends Error {
+    name = 'DataUnrecoverableError';
+    constructor(dataVersion) {
+        super(`Unknown version '${dataVersion}'`);
+    }
+}
+function isDataUnrecoverableError(error) {
+    return error instanceof Error && error.name === 'DataUnrecoverableError';
+}
+/**
+ * Default recover function for unknown versions.
+ * Use as fallback at the end of custom recover functions.
+ *
+ * @example
+ * .recover((version, data) => {
+ *   if (version === 'legacy') {
+ *     return transformLegacyData(data);
+ *   }
+ *   return defaultRecover(version, data);
+ * })
+ */
+const defaultRecover = (version, _data) => {
+    throw new DataUnrecoverableError(version);
+};
+/** Symbol for internal builder creation method */
+const FROM_BUILDER = Symbol('fromBuilder');
+/**
+ * Final builder state after recover() is called.
+ * Only allows calling create() to finalize the DataModel.
+ *
+ * @typeParam VersionedData - Map of version keys to their data types
+ * @typeParam CurrentVersion - The current (final) version in the chain
+ * @internal
+ */
+class DataModelBuilderWithRecover {
+    versionChain;
     migrationSteps;
-    constructor(steps = []) {
+    recoverFn;
+    /** @internal */
+    constructor({ versionChain, steps, recoverFn, }) {
+        this.versionChain = versionChain;
         this.migrationSteps = steps;
+        this.recoverFn = recoverFn;
+    }
+    /**
+     * Finalize the DataModel with initial data factory.
+     *
+     * The initial data factory is called when creating new blocks or when
+     * migration/recovery fails and data must be reset.
+     *
+     * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)
+     * @returns Finalized DataModel instance
+     *
+     * @example
+     * .init(() => ({ numbers: [], labels: [], description: '' }))
+     */
+    init(initialData, 
+    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]
+    ..._noExtraKeys) {
+        return DataModel[FROM_BUILDER]({
+            versionChain: this.versionChain,
+            steps: this.migrationSteps,
+            initialDataFn: initialData,
+            recoverFn: this.recoverFn,
+        });
     }
-    /** Start a migration chain from an initial type */
-    static from() {
-        return new DataModelBuilder();
+}
+/**
+ * Internal builder for constructing DataModel with type-safe migration chains.
+ *
+ * Tracks the current version through the generic type system, ensuring:
+ * - Migration functions receive correctly typed input
+ * - Migration functions must return the correct output type
+ * - Version keys must exist in the VersionedData map
+ * - All versions must be covered before calling init()
+ *
+ * @typeParam VersionedData - Map of version keys to their data types
+ * @typeParam CurrentVersion - The current version in the migration chain
+ * @typeParam RemainingVersions - Versions not yet covered by migrations
+ * @internal
+ */
+class DataModelMigrationChain {
+    versionChain;
+    migrationSteps;
+    /** @internal */
+    constructor({ versionChain, steps = [], }) {
+        this.versionChain = versionChain;
+        this.migrationSteps = steps;
     }
-    /** Add a migration step */
-    migrate(fn) {
-        return new DataModelBuilder([...this.migrationSteps, fn]);
+    /**
+     * Add a migration step to transform data from current version to next version.
+     *
+     * Migration functions:
+     * - Receive data typed as the current version's data type (readonly)
+     * - Must return data matching the target version's data type
+     * - Should be pure functions (no side effects)
+     * - May throw errors (will result in data reset with warning)
+     *
+     * @typeParam NextVersion - The target version key (must be in RemainingVersions)
+     * @param nextVersion - The version key to migrate to
+     * @param fn - Migration function transforming current data to next version
+     * @returns Builder with updated current version
+     *
+     * @example
+     * .migrate(Version.V2, (data) => ({ ...data, labels: [] }))
+     */
+    migrate(nextVersion, fn) {
+        if (this.versionChain.includes(nextVersion)) {
+            throw new Error(`Duplicate version '${nextVersion}' in migration chain`);
+        }
+        const fromVersion = this.versionChain[this.versionChain.length - 1];
+        const step = { fromVersion, toVersion: nextVersion, migrate: fn };
+        return new DataModelMigrationChain({
+            versionChain: [...this.versionChain, nextVersion],
+            steps: [...this.migrationSteps, step],
+        });
     }
-    /** Finalize with initial data, creating the DataModel */
-    create(initialData, ..._) {
-        return DataModel._fromBuilder(this.migrationSteps, initialData);
+    /**
+     * Set a recovery handler for unknown or legacy versions.
+     *
+     * The recover function is called when data has a version not in the migration chain.
+     * It should either:
+     * - Transform the data to the current version's format and return it
+     * - Call `defaultRecover(version, data)` to signal unrecoverable data
+     *
+     * Can only be called once. After calling, only `init()` is available.
+     *
+     * @param fn - Recovery function that transforms unknown data or throws
+     * @returns Builder with only init() method available
+     *
+     * @example
+     * .recover((version, data) => {
+     *   if (version === 'legacy' && isLegacyFormat(data)) {
+     *     return transformLegacy(data);
+     *   }
+     *   return defaultRecover(version, data);
+     * })
+     */
+    recover(fn) {
+        return new DataModelBuilderWithRecover({
+            versionChain: [...this.versionChain],
+            steps: [...this.migrationSteps],
+            recoverFn: fn,
+        });
+    }
+    /**
+     * Finalize the DataModel with initial data factory.
+     *
+     * Can only be called when all versions in VersionedData have been covered
+     * by the migration chain (RemainingVersions is empty).
+     *
+     * The initial data factory is called when creating new blocks or when
+     * migration/recovery fails and data must be reset.
+     *
+     * @param initialData - Factory function returning initial state (must exactly match CurrentVersion's data type)
+     * @returns Finalized DataModel instance
+     *
+     * @example
+     * .init(() => ({ numbers: [], labels: [], description: '' }))
+     */
+    init(initialData, 
+    // Compile-time check: S must have exactly the same keys as VersionedData[CurrentVersion]
+    ..._noExtraKeys) {
+        return DataModel[FROM_BUILDER]({
+            versionChain: this.versionChain,
+            steps: this.migrationSteps,
+            initialDataFn: initialData,
+        });
+    }
+}
+/**
+ * Builder entry point for creating DataModel with type-safe migrations.
+ *
+ * @typeParam VersionedData - Map of version keys to their data types
+ *
+ * @example
+ * const Version = defineDataVersions({
+ *   V1: 'v1',
+ *   V2: 'v2',
+ * });
+ *
+ * type VersionedData = {
+ *   [Version.V1]: { count: number };
+ *   [Version.V2]: { count: number; label: string };
+ * };
+ *
+ * const dataModel = new DataModelBuilder<VersionedData>()
+ *   .from(Version.V1)
+ *   .migrate(Version.V2, (data) => ({ ...data, label: '' }))
+ *   .init(() => ({ count: 0, label: '' }));
+ */
+class DataModelBuilder {
+    /**
+     * Start a migration chain from an initial version.
+     *
+     * @typeParam InitialVersion - The starting version key (inferred from argument)
+     * @param initialVersion - The version key to start from
+     * @returns Migration chain builder for adding migrations
+     *
+     * @example
+     * new DataModelBuilder<VersionedData>()
+     *   .from(Version.V1)
+     *   .migrate(Version.V2, (data) => ({ ...data, newField: '' }))
+     */
+    from(initialVersion) {
+        return new DataModelMigrationChain({ versionChain: [initialVersion] });
     }
 }
 /**
  * DataModel defines the block's data structure, initial values, and migrations.
  * Used by BlockModelV3 to manage data state.
  *
+ * Two ways to create a DataModel:
+ *
+ * 1. **Simple (no migrations)** - Use `DataModel.create()`:
  * @example
- * // Simple data model (no migrations)
  * const dataModel = DataModel.create<BlockData>(() => ({
  *   numbers: [],
  *   labels: [],
  * }));
  *
- * // Data model with migrations
- * const dataModel = DataModel
- *   .from<V1>()
- *   .migrate((data) => ({ ...data, labels: [] }))  // v1 → v2
- *   .migrate((data) => ({ ...data, description: '' }))  // v2 → v3
- *   .create<BlockData>(() => ({ numbers: [], labels: [], description: '' }));
+ * 2. **With migrations** - Use `new DataModelBuilder<VersionedData>()`:
+ * @example
+ * const Version = defineDataVersions({
+ *   V1: 'v1',
+ *   V2: 'v2',
+ *   V3: 'v3',
+ * });
+ *
+ * type VersionedData = {
+ *   [Version.V1]: { numbers: number[] };
+ *   [Version.V2]: { numbers: number[]; labels: string[] };
+ *   [Version.V3]: { numbers: number[]; labels: string[]; description: string };
+ * };
+ *
+ * const dataModel = new DataModelBuilder<VersionedData>()
+ *   .from(Version.V1)
+ *   .migrate(Version.V2, (data) => ({ ...data, labels: [] }))
+ *   .migrate(Version.V3, (data) => ({ ...data, description: '' }))
+ *   .recover((version, data) => {
+ *     if (version === 'legacy' && typeof data === 'object' && data !== null && 'numbers' in data) {
+ *       return { numbers: (data as { numbers: number[] }).numbers, labels: [], description: '' };
+ *     }
+ *     return defaultRecover(version, data);
+ *   })
+ *   .init(() => ({ numbers: [], labels: [], description: '' }));
  */
 class DataModel {
+    versionChain;
     steps;
-    _initialData;
-    constructor(steps, initialData) {
+    initialDataFn;
+    recoverFn;
+    constructor({ versionChain, steps, initialDataFn, recoverFn = defaultRecover, }) {
+        if (versionChain.length === 0) {
+            throw new Error('DataModel requires at least one version key');
+        }
+        this.versionChain = versionChain;
         this.steps = steps;
-        this._initialData = initialData;
-    }
-    /** Start a migration chain from an initial type */
-    static from() {
-        return DataModelBuilder.from();
+        this.initialDataFn = initialDataFn;
+        this.recoverFn = recoverFn;
     }
-    /** Create a data model with just initial data (no migrations) */
-    static create(initialData) {
-        return new DataModel([], initialData);
+    /**
+     * 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,
+        });
     }
-    /** Create from builder (internal use) */
-    static _fromBuilder(steps, initialData) {
-        return new DataModel(steps, initialData);
+    /**
+     * Internal method for creating DataModel from builder.
+     * Uses Symbol key to prevent external access.
+     * @internal
+     */
+    static [FROM_BUILDER](state) {
+        return new DataModel(state);
     }
     /**
-     * Latest version number.
-     * Version 1 = initial state, each migration adds 1.
+     * The latest (current) version key in the migration chain.
      */
     get version() {
-        return this.steps.length + 1;
+        return this.versionChain[this.versionChain.length - 1];
     }
-    /** Number of migration steps */
+    /**
+     * Number of migration steps defined.
+     */
     get migrationCount() {
         return this.steps.length;
     }
-    /** Get initial data */
+    /**
+     * Get a fresh copy of the initial data.
+     */
     initialData() {
-        return this._initialData();
+        return this.initialDataFn();
     }
-    /** Get default data wrapped with current version */
+    /**
+     * Get initial data wrapped with current version.
+     * Used when creating new blocks or resetting to defaults.
+     */
     getDefaultData() {
-        return { version: this.version, data: this._initialData() };
+        return makeDataVersioned(this.version, this.initialDataFn());
+    }
+    recoverFrom(data, version) {
+        try {
+            return { version: this.version, data: this.recoverFn(version, data) };
+        }
+        catch (error) {
+            if (isDataUnrecoverableError(error)) {
+                return { ...this.getDefaultData(), warning: error.message };
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                ...this.getDefaultData(),
+                warning: `Recover failed for version '${version}': ${errorMessage}`,
+            };
+        }
     }
     /**
-     * Upgrade versioned data from any version to the latest.
-     * Applies only the migrations needed (skips already-applied ones).
-     * If a migration fails, returns default data with a warning.
+     * Migrate versioned data from any version to the latest.
+     *
+     * - If data is already at latest version, returns as-is
+     * - If version is in chain, applies needed migrations
+     * - If version is unknown, calls recover function
+     * - If migration/recovery fails, returns default data with warning
+     *
+     * @param versioned - Data with version tag
+     * @returns Migration result with data at latest version
      */
-    upgrade(versioned) {
+    migrate(versioned) {
         const { version: fromVersion, data } = versioned;
-        if (fromVersion > this.version) {
-            throw new Error(`Cannot downgrade from version ${fromVersion} to ${this.version}`);
-        }
         if (fromVersion === this.version) {
             return { version: this.version, data: data };
         }
-        // Apply migrations starting from (fromVersion - 1) index
-        // Version 1 -> no migrations applied yet -> start at index 0
-        // Version 2 -> migration[0] already applied -> start at index 1
-        const startIndex = fromVersion - 1;
-        const migrationsToApply = this.steps.slice(startIndex);
+        const startIndex = this.versionChain.indexOf(fromVersion);
+        if (startIndex < 0) {
+            return this.recoverFrom(data, fromVersion);
+        }
         let currentData = data;
-        for (let i = 0; i < migrationsToApply.length; i++) {
-            const stepIndex = startIndex + i;
-            const fromVer = stepIndex + 1;
-            const toVer = stepIndex + 2;
+        for (let i = startIndex; i < this.steps.length; i++) {
+            const step = this.steps[i];
             try {
-                currentData = migrationsToApply[i](currentData);
+                currentData = step.migrate(currentData);
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
                 return {
                     ...this.getDefaultData(),
-                    warning: `Migration v${fromVer}→v${toVer} failed: ${errorMessage}`,
+                    warning: `Migration ${step.fromVersion}→${step.toVersion} failed: ${errorMessage}`,
                 };
             }
         }
@@ -118,14 +414,11 @@ class DataModel {
      * Register callbacks for use in the VM.
      * Called by BlockModelV3.create() to set up internal callbacks.
      *
-     * All callbacks are prefixed with `__pl_` to indicate internal SDK use:
-     * - `__pl_data_initial`: returns initial data for new blocks
-     * - `__pl_data_upgrade`: upgrades versioned data from any version to latest
-     * - `__pl_storage_initial`: returns initial BlockStorage as JSON string
+     * @internal
      */
     registerCallbacks() {
-        internal.tryRegisterCallback('__pl_data_initial', () => this._initialData());
-        internal.tryRegisterCallback('__pl_data_upgrade', (versioned) => this.upgrade(versioned));
+        internal.tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());
+        internal.tryRegisterCallback('__pl_data_upgrade', (versioned) => this.migrate(versioned));
         internal.tryRegisterCallback('__pl_storage_initial', () => {
             const { version, data } = this.getDefaultData();
             const storage = block_storage.createBlockStorage(data, version);
@@ -135,4 +428,10 @@ class DataModel {
 }
 
 exports.DataModel = DataModel;
+exports.DataModelBuilder = DataModelBuilder;
+exports.DataUnrecoverableError = DataUnrecoverableError;
+exports.defaultRecover = defaultRecover;
+exports.defineDataVersions = defineDataVersions;
+exports.isDataUnrecoverableError = isDataUnrecoverableError;
+exports.makeDataVersioned = makeDataVersioned;
 //# sourceMappingURL=block_migrations.cjs.map

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 } from './block_storage';\n\nexport type MigrationFn<From, To> = (prev: Readonly<From>) => To;\n\n/** Versioned data wrapper for persistence */\nexport type Versioned<T> = {\n  version: number;\n  data: T;\n};\n\n/** Result of upgrade operation, may include warning if migration failed */\nexport type UpgradeResult<T> = Versioned<T> & {\n  warning?: string;\n};\n\n/** Internal builder for chaining migrations */\nclass DataModelBuilder<State> {\n  private readonly migrationSteps: Array<(x: unknown) => unknown>;\n\n  private constructor(steps: Array<(x: unknown) => unknown> = []) {\n    this.migrationSteps = steps;\n  }\n\n  /** Start a migration chain from an initial type */\n  static from<T = unknown>(): DataModelBuilder<T> {\n    return new DataModelBuilder<T>();\n  }\n\n  /** Add a migration step */\n  migrate<Next>(fn: MigrationFn<State, Next>): DataModelBuilder<Next> {\n    return new DataModelBuilder<Next>([...this.migrationSteps, fn as any]);\n  }\n\n  /** Finalize with initial data, creating the DataModel */\n  create<S>(\n    initialData: () => S,\n    ..._: [State] extends [S] ? [] : [never]\n  ): DataModel<S> {\n    return DataModel._fromBuilder<S>(this.migrationSteps, initialData);\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 * @example\n * // Simple data model (no migrations)\n * const dataModel = DataModel.create<BlockData>(() => ({\n *   numbers: [],\n *   labels: [],\n * }));\n *\n * // Data model with migrations\n * const dataModel = DataModel\n *   .from<V1>()\n *   .migrate((data) => ({ ...data, labels: [] }))  // v1 → v2\n *   .migrate((data) => ({ ...data, description: '' }))  // v2 → v3\n *   .create<BlockData>(() => ({ numbers: [], labels: [], description: '' }));\n */\nexport class DataModel<State> {\n  private readonly steps: Array<(x: unknown) => unknown>;\n  private readonly _initialData: () => State;\n\n  private constructor(steps: Array<(x: unknown) => unknown>, initialData: () => State) {\n    this.steps = steps;\n    this._initialData = initialData;\n  }\n\n  /** Start a migration chain from an initial type */\n  static from<S>(): DataModelBuilder<S> {\n    return DataModelBuilder.from<S>();\n  }\n\n  /** Create a data model with just initial data (no migrations) */\n  static create<S>(initialData: () => S): DataModel<S> {\n    return new DataModel<S>([], initialData);\n  }\n\n  /** Create from builder (internal use) */\n  static _fromBuilder<S>(\n    steps: Array<(x: unknown) => unknown>,\n    initialData: () => S,\n  ): DataModel<S> {\n    return new DataModel<S>(steps, initialData);\n  }\n\n  /**\n   * Latest version number.\n   * Version 1 = initial state, each migration adds 1.\n   */\n  get version(): number {\n    return this.steps.length + 1;\n  }\n\n  /** Number of migration steps */\n  get migrationCount(): number {\n    return this.steps.length;\n  }\n\n  /** Get initial data */\n  initialData(): State {\n    return this._initialData();\n  }\n\n  /** Get default data wrapped with current version */\n  getDefaultData(): Versioned<State> {\n    return { version: this.version, data: this._initialData() };\n  }\n\n  /**\n   * Upgrade versioned data from any version to the latest.\n   * Applies only the migrations needed (skips already-applied ones).\n   * If a migration fails, returns default data with a warning.\n   */\n  upgrade(versioned: Versioned<unknown>): UpgradeResult<State> {\n    const { version: fromVersion, data } = versioned;\n\n    if (fromVersion > this.version) {\n      throw new Error(\n        `Cannot downgrade from version ${fromVersion} to ${this.version}`,\n      );\n    }\n\n    if (fromVersion === this.version) {\n      return { version: this.version, data: data as State };\n    }\n\n    // Apply migrations starting from (fromVersion - 1) index\n    // Version 1 -> no migrations applied yet -> start at index 0\n    // Version 2 -> migration[0] already applied -> start at index 1\n    const startIndex = fromVersion - 1;\n    const migrationsToApply = this.steps.slice(startIndex);\n\n    let currentData: unknown = data;\n    for (let i = 0; i < migrationsToApply.length; i++) {\n      const stepIndex = startIndex + i;\n      const fromVer = stepIndex + 1;\n      const toVer = stepIndex + 2;\n      try {\n        currentData = migrationsToApply[i](currentData);\n      } catch (error) {\n        const errorMessage = error instanceof Error ? error.message : String(error);\n        return {\n          ...this.getDefaultData(),\n          warning: `Migration v${fromVer}→v${toVer} 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   * All callbacks are prefixed with `__pl_` to indicate internal SDK use:\n   * - `__pl_data_initial`: returns initial data for new blocks\n   * - `__pl_data_upgrade`: upgrades versioned data from any version to latest\n   * - `__pl_storage_initial`: returns initial BlockStorage as JSON string\n   */\n  registerCallbacks(): void {\n    tryRegisterCallback('__pl_data_initial', () => this._initialData());\n    tryRegisterCallback('__pl_data_upgrade', (versioned: Versioned<unknown>) => this.upgrade(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":["tryRegisterCallback","createBlockStorage"],"mappings":"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"}
+{"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":"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"}