@cosmicdrift/kumiko-framework 0.404.0 → 0.405.0

package/dist/crypto/subject-resolver.js

@@ -1,4 +1,5 @@
 import { normalizeEventPiiSubject } from "@cosmicdrift/kumiko-types/handlers";
+import { isFileField } from "../engine/field-helpers.js";
 import { isSelfPiiField } from "./is-self-pii-field.js";
 import { RECORD_ENTITY_PATTERN } from "./kms-adapter.js";
 // Thrown when a field IS pii-annotated but the row can't name its subject —
@@ -157,24 +158,18 @@ export function collectPiiSubjectFields(entity) {
         .filter(([, field]) => hasSubjectAnnotation(field))
         .map(([name]) => name);
 }
-function isFileReferenceField(field) {
-    return (field.type === "file" ||
-        field.type === "image" ||
-        field.type === "files" ||
-        field.type === "images");
-}
 // File columns hold only the fileRef uuid; the binary is erased by the file-ref
 // user-data hook, so these stay annotated (forget) but are never ciphertext.
 export function collectPiiEncryptedFields(entity) {
     return Object.entries(entity.fields)
-        .filter(([, field]) => hasSubjectAnnotation(field) && !isFileReferenceField(field))
+        .filter(([, field]) => hasSubjectAnnotation(field) && !isFileField(field))
         .map(([name]) => name);
 }
 // The annotated file-reference fields: never ciphertext today, but events from the
 // old backfill (which encrypted them) still carry it and must replay.
 export function collectPiiFileReferenceFields(entity) {
     return Object.entries(entity.fields)
-        .filter(([, field]) => hasSubjectAnnotation(field) && isFileReferenceField(field))
+        .filter(([, field]) => hasSubjectAnnotation(field) && isFileField(field))
         .map(([name]) => name);
 }
 /** Subject-annotated fields that may be plaintext in the derived search index. */

package/dist/db/blind-index-cleanup.js

@@ -13,6 +13,7 @@
 import { collectLookupableFields } from "../crypto/blind-index.js";
 import { quoteIdent, subjectCiphertextLikePattern } from "../crypto/ciphertext-pattern.js";
 import { isSelfPiiField } from "../crypto/is-self-pii-field.js";
+import { findEntity } from "../engine/find-entity.js";
 import { toSnakeCase } from "../utils/case.js";
 import { resolveTableName } from "./entity-table-meta.js";
 import { toPostgresArrayLiteral } from "./queries/postgres-array-literal.js";
@@ -115,14 +116,6 @@ export async function subjectRowExistsInTenant(db, features, subjectId, tenantId
         return false;
     });
 }
-function findEntityByExactName(features, entityName) {
-    for (const feature of features.values()) {
-        const entity = feature.entities?.[entityName];
-        if (entity)
-            return entity;
-    }
-    return undefined;
-}
 // Tighter than subjectRowExistsInTenant: the record subject names its own
 // entity, so this is a single-table lookup instead of a self-PII scan
 // across the whole registry.
@@ -132,7 +125,7 @@ function findEntityByExactName(features, entityName) {
 // at create) — a composite PK or shared table would break this.
 export async function recordRowExistsInTenant(db, features, entityName, recordId, tenantId) {
     return runInSystemRowLevelSecurityScope("record existence check spans tenants", async () => {
-        const entity = findEntityByExactName(features, entityName);
+        const entity = findEntity(features, entityName);
         if (!entity)
             return false;
         const tableName = resolveTableName(entityName, entity, undefined);
@@ -159,7 +152,7 @@ export async function recordEventsOwnedExclusivelyByTenant(db, aggregateType, ag
 // tenant-scoped policy for the row's real owner (not the acting user's tenant).
 export async function recordRowOwningTenantId(db, features, entityName, recordId) {
     return runInSystemRowLevelSecurityScope("record owner lookup spans tenants", async () => {
-        const entity = findEntityByExactName(features, entityName);
+        const entity = findEntity(features, entityName);
         if (!entity)
             return undefined;
         const tableName = resolveTableName(entityName, entity, undefined);

package/dist/db/query.js

@@ -391,26 +391,11 @@ export async function insertOne(db, table, values) {
     if (managedDenied)
         throw managedDenied;
     const info = extractTableInfo(table);
-    const entries = Object.entries(values)
-        .filter(([k]) => info.hasColumn(k))
-        .map(([k, v]) => {
-        const col = info.columnOf(k);
-        const pgType = info.pgTypeOf(col);
-        return { col, prepared: prepareValue(v, pgType) };
-    });
+    const entries = insertEntries(info, values);
     if (entries.length === 0)
         throw new Error("insertOne: empty values object");
-    const cols = entries.map((e) => quoteIdent(e.col)).join(", ");
-    const params = [];
-    const placeholders = entries
-        .map((e) => {
-        if (e.prepared.kind === "literal")
-            return e.prepared.literal;
-        params.push(e.prepared.bound);
-        return `$${params.length}${e.prepared.sql}`;
-    })
-        .join(", ");
-    const sqlText = `INSERT INTO ${quoteIdent(info.name)} (${cols}) VALUES (${placeholders}) RETURNING *`;
+    const { sqlPrefix, params } = buildInsertSql(info, entries);
+    const sqlText = `${sqlPrefix} RETURNING *`;
     const rows = await unsafeLoggingClosedConnection(db, sqlText, params, {
         operation: "insertOne",
         table: info.name,

package/dist/derivatives/variant-key.d.ts

@@ -4,6 +4,10 @@ export declare function specHash(spec: VariantSpec): string;
 export declare const VARIANT_NAME_PATTERN: RegExp;
 export declare function variantSuffix(name: string, spec: VariantSpec): string;
 export declare function isDerivativeSuffix(suffix: string): boolean;
+export declare function splitKey(key: string): {
+    readonly base: string;
+    readonly ext: string;
+};
 export declare function derivativeListPrefix(originalKey: string): string;
 export declare function isDerivativeKeyOf(originalKey: string, candidateKey: string): boolean;
 export declare function parseDerivativeKey(candidateKey: string): {

package/dist/derivatives/variant-key.js

@@ -41,9 +41,10 @@ const DERIVATIVE_SUFFIX_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9-]{0,31}-[0-9a-f]{16}$/
 export function isDerivativeSuffix(suffix) {
     return DERIVATIVE_SUFFIX_PATTERN.test(suffix);
 }
-// Mirrors deriveKey's own split so callers get the exact same base/ext this
-// key's derivatives were built from.
-function splitKey(key) {
+// Splits on the last dot of the last path segment only, so `archive.v2/foo.jpg`
+// yields base `archive.v2/foo`. No dot there: the whole key is the base, ext is
+// empty. deriveKey uses the same split, so derivative keys line up with it.
+export function splitKey(key) {
     const lastSlash = key.lastIndexOf("/");
     const lastSegment = lastSlash === -1 ? key : key.slice(lastSlash + 1);
     const lastDot = lastSegment.lastIndexOf(".");

package/dist/engine/boot-validator/field-conditions.js

@@ -1,5 +1,6 @@
 import { isFileSubField } from "../../files/file-field-slots.js";
 import { parseMaxSize } from "../../files/types.js";
+import { isFileField } from "../field-helpers.js";
 import { conditionComparisonValues, LOCKABLE_FIELD_TYPES } from "./entity-handler.js";
 const STATE_KEYS = ["visibleWhen", "requiredWhen"];
 const SUB_CONDITION_TYPES = new Set([
@@ -178,15 +179,9 @@ function assertField(feature, entityName, entity, fieldName, field) {
     }
     if (field.type === "embedded")
         assertEmbeddedField(where, field);
-    if (isFileAcceptField(field))
+    if (isFileField(field))
         assertAcceptEntries(where, field.accept);
 }
-function isFileAcceptField(field) {
-    return (field.type === "file" ||
-        field.type === "files" ||
-        field.type === "image" ||
-        field.type === "images");
-}
 export function validateFieldConditions(feature) {
     for (const [entityName, entity] of Object.entries(feature.entities ?? {})) {
         for (const [fieldName, field] of Object.entries(entity.fields)) {

package/dist/engine/boot-validator/list-table-aggregate-query.js

@@ -1,7 +1,7 @@
 import { resolveEntityBehindListQuery } from "../entity-list-searchability.js";
+import { findEntity } from "../find-entity.js";
 import { normalizeListColumn } from "../screen-helpers.js";
 import { entityAggregateFieldLookup, validateListTableAggregateFieldTypes, } from "./list-table-aggregate-options.js";
-import { findEntity } from "./parent-ref.js";
 import { getZodObjectShape } from "./zod-shape.js";
 function columnValueTypeLookup(columns) {
     const valueTypes = new Map(columns

package/dist/engine/boot-validator/parent-ref.d.ts

@@ -1,4 +1,2 @@
-import type { EntityDefinition } from "@cosmicdrift/kumiko-types/fields";
 import type { FeatureDefinition } from "../types/index.ts";
-export declare function findEntity(featureMap: ReadonlyMap<string, FeatureDefinition>, entityName: string): EntityDefinition | undefined;
 export declare function validateParentRefs(feature: FeatureDefinition, featureMap: ReadonlyMap<string, FeatureDefinition>): void;

package/dist/engine/boot-validator/parent-ref.js

@@ -1,4 +1,5 @@
 import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handlers";
+import { findEntity } from "../find-entity.js";
 // --- Parent-ref boot validation ---
 //
 // Join-row entities (EntityDefinition.parentRef) derive both the write-path
@@ -8,14 +9,6 @@ import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handler
 // was supplied — throwing there would 500 every custom handler and
 // framework-internal detail() call that doesn't wire it, so the enforcement
 // has to happen loudly here instead, once, at boot.
-export function findEntity(featureMap, entityName) {
-    for (const f of featureMap.values()) {
-        const entity = f.entities?.[entityName];
-        if (entity)
-            return entity;
-    }
-    return undefined;
-}
 function findQueryHandler(featureMap, handlerName) {
     for (const f of featureMap.values()) {
         const handler = f.queryHandlers[handlerName];

package/dist/engine/boot-validator/projection-list-screens.js

@@ -1,11 +1,11 @@
 import { isListQueryWithoutSearchableFields, resolveEntityBehindListQuery, } from "../entity-list-searchability.js";
+import { findEntity } from "../find-entity.js";
 import { QnTypes, qualifyEntityName } from "../qualified-name.js";
 import { isEditLayoutScreen } from "../screen-helpers.js";
 import { bootRuleError } from "./boot-rule.js";
 import { SEARCHABLE_FALSE_WHITELIST } from "./entity-list-screens.js";
 import { validateListTableAggregateQuery } from "./list-table-aggregate-query.js";
 import { NAMED_FILTER_RULES } from "./named-filter-rules.js";
-import { findEntity } from "./parent-ref.js";
 import { getZodObjectShape } from "./zod-shape.js";
 // Sibling to entity-list-screens.ts rather than an extension of it:
 // validateOneEntityListScreen is typed to EntityListScreenDefinition and

package/dist/engine/boot-validator/read-gate.js

@@ -1,6 +1,6 @@
 import { ENTITY_CONVENTION_QUERY_BRAND } from "@cosmicdrift/kumiko-types/handlers";
 import { FILE_REF_ENTITY_NAME } from "../../files/types.js";
-import { findEntity } from "./parent-ref.js";
+import { findEntity } from "../find-entity.js";
 function fail(check, message) {
     throw new Error(`[Kumiko ReadGate] entity "${check.entityName}" (feature: "${check.feature.name}"): ${message}`);
 }

package/dist/engine/find-entity.d.ts

@@ -0,0 +1,3 @@
+import type { EntityDefinition } from "./types/fields.ts";
+import type { FeatureDefinition } from "./types/index.ts";
+export declare function findEntity(features: ReadonlyMap<string, FeatureDefinition>, entityName: string): EntityDefinition | undefined;

package/dist/engine/find-entity.js

@@ -0,0 +1,8 @@
+export function findEntity(features, entityName) {
+    for (const feature of features.values()) {
+        const entity = feature.entities?.[entityName];
+        if (entity)
+            return entity;
+    }
+    return undefined;
+}

package/dist/engine/project-app-schema-for-roles.js

@@ -255,62 +255,26 @@ function keepTreeAction(action, keptScreenQns) {
         return true; // target-based dispatch, not a screen navigate
     return keptScreenQns.has(action.screen);
 }
-// --- RowAction / ToolbarAction / RelatedListToolbarAction array projectors ---
-// Each returns the ORIGINAL array reference when nothing was filtered, and
-// `undefined` (never an empty array) when everything was — same JSON-safety
-// convention as buildAppSchema.
-function keepRowAction(action, feature, indices, keptScreenQns) {
+function keepScreenTargetAction(action, feature, indices, keptScreenQns) {
     if (action.kind === "drawer")
         return isDrawerTargetKept(feature, action.screen, keptScreenQns);
     if (action.kind === "navigate")
         return isNavigateTargetKept(action, indices, keptScreenQns);
-    return true; // writeHandler — no screen target
+    return true; // no screen target
 }
-function projectRowActionArray(actions, feature, indices, keptScreenQns) {
+function filterKeptActions(actions, keep) {
     if (actions === undefined)
         return undefined;
-    const kept = actions.filter((a) => keepRowAction(a, feature, indices, keptScreenQns));
+    const kept = actions.filter(keep);
     if (kept.length === actions.length)
         return actions;
     return kept.length > 0 ? kept : undefined;
 }
-function keepToolbarAction(action, feature, indices, keptScreenQns) {
-    if (action.kind === "navigate")
-        return isNavigateTargetKept(action, indices, keptScreenQns);
-    if (action.kind === "drawer")
-        return isDrawerTargetKept(feature, action.screen, keptScreenQns);
-    return true;
-}
-function projectToolbarActionArray(actions, feature, indices, keptScreenQns) {
-    if (actions === undefined)
-        return undefined;
-    const kept = actions.filter((a) => keepToolbarAction(a, feature, indices, keptScreenQns));
-    if (kept.length === actions.length)
-        return actions;
-    return kept.length > 0 ? kept : undefined;
-}
-function keepRelatedListToolbarAction(action, feature, indices, keptScreenQns) {
-    if (action.kind === "navigate")
-        return isNavigateTargetKept(action, indices, keptScreenQns);
-    if (action.kind === "drawer")
-        return isDrawerTargetKept(feature, action.screen, keptScreenQns);
-    return true;
-}
-function projectRelatedListToolbarActionArray(actions, feature, indices, keptScreenQns) {
-    if (actions === undefined)
-        return undefined;
-    const kept = actions.filter((a) => keepRelatedListToolbarAction(a, feature, indices, keptScreenQns));
-    if (kept.length === actions.length)
-        return actions;
-    return kept.length > 0 ? kept : undefined;
+function projectActionArray(actions, feature, indices, keptScreenQns) {
+    return filterKeptActions(actions, (a) => keepScreenTargetAction(a, feature, indices, keptScreenQns));
 }
 function projectTreeActionArray(actions, keptScreenQns) {
-    if (actions === undefined)
-        return undefined;
-    const kept = actions.filter((a) => keepTreeAction(a, keptScreenQns));
-    if (kept.length === actions.length)
-        return actions;
-    return kept.length > 0 ? kept : undefined;
+    return filterKeptActions(actions, (a) => keepTreeAction(a, keptScreenQns));
 }
 function projectTreeAction(action, keptScreenQns) {
     if (action === undefined)
@@ -329,16 +293,16 @@ function projectEmptyState(emptyState, feature, indices, keptScreenQns) {
         return undefined;
     if (emptyState.action === undefined)
         return emptyState;
-    if (keepRowAction(emptyState.action, feature, indices, keptScreenQns))
+    if (keepScreenTargetAction(emptyState.action, feature, indices, keptScreenQns))
         return emptyState;
     const { action, ...rest } = emptyState;
     return rest;
 }
 function projectRelatedListSection(section, feature, indices, keptScreenQns) {
     const { actions, rowActions, toolbarActions, rowClick, emptyState, ...rest } = section;
-    const nextActions = projectRowActionArray(actions, feature, indices, keptScreenQns);
-    const nextRowActions = projectRowActionArray(rowActions, feature, indices, keptScreenQns);
-    const nextToolbarActions = projectRelatedListToolbarActionArray(toolbarActions, feature, indices, keptScreenQns);
+    const nextActions = projectActionArray(actions, feature, indices, keptScreenQns);
+    const nextRowActions = projectActionArray(rowActions, feature, indices, keptScreenQns);
+    const nextToolbarActions = projectActionArray(toolbarActions, feature, indices, keptScreenQns);
     const nextRowClick = rowClick === undefined || isRowClickEntityKept(rowClick.entity, indices, keptScreenQns)
         ? rowClick
         : undefined;
@@ -365,18 +329,18 @@ function projectEditSection(section, feature, indices, keptScreenQns) {
             return projectRelatedListSection(section, feature, indices, keptScreenQns);
         case "extension": {
             const { actions, ...rest } = section;
-            const kept = projectRowActionArray(actions, feature, indices, keptScreenQns);
+            const kept = projectActionArray(actions, feature, indices, keptScreenQns);
             return kept === actions ? section : { ...rest, ...(kept !== undefined && { actions: kept }) };
         }
         case "writeForm": {
             const { actions, ...rest } = section;
-            const kept = projectRowActionArray(actions, feature, indices, keptScreenQns);
+            const kept = projectActionArray(actions, feature, indices, keptScreenQns);
             return kept === actions ? section : { ...rest, ...(kept !== undefined && { actions: kept }) };
         }
         default: {
             // kind undefined or "fields"
             const { actions, ...rest } = section;
-            const kept = projectRowActionArray(actions, feature, indices, keptScreenQns);
+            const kept = projectActionArray(actions, feature, indices, keptScreenQns);
             return kept === actions ? section : { ...rest, ...(kept !== undefined && { actions: kept }) };
         }
     }
@@ -471,8 +435,8 @@ function dropUnreachableCreateScreen(screen, feature, keptScreenQns) {
 function projectListScreen(original, feature, indices, keptScreenQns) {
     const screen = dropUnreachableCreateScreen(original, feature, keptScreenQns);
     const { rowActions, toolbarActions, ...rest } = screen;
-    const nextRowActions = projectRowActionArray(rowActions, feature, indices, keptScreenQns);
-    const nextToolbarActions = projectToolbarActionArray(toolbarActions, feature, indices, keptScreenQns);
+    const nextRowActions = projectActionArray(rowActions, feature, indices, keptScreenQns);
+    const nextToolbarActions = projectActionArray(toolbarActions, feature, indices, keptScreenQns);
     const expandableRow = screen.type === "entityList" ? screen.expandableRow : undefined;
     const nextExpandableRow = expandableRow === undefined
         ? undefined
@@ -493,7 +457,7 @@ function projectProjectionDetailScreen(screen, feature, indices, keptScreenQns)
     const { metrics, header, actions, layout, listScreenId, ...rest } = screen;
     const nextMetrics = projectMetrics(metrics, indices, keptScreenQns);
     const nextHeader = projectHeader(header, indices, keptScreenQns);
-    const nextActions = projectRowActionArray(actions, feature, indices, keptScreenQns);
+    const nextActions = projectActionArray(actions, feature, indices, keptScreenQns);
     const nextLayout = projectEditLayout(layout, feature, indices, keptScreenQns);
     const nextListScreenId = projectListScreenId(listScreenId, indices, keptScreenQns);
     const unchanged = nextMetrics === metrics &&
@@ -515,7 +479,7 @@ function projectProjectionDetailScreen(screen, feature, indices, keptScreenQns)
 function projectEntityEditScreen(screen, feature, indices, keptScreenQns) {
     const { redirect, actions, layout, listScreenId, ...rest } = screen;
     const nextRedirect = projectRedirect(feature.featureName, redirect, keptScreenQns);
-    const nextActions = projectRowActionArray(actions, feature, indices, keptScreenQns);
+    const nextActions = projectActionArray(actions, feature, indices, keptScreenQns);
     const nextLayout = projectEditLayout(layout, feature, indices, keptScreenQns);
     const nextListScreenId = projectListScreenId(listScreenId, indices, keptScreenQns);
     const unchanged = nextRedirect === redirect &&
@@ -592,7 +556,7 @@ function projectScreen(screen, feature, indices, keptScreenQns) {
         case "dashboard": {
             const { actions, ...rest } = screen;
             const nextPanels = projectDashboardPanels(screen.panels, feature, keptScreenQns);
-            const nextActions = projectRowActionArray(actions, feature, indices, keptScreenQns);
+            const nextActions = projectActionArray(actions, feature, indices, keptScreenQns);
             if (nextPanels === screen.panels && nextActions === actions)
                 return screen;
             return {

package/dist/files/file-handle.js

@@ -10,7 +10,7 @@
 // suffix before the file extension — `foo/bar.jpg` + `"medium-<16 hex>"` →
 // `foo/bar.medium-<16 hex>.jpg`. The suffix must be a `variantSuffix(...)` so
 // the erasure sweep recognizes it. Stable, reversible, no extra lookup tables.
-import { derivativeListPrefix, isDerivativeSuffix } from "../derivatives/variant-key.js";
+import { derivativeListPrefix, isDerivativeSuffix, splitKey } from "../derivatives/variant-key.js";
 import { InternalError } from "../errors/index.js";
 import { assertSafeStorageKey } from "./types.js";
 // `getProvider` is a lazily-resolved, memoized accessor — the provider is
@@ -100,26 +100,13 @@ export function createFileContext(resolve, tenantId, uploadLedger) {
 export function createTenantFileContext(resolver, tenantId) {
     return createFileContext(() => resolver(tenantId), tenantId, resolver.uploadLedgerFor?.(tenantId));
 }
-// Splits a key into the part before the last dot of its last path segment
-// (the "stem") and the extension including the dot. No dot in the last
-// segment: the whole key is the stem, extension is empty.
-function splitKeyExtension(key) {
-    const lastSlash = key.lastIndexOf("/");
-    const lastSegment = lastSlash === -1 ? key : key.slice(lastSlash + 1);
-    const lastDot = lastSegment.lastIndexOf(".");
-    if (lastDot === -1)
-        return { stem: key, ext: "" };
-    const stem = key.slice(0, key.length - lastSegment.length + lastDot);
-    const ext = lastSegment.slice(lastDot);
-    return { stem, ext };
-}
 // Inserts a suffix before the file extension. Keys without an extension get
 // the suffix appended with a dot: `foo/bar` + `"small"` → `foo/bar.small`.
 // Keys with a dot earlier in the path (e.g. `archive.v2/foo.jpg`) correctly
 // split on the LAST segment only.
 export function deriveKey(key, suffix) {
-    const { stem, ext } = splitKeyExtension(key);
-    return ext === "" ? `${key}.${suffix}` : `${stem}.${suffix}${ext}`;
+    const { base, ext } = splitKey(key);
+    return ext === "" ? `${key}.${suffix}` : `${base}.${suffix}${ext}`;
 }
 // The prefix that covers a key AND every `derive()`d variant of it — `foo/bar.jpg` → `foo/bar.`,
 // matching `foo/bar.jpg` and `foo/bar.medium.jpg` alike, since derive() only ever inserts a suffix

package/dist/observability/ids.js

@@ -2,14 +2,7 @@
 // collectors and UIs understand what we emit:
 //   - traceId: 16 random bytes, rendered as 32 lowercase hex chars
 //   - spanId:   8 random bytes, rendered as 16 lowercase hex chars
-function bytesToHex(bytes) {
-    let out = "";
-    for (let i = 0; i < bytes.length; i++) {
-        const b = bytes[i] ?? 0;
-        out += b.toString(16).padStart(2, "0");
-    }
-    return out;
-}
+import { bytesToHex } from "../utils/hex.js";
 export function generateTraceId() {
     const bytes = new Uint8Array(16);
     crypto.getRandomValues(bytes);

package/dist/pipeline/event-retention.js

@@ -68,7 +68,9 @@ export async function pruneEvents(db, options) {
             if (candidates.length === 0) {
                 return { deletedCount: 0, cutoff, aggregateTypes, dryRun };
             }
-            const maxCandidateId = candidates.reduce((acc, row) => (row.id > acc ? row.id : acc), candidates[0]?.id ?? 0n);
+            const maxCandidateId = candidates.reduce(
+            // biome-ignore lint/complexity/useMathMinMax: ids are bigint, Math.max throws a TypeError on BigInt
+            (acc, row) => (row.id > acc ? row.id : acc), candidates[0]?.id ?? 0n);
             // Step 2 — safety guard: check every ACTIVE consumer has moved past
             // the candidate set. Disabled consumers are intentionally excluded —
             // ops disables them precisely to park them while pruning happens.

package/dist/pipeline/projection-rebuild.js

@@ -6,8 +6,9 @@ import { runInSystemRowLevelSecurityScope } from "../db/row-level-security-scope
 import { withoutStatementTimeout } from "../db/statement-timeout.js";
 import { extractTableInfo } from "../db/table-info.js";
 import { withExecutorManagedWrites } from "../db/tenant-db.js";
-import { eventsTable, getEventsHighWaterMark, upcastStoredEvent, } from "../event-store/index.js";
+import { eventsTable, getEventsHighWaterMark, upcastStoredEvent } from "../event-store/index.js";
 import { createRebuildDeadLetterTable, recordRebuildDeadLetters, } from "../event-store/rebuild-dead-letter.js";
+import { toStoredEvent } from "../event-store/row-to-stored-event.js";
 import { createFallbackLogger } from "../logging/utils.js";
 import { emitProjectionRebuild } from "../observability/standard-metrics.js";
 import { projectionStateTable } from "./projection-state.js";
@@ -22,21 +23,6 @@ export const REBUILD_BATCH_SIZE = 1000;
 // live table is held ACCESS EXCLUSIVE).
 const MAX_UNLOCKED_BATCHES = 10_000;
 const DEFAULT_FENCE_LOCK_TIMEOUT_MS = 5_000;
-function rowToStoredEvent(row) {
-    return {
-        id: String(row.id),
-        aggregateId: row.aggregateId,
-        aggregateType: row.aggregateType,
-        tenantId: row.tenantId,
-        version: row.version,
-        type: row.type,
-        eventVersion: row.eventVersion,
-        payload: row.payload,
-        metadata: row.metadata,
-        createdAt: row.createdAt,
-        createdBy: row.createdBy,
-    };
-}
 const TENANT_COLUMN_SUFFIX = ".tenant_id";
 // Ops-facing log line for countColumnDrift's result. No-op when clean.
 function warnOnColumnDrift(projectionName, tableName, drift) {
@@ -93,7 +79,7 @@ async function replayProjectionIntoShadow(projectionName, deps) {
         for (const r of rawEvents) {
             deps.signal?.throwIfAborted();
             const row = coerceRow(r, eventsInfo);
-            const storedEvent = await upcastStoredEvent(rowToStoredEvent(row), upcasters, {
+            const storedEvent = await upcastStoredEvent(toStoredEvent(row), upcasters, {
                 db: tx,
                 tenantId: row.tenantId, // @cast-boundary db-row
             });

package/dist/pipeline/tenant-timezone-cache.js

@@ -8,6 +8,7 @@
 // the write. The TTL below therefore bounds how long OTHER replicas (and
 // writes that bypass that path: migrations, seeds, direct DB edits) keep
 // serving the old value, hence the short default.
+import { createLruCache } from "../utils/lru-cache.js";
 const DEFAULT_TTL_MS = 30 * 1000;
 const DEFAULT_MAX_ENTRIES = 1000;
 export function createTenantTimezoneCache(opts = {}) {
@@ -15,37 +16,17 @@ export function createTenantTimezoneCache(opts = {}) {
     // 0 or negative would never evict (size < max is never true) and grow unbounded.
     const maxEntries = Math.max(1, opts.maxEntries ?? DEFAULT_MAX_ENTRIES);
     const now = opts.now ?? (() => Date.now());
-    // Map insertion order doubles as LRU order: touch = delete+re-insert.
-    const entries = new Map();
+    const entries = createLruCache({
+        maxEntries,
+        ttlMs,
+        now,
+    });
     let generation = 0;
-    function evictOldestIfFull() {
-        // skip: cache has room, nothing to evict
-        if (entries.size < maxEntries)
-            return;
-        const oldestKey = entries.keys().next().value;
-        // skip: defensive — maxEntries >= 1 guarantees a non-empty map here
-        if (oldestKey === undefined)
-            return;
-        entries.delete(oldestKey);
-    }
     function set(tenantId, value) {
-        entries.delete(tenantId);
-        evictOldestIfFull();
-        entries.set(tenantId, { value, expiresAt: now() + ttlMs });
+        entries.set(tenantId, { value });
     }
     return {
-        get(tenantId) {
-            const hit = entries.get(tenantId);
-            if (!hit)
-                return undefined;
-            if (hit.expiresAt <= now()) {
-                entries.delete(tenantId);
-                return undefined;
-            }
-            entries.delete(tenantId);
-            entries.set(tenantId, hit);
-            return { value: hit.value };
-        },
+        get: (tenantId) => entries.get(tenantId),
         set,
         generation() {
             return generation;

package/dist/search/index.d.ts

@@ -1,4 +1,7 @@
+export { collectSearchableFieldNames } from "./configure-tenant-index.ts";
 export { createInMemorySearchAdapter } from "./in-memory-adapter.ts";
+export { isEntitySearchable } from "./is-entity-searchable.ts";
 export { purgeSearchDocumentsForSubject } from "./purge-subject.ts";
 export { reindexEntity } from "./reindex-entity.ts";
+export { type ReindexTenantsSearchOptions, type ReindexTenantsSearchResult, reindexTenantsSearch, } from "./reindex-tenants-search.ts";
 export type { SearchAdapter, SearchAdapterConfig, } from "./types.ts";

package/dist/search/index.js

@@ -2,6 +2,9 @@
 // `@cosmicdrift/kumiko-framework/search/meilisearch`. This keeps the main barrel from loading a
 // Meilisearch client when consumers only use SearchAdapter types, so apps that do not use
 // Meilisearch do not pull in the client code.
+export { collectSearchableFieldNames } from "./configure-tenant-index.js";
 export { createInMemorySearchAdapter } from "./in-memory-adapter.js";
+export { isEntitySearchable } from "./is-entity-searchable.js";
 export { purgeSearchDocumentsForSubject } from "./purge-subject.js";
 export { reindexEntity } from "./reindex-entity.js";
+export { reindexTenantsSearch, } from "./reindex-tenants-search.js";

package/dist/search/is-entity-searchable.d.ts

@@ -0,0 +1,2 @@
+import type { Registry } from "../engine/types/index.ts";
+export declare function isEntitySearchable(registry: Registry, entityName: string): boolean;

package/dist/search/is-entity-searchable.js

@@ -0,0 +1,4 @@
+export function isEntitySearchable(registry, entityName) {
+    return (registry.getSearchableFields(entityName).length > 0 ||
+        registry.getSearchPayloadExtensions(entityName).length > 0);
+}

package/dist/search/meilisearch-peer.js

@@ -1,5 +1,5 @@
 export const MEILISEARCH_PEER = {
     name: "meilisearch",
-    range: "^0.58.0",
+    range: "^0.62.0",
     requiredBy: "@cosmicdrift/kumiko-framework/search/meilisearch",
 };

package/dist/search/reindex-tenants-search.d.ts

@@ -0,0 +1,19 @@
+import type { DbRunner } from "../db/connection.ts";
+import { type Registry, type TenantId } from "../engine/types/index.ts";
+import type { SearchAdapter } from "./types.ts";
+export type ReindexTenantsSearchOptions = {
+    readonly tenantIds: readonly TenantId[];
+    readonly timeoutMs?: number;
+    readonly configureTimeoutMs?: number;
+    readonly dryRun?: boolean;
+    readonly warn?: (message: string) => void;
+};
+export type ReindexTenantsSearchResult = {
+    readonly tenants: number;
+    readonly entities: number;
+    readonly indexedRows: number;
+    readonly failedRows: number;
+    readonly failedReindexes: number;
+    readonly failedConfigures: number;
+};
+export declare function reindexTenantsSearch(db: DbRunner, registry: Registry, searchAdapter: SearchAdapter, options: ReindexTenantsSearchOptions): Promise<ReindexTenantsSearchResult>;