@agent-native/core 0.77.6 → 0.77.8

package/corpus/core/src/client/use-chat-threads.ts

@@ -74,6 +74,7 @@ export interface UseChatThreadsOptions {
 
 const ACTIVE_THREAD_KEY = "agent-chat-active-thread";
 const THREADS_UPDATED_EVENT = "agent-chat:threads-updated";
+const THREADS_PAGE_SIZE = 50;
 
 function emitThreadsUpdated() {
   if (typeof window === "undefined") return;
@@ -215,6 +216,10 @@ export function useChatThreads(
   }
 
   const [threads, setThreads] = useState<ChatThreadSummary[]>([]);
+  const [hasMoreThreads, setHasMoreThreads] = useState(false);
+  const [isLoadingMoreThreads, setIsLoadingMoreThreads] = useState(false);
+  const [threadsLoadError, setThreadsLoadError] = useState<string | null>(null);
+  const nextThreadsOffsetRef = useRef(0);
   const threadsRef = useRef<ChatThreadSummary[]>(threads);
   threadsRef.current = threads;
 
@@ -414,66 +419,106 @@ export function useChatThreads(
     threads,
   ]);
 
-  const fetchThreads = useCallback(async () => {
-    try {
-      const res = await fetch(`${apiUrl}/threads`);
-      if (!res.ok) return;
-      const data = await res.json();
-      setThreads((prev) => {
-        const loaded = (data.threads ?? []) as ChatThreadSummary[];
-        const loadedIds = new Set(loaded.map((t) => t.id));
-        // Preserve any optimistic threads we've created this session that
-        // haven't shown up in the server list yet — the server only learns
-        // about a thread when the user actually sends a message and the
-        // agent run's `persistSubmittedUserMessage` writes the row.
-        const optimisticOnly = prev.filter(
-          (t) => newlyCreatedRef.current.has(t.id) && !loadedIds.has(t.id),
+  const fetchThreads = useCallback(
+    async (options?: { append?: boolean }) => {
+      try {
+        const offset = options?.append ? nextThreadsOffsetRef.current : 0;
+        const res = await fetch(
+          offset > 0
+            ? `${apiUrl}/threads?offset=${offset}`
+            : `${apiUrl}/threads`,
         );
-        // Reconcile each server thread against our local copy. If the local
-        // copy has a newer updatedAt or higher messageCount, keep those
-        // fields — the server probably hasn't observed the user's latest
-        // send yet, and naively replacing makes the recent-chats list
-        // visibly jump back to older timestamps right after a send.
-        const merged = loaded.map((server) => {
-          const local = prev.find((t) => t.id === server.id);
-          if (!local) return server;
-          const next = { ...server };
-          if (local.updatedAt > server.updatedAt) {
-            next.updatedAt = local.updatedAt;
-          }
-          if (userRenamedThreadIdsRef.current.has(server.id) && local.title) {
-            next.title = local.title;
-          }
-          if (pendingPinnedAtRef.current.has(server.id)) {
-            next.pinnedAt = pendingPinnedAtRef.current.get(server.id) ?? null;
-          }
-          if (pendingArchivedAtRef.current.has(server.id)) {
-            next.archivedAt =
-              pendingArchivedAtRef.current.get(server.id) ?? null;
-          }
-          if (local.messageCount > server.messageCount) {
-            next.messageCount = local.messageCount;
-            if (local.preview) next.preview = local.preview;
-            if (local.title) next.title = local.title;
+        if (!res.ok) {
+          if (!options?.append) {
+            setThreadsLoadError("Could not load chat history.");
           }
-          // Preserve optimistic scope: when the server creates the row
-          // on first message it does so without scope, and the next PUT
-          // (saveThreadData) writes the local scope back. In the brief
-          // window between those, the server list returns scope: null
-          // while the user is clearly working inside a deck — keep the
-          // local value so the tab bar doesn't blink unscoped.
-          if (local.scope && !server.scope) {
-            next.scope = local.scope;
+          return;
+        }
+        const data = await res.json();
+        setThreadsLoadError(null);
+        const loaded = (data.threads ?? []) as ChatThreadSummary[];
+        if (!options?.append) {
+          nextThreadsOffsetRef.current = loaded.length;
+        } else {
+          nextThreadsOffsetRef.current += loaded.length;
+        }
+        setHasMoreThreads(loaded.length >= THREADS_PAGE_SIZE);
+        setThreads((prev) => {
+          const loadedIds = new Set(loaded.map((t) => t.id));
+          // Preserve any optimistic threads we've created this session that
+          // haven't shown up in the server list yet — the server only learns
+          // about a thread when the user actually sends a message and the
+          // agent run's `persistSubmittedUserMessage` writes the row.
+          const optimisticOnly = prev.filter(
+            (t) => newlyCreatedRef.current.has(t.id) && !loadedIds.has(t.id),
+          );
+          // Reconcile each server thread against our local copy. If the local
+          // copy has a newer updatedAt or higher messageCount, keep those
+          // fields — the server probably hasn't observed the user's latest
+          // send yet, and naively replacing makes the recent-chats list
+          // visibly jump back to older timestamps right after a send.
+          const merged = loaded.map((server) => {
+            const local = prev.find((t) => t.id === server.id);
+            if (!local) return server;
+            const next = { ...server };
+            if (local.updatedAt > server.updatedAt) {
+              next.updatedAt = local.updatedAt;
+            }
+            if (userRenamedThreadIdsRef.current.has(server.id) && local.title) {
+              next.title = local.title;
+            }
+            if (pendingPinnedAtRef.current.has(server.id)) {
+              next.pinnedAt = pendingPinnedAtRef.current.get(server.id) ?? null;
+            }
+            if (pendingArchivedAtRef.current.has(server.id)) {
+              next.archivedAt =
+                pendingArchivedAtRef.current.get(server.id) ?? null;
+            }
+            if (local.messageCount > server.messageCount) {
+              next.messageCount = local.messageCount;
+              if (local.preview) next.preview = local.preview;
+              if (local.title) next.title = local.title;
+            }
+            // Preserve optimistic scope: when the server creates the row
+            // on first message it does so without scope, and the next PUT
+            // (saveThreadData) writes the local scope back. In the brief
+            // window between those, the server list returns scope: null
+            // while the user is clearly working inside a deck — keep the
+            // local value so the tab bar doesn't blink unscoped.
+            if (local.scope && !server.scope) {
+              next.scope = local.scope;
+            }
+            return next;
+          });
+          if (options?.append) {
+            const existingIds = new Set(prev.map((t) => t.id));
+            return sortThreadSummaries([
+              ...prev,
+              ...merged.filter((t) => !existingIds.has(t.id)),
+            ]);
           }
-          return next;
+          return [...optimisticOnly, ...merged];
         });
-        return [...optimisticOnly, ...merged];
-      });
-      return data.threads as ChatThreadSummary[];
-    } catch {
-      return undefined;
+        return data.threads as ChatThreadSummary[];
+      } catch {
+        if (!options?.append) {
+          setThreadsLoadError("Could not load chat history.");
+        }
+        return undefined;
+      }
+    },
+    [apiUrl],
+  );
+
+  const loadMoreThreads = useCallback(async (): Promise<void> => {
+    if (isLoadingMoreThreads || !hasMoreThreads) return;
+    setIsLoadingMoreThreads(true);
+    try {
+      await fetchThreads({ append: true });
+    } finally {
+      setIsLoadingMoreThreads(false);
     }
-  }, [apiUrl]);
+  }, [fetchThreads, hasMoreThreads, isLoadingMoreThreads]);
 
   // Initial load: load threads from server, then reconcile against the
   // saved active thread.
@@ -1158,10 +1203,14 @@ export function useChatThreads(
     saveThreadData,
     generateTitle,
     searchThreads,
+    loadMoreThreads,
     getThreadShareState,
     createThreadShareLink,
     revokeThreadShareLink,
     refreshThreads,
+    hasMoreThreads,
+    isLoadingMoreThreads,
+    threadsLoadError,
     isNewThread,
   };
 }

package/corpus/core/src/db/ddl-guard.ts

@@ -0,0 +1,190 @@
+/**
+ * Guards for on-demand `ensureTable()` DDL so the common already-migrated path
+ * takes NO `ACCESS EXCLUSIVE` lock on Postgres.
+ *
+ * Lives in its own module (like `./widen-columns.js`) so stores can import it
+ * without every `vi.mock("../db/client.js")` test needing to stub it: the
+ * helpers resolve `isPostgres()` / `getDbExec()` through `client.js`, so a test
+ * that mocks the client to SQLite (`isPostgres: () => false`) makes the
+ * Postgres-only existence checks no-ops automatically.
+ *
+ * ## Why
+ *
+ * `ensureTable()` runs once per process on first DB touch. In a long-lived Node
+ * server the cost is paid once and is invisible. In a Netlify `-background`
+ * function the process is fresh, so this is the FIRST touch — and the
+ * `CREATE TABLE`/`ALTER TABLE ... ADD COLUMN` DDL it issues takes an
+ * `ACCESS EXCLUSIVE` lock on the shared Neon Postgres database. Behind a
+ * concurrent connection that already holds a conflicting lock, that DDL can
+ * block ~indefinitely (observed >16s hangs in the bg worker vs ~1s inline).
+ *
+ * The tables/columns are essentially always already present in production, so
+ * the DDL is redundant in the hot path. These helpers let a store cheaply check
+ * `information_schema` first and only issue DDL when something is actually
+ * missing — and when DDL must run, wrap it in a short `lock_timeout` so a
+ * contended lock fails fast instead of hanging.
+ *
+ * All of this is Postgres-only behaviour gated on `isPostgres()`. On SQLite
+ * (local dev) there is no such lock problem, so callers keep their existing
+ * behaviour there.
+ */
+
+import { isPostgres, getDbExec, type DbExec } from "./client.js";
+
+const PLAIN_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+/**
+ * True when running against Postgres AND the given table already exists in the
+ * `public` schema. Returns `false` on SQLite (callers gate their own behaviour
+ * there), for invalid identifiers, or when `information_schema` is unreadable —
+ * the conservative answer "not known to exist" makes the caller fall through to
+ * its idempotent `CREATE TABLE IF NOT EXISTS`, preserving today's behaviour.
+ *
+ * This is a plain read (no lock), so it never blocks on an `ACCESS EXCLUSIVE`
+ * lock the way `CREATE`/`ALTER` would.
+ */
+export async function pgTableExists(
+  table: string,
+  injectedClient?: DbExec,
+): Promise<boolean> {
+  if (!isPostgres() || !PLAIN_IDENTIFIER.test(table)) return false;
+  const client = injectedClient ?? getDbExec();
+  try {
+    const { rows } = await client.execute({
+      sql: `SELECT 1 FROM information_schema.tables
+            WHERE table_schema = 'public' AND table_name = ? LIMIT 1`,
+      args: [table],
+    });
+    return rows.length > 0;
+  } catch {
+    // information_schema unreadable (permissions / non-standard backend) —
+    // report "unknown" so the caller falls back to IF NOT EXISTS.
+    return false;
+  }
+}
+
+/**
+ * True when running against Postgres AND the given column already exists on the
+ * given table in the `public` schema. Returns `false` on SQLite, for invalid
+ * identifiers, or when `information_schema` is unreadable.
+ *
+ * Plain read — no lock taken.
+ */
+export async function pgColumnExists(
+  table: string,
+  column: string,
+  injectedClient?: DbExec,
+): Promise<boolean> {
+  if (!isPostgres()) return false;
+  if (!PLAIN_IDENTIFIER.test(table) || !PLAIN_IDENTIFIER.test(column)) {
+    return false;
+  }
+  const client = injectedClient ?? getDbExec();
+  try {
+    const { rows } = await client.execute({
+      sql: `SELECT 1 FROM information_schema.columns
+            WHERE table_schema = 'public' AND table_name = ? AND column_name = ?
+            LIMIT 1`,
+      args: [table, column],
+    });
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * True when running against Postgres AND an index with the given name already
+ * exists in the `public` schema. Returns `false` on SQLite, for invalid
+ * identifiers, or when `pg_indexes` is unreadable.
+ *
+ * `CREATE INDEX` (without CONCURRENTLY) takes a `SHARE` lock that blocks
+ * writes, so on a fresh background-worker process behind a concurrent
+ * connection this can hang just like a `CREATE`/`ALTER` would; checking first
+ * skips the lock on the already-migrated hot path.
+ */
+export async function pgIndexExists(
+  indexName: string,
+  injectedClient?: DbExec,
+): Promise<boolean> {
+  if (!isPostgres() || !PLAIN_IDENTIFIER.test(indexName)) return false;
+  const client = injectedClient ?? getDbExec();
+  try {
+    const { rows } = await client.execute({
+      sql: `SELECT 1 FROM pg_indexes
+            WHERE schemaname = 'public' AND indexname = ? LIMIT 1`,
+      args: [indexName],
+    });
+    return rows.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+/** True when an error looks like a Postgres `lock_timeout` (SQLSTATE 55P03). */
+export function isLockTimeoutError(err: unknown): boolean {
+  const anyErr = err as { code?: unknown; message?: unknown } | null;
+  if (anyErr?.code === "55P03") return true;
+  const msg = String(anyErr?.message ?? anyErr ?? "");
+  return /lock[_ ]?timeout|canceling statement due to lock timeout/i.test(msg);
+}
+
+/**
+ * Run a DDL statement that MUST execute (the schema is actually missing), with
+ * a short `lock_timeout` so a contended `ACCESS EXCLUSIVE` lock fails fast
+ * instead of hanging the whole process.
+ *
+ * Postgres path: wrap the DDL in an explicit transaction and set
+ * `SET LOCAL lock_timeout` so the timeout is scoped to THIS transaction only
+ * and reset automatically on COMMIT/ROLLBACK — it never leaks onto the pooled
+ * (session-reused) connection the way a bare `SET lock_timeout` would. If the
+ * DbExec has no `transaction` (shouldn't happen for Postgres, but defensively),
+ * fall back to a session `SET` + `RESET` in a finally. A lock-timeout error is
+ * swallowed: the table/column is virtually always already correct by the time a
+ * contended boot retries, and the caller's memoization should still resolve so
+ * the path isn't retried in a tight loop. Any non-lock-timeout error rethrows.
+ *
+ * SQLite path: no lock problem — just run the DDL directly.
+ *
+ * @returns `true` if the DDL ran to completion, `false` if it was skipped due to
+ *          a lock-timeout (so the caller can decide whether to log).
+ */
+export async function runGuardedDdl(
+  ddl: string,
+  options: { lockTimeout?: string; injectedClient?: DbExec } = {},
+): Promise<boolean> {
+  const client = options.injectedClient ?? getDbExec();
+  if (!isPostgres()) {
+    await client.execute(ddl);
+    return true;
+  }
+
+  const lockTimeout = options.lockTimeout ?? "3s";
+  try {
+    if (typeof client.transaction === "function") {
+      await client.transaction(async (tx) => {
+        // SET LOCAL is transaction-scoped: it reverts on COMMIT/ROLLBACK and
+        // never persists on the pooled connection.
+        await tx.execute(`SET LOCAL lock_timeout = '${lockTimeout}'`);
+        await tx.execute(ddl);
+      });
+    } else {
+      // Defensive fallback: no transaction support. Use a session SET and
+      // guarantee a RESET so the timeout never leaks onto a reused connection.
+      try {
+        await client.execute(`SET lock_timeout = '${lockTimeout}'`);
+        await client.execute(ddl);
+      } finally {
+        await client.execute(`RESET lock_timeout`).catch(() => {});
+      }
+    }
+    return true;
+  } catch (err) {
+    if (isLockTimeoutError(err)) {
+      // Contended lock — the schema is virtually always already correct by now.
+      // Proceed; the caller's memoization still resolves so we don't loop.
+      return false;
+    }
+    throw err;
+  }
+}

package/corpus/core/src/secrets/storage.ts

@@ -15,6 +15,11 @@
 import { randomUUID } from "node:crypto";
 
 import { getDbExec, isPostgres } from "../db/client.js";
+import {
+  pgColumnExists,
+  pgTableExists,
+  runGuardedDdl,
+} from "../db/ddl-guard.js";
 import {
   encryptSecretValue as encryptValue,
   decryptSecretValue as decryptValue,
@@ -34,10 +39,39 @@ async function ensureTable(): Promise<void> {
       const client = getDbExec();
       // Postgres version of the CREATE TABLE — the generic `INTEGER` maps to
       // BIGINT on Postgres, which we need for millisecond timestamps.
-      const sql = isPostgres()
+      const createSql = isPostgres()
         ? APP_SECRETS_CREATE_SQL.replace(/\bINTEGER\b/g, "BIGINT")
         : APP_SECRETS_CREATE_SQL;
-      await client.execute(sql);
+
+      if (isPostgres()) {
+        // Hot path: in production the table and both additive columns are
+        // virtually always already present. Issuing `CREATE`/`ALTER` would
+        // still take an ACCESS EXCLUSIVE lock — which, in a fresh background
+        // worker process behind a concurrent connection on the shared Neon DB,
+        // can block ~indefinitely. So check `information_schema` first (a plain
+        // read, no lock) and run DDL ONLY for what is actually missing. When
+        // DDL must run, `runGuardedDdl` wraps it in a transaction-scoped
+        // `lock_timeout` so a contended lock fails fast instead of hanging.
+        if (!(await pgTableExists("app_secrets"))) {
+          await runGuardedDdl(createSql);
+        }
+        if (!(await pgColumnExists("app_secrets", "description"))) {
+          await runGuardedDdl(
+            `ALTER TABLE app_secrets ADD COLUMN IF NOT EXISTS description TEXT`,
+          );
+        }
+        if (!(await pgColumnExists("app_secrets", "url_allowlist"))) {
+          await runGuardedDdl(
+            `ALTER TABLE app_secrets ADD COLUMN IF NOT EXISTS url_allowlist TEXT`,
+          );
+        }
+        return;
+      }
+
+      // SQLite (local dev): no ACCESS EXCLUSIVE lock problem, keep the original
+      // create-then-additive-alter behaviour. SQLite has no
+      // `ADD COLUMN IF NOT EXISTS`, so the ALTERs stay wrapped in try/catch.
+      await client.execute(createSql);
 
       // Additive migration: description column (for ad-hoc keys)
       try {

package/corpus/core/src/server/analytics.ts

@@ -3,6 +3,10 @@
  * Supported environment variables:
  * - `GA_MEASUREMENT_ID` — Google Analytics 4 measurement ID
  *
+ * Netlify configuration-file env vars are build-time only for serverless
+ * functions, so the Vite plugin also bakes this public value into SSR bundles
+ * as `__AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__`.
+ *
  * Amplitude and Sentry are initialized client-side via their npm packages
  * (see `packages/core/src/client/analytics.ts`). Only GA requires script
  * tag injection because the gtag.js loader must be a `<script src>`.
@@ -17,16 +21,36 @@
  * ```
  */
 
+declare const __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__: string | undefined;
+
+function normalizeMeasurementId(value: string | undefined): string | null {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+
+function getGaMeasurementId(): string | null {
+  return (
+    normalizeMeasurementId(process.env.GA_MEASUREMENT_ID) ||
+    normalizeMeasurementId(
+      typeof __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__ === "string"
+        ? __AGENT_NATIVE_BUILD_GA_MEASUREMENT_ID__
+        : undefined,
+    )
+  );
+}
+
 function getGaScript(): string | null {
-  const id = process.env.GA_MEASUREMENT_ID;
+  const id = getGaMeasurementId();
   if (!id) return null;
+  const srcId = encodeURIComponent(id);
+  const jsId = JSON.stringify(id);
   return (
-    `<script async src="https://www.googletagmanager.com/gtag/js?id=${id}"></script>` +
+    `<script async src="https://www.googletagmanager.com/gtag/js?id=${srcId}"></script>` +
     `<script>` +
     `window.dataLayer=window.dataLayer||[];` +
     `function gtag(){dataLayer.push(arguments);}` +
     `gtag('js',new Date());` +
-    `gtag('config','${id}');` +
+    `gtag('config',${jsId});` +
     `if(typeof sessionStorage!=='undefined'&&sessionStorage.getItem('__an_signin')){` +
     `sessionStorage.removeItem('__an_signin');` +
     `gtag('event','sign_in');` +

package/corpus/core/src/settings/store.ts

@@ -1,6 +1,11 @@
 import { EventEmitter } from "events";
 
 import { getDbExec, isPostgres, intType } from "../db/client.js";
+import {
+  pgIndexExists,
+  pgTableExists,
+  runGuardedDdl,
+} from "../db/ddl-guard.js";
 import { widenIntColumnsToBigInt } from "../db/widen-columns.js";
 
 let _initPromise: Promise<void> | undefined;
@@ -20,17 +25,46 @@ async function ensureTable(): Promise<void> {
     _initPromise = (async () => {
       const client = getDbExec();
       const table = settingsTable();
-      await client.execute(`
+      const createSql = `
         CREATE TABLE IF NOT EXISTS ${table} (
           key TEXT PRIMARY KEY,
           value TEXT NOT NULL,
           updated_at ${intType()} NOT NULL
         )
-      `);
-      // Older deployments (pre BIGINT-compat) have a 32-bit `updated_at`; on
-      // Postgres the `Date.now()` written on every setSetting overflows int4.
-      // Widen in place (no-op once done / on fresh DBs). Pass the unqualified
-      // name — the helper scopes to the `public` schema.
+      `;
+
+      if (isPostgres()) {
+        // Hot path: the `settings` table and its poll index are virtually
+        // always already present in production. Issuing `CREATE TABLE`/
+        // `CREATE INDEX` still takes a lock that, in a fresh background-worker
+        // process behind a concurrent connection on the shared Neon DB, can
+        // block ~indefinitely (ACCESS EXCLUSIVE for CREATE TABLE; a write-
+        // blocking SHARE lock for CREATE INDEX). So check `information_schema`/
+        // `pg_indexes` first (plain reads, no lock) and run DDL ONLY for what
+        // is actually missing. `runGuardedDdl` bounds any DDL that must run
+        // with a transaction-scoped `lock_timeout` so a contended lock fails
+        // fast instead of hanging. `settingsTable()` is `public.settings` on
+        // Postgres; the existence checks use the unqualified table name.
+        if (!(await pgTableExists("settings"))) {
+          await runGuardedDdl(createSql);
+        }
+        // Older deployments (pre BIGINT-compat) have a 32-bit `updated_at`; on
+        // Postgres the `Date.now()` written on every setSetting overflows int4.
+        // widenIntColumnsToBigInt already probes information_schema and only
+        // ALTERs columns that are still int4 — a no-op on fresh/widened DBs.
+        await widenIntColumnsToBigInt("settings", ["updated_at"]);
+        // Index for the poll watermark query: `SELECT MAX(updated_at)`.
+        if (!(await pgIndexExists("settings_updated_at_idx"))) {
+          await runGuardedDdl(
+            `CREATE INDEX IF NOT EXISTS settings_updated_at_idx ON ${table} (updated_at)`,
+          );
+        }
+        return;
+      }
+
+      // SQLite (local dev): no lock problem — keep the original behaviour.
+      await client.execute(createSql);
+      // No-op on SQLite (INTEGER is already 64-bit).
       await widenIntColumnsToBigInt("settings", ["updated_at"]);
       // Index for the poll watermark query: `SELECT MAX(updated_at) FROM settings`.
       // MAX on an indexed column avoids a full-table scan on every poll cycle.

package/corpus/core/src/sharing/access.ts

@@ -71,6 +71,15 @@ export function resolveRegisteredAccessContext(
   return reg?.resolveAccessContext ? reg.resolveAccessContext(ctx) : ctx;
 }
 
+function normalizeEmailForAccess(email: string | undefined): string | null {
+  const normalized = email?.trim().toLowerCase();
+  return normalized || null;
+}
+
+function emailColumnMatches(column: any, email: string): SQL {
+  return sql`lower(${column}) = ${email}`;
+}
+
 /**
  * Build a Drizzle `WHERE` clause that admits rows the current user can see.
  * Pass the ownable resource table and its shares table; optional min role
@@ -103,15 +112,16 @@ export function accessFilter(
   const reg = findRegistrationByTable(resourceTable);
   const ctx = resolveRegisteredAccessContext(reg, rawCtx);
   const { userEmail, orgId } = ctx;
+  const normalizedUserEmail = normalizeEmailForAccess(userEmail);
   const publicAllowed = reg?.allowPublic !== false;
   const includePublic = (options.includePublic ?? false) && publicAllowed;
   const clauses: SQL[] = [];
 
-  if (userEmail) {
+  if (normalizedUserEmail) {
     clauses.push(
       and(
-        eq(resourceTable.ownerEmail, userEmail),
-        ownerScopeFilter(resourceTable, ctx),
+        emailColumnMatches(resourceTable.ownerEmail, normalizedUserEmail),
+        ownerScopeFilter(reg, resourceTable, ctx),
       )!,
     );
   }
@@ -128,13 +138,13 @@ export function accessFilter(
       );
     }
   }
-  if (userEmail) {
+  if (normalizedUserEmail) {
     const shareScope = restrictedShareScopeSql(reg, resourceTable, ctx);
     clauses.push(
       sql`exists (select 1 from ${sharesTable}
                   where ${sharesTable.resourceId} = ${resourceTable.id}
                     and ${sharesTable.principalType} = 'user'
-                    and ${sharesTable.principalId} = ${userEmail}
+                    and lower(${sharesTable.principalId}) = ${normalizedUserEmail}
                     and ${shareScope}
                     and ${minRoleSql(minRole)})`,
     );
@@ -154,7 +164,12 @@ export function accessFilter(
   return or(...clauses) ?? sql`1=0`;
 }
 
-function ownerScopeFilter(resourceTable: any, ctx: AccessContext): SQL {
+function ownerScopeFilter(
+  reg: ShareableResourceRegistration | undefined,
+  resourceTable: any,
+  ctx: AccessContext,
+): SQL {
+  if (reg?.ownerAccessIgnoresOrg === true) return sql`1=1`;
   if (ctx.orgId) {
     // Rows created before org-scoping, or in solo mode, have no org_id. Keep
     // them manageable by their owner after the owner joins or switches into an
@@ -167,7 +182,12 @@ function ownerScopeFilter(resourceTable: any, ctx: AccessContext): SQL {
   return sql`${resourceTable.orgId} IS NULL`;
 }
 
-function ownerMatchesActiveScope(resource: any, ctx: AccessContext): boolean {
+function ownerMatchesActiveScope(
+  reg: ShareableResourceRegistration | undefined,
+  resource: any,
+  ctx: AccessContext,
+): boolean {
+  if (reg?.ownerAccessIgnoresOrg === true) return true;
   const resourceOrgId = resource?.orgId ?? null;
   if (!resourceOrgId) return true;
   return ctx.orgId === resourceOrgId;
@@ -233,11 +253,12 @@ export async function resolveAccess(
   if (!resource) return null;
 
   const { userEmail, orgId } = ctx;
+  const normalizedUserEmail = normalizeEmailForAccess(userEmail);
 
   if (
-    userEmail &&
-    resource.ownerEmail === userEmail &&
-    ownerMatchesActiveScope(resource, ctx)
+    normalizedUserEmail &&
+    normalizeEmailForAccess(resource.ownerEmail) === normalizedUserEmail &&
+    ownerMatchesActiveScope(reg, resource, ctx)
   ) {
     return { role: "owner", resource };
   }
@@ -265,16 +286,17 @@ async function highestShareRole(
   resource: any,
 ): Promise<ShareRole | null> {
   const { userEmail, orgId } = ctx;
-  if (!userEmail && !orgId) return null;
+  const normalizedUserEmail = normalizeEmailForAccess(userEmail);
+  if (!normalizedUserEmail && !orgId) return null;
   if (!explicitSharesAllowedForResource(reg, resource, ctx)) return null;
   const db = reg.getDb() as any;
 
   const principalClauses: ReturnType<typeof and>[] = [];
-  if (userEmail) {
+  if (normalizedUserEmail) {
     principalClauses.push(
       and(
         eq(reg.sharesTable.principalType, "user"),
-        eq(reg.sharesTable.principalId, userEmail),
+        emailColumnMatches(reg.sharesTable.principalId, normalizedUserEmail),
       ),
     );
   }