@gobing-ai/ts-db 0.2.7 → 0.2.9

package/dist/schema/drizzle-internals.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Quarantine for the *unversioned* drizzle-orm internal shapes ts-db reaches into
+ * for DDL generation.
+ *
+ * Everything else in ts-db consumes drizzle's public API (`getTableConfig`,
+ * column accessors). These two helpers are the only places that touch private
+ * structure — the SQL-expression `queryChunks` array and the
+ * `Symbol.for('drizzle:Name')` table-name slot — neither of which is covered by
+ * drizzle's semver contract. Keeping both here means a drizzle bump that changes
+ * an internal shape breaks in ONE file with ONE focused test, instead of silently
+ * mis-generating DDL across `ddl.ts`. If this module starts failing after an
+ * upgrade, the fix lives here.
+ */
+/**
+ * Render a drizzle `sql\`...\`` expression to its literal SQL text by walking its
+ * internal `queryChunks`. Used to emit SQL-level column defaults
+ * (e.g. `DEFAULT (unixepoch())`) into generated DDL.
+ *
+ * Returns `undefined` when `value` is not a drizzle SQL expression with chunks,
+ * so callers can fall through to their primitive/`String()` handling.
+ */
+export declare function sqlExpressionToText(value: unknown): string | undefined;
+/** Resolve a drizzle table object to its declared name (stored at a private symbol). */
+export declare function getDrizzleTableName(table: object): string;
+//# sourceMappingURL=drizzle-internals.d.ts.map

package/dist/schema/drizzle-internals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drizzle-internals.d.ts","sourceRoot":"","sources":["../../src/schema/drizzle-internals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAoBtE;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAGzD"}

package/dist/schema/drizzle-internals.js

@@ -0,0 +1,47 @@
+/**
+ * Quarantine for the *unversioned* drizzle-orm internal shapes ts-db reaches into
+ * for DDL generation.
+ *
+ * Everything else in ts-db consumes drizzle's public API (`getTableConfig`,
+ * column accessors). These two helpers are the only places that touch private
+ * structure — the SQL-expression `queryChunks` array and the
+ * `Symbol.for('drizzle:Name')` table-name slot — neither of which is covered by
+ * drizzle's semver contract. Keeping both here means a drizzle bump that changes
+ * an internal shape breaks in ONE file with ONE focused test, instead of silently
+ * mis-generating DDL across `ddl.ts`. If this module starts failing after an
+ * upgrade, the fix lives here.
+ */
+/**
+ * Render a drizzle `sql\`...\`` expression to its literal SQL text by walking its
+ * internal `queryChunks`. Used to emit SQL-level column defaults
+ * (e.g. `DEFAULT (unixepoch())`) into generated DDL.
+ *
+ * Returns `undefined` when `value` is not a drizzle SQL expression with chunks,
+ * so callers can fall through to their primitive/`String()` handling.
+ */
+export function sqlExpressionToText(value) {
+    if (typeof value !== 'object' || value === null || !('queryChunks' in value)) {
+        return undefined;
+    }
+    const chunks = value.queryChunks;
+    if (!chunks)
+        return undefined;
+    return chunks
+        .map((chunk) => {
+        // StringChunk — the literal SQL fragment
+        if ('value' in chunk && typeof chunk.value === 'string') {
+            return chunk.value;
+        }
+        // Param — use the input value if available
+        if ('input' in chunk && chunk.input !== undefined) {
+            return String(chunk.input);
+        }
+        return String(chunk.value ?? '?');
+    })
+        .join('');
+}
+/** Resolve a drizzle table object to its declared name (stored at a private symbol). */
+export function getDrizzleTableName(table) {
+    const nameSym = Symbol.for('drizzle:Name');
+    return String(table[nameSym]);
+}

package/dist/schema/inbox-messages.d.ts

@@ -0,0 +1,212 @@
+/**
+ * Drizzle schema definition for durable inter-agent inbox messages.
+ */
+export declare const inboxMessages: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "inbox_messages";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        fromId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "from_id";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        toId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "to_id";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        body: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "body";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        status: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "status";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        inReplyTo: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "in_reply_to";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "inbox_messages";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "inbox_messages";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        deliveredAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "delivered_at";
+            tableName: "inbox_messages";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        injectAttempts: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "inject_attempts";
+            tableName: "inbox_messages";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        injectError: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "inject_error";
+            tableName: "inbox_messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=inbox-messages.d.ts.map

package/dist/schema/inbox-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbox-messages.d.ts","sourceRoot":"","sources":["../../src/schema/inbox-messages.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBzB,CAAC"}

package/dist/schema/inbox-messages.js

@@ -0,0 +1,17 @@
+import { index, integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+/**
+ * Drizzle schema definition for durable inter-agent inbox messages.
+ */
+export const inboxMessages = sqliteTable('inbox_messages', {
+    id: text('id').primaryKey(),
+    fromId: text('from_id'),
+    toId: text('to_id').notNull(),
+    body: text('body').notNull(),
+    status: text('status').notNull().default('queued'),
+    inReplyTo: text('in_reply_to'),
+    createdAt: integer('created_at').notNull(),
+    updatedAt: integer('updated_at').notNull(),
+    deliveredAt: integer('delivered_at'),
+    injectAttempts: integer('inject_attempts').notNull().default(0),
+    injectError: text('inject_error'),
+}, (table) => [index('idx_inbox_messages_to_status').on(table.toId, table.status)]);

package/dist/schema/index.d.ts

@@ -2,5 +2,6 @@ export { index, integer, text } from 'drizzle-orm/sqlite-core';
 export * from './common';
 export { generateCreateTableSql } from './ddl';
 export { type DefinedTable, defineTable } from './define-table';
+export { inboxMessages } from './inbox-messages';
 export { queueJobs } from './queue-jobs';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/D,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAE,KAAK,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,yBAAyB,CAAC;AAC/D,cAAc,UAAU,CAAC;AACzB,OAAO,EAAE,sBAAsB,EAAE,MAAM,OAAO,CAAC;AAC/C,OAAO,EAAE,KAAK,YAAY,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/schema/index.js

@@ -2,4 +2,5 @@ export { index, integer, text } from 'drizzle-orm/sqlite-core';
 export * from './common.js';
 export { generateCreateTableSql } from './ddl.js';
 export { defineTable } from './define-table.js';
+export { inboxMessages } from './inbox-messages.js';
 export { queueJobs } from './queue-jobs.js';

package/dist/schema/runtime.d.ts

@@ -1,2 +1,3 @@
+export { inboxMessages } from './inbox-messages';
 export { queueJobs } from './queue-jobs';
 //# sourceMappingURL=runtime.d.ts.map

package/dist/schema/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/schema/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../src/schema/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC"}

package/dist/schema/runtime.js

@@ -1 +1,2 @@
+export { inboxMessages } from './inbox-messages.js';
 export { queueJobs } from './queue-jobs.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gobing-ai/ts-db",
-    "version": "0.2.7",
+    "version": "0.2.9",
     "description": "@gobing-ai/ts-db — a drizzle-free database facade: typed DAOs over Bun SQLite / Cloudflare D1, a small predicate query spec, single-source-of-truth tables, and migrations. Drizzle stays an internal detail.",
     "keywords": [
         "typescript",
@@ -40,6 +40,10 @@
             "types": "./dist/adapters/d1.d.ts",
             "import": "./dist/adapters/d1.js"
         },
+        "./inbox": {
+            "types": "./dist/inbox.d.ts",
+            "import": "./dist/inbox.js"
+        },
         "./schema": {
             "types": "./dist/schema/index.d.ts",
             "import": "./dist/schema/index.js"
@@ -62,7 +66,8 @@
         "release": "echo 'Manual publish is disabled. Releases go through GitHub Actions via Trusted Publishing — push a tag: git tag @gobing-ai/ts-db-v<version> && git push --tags' && exit 1"
     },
     "dependencies": {
-        "@gobing-ai/ts-runtime": "^0.2.7"
+        "@gobing-ai/ts-runtime": "^0.2.9",
+        "@gobing-ai/ts-utils": "^0.2.9"
     },
     "peerDependencies": {
         "drizzle-orm": ">=0.38.0",

package/src/drizzle-builders.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared structural types for drizzle's fluent query builders.
+ *
+ * `InternalDb` is typed as the bare drizzle union (ADR-005 keeps drizzle internal),
+ * so its fluent builders (`insert().values().returning()`, `update().set().where()`,
+ * `select(proj).from()...`) are not surfaced as call-shapes. Each DAO previously
+ * re-declared these narrowings inline — three files independently describing the
+ * same `update → set → where → returning` chain. Centralising them here means the
+ * cast shape lives in one place: when drizzle's builder surface shifts, this file
+ * changes, not every DAO.
+ *
+ * These are deliberately minimal — each type narrows only the chain a DAO actually
+ * invokes. Table-specific projections (`select({ status, count })`) stay local to
+ * their DAO; only the recurring chain skeletons live here.
+ *
+ * @internal
+ */
+
+/** Terminal `.returning()` returning the written rows. */
+export interface ReturningRows {
+    returning: () => Promise<unknown[]>;
+}
+
+/** `insert(table).values(record)` → returning, with optional upsert. */
+export interface InsertBuilder {
+    values: (record: unknown) => ReturningRows & {
+        onConflictDoUpdate: (cfg: { target: unknown; set: unknown }) => ReturningRows;
+    };
+}
+
+/** `update(table).set(data).where(cond)` → `.returning()` rows. */
+export interface UpdateReturningDb {
+    update: (table: unknown) => {
+        set: (data: unknown) => {
+            where: (cond: unknown) => ReturningRows;
+        };
+    };
+}
+
+/** `update(table).set(data).where(cond)` → void (no rows). */
+export interface UpdateVoidDb {
+    update: (table: unknown) => {
+        set: (data: unknown) => {
+            where: (cond: unknown) => Promise<unknown>;
+        };
+    };
+}
+
+/** `update(table).set(data).where(cond)` → `{ changes }` (affected-row count). */
+export interface UpdateChangesDb {
+    update: (table: unknown) => {
+        set: (data: unknown) => {
+            where: (cond: unknown) => Promise<{ changes: number }>;
+        };
+    };
+}
+
+/** `update(table).set(data).where(cond)` → arbitrary single condition (no projection). */
+export interface SimpleUpdateDb {
+    update: (table: unknown) => {
+        set: (data: unknown) => {
+            where: (cond: unknown) => ReturningRows;
+        };
+    };
+}
+
+/** `select(projection).from(table)` exposing `.where(...)` and `.groupBy(...)` terminals. */
+export interface SelectProjectionDb {
+    select: (projection: unknown) => {
+        from: (table: unknown) => {
+            where: (cond: unknown) => Promise<unknown[]>;
+            groupBy: (group: unknown) => Promise<unknown[]>;
+        };
+    };
+}
+
+/** `select().from(table).where(cond).orderBy(o).limit(n)` — the ready-rows read chain. */
+export interface SelectOrderedLimitDb {
+    select: () => {
+        from: (table: unknown) => {
+            where: (cond: unknown) => {
+                orderBy: (order: unknown) => { limit: (limit: number) => Promise<unknown[]> };
+            };
+        };
+    };
+}
+
+/** `select(count).from(table)` that is awaitable and chainable with `.where(...)`. */
+export type CountQuery = Promise<unknown[]> & {
+    where: (condition: unknown) => Promise<unknown[]>;
+};
+
+/** `select({ value: count() }).from(table)` → awaitable count, optionally filtered. */
+export interface CountSelectDb {
+    select: (projection: unknown) => {
+        from: (table: unknown) => CountQuery;
+    };
+}

package/src/embedded-migrations.ts

@@ -29,4 +29,14 @@ export const embeddedMigrations: EmbeddedMigration[] = [
         sql: 'ALTER TABLE `queue_jobs` ADD `expires_at` integer;',
         hash: '7380f8c162352a61b15205af5a87e0e7313a499203dae98fe62151a1dc7fec0e',
     },
+    {
+        tag: '0003_inbox_messages',
+        sql: "CREATE TABLE `inbox_messages` (\n\t`id` text PRIMARY KEY NOT NULL,\n\t`from_id` text,\n\t`to_id` text NOT NULL,\n\t`body` text NOT NULL,\n\t`status` text DEFAULT 'queued' NOT NULL,\n\t`in_reply_to` text,\n\t`created_at` integer NOT NULL,\n\t`updated_at` integer NOT NULL,\n\t`delivered_at` integer,\n\t`inject_attempts` integer DEFAULT 0 NOT NULL,\n\t`inject_error` text\n);",
+        hash: 'c4ba569172d1be276c42b5c164c668404e6229dcf48b41d7fb2bc93e8d29d11b',
+    },
+    {
+        tag: '0004_inbox_messages_to_status_idx',
+        sql: 'CREATE INDEX `idx_inbox_messages_to_status` ON `inbox_messages` (`to_id`,`status`);',
+        hash: '3c00f1bce4f569e442f3142df31ff478d6c9b3d460824d46575f50a324bfae61',
+    },
 ];

package/src/entity-dao.ts

@@ -2,18 +2,9 @@ import { and, count as countFn, eq, type SQL } from 'drizzle-orm';
 import type { SQLiteColumn, SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { DbAdapter } from './adapter';
 import { BaseDao } from './base-dao';
+import type { CountSelectDb, InsertBuilder, ReturningRows } from './drizzle-builders';
 import { compilePredicate, type OrderTerm, type Predicate } from './query-spec';
 
-type ReturningRows = {
-    returning: () => Promise<unknown[]>;
-};
-
-type InsertBuilder = {
-    values: (record: unknown) => ReturningRows & {
-        onConflictDoUpdate: (cfg: { target: SQLiteColumn[]; set: unknown }) => ReturningRows;
-    };
-};
-
 type UpdateBuilder = {
     set: (data: unknown) => {
         where: (condition: SQL) => ReturningRows;
@@ -24,16 +15,6 @@ type DeleteBuilder = {
     where: (condition: SQL) => Promise<unknown>;
 };
 
-type CountQuery = Promise<unknown[]> & {
-    where: (condition: SQL) => Promise<unknown[]>;
-};
-
-type CountDb = {
-    select: (projection: unknown) => {
-        from: (table: unknown) => CountQuery;
-    };
-};
-
 /**
  * Type for tables compatible with EntityDao.
  * Must have standard columns: createdAt, updatedAt.
@@ -347,7 +328,7 @@ export class EntityDao<TTable extends EntityTable, TPK extends SQLiteColumn> ext
     async count(where?: Predicate, includeDeleted = false): Promise<number> {
         const condition = this.withActive(where, includeDeleted);
         const compiled = condition ? compilePredicate(condition) : undefined;
-        const base = (this.db as CountDb).select({ value: countFn() }).from(this.table);
+        const base = (this.db as CountSelectDb).select({ value: countFn() }).from(this.table);
         const result = (await (compiled ? base.where(compiled) : base)) as {
             value: number;
         }[];

package/src/inbox-message-dao.ts

@@ -0,0 +1,91 @@
+import { sql } from 'drizzle-orm';
+import type { DbAdapter } from './adapter';
+import type { UpdateReturningDb } from './drizzle-builders';
+import { EntityDao } from './entity-dao';
+import { inboxMessages } from './schema/inbox-messages';
+
+/** Row type inferred from the inbox_messages Drizzle schema. */
+export type InboxMessage = typeof inboxMessages.$inferSelect;
+
+/**
+ * DAO for durable inter-agent inbox messages.
+ */
+export class InboxMessageDao extends EntityDao<typeof inboxMessages, typeof inboxMessages.id> {
+    constructor(adapter: DbAdapter) {
+        super(adapter, inboxMessages, [inboxMessages.id], 'inbox_messages');
+    }
+
+    async enqueue(fromId: string | null, toId: string, body: string, inReplyTo?: string): Promise<string> {
+        const id = crypto.randomUUID();
+        await this.create({
+            id,
+            fromId,
+            toId,
+            body,
+            status: 'queued',
+            injectAttempts: 0,
+            ...(inReplyTo !== undefined ? { inReplyTo } : {}),
+        });
+        return id;
+    }
+
+    async drainPending(toId: string): Promise<InboxMessage[]> {
+        const now = this.now();
+        const rows = await (this.db as UpdateReturningDb)
+            .update(inboxMessages)
+            .set({
+                status: 'injected',
+                injectAttempts: sql`${inboxMessages.injectAttempts} + 1`,
+                updatedAt: now,
+            })
+            .where(
+                sql`${inboxMessages.id} IN (
+                    SELECT id
+                    FROM ${inboxMessages}
+                    WHERE to_id = ${toId}
+                      AND status = 'queued'
+                    ORDER BY created_at
+                )
+                AND ${inboxMessages.status} = 'queued'`,
+            )
+            .returning();
+
+        return rows as InboxMessage[];
+    }
+
+    async markDelivered(msgId: string): Promise<void> {
+        await this.update(msgId, {
+            status: 'delivered',
+            deliveredAt: this.now(),
+        });
+    }
+
+    async markFailed(msgId: string, error: string): Promise<void> {
+        await this.update(msgId, {
+            status: 'failed',
+            injectError: error,
+        });
+    }
+
+    async inbox(toId: string, limit?: number, offset?: number): Promise<InboxMessage[]> {
+        return this.list({
+            where: { col: inboxMessages.toId, op: 'eq', value: toId },
+            orderBy: [{ col: inboxMessages.createdAt, dir: 'desc' }],
+            ...(limit !== undefined ? { limit } : {}),
+            ...(offset !== undefined ? { offset } : {}),
+        });
+    }
+
+    async countPending(toId: string): Promise<number> {
+        return this.count({
+            and: [
+                { col: inboxMessages.toId, op: 'eq', value: toId },
+                { col: inboxMessages.status, op: 'eq', value: 'queued' },
+            ],
+        });
+    }
+
+    async getById(id: string): Promise<InboxMessage | undefined> {
+        return this.findBy(inboxMessages.id, id);
+    }
+}

package/src/inbox.ts

@@ -0,0 +1,2 @@
+export { type InboxMessage, InboxMessageDao } from './inbox-message-dao';
+export { inboxMessages } from './schema/inbox-messages';

package/src/index.ts

@@ -14,7 +14,8 @@ export {
     type PKValue,
     type SoftDeletableTable,
 } from './entity-dao';
-export { applyMigrations, type MigrationOptions } from './migrate';
+export { type InboxMessage, InboxMessageDao } from './inbox-message-dao';
+export { applyMigrations, type MigrationLogger, type MigrationOptions } from './migrate';
 export {
     type ColRef,
     type ComparisonOp,
@@ -34,5 +35,6 @@ export {
     standardColumns,
     standardColumnsWithSoftDelete,
 } from './schema/common';
+export { inboxMessages } from './schema/inbox-messages';
 export { queueJobs } from './schema/queue-jobs';
 export type { SpanContext } from './span-context';