@byline/db-mysql 4.10.1 → 4.11.0

package/dist/database/schema/index.d.ts

@@ -591,6 +591,42 @@ export declare const documentPaths: import("drizzle-orm/mysql-core").MySqlTableW
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        deleted_at: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "deleted_at";
+            tableName: "byline_document_paths";
+            dataType: "date";
+            columnType: "MySqlDateTime";
+            data: Date;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        alive: import("drizzle-orm/mysql-core").MySqlColumn<{
+            name: "alive";
+            tableName: "byline_document_paths";
+            dataType: "boolean";
+            columnType: "MySqlBoolean";
+            data: boolean;
+            driverParam: number | boolean;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: {
+                type: 'always';
+            };
+        }, {}, {}>;
     };
     dialect: 'mysql';
 }>;

package/dist/database/schema/index.js

@@ -139,6 +139,11 @@ export const documentPaths = mysqlTable('byline_document_paths', {
     // in `./common.ts` for why (case AND accent sensitivity, verified
     // against live Thai/Devanagari/Hebrew slugs, not just Latin parity).
     path: varcharCaseSensitive('path', { length: 255 }).notNull(),
+    // Whole-document soft delete releases the live namespace without
+    // discarding the retained path. `alive` is derived so callers cannot
+    // update the two liveness columns inconsistently.
+    deleted_at: datetime('deleted_at', { fsp: 6 }),
+    alive: boolean('alive').generatedAlwaysAs(sql `CASE WHEN \`deleted_at\` IS NULL THEN true ELSE NULL END`, { mode: 'stored' }),
     ...timestamps,
 }, (table) => [
     foreignKey({
@@ -153,9 +158,9 @@ export const documentPaths = mysqlTable('byline_document_paths', {
     }).onDelete('cascade'),
     // One path per (logical document, locale).
     unique('unique_document_paths_document_locale').on(table.document_id, table.locale),
-    // Per-collection per-locale path uniqueness. Column order matches the
-    // resolution lookup pattern: WHERE collection_id = ? AND locale = ? AND path = ?.
-    unique('idx_document_paths_collection_locale_path').on(table.collection_id, table.locale, table.path),
+    // Per-collection per-locale live-path uniqueness. NULL generated values
+    // allow any number of deleted rows to retain the same path.
+    unique('idx_document_paths_collection_locale_path').on(table.collection_id, table.locale, table.path, table.alive),
     // Reverse lookup by document.
     index('idx_document_paths_document_id').on(table.document_id),
 ]);

package/dist/database/schema/schema-pins.test.node.d.ts

@@ -34,11 +34,13 @@
  *      user-authored field data, not statement-ordering timestamps, so the
  *      race that motivated the instant-column bump upstream doesn't apply
  *      to them.
- *   4. The `byline_document_paths` per-collection path-uniqueness index
+ *   4. The `byline_document_paths` live-path-uniqueness index
  *      keeps the exact name `idx_document_paths_collection_locale_path`,
  *      because `packages/core/src/services/document-lifecycle/internals.ts`
  *      substring-matches this name against the adapter's `classifyError`
- *      constraint report to detect path collisions.
+ *      constraint report to detect path collisions. Its generated `alive`
+ *      discriminator is stored and nullable so deleted rows no longer
+ *      occupy the live namespace.
  *   5. `byline_document_paths.path` carries the `utf8mb4_bin` collation
  *      (project-owner ruling) so path uniqueness is case- and
  *      accent-sensitive on MySQL exactly like it already is on Postgres —

package/dist/database/schema/schema-pins.test.node.js

@@ -34,11 +34,13 @@
  *      user-authored field data, not statement-ordering timestamps, so the
  *      race that motivated the instant-column bump upstream doesn't apply
  *      to them.
- *   4. The `byline_document_paths` per-collection path-uniqueness index
+ *   4. The `byline_document_paths` live-path-uniqueness index
  *      keeps the exact name `idx_document_paths_collection_locale_path`,
  *      because `packages/core/src/services/document-lifecycle/internals.ts`
  *      substring-matches this name against the adapter's `classifyError`
- *      constraint report to detect path collisions.
+ *      constraint report to detect path collisions. Its generated `alive`
+ *      discriminator is stored and nullable so deleted rows no longer
+ *      occupy the live namespace.
  *   5. `byline_document_paths.path` carries the `utf8mb4_bin` collation
  *      (project-owner ruling) so path uniqueness is case- and
  *      accent-sensitive on MySQL exactly like it already is on Postgres —
@@ -371,11 +373,31 @@ describe('schema pins — timestamp precision (spec §F.3)', () => {
     });
 });
 describe('schema pins — document-paths unique index name (spec §E)', () => {
-    it('byline_document_paths carries a unique key literally named idx_document_paths_collection_locale_path', () => {
+    it('pins the live-path and document-locale unique keys', () => {
         const cfg = getTableConfig(coreSchema.documentPaths);
         const pathKey = cfg.uniqueConstraints.find((uc) => uc.name === 'idx_document_paths_collection_locale_path');
         expect(pathKey).toBeDefined();
-        expect(pathKey?.columns.map((c) => c.name)).toEqual(['collection_id', 'locale', 'path']);
+        expect(pathKey?.columns.map((c) => c.name)).toEqual([
+            'collection_id',
+            'locale',
+            'path',
+            'alive',
+        ]);
+        const documentLocaleKey = cfg.uniqueConstraints.find((uc) => uc.name === 'unique_document_paths_document_locale');
+        expect(documentLocaleKey?.columns.map((c) => c.name)).toEqual(['document_id', 'locale']);
+        const width = (pathKey?.columns ?? []).reduce((sum, column) => sum +
+            indexColumnByteWidth('byline_document_paths', 'idx_document_paths_collection_locale_path', column), 0);
+        expect(width).toBe(1097);
+    });
+    it('pins nullable deleted_at and the stored generated alive discriminator', () => {
+        const cfg = getTableConfig(coreSchema.documentPaths);
+        const deletedAt = cfg.columns.find((column) => column.name === 'deleted_at');
+        const alive = cfg.columns.find((column) => column.name === 'alive');
+        expect(deletedAt?.getSQLType()).toBe('datetime(6)');
+        expect(deletedAt?.notNull).toBe(false);
+        expect(alive?.getSQLType()).toBe('boolean');
+        expect(alive?.notNull).toBe(false);
+        expect(alive?.generated).toMatchObject({ type: 'always', mode: 'stored' });
     });
 });
 describe('schema pins — document-paths case-sensitive collation (project-owner ruling)', () => {

package/dist/modules/storage/storage-commands.d.ts

@@ -362,15 +362,28 @@ export declare class DocumentCommands implements IDocumentCommands {
     /**
      * softDeleteDocument
      *
-     * Mark ALL versions of a document as deleted by setting `is_deleted = true`.
-     * The `current_documents` view filters these out, so the document disappears
-     * from listings without physically removing data.
+     * Tombstone every path and version row for a document with one operation
+     * timestamp. Live views and path resolution filter these rows without
+     * physically removing retained content or path values.
      *
      * Returns the number of version rows marked as deleted.
      */
     softDeleteDocument(params: {
         document_id: string;
     }): Promise<number>;
+    /**
+     * Restore every path and version tombstone for a fully soft-deleted document.
+     *
+     * Takes the same collection then document locks as soft delete. A missing,
+     * versionless, already-live, or legacy partially-live document is a no-op.
+     * Path uniqueness is revalidated by the live unique constraint; any conflict
+     * aborts both updates. Tree placement and search/cache projections are not
+     * reconstructed by this storage primitive.
+     */
+    restoreSoftDeletedDocument(params: {
+        document_id: string;
+    }): Promise<number>;
+    private readDocumentVersionLiveness;
     /**
      * Write `order_key` on a single `byline_documents` row. Single-column
      * metadata update — no new version row, no `documentVersions` touch.

package/dist/modules/storage/storage-commands.js

@@ -209,7 +209,15 @@ export class DocumentCommands {
                     .select({ source_locale: documents.source_locale })
                     .from(documents)
                     .where(eq(documents.id, documentId))
+                    .for('update')
                     .then(getFirstOrThrow('Failed to load document for new version'));
+                const versionLiveness = await this.readDocumentVersionLiveness(tx, documentId);
+                if (versionLiveness.total > 0 && versionLiveness.live === 0) {
+                    throw ERR_CONFLICT({
+                        message: 'cannot add a version to a soft-deleted document',
+                        details: { documentId },
+                    });
+                }
                 sourceLocale = existing.source_locale ?? this.defaultContentLocale;
             }
             // 2. Create the document version. The id is minted here (app-side
@@ -738,13 +746,14 @@ export class DocumentCommands {
     /**
      * softDeleteDocument
      *
-     * Mark ALL versions of a document as deleted by setting `is_deleted = true`.
-     * The `current_documents` view filters these out, so the document disappears
-     * from listings without physically removing data.
+     * Tombstone every path and version row for a document with one operation
+     * timestamp. Live views and path resolution filter these rows without
+     * physically removing retained content or path values.
      *
      * Returns the number of version rows marked as deleted.
      */
     async softDeleteDocument(params) {
+        const deletedAt = new Date();
         return this.db.transaction(async (tx) => {
             // Tree placement takes this same collection lock before inspecting any
             // endpoint state. Taking it before document/version locks makes direct
@@ -760,16 +769,76 @@ export class DocumentCommands {
                 .for('update');
             if (document == null)
                 return 0;
+            await tx
+                .update(documentPaths)
+                .set({
+                deleted_at: deletedAt,
+                updated_at: deletedAt,
+            })
+                .where(eq(documentPaths.document_id, params.document_id));
             const result = await tx
                 .update(documentVersions)
                 .set({
                 is_deleted: true,
-                updated_at: new Date(),
+                updated_at: deletedAt,
             })
                 .where(eq(documentVersions.document_id, params.document_id));
             return affectedRowCount(result);
         });
     }
+    /**
+     * Restore every path and version tombstone for a fully soft-deleted document.
+     *
+     * Takes the same collection then document locks as soft delete. A missing,
+     * versionless, already-live, or legacy partially-live document is a no-op.
+     * Path uniqueness is revalidated by the live unique constraint; any conflict
+     * aborts both updates. Tree placement and search/cache projections are not
+     * reconstructed by this storage primitive.
+     */
+    async restoreSoftDeletedDocument(params) {
+        const restoredAt = new Date();
+        return this.db.transaction(async (tx) => {
+            const collectionId = await this.lockDocumentCollection(tx, params.document_id);
+            if (collectionId == null)
+                return 0;
+            const [document] = await tx
+                .select({ id: documents.id })
+                .from(documents)
+                .where(eq(documents.id, params.document_id))
+                .for('update');
+            if (document == null)
+                return 0;
+            const versionLiveness = await this.readDocumentVersionLiveness(tx, params.document_id);
+            if (versionLiveness.total === 0 || versionLiveness.live > 0)
+                return 0;
+            await tx
+                .update(documentPaths)
+                .set({
+                deleted_at: null,
+                updated_at: restoredAt,
+            })
+                .where(eq(documentPaths.document_id, params.document_id));
+            const result = await tx
+                .update(documentVersions)
+                .set({
+                is_deleted: false,
+                updated_at: restoredAt,
+            })
+                .where(eq(documentVersions.document_id, params.document_id));
+            return affectedRowCount(result);
+        });
+    }
+    async readDocumentVersionLiveness(tx, documentId) {
+        // Match the live views: only explicit `false` is live; legacy `NULL` is not.
+        return tx
+            .select({
+            total: sql `CAST(COUNT(*) AS SIGNED)`,
+            live: sql `CAST(COUNT(CASE WHEN ${documentVersions.is_deleted} = false THEN 1 END) AS SIGNED)`,
+        })
+            .from(documentVersions)
+            .where(eq(documentVersions.document_id, documentId))
+            .then(getFirstOrThrow('Failed to read document version liveness'));
+    }
     /**
      * Write `order_key` on a single `byline_documents` row. Single-column
      * metadata update — no new version row, no `documentVersions` touch.

package/dist/modules/storage/storage-queries.d.ts

@@ -182,6 +182,11 @@ export declare class DocumentQueries implements IDocumentQueries {
      * reaches the `ORDER BY` has a genuine position, and ascending order
      * therefore picks the earliest (highest-priority, i.e. most-requested)
      * chain entry first, exactly matching `array_position`'s semantics.
+     *
+     * This is a projection by known document identity, not a live-namespace
+     * lookup. Deliberately do not filter `alive`: history and deleted-document
+     * administration must continue to display the retained path.
+     *
      * Verified live against MySQL 9.7.1 (see the Task 10A report) and pinned
      * by `storage-queries.test.ts`'s locale-chain-ordering test.
      */

package/dist/modules/storage/storage-queries.js

@@ -275,6 +275,11 @@ export class DocumentQueries {
      * reaches the `ORDER BY` has a genuine position, and ascending order
      * therefore picks the earliest (highest-priority, i.e. most-requested)
      * chain entry first, exactly matching `array_position`'s semantics.
+     *
+     * This is a projection by known document identity, not a live-namespace
+     * lookup. Deliberately do not filter `alive`: history and deleted-document
+     * administration must continue to display the retained path.
+     *
      * Verified live against MySQL 9.7.1 (see the Task 10A report) and pinned
      * by `storage-queries.test.ts`'s locale-chain-ordering test.
      */
@@ -307,6 +312,7 @@ export class DocumentQueries {
       SELECT ${documentPaths.document_id} FROM ${documentPaths}
       WHERE ${documentPaths.collection_id} = ${collection_id}
         AND ${documentPaths.path} = ${path}
+        AND ${documentPaths.alive} = true
         AND ${documentPaths.locale} IN (${chainSql})
       ORDER BY FIELD(${documentPaths.locale}, ${chainSql})
       LIMIT 1

package/dist/modules/storage/tests/storage-live-path-queries.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+export {};

package/dist/modules/storage/tests/storage-live-path-queries.test.js

@@ -0,0 +1,222 @@
+/**
+ * This Source Code is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * Copyright (c) Infonomic Company Limited
+ */
+import { eq } from 'drizzle-orm';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { documentPaths, documents, documentVersions } from '../../../database/schema/index.js';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+const timestamp = Date.now();
+const PagesCollectionConfig = {
+    path: `live-path-queries-${timestamp}`,
+    labels: { singular: 'Page', plural: 'Pages' },
+    fields: [{ name: 'title', type: 'text' }],
+};
+describe('live-path query resolution (MySQL)', () => {
+    let testDb;
+    let collectionId;
+    beforeAll(async () => {
+        testDb = setupTestDB([PagesCollectionConfig]);
+        const [collection] = await testDb.commandBuilders.collections.create(PagesCollectionConfig.path, PagesCollectionConfig);
+        if (collection == null)
+            throw new Error('failed to create live-path test collection');
+        collectionId = collection.id;
+    });
+    afterAll(async () => {
+        await testDb.commandBuilders.collections.delete(collectionId);
+        await teardownTestDB();
+    });
+    it('skips a deleted requested-locale row and projects it only for known-document history', async () => {
+        const path = `shared-${timestamp}`;
+        const deleted = await testDb.commandBuilders.documents.createDocumentVersion({
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'create',
+            documentData: { title: 'Former French occupant' },
+            path: `former-source-${timestamp}`,
+            locale: 'all',
+            status: 'draft',
+        });
+        const deletedDocumentId = deleted.document.document_id;
+        await testDb.commandBuilders.documents.updateDocumentPath({
+            documentId: deletedDocumentId,
+            collectionId,
+            locale: 'fr',
+            path,
+        });
+        await testDb.commandBuilders.documents.createDocumentVersion({
+            documentId: deletedDocumentId,
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'update',
+            documentData: { title: 'Former French occupant, revised' },
+            locale: 'all',
+            status: 'draft',
+            previousVersionId: deleted.document.id,
+        });
+        await testDb.commandBuilders.documents.softDeleteDocument({
+            document_id: deletedDocumentId,
+        });
+        const pathRows = await testDb.db
+            .select({
+            deletedAt: documentPaths.deleted_at,
+            updatedAt: documentPaths.updated_at,
+        })
+            .from(documentPaths)
+            .where(eq(documentPaths.document_id, deletedDocumentId));
+        expect(pathRows).toHaveLength(2);
+        const deletedAt = pathRows[0]?.deletedAt;
+        expect(deletedAt).toBeInstanceOf(Date);
+        expect(pathRows.every((row) => row.deletedAt?.getTime() === deletedAt?.getTime())).toBe(true);
+        expect(pathRows.every((row) => row.updatedAt.getTime() === deletedAt?.getTime())).toBe(true);
+        const versionRows = await testDb.db
+            .select({
+            isDeleted: documentVersions.is_deleted,
+            updatedAt: documentVersions.updated_at,
+        })
+            .from(documentVersions)
+            .where(eq(documentVersions.document_id, deletedDocumentId));
+        expect(versionRows).toHaveLength(2);
+        expect(versionRows.every((row) => row.isDeleted)).toBe(true);
+        expect(versionRows.every((row) => row.updatedAt.getTime() === deletedAt?.getTime())).toBe(true);
+        const live = await testDb.commandBuilders.documents.createDocumentVersion({
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'create',
+            documentData: { title: 'Live English fallback' },
+            path,
+            locale: 'all',
+            status: 'draft',
+        });
+        const found = await testDb.queryBuilders.documents.getDocumentByPath({
+            collection_id: collectionId,
+            path,
+            locale: 'fr',
+            reconstruct: false,
+        });
+        expect(found?.document_id).toBe(live.document.document_id);
+        expect(found?.path).toBe(path);
+        expect(found).not.toHaveProperty('deleted_at');
+        expect(found).not.toHaveProperty('alive');
+        const history = await testDb.queryBuilders.documents.getDocumentHistory({
+            collection_id: collectionId,
+            document_id: deletedDocumentId,
+            locale: 'fr',
+        });
+        expect(history.documents).toHaveLength(2);
+        expect(history.documents[0]?.path).toBe(path);
+    });
+    it('restores every tombstone atomically and leaves a legacy partial state untouched', async () => {
+        const originalPath = `restore-source-${timestamp}`;
+        const frenchPath = `restore-fr-${timestamp}`;
+        const first = await testDb.commandBuilders.documents.createDocumentVersion({
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'create',
+            documentData: { title: 'Restored first version' },
+            path: originalPath,
+            locale: 'all',
+            status: 'draft',
+        });
+        const documentId = first.document.document_id;
+        await testDb.commandBuilders.documents.updateDocumentPath({
+            documentId,
+            collectionId,
+            locale: 'fr',
+            path: frenchPath,
+        });
+        const second = await testDb.commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'update',
+            documentData: { title: 'Restored second version' },
+            locale: 'all',
+            status: 'published',
+            previousVersionId: first.document.id,
+        });
+        await testDb.commandBuilders.documents.softDeleteDocument({ document_id: documentId });
+        await expect(testDb.commandBuilders.documents.restoreSoftDeletedDocument({ document_id: documentId })).resolves.toBe(2);
+        const restoredPaths = await testDb.db
+            .select({
+            path: documentPaths.path,
+            deletedAt: documentPaths.deleted_at,
+            updatedAt: documentPaths.updated_at,
+        })
+            .from(documentPaths)
+            .where(eq(documentPaths.document_id, documentId));
+        expect(restoredPaths).toHaveLength(2);
+        expect(restoredPaths.map((row) => row.path).sort()).toEqual([frenchPath, originalPath].sort());
+        expect(restoredPaths.every((row) => row.deletedAt == null)).toBe(true);
+        const restoredAt = restoredPaths[0]?.updatedAt;
+        expect(restoredPaths.every((row) => row.updatedAt.getTime() === restoredAt?.getTime())).toBe(true);
+        const restoredVersions = await testDb.db
+            .select({
+            id: documentVersions.id,
+            status: documentVersions.status,
+            isDeleted: documentVersions.is_deleted,
+            updatedAt: documentVersions.updated_at,
+        })
+            .from(documentVersions)
+            .where(eq(documentVersions.document_id, documentId));
+        expect(restoredVersions).toHaveLength(2);
+        expect(restoredVersions.map((row) => row.status).sort()).toEqual(['draft', 'published']);
+        expect(restoredVersions.every((row) => !row.isDeleted)).toBe(true);
+        expect(restoredVersions.every((row) => row.updatedAt.getTime() === restoredAt?.getTime())).toBe(true);
+        await testDb.commandBuilders.documents.softDeleteDocument({ document_id: documentId });
+        await testDb.db
+            .update(documentVersions)
+            .set({ is_deleted: false })
+            .where(eq(documentVersions.id, second.document.id));
+        await testDb.db
+            .update(documentPaths)
+            .set({ deleted_at: null })
+            .where(eq(documentPaths.document_id, documentId));
+        await expect(testDb.commandBuilders.documents.restoreSoftDeletedDocument({ document_id: documentId })).resolves.toBe(0);
+        const legacyPaths = await testDb.db
+            .select({ deletedAt: documentPaths.deleted_at })
+            .from(documentPaths)
+            .where(eq(documentPaths.document_id, documentId));
+        expect(legacyPaths.every((row) => row.deletedAt == null)).toBe(true);
+        const legacyVersions = await testDb.db
+            .select({ isDeleted: documentVersions.is_deleted })
+            .from(documentVersions)
+            .where(eq(documentVersions.document_id, documentId));
+        expect(legacyVersions.map((row) => row.isDeleted).sort()).toEqual([false, true]);
+    });
+    it('allows an existing versionless document to receive its first version', async () => {
+        const documentId = crypto.randomUUID();
+        const path = `versionless-${timestamp}`;
+        await testDb.db.insert(documents).values({
+            id: documentId,
+            collection_id: collectionId,
+            source_locale: 'en',
+        });
+        const created = await testDb.commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId,
+            collectionVersion: 1,
+            collectionConfig: PagesCollectionConfig,
+            action: 'create',
+            documentData: { title: 'Versionless bootstrap' },
+            path,
+            locale: 'all',
+            status: 'draft',
+        });
+        expect(created.document.document_id).toBe(documentId);
+        const found = await testDb.queryBuilders.documents.getDocumentByPath({
+            collection_id: collectionId,
+            path,
+            reconstruct: false,
+        });
+        expect(found?.document_id).toBe(documentId);
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/db-mysql",
   "private": false,
   "license": "MPL-2.0",
-  "version": "4.10.1",
+  "version": "4.11.0",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -50,8 +50,8 @@
     "drizzle-orm": "^0.45.2",
     "mysql2": "^3.23.1",
     "uuid": "^14.0.1",
-    "@byline/core": "4.10.1",
-    "@byline/admin": "4.10.1"
+    "@byline/admin": "4.11.0",
+    "@byline/core": "4.11.0"
   },
   "devDependencies": {
     "@biomejs/biome": "2.5.4",
@@ -65,9 +65,9 @@
     "tsx": "^4.23.1",
     "typescript": "^7.0.2",
     "vitest": "^4.1.10",
-    "@byline/client": "4.10.1",
-    "@byline/auth": "4.10.1",
-    "@byline/db-conformance": "0.0.5"
+    "@byline/auth": "4.11.0",
+    "@byline/client": "4.11.0",
+    "@byline/db-conformance": "0.0.7"
   },
   "publishConfig": {
     "access": "public",