dshmarket 1.66.31 → 1.66.32

package/lib/regions.js

@@ -107,6 +107,34 @@ const ROUTES = {
         ],
     },
 };
+/**
+ * Every catalog source worth trying for a region: its own list, plus the
+ * catalog's published package on that region's own registry when the list
+ * does not already name it.
+ *
+ * The catalog hangs off a SECOND, independently blockable host (#891), and
+ * the probe that picks a region measures only the npm registry. A network
+ * where npm answers fast and GitHub Pages is blocked therefore measures
+ * `global` — whose one source is that very host — and since the region is
+ * decided once and persisted, nothing ever reconsiders: "catalog fetch
+ * failed" forever, on a machine whose registry is serving the catalog as a
+ * package all along.
+ *
+ * Appending the package closes that blind spot without asking the probe to
+ * learn about the second host, without revisiting the decision, and without
+ * sending anyone to another region's mirror: it rides the registry the probe
+ * already proved reachable. Last, not first — for everyone the official
+ * domain serves, this stays a source that is never contacted.
+ */
+export function catalogSourcesFor(region) {
+    const routes = routesFor(region);
+    const sources = [...routes.catalog];
+    const served = sources.some(source => source.kind === 'npm'
+        && source.registry === routes.npmRegistry && source.pkg === CATALOG_PACKAGE);
+    if (!served)
+        sources.push({ kind: 'npm', registry: routes.npmRegistry, pkg: CATALOG_PACKAGE });
+    return sources;
+}
 /** Read an environment override, treating blank as unset. */
 function override(env, name) {
     const raw = env[name];

package/lib/registry.js

@@ -3,9 +3,10 @@
  * fresh on every request. See `loadRegistry` for why there is nothing
  * behind it any more.
  */
+import { logEvent } from './log.js';
 import { configuredProxy, marketFetch } from './net.js';
 import { catalogFromPackage } from './catalog-npm.js';
-import { activeRegion, routesFor } from './regions.js';
+import { activeRegion, catalogSourcesFor, routesFor } from './regions.js';
 /**
  * Category ids for one catalog entry, de-duplicated in declaration order.
  *
@@ -166,8 +167,23 @@ export async function loadRegistry(region = activeRegion()) {
     // the FIRST request the market makes, so a mirror that has gone down must
     // mean a slow market rather than an empty one — the list ends at the
     // address that has always worked.
-    for (const source of routesFor(region).catalog) {
+    //
+    // The list runs one entry past the region's own sources on purpose (#891):
+    // the region probe measures the npm registry, so it cannot see a network
+    // where npm is fast and the catalog's host is blocked — and the region is
+    // decided once and persisted. The catalog's published package, on the
+    // registry the probe just proved reachable, is the repair that needs
+    // neither the probe nor the decision to change.
+    const ownSources = routesFor(region).catalog.length;
+    const catalogSources = catalogSourcesFor(region);
+    for (const [sourceIndex, source] of catalogSources.entries()) {
         const key = sourceKey(source);
+        const servedBy = (data) => {
+            if (sourceIndex >= ownSources) {
+                logEvent('warn', 'registry', `catalog: the ${region} sources did not answer; read the catalog package from ${key} instead (#891)`);
+            }
+            return data;
+        };
         // Two attempts each. A catalog fetch crossing a long, lossy path fails
         // transiently often enough that one retry is worth more than the second
         // or two it costs — and with nothing behind this call any more, a
@@ -183,12 +199,12 @@ export async function loadRegistry(region = activeRegion()) {
                     const { version, data } = await catalogFromPackage(source.registry, source.pkg, reusable?.version ?? undefined);
                     // `data === null` means the published version is the one in hand.
                     if (data === null && reusable !== null)
-                        return reusable.data;
+                        return servedBy(reusable.data);
                     if (data === null)
                         throw new Error('the catalog package reported no change with nothing to reuse');
                     const parsed = asRegistry(data);
                     served = { key, etag: null, modified: null, version, data: parsed };
-                    return parsed;
+                    return servedBy(parsed);
                 }
                 // ETag first: it is exact, while a date has one-second resolution and
                 // a catalog republished twice within the same second would validate
@@ -221,7 +237,7 @@ export async function loadRegistry(region = activeRegion()) {
                     // otherwise surface as a confusing parse error on an empty body.
                     if (reusable === null)
                         throw new Error('the catalog answered "not modified" with nothing to revalidate');
-                    return reusable.data;
+                    return servedBy(reusable.data);
                 }
                 if (!res.ok)
                     throw new Error(`HTTP ${String(res.status)}`);
@@ -229,7 +245,7 @@ export async function loadRegistry(region = activeRegion()) {
                 served = {
                     key, etag: res.headers.get('etag'), modified: res.headers.get('last-modified'), version: null, data,
                 };
-                return data;
+                return servedBy(data);
             }
             catch (error) {
                 last = error;

package/lib/types/regions.d.ts

@@ -71,6 +71,26 @@ export interface RegionRoutes {
      */
     catalog: CatalogSource[];
 }
+/**
+ * Every catalog source worth trying for a region: its own list, plus the
+ * catalog's published package on that region's own registry when the list
+ * does not already name it.
+ *
+ * The catalog hangs off a SECOND, independently blockable host (#891), and
+ * the probe that picks a region measures only the npm registry. A network
+ * where npm answers fast and GitHub Pages is blocked therefore measures
+ * `global` — whose one source is that very host — and since the region is
+ * decided once and persisted, nothing ever reconsiders: "catalog fetch
+ * failed" forever, on a machine whose registry is serving the catalog as a
+ * package all along.
+ *
+ * Appending the package closes that blind spot without asking the probe to
+ * learn about the second host, without revisiting the decision, and without
+ * sending anyone to another region's mirror: it rides the registry the probe
+ * already proved reachable. Last, not first — for everyone the official
+ * domain serves, this stays a source that is never contacted.
+ */
+export declare function catalogSourcesFor(region: Region): CatalogSource[];
 /**
  * Normalize a user-maintained prefix, or reject it.
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dshmarket",
   "description": "Visual plugin market inside DeepSeek Harness — browse, search, and one-click install community plugins. · DSH 可视化插件市场：逛一逛，点一下，装好。",
-  "version": "1.66.31",
+  "version": "1.66.32",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",

package/src/regions.ts

@@ -157,6 +157,34 @@ const ROUTES: Record<Region, RegionRoutes> = {
   },
 }
 
+/**
+ * Every catalog source worth trying for a region: its own list, plus the
+ * catalog's published package on that region's own registry when the list
+ * does not already name it.
+ *
+ * The catalog hangs off a SECOND, independently blockable host (#891), and
+ * the probe that picks a region measures only the npm registry. A network
+ * where npm answers fast and GitHub Pages is blocked therefore measures
+ * `global` — whose one source is that very host — and since the region is
+ * decided once and persisted, nothing ever reconsiders: "catalog fetch
+ * failed" forever, on a machine whose registry is serving the catalog as a
+ * package all along.
+ *
+ * Appending the package closes that blind spot without asking the probe to
+ * learn about the second host, without revisiting the decision, and without
+ * sending anyone to another region's mirror: it rides the registry the probe
+ * already proved reachable. Last, not first — for everyone the official
+ * domain serves, this stays a source that is never contacted.
+ */
+export function catalogSourcesFor(region: Region): CatalogSource[] {
+  const routes = routesFor(region)
+  const sources = [...routes.catalog]
+  const served = sources.some(source => source.kind === 'npm'
+    && source.registry === routes.npmRegistry && source.pkg === CATALOG_PACKAGE)
+  if (!served) sources.push({ kind: 'npm', registry: routes.npmRegistry, pkg: CATALOG_PACKAGE })
+  return sources
+}
+
 /** Read an environment override, treating blank as unset. */
 function override(env: NodeJS.ProcessEnv, name: string): string | null {
   const raw = env[name]

package/src/registry.ts

@@ -4,9 +4,10 @@
  * behind it any more.
  */
 
+import { logEvent } from './log.ts'
 import { configuredProxy, marketFetch } from './net.ts'
 import { catalogFromPackage } from './catalog-npm.ts'
-import { activeRegion, routesFor, type CatalogSource, type Region } from './regions.ts'
+import { activeRegion, catalogSourcesFor, routesFor, type CatalogSource, type Region } from './regions.ts'
 
 export interface RegistryPlugin {
   name: string
@@ -245,8 +246,23 @@ export async function loadRegistry(region: Region = activeRegion()): Promise<Reg
   // the FIRST request the market makes, so a mirror that has gone down must
   // mean a slow market rather than an empty one — the list ends at the
   // address that has always worked.
-  for (const source of routesFor(region).catalog) {
+  //
+  // The list runs one entry past the region's own sources on purpose (#891):
+  // the region probe measures the npm registry, so it cannot see a network
+  // where npm is fast and the catalog's host is blocked — and the region is
+  // decided once and persisted. The catalog's published package, on the
+  // registry the probe just proved reachable, is the repair that needs
+  // neither the probe nor the decision to change.
+  const ownSources = routesFor(region).catalog.length
+  const catalogSources = catalogSourcesFor(region)
+  for (const [sourceIndex, source] of catalogSources.entries()) {
     const key = sourceKey(source)
+    const servedBy = <T>(data: T): T => {
+      if (sourceIndex >= ownSources) {
+        logEvent('warn', 'registry', `catalog: the ${region} sources did not answer; read the catalog package from ${key} instead (#891)`)
+      }
+      return data
+    }
     // Two attempts each. A catalog fetch crossing a long, lossy path fails
     // transiently often enough that one retry is worth more than the second
     // or two it costs — and with nothing behind this call any more, a
@@ -263,11 +279,11 @@ export async function loadRegistry(region: Region = activeRegion()): Promise<Reg
             source.registry, source.pkg, reusable?.version ?? undefined,
           )
           // `data === null` means the published version is the one in hand.
-          if (data === null && reusable !== null) return reusable.data
+          if (data === null && reusable !== null) return servedBy(reusable.data)
           if (data === null) throw new Error('the catalog package reported no change with nothing to reuse')
           const parsed = asRegistry(data)
           served = { key, etag: null, modified: null, version, data: parsed }
-          return parsed
+          return servedBy(parsed)
         }
         // ETag first: it is exact, while a date has one-second resolution and
         // a catalog republished twice within the same second would validate
@@ -300,7 +316,7 @@ export async function loadRegistry(region: Region = activeRegion()): Promise<Reg
           // Guarded anyway: answering a 304 with nothing to reuse would
           // otherwise surface as a confusing parse error on an empty body.
           if (reusable === null) throw new Error('the catalog answered "not modified" with nothing to revalidate')
-          return reusable.data
+          return servedBy(reusable.data)
         }
         if (!res.ok) throw new Error(`HTTP ${String(res.status)}`)
         const data = asRegistry(JSON.parse(new TextDecoder().decode(
@@ -309,7 +325,7 @@ export async function loadRegistry(region: Region = activeRegion()): Promise<Reg
         served = {
           key, etag: res.headers.get('etag'), modified: res.headers.get('last-modified'), version: null, data,
         }
-        return data
+        return servedBy(data)
       } catch (error) {
         last = error
         failures.push({