@platforma-sdk/model 1.52.7 → 1.53.1

package/dist/block_migrations.js

@@ -1,23 +1,85 @@
 import { tryRegisterCallback } from './internal.js';
-import { createBlockStorage } from './block_storage.js';
+import { DATA_MODEL_DEFAULT_VERSION, createBlockStorage } from './block_storage.js';
 
+/**
+ * Helper to define version keys with literal type inference and runtime validation.
+ * - Validates that all version values are unique
+ * - Eliminates need for `as const` assertion
+ *
+ * @throws Error if duplicate 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 emptyKeys = Object.keys(versions).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 */
+const defaultRecover = (version, _data) => {
+    throw new DataUnrecoverableError(version);
+};
 /** Internal builder for chaining migrations */
 class DataModelBuilder {
+    versionChain;
     migrationSteps;
-    constructor(steps = []) {
+    recoverFn;
+    constructor(versionChain, steps = [], recoverFn) {
+        this.versionChain = versionChain;
         this.migrationSteps = steps;
+        this.recoverFn = recoverFn;
     }
-    /** Start a migration chain from an initial type */
-    static from() {
-        return new DataModelBuilder();
+    /** Start a migration chain from an initial version */
+    static from(initialVersion) {
+        return new DataModelBuilder([initialVersion]);
+    }
+    /** Add a migration step to the target version */
+    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 DataModelBuilder([...this.versionChain, nextVersion], [...this.migrationSteps, step]);
     }
-    /** Add a migration step */
-    migrate(fn) {
-        return new DataModelBuilder([...this.migrationSteps, fn]);
+    /** Set recovery handler for unknown or unsupported versions */
+    recover(fn) {
+        return new DataModelBuilder([...this.versionChain], [...this.migrationSteps], fn);
     }
     /** Finalize with initial data, creating the DataModel */
     create(initialData, ..._) {
-        return DataModel._fromBuilder(this.migrationSteps, initialData);
+        return DataModel._fromBuilder(this.versionChain, this.migrationSteps, initialData, this.recoverFn);
     }
 }
 /**
@@ -32,37 +94,61 @@ class DataModelBuilder {
  * }));
  *
  * // Data model with migrations
+ * 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 = DataModel
- *   .from<V1>()
- *   .migrate((data) => ({ ...data, labels: [] }))  // v1 → v2
- *   .migrate((data) => ({ ...data, description: '' }))  // v2 → v3
- *   .create<BlockData>(() => ({ numbers: [], labels: [], description: '' }));
+ *   .from<VersionedData>(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);
+ *   })
+ *   .create(() => ({ numbers: [], labels: [], description: '' }));
  */
 class DataModel {
+    versionChain;
     steps;
-    _initialData;
-    constructor(steps, initialData) {
+    initialDataFn;
+    recoverFn;
+    constructor(versionChain, steps, initialData, recover = defaultRecover) {
+        if (versionChain.length === 0) {
+            throw new Error('DataModel requires at least one version key');
+        }
+        this.versionChain = versionChain;
         this.steps = steps;
-        this._initialData = initialData;
+        this.initialDataFn = initialData;
+        this.recoverFn = recover;
     }
     /** Start a migration chain from an initial type */
-    static from() {
-        return DataModelBuilder.from();
+    static from(initialVersion) {
+        return DataModelBuilder.from(initialVersion);
     }
     /** Create a data model with just initial data (no migrations) */
-    static create(initialData) {
-        return new DataModel([], initialData);
+    static create(initialData, version = DATA_MODEL_DEFAULT_VERSION) {
+        return new DataModel([version], [], initialData);
     }
     /** Create from builder (internal use) */
-    static _fromBuilder(steps, initialData) {
-        return new DataModel(steps, initialData);
+    static _fromBuilder(versionChain, steps, initialData, recover) {
+        return new DataModel(versionChain, steps, initialData, recover);
     }
     /**
-     * Latest version number.
-     * Version 1 = initial state, each migration adds 1.
+     * Latest version key.
      */
     get version() {
-        return this.steps.length + 1;
+        return this.versionChain[this.versionChain.length - 1];
     }
     /** Number of migration steps */
     get migrationCount() {
@@ -70,43 +156,52 @@ class DataModel {
     }
     /** Get initial data */
     initialData() {
-        return this._initialData();
+        return this.initialDataFn();
     }
     /** Get default data wrapped with current version */
     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.
+     * Migrate 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.
      */
-    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,12 +213,12 @@ class DataModel {
      *
      * 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_data_migrate`: migrates versioned data from any version to latest
      * - `__pl_storage_initial`: returns initial BlockStorage as JSON string
      */
     registerCallbacks() {
-        tryRegisterCallback('__pl_data_initial', () => this._initialData());
-        tryRegisterCallback('__pl_data_upgrade', (versioned) => this.upgrade(versioned));
+        tryRegisterCallback('__pl_data_initial', () => this.initialDataFn());
+        tryRegisterCallback('__pl_data_migrate', (versioned) => this.migrate(versioned));
         tryRegisterCallback('__pl_storage_initial', () => {
             const { version, data } = this.getDefaultData();
             const storage = createBlockStorage(data, version);
@@ -132,5 +227,5 @@ class DataModel {
     }
 }
 
-export { DataModel };
+export { DataModel, DataUnrecoverableError, defaultRecover, defineDataVersions, isDataUnrecoverableError, makeDataVersioned };
 //# sourceMappingURL=block_migrations.js.map

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 } 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":[],"mappings":";;;AAgBA;AACA,MAAM,gBAAgB,CAAA;AACH,IAAA,cAAc;AAE/B,IAAA,WAAA,CAAoB,QAAwC,EAAE,EAAA;AAC5D,QAAA,IAAI,CAAC,cAAc,GAAG,KAAK;IAC7B;;AAGA,IAAA,OAAO,IAAI,GAAA;QACT,OAAO,IAAI,gBAAgB,EAAK;IAClC;;AAGA,IAAA,OAAO,CAAO,EAA4B,EAAA;AACxC,QAAA,OAAO,IAAI,gBAAgB,CAAO,CAAC,GAAG,IAAI,CAAC,cAAc,EAAE,EAAS,CAAC,CAAC;IACxE;;AAGA,IAAA,MAAM,CACJ,WAAoB,EACpB,GAAG,CAAqC,EAAA;QAExC,OAAO,SAAS,CAAC,YAAY,CAAI,IAAI,CAAC,cAAc,EAAE,WAAW,CAAC;IACpE;AACD;AAED;;;;;;;;;;;;;;;;;AAiBG;MACU,SAAS,CAAA;AACH,IAAA,KAAK;AACL,IAAA,YAAY;IAE7B,WAAA,CAAoB,KAAqC,EAAE,WAAwB,EAAA;AACjF,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;AAClB,QAAA,IAAI,CAAC,YAAY,GAAG,WAAW;IACjC;;AAGA,IAAA,OAAO,IAAI,GAAA;AACT,QAAA,OAAO,gBAAgB,CAAC,IAAI,EAAK;IACnC;;IAGA,OAAO,MAAM,CAAI,WAAoB,EAAA;AACnC,QAAA,OAAO,IAAI,SAAS,CAAI,EAAE,EAAE,WAAW,CAAC;IAC1C;;AAGA,IAAA,OAAO,YAAY,CACjB,KAAqC,EACrC,WAAoB,EAAA;AAEpB,QAAA,OAAO,IAAI,SAAS,CAAI,KAAK,EAAE,WAAW,CAAC;IAC7C;AAEA;;;AAGG;AACH,IAAA,IAAI,OAAO,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC;IAC9B;;AAGA,IAAA,IAAI,cAAc,GAAA;AAChB,QAAA,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM;IAC1B;;IAGA,WAAW,GAAA;AACT,QAAA,OAAO,IAAI,CAAC,YAAY,EAAE;IAC5B;;IAGA,cAAc,GAAA;AACZ,QAAA,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,YAAY,EAAE,EAAE;IAC7D;AAEA;;;;AAIG;AACH,IAAA,OAAO,CAAC,SAA6B,EAAA;QACnC,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,SAAS;AAEhD,QAAA,IAAI,WAAW,GAAG,IAAI,CAAC,OAAO,EAAE;YAC9B,MAAM,IAAI,KAAK,CACb,CAAA,8BAAA,EAAiC,WAAW,CAAA,IAAA,EAAO,IAAI,CAAC,OAAO,CAAA,CAAE,CAClE;QACH;AAEA,QAAA,IAAI,WAAW,KAAK,IAAI,CAAC,OAAO,EAAE;YAChC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAa,EAAE;QACvD;;;;AAKA,QAAA,MAAM,UAAU,GAAG,WAAW,GAAG,CAAC;QAClC,MAAM,iBAAiB,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,CAAC;QAEtD,IAAI,WAAW,GAAY,IAAI;AAC/B,QAAA,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,iBAAiB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACjD,YAAA,MAAM,SAAS,GAAG,UAAU,GAAG,CAAC;AAChC,YAAA,MAAM,OAAO,GAAG,SAAS,GAAG,CAAC;AAC7B,YAAA,MAAM,KAAK,GAAG,SAAS,GAAG,CAAC;AAC3B,YAAA,IAAI;gBACF,WAAW,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC;YACjD;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;AACxB,oBAAA,OAAO,EAAE,CAAA,WAAA,EAAc,OAAO,KAAK,KAAK,CAAA,SAAA,EAAY,YAAY,CAAA,CAAE;iBACnE;YACH;QACF;QAEA,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,WAAoB,EAAE;IAC9D;AAEA;;;;;;;;AAQG;IACH,iBAAiB,GAAA;QACf,mBAAmB,CAAC,mBAAmB,EAAE,MAAM,IAAI,CAAC,YAAY,EAAE,CAAC;AACnE,QAAA,mBAAmB,CAAC,mBAAmB,EAAE,CAAC,SAA6B,KAAK,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AACpG,QAAA,mBAAmB,CAAC,sBAAsB,EAAE,MAAK;YAC/C,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,GAAG,IAAI,CAAC,cAAc,EAAE;YAC/C,MAAM,OAAO,GAAG,kBAAkB,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.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 * - Eliminates need for `as const` assertion\n *\n * @throws Error if duplicate 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);\n  const emptyKeys = Object.keys(versions).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/** Default recover function for unknown versions */\nexport const defaultRecover: DataRecoverFn<never> = (version, _data) => {\n  throw new DataUnrecoverableError(version);\n};\n\n/** Internal builder for chaining migrations */\nclass DataModelBuilder<\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  private constructor(\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  /** Start a migration chain from an initial version */\n  static from<\n    VersionedData extends DataVersionMap,\n    InitialVersion extends keyof VersionedData & string = keyof VersionedData & string,\n  >(initialVersion: InitialVersion): DataModelBuilder<VersionedData, InitialVersion> {\n    return new DataModelBuilder<VersionedData, InitialVersion>([initialVersion]);\n  }\n\n  /** Add a migration step to the target version */\n  migrate<NextVersion extends keyof VersionedData & string>(\n    nextVersion: NextVersion,\n    fn: DataMigrateFn<VersionedData[CurrentVersion], VersionedData[NextVersion]>,\n  ): DataModelBuilder<VersionedData, 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 DataModelBuilder<VersionedData, NextVersion>(\n      [...this.versionChain, nextVersion],\n      [...this.migrationSteps, step],\n    );\n  }\n\n  /** Set recovery handler for unknown or unsupported versions */\n  recover(\n    fn: DataRecoverFn<VersionedData[CurrentVersion]>,\n  ): DataModelBuilder<VersionedData, CurrentVersion> {\n    return new DataModelBuilder<VersionedData, CurrentVersion>(\n      [...this.versionChain],\n      [...this.migrationSteps],\n      fn,\n    );\n  }\n\n  /** Finalize with initial data, creating the DataModel */\n  create<S extends VersionedData[CurrentVersion]>(\n    initialData: DataCreateFn<S>,\n    ..._: [VersionedData[CurrentVersion]] extends [S] ? [] : [never]\n  ): DataModel<S> {\n    return DataModel._fromBuilder<S>(\n      this.versionChain,\n      this.migrationSteps,\n      initialData,\n      this.recoverFn as DataRecoverFn<S> | undefined,\n    );\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 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 = DataModel\n *   .from<VersionedData>(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 *   .create(() => ({ 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: DataVersionKey[],\n    steps: MigrationStep[],\n    initialData: () => State,\n    recover: DataRecoverFn<State> = defaultRecover as 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 = initialData;\n    this.recoverFn = recover;\n  }\n\n  /** Start a migration chain from an initial type */\n  static from<\n    VersionedData extends DataVersionMap,\n    InitialVersion extends keyof VersionedData & string = keyof VersionedData & string,\n  >(initialVersion: InitialVersion): DataModelBuilder<VersionedData, InitialVersion> {\n    return DataModelBuilder.from<VersionedData, InitialVersion>(initialVersion);\n  }\n\n  /** Create a data model with just initial data (no migrations) */\n  static create<S>(initialData: () => S, version: DataVersionKey = DATA_MODEL_DEFAULT_VERSION): DataModel<S> {\n    return new DataModel<S>([version], [], initialData);\n  }\n\n  /** Create from builder (internal use) */\n  static _fromBuilder<S>(\n    versionChain: DataVersionKey[],\n    steps: MigrationStep[],\n    initialData: () => S,\n    recover?: DataRecoverFn<S>,\n  ): DataModel<S> {\n    return new DataModel<S>(versionChain, steps, initialData, recover);\n  }\n\n  /**\n   * Latest version key.\n   */\n  get version(): DataVersionKey {\n    return this.versionChain[this.versionChain.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.initialDataFn();\n  }\n\n  /** Get default data wrapped with current version */\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   * Applies only the migrations needed (skips already-applied ones).\n   * If a migration fails, returns default data with a warning.\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   * All callbacks are prefixed with `__pl_` to indicate internal SDK use:\n   * - `__pl_data_initial`: returns initial data for new blocks\n   * - `__pl_data_migrate`: migrates 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.initialDataFn());\n    tryRegisterCallback('__pl_data_migrate', (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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"}

package/dist/block_storage.cjs

@@ -23,6 +23,11 @@ const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';
  * Increment this when the storage structure itself changes (not block state migrations).
  */
 const BLOCK_STORAGE_SCHEMA_VERSION = 'v1';
+/**
+ * Default data version for new blocks without migrations.
+ * Unique identifier ensures blocks are created via DataModel API.
+ */
+const DATA_MODEL_DEFAULT_VERSION = '__pl_v1_d4e8f2a1__';
 /**
  * Type guard to check if a value is a valid BlockStorage object.
  * Checks for the discriminator key and valid schema version.
@@ -42,10 +47,10 @@ function isBlockStorage(value) {
  * Creates a BlockStorage with the given initial data
  *
  * @param initialData - The initial data value (defaults to empty object)
- * @param version - The initial data version (defaults to 1)
+ * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)
  * @returns A new BlockStorage instance with discriminator key
  */
-function createBlockStorage(initialData = {}, version = 1) {
+function createBlockStorage(initialData = {}, version = DATA_MODEL_DEFAULT_VERSION) {
     return {
         [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,
         __dataVersion: version,
@@ -62,10 +67,11 @@ function createBlockStorage(initialData = {}, version = 1) {
  */
 function normalizeBlockStorage(raw) {
     if (isBlockStorage(raw)) {
-        return raw;
+        const storage = raw;
+        return { ...storage, __dataVersion: String(storage.__dataVersion) };
     }
     // Legacy format: raw is the state directly
-    return createBlockStorage(raw, 1);
+    return createBlockStorage(raw);
 }
 // =============================================================================
 // Data Access & Update Functions
@@ -114,7 +120,7 @@ function updateStorageData(storage, payload) {
  * Gets the data version from BlockStorage
  *
  * @param storage - The BlockStorage instance
- * @returns The data version number
+ * @returns The data version key
  */
 function getStorageDataVersion(storage) {
     return storage.__dataVersion;
@@ -123,7 +129,7 @@ function getStorageDataVersion(storage) {
  * Updates the data version in BlockStorage (immutable)
  *
  * @param storage - The current BlockStorage
- * @param version - The new version number
+ * @param version - The new version key
  * @returns A new BlockStorage with updated version
  */
 function updateStorageDataVersion(storage, version) {
@@ -225,6 +231,7 @@ function mergeBlockStorageHandlers(customHandlers) {
 
 exports.BLOCK_STORAGE_KEY = BLOCK_STORAGE_KEY;
 exports.BLOCK_STORAGE_SCHEMA_VERSION = BLOCK_STORAGE_SCHEMA_VERSION;
+exports.DATA_MODEL_DEFAULT_VERSION = DATA_MODEL_DEFAULT_VERSION;
 exports.createBlockStorage = createBlockStorage;
 exports.defaultBlockStorageHandlers = defaultBlockStorageHandlers;
 exports.deriveDataFromStorage = deriveDataFromStorage;

package/dist/block_storage.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"block_storage.cjs","sources":["../src/block_storage.ts"],"sourcesContent":["/**\n * BlockStorage - Typed storage abstraction for block persistent data.\n *\n * This module provides:\n * - A typed structure for block storage with versioning and plugin support\n * - Utility functions for manipulating storage\n * - Handler interfaces for model-level customization\n *\n * @module block_storage\n */\n\n// =============================================================================\n// Core Types\n// =============================================================================\n\n/**\n * Discriminator key for BlockStorage format detection.\n * This unique hash-based key identifies data as BlockStorage vs legacy formats.\n */\nexport const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';\n\n/**\n * Current BlockStorage schema version.\n * Increment this when the storage structure itself changes (not block state migrations).\n */\nexport const BLOCK_STORAGE_SCHEMA_VERSION = 'v1';\n\n/**\n * Type for valid schema versions\n */\nexport type BlockStorageSchemaVersion = 'v1'; // Add 'v2', 'v3', etc. as schema evolves\n\n/**\n * Plugin key type - keys starting with `@plugin/` are reserved for plugin data\n */\nexport type PluginKey = `@plugin/${string}`;\n\n/**\n * Core BlockStorage type that holds:\n * - __pl_a7f3e2b9__: Schema version (discriminator key identifies BlockStorage format)\n * - __dataVersion: Version number for block data migrations\n * - __data: The block's user-facing data (state)\n * - @plugin/*: Optional plugin-specific data\n */\nexport type BlockStorage<TState = unknown> = {\n  /** Schema version - the key itself is the discriminator */\n  readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion;\n  /** Version of the block data, used for migrations */\n  __dataVersion: number;\n  /** The block's user-facing data (state) */\n  __data: TState;\n} & {\n  /** Plugin-specific data, keyed by `@plugin/<pluginName>` */\n  [K in PluginKey]?: unknown;\n};\n\n/**\n * Type guard to check if a value is a valid BlockStorage object.\n * Checks for the discriminator key and valid schema version.\n */\nexport function isBlockStorage(value: unknown): value is BlockStorage {\n  if (value === null || typeof value !== 'object') return false;\n  const obj = value as Record<string, unknown>;\n  const schemaVersion = obj[BLOCK_STORAGE_KEY];\n  // Currently only 'v1' is valid, but this allows future versions\n  return schemaVersion === 'v1'; // Add more versions as schema evolves\n}\n\n// =============================================================================\n// Factory Functions\n// =============================================================================\n\n/**\n * Creates a BlockStorage with the given initial data\n *\n * @param initialData - The initial data value (defaults to empty object)\n * @param version - The initial data version (defaults to 1)\n * @returns A new BlockStorage instance with discriminator key\n */\nexport function createBlockStorage<TState = unknown>(\n  initialData: TState = {} as TState,\n  version: number = 1,\n): BlockStorage<TState> {\n  return {\n    [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,\n    __dataVersion: version,\n    __data: initialData,\n  };\n}\n\n/**\n * Normalizes raw storage data to BlockStorage format.\n * If the input is already a BlockStorage, returns it as-is.\n * If the input is legacy format (raw state), wraps it in BlockStorage structure.\n *\n * @param raw - Raw storage data (may be legacy format or BlockStorage)\n * @returns Normalized BlockStorage\n */\nexport function normalizeBlockStorage<TState = unknown>(raw: unknown): BlockStorage<TState> {\n  if (isBlockStorage(raw)) {\n    return raw as BlockStorage<TState>;\n  }\n  // Legacy format: raw is the state directly\n  return createBlockStorage(raw as TState, 1);\n}\n\n// =============================================================================\n// Data Access & Update Functions\n// =============================================================================\n\n/**\n * Gets the data from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @returns The data value\n */\nexport function getStorageData<TState>(storage: BlockStorage<TState>): TState {\n  return storage.__data;\n}\n\n/**\n * Derives data from raw block storage.\n * This function is meant to be called from sdk/ui-vue to extract\n * user-facing data from the raw storage returned by the middle layer.\n *\n * The middle layer returns raw storage (opaque to it), and the UI\n * uses this function to derive the actual data value.\n *\n * @param rawStorage - Raw storage data from middle layer (may be any format)\n * @returns The extracted data value, or undefined if storage is undefined/null\n */\nexport function deriveDataFromStorage<TData = unknown>(\n  rawStorage: unknown,\n): TData {\n  // Normalize to BlockStorage format (handles legacy formats too)\n  const storage = normalizeBlockStorage<TData>(rawStorage);\n  return getStorageData(storage);\n}\n\n/** Payload for storage mutation operations. SDK defines specific operations. */\nexport type MutateStoragePayload<T = unknown> = { operation: 'update-data'; value: T };\n\n/**\n * Updates the data in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param payload - The update payload with operation and value\n * @returns A new BlockStorage with updated data\n */\nexport function updateStorageData<TValue = unknown>(\n  storage: BlockStorage<TValue>,\n  payload: MutateStoragePayload<TValue>,\n): BlockStorage<TValue> {\n  switch (payload.operation) {\n    case 'update-data':\n      return { ...storage, __data: payload.value };\n    default:\n      throw new Error(`Unknown storage operation: ${(payload as { operation: string }).operation}`);\n  }\n}\n\n/**\n * Gets the data version from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @returns The data version number\n */\nexport function getStorageDataVersion(storage: BlockStorage): number {\n  return storage.__dataVersion;\n}\n\n/**\n * Updates the data version in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param version - The new version number\n * @returns A new BlockStorage with updated version\n */\nexport function updateStorageDataVersion<TState>(\n  storage: BlockStorage<TState>,\n  version: number,\n): BlockStorage<TState> {\n  return { ...storage, __dataVersion: version };\n}\n\n/**\n * Storage debug view returned by __pl_storage_debugView callback.\n * Used by developer tools to display block storage info.\n */\nexport interface StorageDebugView {\n  /** Current data version (1-based, starts at 1) */\n  dataVersion: number;\n  /** Raw data payload stored in BlockStorage */\n  data: unknown;\n}\n\n// =============================================================================\n// Plugin Data Functions\n// =============================================================================\n\n/**\n * Gets plugin-specific data from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @returns The plugin data or undefined if not set\n */\nexport function getPluginData<TData = unknown>(\n  storage: BlockStorage,\n  pluginName: string,\n): TData | undefined {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  return storage[key] as TData | undefined;\n}\n\n/**\n * Sets plugin-specific data in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @param data - The plugin data to store\n * @returns A new BlockStorage with updated plugin data\n */\nexport function setPluginData<TState>(\n  storage: BlockStorage<TState>,\n  pluginName: string,\n  data: unknown,\n): BlockStorage<TState> {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  return { ...storage, [key]: data };\n}\n\n/**\n * Removes plugin-specific data from BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @returns A new BlockStorage with the plugin data removed\n */\nexport function removePluginData<TState>(\n  storage: BlockStorage<TState>,\n  pluginName: string,\n): BlockStorage<TState> {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  const { [key]: _, ...rest } = storage;\n  return rest as BlockStorage<TState>;\n}\n\n/**\n * Gets all plugin names that have data stored\n *\n * @param storage - The BlockStorage instance\n * @returns Array of plugin names (without `@plugin/` prefix)\n */\nexport function getPluginNames(storage: BlockStorage): string[] {\n  return Object.keys(storage)\n    .filter((key): key is PluginKey => key.startsWith('@plugin/'))\n    .map((key) => key.slice('@plugin/'.length));\n}\n\n// =============================================================================\n// Generic Storage Access\n// =============================================================================\n\n/**\n * Gets a value from BlockStorage by key\n *\n * @param storage - The BlockStorage instance\n * @param key - The key to retrieve\n * @returns The value at the given key\n */\nexport function getFromStorage<\n  TState,\n  K extends keyof BlockStorage<TState>,\n>(storage: BlockStorage<TState>, key: K): BlockStorage<TState>[K] {\n  return storage[key];\n}\n\n/**\n * Updates a value in BlockStorage by key (immutable)\n *\n * @param storage - The current BlockStorage\n * @param key - The key to update\n * @param value - The new value\n * @returns A new BlockStorage with the updated value\n */\nexport function updateStorage<\n  TState,\n  K extends keyof BlockStorage<TState>,\n>(\n  storage: BlockStorage<TState>,\n  key: K,\n  value: BlockStorage<TState>[K],\n): BlockStorage<TState> {\n  return { ...storage, [key]: value };\n}\n\n// =============================================================================\n// Storage Handlers (for Phase 2 - Model-Level Customization)\n// =============================================================================\n\n/**\n * Interface for model-configurable storage operations.\n * These handlers allow block models to customize how storage is managed.\n */\nexport interface BlockStorageHandlers<TState = unknown> {\n  /**\n   * Called when setState is invoked - transforms the new state before storing.\n   * Default behavior: replaces the state directly.\n   *\n   * @param currentStorage - The current BlockStorage\n   * @param newState - The new state being set\n   * @returns The updated BlockStorage\n   */\n  transformStateForStorage?: (\n    currentStorage: BlockStorage<TState>,\n    newState: TState,\n  ) => BlockStorage<TState>;\n\n  /**\n   * Called when reading state for args derivation.\n   * Default behavior: returns the state directly.\n   *\n   * @param storage - The current BlockStorage\n   * @returns The state to use for args derivation\n   */\n  deriveStateForArgs?: (storage: BlockStorage<TState>) => TState;\n\n  /**\n   * Called during storage schema migration.\n   * Default behavior: updates stateVersion only.\n   *\n   * @param oldStorage - The storage before migration\n   * @param fromVersion - The version migrating from\n   * @param toVersion - The version migrating to\n   * @returns The migrated BlockStorage\n   */\n  migrateStorage?: (\n    oldStorage: BlockStorage<TState>,\n    fromVersion: number,\n    toVersion: number,\n  ) => BlockStorage<TState>;\n}\n\n/**\n * Default implementations of storage handlers\n */\nexport const defaultBlockStorageHandlers: Required<BlockStorageHandlers<unknown>> = {\n  transformStateForStorage: <TState>(\n    storage: BlockStorage<TState>,\n    newState: TState,\n  ): BlockStorage<TState> => updateStorageData(storage, { operation: 'update-data', value: newState }),\n\n  deriveStateForArgs: <TState>(storage: BlockStorage<TState>): TState => getStorageData(storage),\n\n  migrateStorage: <TState>(\n    storage: BlockStorage<TState>,\n    _fromVersion: number,\n    toVersion: number,\n  ): BlockStorage<TState> => updateStorageDataVersion(storage, toVersion),\n};\n\n/**\n * Merges custom handlers with defaults\n *\n * @param customHandlers - Custom handlers to merge\n * @returns Complete handlers with defaults for missing functions\n */\nexport function mergeBlockStorageHandlers<TState>(\n  customHandlers?: BlockStorageHandlers<TState>,\n): Required<BlockStorageHandlers<TState>> {\n  return {\n    ...defaultBlockStorageHandlers,\n    ...customHandlers,\n  } as Required<BlockStorageHandlers<TState>>;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"block_storage.cjs","sources":["../src/block_storage.ts"],"sourcesContent":["/**\n * BlockStorage - Typed storage abstraction for block persistent data.\n *\n * This module provides:\n * - A typed structure for block storage with versioning and plugin support\n * - Utility functions for manipulating storage\n * - Handler interfaces for model-level customization\n *\n * @module block_storage\n */\n\n// =============================================================================\n// Core Types\n// =============================================================================\n\n/**\n * Discriminator key for BlockStorage format detection.\n * This unique hash-based key identifies data as BlockStorage vs legacy formats.\n */\nexport const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';\n\n/**\n * Current BlockStorage schema version.\n * Increment this when the storage structure itself changes (not block state migrations).\n */\nexport const BLOCK_STORAGE_SCHEMA_VERSION = 'v1';\n\n/**\n * Default data version for new blocks without migrations.\n * Unique identifier ensures blocks are created via DataModel API.\n */\nexport const DATA_MODEL_DEFAULT_VERSION = '__pl_v1_d4e8f2a1__';\n\n/**\n * Type for valid schema versions\n */\nexport type BlockStorageSchemaVersion = 'v1'; // Add 'v2', 'v3', etc. as schema evolves\n\n/**\n * Plugin key type - keys starting with `@plugin/` are reserved for plugin data\n */\nexport type PluginKey = `@plugin/${string}`;\n\n/**\n * Core BlockStorage type that holds:\n * - __pl_a7f3e2b9__: Schema version (discriminator key identifies BlockStorage format)\n * - __dataVersion: Version key for block data migrations\n * - __data: The block's user-facing data (state)\n * - @plugin/*: Optional plugin-specific data\n */\nexport type BlockStorage<TState = unknown> = {\n  /** Schema version - the key itself is the discriminator */\n  readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion;\n  /** Version of the block data, used for migrations */\n  __dataVersion: string;\n  /** The block's user-facing data (state) */\n  __data: TState;\n} & {\n  /** Plugin-specific data, keyed by `@plugin/<pluginName>` */\n  [K in PluginKey]?: unknown;\n};\n\n/**\n * Type guard to check if a value is a valid BlockStorage object.\n * Checks for the discriminator key and valid schema version.\n */\nexport function isBlockStorage(value: unknown): value is BlockStorage {\n  if (value === null || typeof value !== 'object') return false;\n  const obj = value as Record<string, unknown>;\n  const schemaVersion = obj[BLOCK_STORAGE_KEY];\n  // Currently only 'v1' is valid, but this allows future versions\n  return schemaVersion === 'v1'; // Add more versions as schema evolves\n}\n\n// =============================================================================\n// Factory Functions\n// =============================================================================\n\n/**\n * Creates a BlockStorage with the given initial data\n *\n * @param initialData - The initial data value (defaults to empty object)\n * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)\n * @returns A new BlockStorage instance with discriminator key\n */\nexport function createBlockStorage<TState = unknown>(\n  initialData: TState = {} as TState,\n  version: string = DATA_MODEL_DEFAULT_VERSION,\n): BlockStorage<TState> {\n  return {\n    [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,\n    __dataVersion: version,\n    __data: initialData,\n  };\n}\n\n/**\n * Normalizes raw storage data to BlockStorage format.\n * If the input is already a BlockStorage, returns it as-is.\n * If the input is legacy format (raw state), wraps it in BlockStorage structure.\n *\n * @param raw - Raw storage data (may be legacy format or BlockStorage)\n * @returns Normalized BlockStorage\n */\nexport function normalizeBlockStorage<TState = unknown>(raw: unknown): BlockStorage<TState> {\n  if (isBlockStorage(raw)) {\n    const storage = raw as BlockStorage<TState>;\n    return { ...storage, __dataVersion: String(storage.__dataVersion) };\n  }\n  // Legacy format: raw is the state directly\n  return createBlockStorage(raw as TState);\n}\n\n// =============================================================================\n// Data Access & Update Functions\n// =============================================================================\n\n/**\n * Gets the data from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @returns The data value\n */\nexport function getStorageData<TState>(storage: BlockStorage<TState>): TState {\n  return storage.__data;\n}\n\n/**\n * Derives data from raw block storage.\n * This function is meant to be called from sdk/ui-vue to extract\n * user-facing data from the raw storage returned by the middle layer.\n *\n * The middle layer returns raw storage (opaque to it), and the UI\n * uses this function to derive the actual data value.\n *\n * @param rawStorage - Raw storage data from middle layer (may be any format)\n * @returns The extracted data value, or undefined if storage is undefined/null\n */\nexport function deriveDataFromStorage<TData = unknown>(\n  rawStorage: unknown,\n): TData {\n  // Normalize to BlockStorage format (handles legacy formats too)\n  const storage = normalizeBlockStorage<TData>(rawStorage);\n  return getStorageData(storage);\n}\n\n/** Payload for storage mutation operations. SDK defines specific operations. */\nexport type MutateStoragePayload<T = unknown> = { operation: 'update-data'; value: T };\n\n/**\n * Updates the data in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param payload - The update payload with operation and value\n * @returns A new BlockStorage with updated data\n */\nexport function updateStorageData<TValue = unknown>(\n  storage: BlockStorage<TValue>,\n  payload: MutateStoragePayload<TValue>,\n): BlockStorage<TValue> {\n  switch (payload.operation) {\n    case 'update-data':\n      return { ...storage, __data: payload.value };\n    default:\n      throw new Error(`Unknown storage operation: ${(payload as { operation: string }).operation}`);\n  }\n}\n\n/**\n * Gets the data version from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @returns The data version key\n */\nexport function getStorageDataVersion(storage: BlockStorage): string {\n  return storage.__dataVersion;\n}\n\n/**\n * Updates the data version in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param version - The new version key\n * @returns A new BlockStorage with updated version\n */\nexport function updateStorageDataVersion<TState>(\n  storage: BlockStorage<TState>,\n  version: string,\n): BlockStorage<TState> {\n  return { ...storage, __dataVersion: version };\n}\n\n/**\n * Storage debug view returned by __pl_storage_debugView callback.\n * Used by developer tools to display block storage info.\n */\nexport interface StorageDebugView {\n  /** Current data version key */\n  dataVersion: string;\n  /** Raw data payload stored in BlockStorage */\n  data: unknown;\n}\n\n// =============================================================================\n// Plugin Data Functions\n// =============================================================================\n\n/**\n * Gets plugin-specific data from BlockStorage\n *\n * @param storage - The BlockStorage instance\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @returns The plugin data or undefined if not set\n */\nexport function getPluginData<TData = unknown>(\n  storage: BlockStorage,\n  pluginName: string,\n): TData | undefined {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  return storage[key] as TData | undefined;\n}\n\n/**\n * Sets plugin-specific data in BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @param data - The plugin data to store\n * @returns A new BlockStorage with updated plugin data\n */\nexport function setPluginData<TState>(\n  storage: BlockStorage<TState>,\n  pluginName: string,\n  data: unknown,\n): BlockStorage<TState> {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  return { ...storage, [key]: data };\n}\n\n/**\n * Removes plugin-specific data from BlockStorage (immutable)\n *\n * @param storage - The current BlockStorage\n * @param pluginName - The plugin name (without `@plugin/` prefix)\n * @returns A new BlockStorage with the plugin data removed\n */\nexport function removePluginData<TState>(\n  storage: BlockStorage<TState>,\n  pluginName: string,\n): BlockStorage<TState> {\n  const key: PluginKey = `@plugin/${pluginName}`;\n  const { [key]: _, ...rest } = storage;\n  return rest as BlockStorage<TState>;\n}\n\n/**\n * Gets all plugin names that have data stored\n *\n * @param storage - The BlockStorage instance\n * @returns Array of plugin names (without `@plugin/` prefix)\n */\nexport function getPluginNames(storage: BlockStorage): string[] {\n  return Object.keys(storage)\n    .filter((key): key is PluginKey => key.startsWith('@plugin/'))\n    .map((key) => key.slice('@plugin/'.length));\n}\n\n// =============================================================================\n// Generic Storage Access\n// =============================================================================\n\n/**\n * Gets a value from BlockStorage by key\n *\n * @param storage - The BlockStorage instance\n * @param key - The key to retrieve\n * @returns The value at the given key\n */\nexport function getFromStorage<\n  TState,\n  K extends keyof BlockStorage<TState>,\n>(storage: BlockStorage<TState>, key: K): BlockStorage<TState>[K] {\n  return storage[key];\n}\n\n/**\n * Updates a value in BlockStorage by key (immutable)\n *\n * @param storage - The current BlockStorage\n * @param key - The key to update\n * @param value - The new value\n * @returns A new BlockStorage with the updated value\n */\nexport function updateStorage<\n  TState,\n  K extends keyof BlockStorage<TState>,\n>(\n  storage: BlockStorage<TState>,\n  key: K,\n  value: BlockStorage<TState>[K],\n): BlockStorage<TState> {\n  return { ...storage, [key]: value };\n}\n\n// =============================================================================\n// Storage Handlers (for Phase 2 - Model-Level Customization)\n// =============================================================================\n\n/**\n * Interface for model-configurable storage operations.\n * These handlers allow block models to customize how storage is managed.\n */\nexport interface BlockStorageHandlers<TState = unknown> {\n  /**\n   * Called when setState is invoked - transforms the new state before storing.\n   * Default behavior: replaces the state directly.\n   *\n   * @param currentStorage - The current BlockStorage\n   * @param newState - The new state being set\n   * @returns The updated BlockStorage\n   */\n  transformStateForStorage?: (\n    currentStorage: BlockStorage<TState>,\n    newState: TState,\n  ) => BlockStorage<TState>;\n\n  /**\n   * Called when reading state for args derivation.\n   * Default behavior: returns the state directly.\n   *\n   * @param storage - The current BlockStorage\n   * @returns The state to use for args derivation\n   */\n  deriveStateForArgs?: (storage: BlockStorage<TState>) => TState;\n\n  /**\n   * Called during storage schema migration.\n   * Default behavior: updates stateVersion only.\n   *\n   * @param oldStorage - The storage before migration\n   * @param fromVersion - The version migrating from\n   * @param toVersion - The version migrating to\n   * @returns The migrated BlockStorage\n   */\n  migrateStorage?: (\n    oldStorage: BlockStorage<TState>,\n    fromVersion: string,\n    toVersion: string,\n  ) => BlockStorage<TState>;\n}\n\n/**\n * Default implementations of storage handlers\n */\nexport const defaultBlockStorageHandlers: Required<BlockStorageHandlers<unknown>> = {\n  transformStateForStorage: <TState>(\n    storage: BlockStorage<TState>,\n    newState: TState,\n  ): BlockStorage<TState> => updateStorageData(storage, { operation: 'update-data', value: newState }),\n\n  deriveStateForArgs: <TState>(storage: BlockStorage<TState>): TState => getStorageData(storage),\n\n  migrateStorage: <TState>(\n    storage: BlockStorage<TState>,\n    _fromVersion: string,\n    toVersion: string,\n  ): BlockStorage<TState> => updateStorageDataVersion(storage, toVersion),\n};\n\n/**\n * Merges custom handlers with defaults\n *\n * @param customHandlers - Custom handlers to merge\n * @returns Complete handlers with defaults for missing functions\n */\nexport function mergeBlockStorageHandlers<TState>(\n  customHandlers?: BlockStorageHandlers<TState>,\n): Required<BlockStorageHandlers<TState>> {\n  return {\n    ...defaultBlockStorageHandlers,\n    ...customHandlers,\n  } as Required<BlockStorageHandlers<TState>>;\n}\n"],"names":[],"mappings":"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"}

package/dist/block_storage.d.ts

@@ -18,6 +18,11 @@ export declare const BLOCK_STORAGE_KEY = "__pl_a7f3e2b9__";
  * Increment this when the storage structure itself changes (not block state migrations).
  */
 export declare const BLOCK_STORAGE_SCHEMA_VERSION = "v1";
+/**
+ * Default data version for new blocks without migrations.
+ * Unique identifier ensures blocks are created via DataModel API.
+ */
+export declare const DATA_MODEL_DEFAULT_VERSION = "__pl_v1_d4e8f2a1__";
 /**
  * Type for valid schema versions
  */
@@ -29,7 +34,7 @@ export type PluginKey = `@plugin/${string}`;
 /**
  * Core BlockStorage type that holds:
  * - __pl_a7f3e2b9__: Schema version (discriminator key identifies BlockStorage format)
- * - __dataVersion: Version number for block data migrations
+ * - __dataVersion: Version key for block data migrations
  * - __data: The block's user-facing data (state)
  * - @plugin/*: Optional plugin-specific data
  */
@@ -37,7 +42,7 @@ export type BlockStorage<TState = unknown> = {
     /** Schema version - the key itself is the discriminator */
     readonly [BLOCK_STORAGE_KEY]: BlockStorageSchemaVersion;
     /** Version of the block data, used for migrations */
-    __dataVersion: number;
+    __dataVersion: string;
     /** The block's user-facing data (state) */
     __data: TState;
 } & {
@@ -52,10 +57,10 @@ export declare function isBlockStorage(value: unknown): value is BlockStorage;
  * Creates a BlockStorage with the given initial data
  *
  * @param initialData - The initial data value (defaults to empty object)
- * @param version - The initial data version (defaults to 1)
+ * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)
  * @returns A new BlockStorage instance with discriminator key
  */
-export declare function createBlockStorage<TState = unknown>(initialData?: TState, version?: number): BlockStorage<TState>;
+export declare function createBlockStorage<TState = unknown>(initialData?: TState, version?: string): BlockStorage<TState>;
 /**
  * Normalizes raw storage data to BlockStorage format.
  * If the input is already a BlockStorage, returns it as-is.
@@ -101,24 +106,24 @@ export declare function updateStorageData<TValue = unknown>(storage: BlockStorag
  * Gets the data version from BlockStorage
  *
  * @param storage - The BlockStorage instance
- * @returns The data version number
+ * @returns The data version key
  */
-export declare function getStorageDataVersion(storage: BlockStorage): number;
+export declare function getStorageDataVersion(storage: BlockStorage): string;
 /**
  * Updates the data version in BlockStorage (immutable)
  *
  * @param storage - The current BlockStorage
- * @param version - The new version number
+ * @param version - The new version key
  * @returns A new BlockStorage with updated version
  */
-export declare function updateStorageDataVersion<TState>(storage: BlockStorage<TState>, version: number): BlockStorage<TState>;
+export declare function updateStorageDataVersion<TState>(storage: BlockStorage<TState>, version: string): BlockStorage<TState>;
 /**
  * Storage debug view returned by __pl_storage_debugView callback.
  * Used by developer tools to display block storage info.
  */
 export interface StorageDebugView {
-    /** Current data version (1-based, starts at 1) */
-    dataVersion: number;
+    /** Current data version key */
+    dataVersion: string;
     /** Raw data payload stored in BlockStorage */
     data: unknown;
 }
@@ -202,7 +207,7 @@ export interface BlockStorageHandlers<TState = unknown> {
      * @param toVersion - The version migrating to
      * @returns The migrated BlockStorage
      */
-    migrateStorage?: (oldStorage: BlockStorage<TState>, fromVersion: number, toVersion: number) => BlockStorage<TState>;
+    migrateStorage?: (oldStorage: BlockStorage<TState>, fromVersion: string, toVersion: string) => BlockStorage<TState>;
 }
 /**
  * Default implementations of storage handlers

package/dist/block_storage.d.ts.map

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

package/dist/block_storage.js

@@ -21,6 +21,11 @@ const BLOCK_STORAGE_KEY = '__pl_a7f3e2b9__';
  * Increment this when the storage structure itself changes (not block state migrations).
  */
 const BLOCK_STORAGE_SCHEMA_VERSION = 'v1';
+/**
+ * Default data version for new blocks without migrations.
+ * Unique identifier ensures blocks are created via DataModel API.
+ */
+const DATA_MODEL_DEFAULT_VERSION = '__pl_v1_d4e8f2a1__';
 /**
  * Type guard to check if a value is a valid BlockStorage object.
  * Checks for the discriminator key and valid schema version.
@@ -40,10 +45,10 @@ function isBlockStorage(value) {
  * Creates a BlockStorage with the given initial data
  *
  * @param initialData - The initial data value (defaults to empty object)
- * @param version - The initial data version (defaults to 1)
+ * @param version - The initial data version key (defaults to DATA_MODEL_DEFAULT_VERSION)
  * @returns A new BlockStorage instance with discriminator key
  */
-function createBlockStorage(initialData = {}, version = 1) {
+function createBlockStorage(initialData = {}, version = DATA_MODEL_DEFAULT_VERSION) {
     return {
         [BLOCK_STORAGE_KEY]: BLOCK_STORAGE_SCHEMA_VERSION,
         __dataVersion: version,
@@ -60,10 +65,11 @@ function createBlockStorage(initialData = {}, version = 1) {
  */
 function normalizeBlockStorage(raw) {
     if (isBlockStorage(raw)) {
-        return raw;
+        const storage = raw;
+        return { ...storage, __dataVersion: String(storage.__dataVersion) };
     }
     // Legacy format: raw is the state directly
-    return createBlockStorage(raw, 1);
+    return createBlockStorage(raw);
 }
 // =============================================================================
 // Data Access & Update Functions
@@ -112,7 +118,7 @@ function updateStorageData(storage, payload) {
  * Gets the data version from BlockStorage
  *
  * @param storage - The BlockStorage instance
- * @returns The data version number
+ * @returns The data version key
  */
 function getStorageDataVersion(storage) {
     return storage.__dataVersion;
@@ -121,7 +127,7 @@ function getStorageDataVersion(storage) {
  * Updates the data version in BlockStorage (immutable)
  *
  * @param storage - The current BlockStorage
- * @param version - The new version number
+ * @param version - The new version key
  * @returns A new BlockStorage with updated version
  */
 function updateStorageDataVersion(storage, version) {
@@ -221,5 +227,5 @@ function mergeBlockStorageHandlers(customHandlers) {
     };
 }
 
-export { BLOCK_STORAGE_KEY, BLOCK_STORAGE_SCHEMA_VERSION, createBlockStorage, defaultBlockStorageHandlers, deriveDataFromStorage, getFromStorage, getPluginData, getPluginNames, getStorageData, getStorageDataVersion, isBlockStorage, mergeBlockStorageHandlers, normalizeBlockStorage, removePluginData, setPluginData, updateStorage, updateStorageData, updateStorageDataVersion };
+export { BLOCK_STORAGE_KEY, BLOCK_STORAGE_SCHEMA_VERSION, DATA_MODEL_DEFAULT_VERSION, createBlockStorage, defaultBlockStorageHandlers, deriveDataFromStorage, getFromStorage, getPluginData, getPluginNames, getStorageData, getStorageDataVersion, isBlockStorage, mergeBlockStorageHandlers, normalizeBlockStorage, removePluginData, setPluginData, updateStorage, updateStorageData, updateStorageDataVersion };
 //# sourceMappingURL=block_storage.js.map