@ai-matrx/agents 0.59.268 → 0.59.269

package/dist/models/index.js

@@ -247,13 +247,13 @@ function setModelDiagnosticsSink(sink) {
 }
 function reportModelDiagnostic(dedupeKey, entry) {
   try {
-    const s3 = state();
-    if (s3.reported.has(dedupeKey)) return;
-    s3.reported.add(dedupeKey);
+    const s4 = state();
+    if (s4.reported.has(dedupeKey)) return;
+    s4.reported.add(dedupeKey);
     console.warn(`[parseCapabilities] ${entry.message}`);
-    if (s3.sink) s3.sink(entry);
-    else if (!s3.announced) {
-      s3.announced = true;
+    if (s4.sink) s4.sink(entry);
+    else if (!s4.announced) {
+      s4.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."
       );
@@ -926,13 +926,13 @@ function createModelRecords(config) {
     if (known.fetchScope === "active" || known.fetchScope === "all") {
       jobs.push(
         readOptions().then(
-          (rows3) => update((s3) => {
-            const entities = { ...s3.entities };
+          (rows3) => update((s4) => {
+            const entities = { ...s4.entities };
             for (const row of rows3) {
               const existing = entities[row.id];
               entities[row.id] = { ...emptyRecord(), ...existing, ...row, _fetchType: existing?._fetchType === "full" ? "full" : "options" };
             }
-            return withIdLists({ ...s3, entities, lastFetched: Date.now(), error: null });
+            return withIdLists({ ...s4, entities, lastFetched: Date.now(), error: null });
           }),
           (err) => fail("model-records-refresh-options-failed", messageOf(err))
         )
@@ -942,9 +942,9 @@ function createModelRecords(config) {
       if (record._fetchType !== "full") continue;
       jobs.push(
         readFullModel(id).then(
-          (fresh) => update((s3) => {
-            const existing = s3.entities[fresh.id];
-            return withIdLists({ ...s3, entities: { ...s3.entities, [fresh.id]: { ...emptyRecord(), ...existing, ...fresh, maker: fresh.maker ?? existing?.maker ?? null, _fetchType: "full" } } });
+          (fresh) => update((s4) => {
+            const existing = s4.entities[fresh.id];
+            return withIdLists({ ...s4, entities: { ...s4.entities, [fresh.id]: { ...emptyRecord(), ...existing, ...fresh, maker: fresh.maker ?? existing?.maker ?? null, _fetchType: "full" } } });
           }),
           (err) => fail("model-records-refresh-model-failed", `${id}: ${messageOf(err)}`, { modelId: id })
         )
@@ -955,7 +955,7 @@ function createModelRecords(config) {
         Promise.resolve(ai().from("model_definition").select("id, name, common_name, is_deprecated").eq(catalogKeyColumn(id), id).maybeSingle()).then(
           ({ data, error }) => {
             if (error) throw error;
-            if (data) update((s3) => ({ ...s3, identityById: { ...s3.identityById, [id]: data } }));
+            if (data) update((s4) => ({ ...s4, identityById: { ...s4.identityById, [id]: data } }));
           }
         ).catch((err) => fail("model-records-refresh-identity-failed", `${id}: ${messageOf(err)}`, { modelId: id }))
       );
@@ -963,7 +963,7 @@ function createModelRecords(config) {
     if (known.modelClassStatus === "succeeded") {
       jobs.push(
         readOfferings().then(
-          (rows3) => update((s3) => ({ ...s3, modelClassIndex: buildModelClassIndex(rows3) })),
+          (rows3) => update((s4) => ({ ...s4, modelClassIndex: buildModelClassIndex(rows3) })),
           (err) => fail("model-records-refresh-classes-failed", messageOf(err))
         )
       );
@@ -971,11 +971,11 @@ function createModelRecords(config) {
       for (const id of classesReadFor) {
         jobs.push(
           readOfferings(id).then(
-            (rows3) => update((s3) => {
-              if (s3.modelClassStatus === "succeeded") return s3;
+            (rows3) => update((s4) => {
+              if (s4.modelClassStatus === "succeeded") return s4;
               const slice = buildModelClassIndex(rows3);
-              const base = s3.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
-              return { ...s3, modelClassIndex: { classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId }, classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering } } };
+              const base = s4.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
+              return { ...s4, modelClassIndex: { classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId }, classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering } } };
             }),
             (err) => fail("model-records-refresh-classes-failed", `${id}: ${messageOf(err)}`, { modelId: id })
           )
@@ -989,7 +989,7 @@ function createModelRecords(config) {
           ({ data, error }) => {
             if (error) throw error;
             const next = data && typeof data === "object" && !Array.isArray(data) ? data : null;
-            update((s3) => ({ ...s3, classConfigByOffering: { ...s3.classConfigByOffering, [key]: { modelId: cfg.modelId, controls: next?.controls ?? null, constraints: next?.constraints ?? null } } }));
+            update((s4) => ({ ...s4, classConfigByOffering: { ...s4.classConfigByOffering, [key]: { modelId: cfg.modelId, controls: next?.controls ?? null, constraints: next?.constraints ?? null } } }));
           }
         ).catch((err) => fail("model-records-refresh-class-config-failed", `${key}: ${messageOf(err)}`))
       );
@@ -1035,29 +1035,29 @@ function createModelRecords(config) {
     loadOptions() {
       if (state2.fetchScope === "active" || state2.fetchScope === "all") return Promise.resolve();
       return once("options", async () => {
-        update((s3) => ({ ...s3, isLoading: true, error: null }));
+        update((s4) => ({ ...s4, isLoading: true, error: null }));
         try {
           const rows3 = await readOptions();
-          update((s3) => {
-            const entities = { ...s3.entities };
+          update((s4) => {
+            const entities = { ...s4.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({
-              ...s3,
+              ...s4,
               entities,
               isLoading: false,
               error: null,
-              fetchScope: s3.fetchScope !== "all" && s3.fetchScope !== "deprecated" ? "active" : s3.fetchScope,
+              fetchScope: s4.fetchScope !== "all" && s4.fetchScope !== "deprecated" ? "active" : s4.fetchScope,
               lastFetched: Date.now()
             });
           });
         } catch (err) {
           const message = messageOf(err);
           errorSink({ code: "model-records-options-load-failed", message });
-          update((s3) => ({ ...s3, isLoading: false, error: message }));
+          update((s4) => ({ ...s4, isLoading: false, error: message }));
         }
       });
     },
@@ -1067,23 +1067,23 @@ function createModelRecords(config) {
         return inFlight.get(`model:${modelId}`) ?? Promise.resolve();
       }
       return once(`model:${modelId}`, async () => {
-        update((s3) => {
-          const detailErrorById = { ...s3.detailErrorById };
+        update((s4) => {
+          const detailErrorById = { ...s4.detailErrorById };
           delete detailErrorById[modelId];
-          return { ...s3, detailStatusById: { ...s3.detailStatusById, [modelId]: "loading" }, detailErrorById };
+          return { ...s4, detailStatusById: { ...s4.detailStatusById, [modelId]: "loading" }, detailErrorById };
         });
         try {
           const record = await readFullModel(modelId);
-          update((s3) => {
-            const existing = s3.entities[record.id];
-            const detailErrorById = { ...s3.detailErrorById };
+          update((s4) => {
+            const existing = s4.entities[record.id];
+            const detailErrorById = { ...s4.detailErrorById };
             delete detailErrorById[modelId];
             return withIdLists({
-              ...s3,
-              detailStatusById: { ...s3.detailStatusById, [modelId]: "succeeded" },
+              ...s4,
+              detailStatusById: { ...s4.detailStatusById, [modelId]: "succeeded" },
               detailErrorById,
               entities: {
-                ...s3.entities,
+                ...s4.entities,
                 [record.id]: { ...emptyRecord(), ...existing, ...record, maker: record.maker ?? existing?.maker ?? null, _fetchType: "full" }
               }
             });
@@ -1091,21 +1091,21 @@ function createModelRecords(config) {
         } catch (err) {
           const message = `Model configuration ${modelId}: ${messageOf(err)}`;
           errorSink({ code: "model-records-model-load-failed", message, context: { modelId } });
-          update((s3) => ({
-            ...s3,
-            detailStatusById: { ...s3.detailStatusById, [modelId]: "failed" },
-            detailErrorById: { ...s3.detailErrorById, [modelId]: message }
+          update((s4) => ({
+            ...s4,
+            detailStatusById: { ...s4.detailStatusById, [modelId]: "failed" },
+            detailErrorById: { ...s4.detailErrorById, [modelId]: message }
           }));
         }
       });
     },
     retryModel(modelId) {
-      update((s3) => {
-        const detailStatusById = { ...s3.detailStatusById };
-        const detailErrorById = { ...s3.detailErrorById };
+      update((s4) => {
+        const detailStatusById = { ...s4.detailStatusById };
+        const detailErrorById = { ...s4.detailErrorById };
         delete detailStatusById[modelId];
         delete detailErrorById[modelId];
-        return { ...s3, detailStatusById, detailErrorById };
+        return { ...s4, detailStatusById, detailErrorById };
       });
     },
     loadClassConfig(modelId, offeringId) {
@@ -1113,37 +1113,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((s3) => ({ ...s3, classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "loading" } }));
+        update((s4) => ({ ...s4, classConfigStatusByOffering: { ...s4.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((s3) => ({
-            ...s3,
-            classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "succeeded" },
+          update((s4) => ({
+            ...s4,
+            classConfigStatusByOffering: { ...s4.classConfigStatusByOffering, [key]: "succeeded" },
             classConfigByOffering: {
-              ...s3.classConfigByOffering,
+              ...s4.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((s3) => ({ ...s3, classConfigStatusByOffering: { ...s3.classConfigStatusByOffering, [key]: "failed" } }));
+          update((s4) => ({ ...s4, classConfigStatusByOffering: { ...s4.classConfigStatusByOffering, [key]: "failed" } }));
         }
       });
     },
     loadClasses() {
       if (state2.modelClassStatus === "loading" || state2.modelClassStatus === "succeeded") return inFlight.get("classes") ?? Promise.resolve();
       return once("classes", async () => {
-        update((s3) => ({ ...s3, modelClassStatus: "loading" }));
+        update((s4) => ({ ...s4, 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((s3) => ({ ...s3, modelClassStatus: "succeeded", modelClassIndex: index }));
+          update((s4) => ({ ...s4, modelClassStatus: "succeeded", modelClassIndex: index }));
         } catch (err) {
           errorSink({ code: "model-records-classes-failed", message: `Model classes: ${messageOf(err)}` });
-          update((s3) => ({ ...s3, modelClassStatus: "failed" }));
+          update((s4) => ({ ...s4, modelClassStatus: "failed" }));
         }
       });
     },
@@ -1158,11 +1158,11 @@ function createModelRecords(config) {
           if (error) throw error;
           const slice = buildModelClassIndex(data ?? []);
           classesReadFor.add(modelId);
-          update((s3) => {
-            if (s3.modelClassStatus === "succeeded") return s3;
-            const base = s3.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
+          update((s4) => {
+            if (s4.modelClassStatus === "succeeded") return s4;
+            const base = s4.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
             return {
-              ...s3,
+              ...s4,
               modelClassIndex: {
                 classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId },
                 classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering }
@@ -1180,20 +1180,20 @@ function createModelRecords(config) {
         return inFlight.get(`identity:${modelId}`) ?? Promise.resolve();
       }
       return once(`identity:${modelId}`, async () => {
-        update((s3) => ({ ...s3, identityStatusById: { ...s3.identityStatusById, [modelId]: "loading" } }));
+        update((s4) => ({ ...s4, identityStatusById: { ...s4.identityStatusById, [modelId]: "loading" } }));
         try {
           const { data, error } = await ai().from("model_definition").select("id, name, common_name, is_deprecated").eq(catalogKeyColumn(modelId), 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((s3) => ({
-            ...s3,
-            identityById: { ...s3.identityById, [row.id]: row, [modelId]: row },
-            identityStatusById: { ...s3.identityStatusById, [row.id]: "succeeded", [modelId]: "succeeded" }
+          update((s4) => ({
+            ...s4,
+            identityById: { ...s4.identityById, [row.id]: row, [modelId]: row },
+            identityStatusById: { ...s4.identityStatusById, [row.id]: "succeeded", [modelId]: "succeeded" }
           }));
         } catch (err) {
           errorSink({ code: "model-records-identity-failed", message: messageOf(err), context: { modelId } });
-          update((s3) => ({ ...s3, identityStatusById: { ...s3.identityStatusById, [modelId]: "failed" } }));
+          update((s4) => ({ ...s4, identityStatusById: { ...s4.identityStatusById, [modelId]: "failed" } }));
         }
       });
     },
@@ -1212,26 +1212,26 @@ function createModelRecords(config) {
       }
       if (wanted.length > 0) {
         const marked = Object.fromEntries(wanted.map((id) => [id, "loading"]));
-        update((s3) => ({ ...s3, identityStatusById: { ...s3.identityStatusById, ...marked } }));
+        update((s4) => ({ ...s4, identityStatusById: { ...s4.identityStatusById, ...marked } }));
         const run = (async () => {
           try {
             const { data, error } = await ai().from("model_definition").select("id, name, common_name, is_deprecated").in("id", wanted);
             if (error) throw error;
             const rows3 = Array.isArray(data) ? data : [];
             const got = new Set(rows3.map((r) => r.id));
-            update((s3) => ({
-              ...s3,
-              identityById: { ...s3.identityById, ...Object.fromEntries(rows3.map((r) => [r.id, r])) },
+            update((s4) => ({
+              ...s4,
+              identityById: { ...s4.identityById, ...Object.fromEntries(rows3.map((r) => [r.id, r])) },
               identityStatusById: {
-                ...s3.identityStatusById,
+                ...s4.identityStatusById,
                 ...Object.fromEntries(wanted.map((id) => [id, got.has(id) ? "succeeded" : "failed"]))
               }
             }));
           } catch (err) {
             errorSink({ code: "model-records-identity-failed", message: messageOf(err), context: { modelIds: wanted } });
-            update((s3) => ({
-              ...s3,
-              identityStatusById: { ...s3.identityStatusById, ...Object.fromEntries(wanted.map((id) => [id, "failed"])) }
+            update((s4) => ({
+              ...s4,
+              identityStatusById: { ...s4.identityStatusById, ...Object.fromEntries(wanted.map((id) => [id, "failed"])) }
             }));
           }
         })();
@@ -1249,11 +1249,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((s3) => {
-          if (s3.modelClassStatus === "succeeded") return s3;
-          const base = s3.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
+        update((s4) => {
+          if (s4.modelClassStatus === "succeeded") return s4;
+          const base = s4.modelClassIndex ?? { classesByModelId: {}, classOfOffering: {} };
           return {
-            ...s3,
+            ...s4,
             modelClassIndex: {
               classesByModelId: { ...base.classesByModelId, ...slice.classesByModelId },
               classOfOffering: { ...base.classOfOffering, ...slice.classOfOffering }
@@ -1272,16 +1272,16 @@ function createModelRecords(config) {
           controls: row.controls ?? null,
           capabilities: requireCanonicalCapabilities(row.capabilities, { modelId: row.id, modelName: row.name })
         });
-        update((s3) => {
-          const existing = s3.entities[record.id];
-          const detailErrorById = { ...s3.detailErrorById };
+        update((s4) => {
+          const existing = s4.entities[record.id];
+          const detailErrorById = { ...s4.detailErrorById };
           delete detailErrorById[modelId];
           return withIdLists({
-            ...s3,
-            detailStatusById: { ...s3.detailStatusById, [modelId]: "succeeded" },
+            ...s4,
+            detailStatusById: { ...s4.detailStatusById, [modelId]: "succeeded" },
             detailErrorById,
             entities: {
-              ...s3.entities,
+              ...s4.entities,
               [record.id]: { ...emptyRecord(), ...existing, ...record, maker: record.maker ?? existing?.maker ?? null, _fetchType: "full" }
             }
           });
@@ -1291,14 +1291,14 @@ function createModelRecords(config) {
       }
     },
     hydrate({ models, fetchType, fetchScope, lastFetched }) {
-      update((s3) => {
-        const entities = { ...s3.entities };
+      update((s4) => {
+        const entities = { ...s4.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({ ...s3, entities, fetchScope, lastFetched, isLoading: false, error: null });
+        return withIdLists({ ...s4, entities, fetchScope, lastFetched, isLoading: false, error: null });
       });
     }
   };
@@ -1318,28 +1318,28 @@ function memo(fn) {
 var UNSET = /* @__PURE__ */ Symbol("unset");
 var activeKey = null;
 var activeOut = [];
-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);
+function selectActiveModels(s4) {
+  if (!activeKey || activeKey[0] !== s4.entities || activeKey[1] !== s4.activeIds) {
+    activeKey = [s4.entities, s4.activeIds];
+    activeOut = s4.activeIds.map((id) => s4.entities[id]).filter((m) => !!m);
   }
   return activeOut;
 }
 var deprecatedKey = null;
 var deprecatedOut = [];
-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);
+function selectDeprecatedModels(s4) {
+  if (!deprecatedKey || deprecatedKey[0] !== s4.entities || deprecatedKey[1] !== s4.deprecatedIds) {
+    deprecatedKey = [s4.entities, s4.deprecatedIds];
+    deprecatedOut = s4.deprecatedIds.map((id) => s4.entities[id]).filter((m) => !!m);
   }
   return deprecatedOut;
 }
 var allOf = memo((entities) => Object.values(entities));
-var selectAllModels = (s3) => allOf(s3.entities);
+var selectAllModels = (s4) => allOf(s4.entities);
 var optionsOf = memo(
   (models) => models.map((m) => ({ value: m.id, label: modelDisplayLabel(m) || m.id, maker: m.maker, costRating: m.cost_rating, speedRating: m.speed_rating }))
 );
-var selectModelOptions = (s3) => optionsOf(selectActiveModels(s3));
+var selectModelOptions = (s4) => optionsOf(selectActiveModels(s4));
 var allOptionsOf = memo(
   (entities) => Object.values(entities).map((m) => ({
     value: m.id,
@@ -1350,30 +1350,30 @@ var allOptionsOf = memo(
     successorId: m.successor_id ?? null
   }))
 );
-var selectAllModelOptions = (s3) => allOptionsOf(s3.entities);
-var selectModelById = (s3, modelId) => modelId ? s3.entities[modelId] : void 0;
-function selectModelLabelById(s3, modelId) {
+var selectAllModelOptions = (s4) => allOptionsOf(s4.entities);
+var selectModelById = (s4, modelId) => modelId ? s4.entities[modelId] : void 0;
+function selectModelLabelById(s4, modelId) {
   if (!modelId) return void 0;
-  const m = s3.entities[modelId];
-  const identity = s3.identityById[modelId];
+  const m = s4.entities[modelId];
+  const identity = s4.identityById[modelId];
   return modelDisplayLabel(m) || modelDisplayLabel(identity);
 }
-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";
+var selectModelNameById = (s4, modelId) => modelId ? s4.entities[modelId]?.name : void 0;
+var selectModelClassName = (s4, modelId, offeringId) => modelClassName(s4.modelClassIndex, modelId, offeringId);
+function selectModelLabelWithClass(s4, modelId, offeringId) {
+  const label = selectModelLabelById(s4, modelId);
+  return label ? withModelClass(label, selectModelClassName(s4, modelId, offeringId)) : void 0;
+}
+var selectModelControls = (s4, modelId) => s4.entities[modelId]?.controls;
+var selectModelFetchType = (s4, modelId) => s4.entities[modelId]?._fetchType;
+var selectModelFullyLoaded = (s4, modelId) => !!modelId && s4.entities[modelId]?._fetchType === "full";
+var selectModelDetailError = (s4, modelId) => modelId && s4.detailErrorById[modelId] || null;
+var selectModelClassConfig = (s4, modelId, offeringId) => modelId && offeringId ? s4.classConfigByOffering[classConfigKey(modelId, offeringId)] : void 0;
+var selectActiveModelsReady = (s4) => (s4.fetchScope === "active" || s4.fetchScope === "all") && s4.activeIds.length > 0;
+var selectDeprecatedModelsReady = (s4) => (s4.fetchScope === "deprecated" || s4.fetchScope === "all") && s4.deprecatedIds.length > 0;
+var selectAllModelsReady = (s4) => s4.fetchScope === "all";
+var selectModelIdentityById = (s4, modelId) => s4.identityById[modelId];
+var selectModelIdentityLookupStatus = (s4, modelId) => s4.identityStatusById[modelId] ?? "idle";
 async function readModelIdentities(client, modelIds) {
   const ids = [...new Set(modelIds.filter(Boolean))];
   if (ids.length === 0) return [];
@@ -1673,9 +1673,9 @@ function createModelCatalog(config) {
       };
     },
     load(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);
+      const s4 = state2[variant];
+      if (s4.status === "idle" || s4.status === "error") return run(variant);
+      if (s4.status === "ready" && s4.loadedAt !== null && Date.now() - s4.loadedAt > staleAfterMs) return run(variant);
       return inFlight[variant] ?? Promise.resolve();
     },
     reload: (variant) => run(variant)
@@ -1863,9 +1863,9 @@ function placement(v, runtimes, device) {
   }
   return "not_compatible";
 }
-function formatMemoryBytes(n2) {
-  const g = n2 / 2 ** 30;
-  if (g < 1) return `${Math.max(1, Math.round(n2 / 2 ** 20))} MB`;
+function formatMemoryBytes(n3) {
+  const g = n3 / 2 ** 30;
+  if (g < 1) return `${Math.max(1, Math.round(n3 / 2 ** 20))} MB`;
   return `${g < 10 ? Math.round(g * 10) / 10 : Math.round(g)} GB`;
 }
 function describe(c, decided, runnerUp, device) {
@@ -2192,41 +2192,41 @@ var Cursor = class {
     this.read = read;
     this.size = size;
   }
-  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);
+  async need(n3) {
+    if (this.pos + n3 > this.size) throw new GgufError("the file ends inside its header");
+    if (this.pos + n3 > MAX_HEADER) throw new GgufError("its header is larger than any real model's");
+    if (this.pos >= this.base && this.pos + n3 <= this.base + this.buf.length) return;
+    const len = Math.min(Math.max(n3, CHUNK), this.size - this.pos);
     this.buf = await this.read(this.pos, len);
     this.base = this.pos;
-    if (this.buf.length < n2) throw new GgufError("the file ends inside its header");
+    if (this.buf.length < n3) throw new GgufError("the file ends inside its header");
   }
-  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;
+  async view(n3) {
+    await this.need(n3);
+    const v = new DataView(this.buf.buffer, this.buf.byteOffset + (this.pos - this.base), n3);
+    this.pos += n3;
     return v;
   }
   async u32() {
     return (await this.view(4)).getUint32(0, true);
   }
   async u64() {
-    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);
+    const n3 = (await this.view(8)).getBigUint64(0, true);
+    if (n3 > BigInt(Number.MAX_SAFE_INTEGER)) throw new GgufError("a size in its header is out of range");
+    return Number(n3);
   }
   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 s3 = new TextDecoder().decode(this.buf.subarray(at, at + len));
+    const s4 = new TextDecoder().decode(this.buf.subarray(at, at + len));
     this.pos += len;
-    return s3;
+    return s4;
   }
-  async skip(n2) {
-    if (this.pos + n2 > this.size) throw new GgufError("the file ends inside its header");
-    this.pos += n2;
+  async skip(n3) {
+    if (this.pos + n3 > this.size) throw new GgufError("the file ends inside its header");
+    this.pos += n3;
   }
   async scalar(type) {
     switch (type) {
@@ -2278,11 +2278,11 @@ async function readGgufHeader(read, size) {
     const type = await c.u32();
     if (type === 9) {
       const elem = await c.u32();
-      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]);
+      const n3 = await c.u64();
+      if (n3 > 64 * MAX_COUNT) throw new GgufError("an array in its header is out of range");
+      arrays[key] = n3;
+      if (elem === 8) for (let j = 0; j < n3; j++) await c.str();
+      else if (SCALAR_BYTES[elem] !== void 0) await c.skip(n3 * SCALAR_BYTES[elem]);
       else throw new GgufError(`its header has an array of unknown type ${elem}`);
     } else kv[key] = await c.scalar(type);
   }
@@ -2312,20 +2312,20 @@ async function readGgufHeader(read, size) {
   return { version, kv, array_lengths: arrays, tensors, data_offset: dataOffset, data_end: end };
 }
 function ggufFacts(h) {
-  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 s4 = (k) => typeof h.kv[k] === "string" ? h.kv[k] : null;
+  const n3 = (k) => typeof h.kv[k] === "number" ? h.kv[k] : null;
+  const arch = s4("general.architecture");
+  const ft = n3("general.file_type");
   const params = h.tensors.reduce((t, x) => t + x.dims.reduce((a, b) => a * b, 1), 0);
   return {
     architecture: arch,
-    name: s3("general.name"),
+    name: s4("general.name"),
     quant: ft !== null ? FILE_TYPE_QUANT[ft] ?? `FTYPE_${ft}` : null,
-    context_length: arch ? n2(`${arch}.context_length`) : null,
+    context_length: arch ? n3(`${arch}.context_length`) : null,
     parameter_count: params > 0 ? params : null,
-    split_count: n2("split.count") ?? 1,
-    split_index: n2("split.no") ?? 0,
-    type: s3("general.type"),
+    split_count: n3("split.count") ?? 1,
+    split_index: n3("split.no") ?? 0,
+    type: s4("general.type"),
     has_tokenizer: typeof h.kv["tokenizer.ggml.model"] === "string"
   };
 }
@@ -2366,16 +2366,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((s3) => s3 !== null);
+  const shards = names.map(shardName).filter((s4) => s4 !== null);
   if (!shards.length) return [];
-  const counts = [...new Set(shards.map((s3) => s3.count))];
+  const counts = [...new Set(shards.map((s4) => s4.count))];
   if (counts.length !== 1) return [`its parts disagree on how many parts there are (${counts.sort((a, b) => a - b).join(", ")})`];
-  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 n3 = counts[0];
+  const have = shards.map((s4) => s4.index);
+  const missing = Array.from({ length: n3 }, (_, 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 ${n2}`).join(", ")} ${missing.length === 1 ? "is" : "are"} missing`);
+  if (missing.length) out.push(`part${missing.length === 1 ? "" : "s"} ${missing.map((i) => `${i} of ${n3}`).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;
 }
@@ -2412,8 +2412,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((s3) => s3 !== primary && shardName(s3.name)?.stem === shard.stem)];
-    const problems = splitSetProblems(same.map((s3) => s3.name));
+    const same = [primary, ...siblings.filter((s4) => s4 !== primary && shardName(s4.name)?.stem === shard.stem)];
+    const problems = splitSetProblems(same.map((s4) => s4.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));
   }
@@ -2446,7 +2446,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((s3) => s3 !== primary && extOf(s3.name) === ".gguf" && isProjectorName(s3.name));
+  const projectorFiles = siblings.filter((s4) => s4 !== primary && extOf(s4.name) === ".gguf" && isProjectorName(s4.name));
   const pickedName = pickProjector(quant === "unknown" ? null : quant, projectorFiles.map((p) => p.name));
   let projector = null;
   const picked = projectorFiles.find((p) => p.name === pickedName);
@@ -2568,6 +2568,77 @@ function curatedList(models, { offeredOnly }) {
 
 // models/catalog-reader.ts
 import { sha256Hex } from "@ai-matrx/kit/sha256";
+
+// models/device-models.ts
+var DEVICE_SERVED_VIA = "device";
+var DEVICE_FILE_USABLE_STATES = Object.freeze(["present"]);
+var DEVICE_OWN_FILE_USABLE_STATES = Object.freeze(["present", "unmatched"]);
+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;
+function toDeviceModelFile(r) {
+  return {
+    id: s2(r.id),
+    app_instance_id: s2(r.app_instance_id),
+    root_id: s2(r.root_id),
+    rel_path: sn2(r.rel_path),
+    size_bytes: n(r.size_bytes),
+    sha256: sn2(r.sha256),
+    artifact_id: sn2(r.artifact_id),
+    state: s2(r.state),
+    organization_id: sn2(r.organization_id)
+  };
+}
+async function readDeviceModelFiles(client, opts = {}) {
+  const db = client;
+  let q = db.schema("ai").from("device_model_file").select("*").is("deleted_at", null).in("state", opts.states ?? DEVICE_FILE_USABLE_STATES);
+  if (opts.appInstanceIds) q = q.in("app_instance_id", opts.appInstanceIds);
+  const { data, error } = await q;
+  if (error) throw new Error(`ai.device_model_file: ${error.message}`);
+  return (data ?? []).filter((r) => r.deleted_at == null).map(toDeviceModelFile);
+}
+function requiredArtifactIds(v) {
+  const core = v.artifacts.filter((a) => a.required_for.includes("core"));
+  return (core.length ? core : v.artifacts).map((a) => a.id);
+}
+function availableOnDevices(variants, files) {
+  const usable = files.filter((f) => f.artifact_id && DEVICE_FILE_USABLE_STATES.includes(f.state));
+  const out = /* @__PURE__ */ new Map();
+  for (const v of variants) {
+    const order = new Map(v.artifacts.map((a, i) => [a.id, i]));
+    const required = requiredArtifactIds(v);
+    const byDevice = /* @__PURE__ */ new Map();
+    for (const f of usable)
+      if (order.has(f.artifact_id)) {
+        const list2 = byDevice.get(f.app_instance_id) ?? [];
+        list2.push(f);
+        byDevice.set(f.app_instance_id, list2);
+      }
+    const list = [];
+    for (const device of [...byDevice.keys()].sort()) {
+      const held = byDevice.get(device);
+      const have = new Set(held.map((f) => f.artifact_id));
+      if (!required.length || !required.every((id) => have.has(id))) continue;
+      list.push({
+        app_instance_id: device,
+        variant_id: v.id,
+        device_model_file_ids: held.slice().sort((a, b) => order.get(a.artifact_id) - order.get(b.artifact_id) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)).map((f) => f.id)
+      });
+    }
+    out.set(v.id, list);
+  }
+  return out;
+}
+var DeviceModelUnavailableError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "DeviceModelUnavailableError";
+    this.code = code;
+  }
+};
+
+// models/catalog-reader.ts
 var MODEL_CATALOG_KINDS = /* @__PURE__ */ new Set([
   "llm_model",
   "whisper_model",
@@ -2605,14 +2676,17 @@ 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 s3 = (v) => typeof v === "string" ? v : "";
+var sn3 = (v) => typeof v === "string" ? v : null;
+var n2 = (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 byId = (rows3) => new Map(rows3.map((r) => [s3(r.id), r]));
 var strings = (v) => Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
 async function readModelCatalog(client, opts = {}) {
+  return readCatalogWith(client, opts, null);
+}
+async function readCatalogWith(client, opts, preread) {
   const db = client;
   const offeredOnly = opts.offeredOnly ?? true;
   const ai = db.schema("ai");
@@ -2630,20 +2704,29 @@ async function readModelCatalog(client, opts = {}) {
   ]);
   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 variants = raw.variants.filter((v) => listed.has(s3(v.model_id)) && (offeredOnly ? s3(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([]),
+  const devices = opts.devices ? opts.devices === true ? {} : opts.devices : null;
+  const [artifacts, entries, deviceFiles] = await Promise.all([
+    variants.length ? all("model_artifact", (q) => q.in("variant_id", variants.map((v) => s3(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([])
+    }) : Promise.resolve([]),
+    devices ? preread ? Promise.resolve(preread) : readDeviceModelFiles(client, devices.appInstanceIds ? { appInstanceIds: devices.appInstanceIds } : {}) : Promise.resolve(null)
   ]);
-  const kindOfEntry = new Map(entries.map((e) => [s2(e.id), s2(e.kind)]));
+  const placement2 = deviceFiles ? availableOnDevices(
+    variants.map((v) => ({
+      id: s3(v.id),
+      artifacts: artifacts.filter((a) => s3(a.variant_id) === s3(v.id)).map((a) => ({ id: s3(a.id), required_for: strings(a.required_for) }))
+    })),
+    deviceFiles
+  ) : null;
+  const kindOfEntry = new Map(entries.map((e) => [s3(e.id), s3(e.kind)]));
   const stamps = [];
   const stamp = (r) => {
     if (r && typeof r.updated_at === "string") stamps.push(r.updated_at);
@@ -2651,84 +2734,87 @@ async function readModelCatalog(client, opts = {}) {
   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 presentationOf = new Map(raw.presentations.map((p) => [s3(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));
+    const maker = providerById.get(s3(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),
+        id: s3(m.id),
+        name: s3(m.name),
+        desktop_id: sn3(m.metadata?.desktop_id),
+        common_name: sn3(m.common_name),
+        maker: sn3(maker?.name),
+        maker_logo_file_id: sn3(maker?.logo_file_id),
+        description: sn3(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),
+          summary: sn3(p.summary),
+          symbol: sn3(p.symbol),
+          color: sn3(p.color),
+          shelf: sn3(p.shelf),
+          shelf_title: sn3(p.shelf_title),
+          shelf_subtitle: sn3(p.shelf_subtitle),
+          display_order: n2(p.display_order),
+          page: sn3(p.page),
+          params_label: sn3(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),
+          thumbnail_file_id: sn3(p.thumbnail_file_id),
+          hero_file_id: sn3(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) => {
+        variants: variants.filter((v) => s3(v.model_id) === c.id).sort((a, b) => byCodepoint2(s3(a.key), s3(b.key))).map((v) => {
           stamp(v);
-          const up = upstreamById.get(s2(v.upstream_id));
+          const up = upstreamById.get(s3(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)));
+          const arts = artifacts.filter((a) => s3(a.variant_id) === s3(v.id)).sort((a, b) => (n2(a.shard_index) ?? 0) - (n2(b.shard_index) ?? 0) || byCodepoint2(s3(a.path_in_repo), s3(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),
+            id: s3(v.id),
+            key: s3(v.key),
+            catalog_key: `${s3(m.name)}/${s3(v.key)}`,
+            review_state: s3(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),
+            format: s3(v.format),
+            quant: s3(v.quant),
+            architecture: s3(v.architecture),
+            chat_template_kind: s3(v.chat_template_kind),
             os_arch: strings(v.os_arch),
-            selection_rank: n(v.selection_rank) ?? Number.MAX_SAFE_INTEGER,
+            selection_rank: n2(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),
+            license: sn3(v.license_id),
+            gated: s3(v.gated),
+            total_bytes: n2(v.total_bytes),
+            memory_bytes_min: n2(v.memory_bytes_min),
+            memory_bytes_recommended: n2(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,
+            min_app_version: sn3(v.min_app_version),
+            upstream: up ? { kind: s3(up.upstream_kind), repo: sn3(up.repo), revision: sn3(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),
+              role: s3(a.role),
+              path: s3(a.path_in_repo),
+              url: s3(a.url),
+              size_bytes: n2(a.size_bytes) ?? 0,
+              sha256: s3(a.sha256),
               required_for: strings(a.required_for).sort(),
-              shard_index: n(a.shard_index),
-              shard_count: n(a.shard_count)
+              shard_index: n2(a.shard_index),
+              shard_count: n2(a.shard_count)
             }))
           };
-        })
+        }),
+        ...placement2 ? {
+          available_on: variants.filter((v) => s3(v.model_id) === c.id).sort((a, b) => byCodepoint2(s3(a.key), s3(b.key))).flatMap((v) => placement2.get(s3(v.id)) ?? [])
+        } : {}
       }
     ];
   });
@@ -2736,36 +2822,36 @@ async function readModelCatalog(client, opts = {}) {
     $schema: "matrx.model-catalog.snapshot/v1",
     catalog_updated_at: "",
     models,
-    runtimes: runtimes.sort((a, b) => byCodepoint2(s2(a.key), s2(b.key))).map((rt) => {
+    runtimes: runtimes.sort((a, b) => byCodepoint2(s3(a.key), s3(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) => {
+        key: s3(rt.key),
+        name: s3(rt.name),
+        upstream_repo: sn3(rt.upstream_repo),
+        builds: builds.filter((b) => s3(b.runtime_id) === s3(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),
+            id: s3(b.id),
+            version: s3(b.runtime_version),
+            os: s3(b.os),
+            arch: s3(b.arch),
+            accelerator: s3(b.accelerator),
+            build_kind: s3(b.build_kind),
+            url: sn3(b.url),
+            size_bytes: n2(b.size_bytes),
+            sha256: sn3(b.sha256),
             is_active: b.is_active === true,
-            min_app_version: sn2(b.min_app_version),
+            min_app_version: sn3(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)
+            compat: compat.filter((c) => s3(c.runtime_build_id) === s3(b.id)).map((c) => ({
+              hardware_class: s3(c.hardware_class),
+              format: s3(c.format),
+              quant: s3(c.quant),
+              architecture: s3(c.architecture),
+              chat_template_kind: s3(c.chat_template_kind),
+              status: s3(c.status)
             }))
           };
         })
@@ -2777,6 +2863,37 @@ async function readModelCatalog(client, opts = {}) {
   out.catalog_fingerprint = catalogFingerprint(out);
   return out;
 }
+async function resolveDeviceModel(client, req) {
+  const files = await readDeviceModelFiles(client, {
+    appInstanceIds: [req.app_instance_id],
+    states: [.../* @__PURE__ */ new Set([...DEVICE_FILE_USABLE_STATES, ...DEVICE_OWN_FILE_USABLE_STATES])]
+  });
+  const own = files.find((f) => f.id === req.local_model_id);
+  if (own) {
+    if (own.artifact_id)
+      throw new DeviceModelUnavailableError("not_own_file", `device model file ${own.id} is catalog artifact ${own.artifact_id}; pass its model id, not the file id`);
+    if (!DEVICE_OWN_FILE_USABLE_STATES.includes(own.state))
+      throw new DeviceModelUnavailableError("file_not_usable", `own model file ${own.id} on computer ${req.app_instance_id} is ${own.state}`);
+    return { own: true, file: own };
+  }
+  const usable = files.filter((f) => DEVICE_FILE_USABLE_STATES.includes(f.state));
+  const catalog = await readCatalogWith(client, { offeredOnly: false, devices: { appInstanceIds: [req.app_instance_id] } }, usable);
+  const model = catalog.models.find((m) => m.id === req.local_model_id);
+  if (!model)
+    throw new DeviceModelUnavailableError("unknown_model", `no catalog model or own model file ${req.local_model_id} on computer ${req.app_instance_id}`);
+  const label = model.common_name || model.name;
+  if (req.variant_id && !model.variants.some((v) => v.id === req.variant_id))
+    throw new DeviceModelUnavailableError("unknown_variant", `${label} has no listed variant ${req.variant_id}`);
+  const held = (model.available_on ?? []).filter((a) => a.app_instance_id === req.app_instance_id && (!req.variant_id || a.variant_id === req.variant_id));
+  const variants = held.map((a) => ({ a, v: model.variants.find((v) => v.id === a.variant_id) })).sort((x, y) => Number(y.v.is_default) - Number(x.v.is_default) || x.v.selection_rank - y.v.selection_rank || byCodepoint2(x.v.key, y.v.key));
+  const pick = variants[0];
+  if (!pick) {
+    const which = req.variant_id ? ` (${model.variants.find((v) => v.id === req.variant_id).key})` : "";
+    throw new DeviceModelUnavailableError("not_on_device", `computer ${req.app_instance_id} does not hold every required file of ${label}${which}`);
+  }
+  const byFileId = new Map(usable.map((f) => [f.id, f]));
+  return { own: false, model, variant: pick.v, files: pick.a.device_model_file_ids.map((id) => byFileId.get(id)) };
+}
 
 // models/fit.ts
 var featuresOf = (c) => {
@@ -2861,6 +2978,10 @@ export {
   CHAT_DEFAULT_MODEL_KNOB,
   CONTENT_TYPES,
   DEFAULT_CAPABILITIES,
+  DEVICE_FILE_USABLE_STATES,
+  DEVICE_OWN_FILE_USABLE_STATES,
+  DEVICE_SERVED_VIA,
+  DeviceModelUnavailableError,
   EMPTY_MODEL_RECORDS,
   EXCLUDED_REVIEW_STATES,
   FEATURE_BUCKETS,
@@ -2881,6 +3002,7 @@ export {
   TOP_TIER_LOCKED_TITLE,
   acceptsTextInstructions,
   announceModelCatalogChanged,
+  availableOnDevices,
   blendedPrice,
   buildModelClassIndex,
   buildSuccessionIndex,
@@ -2950,6 +3072,7 @@ export {
   quantFromName,
   rankVariants,
   readCuratedRows,
+  readDeviceModelFiles,
   readGgufHeader,
   readModelCatalog,
   readModelIdentities,
@@ -2957,8 +3080,10 @@ export {
   reconcileModelFavoriteIds,
   reportModelDiagnostic,
   requireCanonicalCapabilities,
+  requiredArtifactIds,
   requiredArtifacts,
   resetSuccessionLogForTests,
+  resolveDeviceModel,
   resolveLiveModelId,
   resolveModelMapKnob,
   resolveNewAgentModelId,
@@ -2997,6 +3122,7 @@ export {
   splitSetProblems,
   takesInput,
   toAuditRecord,
+  toDeviceModelFile,
   validateModelSet,
   variantVerdict,
   withModelClass