@ai-matrx/agents 0.59.186 → 0.59.188

package/dist/models/index.js

@@ -241,13 +241,13 @@ function setModelDiagnosticsSink(sink) {
 }
 function reportModelDiagnostic(dedupeKey, entry) {
   try {
-    const s2 = state();
-    if (s2.reported.has(dedupeKey)) return;
-    s2.reported.add(dedupeKey);
+    const s3 = state();
+    if (s3.reported.has(dedupeKey)) return;
+    s3.reported.add(dedupeKey);
     console.warn(`[parseCapabilities] ${entry.message}`);
-    if (s2.sink) s2.sink(entry);
-    else if (!s2.announced) {
-      s2.announced = true;
+    if (s3.sink) s3.sink(entry);
+    else if (!s3.announced) {
+      s3.announced = true;
       console.error(
         "[@ai-matrx/agents/models] No diagnostics sink is bound \u2014 capability-vocabulary drift reaches the console only. Call setModelDiagnosticsSink(...) with your error store."
       );
@@ -874,29 +874,29 @@ function createModelRecords(config) {
     loadOptions() {
       if (state2.fetchScope === "active" || state2.fetchScope === "all") return Promise.resolve();
       return once("options", async () => {
-        update((s2) => ({ ...s2, isLoading: true, error: null }));
+        update((s3) => ({ ...s3, isLoading: true, error: null }));
         try {
           const rows3 = await readOptions();
-          update((s2) => {
-            const entities = { ...s2.entities };
+          update((s3) => {
+            const entities = { ...s3.entities };
             for (const row of rows3) {
               const existing = entities[row.id];
               if (existing?._fetchType === "full") continue;
               entities[row.id] = { ...emptyRecord(), ...existing, ...row, _fetchType: "options" };
             }
             return withIdLists({
-              ...s2,
+              ...s3,
               entities,
               isLoading: false,
               error: null,
-              fetchScope: s2.fetchScope !== "all" && s2.fetchScope !== "deprecated" ? "active" : s2.fetchScope,
+              fetchScope: s3.fetchScope !== "all" && s3.fetchScope !== "deprecated" ? "active" : s3.fetchScope,
               lastFetched: Date.now()
             });
           });
         } catch (err) {
           const message = messageOf(err);
           errorSink({ code: "model-records-options-load-failed", message });
-          update((s2) => ({ ...s2, isLoading: false, error: message }));
+          update((s3) => ({ ...s3, isLoading: false, error: message }));
         }
       });
     },
@@ -906,10 +906,10 @@ function createModelRecords(config) {
         return inFlight.get(`model:${modelId}`) ?? Promise.resolve();
       }
       return once(`model:${modelId}`, async () => {
-        update((s2) => {
-          const detailErrorById = { ...s2.detailErrorById };
+        update((s3) => {
+          const detailErrorById = { ...s3.detailErrorById };
           delete detailErrorById[modelId];
-          return { ...s2, detailStatusById: { ...s2.detailStatusById, [modelId]: "loading" }, detailErrorById };
+          return { ...s3, detailStatusById: { ...s3.detailStatusById, [modelId]: "loading" }, detailErrorById };
         });
         try {
           const relation = await isSignedIn() ? "model_config" : "model_public";
@@ -926,16 +926,16 @@ function createModelRecords(config) {
             capabilities: requireCanonicalCapabilities(row.capabilities, { modelId: row.id, modelName: row.name })
           };
           const record = normalizeModel(read);
-          update((s2) => {
-            const existing = s2.entities[record.id];
-            const detailErrorById = { ...s2.detailErrorById };
+          update((s3) => {
+            const existing = s3.entities[record.id];
+            const detailErrorById = { ...s3.detailErrorById };
             delete detailErrorById[modelId];
             return withIdLists({
-              ...s2,
-              detailStatusById: { ...s2.detailStatusById, [modelId]: "succeeded" },
+              ...s3,
+              detailStatusById: { ...s3.detailStatusById, [modelId]: "succeeded" },
               detailErrorById,
               entities: {
-                ...s2.entities,
+                ...s3.entities,
                 [record.id]: { ...emptyRecord(), ...existing, ...record, maker: record.maker ?? existing?.maker ?? null, _fetchType: "full" }
               }
             });
@@ -943,21 +943,21 @@ function createModelRecords(config) {
         } catch (err) {
           const message = `Model configuration ${modelId}: ${messageOf(err)}`;
           errorSink({ code: "model-records-model-load-failed", message, context: { modelId } });
-          update((s2) => ({
-            ...s2,
-            detailStatusById: { ...s2.detailStatusById, [modelId]: "failed" },
-            detailErrorById: { ...s2.detailErrorById, [modelId]: message }
+          update((s3) => ({
+            ...s3,
+            detailStatusById: { ...s3.detailStatusById, [modelId]: "failed" },
+            detailErrorById: { ...s3.detailErrorById, [modelId]: message }
           }));
         }
       });
     },
     retryModel(modelId) {
-      update((s2) => {
-        const detailStatusById = { ...s2.detailStatusById };
-        const detailErrorById = { ...s2.detailErrorById };
+      update((s3) => {
+        const detailStatusById = { ...s3.detailStatusById };
+        const detailErrorById = { ...s3.detailErrorById };
         delete detailStatusById[modelId];
         delete detailErrorById[modelId];
-        return { ...s2, detailStatusById, detailErrorById };
+        return { ...s3, detailStatusById, detailErrorById };
       });
     },
     loadClassConfig(modelId, offeringId) {
@@ -965,37 +965,37 @@ function createModelRecords(config) {
       const status = state2.classConfigStatusByOffering[key];
       if (status === "loading" || status === "succeeded") return inFlight.get(`class:${key}`) ?? Promise.resolve();
       return once(`class:${key}`, async () => {
-        update((s2) => ({ ...s2, classConfigStatusByOffering: { ...s2.classConfigStatusByOffering, [key]: "loading" } }));
+        update((s3) => ({ ...s3, classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "loading" } }));
         try {
           const { data, error } = await ai().rpc("resolve_model_config", { p_model_id: modelId, p_offering_id: offeringId });
           if (error) throw error;
           const cfg = data && typeof data === "object" && !Array.isArray(data) ? data : null;
-          update((s2) => ({
-            ...s2,
-            classConfigStatusByOffering: { ...s2.classConfigStatusByOffering, [key]: "succeeded" },
+          update((s3) => ({
+            ...s3,
+            classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "succeeded" },
             classConfigByOffering: {
-              ...s2.classConfigByOffering,
+              ...s3.classConfigByOffering,
               [key]: { modelId, controls: cfg?.controls ?? null, constraints: cfg?.constraints ?? null }
             }
           }));
         } catch (err) {
           errorSink({ code: "model-records-class-config-failed", message: `Model class configuration ${modelId} / ${offeringId}: ${messageOf(err)}` });
-          update((s2) => ({ ...s2, classConfigStatusByOffering: { ...s2.classConfigStatusByOffering, [key]: "failed" } }));
+          update((s3) => ({ ...s3, classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "failed" } }));
         }
       });
     },
     loadClasses() {
       if (state2.modelClassStatus === "loading" || state2.modelClassStatus === "succeeded") return inFlight.get("classes") ?? Promise.resolve();
       return once("classes", async () => {
-        update((s2) => ({ ...s2, modelClassStatus: "loading" }));
+        update((s3) => ({ ...s3, modelClassStatus: "loading" }));
         try {
           const { data, error } = await ai().from("model_offering").select("model_id, offering_id, served_via, served_via_endpoint_id, priority");
           if (error) throw error;
           const index = buildModelClassIndex(data ?? []);
-          update((s2) => ({ ...s2, modelClassStatus: "succeeded", modelClassIndex: index }));
+          update((s3) => ({ ...s3, modelClassStatus: "succeeded", modelClassIndex: index }));
         } catch (err) {
           errorSink({ code: "model-records-classes-failed", message: `Model classes: ${messageOf(err)}` });
-          update((s2) => ({ ...s2, modelClassStatus: "failed" }));
+          update((s3) => ({ ...s3, modelClassStatus: "failed" }));
         }
       });
     },
@@ -1010,11 +1010,11 @@ function createModelRecords(config) {
           if (error) throw error;
           const slice = buildModelClassIndex(data ?? []);
           classesReadFor.add(modelId);
-          update((s2) => {
-            if (s2.modelClassStatus === "succeeded") return s2;
-            const base = s2.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
+          update((s3) => {
+            if (s3.modelClassStatus === "succeeded") return s3;
+            const base = s3.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
             return {
-              ...s2,
+              ...s3,
               modelClassIndex: {
                 classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId },
                 classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering }
@@ -1032,20 +1032,20 @@ function createModelRecords(config) {
         return inFlight.get(`identity:${modelId}`) ?? Promise.resolve();
       }
       return once(`identity:${modelId}`, async () => {
-        update((s2) => ({ ...s2, identityStatusById: { ...s2.identityStatusById, [modelId]: "loading" } }));
+        update((s3) => ({ ...s3, identityStatusById: { ...s3.identityStatusById, [modelId]: "loading" } }));
         try {
           const { data, error } = await ai().from("model_definition").select("id, name, common_name, is_deprecated").eq("id", modelId).maybeSingle();
           if (error) throw error;
           if (!data) throw new Error(`AI model ${modelId} is not available (ai.model_definition has no such row)`);
           const row = data;
-          update((s2) => ({
-            ...s2,
-            identityById: { ...s2.identityById, [row.id]: row },
-            identityStatusById: { ...s2.identityStatusById, [row.id]: "succeeded" }
+          update((s3) => ({
+            ...s3,
+            identityById: { ...s3.identityById, [row.id]: row },
+            identityStatusById: { ...s3.identityStatusById, [row.id]: "succeeded" }
           }));
         } catch (err) {
           errorSink({ code: "model-records-identity-failed", message: messageOf(err), context: { modelId } });
-          update((s2) => ({ ...s2, identityStatusById: { ...s2.identityStatusById, [modelId]: "failed" } }));
+          update((s3) => ({ ...s3, identityStatusById: { ...s3.identityStatusById, [modelId]: "failed" } }));
         }
       });
     },
@@ -1054,11 +1054,11 @@ function createModelRecords(config) {
       if (!classesReadFor.has(modelId) && state2.modelClassStatus !== "succeeded") {
         const slice = buildModelClassIndex(offerings.filter((o) => o.model_id === modelId));
         classesReadFor.add(modelId);
-        update((s2) => {
-          if (s2.modelClassStatus === "succeeded") return s2;
-          const base = s2.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
+        update((s3) => {
+          if (s3.modelClassStatus === "succeeded") return s3;
+          const base = s3.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
           return {
-            ...s2,
+            ...s3,
             modelClassIndex: {
               classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId },
               classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering }
@@ -1077,16 +1077,16 @@ function createModelRecords(config) {
           controls: row.controls ?? null,
           capabilities: requireCanonicalCapabilities(row.capabilities, { modelId: row.id, modelName: row.name })
         });
-        update((s2) => {
-          const existing = s2.entities[record.id];
-          const detailErrorById = { ...s2.detailErrorById };
+        update((s3) => {
+          const existing = s3.entities[record.id];
+          const detailErrorById = { ...s3.detailErrorById };
           delete detailErrorById[modelId];
           return withIdLists({
-            ...s2,
-            detailStatusById: { ...s2.detailStatusById, [modelId]: "succeeded" },
+            ...s3,
+            detailStatusById: { ...s3.detailStatusById, [modelId]: "succeeded" },
             detailErrorById,
             entities: {
-              ...s2.entities,
+              ...s3.entities,
               [record.id]: { ...emptyRecord(), ...existing, ...record, maker: record.maker ?? existing?.maker ?? null, _fetchType: "full" }
             }
           });
@@ -1096,14 +1096,14 @@ function createModelRecords(config) {
       }
     },
     hydrate({ models, fetchType, fetchScope, lastFetched }) {
-      update((s2) => {
-        const entities = { ...s2.entities };
+      update((s3) => {
+        const entities = { ...s3.entities };
         for (const raw of models) {
           const existing = entities[raw.id];
           if (existing?._fetchType === "full" && fetchType === "options") continue;
           entities[raw.id] = { ...emptyRecord(), ...normalizeModel({ ...raw, controls: raw.controls ?? null }), _fetchType: fetchType };
         }
-        return withIdLists({ ...s2, entities, fetchScope, lastFetched, isLoading: false, error: null });
+        return withIdLists({ ...s3, entities, fetchScope, lastFetched, isLoading: false, error: null });
       });
     }
   };
@@ -1122,28 +1122,28 @@ function memo(fn) {
 var UNSET = /* @__PURE__ */ Symbol("unset");
 var activeKey = null;
 var activeOut = [];
-function selectActiveModels(s2) {
-  if (!activeKey || activeKey[0] !== s2.entities || activeKey[1] !== s2.activeIds) {
-    activeKey = [s2.entities, s2.activeIds];
-    activeOut = s2.activeIds.map((id) => s2.entities[id]).filter((m) => !!m);
+function selectActiveModels(s3) {
+  if (!activeKey || activeKey[0] !== s3.entities || activeKey[1] !== s3.activeIds) {
+    activeKey = [s3.entities, s3.activeIds];
+    activeOut = s3.activeIds.map((id) => s3.entities[id]).filter((m) => !!m);
   }
   return activeOut;
 }
 var deprecatedKey = null;
 var deprecatedOut = [];
-function selectDeprecatedModels(s2) {
-  if (!deprecatedKey || deprecatedKey[0] !== s2.entities || deprecatedKey[1] !== s2.deprecatedIds) {
-    deprecatedKey = [s2.entities, s2.deprecatedIds];
-    deprecatedOut = s2.deprecatedIds.map((id) => s2.entities[id]).filter((m) => !!m);
+function selectDeprecatedModels(s3) {
+  if (!deprecatedKey || deprecatedKey[0] !== s3.entities || deprecatedKey[1] !== s3.deprecatedIds) {
+    deprecatedKey = [s3.entities, s3.deprecatedIds];
+    deprecatedOut = s3.deprecatedIds.map((id) => s3.entities[id]).filter((m) => !!m);
   }
   return deprecatedOut;
 }
 var allOf = memo((entities) => Object.values(entities));
-var selectAllModels = (s2) => allOf(s2.entities);
+var selectAllModels = (s3) => allOf(s3.entities);
 var optionsOf = memo(
   (models) => models.map((m) => ({ value: m.id, label: m.common_name || m.name || m.id, maker: m.maker, costRating: m.cost_rating, speedRating: m.speed_rating }))
 );
-var selectModelOptions = (s2) => optionsOf(selectActiveModels(s2));
+var selectModelOptions = (s3) => optionsOf(selectActiveModels(s3));
 var allOptionsOf = memo(
   (entities) => Object.values(entities).map((m) => ({
     value: m.id,
@@ -1154,30 +1154,30 @@ var allOptionsOf = memo(
     successorId: m.successor_id ?? null
   }))
 );
-var selectAllModelOptions = (s2) => allOptionsOf(s2.entities);
-var selectModelById = (s2, modelId) => modelId ? s2.entities[modelId] : void 0;
-function selectModelLabelById(s2, modelId) {
+var selectAllModelOptions = (s3) => allOptionsOf(s3.entities);
+var selectModelById = (s3, modelId) => modelId ? s3.entities[modelId] : void 0;
+function selectModelLabelById(s3, modelId) {
   if (!modelId) return void 0;
-  const m = s2.entities[modelId];
-  const identity = s2.identityById[modelId];
+  const m = s3.entities[modelId];
+  const identity = s3.identityById[modelId];
   return m?.common_name || m?.name || identity?.common_name || identity?.name || void 0;
 }
-var selectModelNameById = (s2, modelId) => modelId ? s2.entities[modelId]?.name : void 0;
-var selectModelClassName = (s2, modelId, offeringId) => modelClassName(s2.modelClassIndex, modelId, offeringId);
-function selectModelLabelWithClass(s2, modelId, offeringId) {
-  const label = selectModelLabelById(s2, modelId);
-  return label ? withModelClass(label, selectModelClassName(s2, modelId, offeringId)) : void 0;
-}
-var selectModelControls = (s2, modelId) => s2.entities[modelId]?.controls;
-var selectModelFetchType = (s2, modelId) => s2.entities[modelId]?._fetchType;
-var selectModelFullyLoaded = (s2, modelId) => !!modelId && s2.entities[modelId]?._fetchType === "full";
-var selectModelDetailError = (s2, modelId) => modelId && s2.detailErrorById[modelId] || null;
-var selectModelClassConfig = (s2, modelId, offeringId) => modelId && offeringId ? s2.classConfigByOffering[classConfigKey(modelId, offeringId)] : void 0;
-var selectActiveModelsReady = (s2) => (s2.fetchScope === "active" || s2.fetchScope === "all") && s2.activeIds.length > 0;
-var selectDeprecatedModelsReady = (s2) => (s2.fetchScope === "deprecated" || s2.fetchScope === "all") && s2.deprecatedIds.length > 0;
-var selectAllModelsReady = (s2) => s2.fetchScope === "all";
-var selectModelIdentityById = (s2, modelId) => s2.identityById[modelId];
-var selectModelIdentityLookupStatus = (s2, modelId) => s2.identityStatusById[modelId] ?? "idle";
+var selectModelNameById = (s3, modelId) => modelId ? s3.entities[modelId]?.name : void 0;
+var selectModelClassName = (s3, modelId, offeringId) => modelClassName(s3.modelClassIndex, modelId, offeringId);
+function selectModelLabelWithClass(s3, modelId, offeringId) {
+  const label = selectModelLabelById(s3, modelId);
+  return label ? withModelClass(label, selectModelClassName(s3, modelId, offeringId)) : void 0;
+}
+var selectModelControls = (s3, modelId) => s3.entities[modelId]?.controls;
+var selectModelFetchType = (s3, modelId) => s3.entities[modelId]?._fetchType;
+var selectModelFullyLoaded = (s3, modelId) => !!modelId && s3.entities[modelId]?._fetchType === "full";
+var selectModelDetailError = (s3, modelId) => modelId && s3.detailErrorById[modelId] || null;
+var selectModelClassConfig = (s3, modelId, offeringId) => modelId && offeringId ? s3.classConfigByOffering[classConfigKey(modelId, offeringId)] : void 0;
+var selectActiveModelsReady = (s3) => (s3.fetchScope === "active" || s3.fetchScope === "all") && s3.activeIds.length > 0;
+var selectDeprecatedModelsReady = (s3) => (s3.fetchScope === "deprecated" || s3.fetchScope === "all") && s3.deprecatedIds.length > 0;
+var selectAllModelsReady = (s3) => s3.fetchScope === "all";
+var selectModelIdentityById = (s3, modelId) => s3.identityById[modelId];
+var selectModelIdentityLookupStatus = (s3, modelId) => s3.identityStatusById[modelId] ?? "idle";
 
 // models/catalog/store.ts
 var IDLE = { status: "idle", models: [], error: null, loadedAt: null };
@@ -1452,9 +1452,9 @@ function createModelCatalog(config) {
       };
     },
     load(variant) {
-      const s2 = state2[variant];
-      if (s2.status === "idle" || s2.status === "error") return run(variant);
-      if (s2.status === "ready" && s2.loadedAt !== null && Date.now() - s2.loadedAt > staleAfterMs) return run(variant);
+      const s3 = state2[variant];
+      if (s3.status === "idle" || s3.status === "error") return run(variant);
+      if (s3.status === "ready" && s3.loadedAt !== null && Date.now() - s3.loadedAt > staleAfterMs) return run(variant);
       return inFlight[variant] ?? Promise.resolve();
     },
     reload: (variant) => run(variant)
@@ -1639,9 +1639,9 @@ function placement(v, runtimes, device) {
   }
   return "not_compatible";
 }
-function formatMemoryBytes(n) {
-  const g = n / 2 ** 30;
-  if (g < 1) return `${Math.max(1, Math.round(n / 2 ** 20))} MB`;
+function formatMemoryBytes(n2) {
+  const g = n2 / 2 ** 30;
+  if (g < 1) return `${Math.max(1, Math.round(n2 / 2 ** 20))} MB`;
   return `${g < 10 ? Math.round(g * 10) / 10 : Math.round(g)} GB`;
 }
 function describe(c, decided, runnerUp, device) {
@@ -1933,41 +1933,41 @@ var Cursor = class {
     this.read = read;
     this.size = size;
   }
-  async need(n) {
-    if (this.pos + n > this.size) throw new GgufError("the file ends inside its header");
-    if (this.pos + n > MAX_HEADER) throw new GgufError("its header is larger than any real model's");
-    if (this.pos >= this.base && this.pos + n <= this.base + this.buf.length) return;
-    const len = Math.min(Math.max(n, CHUNK), this.size - this.pos);
+  async need(n2) {
+    if (this.pos + n2 > this.size) throw new GgufError("the file ends inside its header");
+    if (this.pos + n2 > MAX_HEADER) throw new GgufError("its header is larger than any real model's");
+    if (this.pos >= this.base && this.pos + n2 <= this.base + this.buf.length) return;
+    const len = Math.min(Math.max(n2, CHUNK), this.size - this.pos);
     this.buf = await this.read(this.pos, len);
     this.base = this.pos;
-    if (this.buf.length < n) throw new GgufError("the file ends inside its header");
+    if (this.buf.length < n2) throw new GgufError("the file ends inside its header");
   }
-  async view(n) {
-    await this.need(n);
-    const v = new DataView(this.buf.buffer, this.buf.byteOffset + (this.pos - this.base), n);
-    this.pos += n;
+  async view(n2) {
+    await this.need(n2);
+    const v = new DataView(this.buf.buffer, this.buf.byteOffset + (this.pos - this.base), n2);
+    this.pos += n2;
     return v;
   }
   async u32() {
     return (await this.view(4)).getUint32(0, true);
   }
   async u64() {
-    const n = (await this.view(8)).getBigUint64(0, true);
-    if (n > BigInt(Number.MAX_SAFE_INTEGER)) throw new GgufError("a size in its header is out of range");
-    return Number(n);
+    const n2 = (await this.view(8)).getBigUint64(0, true);
+    if (n2 > BigInt(Number.MAX_SAFE_INTEGER)) throw new GgufError("a size in its header is out of range");
+    return Number(n2);
   }
   async str() {
     const len = await this.u64();
     if (len > MAX_STRING) throw new GgufError("a text value in its header is out of range");
     await this.need(len);
     const at = this.pos - this.base;
-    const s2 = new TextDecoder().decode(this.buf.subarray(at, at + len));
+    const s3 = new TextDecoder().decode(this.buf.subarray(at, at + len));
     this.pos += len;
-    return s2;
+    return s3;
   }
-  async skip(n) {
-    if (this.pos + n > this.size) throw new GgufError("the file ends inside its header");
-    this.pos += n;
+  async skip(n2) {
+    if (this.pos + n2 > this.size) throw new GgufError("the file ends inside its header");
+    this.pos += n2;
   }
   async scalar(type) {
     switch (type) {
@@ -2019,11 +2019,11 @@ async function readGgufHeader(read, size) {
     const type = await c.u32();
     if (type === 9) {
       const elem = await c.u32();
-      const n = await c.u64();
-      if (n > 64 * MAX_COUNT) throw new GgufError("an array in its header is out of range");
-      arrays[key] = n;
-      if (elem === 8) for (let j = 0; j < n; j++) await c.str();
-      else if (SCALAR_BYTES[elem] !== void 0) await c.skip(n * SCALAR_BYTES[elem]);
+      const n2 = await c.u64();
+      if (n2 > 64 * MAX_COUNT) throw new GgufError("an array in its header is out of range");
+      arrays[key] = n2;
+      if (elem === 8) for (let j = 0; j < n2; j++) await c.str();
+      else if (SCALAR_BYTES[elem] !== void 0) await c.skip(n2 * SCALAR_BYTES[elem]);
       else throw new GgufError(`its header has an array of unknown type ${elem}`);
     } else kv[key] = await c.scalar(type);
   }
@@ -2053,20 +2053,20 @@ async function readGgufHeader(read, size) {
   return { version, kv, array_lengths: arrays, tensors, data_offset: dataOffset, data_end: end };
 }
 function ggufFacts(h) {
-  const s2 = (k) => typeof h.kv[k] === "string" ? h.kv[k] : null;
-  const n = (k) => typeof h.kv[k] === "number" ? h.kv[k] : null;
-  const arch = s2("general.architecture");
-  const ft = n("general.file_type");
+  const s3 = (k) => typeof h.kv[k] === "string" ? h.kv[k] : null;
+  const n2 = (k) => typeof h.kv[k] === "number" ? h.kv[k] : null;
+  const arch = s3("general.architecture");
+  const ft = n2("general.file_type");
   const params = h.tensors.reduce((t, x) => t + x.dims.reduce((a, b) => a * b, 1), 0);
   return {
     architecture: arch,
-    name: s2("general.name"),
+    name: s3("general.name"),
     quant: ft !== null ? FILE_TYPE_QUANT[ft] ?? `FTYPE_${ft}` : null,
-    context_length: arch ? n(`${arch}.context_length`) : null,
+    context_length: arch ? n2(`${arch}.context_length`) : null,
     parameter_count: params > 0 ? params : null,
-    split_count: n("split.count") ?? 1,
-    split_index: n("split.no") ?? 0,
-    type: s2("general.type"),
+    split_count: n2("split.count") ?? 1,
+    split_index: n2("split.no") ?? 0,
+    type: s3("general.type"),
     has_tokenizer: typeof h.kv["tokenizer.ggml.model"] === "string"
   };
 }
@@ -2107,16 +2107,16 @@ var isHelperGguf = (name) => HELPER_RE.test(name);
 var isProjectorName = (name) => name.toLowerCase().includes("mmproj");
 var quantFromName = (name) => QUANT_RE.exec(name.split("/").pop() ?? name)?.[1]?.toUpperCase() ?? null;
 function splitSetProblems(names) {
-  const shards = names.map(shardName).filter((s2) => s2 !== null);
+  const shards = names.map(shardName).filter((s3) => s3 !== null);
   if (!shards.length) return [];
-  const counts = [...new Set(shards.map((s2) => s2.count))];
+  const counts = [...new Set(shards.map((s3) => s3.count))];
   if (counts.length !== 1) return [`its parts disagree on how many parts there are (${counts.sort((a, b) => a - b).join(", ")})`];
-  const n = counts[0];
-  const have = shards.map((s2) => s2.index);
-  const missing = Array.from({ length: n }, (_, i) => i + 1).filter((i) => !have.includes(i));
+  const n2 = counts[0];
+  const have = shards.map((s3) => s3.index);
+  const missing = Array.from({ length: n2 }, (_, i) => i + 1).filter((i) => !have.includes(i));
   const dupes = [...new Set(have.filter((i, k) => have.indexOf(i) !== k))].sort((a, b) => a - b);
   const out = [];
-  if (missing.length) out.push(`part${missing.length === 1 ? "" : "s"} ${missing.map((i) => `${i} of ${n}`).join(", ")} ${missing.length === 1 ? "is" : "are"} missing`);
+  if (missing.length) out.push(`part${missing.length === 1 ? "" : "s"} ${missing.map((i) => `${i} of ${n2}`).join(", ")} ${missing.length === 1 ? "is" : "are"} missing`);
   if (dupes.length) out.push(`part${dupes.length === 1 ? "" : "s"} ${dupes.join(", ")} appear${dupes.length === 1 ? "s" : ""} twice`);
   return out;
 }
@@ -2160,8 +2160,8 @@ async function validateModelSet(primary, siblings, env) {
   let parts = [primary];
   if (shard) {
     if (shard.index !== 1) return { ok: false, reason: `This is part ${shard.index} of ${shard.count} of a split model; add its first part, ${shardFileName(shard.stem, 1, shard.count)}.` };
-    const same = [primary, ...siblings.filter((s2) => s2 !== primary && shardName(s2.name)?.stem === shard.stem)];
-    const problems = splitSetProblems(same.map((s2) => s2.name));
+    const same = [primary, ...siblings.filter((s3) => s3 !== primary && shardName(s3.name)?.stem === shard.stem)];
+    const problems = splitSetProblems(same.map((s3) => s3.name));
     if (problems.length) return { ok: false, reason: `It is a model in ${shard.count} parts and ${problems.join("; ")} (every part has to be in the same folder).` };
     parts = same.sort((a, b) => (shardName(a.name)?.index ?? 0) - (shardName(b.name)?.index ?? 0));
   }
@@ -2194,7 +2194,7 @@ async function validateModelSet(primary, siblings, env) {
     if (end !== null && p.size < end) return { ok: false, reason: `${parts.length > 1 ? `Part ${i + 1} of ${parts.length} is incomplete` : "The file is incomplete"}: it is ${formatMemoryBytes(p.size)} and its header says ${formatMemoryBytes(end)} (a download that stopped early?).` };
   }
   const quant = f.quant ?? quantFromName(primary.name) ?? "unknown";
-  const projectorFiles = siblings.filter((s2) => s2 !== primary && extOf(s2.name) === ".gguf" && isProjectorName(s2.name));
+  const projectorFiles = siblings.filter((s3) => s3 !== primary && extOf(s3.name) === ".gguf" && isProjectorName(s3.name));
   const pickedName = pickProjector(quant === "unknown" ? null : quant, projectorFiles.map((p) => p.name));
   let projector = null;
   const picked = projectorFiles.find((p) => p.name === pickedName);
@@ -2259,12 +2259,13 @@ async function rows2(client, table) {
   if (error) throw new Error(`ai.${table}: ${error.message}`);
   return (data ?? []).filter(live);
 }
+var EXCLUDED_REVIEW_STATES = /* @__PURE__ */ new Set(["rejected", "withdrawn"]);
+var isListedVariant = (v) => live(v) && !EXCLUDED_REVIEW_STATES.has(s(v.review_state));
 function shapeCuratedModels(input) {
   const providerName = new Map(input.providers.map((p) => [s(p.id), sn(p.name)]));
   const presentationOf = new Map(input.presentations.filter(live).map((p) => [s(p.model_id), p]));
   const variantsOf = /* @__PURE__ */ new Map();
-  for (const v of input.variants.filter(live)) {
-    if (s(v.review_state) === "dismissed") continue;
+  for (const v of input.variants.filter(isListedVariant)) {
     const meta = v.metadata ?? {};
     const list = variantsOf.get(s(v.model_id)) ?? [];
     list.push({
@@ -2297,23 +2298,239 @@ function shapeCuratedModels(input) {
     };
   });
 }
-async function fetchCuratedModels(client) {
+async function readCuratedRows(client) {
   const [models, variants, presentations, providers] = await Promise.all([
     rows2(client, "model_definition"),
     rows2(client, "model_variant"),
     rows2(client, "model_presentation"),
     rows2(client, "provider")
   ]);
-  return shapeCuratedModels({ models, variants, presentations, providers });
+  return { models, variants, presentations, providers };
+}
+async function fetchCuratedModels(client) {
+  return shapeCuratedModels(await readCuratedRows(client));
 }
 function curatedList(models, { offeredOnly }) {
   return orderCatalogModels(offeredOnly ? models.filter((m) => m.offered) : models);
 }
+
+// models/catalog-reader.ts
+import { sha256Hex } from "@ai-matrx/kit/sha256";
+var MODEL_CATALOG_KINDS = /* @__PURE__ */ new Set([
+  "llm_model",
+  "whisper_model",
+  "tts_model_file",
+  "image_gen_model",
+  "video_gen_model",
+  "ner_model",
+  "wake_word_model",
+  "lora"
+]);
+function catalogKindOf(m, kindOfEntry) {
+  for (const v of m.variants)
+    for (const id of v.catalog_entry_ids ?? []) {
+      const k = kindOfEntry.get(id);
+      if (k && MODEL_CATALOG_KINDS.has(k)) return k;
+    }
+  const out = m.capabilities.output ?? [];
+  const inp = m.capabilities.input ?? [];
+  if (m.presentation?.shelf === "loras") return "lora";
+  if (out.includes("video")) return "video_gen_model";
+  if (out.includes("image")) return "image_gen_model";
+  if (out.includes("audio")) return "tts_model_file";
+  if (inp.includes("audio")) return "whisper_model";
+  if (m.capabilities.interaction === "extraction") return "ner_model";
+  return "llm_model";
+}
+function canonicalJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  const entries = Object.entries(value).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  return `{${entries.map(([k, v]) => `${JSON.stringify(k)}:${canonicalJson(v)}`).join(",")}}`;
+}
+function catalogFingerprint(catalog) {
+  const { catalog_fingerprint: _omit, ...rest } = catalog;
+  return sha256Hex(canonicalJson(rest));
+}
+var s2 = (v) => typeof v === "string" ? v : "";
+var sn2 = (v) => typeof v === "string" ? v : null;
+var n = (v) => typeof v === "number" && Number.isFinite(v) ? v : typeof v === "string" && v.trim() !== "" && Number.isFinite(Number(v)) ? Number(v) : null;
+var live2 = (r) => r.deleted_at == null;
+var byCodepoint2 = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var byId = (rows3) => new Map(rows3.map((r) => [s2(r.id), r]));
+var strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+async function readModelCatalog(client, opts = {}) {
+  const db = client;
+  const offeredOnly = opts.offeredOnly ?? true;
+  const ai = db.schema("ai");
+  const all = async (table, filter = (q) => q) => {
+    const { data, error } = await filter(ai.from(table).select("*").is("deleted_at", null));
+    if (error) throw new Error(`ai.${table}: ${error.message}`);
+    return (data ?? []).filter(live2);
+  };
+  const [raw, upstreams, runtimes, builds, compat] = await Promise.all([
+    readCuratedRows(client),
+    all("model_upstream"),
+    all("runtime"),
+    all("runtime_build"),
+    all("runtime_compat")
+  ]);
+  const curated = curatedList(shapeCuratedModels(raw), { offeredOnly });
+  const listed = new Set(curated.map((m) => m.id));
+  const variants = raw.variants.filter((v) => listed.has(s2(v.model_id)) && (offeredOnly ? s2(v.review_state) === "offered" : isListedVariant(v)));
+  const entryIds = [...new Set(curated.flatMap((m) => m.variants.flatMap((v) => v.catalog_entry_ids)))].sort(byCodepoint2);
+  const warnings = [];
+  const [artifacts, entries] = await Promise.all([
+    variants.length ? all("model_artifact", (q) => q.in("variant_id", variants.map((v) => s2(v.id)))) : Promise.resolve([]),
+    entryIds.length ? Promise.resolve(db.schema("public").from("catalog_entries").select("id,kind").in("id", entryIds)).then(({ data, error }) => {
+      if (error) {
+        warnings.push(`public.catalog_entries: ${error.message} (models placed by what they do)`);
+        return [];
+      }
+      return data ?? [];
+    }) : Promise.resolve([])
+  ]);
+  const kindOfEntry = new Map(entries.map((e) => [s2(e.id), s2(e.kind)]));
+  const stamps = [];
+  const stamp = (r) => {
+    if (r && typeof r.updated_at === "string") stamps.push(r.updated_at);
+  };
+  const modelById = byId(raw.models);
+  const providerById = byId(raw.providers);
+  const upstreamById = byId(upstreams);
+  const presentationOf = new Map(raw.presentations.map((p) => [s2(p.model_id), p]));
+  const models = curated.flatMap((c) => {
+    const m = modelById.get(c.id);
+    if (!m) return [];
+    stamp(m);
+    const p = presentationOf.get(c.id);
+    stamp(p);
+    const maker = providerById.get(s2(m.provider_id));
+    return [
+      {
+        id: s2(m.id),
+        name: s2(m.name),
+        desktop_id: sn2(m.metadata?.desktop_id),
+        common_name: sn2(m.common_name),
+        maker: sn2(maker?.name),
+        maker_logo_file_id: sn2(maker?.logo_file_id),
+        description: sn2(m.description),
+        capabilities: m.capabilities ?? {},
+        kind: catalogKindOf(c, kindOfEntry),
+        offered: c.offered,
+        updated_at: c.updated_at,
+        presentation: p ? {
+          summary: sn2(p.summary),
+          symbol: sn2(p.symbol),
+          color: sn2(p.color),
+          shelf: sn2(p.shelf),
+          shelf_title: sn2(p.shelf_title),
+          shelf_subtitle: sn2(p.shelf_subtitle),
+          display_order: n(p.display_order),
+          page: sn2(p.page),
+          params_label: sn2(p.params_label),
+          tags: strings(p.tags),
+          links: Array.isArray(p.links) ? p.links : [],
+          thumbnail_file_id: sn2(p.thumbnail_file_id),
+          hero_file_id: sn2(p.hero_file_id),
+          gallery_file_ids: strings(p.gallery_file_ids).filter((f) => f.length > 0),
+          facts: p.facts && typeof p.facts === "object" && !Array.isArray(p.facts) ? p.facts : {}
+        } : null,
+        variants: variants.filter((v) => s2(v.model_id) === c.id).sort((a, b) => byCodepoint2(s2(a.key), s2(b.key))).map((v) => {
+          stamp(v);
+          const up = upstreamById.get(s2(v.upstream_id));
+          stamp(up);
+          const arts = artifacts.filter((a) => s2(a.variant_id) === s2(v.id)).sort((a, b) => (n(a.shard_index) ?? 0) - (n(b.shard_index) ?? 0) || byCodepoint2(s2(a.path_in_repo), s2(b.path_in_repo)));
+          arts.forEach(stamp);
+          return {
+            id: s2(v.id),
+            key: s2(v.key),
+            catalog_key: `${s2(m.name)}/${s2(v.key)}`,
+            review_state: s2(v.review_state),
+            catalog_entry_ids: strings(v.metadata?.catalog_entry_ids),
+            is_default: v.is_default === true,
+            format: s2(v.format),
+            quant: s2(v.quant),
+            architecture: s2(v.architecture),
+            chat_template_kind: s2(v.chat_template_kind),
+            os_arch: strings(v.os_arch),
+            selection_rank: n(v.selection_rank) ?? Number.MAX_SAFE_INTEGER,
+            // internal-bound: a row with no rank sorts last (the column is NOT NULL; this only orders a malformed row)
+            license: sn2(v.license_id),
+            gated: s2(v.gated),
+            total_bytes: n(v.total_bytes),
+            memory_bytes_min: n(v.memory_bytes_min),
+            memory_bytes_recommended: n(v.memory_bytes_recommended),
+            tested_on_current_runtime: v.tested_on_current_runtime === true,
+            min_app_version: sn2(v.min_app_version),
+            upstream: up ? { kind: s2(up.upstream_kind), repo: sn2(up.repo), revision: sn2(up.revision) } : null,
+            artifacts: arts.map((a) => ({
+              role: s2(a.role),
+              path: s2(a.path_in_repo),
+              url: s2(a.url),
+              size_bytes: n(a.size_bytes) ?? 0,
+              sha256: s2(a.sha256),
+              required_for: strings(a.required_for).sort(),
+              shard_index: n(a.shard_index),
+              shard_count: n(a.shard_count)
+            }))
+          };
+        })
+      }
+    ];
+  });
+  const out = {
+    $schema: "matrx.model-catalog.snapshot/v1",
+    catalog_updated_at: "",
+    models,
+    runtimes: runtimes.sort((a, b) => byCodepoint2(s2(a.key), s2(b.key))).map((rt) => {
+      stamp(rt);
+      return {
+        key: s2(rt.key),
+        name: s2(rt.name),
+        upstream_repo: sn2(rt.upstream_repo),
+        builds: builds.filter((b) => s2(b.runtime_id) === s2(rt.id)).map((b) => {
+          stamp(b);
+          const known = b.metadata?.known_architectures;
+          return {
+            id: s2(b.id),
+            version: s2(b.runtime_version),
+            os: s2(b.os),
+            arch: s2(b.arch),
+            accelerator: s2(b.accelerator),
+            build_kind: s2(b.build_kind),
+            url: sn2(b.url),
+            size_bytes: n(b.size_bytes),
+            sha256: sn2(b.sha256),
+            is_active: b.is_active === true,
+            min_app_version: sn2(b.min_app_version),
+            // The architectures this pinned llama-server build loads (runtime_build.metadata): the own-model judge reads it.
+            known_architectures: Array.isArray(known) ? known.map(String).sort() : null,
+            compat: compat.filter((c) => s2(c.runtime_build_id) === s2(b.id)).map((c) => ({
+              hardware_class: s2(c.hardware_class),
+              format: s2(c.format),
+              quant: s2(c.quant),
+              architecture: s2(c.architecture),
+              chat_template_kind: s2(c.chat_template_kind),
+              status: s2(c.status)
+            }))
+          };
+        })
+      };
+    })
+  };
+  out.catalog_updated_at = stamps.sort().at(-1) ?? "";
+  if (warnings.length) out.warnings = warnings;
+  out.catalog_fingerprint = catalogFingerprint(out);
+  return out;
+}
 export {
   CHAT_DEFAULT_MODEL_KNOB,
   CONTENT_TYPES,
   DEFAULT_CAPABILITIES,
   EMPTY_MODEL_RECORDS,
+  EXCLUDED_REVIEW_STATES,
   FEATURE_BUCKETS,
   FEATURE_BUCKET_ORDER,
   FEATURE_KEYS,
@@ -2322,6 +2539,7 @@ export {
   INPUT_MODALITIES,
   INTERACTION_MODES,
   MAX_SUCCESSION_HOPS,
+  MODEL_CATALOG_KINDS,
   MODEL_FAVORITE_ENTITY_TYPE,
   OUTPUT_MODALITIES,
   SERVICE_LABEL,
@@ -2331,7 +2549,9 @@ export {
   acceptsTextInstructions,
   buildModelClassIndex,
   buildSuccessionIndex,
+  catalogFingerprint,
   catalogForApp,
+  catalogKindOf,
   classConfigKey,
   collapseTiersByClass,
   costRatingTier,
@@ -2359,6 +2579,7 @@ export {
   isFeatureKey,
   isHelperGguf,
   isInteractionMode,
+  isListedVariant,
   isLocalModelCatalog,
   isManagedAgentModelCapability,
   isProjectorName,
@@ -2384,7 +2605,9 @@ export {
   priceTierRating,
   quantFromName,
   rankVariants,
+  readCuratedRows,
   readGgufHeader,
+  readModelCatalog,
   reconcileModelFavoriteIds,
   reportModelDiagnostic,
   requireCanonicalCapabilities,