@aws-blocks/bb-distributed-table 0.1.2 → 0.1.4

package/src/index.cdk.ts

@@ -15,7 +15,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 
 export { DistributedTableErrors } from './errors.js';
-export type { DistributedTableOptions, TableKeyConfig, TableKey, PutOptions, DeleteOptions, QueryOptions, ScanOptions, ExternalTableRef } from './types.js';
+export type { DistributedTableOptions, ReadValidationMode, TableKeyConfig, TableKey, PutOptions, DeleteOptions, QueryOptions, ScanOptions, ExternalTableRef } from './types.js';
 
 export class DistributedTable<T = any> extends Scope {
 	private table: ITable;

package/src/index.mock.ts

@@ -13,6 +13,7 @@ export { DistributedTableErrors } from './errors.js';
 export type {
 	TableKeyConfig,
 	DistributedTableOptions,
+	ReadValidationMode,
 	ExternalTableRef,
 	TableKey,
 	PartitionKeyCondition,
@@ -33,8 +34,9 @@ import type {
 	PutOptions,
 	DeleteOptions,
 	TableKey,
+	ReadValidationMode,
 } from './types.js';
-import { DistributedTableErrors, DistributedTableMessages, blocksError, normalizeSortKeyCondition } from './errors.js';
+import { DistributedTableErrors, DistributedTableMessages, blocksError, normalizeSortKeyCondition, applyReadValidation } from './errors.js';
 
 // ── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -125,23 +127,38 @@ export class DistributedTable<
 	private schema: StandardSchemaV1<T>;
 	private keyConfig: K;
 	private indexes: Indexes;
+	private readValidation: ReadValidationMode;
 
-	/** @internal Logger for internal operations. Defaults to error-level when not provided. */
+	/** @internal Logger for internal operations. Defaults to warn-level when not provided. */
 	protected log: ChildLogger;
 
 	constructor(scope: ScopeParent, id: string, public options: DistributedTableOptions<T, K, Indexes>) {
 		super(id, { parent: scope, bbName: BB_NAME, bbVersion: BB_VERSION });
-		this.log = options?.logger ?? new Logger(this, 'logger', { level: 'error' });
+		// Default level is 'warn' (not 'error') so the readValidation='coerce'
+		// raw-fallback warning actually surfaces — it's the only log the block
+		// emits, so this doesn't add noise. Callers can pass their own logger.
+		this.log = options?.logger ?? new Logger(this, 'logger', { level: 'warn' });
 		this.filePath = join(getMockDataDir(this), 'data.json');
 		this.data = this.loadFromDisk();
 		this.schema = options.schema;
 		this.keyConfig = options.key;
 		this.indexes = (options.indexes ?? {}) as Indexes;
+		this.readValidation = options.readValidation ?? 'coerce';
 		registerSdkIdentifiers(this.fullId, { tableName: `mock-${this.fullId}`.substring(0, 255) });
 	}
 
 	async get(key: TableKey<T, K>): Promise<T | null> {
-		return this.data.get(this.serializeKey(key)) ?? null;
+		return this.reconcileRead(this.data.get(this.serializeKey(key)) ?? null);
+	}
+
+	/**
+	 * Reconcile a stored value with the schema per this table's `readValidation`
+	 * mode (`off` → raw, `coerce` → coerced output / raw+warn on failure, `strict`
+	 * → throw on mismatch). `null` (a missing item) passes straight through. See
+	 * {@link applyReadValidation}.
+	 */
+	private reconcileRead(item: T | null): Promise<T | null> {
+		return applyReadValidation(this.readValidation, this.schema, item, this.log, { table: this.fullId });
 	}
 
 	async put(item: T, options?: PutOptions<T>): Promise<void> {
@@ -253,7 +270,7 @@ export class DistributedTable<
 
 		let count = 0;
 		for (const item of items) {
-			yield item;
+			yield (await this.reconcileRead(item)) as T;
 			if (options.limit && ++count >= options.limit) return;
 		}
 	}
@@ -261,7 +278,7 @@ export class DistributedTable<
 	async *scan(options?: ScanOptions): AsyncIterable<T> {
 		let count = 0;
 		for (const item of this.data.values()) {
-			yield item;
+			yield (await this.reconcileRead(item)) as T;
 			if (options?.limit && ++count >= options.limit) return;
 		}
 	}
@@ -275,7 +292,9 @@ export class DistributedTable<
 	 *   sustained throttling. The local mock never throttles, so it does not throw this.
 	 */
 	async getBatch(keys: TableKey<T, K>[]): Promise<(T | null)[]> {
-		return keys.map(key => this.data.get(this.serializeKey(key)) ?? null);
+		return Promise.all(
+			keys.map(key => this.reconcileRead(this.data.get(this.serializeKey(key)) ?? null)),
+		);
 	}
 
 	/**

package/src/index.test.ts

@@ -219,6 +219,211 @@ describe('DistributedTable', () => {
 		});
 	});
 
+	// ── readValidation (off | coerce | strict) ────────────────────────────────
+	// Regression for the bug bash finding #1007: get() returned raw stored values
+	// without reconciling them against the schema, so after a schema change a legacy
+	// row no longer conformed to T — an added field was absent (a schema .default()
+	// was neither applied nor persisted on write-back) and a required-no-default
+	// field made the put() half of the read-modify-write cycle throw ValidationFailed.
+	// `readValidation` defaults to 'coerce', which closes the coercible gap.
+
+	describe('readValidation', () => {
+		// V1: no `currency`. V2: adds `currency` with a default.
+		const orderV1 = z.object({ orderId: z.string(), total: z.number() });
+		const orderV2 = z.object({
+			orderId: z.string(),
+			total: z.number(),
+			currency: z.string().default('USD'),
+		});
+
+		// Fixed scope so a V1 writer and a V2 reader share the same on-disk table,
+		// simulating a schema augmentation over pre-existing (legacy) rows.
+		function legacyScope() {
+			return new Scope(`dt-legacy-${++scopeCounter}-${Date.now()}`);
+		}
+
+		test("default is 'coerce': get() coerces the legacy row through the current schema (fills default)", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+
+			// No readValidation option → defaults to 'coerce'.
+			const v2 = new DistributedTable(scope, 'orders', { schema: orderV2, key: { partitionKey: 'orderId' } });
+			const row = await v2.get({ orderId: 'o1' });
+			assert.deepEqual(row, { orderId: 'o1', total: 10, currency: 'USD' });
+		});
+
+		test("default 'coerce': coerced read can be written back (fixes the read-modify-write cycle)", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+
+			const v2 = new DistributedTable(scope, 'orders', { schema: orderV2, key: { partitionKey: 'orderId' } });
+			const row = await v2.get({ orderId: 'o1' });
+			assert.ok(row);
+			await v2.put({ ...row, total: 20 }); // must NOT throw ValidationFailed
+			assert.deepEqual(await v2.get({ orderId: 'o1' }), { orderId: 'o1', total: 20, currency: 'USD' });
+		});
+
+		test("'off': get() returns the raw legacy row unchanged (opt-out of coercion)", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+
+			const v2 = new DistributedTable(scope, 'orders', {
+				schema: orderV2, key: { partitionKey: 'orderId' }, readValidation: 'off',
+			});
+			const row = await v2.get({ orderId: 'o1' });
+			assert.deepEqual(row, { orderId: 'o1', total: 10 }); // no currency injected
+		});
+
+		test("'coerce': an unrecoverable row is returned RAW (never throws) so it stays readable", async () => {
+			const scope = legacyScope();
+			// Write a row that violates the strict schema (total is a string, no coercion path).
+			const loose = z.object({ orderId: z.string(), total: z.any() });
+			const strict = z.object({ orderId: z.string(), total: z.number() });
+			const w = new DistributedTable(scope, 'orders', { schema: loose, key: { partitionKey: 'orderId' } });
+			await w.put({ orderId: 'bad', total: 'not-a-number' });
+
+			const r = new DistributedTable(scope, 'orders', {
+				schema: strict, key: { partitionKey: 'orderId' }, readValidation: 'coerce',
+			});
+			const row = await r.get({ orderId: 'bad' }); // must NOT throw
+			assert.deepEqual(row, { orderId: 'bad', total: 'not-a-number' }); // raw fallback
+		});
+
+		test("'coerce' PRESERVES stored keys not in the schema (no silent data loss)", async () => {
+			const scope = legacyScope();
+			// Row stored under a schema that had an extra `legacyNote` field.
+			const wide = z.object({ orderId: z.string(), total: z.number(), legacyNote: z.string() });
+			const narrow = z.object({ orderId: z.string(), total: z.number() }); // current schema no longer declares legacyNote
+			const w = new DistributedTable(scope, 'orders', { schema: wide, key: { partitionKey: 'orderId' } });
+			await w.put({ orderId: 'o1', total: 10, legacyNote: 'keep me' });
+
+			// coerce (default): unknown key is preserved (coerced output merged over the raw item).
+			const coerceReader = new DistributedTable(scope, 'orders', { schema: narrow, key: { partitionKey: 'orderId' } });
+			assert.deepEqual(await coerceReader.get({ orderId: 'o1' }), { orderId: 'o1', total: 10, legacyNote: 'keep me' });
+
+			// off also preserves (raw passthrough) — same observable result here.
+			const offReader = new DistributedTable(scope, 'orders', {
+				schema: narrow, key: { partitionKey: 'orderId' }, readValidation: 'off',
+			});
+			assert.deepEqual(await offReader.get({ orderId: 'o1' }), { orderId: 'o1', total: 10, legacyNote: 'keep me' });
+		});
+
+		test("'coerce' read-modify-write does NOT drop an unknown stored key (the reviewer's scenario)", async () => {
+			const scope = legacyScope();
+			const wide = z.object({ orderId: z.string(), total: z.number(), couponCode: z.string() });
+			const narrow = z.object({ orderId: z.string(), total: z.number() }); // couponCode no longer in schema
+			const seed = new DistributedTable(scope, 'orders', { schema: wide, key: { partitionKey: 'orderId' } });
+			await seed.put({ orderId: 'A1', total: 10, couponCode: 'SAVE10' });
+
+			// Read, change an unrelated field, write back — couponCode must survive.
+			const t = new DistributedTable(scope, 'orders', { schema: narrow, key: { partitionKey: 'orderId' } });
+			const row = await t.get({ orderId: 'A1' });
+			assert.ok(row);
+			await t.put({ ...row, total: 50 });
+			const after = await t.get({ orderId: 'A1' });
+			assert.deepEqual(after, { orderId: 'A1', total: 50, couponCode: 'SAVE10' });
+		});
+
+		test("'coerce' adds a new default AND preserves an unknown key at the same time", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', {
+				schema: z.object({ orderId: z.string(), total: z.number(), couponCode: z.string() }),
+				key: { partitionKey: 'orderId' },
+			});
+			await v1.put({ orderId: 'o1', total: 10, couponCode: 'X' });
+
+			// V2 adds currency (default) and no longer declares couponCode.
+			const v2 = new DistributedTable(scope, 'orders', {
+				schema: z.object({ orderId: z.string(), total: z.number(), currency: z.string().default('USD') }),
+				key: { partitionKey: 'orderId' },
+			});
+			assert.deepEqual(await v2.get({ orderId: 'o1' }), { orderId: 'o1', total: 10, currency: 'USD', couponCode: 'X' });
+		});
+
+		test("'coerce' preserves unknown keys nested inside a known object (deep)", async () => {
+			const scope = legacyScope();
+			const wide = z.object({ orderId: z.string(), meta: z.object({ a: z.number(), legacy: z.boolean() }) });
+			const narrow = z.object({ orderId: z.string(), meta: z.object({ a: z.number() }) }); // dropped meta.legacy
+			const w = new DistributedTable(scope, 'orders', { schema: wide, key: { partitionKey: 'orderId' } });
+			await w.put({ orderId: 'o1', meta: { a: 1, legacy: true } });
+
+			const t = new DistributedTable(scope, 'orders', { schema: narrow, key: { partitionKey: 'orderId' } });
+			assert.deepEqual(await t.get({ orderId: 'o1' }), { orderId: 'o1', meta: { a: 1, legacy: true } });
+		});
+
+		test("'coerce' replaces arrays wholesale — never duplicates elements", async () => {
+			const scope = legacyScope();
+			const schema = z.object({ orderId: z.string(), tags: z.array(z.string()) });
+			const w = new DistributedTable(scope, 'orders', { schema, key: { partitionKey: 'orderId' } });
+			await w.put({ orderId: 'o1', tags: ['a', 'b'] });
+
+			// Same schema on read: coerced tags === raw tags; merge must NOT concat them.
+			const t = new DistributedTable(scope, 'orders', { schema, key: { partitionKey: 'orderId' } });
+			assert.deepEqual(await t.get({ orderId: 'o1' }), { orderId: 'o1', tags: ['a', 'b'] });
+		});
+
+		test("'strict': get() throws ValidationFailed on a non-conforming stored row", async () => {
+			const scope = legacyScope();
+			const loose = z.object({ orderId: z.string(), total: z.any() });
+			const strict = z.object({ orderId: z.string(), total: z.number() });
+			const w = new DistributedTable(scope, 'orders', { schema: loose, key: { partitionKey: 'orderId' } });
+			await w.put({ orderId: 'bad', total: 'not-a-number' });
+
+			const r = new DistributedTable(scope, 'orders', {
+				schema: strict, key: { partitionKey: 'orderId' }, readValidation: 'strict',
+			});
+			await assert.rejects(
+				() => r.get({ orderId: 'bad' }),
+				(err: any) => err.name === 'ValidationFailedException',
+			);
+		});
+
+		test("'strict': a conforming row reads back fine", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+			const r = new DistributedTable(scope, 'orders', {
+				schema: orderV1, key: { partitionKey: 'orderId' }, readValidation: 'strict',
+			});
+			assert.deepEqual(await r.get({ orderId: 'o1' }), { orderId: 'o1', total: 10 });
+		});
+
+		test('get() still returns null for a missing item (all modes)', async () => {
+			for (const readValidation of ['off', 'coerce', 'strict'] as const) {
+				const table = new DistributedTable(testScope(), 'orders', {
+					schema: orderV2, key: { partitionKey: 'orderId' }, readValidation,
+				});
+				assert.equal(await table.get({ orderId: 'nope' }), null);
+			}
+		});
+
+		test("default 'coerce': scan() and query() coerce yielded items", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+			await v1.put({ orderId: 'o2', total: 20 });
+
+			const v2 = new DistributedTable(scope, 'orders', { schema: orderV2, key: { partitionKey: 'orderId' } });
+			const scanned = await collect(v2.scan());
+			assert.ok(scanned.every(o => o.currency === 'USD'));
+			const queried = await collect(v2.query({ where: { orderId: { equals: 'o1' } } }));
+			assert.deepEqual(queried, [{ orderId: 'o1', total: 10, currency: 'USD' }]);
+		});
+
+		test("default 'coerce': getBatch() coerces each hit and preserves null holes", async () => {
+			const scope = legacyScope();
+			const v1 = new DistributedTable(scope, 'orders', { schema: orderV1, key: { partitionKey: 'orderId' } });
+			await v1.put({ orderId: 'o1', total: 10 });
+
+			const v2 = new DistributedTable(scope, 'orders', { schema: orderV2, key: { partitionKey: 'orderId' } });
+			const rows = await v2.getBatch([{ orderId: 'o1' }, { orderId: 'missing' }]);
+			assert.deepEqual(rows, [{ orderId: 'o1', total: 10, currency: 'USD' }, null]);
+		});
+	});
+
 	// ── Query: numeric sort key ─────────────────────────────────────────────
 
 	describe('query (numeric sort key)', () => {

package/src/parity.test.ts

@@ -761,3 +761,79 @@ describe('DistributedTableErrors split the old single Validation bucket into int
 		assert.strictEqual((DistributedTableErrors as any).Validation, undefined);
 	});
 });
+
+describe('readValidation behaves identically on the mock and the AWS runtime', () => {
+	// V2 schema adds `currency` with a default; a legacy row lacks it.
+	const schemaV2 = z.object({ orderId: z.string(), total: z.number(), currency: z.string().default('USD') });
+	const legacyRow = { orderId: 'o1', total: 10 };
+	const coerced = { orderId: 'o1', total: 10, currency: 'USD' };
+
+	test("mock get() coerces a stored legacy-shaped row under the default 'coerce'", async () => {
+		// Write the legacy-shaped row directly into the store (bypassing put's
+		// write validation) to simulate a row that predates the V2 schema, then
+		// read it back through the V2 schema (readValidation defaults to 'coerce').
+		const v2 = new DistributedTable(testScope(), 'orders', {
+			schema: schemaV2, key: { partitionKey: 'orderId' },
+		});
+		(v2 as any).data.set((v2 as any).serializeKey({ orderId: 'o1' }), legacyRow);
+		assert.deepStrictEqual(await v2.get({ orderId: 'o1' }), coerced);
+	});
+
+	test("AWS get() coerces the same legacy row identically under the default 'coerce'", async () => {
+		const table = awsTableWithFakeClient('ovr-aws-1',
+			{ schema: schemaV2, key: { partitionKey: 'orderId' } },
+			async () => ({ Item: legacyRow }),
+		);
+		assert.deepStrictEqual(await table.get({ orderId: 'o1' }), coerced);
+	});
+
+	test("AWS get() with readValidation 'off' returns the raw legacy row unchanged", async () => {
+		const table = awsTableWithFakeClient('ovr-aws-2',
+			{ schema: schemaV2, key: { partitionKey: 'orderId' }, readValidation: 'off' },
+			async () => ({ Item: legacyRow }),
+		);
+		assert.deepStrictEqual(await table.get({ orderId: 'o1' }), legacyRow);
+	});
+
+	test("AWS get() 'coerce' returns an uncoercible row RAW and never throws", async () => {
+		const strict = z.object({ orderId: z.string(), total: z.number() });
+		const bad = { orderId: 'x', total: 'not-a-number' };
+		const table = awsTableWithFakeClient('ovr-aws-3',
+			{ schema: strict, key: { partitionKey: 'orderId' }, readValidation: 'coerce' },
+			async () => ({ Item: bad }),
+		);
+		assert.deepStrictEqual(await table.get({ orderId: 'x' }), bad);
+	});
+
+	test("AWS get() 'strict' throws ValidationFailed on the same uncoercible row (mock parity)", async () => {
+		const strict = z.object({ orderId: z.string(), total: z.number() });
+		const bad = { orderId: 'x', total: 'not-a-number' };
+		const table = awsTableWithFakeClient('ovr-aws-4',
+			{ schema: strict, key: { partitionKey: 'orderId' }, readValidation: 'strict' },
+			async () => ({ Item: bad }),
+		);
+		await assert.rejects(
+			() => table.get({ orderId: 'x' }),
+			(err: any) => err.name === 'ValidationFailedException',
+		);
+	});
+
+	// coerce preserves unknown stored keys (adds default) — must be identical mock ↔ aws.
+	const narrow = z.object({ orderId: z.string(), total: z.number(), currency: z.string().default('USD') });
+	const legacyWithExtra = { orderId: 'o1', total: 10, couponCode: 'X' }; // couponCode not in schema
+	const preserved = { orderId: 'o1', total: 10, couponCode: 'X', currency: 'USD' };
+
+	test("mock 'coerce' preserves an unknown key while adding the new default", async () => {
+		const t = new DistributedTable(testScope(), 'orders', { schema: narrow, key: { partitionKey: 'orderId' } });
+		(t as any).data.set((t as any).serializeKey({ orderId: 'o1' }), legacyWithExtra);
+		assert.deepStrictEqual(await t.get({ orderId: 'o1' }), preserved);
+	});
+
+	test("AWS 'coerce' preserves the same unknown key identically", async () => {
+		const table = awsTableWithFakeClient('ovr-aws-5',
+			{ schema: narrow, key: { partitionKey: 'orderId' } },
+			async () => ({ Item: legacyWithExtra }),
+		);
+		assert.deepStrictEqual(await table.get({ orderId: 'o1' }), preserved);
+	});
+});

package/src/types.ts

@@ -8,6 +8,19 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { ChildLogger } from '@aws-blocks/bb-logger';
 
+// ── Read validation ─────────────────────────────────────────────────────────
+
+/**
+ * Controls how reads reconcile a stored item with the schema. See
+ * {@link DistributedTableOptions.readValidation} for full semantics.
+ *
+ * - `'coerce'` (default): pass through the schema, return coerced output; on
+ *   validation failure return the raw value + warn (never throws).
+ * - `'strict'`: validate and throw `ValidationFailed` on any non-conforming item.
+ * - `'off'`: return the raw stored value with no validation.
+ */
+export type ReadValidationMode = 'off' | 'coerce' | 'strict';
+
 // ── Key configuration ───────────────────────────────────────────────────────
 
 export interface TableKeyConfig<T> {
@@ -44,6 +57,47 @@ export interface DistributedTableOptions<
 	 * ```
 	 */
 	ttl?: keyof T & string;
+	/**
+	 * How reads (`get`, `getBatch`, `query`, `scan`) reconcile a stored item with
+	 * the configured `schema`. Writes (`put`/`putBatch`) always validate; this
+	 * governs the read side, which matters after a schema change: a row written
+	 * under an older schema may no longer conform to the current type `T`.
+	 *
+	 * - **`'coerce'`** (default) — pass each stored item through the schema and
+	 *   return its output. For transform-bearing schemas (e.g. Zod) this fills
+	 *   `.default()`s and narrows types so the value satisfies `T` and the
+	 *   read-modify-write cycle (`get()` → mutate → `put()`) round-trips. **Never
+	 *   throws:** an item that fails validation is returned **as-is** with a
+	 *   warning, keeping drifted/legacy rows readable for migration.
+	 * - **`'strict'`** — validate on read and **throw** `ValidationFailed` on any
+	 *   item that doesn't satisfy the schema. For tables where a mismatch should be
+	 *   treated as corruption/tampering and rejected rather than absorbed. Note
+	 *   this makes a single bad row fail the whole `query`/`scan`/`getBatch`.
+	 * - **`'off'`** — return the raw stored value with no validation (lowest cost).
+	 *   Use for hot paths, data you trust was written through this schema, or to
+	 *   read items you can't yet coerce during a migration.
+	 *
+	 * Defaults to `'coerce'`.
+	 *
+	 * > **Best-effort coercion (validator-dependent).** Coercion relies on the
+	 * > schema *transforming* its input. Zod fills defaults and casts; a check-only
+	 * > Standard Schema validator (some Valibot/ArkType schemas) validates without
+	 * > transforming, so `'coerce'` returns the value unchanged for those — it never
+	 * > invents data. A required field with no default is never fabricated: under
+	 * > `'coerce'` such a row is returned raw + warned; under `'strict'` it throws.
+	 *
+	 * @example
+	 * ```typescript
+	 * const orders = new DistributedTable(scope, 'orders', {
+	 *   schema: orderSchemaV2,        // adds `currency: z.string().default('USD')`
+	 *   key: { partitionKey: 'orderId' },
+	 *   // readValidation: 'coerce' is the default
+	 * });
+	 * const order = await orders.get({ orderId: 'o1' }); // legacy row → currency: 'USD'
+	 * await orders.put({ ...order, total: 20 });         // round-trips cleanly
+	 * ```
+	 */
+	readValidation?: ReadValidationMode;
 	/** Wrap an existing table instead of creating one. */
 	table?: ExternalTableRef;
 	/** Optional logger for internal operations. When omitted, a default Logger at error level is created. */

package/src/version.ts

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/generate-version.mjs — do not edit manually
 export const BB_NAME = 'DistributedTable';
-export const BB_VERSION = '0.1.2';
+export const BB_VERSION = '0.1.4';