@hexis-ai/engram-server 0.12.0 → 0.13.0

package/dist/adapters/memory-key-store.d.ts

@@ -13,6 +13,10 @@ export declare class InMemoryKeyStore implements KeyStore {
     }): Promise<Workspace>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/memory-key-store.js

@@ -26,6 +26,18 @@ export class InMemoryKeyStore {
     async listWorkspaces() {
         return [...this.workspaces.values()].sort((a, b) => b.createdAt.localeCompare(a.createdAt));
     }
+    async updateWorkspace(id, patch) {
+        const existing = this.workspaces.get(id);
+        if (!existing)
+            throw new Error("workspace_not_found");
+        const next = {
+            ...existing,
+            ...(patch.name !== undefined ? { name: patch.name } : {}),
+            ...(patch.metadata !== undefined ? { metadata: patch.metadata } : {}),
+        };
+        this.workspaces.set(id, next);
+        return next;
+    }
     async deleteWorkspace(id) {
         this.workspaces.delete(id);
         for (const [keyId, row] of this.keys) {

package/dist/adapters/memory.js

@@ -1,11 +1,5 @@
-import { foldEvents } from "../storage";
-function defaultPersonId() {
-    const ALPHA = "abcdefghijklmnopqrstuvwxyz0123456789";
-    let out = "p_";
-    for (let i = 0; i < 8; i++)
-        out += ALPHA[Math.floor(Math.random() * ALPHA.length)];
-    return out;
-}
+import { foldEvents, newPersonId } from "../storage";
+import { applyPartial } from "./util";
 /**
  * In-process storage adapter for tests, dev, and small single-node deploys.
  * Idempotency: events keyed by (sessionId, seq) — duplicates overwrite by seq.
@@ -19,7 +13,7 @@ export class InMemoryAdapter {
     identities = new Map();
     newPersonId;
     constructor(opts = {}) {
-        this.newPersonId = opts.newPersonId ?? defaultPersonId;
+        this.newPersonId = opts.newPersonId ?? newPersonId;
     }
     // --- Sessions -----------------------------------------------------
     async createSession(init) {
@@ -88,49 +82,12 @@ export class InMemoryAdapter {
         const s = this.sessions.get(sessionId);
         if (!s)
             return null;
-        // Patch semantics: undefined = leave alone; null = clear; value = set.
-        // SessionRow optional fields use `string | undefined`, so a "null"
-        // request collapses to `undefined` storage-side.
-        const next = { ...s.row };
-        if (patch.title !== undefined) {
-            if (patch.title === null)
-                delete next.title;
-            else
-                next.title = patch.title;
-        }
-        if (patch.channel !== undefined) {
-            if (patch.channel === null)
-                delete next.channel;
-            else
-                next.channel = patch.channel;
-        }
-        if (patch.status !== undefined) {
-            next.status = patch.status;
-        }
-        if (patch.summary !== undefined) {
-            if (patch.summary === null)
-                delete next.summary;
-            else
-                next.summary = patch.summary;
-        }
-        if (patch.model !== undefined) {
-            if (patch.model === null)
-                delete next.model;
-            else
-                next.model = patch.model;
-        }
-        if (patch.trigger_conversation_id !== undefined) {
-            if (patch.trigger_conversation_id === null)
-                delete next.trigger_conversation_id;
-            else
-                next.trigger_conversation_id = patch.trigger_conversation_id;
-        }
-        if (patch.trigger_event_id !== undefined) {
-            if (patch.trigger_event_id === null)
-                delete next.trigger_event_id;
-            else
-                next.trigger_event_id = patch.trigger_event_id;
-        }
+        // Patch semantics: undefined = leave alone; null = clear (deletes the
+        // key, matching the SessionRow shape where optional fields are absent);
+        // value = set. `status` clears to "active" to match the column default.
+        const next = applyPartial(s.row, patch, {
+            status: "active",
+        });
         next.updatedAt = new Date().toISOString();
         s.row = next;
         return foldEvents(s.row, [...s.events.values()], new Date());
@@ -213,16 +170,15 @@ export class InMemoryAdapter {
         const existing = this.persons.get(id);
         if (!existing)
             return null;
-        const now = new Date().toISOString();
-        // undefined = no-op, null = clear (per the SDK contract).
-        const next = {
-            ...existing,
-            display_name: patch.display_name !== undefined ? patch.display_name : existing.display_name,
-            role: patch.role !== undefined ? patch.role : existing.role ?? null,
-            team: patch.team !== undefined ? patch.team : existing.team ?? null,
-            source: patch.source !== undefined ? patch.source : existing.source ?? "auto",
-            updated_at: now,
-        };
+        // undefined = no-op; null = clear (display_name/role/team to null,
+        // source to "auto" to match the column default).
+        const next = applyPartial(existing, patch, {
+            display_name: null,
+            role: null,
+            team: null,
+            source: "auto",
+        });
+        next.updated_at = new Date().toISOString();
         this.persons.set(id, next);
         return next;
     }
@@ -269,8 +225,18 @@ export class InMemoryAdapter {
     }
     // --- Aliases ------------------------------------------------------
     async upsertAlias(personId, input) {
-        if (!this.persons.has(personId))
-            return null;
+        if (!this.persons.has(personId)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(personId, {
+                id: personId,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const key = aliasKey(personId, input.name);
         const now = new Date().toISOString();
         const existing = this.aliases.get(key);
@@ -304,8 +270,23 @@ export class InMemoryAdapter {
     }
     // --- Identities ---------------------------------------------------
     async upsertIdentity(ref, input) {
-        if (!this.persons.has(input.person_id))
-            return null;
+        // Auto-create a stub person when missing. The two telemetry
+        // calls (person + identity) race over the network; treating
+        // the identity PUT as authoritative for "this person id exists"
+        // matches the host-supplied-id upsert model and avoids a 404
+        // when the calls arrive out of order.
+        if (!this.persons.has(input.person_id)) {
+            const stubNow = new Date().toISOString();
+            this.persons.set(input.person_id, {
+                id: input.person_id,
+                display_name: null,
+                role: null,
+                team: null,
+                source: undefined,
+                created_at: stubNow,
+                updated_at: stubNow,
+            });
+        }
         const now = new Date().toISOString();
         const existing = this.identities.get(ref);
         // COALESCE-on-conflict for the soft-overlap fields; ref-level

package/dist/adapters/pg-tagged.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+import type { Pool, PoolClient } from "pg";
+import type { SqlClient } from "./postgres";
+export declare function pgSqlClient(executor: Pool | PoolClient): SqlClient;

package/dist/adapters/pg-tagged.js

@@ -0,0 +1,29 @@
+/**
+ * Tagged-template SQL client backed by node-postgres (`pg`).
+ *
+ * The rest of the codebase was written against the `postgres` package's
+ * tagged-template surface (`SqlClient` in ./postgres.ts). This adapter
+ * exposes the same shape on top of a `pg.Pool` (or `pg.PoolClient`) so
+ * we can unify on a single SQL driver — better-auth requires `pg`, and
+ * keeping two pools around just to satisfy `postgres-js`'s template API
+ * was preventing cross-store transactions.
+ *
+ * Translation rule: each `${value}` becomes `$N` in the emitted SQL,
+ * and the values land in the parameter array in tag order. Arrays
+ * map directly to Postgres arrays via `pg`'s native handling (callers
+ * already include explicit `::text[]` casts where needed).
+ */
+export function pgSqlClient(executor) {
+    const tagged = (async (strings, ...values) => {
+        let text = strings[0];
+        for (let i = 0; i < values.length; i++) {
+            text += `$${i + 1}` + strings[i + 1];
+        }
+        const r = await executor.query({ text, values });
+        return r.rows;
+    });
+    tagged.unsafe = async (text) => {
+        await executor.query(text);
+    };
+    return tagged;
+}

package/dist/adapters/postgres-key-store.d.ts

@@ -15,6 +15,10 @@ export declare class PostgresKeyStore implements KeyStore {
     }): Promise<Workspace>;
     getWorkspace(id: string): Promise<Workspace | null>;
     listWorkspaces(): Promise<Workspace[]>;
+    updateWorkspace(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Workspace>;
     deleteWorkspace(id: string): Promise<void>;
     issueKey(workspaceId: string, opts?: {
         name?: string;

package/dist/adapters/postgres-key-store.js

@@ -1,5 +1,6 @@
 import { deriveKey, hashKey, mintKey, resolveWorkspaceId, } from "../key-store";
 import { runMigrations } from "../migrator";
+import { isoString } from "./util";
 export class PostgresKeyStore {
     sql;
     constructor(sql) {
@@ -36,6 +37,19 @@ export class PostgresKeyStore {
     `;
         return rows.map(toWorkspace);
     }
+    async updateWorkspace(id, patch) {
+        const rows = await this.sql `
+      UPDATE engram_workspaces
+      SET
+        name = COALESCE(${patch.name ?? null}, name),
+        metadata = COALESCE(${patch.metadata ? patch.metadata : null}, metadata)
+      WHERE id = ${id}
+      RETURNING id, name, metadata, created_at
+    `;
+        if (rows.length === 0)
+            throw new Error("workspace_not_found");
+        return toWorkspace(rows[0]);
+    }
     async deleteWorkspace(id) {
         // engram_api_keys cascades via FK. engram_sessions/events are explicit
         // since they predate the workspaces table and have no FK to it.
@@ -132,6 +146,3 @@ function toInfo(r) {
         ...(r.revoked_at !== null ? { revokedAt: isoString(r.revoked_at) } : {}),
     };
 }
-function isoString(v) {
-    return typeof v === "string" ? v : v.toISOString();
-}

package/dist/adapters/postgres-org-store.d.ts

@@ -10,6 +10,10 @@ export declare class PostgresOrgStore implements OrgStore {
     }): Promise<OrgRow>;
     getOrg(id: string): Promise<OrgRow | null>;
     listOrgs(): Promise<OrgRow[]>;
+    updateOrg(id: string, patch: {
+        name?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<OrgRow>;
     deleteOrg(id: string): Promise<void>;
     listMembers(orgId: string): Promise<OrgMembershipRow[]>;
     upsertMember(input: {
@@ -34,4 +38,5 @@ export declare class PostgresOrgStore implements OrgStore {
         orgId: string;
     }[]>;
     userCanAccessWorkspace(userId: string, workspaceId: string): Promise<boolean>;
+    workspaceInOrg(orgId: string, workspaceId: string): Promise<boolean>;
 }

package/dist/adapters/postgres-org-store.js

@@ -1,13 +1,11 @@
 import { randomUUID } from "node:crypto";
-function iso(v) {
-    return typeof v === "string" ? v : v.toISOString();
-}
+import { isoString } from "./util";
 function toOrg(r) {
     return {
         id: r.id,
         name: r.name,
         metadata: r.metadata ?? {},
-        createdAt: iso(r.created_at),
+        createdAt: isoString(r.created_at),
     };
 }
 function toMember(r) {
@@ -15,7 +13,7 @@ function toMember(r) {
         orgId: r.org_id,
         userId: r.user_id,
         role: r.role,
-        joinedAt: iso(r.joined_at),
+        joinedAt: isoString(r.joined_at),
     };
 }
 export class PostgresOrgStore {
@@ -45,6 +43,21 @@ export class PostgresOrgStore {
         const { rows } = await this.pool.query(`SELECT id, name, metadata, created_at FROM engram_orgs ORDER BY created_at`);
         return rows.map(toOrg);
     }
+    async updateOrg(id, patch) {
+        const { rows } = await this.pool.query(`UPDATE engram_orgs
+       SET
+         name = COALESCE($2, name),
+         metadata = COALESCE($3::jsonb, metadata)
+       WHERE id = $1
+       RETURNING id, name, metadata, created_at`, [
+            id,
+            patch.name ?? null,
+            patch.metadata ? JSON.stringify(patch.metadata) : null,
+        ]);
+        if (rows.length === 0)
+            throw new Error("org_not_found");
+        return toOrg(rows[0]);
+    }
     async deleteOrg(id) {
         // CASCADE drops members + workspaces under this org.
         await this.pool.query(`DELETE FROM engram_orgs WHERE id = $1`, [id]);
@@ -99,4 +112,9 @@ export class PostgresOrgStore {
        LIMIT 1`, [userId, workspaceId]);
         return rows.length > 0;
     }
+    async workspaceInOrg(orgId, workspaceId) {
+        const { rows } = await this.pool.query(`SELECT 1 AS ok FROM engram_workspaces
+       WHERE id = $1 AND org_id = $2 LIMIT 1`, [workspaceId, orgId]);
+        return rows.length > 0;
+    }
 }

package/dist/adapters/postgres.js

@@ -1,19 +1,6 @@
 import { runMigrations } from "../migrator";
-import { foldEvents } from "../storage";
-/**
- * 10-char alphanumeric id, e.g. `p_a8b3c2d4`. Cryptographic randomness via
- * the platform's getRandomValues; collision probability negligible for any
- * realistic person count.
- */
-function defaultPersonId() {
-    const ALPHA = "abcdefghijklmnopqrstuvwxyz0123456789";
-    const buf = new Uint8Array(8);
-    crypto.getRandomValues(buf);
-    let out = "p_";
-    for (const b of buf)
-        out += ALPHA[b % ALPHA.length];
-    return out;
-}
+import { foldEvents, newPersonId } from "../storage";
+import { isoString, pickPatch } from "./util";
 export class PostgresAdapter {
     workspaceId;
     sql;
@@ -21,7 +8,7 @@ export class PostgresAdapter {
     constructor(opts) {
         this.workspaceId = opts.workspaceId;
         this.sql = opts.sql;
-        this.newPersonId = opts.newPersonId ?? defaultPersonId;
+        this.newPersonId = opts.newPersonId ?? newPersonId;
     }
     /**
      * Apply all pending schema migrations. Safe to call repeatedly and
@@ -125,29 +112,27 @@ export class PostgresAdapter {
         return foldEvents(toSessionRow(rows[0]), events.map((e) => e.payload), new Date());
     }
     async updateSession(sessionId, patch) {
-        // Translate JS undefined → "no change" via a per-column "provided"
-        // flag the SQL evaluates with CASE WHEN. null in patch becomes a
-        // real null in the DB (clear), value becomes a set.
-        const titleProvided = patch.title !== undefined;
-        const channelProvided = patch.channel !== undefined;
-        const statusProvided = patch.status !== undefined;
-        const summaryProvided = patch.summary !== undefined;
-        const modelProvided = patch.model !== undefined;
-        const tcIdProvided = patch.trigger_conversation_id !== undefined;
-        const teIdProvided = patch.trigger_event_id !== undefined;
+        // Per-column "provided" flags drive a CASE WHEN per field: undefined
+        // leaves the column alone, null clears, value sets. `status` defaults
+        // to "active" on clear to match the column default.
+        const title = pickPatch(patch, "title");
+        const channel = pickPatch(patch, "channel");
+        const status = pickPatch(patch, "status", "active");
+        const summary = pickPatch(patch, "summary");
+        const model = pickPatch(patch, "model");
+        const tcId = pickPatch(patch, "trigger_conversation_id");
+        const teId = pickPatch(patch, "trigger_event_id");
         const rows = await this.sql `
       UPDATE engram_sessions SET
-        title    = CASE WHEN ${titleProvided}    THEN ${patch.title ?? null}    ELSE title    END,
-        channel  = CASE WHEN ${channelProvided}  THEN ${patch.channel ?? null}  ELSE channel  END,
-        status   = CASE WHEN ${statusProvided}   THEN ${patch.status ?? "active"} ELSE status END,
-        summary  = CASE WHEN ${summaryProvided}  THEN ${patch.summary ?? null}  ELSE summary  END,
-        model    = CASE WHEN ${modelProvided}    THEN ${patch.model ?? null}    ELSE model    END,
-        trigger_conversation_id = CASE WHEN ${tcIdProvided}
-          THEN ${patch.trigger_conversation_id ?? null}
-          ELSE trigger_conversation_id END,
-        trigger_event_id = CASE WHEN ${teIdProvided}
-          THEN ${patch.trigger_event_id ?? null}
-          ELSE trigger_event_id END,
+        title    = CASE WHEN ${title.provided}   THEN ${title.value}   ELSE title   END,
+        channel  = CASE WHEN ${channel.provided} THEN ${channel.value} ELSE channel END,
+        status   = CASE WHEN ${status.provided}  THEN ${status.value}  ELSE status  END,
+        summary  = CASE WHEN ${summary.provided} THEN ${summary.value} ELSE summary END,
+        model    = CASE WHEN ${model.provided}   THEN ${model.value}   ELSE model   END,
+        trigger_conversation_id = CASE WHEN ${tcId.provided}
+          THEN ${tcId.value} ELSE trigger_conversation_id END,
+        trigger_event_id = CASE WHEN ${teId.provided}
+          THEN ${teId.value} ELSE trigger_event_id END,
         updated_at = now()
       WHERE workspace_id = ${this.workspaceId} AND id = ${sessionId}
       RETURNING id
@@ -246,17 +231,18 @@ export class PostgresAdapter {
         return toPersonInfo(rows[0]);
     }
     async updatePerson(id, patch) {
-        // Treat `null` as an explicit clear; `undefined` as no-op.
-        const nameProvided = patch.display_name !== undefined;
-        const roleProvided = patch.role !== undefined;
-        const teamProvided = patch.team !== undefined;
-        const sourceProvided = patch.source !== undefined;
+        // undefined = no-op, null = clear (source clears to "auto" to match
+        // the column default).
+        const name = pickPatch(patch, "display_name");
+        const role = pickPatch(patch, "role");
+        const team = pickPatch(patch, "team");
+        const source = pickPatch(patch, "source", "auto");
         const rows = await this.sql `
       UPDATE engram_persons SET
-        display_name = CASE WHEN ${nameProvided}   THEN ${patch.display_name ?? null} ELSE display_name END,
-        role         = CASE WHEN ${roleProvided}   THEN ${patch.role ?? null}         ELSE role         END,
-        team         = CASE WHEN ${teamProvided}   THEN ${patch.team ?? null}         ELSE team         END,
-        source       = CASE WHEN ${sourceProvided} THEN ${patch.source ?? "auto"}     ELSE source       END,
+        display_name = CASE WHEN ${name.provided}   THEN ${name.value}   ELSE display_name END,
+        role         = CASE WHEN ${role.provided}   THEN ${role.value}   ELSE role         END,
+        team         = CASE WHEN ${team.provided}   THEN ${team.value}   ELSE team         END,
+        source       = CASE WHEN ${source.provided} THEN ${source.value} ELSE source       END,
         updated_at   = now()
       WHERE workspace_id = ${this.workspaceId} AND id = ${id}
       RETURNING id, display_name, role, team, source, created_at, updated_at
@@ -326,15 +312,13 @@ export class PostgresAdapter {
     }
     // --- Aliases ------------------------------------------------------
     async upsertAlias(personId, input) {
-        // Pre-check rather than rely on the FK so unknown persons return
-        // `null` instead of throwing a constraint violation.
-        const personExists = await this.sql `
-      SELECT id FROM engram_persons
-      WHERE workspace_id = ${this.workspaceId} AND id = ${personId}
-      LIMIT 1
+        // Same race as upsertIdentity — alias telemetry can land before
+        // the matching person telemetry. Auto-create a stub person.
+        await this.sql `
+      INSERT INTO engram_persons (workspace_id, id)
+      VALUES (${this.workspaceId}, ${personId})
+      ON CONFLICT (workspace_id, id) DO NOTHING
     `;
-        if (personExists.length === 0)
-            return null;
         const increment = input.increment ?? true;
         // Branch on the upsert behaviour. `increment=true` bumps usage_count
         // and replaces caller/last_used; `increment=false` is idempotent —
@@ -390,15 +374,15 @@ export class PostgresAdapter {
     }
     // --- Identities ---------------------------------------------------
     async upsertIdentity(ref, input) {
-        // Pre-check rather than rely on the FK so unknown persons return
-        // `null` instead of throwing a constraint violation.
-        const personExists = await this.sql `
-      SELECT id FROM engram_persons
-      WHERE workspace_id = ${this.workspaceId} AND id = ${input.person_id}
-      LIMIT 1
+        // Auto-create a stub person if missing. The two telemetry calls
+        // (person + identity) leave monet fire-and-forget and race over
+        // the network, so it's normal for the identity PUT to land first.
+        // Empty stub gets enriched by the trailing person PUT.
+        await this.sql `
+      INSERT INTO engram_persons (workspace_id, id)
+      VALUES (${this.workspaceId}, ${input.person_id})
+      ON CONFLICT (workspace_id, id) DO NOTHING
     `;
-        if (personExists.length === 0)
-            return null;
         // unlinked_at semantics: undefined = leave alone, null = clear,
         // value = set. matches the patch contract for the other fields.
         const unlinkedProvided = input.unlinked_at !== undefined;
@@ -460,27 +444,25 @@ export class PostgresAdapter {
     }
 }
 function toPersonInfo(r) {
-    const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
     return {
         id: r.id,
         display_name: r.display_name,
         role: r.role,
         team: r.team,
         source: r.source,
-        created_at: toIso(r.created_at),
-        updated_at: toIso(r.updated_at),
+        created_at: isoString(r.created_at),
+        updated_at: isoString(r.updated_at),
     };
 }
 function toSessionRow(r) {
-    const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
     return {
         id: r.id,
         ...(r.title ? { title: r.title } : {}),
         ...(r.channel ? { channel: r.channel } : {}),
         participants: r.participants,
         viewable_by: r.viewable_by,
-        createdAt: toIso(r.created_at),
-        updatedAt: toIso(r.updated_at),
+        createdAt: isoString(r.created_at),
+        updatedAt: isoString(r.updated_at),
         ...(r.status === "active" || r.status === "idle" || r.status === "completed"
             ? { status: r.status }
             : {}),
@@ -495,24 +477,19 @@ function toSessionRow(r) {
     };
 }
 function toAliasInfo(r) {
-    const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
     // last_used is a DATE column; postgres-js returns it as a Date at UTC
     // midnight. Render as plain YYYY-MM-DD to match the wire type.
-    const lastUsed = typeof r.last_used === "string"
-        ? r.last_used.slice(0, 10)
-        : r.last_used.toISOString().slice(0, 10);
     return {
         person_id: r.person_id,
         name: r.name,
         caller: r.caller,
         usage_count: r.usage_count,
-        last_used: lastUsed,
-        created_at: toIso(r.created_at),
-        updated_at: toIso(r.updated_at),
+        last_used: isoString(r.last_used).slice(0, 10),
+        created_at: isoString(r.created_at),
+        updated_at: isoString(r.updated_at),
     };
 }
 function toIdentityInfo(r) {
-    const toIso = (v) => (typeof v === "string" ? v : v.toISOString());
     // linked_at is now TIMESTAMPTZ (post-migration 0004). Emit full ISO.
     return {
         ref: r.ref,
@@ -523,9 +500,9 @@ function toIdentityInfo(r) {
         source: r.source,
         is_primary: r.is_primary,
         picture: r.picture,
-        linked_at: toIso(r.linked_at),
-        unlinked_at: r.unlinked_at === null ? null : toIso(r.unlinked_at),
-        created_at: toIso(r.created_at),
-        updated_at: toIso(r.updated_at),
+        linked_at: isoString(r.linked_at),
+        unlinked_at: r.unlinked_at === null ? null : isoString(r.unlinked_at),
+        created_at: isoString(r.created_at),
+        updated_at: isoString(r.updated_at),
     };
 }

package/dist/adapters/util.d.ts

@@ -0,0 +1,27 @@
+/** Postgres drivers return timestamp columns as either string or Date depending
+ *  on the type parser. Normalise to ISO-8601 string for the wire format. */
+export declare function isoString(v: string | Date): string;
+/**
+ * Apply a partial patch with the SDK's three-state semantics:
+ *   - `undefined` → keep `existing[key]`
+ *   - `null`      → clear (set to `clearTo`, default `null`)
+ *   - value       → set
+ *
+ * Used by the in-memory adapter to mirror the postgres adapter's
+ * per-column CASE WHEN behaviour without hand-writing the if/else
+ * tree for every field. Returns a new object — never mutates.
+ */
+export declare function applyPartial<E, P>(existing: E, patch: P, 
+/** Default value when a key is explicitly cleared (`null` in the patch). */
+clearTo?: Partial<{
+    [K in keyof P]: unknown;
+}>): E;
+/**
+ * Per-field patch helper for postgres CASE WHEN. Returns the
+ * `{provided, value}` tuple the SQL template uses; `clearTo` plugs in
+ * when the patch explicitly cleared the field with `null`.
+ */
+export declare function pickPatch<P, K extends keyof P>(patch: P, key: K, clearTo?: NonNullable<P[K]> | null): {
+    provided: boolean;
+    value: NonNullable<P[K]> | null;
+};

package/dist/adapters/util.js

@@ -0,0 +1,47 @@
+/** Postgres drivers return timestamp columns as either string or Date depending
+ *  on the type parser. Normalise to ISO-8601 string for the wire format. */
+export function isoString(v) {
+    return typeof v === "string" ? v : v.toISOString();
+}
+/**
+ * Apply a partial patch with the SDK's three-state semantics:
+ *   - `undefined` → keep `existing[key]`
+ *   - `null`      → clear (set to `clearTo`, default `null`)
+ *   - value       → set
+ *
+ * Used by the in-memory adapter to mirror the postgres adapter's
+ * per-column CASE WHEN behaviour without hand-writing the if/else
+ * tree for every field. Returns a new object — never mutates.
+ */
+export function applyPartial(existing, patch, 
+/** Default value when a key is explicitly cleared (`null` in the patch). */
+clearTo = {}) {
+    const next = { ...existing };
+    for (const key of Object.keys(patch)) {
+        const value = patch[key];
+        if (value === undefined)
+            continue;
+        if (value === null) {
+            const fallback = clearTo[key];
+            if (fallback === undefined)
+                delete next[key];
+            else
+                next[key] = fallback;
+        }
+        else {
+            next[key] = value;
+        }
+    }
+    return next;
+}
+/**
+ * Per-field patch helper for postgres CASE WHEN. Returns the
+ * `{provided, value}` tuple the SQL template uses; `clearTo` plugs in
+ * when the patch explicitly cleared the field with `null`.
+ */
+export function pickPatch(patch, key, clearTo = null) {
+    const provided = patch[key] !== undefined;
+    const raw = patch[key];
+    const value = raw == null ? clearTo : raw;
+    return { provided, value };
+}