okengine 0.11.2 → 0.13.0

package/src/elements/store/runtime.ts

@@ -42,6 +42,7 @@ import type {
   SqlStoreDecl,
   StoreDecl,
 } from "./declare.ts";
+import { openSqlKvNamespace } from "./kv-sql.ts";
 import { createGatedFilesStoreHandle, type GatedFilesFxBridge } from "./files-fx.ts";
 import {
   createFilesImagePipeline,
@@ -98,6 +99,11 @@ export interface CreateStoreRuntimeOptions {
    * Boot sets `off` for docker/prod and local+autoPush.
    */
   readonly domainDdl?: DomainDdlMode;
+  /**
+   * Shared SQL URL for durable KV (and apps with no `store.sql()` decl).
+   * Durable namespaces open via `sharedSqlConn`, never a second Redis.
+   */
+  readonly sqlUrl?: string;
 }
 
 /** Per-invocation context when opening a handle through the runtime. */
@@ -118,7 +124,7 @@ export type StoreHandle =
 /** KV handle on `fx.store`. */
 export interface KvStoreFxHandle {
   readonly ref: `kv:${string}`;
-  readonly driverId: "memory" | "redis";
+  readonly driverId: "memory" | "redis" | "postgres" | "pglite";
   get(key: string): Promise<unknown>;
   set(key: string, value: unknown, ttl?: string): Promise<void>;
   delete(key: string): Promise<boolean>;
@@ -128,6 +134,12 @@ export interface KvStoreFxHandle {
    * @param prefix - Optional prefix filter
    */
   list(prefix?: string): Promise<string[]>;
+  /**
+   * Remaining TTL in milliseconds, or `null` when the key has no expiry.
+   *
+   * @param key - Entry key
+   */
+  ttlMs(key: string): Promise<number | null>;
 }
 
 /** Files handle on `fx.store`. */
@@ -165,6 +177,14 @@ export interface VectorIndexStoreFxHandle {
     topK?: number,
   ): Promise<ReadonlyArray<{ id: string; score: number; meta?: Record<string, unknown> }>>;
   delete(id: string): Promise<boolean>;
+  /**
+   * List stored documents (id + meta, no embeddings).
+   *
+   * @param limit - Max documents (default 100)
+   */
+  list(
+    limit?: number,
+  ): Promise<ReadonlyArray<{ id: string; score: number; meta?: Record<string, unknown> }>>;
 }
 
 /** Full-text index handle on `fx.store`. */
@@ -174,6 +194,14 @@ export interface TextIndexStoreFxHandle {
   upsert(id: string, document: Record<string, unknown>): Promise<void>;
   search(q: string, opts?: TextIndexSearchOptions): Promise<TextIndexSearchResult>;
   delete(id: string): Promise<boolean>;
+  /**
+   * List stored documents (id + fields as meta).
+   *
+   * @param limit - Max documents (default 100)
+   */
+  list(
+    limit?: number,
+  ): Promise<ReadonlyArray<{ id: string; score: number; meta?: Record<string, unknown> }>>;
 }
 
 /** Index handle on `fx.store` — discriminated by `driverId`. */
@@ -183,6 +211,10 @@ export type IndexStoreFxHandle = VectorIndexStoreFxHandle | TextIndexStoreFxHand
 export interface StoreRuntime {
   /** Shared multi-tier cache. */
   readonly cache: StoreCache;
+  /** Configured KV driver id — `fx.store(kv).driverId` before first I/O. */
+  readonly kvDriverId?: KvStoreFxHandle["driverId"];
+  /** Configured index driver id — `fx.store(index).driverId` before first I/O. */
+  readonly indexDriverId?: IndexStoreFxHandle["driverId"];
   /**
    * Open a handle for a store declaration under the given invoke context.
    *
@@ -197,6 +229,13 @@ export interface StoreRuntime {
    * @param ctx - Invoke context
    */
   openRef(ref: ResourceRef, ctx: StoreInvokeContext): Promise<StoreHandle>;
+  /**
+   * Driver KV namespace for Console engine telemetry. Not the `fx.store`
+   * handle — `send` stays off the public surface.
+   *
+   * @param ref - `kv:name`
+   */
+  kvNamespace(ref: ResourceRef): Promise<KvNamespace>;
   /**
    * Register a declaration (usually done at module load).
    *
@@ -217,11 +256,13 @@ export interface StoreRuntime {
    * @param effects - Read effects
    * @param value - Cached payload
    * @param dimsByResource - Optional key dimensions
+   * @param ttlMs - Optional TTL; omit / `null` for invalidate-only
    */
   putTier1(
     effects: Effects,
     value: unknown,
     dimsByResource?: Readonly<Record<string, readonly string[]>>,
+    ttlMs?: number | null,
   ): string[];
   /** Close all open connections. */
   close(): Promise<void>;
@@ -348,17 +389,37 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
     return sharedSqlConn(sqlDriver, "primary", { url });
   }
 
+  /**
+   * Durable KV — JSONB table on the shared SQL connection.
+   *
+   * @param name - Namespace
+   */
+  async function openDurableKv(name: string): Promise<KvNamespace> {
+    const sqlDriver = options.drivers.sql;
+    if (!sqlDriver) {
+      throw new Error("oke store: durable store.kv needs a configured sql driver");
+    }
+    const firstSql = Object.values(options.sql ?? [])[0];
+    const url = options.sqlUrl ?? firstSql?.primary.url;
+    const conn = await sharedSqlConn(sqlDriver, "primary", { url });
+    return openSqlKvNamespace({ conn, namespace: name, now });
+  }
+
   async function openKv(decl: KvStoreDecl): Promise<KvStoreFxHandle> {
-    const driver = options.drivers.kv;
-    if (!driver) throw new Error("No kv driver configured");
     let ns = kvNs.get(decl.name);
     if (!ns) {
-      const binding = options.kv?.[decl.name] ?? {};
-      ns = await driver.open({
-        name: decl.name,
-        url: binding.url,
-        client: binding.client as never,
-      });
+      if (decl.durable === true) {
+        ns = await openDurableKv(decl.name);
+      } else {
+        const driver = options.drivers.kv;
+        if (!driver) throw new Error("No kv driver configured");
+        const binding = options.kv?.[decl.name] ?? {};
+        ns = await driver.open({
+          name: decl.name,
+          url: binding.url,
+          client: binding.client as never,
+        });
+      }
       kvNs.set(decl.name, ns);
     }
     const driverId = ns.driverId;
@@ -369,6 +430,7 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       set: (key, value, ttl) => ns!.set(key, value, ttl),
       delete: (key) => ns!.delete(key),
       list: (prefix) => ns!.list(prefix),
+      ttlMs: (key) => ns!.ttlMs(key),
     };
   }
 
@@ -426,6 +488,7 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
         upsert: (id, document) => text.upsert(id, document),
         search: (q, opts) => text.search(q, opts),
         delete: (id) => text.delete(id),
+        list: (limit) => text.list(limit),
       };
     }
     const vector = idx as VectorIndexStore;
@@ -435,11 +498,14 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       upsert: (id, vec, meta) => vector.upsert(id, vec, meta),
       search: (vec, topK) => vector.search(vec, topK),
       delete: (id) => vector.delete(id),
+      list: (limit) => vector.list(limit),
     };
   }
 
   const runtime: StoreRuntime = {
     cache,
+    kvDriverId: options.drivers.kv?.id,
+    indexDriverId: options.drivers.index?.id,
     declarations,
     register(decl) {
       declarations.set(`${decl.facet}:${decl.name}`, decl);
@@ -465,19 +531,30 @@ export function createStoreRuntime(options: CreateStoreRuntimeOptions): StoreRun
       if (!decl) throw new Error(`Unknown store ref: ${ref}`);
       return this.open(decl, ctx);
     },
+    async kvNamespace(ref) {
+      const decl = declarations.get(ref);
+      if (!decl || decl.facet !== "kv") {
+        throw new Error(`Unknown kv ref: ${ref}`);
+      }
+      await openKv(decl);
+      const ns = kvNs.get(decl.name);
+      if (!ns) throw new Error(`Unknown kv ref: ${ref}`);
+      return ns;
+    },
     onWriteEffects(effects) {
       return cache.invalidateFromEffects(effects);
     },
-    putTier1(effects, value, dimsByResource) {
+    putTier1(effects, value, dimsByResource, ttlMs) {
       const keys = tier1KeysForReads(effects, dimsByResource);
       const resources = (effects.reads ?? []).filter((r): r is ResourceRef => r !== "runs");
+      const expiresAt = ttlMs !== undefined && ttlMs !== null && ttlMs > 0 ? now() + ttlMs : null;
       for (const key of keys) {
         cache.set({
           tier: 1,
           key,
           value,
           resources,
-          expiresAt: null,
+          expiresAt,
         });
       }
       return keys;

package/src/elements/store/schema-decl.test.ts

@@ -10,6 +10,7 @@ import {
   createStoreRuntime,
   field,
   id,
+  isSchemaTableDecl,
   maskRows,
   now,
   PII_MASK,
@@ -53,6 +54,14 @@ describe("store.schema.table + field.*", () => {
     const fromTable = classificationsFromTable(notes);
     expect(fromTable.email?.pii).toBe(true);
 
+    const views = store.schema.table("views", {
+      id: field.text().primaryKey(),
+      ownerEmail: field.text().pii(),
+    });
+    const fromViews = classificationsFromTable(views);
+    expect(fromViews.ownerEmail?.pii).toBe(true);
+    expect(fromViews.owner_email?.pii).toBe(true);
+
     const decl = store.sql("notes", { schema: { notes } });
     const runtime = createStoreRuntime({
       drivers: {},
@@ -82,6 +91,46 @@ describe("store.schema.table + field.*", () => {
     const rows = await handle.select().from(notes);
     expect(rows[0]!.email).toBe(PII_MASK);
   });
+
+  test("a `name` column does not break insert / select / emit", async () => {
+    const teams = store.schema.table("teams", {
+      id: field.text().primaryKey(),
+      key: field.text().notNull(),
+      name: field.text().notNull(),
+    });
+
+    expect(teams.kind).toBe("schema-table");
+    expect(teams.tableName).toBe("teams");
+    expect(typeof teams.name).toBe("object");
+    expect(teams.columns.name.sqlName).toBe("name");
+
+    const src = emitDrizzleSource([teams], "postgres");
+    expect(src).toContain('export const teams = pgTable("teams"');
+
+    const { memorySqlDriver } = await import("../../drivers/index.ts");
+    const decl = store.sql("app", { schema: { teams } });
+    const rt = createStoreRuntime({
+      drivers: { sql: memorySqlDriver },
+      sql: { app: { name: "app", primary: {} } },
+    });
+    rt.register(decl);
+    const handle = (await rt.open(decl, {
+      effects: { writes: ["sql:app"], reads: ["sql:app"] },
+    })) as SqlStoreHandle;
+    await handle.insert(teams).values({ id: "team_eng", key: "ENG", name: "Engineering" });
+    const rows = await handle.select().from(teams);
+    expect(rows).toEqual([{ id: "team_eng", key: "ENG", name: "Engineering" }]);
+  });
+
+  test("a `kind` column does not hide the table discriminant", () => {
+    const tasks = store.schema.table("tasks", {
+      id: field.text().primaryKey(),
+      kind: field.text().notNull(),
+    });
+    expect(isSchemaTableDecl(tasks)).toBe(true);
+    expect(tasks.kind).toBe("schema-table");
+    expect(tasks.columns.kind.sqlName).toBe("kind");
+  });
 });
 
 describe("emitDrizzleSource — postgres pgTable from one declaration", () => {

package/src/elements/store/schema-decl.ts

@@ -73,6 +73,11 @@ export interface SchemaColumnDecl extends ColumnDef {
 export interface SchemaTableDecl extends TableHandle {
   readonly kind: "schema-table";
   readonly columns: Readonly<Record<string, SchemaColumnDecl>>;
+  /**
+   * SQL table name. Non-enumerable when a column is also named `name`
+   * (spreading columns would otherwise shadow {@link TableHandle.name}).
+   */
+  readonly tableName?: string;
 }
 
 /** Fluent field builder before key finalization. */
@@ -267,13 +272,25 @@ export function finalizeColumnMap(
  * @param value - Unknown
  */
 export function isSchemaTableDecl(value: unknown): value is SchemaTableDecl {
-  return (
-    !!value &&
-    typeof value === "object" &&
-    (value as SchemaTableDecl).kind === "schema-table" &&
-    typeof (value as SchemaTableDecl).name === "string" &&
-    "columns" in value
-  );
+  if (!value || typeof value !== "object") return false;
+  const table = value as SchemaTableDecl;
+  if (table.kind !== "schema-table" || !("columns" in table)) return false;
+  return typeof schemaTableSqlName(table) === "string";
+}
+
+/**
+ * SQL name for a {@link SchemaTableDecl}, including tables whose `name`
+ * column shadows {@link TableHandle.name}.
+ *
+ * @param table - Schema table declaration
+ */
+export function schemaTableSqlName(table: SchemaTableDecl): string | undefined {
+  if (typeof table.tableName === "string") return table.tableName;
+  if (typeof table.name === "string") return table.name;
+  for (const col of Object.values(table.columns ?? {})) {
+    if (typeof col.tableName === "string") return col.tableName;
+  }
+  return undefined;
 }
 
 /**
@@ -283,7 +300,7 @@ export type SchemaTableWithColumns<
   C extends Record<string, SchemaColumnDecl> = Record<string, SchemaColumnDecl>,
 > = Omit<SchemaTableDecl, "columns"> & {
   readonly columns: Readonly<C>;
-} & C;
+} & Omit<C, "kind" | "tableName">;
 
 /**
  * Declare an abstract schema table (ORM-agnostic).
@@ -304,11 +321,14 @@ export function schemaTable<C extends Record<string, SchemaColumnInput>>(
     stamped[key] = { ...col, tableName: name };
   }
   const table = {
-    kind: "schema-table" as const,
     name,
     columns: stamped,
     ...stamped,
   };
+  // Survive columns named `name` or `kind` (they would otherwise shadow
+  // the table discriminant / SQL name).
+  Object.defineProperty(table, "kind", { value: "schema-table", enumerable: false });
+  Object.defineProperty(table, "tableName", { value: name, enumerable: false });
   return table as SchemaTableWithColumns<{ [K in keyof C]: SchemaColumnDecl }>;
 }
 

package/src/elements/store/seed.test.ts

@@ -1,5 +1,12 @@
 import { describe, expect, test } from "bun:test";
-import { defineSeed, normalizeSeedFns, resolveSeedCategory, type SeedFn } from "./seed.ts";
+import {
+  defineSeed,
+  normalizeSeedFns,
+  resolveSeedCategory,
+  resolveSeedIdentity,
+  seedPromptMessage,
+  type SeedFn,
+} from "./seed.ts";
 
 describe("defineSeed / resolveSeedCategory", () => {
   test("defineSeed returns the same def", () => {
@@ -23,4 +30,18 @@ describe("defineSeed / resolveSeedCategory", () => {
     expect(resolveSeedCategory("prod")).toBe("prod");
     expect(resolveSeedCategory("test")).toBe(null);
   });
+
+  test("resolveSeedIdentity prefers defineSeed name over the folder", () => {
+    expect(
+      resolveSeedIdentity({ name: "keel", description: "Featured Harbor story" }, "/tmp/app"),
+    ).toEqual({
+      name: "keel",
+      description: "Featured Harbor story",
+    });
+    expect(resolveSeedIdentity(undefined, "/repo/examples/keel")).toEqual({ name: "keel" });
+    expect(seedPromptMessage({ name: "keel", description: "Featured Harbor story" })).toBe(
+      "Seed keel (Featured Harbor story)?",
+    );
+    expect(seedPromptMessage({ name: "notes" })).toBe("Seed notes?");
+  });
 });

package/src/elements/store/seed.ts

@@ -19,20 +19,65 @@ export type SeedFns = SeedFn | readonly SeedFn[];
  * - `essential` — every environment, always
  * - `dev` — `dev` ConfigEnv only (Docker Compose laptop)
  * - `prod` — `prod` only
+ *
+ * `name` / `description` identify this app's seed (template or example) —
+ * the CLI prompt and `.oke/state.json` key off `name`, never a global flag.
  */
 export interface SeedDef {
+  /** App / template / example id (`keel`, `notes`). */
+  readonly name?: string;
+  /** One-line label for the `oke dev` seed prompt. */
+  readonly description?: string;
   readonly essential?: SeedFns;
   readonly dev?: SeedFns;
   readonly prod?: SeedFns;
 }
 
+/** Resolved seed identity for CLI prompt + project state. */
+export interface SeedIdentity {
+  readonly name: string;
+  readonly description?: string;
+}
+
+/**
+ * Identity for this seed module: declared `name`, else the project folder.
+ *
+ * @param def - Seed declaration (may omit name)
+ * @param cwd - Project root
+ */
+export function resolveSeedIdentity(
+  def: Pick<SeedDef, "name" | "description"> | undefined,
+  cwd: string,
+): SeedIdentity {
+  const declared = def?.name?.trim();
+  const fromDir = cwd
+    .replace(/[/\\]+$/, "")
+    .split(/[/\\]/)
+    .pop()
+    ?.trim();
+  const name = (declared && declared.length > 0 ? declared : fromDir) || "app";
+  const description = def?.description?.trim();
+  return description && description.length > 0 ? { name, description } : { name };
+}
+
+/**
+ * Confirm copy for `oke dev` / `oke db seed` — names this app's seed.
+ *
+ * @param identity - Resolved {@link SeedIdentity}
+ */
+export function seedPromptMessage(identity: SeedIdentity): string {
+  return identity.description
+    ? `Seed ${identity.name} (${identity.description})?`
+    : `Seed ${identity.name}?`;
+}
+
 /** Env-selected category that runs alongside `essential` (or neither). */
 export type SeedCategory = "dev" | "prod";
 
 /**
  * Freeze a seed declaration for `src/db/seed/index.ts` default export.
  *
- * @param def - Essential / dev / prod function bags
+ * @param def - Name / description plus essential / dev / prod function bags
  */
 export function defineSeed(def: SeedDef): SeedDef {
   return def;

package/src/elements/store/sql-session.ts

@@ -263,6 +263,8 @@ export interface SqlStoreHandle {
   increment(table: TableHandle | unknown, id: string, column: string, by?: number): Promise<number>;
   /**
    * Raw SQL — PII masking still applied at the boundary.
+   * DML without `RETURNING` uses `exec` (memory SQL has no generic UPDATE
+   * on `query`); SELECT and `RETURNING` still return masked rows.
    *
    * @param sql - SQL with `?` placeholders
    * @param params - Bound parameters
@@ -312,9 +314,19 @@ export interface SqlPageOptions {
   /**
    * Keyset mode — a Drizzle SQL condition describing "rows strictly after
    * the cursor" (composed by the caller / `store.resource`); ANDed onto
-   * `where`. Cannot combine with `offset`.
+   * `where`. Cannot combine with `offset` or `before`.
    */
   readonly after?: unknown;
+  /**
+   * Keyset mode — rows strictly before the cursor. Caller flips `orderBy`
+   * and reverses the result. Cannot combine with `offset` or `after`.
+   */
+  readonly before?: unknown;
+}
+
+/** True when `sql` is DML/DDL (not a SELECT). */
+function isSqlDml(sql: string): boolean {
+  return /^(insert|update|delete|create|drop|alter|truncate|replace)\b/i.test(sql.trim());
 }
 
 /**
@@ -697,6 +709,12 @@ export function createSqlStoreHandle(
 
     async raw(sql, params = []) {
       const table = tableFromSql(sql);
+      // Memory SQL (console-next seed) implements DML on `exec`, not `query`.
+      // SELECT / RETURNING still go through `query` so callers get rows.
+      if (isSqlDml(sql) && !/\breturning\b/i.test(sql)) {
+        const result = await exec(sql, params);
+        return [{ changes: result.changes }];
+      }
       const rows = await query(sql, params);
       return mask(rows, table);
     },
@@ -718,15 +736,22 @@ export function createSqlStoreHandle(
     },
 
     async page(table, options) {
-      if (options.offset !== undefined && options.after !== undefined) {
-        throw new Error("page(): offset and after (keyset) cannot combine");
+      if (options.after !== undefined && options.before !== undefined) {
+        throw new Error("page(): after and before (keyset) cannot combine");
+      }
+      if (
+        options.offset !== undefined &&
+        (options.after !== undefined || options.before !== undefined)
+      ) {
+        throw new Error("page(): offset and keyset (after/before) cannot combine");
       }
+      const keyset = options.after ?? options.before;
       const where =
-        options.after === undefined
+        keyset === undefined
           ? options.where
           : options.where === undefined
-            ? options.after
-            : andWhere(options.where, options.after);
+            ? keyset
+            : andWhere(options.where, keyset);
       return runSelect(table, null, {
         where,
         orders: options.orderBy,
@@ -756,7 +781,7 @@ export function createSqlStoreHandle(
           return `${quoteIdent(c.name)} ${typ}`;
         })
         .join(", ");
-      await exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(table.name)} (${colSql})`);
+      await exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(resolveTableName(table))} (${colSql})`);
     },
   };
 

package/src/elements/store/table.ts

@@ -74,6 +74,16 @@ export function resolveTableName(table: unknown): string {
   if (typeof table === "string") return table;
   if (table && typeof table === "object") {
     const t = table as Record<string, unknown>;
+    if (t.kind === "schema-table") {
+      if (typeof t.tableName === "string") return t.tableName;
+      if (typeof t.name === "string") return t.name;
+      const cols = t.columns;
+      if (cols && typeof cols === "object") {
+        for (const col of Object.values(cols as Record<string, { tableName?: unknown }>)) {
+          if (typeof col?.tableName === "string") return col.tableName;
+        }
+      }
+    }
     if (typeof t.name === "string" && !isDrizzleTable(t)) return t.name;
     // Drizzle stores the name on an internal symbol; also expose via _.name / [Symbol]
     for (const key of Object.getOwnPropertySymbols(t)) {
@@ -308,7 +318,13 @@ export function mapRowToJs(
 export function classificationsFromTable(table: TableHandle): Record<string, ColumnClassification> {
   const out: Record<string, ColumnClassification> = {};
   for (const [key, col] of Object.entries(table.columns)) {
-    if (col.classification) out[key] = col.classification;
+    if (!col.classification) continue;
+    out[key] = col.classification;
+    const sqlName =
+      "sqlName" in col && typeof (col as { sqlName?: unknown }).sqlName === "string"
+        ? (col as { sqlName: string }).sqlName
+        : col.name;
+    if (sqlName && sqlName !== key) out[sqlName] = col.classification;
   }
   return out;
 }

package/src/elements/store/upsert-app.test.ts

@@ -45,7 +45,7 @@ describe("fx.store(db).upsert via app.fetch (real boot)", () => {
     const db = store.sql("app", { schema: { notes } });
 
     const seed = on(
-      http.post("/seed").gate(gate.public),
+      http.post("/seed").gate.public,
       flow("notes.seed", {
         in: UpsertIn,
         out: UpsertOut,

package/src/elements/store.test.ts

@@ -63,6 +63,8 @@ describe("store facets", () => {
   test("declares sql · kv · files · index with resource refs", () => {
     expect(store.sql("notes").ref).toBe("sql:notes");
     expect(store.kv("sessions").ref).toBe("kv:sessions");
+    expect(store.kv("ledger", { durable: true }).durable).toBe(true);
+    expect(store.kv("sessions").durable).toBeUndefined();
     expect(store.files("uploads").ref).toBe("files:uploads");
     expect(store.index("kb", { dims: 8 }).ref).toBe("index:kb");
   });
@@ -345,4 +347,25 @@ describe("PII masking at the driver boundary", () => {
     });
     expect(masked[0]).toEqual({ id: "1", phone: PII_MASK, name: "Ada" });
   });
+
+  test("maskRows aliases ownerEmail / owner_email so raw SQL cannot leak", () => {
+    const fromJs = buildClassificationMap({
+      views: { ownerEmail: classify({ pii: true }) },
+    });
+    const fromSql = buildClassificationMap({
+      views: { owner_email: classify({ pii: true }) },
+    });
+    expect(
+      maskRows([{ id: "v1", owner_email: "aria@keel.dev" }], {
+        classifications: fromJs,
+        table: "views",
+      })[0],
+    ).toEqual({ id: "v1", owner_email: PII_MASK });
+    expect(
+      maskRows([{ id: "v1", ownerEmail: "ben@keel.dev" }], {
+        classifications: fromSql,
+        table: "views",
+      })[0],
+    ).toEqual({ id: "v1", ownerEmail: PII_MASK });
+  });
 });

package/src/elements/store.ts

@@ -57,6 +57,10 @@ export {
   buildClassificationMap,
   maskRows,
   isPiiColumn,
+  piiNameAliases,
+  addPiiFieldName,
+  expandPiiNames,
+  piiLogicalCount,
   tableFromSql,
   PII_MASK,
 } from "./store/classify.ts";
@@ -66,6 +70,9 @@ export {
   createStoreCache,
   computedCacheKey,
   tier1KeysForReads,
+  tier1FlowDims,
+  tier1DimsByResource,
+  autoCacheEligible,
   resourcesTouchedByWrites,
   isInvalidatedByWrite,
   parseTtlMs,
@@ -91,8 +98,14 @@ export type {
   ResolvedListConfig,
 } from "./store/resource.ts";
 
-export { defineSeed, normalizeSeedFns, resolveSeedCategory } from "./store/seed.ts";
-export type { SeedCategory, SeedDef, SeedFn, SeedFns } from "./store/seed.ts";
+export {
+  defineSeed,
+  normalizeSeedFns,
+  resolveSeedCategory,
+  resolveSeedIdentity,
+  seedPromptMessage,
+} from "./store/seed.ts";
+export type { SeedCategory, SeedDef, SeedFn, SeedFns, SeedIdentity } from "./store/seed.ts";
 
 export { createSqlStoreHandle, resolvePkColumn } from "./store/sql-session.ts";
 export type {
@@ -125,7 +138,17 @@ export type {
   TextIndexStoreFxHandle,
 } from "./store/runtime.ts";
 
-export { fileKeyWarnings, contentAddressedKey, projectFileKeys } from "./store/files-policy.ts";
+export {
+  fileKeyWarnings,
+  contentAddressedKey,
+  projectFileKeys,
+  inferFileContentType,
+  isAsciiObjectKey,
+  slugFileSegment,
+  safeFilePrefix,
+  safeFileObjectKey,
+  coerceSafeFileObjectKey,
+} from "./store/files-policy.ts";
 export type { FileKeyWarning } from "./store/files-policy.ts";
 
 export {