@byline/db-postgres 1.7.7 → 1.8.1

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

@@ -316,25 +316,6 @@ export declare const documentVersions: import("drizzle-orm/pg-core").PgTableWith
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
-        path: import("drizzle-orm/pg-core").PgColumn<{
-            name: "path";
-            tableName: "byline_document_versions";
-            dataType: "string";
-            columnType: "PgVarchar";
-            data: string;
-            driverParam: string;
-            notNull: true;
-            hasDefault: false;
-            isPrimaryKey: false;
-            isAutoincrement: false;
-            hasRuntimeDefault: false;
-            enumValues: [string, ...string[]];
-            baseColumn: never;
-            identity: undefined;
-            generated: undefined;
-        }, {}, {
-            length: 255;
-        }>;
         doc: import("drizzle-orm/pg-core").PgColumn<{
             name: "doc";
             tableName: "byline_document_versions";
@@ -478,6 +459,119 @@ export declare const documentVersions: import("drizzle-orm/pg-core").PgTableWith
     };
     dialect: "pg";
 }>;
+export declare const documentPaths: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "byline_document_paths";
+    schema: undefined;
+    columns: {
+        document_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "document_id";
+            tableName: "byline_document_paths";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        locale: import("drizzle-orm/pg-core").PgColumn<{
+            name: "locale";
+            tableName: "byline_document_paths";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 10;
+        }>;
+        collection_id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "collection_id";
+            tableName: "byline_document_paths";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        path: import("drizzle-orm/pg-core").PgColumn<{
+            name: "path";
+            tableName: "byline_document_paths";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: 255;
+        }>;
+        created_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "byline_document_paths";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updated_at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "byline_document_paths";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
 export declare const documentRelationships: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "byline_document_relationships";
     schema: undefined;
@@ -605,23 +699,6 @@ export declare const currentDocumentsView: import("drizzle-orm/pg-core").PgViewW
         identity: undefined;
         generated: undefined;
     }, {}, {}>;
-    path: import("drizzle-orm/pg-core").PgColumn<{
-        name: "path";
-        tableName: "byline_current_documents";
-        dataType: "string";
-        columnType: "PgVarchar";
-        data: string;
-        driverParam: string;
-        notNull: true;
-        hasDefault: false;
-        isPrimaryKey: false;
-        isAutoincrement: false;
-        hasRuntimeDefault: false;
-        enumValues: [string, ...string[]];
-        baseColumn: never;
-        identity: undefined;
-        generated: undefined;
-    }, {}, {}>;
     event_type: import("drizzle-orm/pg-core").PgColumn<{
         name: "event_type";
         tableName: "byline_current_documents";
@@ -811,23 +888,6 @@ export declare const currentPublishedDocumentsView: import("drizzle-orm/pg-core"
         identity: undefined;
         generated: undefined;
     }, {}, {}>;
-    path: import("drizzle-orm/pg-core").PgColumn<{
-        name: "path";
-        tableName: "byline_current_published_documents";
-        dataType: "string";
-        columnType: "PgVarchar";
-        data: string;
-        driverParam: string;
-        notNull: true;
-        hasDefault: false;
-        isPrimaryKey: false;
-        isAutoincrement: false;
-        hasRuntimeDefault: false;
-        enumValues: [string, ...string[]];
-        baseColumn: never;
-        identity: undefined;
-        generated: undefined;
-    }, {}, {}>;
     event_type: import("drizzle-orm/pg-core").PgColumn<{
         name: "event_type";
         tableName: "byline_current_published_documents";

package/dist/database/schema/index.js

@@ -49,7 +49,6 @@ export const documentVersions = pgTable('byline_document_versions', {
     // shapes. Phase 1 records the number; no composite FK yet — that
     // anchors in Phase 2 alongside the history table.
     collection_version: integer('collection_version').notNull(),
-    path: varchar('path', { length: 255 }).notNull(), // Can change between versions
     doc: jsonb('doc'), // optionally store the original document
     event_type: varchar('event_type', { length: 20 }).notNull().default('create'), // 'create', 'update', 'delete'
     status: varchar('status', { length: 50 }).default('draft'),
@@ -61,8 +60,6 @@ export const documentVersions = pgTable('byline_document_versions', {
 }, (table) => [
     // Index for finding all versions of a logical document
     index('idx_documents_document_id').on(table.document_id),
-    // Index for current document lookup by path
-    index('idx_documents_collection_path_deleted').on(table.collection_id, table.path, table.is_deleted),
     // Index for current document lookup by logical document ID
     index('idx_documents_collection_document_deleted').on(table.collection_id, table.document_id, table.is_deleted),
     // Index to optimize the current documents view
@@ -72,10 +69,34 @@ export const documentVersions = pgTable('byline_document_versions', {
     index('idx_documents_created_at').on(table.created_at),
     // Ensure logical document belongs to only one collection
     index('idx_documents_document_collection').on(table.document_id, table.collection_id),
-    // Per-collection path uniqueness is a DEFERRED design decision — it
-    // depends on a collision-handling policy (reject vs auto-suffix) and
-    // is planned to land alongside preview-link UX. See
-    // `docs/analysis/DOCUMENT-PATH-ANALYSIS.md` § "Path uniqueness".
+]);
+// Document paths — one row per (logical document, content locale).
+// Promotes `path` out of the version row so per-collection uniqueness can
+// be enforced at the DB layer without colliding with the sticky
+// carry-forward of path across versions. Phase 1 only ever writes the
+// installation's default content locale; per-locale UI is a future phase
+// that adds rows for additional locales without reshaping the schema.
+// History is intentionally not preserved here — path rows are updated in
+// place. See `docs/DOCUMENT-PATHS.md` § "Path uniqueness".
+export const documentPaths = pgTable('byline_document_paths', {
+    document_id: uuid('document_id')
+        .notNull()
+        .references(() => documents.id, { onDelete: 'cascade' }),
+    locale: varchar('locale', { length: 10 }).notNull(),
+    collection_id: uuid('collection_id')
+        .notNull()
+        .references(() => collections.id, { onDelete: 'cascade' }),
+    path: varchar('path', { length: 255 }).notNull(),
+    created_at: timestamp('created_at').defaultNow(),
+    updated_at: timestamp('updated_at').defaultNow(),
+}, (table) => [
+    // 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),
+    // Reverse lookup by document.
+    index('idx_document_paths_document_id').on(table.document_id),
 ]);
 // Document Relationships (Parent/Child) - Many-to-Many
 export const documentRelationships = pgTable('byline_document_relationships', {
@@ -99,6 +120,11 @@ export const documentRelationships = pgTable('byline_document_relationships', {
 // `ROW_NUMBER() OVER (PARTITION BY document_id ORDER BY id DESC)`.
 // `selectDistinct` is not an option here: it distincts on the whole row,
 // not on `document_id`.
+//
+// `path` is intentionally NOT projected here. Path resolution is locale-
+// aware and lives in the storage adapter's read functions, which join
+// `byline_document_paths` with the requested locale + default-locale
+// fallback. See docs/DOCUMENT-PATHS.md.
 export const currentDocumentsView = pgView('byline_current_documents').as((qb) => {
     const sq = qb.$with('sq').as(qb
         .select({
@@ -106,7 +132,6 @@ export const currentDocumentsView = pgView('byline_current_documents').as((qb) =
         document_id: documentVersions.document_id,
         collection_id: documentVersions.collection_id,
         collection_version: documentVersions.collection_version,
-        path: documentVersions.path,
         event_type: documentVersions.event_type,
         status: documentVersions.status,
         is_deleted: documentVersions.is_deleted,
@@ -125,7 +150,6 @@ export const currentDocumentsView = pgView('byline_current_documents').as((qb) =
         document_id: sq.document_id,
         collection_id: sq.collection_id,
         collection_version: sq.collection_version,
-        path: sq.path,
         event_type: sq.event_type,
         status: sq.status,
         is_deleted: sq.is_deleted,
@@ -149,7 +173,6 @@ export const currentPublishedDocumentsView = pgView('byline_current_published_do
         document_id: documentVersions.document_id,
         collection_id: documentVersions.collection_id,
         collection_version: documentVersions.collection_version,
-        path: documentVersions.path,
         event_type: documentVersions.event_type,
         status: documentVersions.status,
         is_deleted: documentVersions.is_deleted,
@@ -168,7 +191,6 @@ export const currentPublishedDocumentsView = pgView('byline_current_published_do
         document_id: sq.document_id,
         collection_id: sq.collection_id,
         collection_version: sq.collection_version,
-        path: sq.path,
         event_type: sq.event_type,
         status: sq.status,
         is_deleted: sq.is_deleted,

package/dist/index.d.ts

@@ -24,7 +24,15 @@ export interface PgAdapter extends IDbAdapter {
     /** The pg connection pool — exposed for housekeeping and teardown. */
     pool: pg.Pool;
 }
-export declare const pgAdapter: ({ connectionString, collections, }: {
+export declare const pgAdapter: ({ connectionString, collections, defaultContentLocale, }: {
     connectionString: string;
     collections: CollectionDefinition[];
+    /**
+     * The installation's default content locale, sourced from
+     * `ServerConfig.i18n.content.defaultLocale`. Used by the storage layer
+     * for path resolution: read functions build a `[requested, default]`
+     * fallback chain when looking up `byline_document_paths`, and write
+     * functions tag default-locale path rows with this value.
+     */
+    defaultContentLocale: string;
 }) => PgAdapter;

package/dist/index.js

@@ -10,7 +10,7 @@ import pg from 'pg';
 import * as schema from './database/schema/index.js';
 import { createCommandBuilders } from './modules/storage/storage-commands.js';
 import { createQueryBuilders } from './modules/storage/storage-queries.js';
-export const pgAdapter = ({ connectionString, collections, }) => {
+export const pgAdapter = ({ connectionString, collections, defaultContentLocale, }) => {
     const pool = new pg.Pool({
         connectionString: connectionString,
         max: 20,
@@ -18,8 +18,8 @@ export const pgAdapter = ({ connectionString, collections, }) => {
         connectionTimeoutMillis: 1000,
     });
     const db = drizzle(pool, { schema });
-    const commandBuilders = createCommandBuilders(db);
-    const queryBuilders = createQueryBuilders(db, collections);
+    const commandBuilders = createCommandBuilders(db, defaultContentLocale);
+    const queryBuilders = createQueryBuilders(db, collections, defaultContentLocale);
     return {
         commands: commandBuilders,
         queries: queryBuilders,

package/dist/lib/test-helper.js

@@ -28,11 +28,11 @@ export function setupTestDB(collections = []) {
         db = drizzle(pool, { schema });
     }
     if (!commandBuilders) {
-        commandBuilders = createCommandBuilders(db);
+        commandBuilders = createCommandBuilders(db, 'en');
     }
     // Recreate queryBuilders when collections are provided so that
     // DocumentQueries can resolve collection definitions by path.
-    queryBuilders = createQueryBuilders(db, collections);
+    queryBuilders = createQueryBuilders(db, collections, 'en');
     return { pool, db, commandBuilders, queryBuilders };
 }
 export async function teardownTestDB() {

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

@@ -51,7 +51,8 @@ export declare class CollectionCommands implements ICollectionCommands {
  */
 export declare class DocumentCommands implements IDocumentCommands {
     private db;
-    constructor(db: DatabaseConnection);
+    private defaultContentLocale;
+    constructor(db: DatabaseConnection, defaultContentLocale: string);
     /**
      * createDocumentVersion
      *
@@ -67,7 +68,13 @@ export declare class DocumentCommands implements IDocumentCommands {
         collectionConfig: CollectionDefinition;
         action: string;
         documentData: any;
-        path: string;
+        /**
+         * Optional. When provided, upserts a row into byline_document_paths
+         * keyed by (document_id, this.defaultContentLocale). Omitted by the
+         * lifecycle for non-default-locale (translation) saves so the
+         * existing path row is left untouched.
+         */
+        path?: string;
         locale?: string;
         status?: string;
         createdBy?: string;
@@ -77,7 +84,6 @@ export declare class DocumentCommands implements IDocumentCommands {
             id: string;
             created_at: Date | null;
             updated_at: Date | null;
-            path: string;
             collection_id: string;
             document_id: string;
             collection_version: number;
@@ -128,7 +134,7 @@ export declare class DocumentCommands implements IDocumentCommands {
         document_id: string;
     }): Promise<number>;
 }
-export declare function createCommandBuilders(db: DatabaseConnection): {
+export declare function createCommandBuilders(db: DatabaseConnection, defaultContentLocale: string): {
     collections: CollectionCommands;
     documents: DocumentCommands;
 };

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

@@ -7,7 +7,7 @@
  */
 import { and, eq, ne, sql } from 'drizzle-orm';
 import { v7 as uuidv7 } from 'uuid';
-import { booleanStore, collections, datetimeStore, documents, documentVersions, fileStore, jsonStore, metaStore, numericStore, relationStore, textStore, } from '../../database/schema/index.js';
+import { booleanStore, collections, datetimeStore, documentPaths, documents, documentVersions, fileStore, jsonStore, metaStore, numericStore, relationStore, textStore, } from '../../database/schema/index.js';
 import { flattenFieldSetData } from './storage-flatten.js';
 import { prepareFieldInsertBuckets } from './storage-insert.js';
 import { getFirstOrThrow } from './storage-utils.js';
@@ -52,8 +52,10 @@ export class CollectionCommands {
  */
 export class DocumentCommands {
     db;
-    constructor(db) {
+    defaultContentLocale;
+    constructor(db, defaultContentLocale) {
         this.db = db;
+        this.defaultContentLocale = defaultContentLocale;
     }
     /**
      * createDocumentVersion
@@ -86,12 +88,35 @@ export class DocumentCommands {
                 document_id: documentId,
                 collection_id: params.collectionId,
                 collection_version: params.collectionVersion,
-                path: params.path,
                 event_type: params.action ?? 'create',
                 status: params.status ?? 'draft',
             })
                 .returning()
                 .then(getFirstOrThrow('Failed to create document version'));
+            // 2a. Upsert the document_paths row when a path is supplied. Path
+            // is only ever written under the installation's default content
+            // locale in phase 1; the lifecycle layer skips this param for
+            // non-default-locale (translation) saves. Unique-constraint
+            // violations on (collection_id, locale, path) bubble up as a
+            // Postgres error which the lifecycle wraps as ERR_PATH_CONFLICT.
+            if (params.path !== undefined) {
+                await tx
+                    .insert(documentPaths)
+                    .values({
+                    document_id: documentId,
+                    locale: this.defaultContentLocale,
+                    collection_id: params.collectionId,
+                    path: params.path,
+                })
+                    .onConflictDoUpdate({
+                    target: [documentPaths.document_id, documentPaths.locale],
+                    set: {
+                        path: params.path,
+                        collection_id: params.collectionId,
+                        updated_at: new Date(),
+                    },
+                });
+            }
             // 3. Flatten the document data to field values
             const flattenedFields = flattenFieldSetData(params.collectionConfig.fields, params.documentData, params.locale ?? 'all');
             // 4. Batch-insert all field values, grouped by store type
@@ -263,9 +288,9 @@ export class DocumentCommands {
         return result.rowCount ?? 0;
     }
 }
-export function createCommandBuilders(db) {
+export function createCommandBuilders(db, defaultContentLocale) {
     return {
         collections: new CollectionCommands(db),
-        documents: new DocumentCommands(db),
+        documents: new DocumentCommands(db, defaultContentLocale),
     };
 }

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

@@ -55,8 +55,9 @@ export declare class CollectionQueries implements ICollectionQueries {
 export declare class DocumentQueries implements IDocumentQueries {
     private db;
     private collections;
+    private defaultContentLocale;
     private collectionPathCache;
-    constructor(db: DatabaseConnection, collections: CollectionDefinition[]);
+    constructor(db: DatabaseConnection, collections: CollectionDefinition[], defaultContentLocale: string);
     /**
      * Resolve a collection UUID to its CollectionDefinition by looking up the
      * collection's path in the DB and matching it against the injected array.
@@ -76,6 +77,66 @@ export declare class DocumentQueries implements IDocumentQueries {
      * drop-in substitutable at every select/where site.
      */
     private pickCurrentView;
+    /**
+     * Build the locale priority chain for path resolution:
+     * `[requested, default]`, deduplicated when both are the same.
+     *
+     * Used by every read path that touches `byline_document_paths`. In
+     * phase 1 only the default-locale row is ever populated, so a non-
+     * default `requested` locale always falls through to the default —
+     * but the chain shape is correct for phase 2 when per-locale rows
+     * begin to exist.
+     */
+    private buildLocaleChain;
+    /**
+     * Emit a SQL fragment that resolves the path string for a document via
+     * the locale priority chain. Used as a projected column expression
+     * inside `SELECT` lists.
+     *
+     * ```sql
+     * (SELECT path FROM byline_document_paths
+     *  WHERE document_id = <docIdSql>
+     *    AND locale = ANY(<chain>)
+     *  ORDER BY array_position(<chain>, locale)
+     *  LIMIT 1)
+     * ```
+     */
+    private pathProjection;
+    /**
+     * Project list for `current_documents` / `current_published_documents`
+     * reads, with `path` resolved through the locale priority chain. Used
+     * everywhere a read previously did `.select()` (which auto-pulls every
+     * view column) — `path` is no longer projected by the views, so call
+     * sites must list the projection explicitly. This helper keeps the
+     * shape consistent and the call sites tidy.
+     */
+    private viewProjection;
+    /**
+     * Project list for direct `byline_document_versions` reads (history,
+     * version-by-id lookups). Mirrors `viewProjection` but against the
+     * underlying table — `path` is sourced from `byline_document_paths` via
+     * the locale priority chain, since it no longer lives on the version row.
+     */
+    private documentVersionsProjection;
+    /**
+     * Emit a SQL fragment that resolves a `(collection_id, path)` tuple to
+     * a `document_id` via the locale priority chain. Used inside `WHERE`
+     * clauses for findByPath-style lookups:
+     *
+     * ```sql
+     * WHERE document_id = (
+     *   SELECT document_id FROM byline_document_paths
+     *   WHERE collection_id = ? AND path = ?
+     *     AND locale = ANY(<chain>)
+     *   ORDER BY array_position(<chain>, locale)
+     *   LIMIT 1
+     * )
+     * ```
+     *
+     * Returns NULL when no row matches in any locale, which makes the
+     * outer `=` predicate fail cleanly (no document found).
+     */
+    private resolveDocumentIdByPath;
     /**
      * Reconstruct document fields from unified row values using schema-aware
      * restoration. Meta rows (from store_meta) are converted to
@@ -383,7 +444,7 @@ export declare class DocumentQueries implements IDocumentQueries {
      */
     private convertUnionRowToFlattenedStores;
 }
-export declare function createQueryBuilders(db: DatabaseConnection, collections: CollectionDefinition[]): {
+export declare function createQueryBuilders(db: DatabaseConnection, collections: CollectionDefinition[], defaultContentLocale: string): {
     collections: CollectionQueries;
     documents: DocumentQueries;
 };

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

@@ -11,7 +11,7 @@
 // either deferring adapter construction or accepting a lazy logger parameter.
 import { ERR_DATABASE, ERR_NOT_FOUND, getLogger } from '@byline/core';
 import { and, eq, inArray, sql } from 'drizzle-orm';
-import { collections, currentDocumentsView, currentPublishedDocumentsView, documentVersions, metaStore, } from '../../database/schema/index.js';
+import { collections, currentDocumentsView, currentPublishedDocumentsView, documentPaths, documentVersions, metaStore, } from '../../database/schema/index.js';
 import { extractFlattenedFieldValue, restoreFieldSetData } from './storage-restore.js';
 import { allStoreTypes, storeSelectList, storeTableNames, } from './storage-store-manifest.js';
 import { resolveStoreTypes } from './storage-utils.js';
@@ -39,10 +39,12 @@ export class CollectionQueries {
 export class DocumentQueries {
     db;
     collections;
+    defaultContentLocale;
     collectionPathCache = new Map();
-    constructor(db, collections) {
+    constructor(db, collections, defaultContentLocale) {
         this.db = db;
         this.collections = collections;
+        this.defaultContentLocale = defaultContentLocale;
     }
     /**
      * Resolve a collection UUID to its CollectionDefinition by looking up the
@@ -88,6 +90,126 @@ export class DocumentQueries {
     pickCurrentView(readMode) {
         return readMode === 'published' ? currentPublishedDocumentsView : currentDocumentsView;
     }
+    /**
+     * Build the locale priority chain for path resolution:
+     * `[requested, default]`, deduplicated when both are the same.
+     *
+     * Used by every read path that touches `byline_document_paths`. In
+     * phase 1 only the default-locale row is ever populated, so a non-
+     * default `requested` locale always falls through to the default —
+     * but the chain shape is correct for phase 2 when per-locale rows
+     * begin to exist.
+     */
+    buildLocaleChain(requestedLocale) {
+        const requested = requestedLocale ?? this.defaultContentLocale;
+        return requested === this.defaultContentLocale
+            ? [requested]
+            : [requested, this.defaultContentLocale];
+    }
+    /**
+     * Emit a SQL fragment that resolves the path string for a document via
+     * the locale priority chain. Used as a projected column expression
+     * inside `SELECT` lists.
+     *
+     * ```sql
+     * (SELECT path FROM byline_document_paths
+     *  WHERE document_id = <docIdSql>
+     *    AND locale = ANY(<chain>)
+     *  ORDER BY array_position(<chain>, locale)
+     *  LIMIT 1)
+     * ```
+     */
+    pathProjection(documentIdCol, requestedLocale) {
+        const chain = this.buildLocaleChain(requestedLocale);
+        // Build a `ARRAY[$1, $2, ...]::text[]` literal so each locale is its
+        // own parameter. Passing a JS array as a single `${chain}` placeholder
+        // serialises as a scalar string (`'en'`), which Postgres rejects when
+        // cast to `text[]` ("malformed array literal").
+        const chainSql = sql.join(chain.map((l) => sql `${l}`), sql `, `);
+        return sql `(
+      SELECT ${documentPaths.path} FROM ${documentPaths}
+      WHERE ${documentPaths.document_id} = ${documentIdCol}
+        AND ${documentPaths.locale} = ANY(ARRAY[${chainSql}]::text[])
+      ORDER BY array_position(ARRAY[${chainSql}]::text[], ${documentPaths.locale})
+      LIMIT 1
+    )`;
+    }
+    /**
+     * Project list for `current_documents` / `current_published_documents`
+     * reads, with `path` resolved through the locale priority chain. Used
+     * everywhere a read previously did `.select()` (which auto-pulls every
+     * view column) — `path` is no longer projected by the views, so call
+     * sites must list the projection explicitly. This helper keeps the
+     * shape consistent and the call sites tidy.
+     */
+    viewProjection(view, requestedLocale) {
+        return {
+            id: view.id,
+            document_id: view.document_id,
+            collection_id: view.collection_id,
+            collection_version: view.collection_version,
+            event_type: view.event_type,
+            status: view.status,
+            is_deleted: view.is_deleted,
+            created_at: view.created_at,
+            updated_at: view.updated_at,
+            created_by: view.created_by,
+            change_summary: view.change_summary,
+            path: this.pathProjection(sql `${view.document_id}`, requestedLocale),
+        };
+    }
+    /**
+     * Project list for direct `byline_document_versions` reads (history,
+     * version-by-id lookups). Mirrors `viewProjection` but against the
+     * underlying table — `path` is sourced from `byline_document_paths` via
+     * the locale priority chain, since it no longer lives on the version row.
+     */
+    documentVersionsProjection(requestedLocale) {
+        return {
+            id: documentVersions.id,
+            document_id: documentVersions.document_id,
+            collection_id: documentVersions.collection_id,
+            collection_version: documentVersions.collection_version,
+            event_type: documentVersions.event_type,
+            status: documentVersions.status,
+            is_deleted: documentVersions.is_deleted,
+            created_at: documentVersions.created_at,
+            updated_at: documentVersions.updated_at,
+            created_by: documentVersions.created_by,
+            change_summary: documentVersions.change_summary,
+            path: this.pathProjection(sql `${documentVersions.document_id}`, requestedLocale),
+        };
+    }
+    /**
+     * Emit a SQL fragment that resolves a `(collection_id, path)` tuple to
+     * a `document_id` via the locale priority chain. Used inside `WHERE`
+     * clauses for findByPath-style lookups:
+     *
+     * ```sql
+     * WHERE document_id = (
+     *   SELECT document_id FROM byline_document_paths
+     *   WHERE collection_id = ? AND path = ?
+     *     AND locale = ANY(<chain>)
+     *   ORDER BY array_position(<chain>, locale)
+     *   LIMIT 1
+     * )
+     * ```
+     *
+     * Returns NULL when no row matches in any locale, which makes the
+     * outer `=` predicate fail cleanly (no document found).
+     */
+    resolveDocumentIdByPath(collection_id, path, requestedLocale) {
+        const chain = this.buildLocaleChain(requestedLocale);
+        const chainSql = sql.join(chain.map((l) => sql `${l}`), sql `, `);
+        return sql `(
+      SELECT ${documentPaths.document_id} FROM ${documentPaths}
+      WHERE ${documentPaths.collection_id} = ${collection_id}
+        AND ${documentPaths.path} = ${path}
+        AND ${documentPaths.locale} = ANY(ARRAY[${chainSql}]::text[])
+      ORDER BY array_position(ARRAY[${chainSql}]::text[], ${documentPaths.locale})
+      LIMIT 1
+    )`;
+    }
     /**
      * Reconstruct document fields from unified row values using schema-aware
      * restoration. Meta rows (from store_meta) are converted to
@@ -137,7 +259,10 @@ export class DocumentQueries {
             document_version_id: currentDocumentsView.id,
             document_id: currentDocumentsView.document_id,
             collection_id: currentDocumentsView.collection_id,
-            path: currentDocumentsView.path,
+            // Lifecycle metadata fetch — always reads the default-locale path.
+            // This is internal lifecycle plumbing (status changes, delete checks),
+            // not a user-facing read, so the request locale never applies.
+            path: this.pathProjection(sql `${currentDocumentsView.document_id}`),
             status: currentDocumentsView.status,
             created_at: currentDocumentsView.created_at,
             updated_at: currentDocumentsView.updated_at,
@@ -151,7 +276,7 @@ export class DocumentQueries {
             document_version_id: row.document_version_id,
             document_id: row.document_id,
             collection_id: row.collection_id ?? '',
-            path: row.path,
+            path: row.path ?? '',
             status: row.status ?? 'draft',
             created_at: row.created_at ?? new Date(),
             updated_at: row.updated_at ?? new Date(),
@@ -176,14 +301,14 @@ export class DocumentQueries {
             const outerScope = {
                 docVersionId: sql `${view.id}`,
                 status: sql `${view.status}`,
-                path: sql `${view.path}`,
+                path: this.pathProjection(sql `${view.document_id}`, locale),
             };
             for (const f of filters) {
                 baseConditions.push(this.buildFilterExists(f, locale, outerScope, readMode, 0));
             }
         }
         const [document] = await this.db
-            .select()
+            .select(this.viewProjection(view, locale))
             .from(view)
             .where(and(...baseConditions));
         if (document == null) {
@@ -207,7 +332,7 @@ export class DocumentQueries {
             return {
                 document_version_id: document.id,
                 document_id: document.document_id,
-                path: document.path,
+                path: document.path ?? '',
                 status: document.status,
                 created_at: document.created_at,
                 updated_at: document.updated_at,
@@ -220,7 +345,7 @@ export class DocumentQueries {
         return {
             document_version_id: document.id,
             document_id: document.document_id,
-            path: document.path,
+            path: document.path ?? '',
             status: document.status,
             created_at: document.created_at,
             updated_at: document.updated_at,
@@ -230,19 +355,27 @@ export class DocumentQueries {
     async getDocumentByPath({ collection_id, path, locale = 'en', reconstruct = true, readMode, filters, }) {
         const view = this.pickCurrentView(readMode);
         // 1. Get current version (or current published version, per readMode)
-        const baseConditions = [eq(view.collection_id, collection_id), eq(view.path, path)];
+        //
+        // findByPath: resolve `(collection_id, path, locale-chain)` to a
+        // document_id via the document_paths subquery, then look up the
+        // current version by that id. Returns NULL when no path matches in
+        // any locale, which makes the outer `=` predicate fail cleanly.
+        const baseConditions = [
+            eq(view.collection_id, collection_id),
+            sql `${view.document_id} = ${this.resolveDocumentIdByPath(collection_id, path, locale)}`,
+        ];
         if (filters?.length) {
             const outerScope = {
                 docVersionId: sql `${view.id}`,
                 status: sql `${view.status}`,
-                path: sql `${view.path}`,
+                path: this.pathProjection(sql `${view.document_id}`, locale),
             };
             for (const f of filters) {
                 baseConditions.push(this.buildFilterExists(f, locale, outerScope, readMode, 0));
             }
         }
         const [document] = await this.db
-            .select()
+            .select(this.viewProjection(view, locale))
             .from(view)
             .where(and(...baseConditions));
         if (document == null) {
@@ -266,7 +399,7 @@ export class DocumentQueries {
             return {
                 document_version_id: document.id,
                 document_id: document.document_id,
-                path: document.path,
+                path: document.path ?? '',
                 status: document.status,
                 created_at: document.created_at,
                 updated_at: document.updated_at,
@@ -278,7 +411,7 @@ export class DocumentQueries {
         return {
             document_version_id: document.id,
             document_id: document.document_id,
-            path: document.path,
+            path: document.path ?? '',
             status: document.status,
             created_at: document.created_at,
             updated_at: document.updated_at,
@@ -289,9 +422,11 @@ export class DocumentQueries {
      * getDocumentByVersion — fetches a specific version and reconstructs its fields.
      */
     async getDocumentByVersion({ document_version_id, locale = 'all', }) {
-        const document = await this.db.query.documentVersions.findFirst({
-            where: eq(documentVersions.id, document_version_id),
-        });
+        const projectionLocale = locale === 'all' ? undefined : locale;
+        const [document] = await this.db
+            .select(this.documentVersionsProjection(projectionLocale))
+            .from(documentVersions)
+            .where(eq(documentVersions.id, document_version_id));
         if (document == null) {
             throw ERR_NOT_FOUND({
                 message: `no current version found for document ${document_version_id}`,
@@ -313,7 +448,7 @@ export class DocumentQueries {
         const documentWithFields = {
             document_version_id: document.id,
             document_id: document.document_id,
-            path: document.path,
+            path: document.path ?? '',
             status: document.status,
             created_at: document.created_at,
             updated_at: document.updated_at,
@@ -330,7 +465,7 @@ export class DocumentQueries {
         if (document_version_ids.length === 0)
             return [];
         const docs = await this.db
-            .select()
+            .select(this.documentVersionsProjection(locale === 'all' ? undefined : locale))
             .from(documentVersions)
             .where(inArray(documentVersions.id, document_version_ids));
         return this.reconstructDocuments({ documents: docs, locale });
@@ -355,9 +490,9 @@ export class DocumentQueries {
         // The locale used to compile filter EXISTS subqueries should resolve
         // values from a real locale, even when the surrounding read uses the
         // sentinel `'all'` (populate batches that span every locale do this).
-        // Falling back to `'en'` here matches the default used by the
-        // single-doc lookup methods.
-        const filterLocale = locale === 'all' ? 'en' : locale;
+        // Falling back to the installation default here matches the default
+        // used by the single-doc lookup methods.
+        const filterLocale = locale === 'all' ? this.defaultContentLocale : locale;
         const baseConditions = [
             eq(view.collection_id, collection_id),
             inArray(view.document_id, document_ids),
@@ -366,14 +501,14 @@ export class DocumentQueries {
             const outerScope = {
                 docVersionId: sql `${view.id}`,
                 status: sql `${view.status}`,
-                path: sql `${view.path}`,
+                path: this.pathProjection(sql `${view.document_id}`, filterLocale),
             };
             for (const f of filters) {
                 baseConditions.push(this.buildFilterExists(f, filterLocale, outerScope, readMode, 0));
             }
         }
         const docs = await this.db
-            .select()
+            .select(this.viewProjection(view, filterLocale))
             .from(view)
             .where(and(...baseConditions));
         return this.reconstructDocuments({ documents: docs, locale, fields });
@@ -401,10 +536,14 @@ export class DocumentQueries {
         const total = Number(totalResult[0]?.count) || 0;
         const total_pages = Math.ceil(total / page_size);
         const offset = (page - 1) * page_size;
-        const orderColumn = order === 'path' ? documentVersions.path : documentVersions.created_at;
+        // History is per-document; path is sticky so every version row has the
+        // same value. `order === 'path'` is degenerate and was removed when
+        // path moved to byline_document_paths — fall back to created_at.
+        const orderColumn = documentVersions.created_at;
         const orderFunc = desc === true ? sql `DESC` : sql `ASC`;
+        const projectionLocale = locale === 'all' ? undefined : locale;
         const result = await this.db
-            .select()
+            .select(this.documentVersionsProjection(projectionLocale))
             .from(documentVersions)
             .where(and(eq(documentVersions.collection_id, collection_id), eq(documentVersions.document_id, document_id)))
             .orderBy(sql `${orderColumn} ${orderFunc}`)
@@ -479,10 +618,10 @@ export class DocumentQueries {
             const outerScope = {
                 docVersionId: sql `${currentDocumentsView.id}`,
                 status: sql `${currentDocumentsView.status}`,
-                path: sql `${currentDocumentsView.path}`,
+                path: this.pathProjection(sql `${currentDocumentsView.document_id}`, this.defaultContentLocale),
             };
             for (const f of filters) {
-                conditions.push(this.buildFilterExists(f, 'en', outerScope, undefined, 0));
+                conditions.push(this.buildFilterExists(f, this.defaultContentLocale, outerScope, undefined, 0));
             }
         }
         const rows = await this.db
@@ -564,7 +703,7 @@ export class DocumentQueries {
             const documentWithFields = {
                 document_version_id: doc.id,
                 document_id: doc.document_id,
-                path: doc.path,
+                path: doc.path ?? '',
                 status: doc.status,
                 created_at: doc.created_at,
                 updated_at: doc.updated_at,
@@ -635,7 +774,7 @@ export class DocumentQueries {
             conditions.push(sql `d.status = ${status}`);
         }
         if (pathFilter) {
-            conditions.push(this.buildDocumentLevelCondition('d.path', pathFilter.operator, pathFilter.value));
+            conditions.push(this.buildFilterCondition(this.pathProjection(sql `d.document_id`, locale), pathFilter.operator, pathFilter.value));
         }
         // Text search across configured search fields via EXISTS on store_text.
         if (query) {
@@ -653,7 +792,11 @@ export class DocumentQueries {
         // introduces its own alias scope (`r${depth}`, `td${depth}`) so nested
         // EXISTS clauses don't shadow their outer relation's aliases.
         for (const filter of filters) {
-            conditions.push(this.buildFilterExists(filter, locale, { docVersionId: sql `d.id`, status: sql `d.status`, path: sql `d.path` }, readMode, 0));
+            conditions.push(this.buildFilterExists(filter, locale, {
+                docVersionId: sql `d.id`,
+                status: sql `d.status`,
+                path: this.pathProjection(sql `d.document_id`, locale),
+            }, readMode, 0));
         }
         const whereClause = sql.join(conditions, sql ` AND `);
         // -- Build ORDER BY -------------------------------------------------------
@@ -697,8 +840,14 @@ export class DocumentQueries {
             return { documents: [], total: 0 };
         }
         // -- Main query -----------------------------------------------------------
+        //
+        // `d.*` no longer includes `path` (it lives in byline_document_paths
+        // keyed by document_id + locale). Project it via the locale-aware
+        // subquery so the result rows still carry `path` for the in-memory
+        // Document shape.
+        const pathProjectionSql = this.pathProjection(sql `d.document_id`, locale);
         const mainQuery = sql `
-      SELECT d.*
+      SELECT d.*, ${pathProjectionSql} AS path
       FROM ${sourceTable} d
       ${sortJoin}
       WHERE ${whereClause}
@@ -712,7 +861,7 @@ export class DocumentQueries {
             document_id: row.document_id,
             collection_id: row.collection_id,
             collection_version: row.collection_version,
-            path: row.path,
+            path: row.path ?? null,
             event_type: row.event_type,
             status: row.status,
             is_deleted: row.is_deleted,
@@ -830,7 +979,9 @@ export class DocumentQueries {
         const innerScope = {
             docVersionId: sql.raw(`td${depth}.id`),
             status: sql.raw(`td${depth}.status`),
-            path: sql.raw(`td${depth}.path`),
+            // `td${depth}.path` no longer exists on the view; resolve via the
+            // locale priority chain against byline_document_paths instead.
+            path: this.pathProjection(sql.raw(`td${depth}.document_id`), locale),
         };
         const nestedConditions = filter.nested.map((nested) => this.buildFilterExists(nested, locale, innerScope, readMode, depth + 1));
         const nestedAnd = nestedConditions.length > 0 ? sql ` AND ${sql.join(nestedConditions, sql ` AND `)}` : sql ``;
@@ -987,9 +1138,9 @@ export class DocumentQueries {
         });
     }
 }
-export function createQueryBuilders(db, collections) {
+export function createQueryBuilders(db, collections, defaultContentLocale) {
     return {
         collections: new CollectionQueries(db),
-        documents: new DocumentQueries(db, collections),
+        documents: new DocumentQueries(db, collections, defaultContentLocale),
     };
 }

package/dist/modules/storage/tests/storage-document-paths.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-document-paths.test.js

@@ -0,0 +1,202 @@
+/**
+ * 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
+ */
+/**
+ * Integration tests for the byline_document_paths layer.
+ *
+ * Exercises the storage adapter directly (not the lifecycle) so each test
+ * isolates one storage-level invariant:
+ *
+ *   - per-(collection, locale) path uniqueness — the second insert with
+ *     the same `(collection_id, locale, path)` triggers Postgres SQLSTATE
+ *     23505 on `idx_document_paths_collection_locale_path`.
+ *   - locale fallback in reads — `getDocumentByPath` with a non-default
+ *     `locale` resolves through the priority chain `[requested, default]`
+ *     and finds the default-locale row when no row exists for the
+ *     requested locale.
+ *   - upsert-on-self — re-issuing `createDocumentVersion` with the same
+ *     `path` for the same `documentId` succeeds (the conflict target is
+ *     `(document_id, locale)`, so the existing row is updated in place).
+ */
+import assert from 'node:assert';
+import { after, before, describe, it } from 'node:test';
+import { setupTestDB, teardownTestDB } from '../../../lib/test-helper.js';
+let commandBuilders;
+let queryBuilders;
+const timestamp = Date.now();
+const PathsCollectionConfig = {
+    path: `paths-${timestamp}`,
+    labels: { singular: 'PathsTest', plural: 'PathsTests' },
+    fields: [{ name: 'title', type: 'text' }],
+};
+let testCollection = {};
+describe('byline_document_paths integration', () => {
+    before(async () => {
+        const testDB = setupTestDB([PathsCollectionConfig]);
+        commandBuilders = testDB.commandBuilders;
+        queryBuilders = testDB.queryBuilders;
+        const result = await commandBuilders.collections.create(PathsCollectionConfig.path, PathsCollectionConfig);
+        const collection = result[0];
+        if (collection == null) {
+            throw new Error('Failed to create test collection');
+        }
+        testCollection = { id: collection.id, name: collection.path };
+    });
+    after(async () => {
+        try {
+            await commandBuilders.collections.delete(testCollection.id);
+        }
+        catch (error) {
+            console.error('Failed to cleanup test collection:', error);
+        }
+        await teardownTestDB();
+    });
+    it('rejects a second create with the same (collection_id, locale, path)', async () => {
+        const sharedPath = `dup-${Date.now()}`;
+        // First create succeeds — no row yet under (collection, 'en', path).
+        await commandBuilders.documents.createDocumentVersion({
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'create',
+            documentData: { title: 'First' },
+            path: sharedPath,
+            locale: 'all',
+            status: 'draft',
+        });
+        // Second create — different document, same path — collides on the
+        // unique index `idx_document_paths_collection_locale_path`.
+        let caught = null;
+        try {
+            await commandBuilders.documents.createDocumentVersion({
+                collectionId: testCollection.id,
+                collectionVersion: 1,
+                collectionConfig: PathsCollectionConfig,
+                action: 'create',
+                documentData: { title: 'Second' },
+                path: sharedPath,
+                locale: 'all',
+                status: 'draft',
+            });
+        }
+        catch (err) {
+            caught = err;
+        }
+        assert.ok(caught, 'expected unique-constraint violation on duplicate path');
+        // Drizzle wraps pg errors in DrizzleQueryError with the original error
+        // attached as `cause`. The lifecycle layer's rethrowPathConflict reads
+        // both the wrapper and the cause to detect 23505 + the path constraint
+        // name; mirror that here.
+        const original = caught.cause ?? caught;
+        assert.strictEqual(original.code, '23505', `expected SQLSTATE 23505, got ${original?.code}`);
+        assert.match(String(original.constraint ?? ''), /document_paths_collection_locale_path/, `constraint name should reference the path index, got ${original?.constraint}`);
+    });
+    it('upserts in place when the same document re-saves the same path', async () => {
+        const sharedPath = `same-doc-${Date.now()}`;
+        const first = await commandBuilders.documents.createDocumentVersion({
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'create',
+            documentData: { title: 'V1' },
+            path: sharedPath,
+            locale: 'all',
+            status: 'draft',
+        });
+        const documentId = first.document.document_id;
+        // Same path on the same logical document — the conflict target is
+        // (document_id, locale), so onConflictDoUpdate handles this.
+        const second = await commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'update',
+            documentData: { title: 'V2' },
+            path: sharedPath,
+            locale: 'all',
+            status: 'draft',
+            previousVersionId: first.document.id,
+        });
+        assert.strictEqual(second.document.document_id, documentId, 'same logical document');
+    });
+    it('updates the path row in place when a document changes its path', async () => {
+        const originalPath = `original-${Date.now()}`;
+        const updatedPath = `updated-${Date.now()}`;
+        const first = await commandBuilders.documents.createDocumentVersion({
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'create',
+            documentData: { title: 'X' },
+            path: originalPath,
+            locale: 'all',
+            status: 'draft',
+        });
+        const documentId = first.document.document_id;
+        await commandBuilders.documents.createDocumentVersion({
+            documentId,
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'update',
+            documentData: { title: 'X' },
+            path: updatedPath,
+            locale: 'all',
+            status: 'draft',
+            previousVersionId: first.document.id,
+        });
+        // The new path resolves; the old one no longer does.
+        const found = await queryBuilders.documents.getDocumentByPath({
+            collection_id: testCollection.id,
+            path: updatedPath,
+            reconstruct: false,
+        });
+        assert.ok(found, 'updated path should resolve');
+        assert.strictEqual(found.document_id, documentId);
+        const oldNotFound = await queryBuilders.documents.getDocumentByPath({
+            collection_id: testCollection.id,
+            path: originalPath,
+            reconstruct: false,
+        });
+        assert.strictEqual(oldNotFound, null, 'original path no longer resolves');
+    });
+    it('falls back to the default-locale path row when the requested locale has no row', async () => {
+        const onlyDefaultPath = `default-only-${Date.now()}`;
+        const first = await commandBuilders.documents.createDocumentVersion({
+            collectionId: testCollection.id,
+            collectionVersion: 1,
+            collectionConfig: PathsCollectionConfig,
+            action: 'create',
+            documentData: { title: 'EN-Only' },
+            path: onlyDefaultPath,
+            locale: 'all',
+            status: 'draft',
+        });
+        const documentId = first.document.document_id;
+        // No 'fr' row exists for this document; the read still resolves via
+        // the [requested, default] priority chain.
+        const found = await queryBuilders.documents.getDocumentByPath({
+            collection_id: testCollection.id,
+            path: onlyDefaultPath,
+            locale: 'fr',
+            reconstruct: false,
+        });
+        assert.ok(found, 'fallback chain should resolve via the en row');
+        assert.strictEqual(found.document_id, documentId);
+        assert.strictEqual(found.path, onlyDefaultPath);
+    });
+    it('returns null on getDocumentByPath when no row matches in any locale', async () => {
+        const result = await queryBuilders.documents.getDocumentByPath({
+            collection_id: testCollection.id,
+            path: `does-not-exist-${Date.now()}`,
+            locale: 'fr',
+            reconstruct: false,
+        });
+        assert.strictEqual(result, null);
+    });
+});

package/package.json

@@ -2,7 +2,7 @@
   "name": "@byline/db-postgres",
   "private": false,
   "license": "MPL-2.0",
-  "version": "1.7.7",
+  "version": "1.8.1",
   "engines": {
     "node": ">=20.9.0"
   },
@@ -52,9 +52,9 @@
     "pg": "^8.20.0",
     "uuid": "^14.0.0",
     "zod": "^4.4.2",
-    "@byline/auth": "1.7.7",
-    "@byline/core": "1.7.7",
-    "@byline/admin": "1.7.7"
+    "@byline/auth": "1.8.1",
+    "@byline/core": "1.8.1",
+    "@byline/admin": "1.8.1"
   },
   "devDependencies": {
     "@biomejs/biome": "2.4.14",