@bushizhanghan/dsh-publish-gate 0.2.0 → 0.3.0

package/README.md

@@ -29,11 +29,12 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 
 | 工具 | 作用 |
 |---|---|
-| `publish_gate` | 全量门禁：清单 + 产物 + 运行时 + 网络，返回 `safeToPublish`（`skipPack` / `skipTools` / `skipNetwork` 可逐层跳过） |
+| `publish_gate` | 全量门禁：清单 + 产物 + 运行时 + 浏览器半边 + 网络，返回 `safeToPublish`（`skipPack` / `skipTools` / `skipClient` / `skipNetwork` 可逐层跳过） |
 | `publish_gate_tools` | 只跑运行时层：在子进程里 `apply(ctx)`，看注册了哪些工具、有没有缺 `execute`、重名、`presentCall` 抛错、`card` 用了宿主不认识的值 |
+| `publish_gate_client` | 只跑浏览器半边：在子进程里假造 `window.__ModuleLoader__`，看 bundle 会不会加载、`apply` 会不会抛、到底往哪个服务注册了东西、`inject` 有没有漏 |
 | `publish_gate_verify` | 发后校验：`npm pack --dry-run` 的 shasum 和 registry 上的 `dist.shasum` 逐字节比，比版本号猜准 |
 | `publish_gate_patch` | 只查 `cordis.patch.yml`——「插件装了但工具没出现」的第一个怀疑对象 |
-| `publish_gate_market` | 校验市场条目 YAML（url/name/category/description 双语） |
+| `publish_gate_market` | 校验市场条目 YAML（url/name/category/description 双语）；传 `dir` 则改查只有线上才能回答的三件事：这个仓库**已经在目录里**（再开 PR 就是重复条目）、另一个条目也在发同一个 npm 包、仓库还**不满 24 小时**（提交门禁会失败并自己重跑） |
 | `publish_gate_next_version` | 当前版本、是否已被 registry 占用、建议 bump 到多少（本地比 npm 旧时从 npm 的 latest 往上加，不会推荐一个已被占用的版本） |
 | `publish_gate_doctor` | 扫整个目录，按 blocker 数排序，附带每个插件的真实包体积，看哪个还不能发 |
 | `publish_gate_commands` | 按顺序列出发布命令，并标出这台机器已经走到哪一步 |
@@ -50,9 +51,14 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 | `files-omits-lib` | 发出去是空包——**npm 不警告** |
 | `files-omits-patch` | `dsh.bundle.patch` 指的文件不在 files 里，装上不挂载 |
 | `no-exports` | 缺 `exports["."]`，宿主解析不到入口 |
+| `private-field-set` | 还留着脚手架模板的 `"private": true`，npm 直接 EPRIVATE 拒发 |
 | `client-without-export` | 声明了 client 平台却没导出 `./client`，宿主半边在、侧栏永不出现 |
+| `client-without-platform` | 反过来：导出了 `./client` 却没写 `dsh.client.platform`。文件发出去了，宿主不知道要加载它——装上后一个字节都不执行，而且没有任何报错 |
 | `not-esm` | 没 `"type": "module"`，`import` 在加载时炸 |
 | `no-insert-row` | patch 里只有 override，永远不挂载（页面报的仍然是这条——顶层 `- id:` 是 patch 不是挂载） |
+| `bundle-patch-not-declared` | 有 `cordis.patch.yml` 但清单里没有 `dsh.bundle.patch`——patch 是死的，装了不挂载 |
+| `entry-path-missing` | `main` / `exports["."]` / `exports["./client"]` 指的文件不存在，宿主解析到空 |
+| `inject-missing-*` | 用了 `ctx.tools` / `ctx.web` / `ctx.webServer` / `ctx.setInterval` 却没在 `inject` 里声明，cordis 永远不激活 |
 | `patch-not-mount` | info：这些顶层 `- id:` 是在覆盖已有条目，合法，但**不是**挂载 |
 | `insert-missing-name` / `insert-name-mismatch` | 挂载名缺失或与 package.json 不一致 |
 | `no-patch-file` | 有 `lib/index.js` 但没有 `cordis.patch.yml` |
@@ -63,7 +69,7 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 | `registry-unreachable` | registry 回了 500/429 —— 版本检查**没跑**，所以别把它当干净 |
 
 ### 值得在发布前知道的（warn / info）
-`unscoped-name`（granular token 的 403）、`repo-missing`、`patch-name-unresolvable`（junction 放错层级）、`no-readme` / `readme-no-install` / `readme-no-profile`、`license-mismatch`、`no-tests` / `no-test-files` / `no-test-script`、`no-engines`、`bad-repo-url`、`no-git` / `no-gitignore`、`readme-tool-undocumented`（README 没提这个工具）/ `readme-test-count`（README 写的测试数和真实数不一致），以及市场条目的 `market-*` 全系列。
+`unscoped-name`（granular token 的 403）、`repo-missing`、`patch-name-unresolvable`（junction 放错层级）、`inject-unused-service`（`inject` 里写了个拼错的服务名，cordis 一直等它，插件静默不激活）、`no-publish-config-access`（scoped 包没写 `publishConfig.access`，只是提醒，因为命令里本来就带 `--access public`）、`publish-config-registry`（`publishConfig.registry` 指到内网 registry，版本发到别人装不到的地方）、`no-readme` / `readme-no-install` / `readme-no-profile`、`license-mismatch`、`no-tests` / `no-test-files` / `no-test-script`、`no-engines`、`bad-repo-url`、`no-git` / `no-gitignore`、`readme-tool-undocumented`（README 没提这个工具）/ `readme-test-count`（README 写的测试数和真实数不一致），以及市场条目的 `market-*` 全系列。
 
 ### 产物层：npm 到底会发出什么
 
@@ -73,8 +79,10 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 |---|---|
 | `pack-omits-lib` | tarball 里没有 `lib/`——发出去是空包，**npm 不警告** |
 | `pack-omits-patch` | `dsh.bundle.patch` 指的文件没进 tarball，装上不挂载 |
+| `pack-omits-client` | `exports["./client"]` 指的文件没进 tarball。npm **不会**因为它在 `exports` 里就强制入包（只强制 `main`），所以 `files` 里没写它就会静默丢掉——本地能跑、装了没侧栏 |
 | `pack-omits-readme` / `pack-omits-license` | README / LICENSE 没进包 |
 | `pack-oversize` | 解包 >5 MB 是 error、>1 MB 是 warn，并点名最大的三个文件。测试 fixture 是常见元凶——我的一个插件曾把 20 MB 的算例目录发上去，装了它的人每次都要下 20 MB |
+| `pack-ships-secret` | tarball 里有 `.env` / `.npmrc` / `*.pem` / `*.key` / `id_rsa`。没写 `files` 字段时 npm 会把 `.gitignore` 没排除的一切都打包，而包一发布就是公开的、npm 不会帮你撤回 |
 | `pack-unexpected-dir` | `fixtures` / `test` / `tests` / `src` 被打进包里 |
 | `pack-script-build` | 有 `prepack` / `prepare`：dry run 用了 `--ignore-scripts`，这次清单**不代表**真正发布时的产物 |
 | `pack-unavailable` | npm 跑不起来（warn）——产物层没跑，别把它当干净 |
@@ -92,10 +100,53 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 | `tool-duplicate-name` | 两个工具同名，后者静默覆盖前者 |
 | `tool-present-call-throws` | `presentCall` 抛——调用记录渲染时炸 |
 | `tool-bad-card-kind` | `card: 'generic'` 的 `kind` 不在宿主认识的那一组里（`other` / `execute` / `search` / `read` / `edit` / `delete` / `fetch`）。注册不报错，卡片渲染坏掉——我五个插件一起踩过 |
+| `tool-bad-parameter-type` | `parameters` 里某个 `type` 写错（`"strin"`）。宿主把 `parameters` 渲染进 prompt、但**从不校验**调用值，所以这个 typo 只是悄悄把类型提示弄丢 |
+
+### 浏览器半边：侧栏面板到底会不会出现
+
+清单层只检查「声明了 client 平台就得有 `exports["./client"]`」，可这一步过了之后还能坏很多次。而且它坏得很安静：宿主半边照样跑、工具照样能用，只是侧栏里什么都没有——看起来像 UI bug，其实是打包/注册 bug。
+
+所以这一层真的把那个 bundle 在一个子进程里跑一遍：造一个假的 `window.__ModuleLoader__`、假的 `require('react')`，再给一个 `ctx`——`effect` / `inject` 会立刻执行回调，其余服务（`sidebarRightTabs`、`slots`…）每被调用一次就记一条。
+
+| 规则 | 抓什么 |
+|---|---|
+| `client-file-missing` | `exports["./client"]` 指的文件不存在 |
+| `client-no-module-loader` | bundle 里没有 `window.__ModuleLoader__.load`——宿主根本不会执行它 |
+| `client-load-not-called` | 文件能解析，但跑完没调用 `load`（常见：包在 `if (typeof window !== 'undefined')` 里，判断写错了） |
+| `client-factory-throws` | `factory(require)` 抛 |
+| `client-no-apply` | `factory` 返回的对象里没有 `apply` |
+| `client-apply-throws` | `apply(ctx)` 抛 |
+| `client-no-registration` | `apply` 跑完一次服务都没调用——面板不会出现 |
+| `client-inject-missing-<service>` | `apply` 用了 `ctx.sidebarRightTabs` 但 `inject` 数组里没写它。cordis 不会把没声明的服务给你，于是 `ctx.sidebarRightTabs` 是 `undefined`，`apply` 一碰就抛（或静默什么都没注册） |
+| `client-parse-failed` | 文件有语法错误。**单独判**：`SyntaxError` 说明 bundle 本身是坏的，别的报错说明是沙箱不够真，两者别混为一谈 |
+| `client-unavailable` | 子进程没跑起来（warn）——这一层没跑，别把它当干净 |
+
+### 市场层：提交之前就能知道会不会被打回
+
+本地全绿之后，发布还会在提交门禁那儿停一次。停的原因通常只有三种，而且三种都能提前查：
+
+| 规则 | 抓什么 |
+|---|---|
+| `market-duplicate-entry` | 这个仓库**已经在目录里**。再提一个 PR 就是同一仓库的第二条条目，reviewer 会拒。版本升级根本不需要 PR——目录条目只存 `url` |
+| `market-npm-name-collision` | 另一个条目也在发同一个 npm 包，安装路径会互相盖 |
+| `market-repo-too-new` | 仓库创建不满 24 小时。门禁会报 `0.0 days old` 然后**自己重跑**，PR 不会丢，但在那之前什么都不会合 |
+| `market-no-repo` | `package.json` 里没有 GitHub 地址，没东西可提交 |
+| `market-unavailable` | 目录拉不到（warn）——这几条没跑，别把它当干净 |
 
 ### 代码卫生
 
-`lib-debugger`（error）、`lib-console-log`、`lib-hardcoded-path`（`C:\Users\...` 硬编码）、`lib-url-pathname`（`new URL(...).pathname` 在中文路径上会百分号编码，得用 `fileURLToPath`）、`inject-missing-<service>`（用了 `ctx.tools` / `ctx.web` / `ctx.webServer` / `ctx.setInterval` 却没写进 `inject`，服务永远注入不进来）。
+`lib-debugger`（error）、`lib-console-log`、`lib-hardcoded-path`（`C:\Users\...` 硬编码）、`lib-url-pathname`（`new URL(...).pathname` 在中文路径上会百分号编码，得用 `fileURLToPath`）。
+
+### 构建产物：`src/` 和 `lib/` 谁更新
+
+有 `src/` 的插件（TypeScript 源码 + 构建出来的 `lib/`）最容易在这件事上翻车，而且两种翻车的表现一模一样——**发出去的字节没人跑过**：
+
+| 规则 | 抓什么 |
+|---|---|
+| `stale-build` | `src/` 比 `lib/` 新：构建没跑就发布了，tarball 里是上一次的产物 |
+| `hand-edited-build` | `lib/` 比 `src/` 新：有人直接改了构建产物。下一次干净的构建会**静默丢掉**这些改动，所以发布的字节没法从 `src/` 复现出来 |
+
+两条都只是 warn：有可能你就是要发手改的产物（我干过）。但发之前你得知道自己在发什么。
 
 ## 一个真实的例子
 
@@ -120,6 +171,7 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 ## 设计取舍
 
 - **三层，按代价排序**：清单层最便宜、先跑；产物层要起一个 npm（约 1–2 秒）；运行时层要起一个 node 子进程。前一层没过的错误通常值得先修，但三层都会跑完——一次给全，比来回问好。
+- **浏览器半边单独一层，不并进运行时层**：宿主半边的失败会抛错、会有日志；浏览器半边的失败是「什么都没发生」。两者的排查路径完全不同，所以各起一个子进程、各有一组规则、各自能单独跳过（`skipTools` / `skipClient`）。
 - **产物层用 `npm pack --dry-run`，不用自己推 `files` 规则**：npm 的入包规则（`main` / `exports` 强制入包、README/LICENSE 强制入包、`.npmignore` 优先级）比自己实现的准。唯一的代价是它需要这台机器上有 npm，所以跑不起来时降级成 `pack-unavailable` 而不是报错。
 - **运行时层真的执行插件代码**：这是唯一能回答「装上能不能用」的办法。代价是 `apply()` 会跑，所以：假 ctx 是 Proxy 不落盘、20 秒硬超时、`skipTools` 一键跳过。
 - **`--ignore-scripts`**：dry run 不跑 `prepack`，否则检查会触发一次构建。代价是清单可能和真实产物不同，所以有 `pack-script-build` 把这件事说出来。
@@ -131,8 +183,8 @@ dsh plugin --profile desktop add @bushizhanghan/dsh-publish-gate
 ## 开发
 
 ```sh
-node --test                      # 44 个引擎单测
-node test/integration.test.mjs   # 21 条集成断言（9 个真实插件作 fixture）
+node --test                      # 64 个引擎单测
+node test/integration.test.mjs   # 24 条集成断言（9 个真实插件作 fixture）
 ```
 
 ## License

package/lib/engine.js

@@ -6,7 +6,7 @@
 // unscoped npm name that returned E403, a git push that failed on the network
 // while the REST API worked. All of them are silent until the moment they cost
 // you a publish, so they are all checkable before you spend it.
-import { existsSync, readFileSync, readdirSync } from 'node:fs'
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
@@ -59,6 +59,57 @@ function walkFiles(root, filter, acc = []) {
 /** Drop a trailing // comment so a commented-out line is not reported as live code. */
 const stripComment = (line) => line.replace(/\/\/.*$/, '')
 
+const mtimeOf = (file) => {
+  try {
+    return statSync(file).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
+/**
+ * Which of `src/` and `lib/` was touched last.
+ *
+ * The two failure modes look identical from the outside and both ship code the
+ * author never ran:
+ *   - src newer  -> lib is stale build output. Publishing with --ignore-scripts
+ *     (or a missing prepack) ships the old bytes.
+ *   - lib newer  -> lib was hand-edited after the source. The next clean build
+ *     silently drops those edits, so the published tarball is not reproducible.
+ */
+export function checkBuildFreshness(dir) {
+  const src = join(dir, 'src')
+  if (!existsSync(src)) return []
+  const newest = (root) => walkFiles(root, /\.(?:[cm]?[jt]sx?)$/, []).reduce((max, f) => Math.max(max, mtimeOf(f)), 0)
+  const srcTime = newest(src)
+  const libTime = newest(join(dir, 'lib'))
+  if (!srcTime || !libTime) return []
+  const stamp = (ms) => new Date(ms).toISOString().replace('T', ' ').slice(0, 19)
+  if (srcTime > libTime + 1000) {
+    return [
+      F(
+        'stale-build',
+        'warn',
+        `src/ is newer than lib/ (${stamp(srcTime)} vs ${stamp(libTime)})`,
+        'lib/ is what npm ships. If the build did not run before publish, the tarball carries the old output.',
+        'Run the build (npm run build) and commit the result, or check that prepack runs it.',
+      ),
+    ]
+  }
+  if (libTime > srcTime + 1000) {
+    return [
+      F(
+        'hand-edited-build',
+        'warn',
+        `lib/ is newer than src/ (${stamp(libTime)} vs ${stamp(srcTime)})`,
+        'lib/ was edited after the source. A clean build overwrites it, so the published bytes cannot be reproduced from src/.',
+        'Port the change into src/ and rebuild, or accept that the next build drops it.',
+      ),
+    ]
+  }
+  return []
+}
+
 const bytesHuman = (n) => {
   const v = Number(n) || 0
   return v >= 1_048_576 ? `${(v / 1_048_576).toFixed(1)} MB` : v >= 1024 ? `${Math.round(v / 1024)} kB` : `${v} B`
@@ -201,6 +252,20 @@ export function checkPackageJson(dir) {
       ),
     )
   }
+  // The mirror image, and the quieter one: the bundle ships, but nothing tells
+  // the host to load it. It installs, the host half works, the file is dead
+  // weight — and there is no error anywhere.
+  if (hasClient && !wantsClient) {
+    out.push(
+      F(
+        'client-without-platform',
+        'error',
+        'exports["./client"] is declared but dsh.client.platform is missing',
+        'The host decides whether to fetch a client bundle from dsh.client.platform; without it the file ships and is never loaded.',
+        'Add "dsh": { "client": { "platform": "web" } }.',
+      ),
+    )
+  }
 
   // repository.url — GitHub Actions and the market link use it. Both shapes
   // occur: a bare string, and the {type,url} object npm documents. The object
@@ -211,11 +276,95 @@ export function checkPackageJson(dir) {
     out.push(F('bad-repo-url', 'warn', `repository "${repoRaw}" is not a github.com URL`, 'The market listing and issue links will not resolve.', 'Use "git+https://github.com/<owner>/<repo>.git".'))
   }
 
+  // "private": true is the one flag npm refuses outright (EPRIVATE), and it is
+  // easy to leave behind from a scaffolding template.
+  if (json.private === true) {
+    out.push(
+      F(
+        'private-field-set',
+        'error',
+        '"private": true blocks publishing outright',
+        'npm refuses with EPRIVATE and no partial state, so this is a hard stop rather than a risk.',
+        'Remove "private": true (or set it false) before publishing.',
+      ),
+    )
+  }
+
+  // publishConfig.registry redirects the publish. A leftover internal registry
+  // means the release lands somewhere nobody else can install from.
+  const targetRegistry = json.publishConfig?.registry
+  if (typeof targetRegistry === 'string' && !/^https?:\/\/registry\.npmjs\.org\/?$/.test(targetRegistry)) {
+    out.push(
+      F(
+        'publish-config-registry',
+        'warn',
+        `publishConfig.registry points at ${targetRegistry}`,
+        'npm publishes there instead of the public registry, so the version you announce is not the version consumers can install.',
+        'Remove publishConfig.registry, or confirm that registry is intentional.',
+      ),
+    )
+  }
+
   // engines — a too-low floor lets the install succeed and then crash
   if (!json.engines?.node) {
     out.push(F('no-engines', 'info', 'no engines.node declared', 'Consumers on an older Node get a runtime error instead of an install-time message.', 'Add "engines": { "node": ">=22" }.'))
   }
 
+  // Scoped packages default to restricted. Publish one without --access public
+  // (or publishConfig.access) and it installs for you and 404s for everyone
+  // else — the publish output says nothing about it. Info, not a defect:
+  // `publish_gate_commands` always emits --access public, so this is a
+  // reminder to make that explicit in the manifest rather than to change it.
+  if (typeof json.name === 'string' && json.name.startsWith('@') && json.publishConfig?.access !== 'public') {
+    out.push(
+      F(
+        'no-publish-config-access',
+        'info',
+        'scoped name without publishConfig.access: "public"',
+        'npm publishes a scoped package as restricted unless you pass --access public or set publishConfig.access. A restricted package installs fine on the machine that published it and 404s for every other consumer, with no hint in the publish output. Already-public packages stay public, so this only matters on a first publish.',
+        'Add "publishConfig": { "access": "public" }, or always publish with --access public (publish_gate_commands does).',
+      ),
+    )
+  }
+
+  // The patch file is inert without the declaration. The host mounts a plugin
+  // through dsh.bundle.patch; with the file present but undeclared, the plugin
+  // installs, the entry loads, and no tool or panel ever appears.
+  if (existsSync(join(dir, 'cordis.patch.yml')) && !json.dsh?.bundle?.patch) {
+    out.push(
+      F(
+        'bundle-patch-not-declared',
+        'error',
+        'cordis.patch.yml exists but dsh.bundle.patch is not declared',
+        'The host mounts a plugin through dsh.bundle.patch. Without the declaration the patch file is inert: the plugin installs, its entry loads, and no tool or panel ever appears. Nothing reports an error, because from the host point of view nothing was ever asked of it.',
+        'Add "dsh": { "bundle": { "patch": "./cordis.patch.yml" } }.',
+      ),
+    )
+  }
+
+  // Entry paths pointing at files that are not there. npm does not validate
+  // them, so the package publishes and every consumer hits a bare
+  // MODULE_NOT_FOUND that never names the manifest field responsible.
+  const entryTargets = [
+    ['main', typeof json.main === 'string' ? json.main : null],
+    ['exports["."]', typeof json.exports === 'object' && json.exports ? json.exports['.'] : null],
+    ['exports["./client"]', typeof json.exports === 'object' && json.exports ? json.exports['./client'] : null],
+  ]
+  for (const [field, target] of entryTargets) {
+    if (typeof target !== 'string' || target.includes('*')) continue
+    const rel = target.replace(/^\.\//, '')
+    if (existsSync(join(dir, rel))) continue
+    out.push(
+      F(
+        'entry-path-missing',
+        'error',
+        `${field} points at "${target}", which does not exist`,
+        'The manifest publishes, the package resolves, and the import then fails at load time with a MODULE_NOT_FOUND that does not name the field responsible.',
+        `Create ${target}, or point ${field} at the file you actually ship.`,
+      ),
+    )
+  }
+
   return out
 }
 
@@ -522,6 +671,118 @@ export function checkMarketEntry(text) {
   return out
 }
 
+// The submission gate is where a release stalls after all the local checks are
+// green: the catalogue already has this repo (a duplicate PR), the repo is too
+// young (the gate fails with "0.0 days old" and only reruns on its own), or the
+// name is taken. All three are visible before opening the PR — this reads the
+// live catalogue and the GitHub repo metadata instead of guessing.
+const CATALOGUE_URL = 'https://awesome-dsh-plugin.com/plugins.json'
+let catalogueCache = null
+
+export function repoSlug(dir) {
+  const json = readPkgJson(dir)
+  const raw = typeof json?.repository === 'string' ? json.repository : json?.repository?.url
+  if (typeof raw !== 'string') return null
+  const m = /github\.com[/:]([^/\s]+)\/([^/\s#?]+?)(?:\.git)?$/.exec(raw.replace(/^git\+/, ''))
+  return m ? `${m[1]}/${m[2]}` : null
+}
+
+export async function checkMarketReadiness(dir, opts = {}) {
+  const out = []
+  const timeoutMs = opts.timeoutMs ?? 8000
+  const slug = repoSlug(dir)
+  if (!slug) {
+    out.push(F('market-no-repo', 'warn', 'package.json has no GitHub repository', 'The market lists GitHub repos; without one there is nothing to submit.', 'Add repository.url.'))
+    return out
+  }
+  const json = readPkgJson(dir)
+  const pkgName = typeof json?.name === 'string' ? json.name : null
+
+  let entries = Array.isArray(opts.entries) ? opts.entries : null
+  try {
+    if (!entries) {
+      if (!catalogueCache) {
+        const res = await fetch(CATALOGUE_URL, { signal: AbortSignal.timeout(timeoutMs), headers: { 'user-agent': 'dsh-publish-gate' } })
+        if (!res.ok) throw new Error(`HTTP ${res.status}`)
+        const data = await res.json()
+        catalogueCache = Array.isArray(data) ? data : Array.isArray(data?.plugins) ? data.plugins : []
+      }
+      entries = catalogueCache
+    }
+  } catch (error) {
+    out.push(
+      F(
+        'market-unavailable',
+        'warn',
+        'the market catalogue could not be read',
+        `The duplicate and name-collision checks did not run, so this is NOT a clean market report. ${String(error?.message || error).slice(0, 120)}`,
+        'Retry when the network is available.',
+      ),
+    )
+    return out
+  }
+
+  const sameRepo = entries.filter((e) => typeof e?.url === 'string' && e.url.toLowerCase().includes(slug.toLowerCase()))
+  if (sameRepo.length > 0) {
+    out.push(
+      F(
+        'market-duplicate-entry',
+        'warn',
+        `${slug} is already in the market catalogue`,
+        `Listed as "${sameRepo[0].name}" (category ${sameRepo[0].category}). A new submission PR adds a second entry for the same repo, which reviewers reject.`,
+        'Update the existing entry instead of adding one — a version bump needs no PR at all.',
+      ),
+    )
+  }
+  if (pkgName) {
+    const sameName = entries.filter((e) => e?.npm === pkgName && !sameRepo.includes(e))
+    if (sameName.length > 0) {
+      out.push(
+        F(
+          'market-npm-name-collision',
+          'warn',
+          `another catalogue entry also publishes ${pkgName}`,
+          `Listed as "${sameName[0].name}" — two entries installing the same npm package confuse the install path.`,
+          'Check whether one of them is stale.',
+        ),
+      )
+    }
+  }
+
+  // The gate rejects a repo younger than a day and only reruns by itself, so
+  // opening the PR earlier wastes a round trip.
+  let repoInfo = opts.repoInfo ?? null
+  if (!repoInfo) {
+    try {
+      const res = await fetch(`https://api.github.com/repos/${slug}`, {
+        signal: AbortSignal.timeout(timeoutMs),
+        headers: { 'user-agent': 'dsh-publish-gate', accept: 'application/vnd.github+json' },
+      })
+      if (res.ok) repoInfo = await res.json()
+    } catch {
+      // a blocked GitHub API only costs the age hint
+    }
+  }
+  if (repoInfo?.created_at) {
+    const created = Date.parse(repoInfo.created_at)
+    if (Number.isFinite(created)) {
+      const hours = (Date.now() - created) / 3_600_000
+      if (hours < 24) {
+        out.push(
+          F(
+            'market-repo-too-new',
+            'warn',
+            `the repo is ${hours.toFixed(1)}h old; the submission gate needs 24h`,
+            'The gate fails with a "repo too new" message and reruns on its own, so the PR is not lost — but nothing merges until it passes.',
+            'Wait until the repo is a day old before submitting.',
+          ),
+        )
+      }
+    }
+  }
+  return out
+}
+
 // =====================================================================
 // Source sanity: the entry protocol
 // =====================================================================
@@ -537,9 +798,17 @@ export function checkEntrySource(dir) {
   if (!/export\s+const\s+inject/.test(text)) out.push(F('no-inject', 'warn', 'lib/index.js does not export `inject`', 'Without an inject list the service is resolved late and `ctx.tools` may be undefined when apply runs.', 'Add `export const inject = [\'tools\']`.'))
   // require() in ESM blows up at load
   // Any call form, including destructuring and a member access: `const {a} = require(…)`,
-  // `x = require(…)`, `require('node:fs').readFileSync`. A bare `require(` inside a
-  // string is not matched because the regex requires a call with a quote argument.
-  if (/\brequire\s*\(\s*['"`]/.test(text)) {
+  // `x = require(…)`, `require('node:fs').readFileSync`. Quoted literals are removed
+  // first, because a tool description that *mentions* `require("react")` is prose —
+  // this rule fired on this plugin's own description until that was fixed.
+  const code = text
+    .split('\n')
+    .map(stripComment)
+    .join('\n')
+    .replace(/'(?:[^'\\\n]|\\.)*'/g, "''")
+    .replace(/"(?:[^"\\\n]|\\.)*"/g, '""')
+    .replace(/`(?:[^`\\]|\\.)*`/g, '``')
+  if (/\brequire\s*\(\s*['"`]/.test(code)) {
     out.push(
       F(
         'require-in-esm',
@@ -660,9 +929,39 @@ export async function checkPack(dir, opts = {}) {
       ),
     )
   }
+  // The browser half can work in dev and be absent from the package: `files`
+  // is usually ["lib"], so a bundle that lives anywhere else silently drops out.
+  const clientRel = typeof json?.exports === 'object' && json?.exports ? json.exports['./client'] : null
+  if (typeof clientRel === 'string' && !clientRel.includes('*') && !paths.includes(clientRel.replace(/^\.\//, ''))) {
+    out.push(
+      F(
+        'pack-omits-client',
+        'error',
+        `the tarball does not contain ${clientRel}`,
+        'exports["./client"] points at a file npm did not pack, so the installed plugin has no browser half even though it works from the checkout.',
+        'Add its directory to files, or move the bundle under lib/.',
+      ),
+    )
+  }
   if (!paths.includes('README.md')) out.push(F('pack-omits-readme', 'warn', 'the tarball has no README.md', 'npm renders it as the package page and the market reviewer reads it.', 'Add "README.md" to files.'))
   if (!paths.includes('LICENSE')) out.push(F('pack-omits-license', 'warn', 'the tarball has no LICENSE', 'npm warns on publish and consumers get an unlicensed package.', 'Add "LICENSE" to files.'))
 
+  // A tarball that carries credentials is worse than any other finding here:
+  // npm never expires them and the market mirrors the tarball.
+  const SECRET = /(?:^|\/)(?:\.env(?:\..+)?|\.npmrc|\.netrc|id_rsa|id_ed25519)$|\.(?:pem|key|p12|pfx)$/i
+  const secrets = paths.filter((p) => SECRET.test(p))
+  if (secrets.length > 0) {
+    out.push(
+      F(
+        'pack-ships-secret',
+        'error',
+        `the tarball contains ${secrets.length} credential-shaped file(s)`,
+        `${secrets.slice(0, 5).join(', ')} — npm does not expire these and the tarball is public the moment it is published. Without a "files" field npm packs everything .gitignore does not exclude.`,
+        'Delete them from the package and narrow "files".',
+      ),
+    )
+  }
+
   const unpacked = Number(pack.unpackedSize ?? 0)
   if (unpacked > warnBytes) {
     const biggest = [...files]
@@ -722,6 +1021,18 @@ import { pathToFileURL } from 'node:url'
 import { join } from 'node:path'
 const dir = process.argv[1]
 const registered = []
+// The host renders \`parameters\` into the prompt and never validates the value
+// against it, so a typo like "strin" silently removes the type hint.
+const JSON_TYPES = new Set(['string', 'number', 'integer', 'boolean', 'object', 'array', 'null'])
+const badParamTypes = []
+const walkParams = (schema, path) => {
+  if (!schema || typeof schema !== 'object') return
+  if (typeof schema.type === 'string' && !JSON_TYPES.has(schema.type)) badParamTypes.push(path + '.type=' + schema.type)
+  if (schema.properties && typeof schema.properties === 'object') {
+    for (const [key, sub] of Object.entries(schema.properties)) walkParams(sub, path + '.' + key)
+  }
+  if (schema.items) walkParams(schema.items, path + '[]')
+}
 const noopService = () => new Proxy(function () {}, {
   get: (target, prop) => {
     // Own properties win, or ctx.tools would resolve to another no-op proxy
@@ -752,6 +1063,7 @@ ctx.tools = {
       hasOutputSchema: Boolean(def && def.output && def.output.schema),
       cardKind: card,
     })
+    walkParams(def?.parameters, typeof def?.name === 'string' ? def.name : '(unnamed)')
   },
 }
 const emit = (payload) => process.stdout.write('\\n@@PG@@' + JSON.stringify(payload) + '\\n')
@@ -761,7 +1073,7 @@ try {
   stage = 'apply'
   if (typeof mod.apply !== 'function') throw new Error('lib/index.js does not export apply')
   await mod.apply(ctx, {})
-  emit({ ok: true, tools: registered })
+  emit({ ok: true, tools: registered, badParamTypes })
 } catch (error) {
   emit({ ok: false, stage, error: String((error && error.message) || error) })
 }
@@ -842,6 +1154,18 @@ export async function checkToolRegistrations(dir, opts = {}) {
       )
     }
   }
+  const badParams = Array.isArray(payload.badParamTypes) ? payload.badParamTypes : []
+  for (const where of badParams) {
+    out.push(
+      F(
+        'tool-bad-parameter-type',
+        'warn',
+        `a parameters schema uses an unknown type at ${where}`,
+        'The host renders parameters into the prompt and never validates a call against it, so a typo like "strin" removes the type hint with no error anywhere.',
+        'Use one of string, number, integer, boolean, object, array, null.',
+      ),
+    )
+  }
   return { findings: out, tools }
 }
 
@@ -905,9 +1229,227 @@ export function checkInjectCoverage(dir) {
       ),
     )
   }
+
+  // The other direction. cordis waits for every declared service before apply
+  // runs, so a misspelled entry ('tool' for 'tools') leaves the plugin pending
+  // forever with no error at all — the tools simply never appear. Scan every
+  // lib file, so a service used from a helper still counts as used.
+  const all = walkFiles(join(dir, 'lib'), /\.(?:js|mjs|cjs)$/)
+    .map((f) => safeText(f))
+    .filter((t) => t !== null)
+    .map((t) => t.split('\n').map(stripComment).join('\n'))
+    .join('\n')
+  for (const name of names) {
+    const usage = INJECT_HINTS.find(([service]) => service === name)?.[1] ?? new RegExp(`ctx\\.${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`)
+    if (usage.test(all)) continue
+    out.push(
+      F(
+        'inject-unused-service',
+        'warn',
+        `inject declares "${name}" but no lib file uses ctx.${name}`,
+        'cordis resolves every injected service before apply runs. A misspelled or leftover entry keeps the plugin pending forever without an error message — the tools just never appear, and the plugin looks installed.',
+        `Fix the spelling, or remove "${name}" from inject.`,
+      ),
+    )
+  }
+  return out
+}
+
+// =====================================================================
+// The browser half. It is the half that fails silently: the host half keeps
+// working, so a panel that never registers looks like a UI bug.
+// =====================================================================
+
+const clientTarget = (json) => (typeof json?.exports === 'object' && json?.exports ? json.exports['./client'] : null)
+
+export function checkClientHalf(dir) {
+  const out = []
+  const json = readPkgJson(dir)
+  const target = clientTarget(json)
+  if (typeof target !== 'string') return out // client-without-export covers the other direction
+  const file = join(dir, target.replace(/^\.\//, ''))
+  if (!existsSync(file)) {
+    out.push(
+      F(
+        'client-file-missing',
+        'error',
+        `exports["./client"] points at ${target}, which does not exist`,
+        'The host asks for the client bundle, gets MODULE_NOT_FOUND, and the panel never appears — while the host half keeps working, so nothing looks broken.',
+        `Ship ${target}.`,
+      ),
+    )
+    return out
+  }
+  const text = safeText(file)
+  if (text === null) return out
+  const code = text.split('\n').map(stripComment).join('\n')
+  if (!/__ModuleLoader__/.test(code)) {
+    out.push(
+      F(
+        'client-no-module-loader',
+        'error',
+        `${target} never calls window.__ModuleLoader__.load()`,
+        'The host evaluates the bundle and looks for a factory registered through __ModuleLoader__. A bundle that never registers one is loaded and discarded: no error, no panel.',
+        'Wrap the module in window.__ModuleLoader__.load({ id, factory }).',
+      ),
+    )
+  }
   return out
 }
 
+// Evaluates the bundle in a child process: fake window, fake module loader,
+// fake React, fake ctx. Answers the question the source cannot: does apply()
+// actually register anything, and does it touch a service it forgot to inject?
+const CLIENT_RUNNER = `
+const { readFileSync } = await import('node:fs')
+// With -e, the extra argument lands at argv[1]; there is no script path.
+const file = process.argv[2] || process.argv[1]
+const records = { loaded: 0, id: null, parseError: null, evalError: null, factoryError: null, hasApply: false, inject: null, applyError: null, registrations: [], services: [] }
+const noop = () => {}
+const serviceProxy = (name) => new Proxy({}, {
+  get(_t, prop) {
+    if (prop === 'then') return undefined
+    if (prop === 'inject') return (_slot, fn) => { try { return fn() } catch (e) { records.applyError = records.applyError || String(e && e.message || e); return noop } }
+    return () => { records.registrations.push(name + '.' + String(prop)); return noop }
+  },
+})
+const fakeCtx = new Proxy({}, {
+  get(_t, prop) {
+    if (prop === 'then') return undefined
+    if (prop === 'effect') return (fn) => { try { return fn() } catch (e) { records.applyError = records.applyError || String(e && e.message || e); return noop } }
+    if (prop === 'on' || prop === 'emit' || prop === 'off') return noop
+    records.services.push(String(prop))
+    return serviceProxy(String(prop))
+  },
+})
+globalThis.window = {
+  __ModuleLoader__: {
+    load(spec) {
+      records.loaded += 1
+      records.id = spec && spec.id
+      if (typeof spec?.factory !== 'function') { records.factoryError = 'factory is not a function'; return }
+      const fakeRequire = (name) => {
+        if (name === 'react') {
+          return { createElement: () => null, useState: (v) => [v, noop], useEffect: noop, useMemo: (f) => f(), useCallback: (f) => f, useRef: (v) => ({ current: v }), Fragment: 'fragment' }
+        }
+        return new Proxy({}, { get: () => noop })
+      }
+      let mod
+      try { mod = spec.factory(fakeRequire) } catch (e) { records.factoryError = String(e && e.message || e); return }
+      records.hasApply = typeof mod?.apply === 'function'
+      records.inject = Array.isArray(mod?.inject) ? mod.inject : null
+      if (!records.hasApply) return
+      try { mod.apply(fakeCtx) } catch (e) { records.applyError = String(e && e.message || e) }
+    },
+  },
+}
+globalThis.fetch = () => Promise.reject(new Error('stubbed by publish-gate'))
+const stub = new Proxy(function () {}, { get: (_t, p) => (p === 'then' ? undefined : stub), apply: () => stub, construct: () => stub })
+// Node already defines some of these as getter-only (navigator), so a plain
+// assignment throws and would abort the whole probe.
+for (const name of ['document', 'localStorage', 'sessionStorage', 'navigator', 'location', 'history', 'getComputedStyle', 'requestAnimationFrame', 'cancelAnimationFrame', 'matchMedia']) {
+  try { globalThis[name] = stub } catch { try { Object.defineProperty(globalThis, name, { value: stub, configurable: true, writable: true }) } catch {} }
+}
+let source = ''
+try { source = readFileSync(file, 'utf8') } catch (e) { records.parseError = 'unreadable: ' + String(e && e.message || e) }
+if (!records.parseError) {
+  try { new Function(source)() } catch (e) {
+    const text = String(e && e.message || e)
+    if (e && e.name === 'SyntaxError') records.parseError = text
+    else records.evalError = text
+  }
+}
+process.stdout.write('\\n@@PG@@' + JSON.stringify(records))
+process.exit(0)
+`
+
+export async function checkClientRuntime(dir, opts = {}) {
+  const out = []
+  const json = readPkgJson(dir)
+  const target = clientTarget(json)
+  if (typeof target !== 'string') return { findings: out, client: null }
+  const file = join(dir, target.replace(/^\.\//, ''))
+  if (!existsSync(file)) return { findings: out, client: null } // checkClientHalf names it
+  const timeoutMs = opts.timeoutMs || 20000
+
+  let stdout
+  try {
+    ;({ stdout } = await runFile(process.execPath, ['--input-type=module', '-e', CLIENT_RUNNER, file], { timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, windowsHide: true }))
+  } catch (error) {
+    // execFile's own message is the whole command line; stderr has the reason.
+    const why = String(error.stderr || error.message || error).trim().split('\n').filter(Boolean).slice(-3).join(' ').slice(0, 300)
+    out.push(
+      F(
+        'client-unavailable',
+        'warn',
+        'the client bundle could not be evaluated',
+        `${why} — the runtime layer did not run, so treat this bundle as unverified.`,
+        'Check that the file parses as a classic script, or pass skipClient.',
+      ),
+    )
+    return { findings: out, client: null }
+  }
+  const m = /@@PG@@(.*)$/m.exec(stdout)
+  if (!m) {
+    out.push(F('client-unavailable', 'warn', 'the client probe produced no result', 'The child process exited without reporting — the bundle may call process.exit() or loop forever.', 'Run the bundle by hand, or pass skipClient.'))
+    return { findings: out, client: null }
+  }
+  const r = JSON.parse(m[1])
+
+  if (r.parseError) {
+    out.push(F('client-parse-failed', 'error', `${target} does not parse: ${String(r.parseError).slice(0, 160)}`, 'The host evaluates this file as a classic script. A syntax error there means the whole client half never runs.', 'Fix the syntax error.'))
+    return { findings: out, client: r }
+  }
+  if (r.loaded === 0) {
+    out.push(
+      F(
+        'client-load-not-called',
+        'error',
+        `${target} ran without calling window.__ModuleLoader__.load()`,
+        'Nothing was registered with the module loader, so the host has no factory to call: the bundle is loaded and discarded with no error and no panel.',
+        'Register through window.__ModuleLoader__.load({ id, factory }) unconditionally.',
+      ),
+    )
+  }
+  if (r.factoryError) {
+    out.push(F('client-factory-throws', 'error', `the factory in ${target} throws: ${String(r.factoryError).slice(0, 160)}`, 'The host calls the factory to get the module. A throw here aborts the panel and can leave the surrounding UI pending.', 'Fix the throw, or move the work into apply().'))
+  }
+  if (r.loaded > 0 && !r.hasApply && !r.factoryError) {
+    out.push(F('client-no-apply', 'error', `the factory in ${target} returns no apply()`, 'The host calls module.apply(ctx) to let the panel register itself. Without it the factory result is inert.', 'Return { apply, inject } from the factory.'))
+  }
+  if (r.applyError) {
+    out.push(F('client-apply-throws', 'error', `apply() in ${target} throws: ${String(r.applyError).slice(0, 160)}`, 'Registration happens inside apply(); a throw there leaves the panel unregistered while the host half keeps working.', 'Wrap the failing registration, or fix the cause.'))
+  }
+  if (r.hasApply && !r.applyError && r.registrations.length === 0) {
+    out.push(
+      F(
+        'client-no-registration',
+        'warn',
+        `apply() in ${target} registered nothing`,
+        'apply() ran and touched no slot or tab registration. The panel is loaded, mounted nowhere, and there is no error to find.',
+        'Call ctx.slots.inject(...) / ctx.<tab>.register(...) inside apply().',
+      ),
+    )
+  }
+  if (Array.isArray(r.inject)) {
+    const declared = new Set(r.inject)
+    const used = new Set(r.services.filter((s) => s !== 'effect'))
+    for (const service of used) {
+      if (declared.has(service)) continue
+      out.push(
+        F(
+          `client-inject-missing-${service}`,
+          'warn',
+          `apply() in ${target} uses ctx.${service} but inject does not list it`,
+          'The client loader resolves injected services before calling apply. Without the entry the property can be undefined at that moment, so the registration throws or silently does nothing.',
+          `Add "${service}" to the inject array the factory returns.`,
+        ),
+      )
+    }
+  }
+  return { findings: out, client: r }
+}
+
 export function checkReadmeTruth(dir, toolNames = null) {
   const out = []
   const text = safeText(join(dir, 'README.md'))
@@ -1001,11 +1543,13 @@ export async function checkPublishedMatches(name, version, localPack, { registry
 export async function runArtifactChecks(dir, opts = {}) {
   const packResult = opts.skipPack ? { findings: [], pack: null } : await checkPack(dir, opts)
   const toolResult = opts.skipTools ? { findings: [], tools: null } : await checkToolRegistrations(dir, opts)
+  const clientResult = opts.skipClient ? { findings: [], client: null } : await checkClientRuntime(dir, opts)
   const names = toolResult.tools ? toolResult.tools.map((t) => t.name).filter(Boolean) : null
   return {
-    findings: [...packResult.findings, ...toolResult.findings, ...checkReadmeTruth(dir, names)],
+    findings: [...packResult.findings, ...toolResult.findings, ...clientResult.findings, ...checkReadmeTruth(dir, names)],
     pack: packResult.pack,
     tools: toolResult.tools,
+    client: clientResult.client,
   }
 }
 
@@ -1018,7 +1562,9 @@ export function runStaticChecks(dir) {
     ...checkPatchYml(dir),
     ...checkEntrySource(dir),
     ...checkInjectCoverage(dir),
+    ...checkClientHalf(dir),
     ...checkLibHygiene(dir),
+    ...checkBuildFreshness(dir),
     ...checkDocs(dir),
     ...checkTests(dir),
     ...checkNpmState(dir),
@@ -1028,20 +1574,25 @@ export function runStaticChecks(dir) {
 
 const RULE_ORDER = [
   'missing-file', 'unreadable', 'utf8-bom', 'json-parse', 'yaml-bom', 'invalid-name', 'invalid-version',
-  'missing-field', 'not-esm', 'files-omits-lib', 'files-omits-patch', 'no-exports', 'client-without-export',
+  'missing-field', 'not-esm', 'files-omits-lib', 'files-omits-patch', 'no-exports', 'client-without-export', 'client-without-platform',
+  'entry-path-missing', 'bundle-patch-not-declared', 'no-publish-config-access', 'private-field-set', 'publish-config-registry',
+  'client-file-missing', 'client-no-module-loader', 'client-parse-failed', 'client-load-not-called',
+  'client-factory-throws', 'client-no-apply', 'client-apply-throws', 'client-no-registration',
+  'client-inject-missing-slots', 'client-inject-missing-sidebarRightTabs', 'client-unavailable',
   'no-patch-file', 'no-insert-row', 'insert-missing-name', 'insert-name-mismatch',
   'patch-name-unresolvable', 'no-name-export', 'no-apply-export', 'no-inject', 'require-in-esm',
   'entry-import-failed', 'apply-threw', 'tools-unavailable',
   'inject-missing-tools', 'inject-missing-web', 'inject-missing-webServer', 'inject-missing-timer',
+  'inject-unused-service',
   'tool-missing-name', 'tool-duplicate-name', 'tool-missing-execute', 'tool-present-call-throws',
-  'tool-bad-card-kind', 'tool-missing-output-schema', 'tool-none-registered',
-  'lib-debugger', 'lib-console-log', 'lib-hardcoded-path', 'lib-url-pathname',
-  'pack-omits-lib', 'pack-omits-patch', 'pack-oversize', 'pack-omits-readme', 'pack-omits-license',
+  'tool-bad-card-kind', 'tool-missing-output-schema', 'tool-none-registered', 'tool-bad-parameter-type',
+  'lib-debugger', 'lib-console-log', 'lib-hardcoded-path', 'lib-url-pathname', 'stale-build', 'hand-edited-build',
+  'pack-omits-lib', 'pack-omits-patch', 'pack-omits-client', 'pack-oversize', 'pack-omits-readme', 'pack-omits-license', 'pack-ships-secret',
   'pack-unexpected-dir', 'pack-script-build', 'pack-unavailable',
   'no-license', 'license-mismatch', 'version-taken', 'registry-unreachable', 'publish-not-served',
   'publish-served-mismatch', 'publish-served', 'market-empty', 'market-no-url', 'market-url-not-github',
-  'market-no-name', 'market-name-shape', 'market-no-category', 'market-bad-category', 'market-no-desc',
-  'market-no-en', 'market-no-zh', 'unscoped-name', 'no-git', 'no-readme', 'readme-no-install', 'readme-no-profile',
+  'market-no-name', 'market-name-shape', 'market-no-category', 'market-bad-category', 'market-no-desc', 'market-no-en', 'market-no-zh', 'unscoped-name', 'no-git', 'no-readme', 'readme-no-install', 'readme-no-profile',
+  'market-no-repo', 'market-unavailable', 'market-duplicate-entry', 'market-npm-name-collision', 'market-repo-too-new',
   'readme-tool-undocumented', 'readme-test-count',
   'no-tests', 'no-test-files', 'no-test-script', 'no-engines', 'bad-repo-url', 'no-gitignore',
 ]

package/lib/index.js

@@ -13,6 +13,7 @@ import {
   checkEntrySource,
   checkGitState,
   checkMarketEntry,
+  checkMarketReadiness,
   checkNpmState,
   checkPackageJson,
   checkPack,
@@ -20,6 +21,7 @@ import {
   checkPublishedMatches,
   checkTests,
   checkToolRegistrations,
+  checkClientRuntime,
   checkVersionTaken,
   compareVersions,
   latestPublished,
@@ -89,7 +91,7 @@ export function apply(ctx, config = {}) {
     {
       name: 'publish_gate',
       description:
-        'Run the full pre-publish gate over a DSH plugin directory. Three layers. (1) Manifest: missing exports["."], files omitting lib/, no "type": "module", UTF-8 BOM, JSON/YAML parse errors, cordis.patch.yml insert rows at the wrong indent (the bug that makes a plugin install and never mount), insert name mismatches, missing entry exports, missing LICENSE or README install line, missing tests, unscoped npm names (the 403 you cannot diagnose). (2) Artifact: runs `npm pack --dry-run` and reads what npm will actually ship — lib/ missing from the tarball, a dsh.bundle.patch that never gets packed, oversize tarballs (test fixtures are the usual cause), dev directories shipping, and a prepack hook that means the dry run did not build. (3) Runtime: imports the entry in an isolated child process, calls apply(ctx) with a fake ctx, and reports a throwing import, a throwing apply, tools with no execute, duplicate tool names, a presentCall that throws, and card kinds the host does not render. Deterministic: every rule is a file, subprocess or API check, no LLM. Returns {ok, report, findings:[{rule,severity,title,detail,fix}], counts}.',
+        'Run the full pre-publish gate over a DSH plugin directory. Three layers. (1) Manifest: missing exports["."], files omitting lib/, no "type": "module", UTF-8 BOM, JSON/YAML parse errors, cordis.patch.yml insert rows at the wrong indent (the bug that makes a plugin install and never mount), insert name mismatches, missing entry exports, an entry path that points at no file, a cordis.patch.yml the manifest never declares (inert), missing LICENSE or README install line, missing tests, unscoped npm names (the 403 you cannot diagnose). (2) Artifact: runs `npm pack --dry-run` and reads what npm will actually ship — lib/ missing from the tarball, a dsh.bundle.patch that never gets packed, oversize tarballs (test fixtures are the usual cause), dev directories shipping, and a prepack hook that means the dry run did not build. (3) Runtime: imports the entry in an isolated child process, calls apply(ctx) with a fake ctx, and reports a throwing import, a throwing apply, tools with no execute, duplicate tool names, a presentCall that throws, and card kinds the host does not render; then, if the package declares exports["./client"], loads the browser bundle against a fake window.__ModuleLoader__ and reports a bundle that never loads, never returns apply, throws, or registers nothing. Deterministic: every rule is a file, subprocess or API check, no LLM. Returns {ok, report, findings:[{rule,severity,title,detail,fix}], counts}.',
       parameters: {
         type: 'object',
         properties: {
@@ -97,13 +99,14 @@ export function apply(ctx, config = {}) {
           skipNetwork: { type: 'boolean', description: 'Skip the npm registry and GitHub checks (default false).' },
           skipPack: { type: 'boolean', description: 'Skip `npm pack --dry-run` (default false). Faster, but says nothing about the real tarball.' },
           skipTools: { type: 'boolean', description: 'Skip the isolated import of the plugin entry (default false).' },
+          skipClient: { type: 'boolean', description: 'Skip the isolated load of the browser bundle (default false).' },
         },
       },
       async execute(args) {
         const dir = resolveDir(args.dir)
         if (!dir) return { ok: false, error: 'no plugin directory given and cwd has no package.json' }
         const findings = runStaticChecks(dir)
-        const artifact = await runArtifactChecks(dir, { skipPack: args.skipPack, skipTools: args.skipTools })
+        const artifact = await runArtifactChecks(dir, { skipPack: args.skipPack, skipTools: args.skipTools, skipClient: args.skipClient })
         findings.push(...artifact.findings)
         if (!args.skipNetwork) findings.push(...(await networkGate(dir)))
         const counts = {
@@ -117,6 +120,7 @@ export function apply(ctx, config = {}) {
           counts,
           findings,
           tools: artifact.tools,
+          client: artifact.client,
           unpackedSize: artifact.pack?.unpackedSize ?? null,
           report: renderReport(findings, { title: `publish gate · ${dir}` }),
           safeToPublish: counts.error === 0,
@@ -141,6 +145,24 @@ export function apply(ctx, config = {}) {
         return { ok: true, tools, findings, report: renderReport(findings, { title: `runtime gate · ${dir}` }) }
       },
     },
+    {
+      name: 'publish_gate_client',
+      description:
+        'Load a plugin\'s browser bundle in an isolated child process and report whether it would actually appear in the UI. A client half fails silently: the host half keeps working, so a panel that never registers looks like a UI bug rather than a packaging one. Reproduces the host contract — a fake window.__ModuleLoader__.load({id, factory}), a fake require("react"), a ctx whose effect/inject run the callback and whose services record every call — then reports: the file declared in exports["./client"] is missing, the bundle never calls load, the factory throws, it returns no apply, apply throws, apply registers nothing, the bundle uses a service its own inject array omits (cordis never hands it over, so the panel is blank), and a SyntaxError anywhere in the file. 20 s timeout, plugin code never runs in the host process. Returns {ok, client:{loaded,id,hasApply,inject,registrations,services,parseError,evalError,factoryError,applyError}, findings, report}.',
+      parameters: {
+        type: 'object',
+        properties: {
+          dir: { type: 'string', description: 'Plugin directory.' },
+          timeoutMs: { type: 'number', description: 'Kill the child after this long (default 20000).' },
+        },
+      },
+      async execute(args) {
+        const dir = resolveDir(args.dir)
+        if (!dir) return { ok: false, error: 'no plugin directory given' }
+        const { findings, client } = await checkClientRuntime(dir, { timeoutMs: args.timeoutMs })
+        return { ok: true, client, findings, report: renderReport(findings, { title: `client gate · ${dir}` }) }
+      },
+    },
     {
       name: 'publish_gate_verify',
       description:
@@ -194,15 +216,22 @@ export function apply(ctx, config = {}) {
     {
       name: 'publish_gate_market',
       description:
-        'Validate a market submission entry (the YAML you put in data/plugins/<owner>__<repo>.yml): url is a GitHub URL, name is owner/repo, category is one the market knows, and description carries both en: and zh:. Catches the shape errors the submission gate rejects. Returns {ok, findings, report, entry}.',
+        'Validate a market submission entry (the YAML you put in data/plugins/<owner>__<repo>.yml): url is a GitHub URL, name is owner/repo, category is one the market knows, and description carries both en: and zh:. Catches the shape errors the submission gate rejects. Pass dir instead to run the pre-submission checks that only the live catalogue can answer: this repo is already listed (a duplicate PR), another entry publishes the same npm package, and the repo is younger than the 24 h the submission gate requires — that last one fails with "0.0 days old" and only reruns on its own, so it is worth knowing before you open the PR. Returns {ok, findings, report, entry}.',
       parameters: {
         type: 'object',
         properties: {
           text: { type: 'string', description: 'The entry YAML text.' },
           file: { type: 'string', description: 'Or a path to the entry file.' },
+          dir: { type: 'string', description: 'Or a plugin directory: reads the live catalogue and GitHub metadata instead of validating YAML.' },
         },
       },
       async execute(args) {
+        if (!args.text && !args.file && args.dir) {
+          const dir = resolveDir(args.dir)
+          if (!dir) return { ok: false, error: 'no plugin directory given' }
+          const findings = await checkMarketReadiness(dir, { timeoutMs: cfg.networkTimeoutMs })
+          return { ok: true, findings, report: renderReport(findings, { title: `market readiness · ${dir}` }) }
+        }
         let text = args.text ?? null
         if (text === null && args.file) {
           try {
@@ -212,7 +241,7 @@ export function apply(ctx, config = {}) {
             return { ok: false, error: `cannot read ${args.file}` }
           }
         }
-        if (text === null) return { ok: false, error: 'give either text or file' }
+        if (text === null) return { ok: false, error: 'give text, file, or dir' }
         const findings = checkMarketEntry(text)
         return { ok: true, findings, report: renderReport(findings, { title: 'market entry' }), entry: text }
       },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bushizhanghan/dsh-publish-gate",
-  "version": "0.2.0",
-  "description": "Helps DSH plugin AUTHORS publish their plugins: a three-layer gate that turns every silent failure in the publish path into a deterministic check. Manifest layer — package.json completeness, BOM, YAML/JSON parseability, patch insert correctness, npm scope permissions, GitHub repo and token state, market entry format, LICENSE/README, tests. Artifact layer — runs `npm pack --dry-run` and reads what npm will really ship: code missing from the tarball, an unpacked patch, oversize packages, dev directories. Runtime layer — imports the entry in an isolated child process, calls apply(ctx), and reports tools that never register, missing execute, duplicate names, throwing presentCall and card kinds the host does not render. Then GitHub + npm + market, and a post-publish shasum check that proves the registry holds these exact bytes. 帮助插件作者一键发布：写完插件后跑一遍三层门禁（清单 / 产物 / 运行时），把发布链路上的每个静默坑变成确定性检查，然后 GitHub + npm + 市场一键三连。",
+  "version": "0.3.0",
+  "description": "Helps DSH plugin AUTHORS publish their plugins: a gate that turns every silent failure in the publish path into a deterministic check. Manifest layer — package.json completeness, BOM, YAML/JSON parseability, entry paths that point at no file, a patch the manifest never declares, patch insert correctness, a build whose lib/ is older than src/, inject services that are missing or misspelled, npm scope permissions, GitHub repo and token state, market entry format, LICENSE/README, tests. Artifact layer — runs `npm pack --dry-run` and reads what npm will really ship: code missing from the tarball, an unpacked patch, oversize packages, dev directories. Runtime layer — imports the entry in an isolated child process, calls apply(ctx), and reports tools that never register, missing execute, duplicate names, throwing presentCall and card kinds the host does not render. Browser half — loads the client bundle against a fake window.__ModuleLoader__ and reports a bundle that never loads, returns no apply, throws, registers nothing, or uses a service its own inject array omits, because a panel that never appears looks like a UI bug, not a packaging one. Then GitHub + npm + market, and a post-publish shasum check that proves the registry holds these exact bytes. 帮助插件作者一键发布：写完插件后跑一遍门禁（清单 / 产物 / 运行时 / 浏览器半边），把发布链路上的每个静默坑变成确定性检查，然后 GitHub + npm + 市场一键三连。",
   "type": "module",
   "main": "lib/index.js",
   "exports": {