@oh-my-pi/pi-catalog 18.4.0 → 18.4.2

package/src/compat/types.ts

@@ -270,6 +270,8 @@ export interface CompiledCursorParameter {
 /** One provider quota-scope table. */
 export interface CompiledQuotaRule {
 	provider: string;
+	/** Tier used when no exact or fallback membership matches. */
+	defaultTier?: string;
 	tiers: { label: string; models: string[] }[];
 	fallbacks: { label: string; substring: string }[];
 }

package/src/model-cache.ts

@@ -94,7 +94,15 @@ export interface CacheEntry<TApi extends Api = Api> {
 let sharedDb: Database | null = null;
 let sharedDbPath: string | null = null;
 
-const readRowCache = new Map<string, { dataVersion: number; entry: CacheEntry<Api> | null }>();
+interface ReadRowCacheEntry {
+	/** `PRAGMA data_version` of the shared connection when validated; null for per-call connections. */
+	dataVersion: number | null;
+	/** Raw row the entry was parsed from; null when the row was absent or rejected. */
+	row: CacheRow | null;
+	entry: CacheEntry<Api> | null;
+}
+
+const readRowCache = new Map<string, ReadRowCacheEntry>();
 const READ_ROW_CACHE_MAX = 64;
 
 function readCacheKey(resolvedPath: string, providerId: string): string {
@@ -329,67 +337,98 @@ export function readModelCache<TApi extends Api>(
 		// Monotonic change signal: same-shaped WAL overwrites after checkpoint
 		// can leave every size:mtime pair identical, so file metadata alone
 		// cannot invalidate. PRAGMA data_version increments on each committed
-		// write transaction visible to a new reader.
-		const entry = withModelCacheDb(dbPath, db => {
-			const dataVersion = dbDataVersion(db);
-			if (dataVersion !== null) {
-				const cached = readRowCache.get(key);
-				if (cached !== undefined && cached.dataVersion === dataVersion) {
-					// Freshness is time-relative: recompute per call from the
-					// cached row's updatedAt so a long-lived process goes stale.
-					return { hit: true as const, entry: withFreshness(cached.entry as CacheEntry<TApi> | null, ttlMs, now) };
-				}
+		// write transaction visible to a new reader. It is only comparable
+		// across calls on the same connection, so it gates the no-query fast
+		// path for the shared handle only.
+		const shared = dbPath === undefined;
+		return runModelCacheDb(resolvedPath, shared, db => {
+			const dataVersion = shared ? dbDataVersion(db) : null;
+			const cached = readRowCache.get(key);
+			if (dataVersion !== null && cached?.dataVersion === dataVersion) {
+				// Freshness is time-relative: recompute per call from the
+				// cached row's updatedAt so a long-lived process goes stale.
+				return withFreshness(cached.entry as CacheEntry<TApi> | null, ttlMs, now);
 			}
-			const fresh = readRowUncached<TApi>(db, providerId, ttlMs, now);
-			if (dataVersion !== null) {
-				if (readRowCache.size >= READ_ROW_CACHE_MAX) readRowCache.clear();
-				readRowCache.set(key, { dataVersion, entry: fresh as CacheEntry<Api> | null });
+			// Any commit (to any provider's row) bumps data_version. Re-read this
+			// row, but reuse the parsed entry when its bytes are unchanged.
+			const stmt = db.query<CacheRow, [string]>("SELECT * FROM model_cache WHERE provider_id = ?");
+			let row: CacheRow | null;
+			try {
+				row = stmt.get(providerId);
+			} finally {
+				stmt.finalize();
+			}
+			let entry: CacheEntry<TApi> | null;
+			if (
+				cached?.entry &&
+				cached.row &&
+				row &&
+				row.materialization_policy === materializationPolicy() &&
+				cacheRowsEqual(cached.row, row)
+			) {
+				entry = withFreshness(cached.entry as CacheEntry<TApi>, ttlMs, now);
+			} else {
+				entry = parseCacheRow<TApi>(db, providerId, row, ttlMs, now);
 			}
-			return { hit: false as const, entry: fresh };
+			if (readRowCache.size >= READ_ROW_CACHE_MAX) readRowCache.clear();
+			readRowCache.set(key, {
+				dataVersion,
+				row: entry === null ? null : row,
+				entry: entry as CacheEntry<Api> | null,
+			});
+			return entry;
 		});
-		return entry.entry;
 	} catch {
 		return null;
 	}
 }
 
-function readRowUncached<TApi extends Api>(
+function cacheRowsEqual(left: CacheRow, right: CacheRow): boolean {
+	return (
+		left.version === right.version &&
+		left.materialization_policy === right.materialization_policy &&
+		left.updated_at === right.updated_at &&
+		left.authoritative === right.authoritative &&
+		left.static_fingerprint === right.static_fingerprint &&
+		left.header_omitted_model_ids === right.header_omitted_model_ids &&
+		left.unrestorable_header_model_ids === right.unrestorable_header_model_ids &&
+		left.header_restore_version === right.header_restore_version &&
+		left.models === right.models
+	);
+}
+
+function parseCacheRow<TApi extends Api>(
 	db: Database,
 	providerId: string,
+	row: CacheRow | null,
 	ttlMs: number,
 	now: () => number,
 ): CacheEntry<TApi> | null {
-	const stmt = db.query<CacheRow, [string]>("SELECT * FROM model_cache WHERE provider_id = ?");
-	try {
-		const row = stmt.get(providerId);
-		if (!row || row.version !== CACHE_SCHEMA_VERSION || row.materialization_policy !== materializationPolicy()) {
-			return null;
-		}
-		const models = parseMaterializedModels<TApi>(row.models);
-		const headerOmittedModelIds = parseModelIds(row.header_omitted_model_ids);
-		const unrestorableHeaderModelIds = parseModelIds(row.unrestorable_header_model_ids);
-		if (models === null || headerOmittedModelIds === null || unrestorableHeaderModelIds === null) {
-			// Fail closed on corrupt header provenance: treating malformed
-			// markers as empty could return a model with required credentials
-			// silently absent. secure_delete scrubs the rejected payload.
-			db.run("DELETE FROM model_cache WHERE provider_id = ?", [providerId]);
-			return null;
-		}
-		const ageMs = now() - row.updated_at;
-		const fresh = Number.isFinite(ageMs) && ageMs >= 0 && ageMs <= ttlMs;
-		return {
-			models,
-			fresh,
-			authoritative: row.authoritative === 1,
-			updatedAt: row.updated_at,
-			headerOmittedModelIds,
-			unrestorableHeaderModelIds,
-			legacyHeaderRestoreMarkers: row.header_restore_version < HEADER_RESTORE_VERSION,
-			staticFingerprint: row.static_fingerprint ?? "",
-		};
-	} finally {
-		stmt.finalize();
+	if (!row || row.version !== CACHE_SCHEMA_VERSION || row.materialization_policy !== materializationPolicy()) {
+		return null;
 	}
+	const models = parseMaterializedModels<TApi>(row.models);
+	const headerOmittedModelIds = parseModelIds(row.header_omitted_model_ids);
+	const unrestorableHeaderModelIds = parseModelIds(row.unrestorable_header_model_ids);
+	if (models === null || headerOmittedModelIds === null || unrestorableHeaderModelIds === null) {
+		// Fail closed on corrupt header provenance: treating malformed
+		// markers as empty could return a model with required credentials
+		// silently absent. secure_delete scrubs the rejected payload.
+		db.run("DELETE FROM model_cache WHERE provider_id = ?", [providerId]);
+		return null;
+	}
+	const ageMs = now() - row.updated_at;
+	const fresh = Number.isFinite(ageMs) && ageMs >= 0 && ageMs <= ttlMs;
+	return {
+		models,
+		fresh,
+		authoritative: row.authoritative === 1,
+		updatedAt: row.updated_at,
+		headerOmittedModelIds,
+		unrestorableHeaderModelIds,
+		legacyHeaderRestoreMarkers: row.header_restore_version < HEADER_RESTORE_VERSION,
+		staticFingerprint: row.static_fingerprint ?? "",
+	};
 }
 
 /** Whether a live model carries at least one request header. */