@klarkxy/dsh-blueprint 0.1.0-alpha.2

package/ACCEPTANCE.md

@@ -0,0 +1,33 @@
+# Acceptance record
+
+Date: 2026-09-27. Status: implementation/source preview; native end-to-end acceptance is pending.
+
+## Executed in this development environment
+
+Node.js 22.16.0, Linux, isolated temporary directories.
+
+- `npm test`: 84 passed, 0 failed, 0 skipped. Pure-core cases cover strict JSON/J/Z parsing, Unicode and size limits, default inclusion and exclusions, preserved order, two-stage imports, native revision fences, one-use plans, partial failure reporting, connection-target guarding, schema secrets including intersections and new dictionary entries, interruption and final-order verification.
+- Adapter contract fixtures exercise the actual `official.mjs` and `index.mjs` implementations against a synthetic Context with the inspected upstream signatures. They verify redacted native reads, page-independent scope, package/row ownership, malformed policy handling, native install/mutate/cancel arguments, sanitized results and explicit confirmation. They do not load a real DSH host.
+- A VM client-registration test executes `client.js` with a synthetic module loader and React facade. It verifies the official manager page and contextual share action registrations. This is not a browser visual or interaction test.
+- `npm run build`: JavaScript syntax checks of all six executable source files.
+- Distribution contents checked with `npm pack --dry-run` and a real local `npm pack`; tests and development files are not shipped. The packed core can be imported and its codec round-tripped without third-party dependencies.
+
+The alpha.2 scope revision adds ten tests: custom-only storage is not read, plugin-list sharing still works, unsupported imported settings block before writes, stale selections fail, author policy cannot widen native access, inactive/mismatched entries are excluded, browser page metadata is rejected, native defaults remain shareable, and the client does not enumerate configuration slots. Existing presentation tests now verify native support regardless of page slots or `autoGenerate`.
+
+No real `~/.dsh`, model provider, credential store or network installation was touched.
+
+## GitHub Actions verification
+
+Implementation commit: `420336f78444ea7e02db190e2c2676c848a78171`.
+
+- [CI #42, push](https://github.com/klarkxy/dsh-plugins/actions/runs/36299619992) completed successfully. Its complete job log was inspected: Node.js 24.21.0, pnpm 10.29.2, `pnpm install --frozen-lockfile` and the full root `pnpm check` passed. The blueprint package ran all 84 tests with zero failures and zero skips. Release-target checks, site tests, existing TypeScript checks, other plugin tests, build and pack checks also passed.
+- [CI #43, pull request](https://github.com/klarkxy/dsh-plugins/actions/runs/36299637488) also completed successfully; its job steps confirm the frozen installation and full root check.
+- The package added no dependencies and did not change the root lockfile, workflows or unrelated packages. All 18 initial remote blobs were checked against the tested local source, tests and documentation. This record is a later documentation-only addition; the linked runs identify the implementation commit they actually tested.
+
+## Not established by those tests
+
+The local shell cannot resolve GitHub and pnpm is not installed; dependency installation and the root monorepo checks were not run locally. They were verified in CI as recorded above, not by claiming a local run. No claim is made that a particular released DSH npm/desktop build has passed the whole workflow. Genuine HTTP authentication, HMR/plugin lifecycle behavior, cross-editor races and a real browser remain to be checked in a configured runtime.
+
+Before a stable release, use a fresh throwaway DSH Home and a non-production profile to install the actual tarball, verify Plugins-page mounting, export/import a real npm bundle in both modes, inspect bundle order, confirm secrets remain local, exercise post-install configuration preview and native restart/failure cases, and test browser reload/cancellation. Repeat on supported hosts. Do not claim a green unit-test run covers these steps.
+
+The package remains a prerelease; it is not added to the site's npm-backed catalog until a published `latest` version exists. This change does not remove the source repository's v1 runtime, delete user blueprints, merge a PR or publish to npm.

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 DSH Spaces contributors
+Copyright (c) 2026 klarkxy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE.md

@@ -0,0 +1,14 @@
+# Source provenance
+
+The JSON/share-code blueprint concept and the raw-DEFLATE, Base64url, UTF-8 and bounded-decompression codec in `codec.mjs` are extracted/adapted from:
+
+- Repository: https://github.com/klarkxy/dsh-spaces
+- Source path: `src/adapters/node/blueprint-codec.ts`
+- Source blob: `c3e9a717dcf00ce1a7bab68dd53e7675c59712d2`
+- Source license: MIT, copyright (c) 2026 DSH Spaces contributors.
+
+The original MIT notice is retained in LICENSE. New code in this package is also MIT. The surrounding dsh-plugins repository's other packages retain their own licenses.
+
+The application engine, strict v2 JSON validation, optional policy, host adapter and client integration here target the official current-profile plugin manager. Spaces Supervisor, space creation, LLM connection bindings, workbench RPC, Electron integration and private filesystem write paths are not runtime dependencies and were not copied.
+
+Upstream API inspection: deepseek-ai/deepseek-harness at `477b4f420553e8a52c2fbccc464d7561b239c443`, particularly `packages/boot/plugin-manager`, `packages/settings/settings`, `packages/client/connection`, `packages/client/ui-plugin-manager` and the official settings-page controllers. This inspection is source evidence, not a claim that the same APIs are shipped by every npm or desktop version.

package/README.md

@@ -0,0 +1,106 @@
+# DSH Blueprint
+
+[中文](README.zh-CN.md)
+
+Export and import DSH plugin compositions from the **official Plugins page**. Share either the plugin list and layer order, or the same composition with saved configuration. No Spaces installation, workspace supervisor, separate desktop application or cloud account is required.
+
+**Source preview, not a published or end-to-end-certified release.** See [ACCEPTANCE.md](ACCEPTANCE.md) for actual test coverage and outstanding runtime verification.
+
+## Install this checkout
+
+Requires a DSH Web host exposing the official `pluginManager`, profile-backed volatile `settings`, `pluginPackages`, `loader`, authenticated `connection.rpc` and plugin-manager configuration slots. The adapter checks capabilities instead of assuming a version string guarantees support. The current source contracts were reviewed at upstream commit `477b4f420553e8a52c2fbccc464d7561b239c443`; compatibility with a particular npm/desktop release still needs a runtime test.
+
+```sh
+cd plugins/dsh-blueprint
+npm test
+npm run build
+npm pack
+# Use the tarball path printed by npm pack, and your intended profile:
+dsh plugin --profile <target-profile> add /absolute/path/to/klarkxy-dsh-blueprint-0.1.0-alpha.2.tgz
+```
+
+This package has no npm dependencies and no compilation requirement. It calls native host services and uses the host's React runtime. Do not copy a standalone React or another Cordis instance into the host.
+
+## Use
+
+Open **Plugins → DSH Blueprint**. A **Share blueprint** action on another bundle's detail page opens the same export screen focused on that bundle.
+
+Select bundles, choose **Plugins only** or **Include saved settings**, and generate a preview. Settings mode also records editable plugin-row enabled states. Ordinary fields are included by default. Uncheck a form or individual field before generating. Copy the share code or save UTF-8 JSON. Nothing is published or sent to a third-party service.
+
+On the receiving host, paste a code/JSON or open a file, then **Preview import changes**. Inspect versions, operations, the resulting complete layer order, settings values and warnings. Confirm the trust notice before applying. Missing packages are installed disabled through the official manager; requested bundle activation is an explicit, previewed operation and executes plugin code.
+
+When composition changes are needed, apply those first, then run **Preview settings after installation**. This second preview binds configuration writes to the real installed plugin's native schema and revision. The plugin never invents configuration metadata for code that has not been loaded. Native `restart-required`, rejected writes or failures stop the plan and are reported rather than called success.
+
+## Scope and defaults
+
+- Only bundles listed by the official manager are selected. Exact npm versions and installation-provided bundles are supported. Local links, git/tarball sources, aliases, unreadable metadata and version conflicts are reported, not silently rewritten as npm packages. Dependencies without a bundle remain the native package manager's responsibility.
+- The native manifest supplies layer order, not the alphabetically sorted cards. Unshared bundles are not removed or disabled. If relative order must change, selected active bundles are disabled and then enabled in blueprint order, after unshared layers. The preview shows this placement and every resulting operation. A bundle with no activation change is not cycled unnecessarily.
+- Settings come exclusively from the official Config/Settings **native editable descriptors**: saved effective values, including defaults, not browser drafts, raw Config files or plugin data directories. No page ledger or per-page mapping is maintained. Custom UI over native Settings works without UI-specific handling; custom-only pages, APIs and storage are deliberately unsupported.
+- Only active, uniquely owned, writable native forms are eligible. Ordinary nonvolatile fields are not shared. Unavailable native settings are reported; package-list sharing remains available. An incoming unsupported form or path blocks the settings preview instead of being silently dropped. A custom page may display fewer fields than the native descriptor: review the actual export fields, not the page's appearance.
+- See [Settings scope](SETTINGS-SCOPE.md) for the normative boundary, author responsibilities, alpha.1 behavior change and upstream evidence. There is no planned per-plugin custom-storage adapter or migration layer.
+- Host-redacted secrets never enter the blueprint. A secret-bearing array is omitted as a whole rather than reindexed or copied incompletely. The plugin does not read the credential service. **Unmarked private text is not reliably recognizable as a secret.** Preview the output before publishing it.
+- Import applies explicit field edits with the native revision check, preserving unmentioned values. It is not a whole-form replacement. Nonsecret arrays are replaced atomically; they are not guessed or merged by index. Connection-target changes (`baseURL`, `endpoint`, `url`, `host`, `apiKeyEnv` and spelling variants) require local changes in the official page before importing, even when the secret lives outside the Settings form. This avoids silently combining an imported endpoint with a receiver's existing key.
+- Native type/schema validation still applies. Directory strings and provider/model route names are ordinary settings, not copied resources; the recipient must ensure they refer to available local resources. Import does not transfer directories, model connections, keys, sessions, attachments, histories, databases or caches.
+
+## Optional author policy
+
+No contribution means **include the native public form by default**. In the owning package's `package.json`, an author can narrow sharing for an exact native row id:
+
+```json
+{
+  "dshBlueprint": {
+    "version": 1,
+    "entries": {
+      "my-plugin": {
+        "exclude": [["privateNote"], ["connection", "machineId"]]
+      },
+      "another-instance": { "share": false },
+      "theme": { "include": [["appearance"]] }
+    }
+  }
+}
+```
+
+Paths are arrays of exact segments, not globs or JavaScript. `share: false` excludes the entire form; `include` narrows it; `exclude`, native editability and host secret annotations always win. The receiver rechecks its installed policy. Invalid declarations make that package's configuration unavailable with a warning; they never degrade to exporting everything. Metadata is read as JSON without executing export callbacks. This policy only narrows native fields; it cannot register another storage source. This is this plugin's contribution contract, not an official DSH manifest extension.
+
+## Portable format v2
+
+```json
+{
+  "kind": "dsh-blueprint",
+  "formatVersion": 2,
+  "metadata": { "name": "My setup", "version": "1.0.0" },
+  "packages": [
+    { "name": "example-plugin", "version": "1.2.3", "source": "npm" }
+  ],
+  "bundles": ["example-plugin"],
+  "settings": [
+    {
+      "package": "example-plugin",
+      "row": "example",
+      "module": "example-plugin",
+      "fields": [{ "path": ["theme"], "value": "paper" }]
+    }
+  ]
+}
+```
+
+The package is illustrative, not an install recommendation. `settings` and `rows` are optional; plugin-only exports omit both. `rows` entries carry `package`, `row`, `module` and boolean `enabled`. `source` is `npm` or `builtin`. Exact row/module/package identity is verified on the recipient. Unknown root/entry fields and unsupported versions are rejected.
+
+Codes are `DSHBP2:J:<unpadded-base64url-UTF8-JSON>` or `DSHBP2:Z:<unpadded-base64url-raw-DEFLATE-JSON>`. The encoder chooses the shorter form. Limits: 1 MiB decoded JSON, 2 MiB input code, 64 JSON container levels. Duplicate JSON members, unsafe numbers, prototype keys, malformed Unicode, noncanonical Base64url and trailing compressed streams are rejected. Codes are **not encryption, signatures or proof of trust**.
+
+Spaces `DSHBP1` / format v1 described creation of a new isolated space, including Spaces-specific bindings. The v2 reader rejects those codes rather than silently applying them to the current profile. Re-export through the new manager integration. This extraction does not delete or rewrite the legacy v1 implementation in the source repository; no in-place v1 migration is claimed.
+
+## Operation and security contract
+
+All management goes through the official manager; all setting writes go through native Settings. The package registers an authenticated logical RPC channel through official Connection, not a second server. The native transport's request cap also applies.
+
+A preview creates a process-local, five-minute, one-use plan bound to the observed profile and form revisions. At most eight plans/results are retained. Changed observations invalidate a plan; completed results can be read without rerunning operations. No automatic retries, upgrades, downgrades, script approvals, removals, cross-profile writes or blueprint-level rollback are performed. The native installer retains its own documented failure behavior.
+
+A multi-step import is **not a transaction or a lock against every other editor**. It checks observed state between operations and uses native per-operation serialization/revision checks. Stop editing that profile elsewhere while applying. Failures preserve visible partial outcomes; a lost response is not a reason to replay an import. Closing the page requests cancellation where supported. Already-completed changes may remain.
+
+## Development
+
+`npm test` runs dependency-free unit, adapter-contract and client-registration tests. `npm run build` checks JavaScript syntax; it is not a TypeScript or native integration check. `npm pack --dry-run` checks distribution contents. No test uses the real DSH home.
+
+MIT. The extracted codec's original copyright is retained; see [NOTICE.md](NOTICE.md) and [LICENSE](LICENSE).

package/README.zh-CN.md

@@ -0,0 +1,85 @@
+# DSH 蓝图
+
+[English](README.md)
+
+在 **DSH 官方插件管理器**内导入、导出插件组合：可以只分享插件列表与生效顺序，也可以连已保存的配置一起分享。无需安装 Spaces，无需独立客户端、Supervisor 或云账户。
+
+**当前为源码预览版本，尚未发布到 npm，也未完成真实 DSH 端到端验收。** 已执行检查与剩余验收见 [ACCEPTANCE.md](ACCEPTANCE.md)。
+
+## 安装与入口
+
+需要提供官方 `pluginManager`、基于 profile 的 volatile `settings`、`pluginPackages`、`loader`、已鉴权 `connection.rpc` 和插件配置 slot 的 DSH Web 宿主。启动会检查所需能力；仅凭版本号不声称兼容。接口核对基于上游提交 `477b4f420553e8a52c2fbccc464d7561b239c443`，具体 npm 或桌面版本仍需实际验收。
+
+```sh
+cd plugins/dsh-blueprint
+npm test
+npm run build
+npm pack
+# 使用 npm pack 输出的归档路径，并明确目标 profile：
+dsh plugin --profile <目标profile> add /绝对路径/klarkxy-dsh-blueprint-0.1.0-alpha.2.tgz
+```
+
+包没有 npm 依赖和编译要求，复用宿主服务与 React。安装后打开 **插件 → DSH 蓝图**。其他组合包详情页的 **分享蓝图** 按钮会进入同一界面并选中该包。
+
+## 导出
+
+选择插件，选择 **仅插件组合** 或 **包含已保存设置**。后者还记录可修改的插件行启停状态。普通配置默认包含，不要求作者专门适配；生成前可取消某个表单或字段。检查生成的 JSON，然后复制分享码或保存 JSON。不会自动上传或发布。
+
+**唯一设置来源是官方 Config／Settings 暴露的可编辑描述符。** 导出原生已保存的生效值（包括默认值），不读取浏览器草稿、普通非 volatile Config 字段、任意配置文件或插件数据目录。不再枚举页面 slots，也不维护页面专用字段映射。
+
+自己画 UI、但仍使用原生 Settings 的插件，在数据层照常支持；完全自建页面、接口或存储的配置不读取、不推断、不适配。自定义页面可能只显示原生字段的子集，蓝图不尝试识别该子集；请按实际导出预览选择字段。不可用的原生设置会报告，但插件清单仍可分享；导入不支持的设置会阻止设置预览，不默默丢弃。
+
+完整范围、作者责任、与 alpha.1 的行为区别及官方依据见 [设置范围说明](SETTINGS-SCOPE.md)。自建配置适配与自动迁移明确不在本产品范围内。
+
+关闭的插件没有活动表单，不能读取其不可见设置，但仍可分享安装清单与 bundle 选择。共享前请核对列出的配置项。凭据服务不被读取；宿主已标记的秘密不会导出。数组含秘密或排除字段时，整段数组被排除，避免索引错位。**未标记的私密文本不能保证被自动识别，公开分享前应查看预览。**
+
+## 导入
+
+粘贴分享码、JSON 或读取文件，选择 **预览导入变更**，核对版本、操作、完整生效顺序和设置值，再确认信任提示并执行。安装、启停都调用官方管理器，不另建安装器；不自动授权构建脚本，但宿主已有的脚本授权仍可能生效。启用插件会执行其代码。
+
+需要新增或重排组合时，先执行组合阶段，再点 **安装后重新预览设置**。第二次预览依据真正安装后的原生 schema 和修订号生成设置操作。宿主要求重启、配置拒绝或中途失败都会停止，不会报告为整体成功。
+
+只修改所选组合包，不卸载未选包。需要改变相对顺序时，先关闭所选已启用层，再按蓝图顺序开启，放到未选层之后；预览会展示全部操作和最终顺序。无须重排时不重复启停。安装清单与生效顺序分别记录，不使用页面的字母排序冒充顺序。
+
+设置采用带原生 revision 的逐字段写入，保留未提及的值，不用脱敏后的对象整段覆盖配置。普通数组作为整体替换，不猜测按下标合并。`baseURL`、`endpoint`、`url`、`host`、`apiKeyEnv` 等连接目标发生变化时，需要先在接收者的官方配置页本地处理，再导入其余设置，避免将分享者的地址和接收者的密钥自动配对。
+
+目录字符串和模型路由名只是设置值，不代表相关资源被复制；接收者应确认本机可用性。不会搬运模型连接库、API Key、会话、附件、数据库或缓存。
+
+## 插件作者声明
+
+缺省规则为 **包含对应原生表单内的公开字段**。作者可在自己包的 `package.json` 中按原生插件行 id 声明：
+
+```json
+{
+  "dshBlueprint": {
+    "version": 1,
+    "entries": {
+      "my-plugin": { "exclude": [["privateNote"], ["connection", "machineId"]] },
+      "another-instance": { "share": false },
+      "theme": { "include": [["appearance"]] }
+    }
+  }
+}
+```
+
+路径是精确段落数组，不是 glob、表达式或 JavaScript。`share: false` 关闭整个表单的分享；`include` 缩小范围；`exclude`、原生可编辑范围和宿主秘密标记优先。接收端重新检查本机安装版本的声明。无效声明会明确使该包的配置不可分享，不退回“全量导出”。声明只读取 JSON，不执行自定义导出回调，也不能注册自建存储来源。这是本插件的扩展约定，不冒充官方 DSH manifest 标准。
+
+## 格式与迁移
+
+新格式为 `kind: "dsh-blueprint"`、`formatVersion: 2`。`packages` 记录精确版本和 `npm` / `builtin` 来源；`bundles` 记录有序启用层；可选 `settings` 记录 `{package,row,module,fields:[{path,value}]}`；可选 `rows` 记录 `{package,row,module,enabled}`。最小示例及字段规则见英文文档的 Portable format v2。
+
+分享码为 `DSHBP2:J:`（UTF-8 JSON 的无填充 Base64url）或 `DSHBP2:Z:`（先 raw DEFLATE 压缩）。最大 JSON 1 MiB、输入分享码 2 MiB、64 层 JSON 容器；宿主传输的请求大小限制也生效。重复键、不安全数字、原型键、损坏 Unicode、非规范 Base64url 和压缩尾随数据拒绝读取。编码不是加密、签名或作者认证。
+
+只支持可确认的精确 npm 来源与宿主内置组合包。本地链接、git/tarball、别名和版本冲突会列出，不悄悄改源。官方管理器不列为组合包的普通依赖由包管理器负责。
+
+Spaces 的 `DSHBP1` / v1 原义是创建新隔离空间，包含专属绑定；这里明确拒绝，不偷偷把旧码解释成修改当前 profile。应通过新入口重新导出。本次独立实现没有删除或改写原仓库的历史 v1 实现，不宣称已完成旧空间数据迁移。
+
+## 执行边界
+
+复用官方 Connection 的鉴权与 Host/Origin 检查，不启动第二个服务器。预览计划只保存在当前进程，五分钟过期、单次消费，最多保留八个计划或结果；实际观测变化使旧计划失效。已完成的结果可读取，不重新执行。
+
+不自动重试、升级、降级、授权脚本、卸载、跨 profile 写入或整组回滚。原生安装器自己的失败行为保持不变。多步骤导入不是全局事务，也没有锁住所有其他编辑器；执行期间请勿在其他窗口同时改该 profile。中途失败保留已完成结果；响应丢失不表示可以重放。关闭页面会在支持时请求取消，已经完成的更改可能保留。
+
+`npm test` 为无外部依赖的单元、接口适配和界面注册测试；`npm run build` 为语法检查，不等于真实宿主或 TypeScript 验收。所有测试只使用临时目录，不接触真实 DSH Home。
+
+MIT；原 Spaces 编解码器的版权说明保留在 [NOTICE.md](NOTICE.md) 与 [LICENSE](LICENSE)。

package/SETTINGS-SCOPE.md

@@ -0,0 +1,61 @@
+# Settings scope / 设置范围
+
+Decision date: 2026-09-27. Applies to `@klarkxy/dsh-blueprint@0.1.0-alpha.2`.
+
+## 中文：只对接官方配置契约
+
+蓝图以 **官方 Config / Settings 暴露的可编辑字段** 为唯一设置数据来源，不以任意自定义页面的控件或可见字段为准。插件管理器是操作入口，不是所有第三方数据存储的统一协议。
+
+| 情况 | 行为 |
+| --- | --- |
+| 活动插件通过官方 Settings 暴露可唯一定位的 volatile 字段 | 可导出已保存的生效值；导入使用原生逐字段修改与 revision 检查。 |
+| 插件自己画 UI，但仍使用同一官方 Settings 数据接口 | 原生字段照常支持，不分析 UI，也不按页面显示的子集自动裁剪。 |
+| 插件只使用自定义页面、自建接口、文件、localStorage 或数据库 | 不读取、不推断、不适配；其插件清单和可管理的启用状态仍可分享。 |
+| 插件未启动、已禁用或没有原生表单 | 不读取底层 Config 或旧存储作为替代；不可用设置会报告。 |
+| 接收者没有匹配的原生表单或可编辑路径 | 设置预览明确阻止写入，不默默忽略、不创建自定义设置。 |
+
+### 数据来源与写入
+
+读操作只使用 `settings.describe({ redactSecrets: true })` 返回的原生描述符值，校对官方插件清单、包/行/模块身份和可修改性；只读取 Loader 的 schema 元数据检查 volatile 与 secret 标记，不从运行时 Config 抽取隐藏值。文件读取只用于 profile/package manifest 的组合顺序、包身份和声明式分享策略，不遍历插件设置目录。
+
+不再维护 Shell、搜索等页面的手写字段映射，不接收浏览器上传的页面 ledger 作为授权依据，不枚举或解析第三方 React 表单，不安装页面专用导出回调。`autoGenerate: false` 只是呈现策略，不会使仍由官方 Settings 提供的数据失去支持。
+
+导入只通过 `settings.mutate` 写入明确的字段路径和读取时的修订号，由 Host 验证完整 Config 并持久化；不整段替换脱敏对象，不修改未提及的设置。非原生路径、秘密路径及作者禁止路径不能因蓝图自行声明而获得权限。
+
+### 分享默认值与责任边界
+
+没有作者声明时，原生范围内的公开可编辑字段默认包含。`dshBlueprint.entries` 是本插件可选的声明式缩小规则：`exclude`、`include`、`share: false`；它不能扩展到官方数据接口以外，也不是自定义存储的适配器。宿主已标记的秘密始终排除；用户可取消表单或字段。未知的私密文本无法保证自动识别，发布前需要检查预览。
+
+“自定义配置不支持”是当前产品的明确范围，不是承诺以后为每个插件补适配。希望参与配置分享的作者应使用官方 Config / Settings 接口；现有自建配置的迁移由插件作者处理，蓝图不提供扫描、备份或自动迁移。
+
+### 兼容性与失败说明
+
+此版本取消 alpha.1 中按页面 slots 选择表单和四组手写页面字段映射的行为；分享范围以官方原生描述符为准，因此同一原生表单可能比某个自定义页面显示的字段更多。导出界面和 JSON 预览必须如实展示字段，用户或作者可以进一步缩小。
+
+蓝图仍使用格式 v2 / `DSHBP2`。接收旧的 v2 数据时，所有设置仍需通过当前原生身份、schema、作者策略和秘密检查。未识别的自定义路径会阻止设置阶段。预览、分阶段执行和部分失败报告不提供跨阶段事务保证；安装阶段已经完成的操作不会因后续设置不支持而自动回滚。
+
+## English: native configuration contract only
+
+The sole settings source is the **editable data exposed by official Config / Settings**, not the controls or visible subset of an arbitrary custom page. The official plugin manager supplies the user entry point; registering a UI does not make a third-party storage format part of this contract.
+
+Active, uniquely addressable native volatile fields support export of saved effective values and import through revision-fenced path edits. A custom UI that uses the same native Settings contract remains supported at the data level, including when `autoGenerate` is false. No UI inspection or special adapter is needed or promised.
+
+Custom-only pages, APIs, local files, browser storage and databases are out of scope. Their packages and manageable activation state remain shareable. Missing/inactive native forms have no raw-Config or filesystem fallback. Incoming settings without an exact native form or editable path block the settings preview instead of being silently ignored or written elsewhere.
+
+The reader consumes only `settings.describe({ redactSecrets: true })` values. Native manager records and Loader schema metadata establish identity, writability, volatile fields and secret protection. Loader Config values are not an export source. File reads are limited to profile/package manifests for order, package identity and declarative policy. There is no client-supplied page ledger, hand-maintained field table, DOM/React inspection, storage crawl or page-specific export callback.
+
+Writes use official `settings.mutate` with explicit paths and the observed revision. Host validation and persistence stay authoritative. Unmentioned values remain local; a redacted object is never used as a whole-form replacement. A blueprint cannot grant itself access to nonnative or secret paths.
+
+No author policy means include the public native editable fields by default. The optional `dshBlueprint.entries` policy can only narrow that set; it cannot grant access to another data source. Host-marked secrets remain excluded, users can deselect fields, and unmarked private text still needs review. Custom-storage adapters and automatic migrations are deliberately not part of this product.
+
+This supersedes alpha.1's page-ledger filtering and four hard-coded official page mappings. Native descriptors can contain more fields than one custom UI displays; the export screen and JSON preview expose that scope. Format v2 / `DSHBP2` remains unchanged and imported v2 fields are revalidated against the receiver's native contract. Unsupported settings block their stage; successful earlier package operations are not rolled back.
+
+## Upstream evidence / 官方依据
+
+Reviewed against upstream commit `477b4f420553e8a52c2fbccc464d7561b239c443`:
+
+- [Settings contract](https://github.com/deepseek-ai/deepseek-harness/blob/477b4f420553e8a52c2fbccc464d7561b239c443/packages/settings/settings/README.zh.md): native volatile forms, instance identity, `autoGenerate`, redaction and unavailable forms.
+- [Settings API](https://github.com/deepseek-ai/deepseek-harness/blob/477b4f420553e8a52c2fbccc464d7561b239c443/docs/subsystems/settings.zh.md): descriptors, path edits, complete-Config validation and revision checks.
+- [Plugin-page slots](https://github.com/deepseek-ai/deepseek-harness/blob/477b4f420553e8a52c2fbccc464d7561b239c443/packages/client/ui-plugin-manager/src/client/slot-contract.ts): presentation extension points, not a universal settings-storage declaration.
+
+These source contracts are not proof of an end-to-end pass on every released host. See [ACCEPTANCE.md](ACCEPTANCE.md).

package/blueprint.mjs

@@ -0,0 +1,124 @@
+import { fail, plain, forbidden, parseJson } from './codec.mjs';
+export const PACKAGE = '@klarkxy/dsh-blueprint';
+const NAME = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+const VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export const exactVersion = value => typeof value === 'string' && VERSION.test(value);
+export function closed(value, keys, label) {
+  if (!plain(value) || Object.keys(value).some(k => !keys.includes(k))) fail('shape', `Invalid ${label}.`);
+}
+export function text(value, label, max = 512) {
+  if (typeof value !== 'string' || !value.length || value.length > max || /[\x00-\x1f]/.test(value)) fail('field', `Invalid ${label}.`);
+  return value;
+}
+export function array(value, label, max = 512) {
+  if (!Array.isArray(value) || value.length > max) fail('field', `Invalid ${label}.`); return value;
+}
+export function path(value) {
+  array(value, 'field path', 64);
+  if (!value.length) fail('path', 'Whole-form replacement is not supported.');
+  for (const p of value) { text(p, 'path segment'); if (forbidden(p)) fail('path', 'Unsafe field path.'); }
+  return value;
+}
+export const prefix = (a, b) => a.length <= b.length && a.every((v, i) => v === b[i]);
+export const overlaps = (a, b) => prefix(a, b) || prefix(b, a);
+export const identity = form => JSON.stringify([form.package, form.row, form.module]);
+export const equal = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+export function get(value, parts) {
+  for (const part of parts) { if (value === null || typeof value !== 'object' || !Object.hasOwn(value, part)) return undefined; value = value[part]; }
+  return value;
+}
+export function validate(value) {
+  // Also reject cycles, non-finite values, exotic objects and undefined before JSON conversion.
+  function json(v, depth = 0) {
+    if (depth > 64) fail('depth', 'Blueprint too deeply nested.');
+    if (v === null || typeof v === 'string' || typeof v === 'boolean') return;
+    if (typeof v === 'number' && Number.isFinite(v) && (!Number.isInteger(v) || Number.isSafeInteger(v))) return;
+    if (!Array.isArray(v) && !plain(v)) fail('json', 'Blueprint must contain JSON data only.');
+    if (Array.isArray(v) && Object.keys(v).length !== v.length) fail('json', 'Sparse or decorated arrays are not supported.');
+    for (const [k, x] of Object.entries(v)) { if (forbidden(k)) fail('key', 'Unsafe object key.'); json(x, depth + 1); }
+  }
+  json(value); value = parseJson(JSON.stringify(value));
+  closed(value, ['kind', 'formatVersion', 'metadata', 'packages', 'bundles', 'settings', 'rows'], 'blueprint');
+  if (value.kind !== 'dsh-blueprint' || value.formatVersion !== 2) fail('version', 'Only current-profile dsh-blueprint v2 is supported.');
+  closed(value.metadata, ['name', 'version', 'description'], 'metadata'); text(value.metadata.name, 'name', 120);
+  if (!exactVersion(value.metadata.version)) fail('version', 'Invalid blueprint release version.');
+  if (value.metadata.description !== undefined) text(value.metadata.description, 'description', 4000);
+  const names = new Set();
+  for (const p of array(value.packages, 'packages', 128)) {
+    closed(p, ['name', 'version', 'source'], 'package');
+    if (typeof p.name !== 'string' || !NAME.test(p.name) || p.name.length > 214 || p.name === PACKAGE || names.has(p.name)) fail('package', 'Invalid, duplicate or self-referencing package.');
+    if (!exactVersion(p.version) || !['npm', 'builtin'].includes(p.source)) fail('package', 'Packages require exact versions and known sources.');
+    names.add(p.name);
+  }
+  const bundles = array(value.bundles, 'bundles', 128);
+  if (new Set(bundles).size !== bundles.length || bundles.some(n => !names.has(n))) fail('bundle', 'Bundle order must reference unique selected packages.');
+  const forms = new Set();
+  for (const s of array(value.settings ?? [], 'settings', 256)) {
+    closed(s, ['package', 'row', 'module', 'fields'], 'settings'); text(s.package, 'package'); text(s.row, 'row'); text(s.module, 'module');
+    const id = identity(s); if (forms.has(id)) fail('settings', 'Duplicate form.'); forms.add(id);
+    const seen = [];
+    for (const f of array(s.fields, 'fields', 2048)) {
+      closed(f, ['path', 'value'], 'field'); path(f.path);
+      if (!Object.hasOwn(f, 'value') || seen.some(p => overlaps(p, f.path))) fail('path', 'Missing value or overlapping fields.');
+      seen.push(f.path);
+    }
+  }
+  const rows = new Set();
+  for (const r of array(value.rows ?? [], 'rows', 512)) {
+    closed(r, ['package', 'row', 'module', 'enabled'], 'row');
+    text(r.package, 'package'); text(r.row, 'row'); text(r.module, 'module');
+    if (typeof r.enabled !== 'boolean' || !names.has(r.package) || rows.has(identity(r))) fail('row', 'Invalid row state.');
+    rows.add(identity(r));
+  }
+  return value;
+}
+
+/** Authors may narrow an editable form; absence means include every public field. */
+export function policy(value) {
+  if (value === undefined) return { exclude: [], include: null };
+  closed(value, ['share', 'include', 'exclude'], 'share policy');
+  if (value.share !== undefined && typeof value.share !== 'boolean') fail('policy', 'Invalid share policy.');
+  const list = key => array(value[key] ?? [], key).map(path);
+  return { exclude: list('exclude'), include: value.share === false ? [] : value.include === undefined ? null : list('include') };
+}
+
+/** Keep arrays atomic. If redaction touched an array, omit it instead of corrupting positions or secrets. */
+export function publicFields(form, authorPolicy) {
+  const p = policy(authorPolicy), omitted = [], fields = [];
+  const blocked = [...p.exclude, ...(form.secrets ?? []).map(s => s.path)];
+  function visit(v, at) {
+    if (blocked.some(b => prefix(b, at))) { omitted.push({ path: at, reason: 'excluded-or-secret' }); return; }
+    if (p.include !== null && !p.include.some(b => overlaps(b, at))) return;
+    if (Array.isArray(v) && blocked.some(b => overlaps(b, at))) { omitted.push({ path: at, reason: 'array-contains-excluded-field' }); return; }
+    if (plain(v) && Object.keys(v).length) {
+      for (const [k, child] of Object.entries(v)) { if (!forbidden(k)) visit(child, [...at, k]); }
+    } else if (at.length && v !== undefined) {
+      if (p.include !== null && !p.include.some(b => prefix(b, at))) { omitted.push({ path: at, reason: 'partial-array-policy' }); return; }
+      fields.push({ path: at, value: v });
+    }
+  }
+  visit(form.value, []); return { fields, omitted };
+}
+
+/** An editable path must be volatile. Secret declarations in any schema branch win. */
+export function schemaAllows(schema, at, proposed) {
+  function permission(node, parts, live = false, seen = new Set()) {
+    if (!node || seen.has(node)) return undefined;
+    if (node.meta?.role === 'secret') return false;
+    seen = new Set(seen).add(node); live ||= Boolean(node.meta?.volatile);
+    if (node.type === 'union' || node.type === 'intersect') {
+      const relevant = (node.list ?? []).map(n => permission(n, parts, live, seen)).filter(v => v !== undefined);
+      return relevant.length ? relevant.every(Boolean) : undefined;
+    }
+    if (node.type === 'transform') return permission(node.inner, parts, live, seen);
+    if (!parts.length) return live;
+    const [head, ...tail] = parts;
+    const next = node.type === 'object' ? node.dict?.[head] : ['dict', 'array'].includes(node.type) ? node.inner : undefined;
+    return permission(next, tail, live, seen);
+  }
+  if (permission(schema, at) !== true) return false;
+  if (Array.isArray(proposed) || plain(proposed)) {
+    return Object.entries(proposed).every(([key, value]) => schemaAllows(schema, [...at, key], value));
+  }
+  return true; // The native Settings service validates the complete Config and callbacks on write.
+}

package/client.js

@@ -0,0 +1,124 @@
+window.__ModuleLoader__.load({
+  id: '@klarkxy/dsh-blueprint',
+  factory(require) {
+    const React = require('react'), h = React.createElement;
+    const PACKAGE = '@klarkxy/dsh-blueprint';
+    const idOf = f => JSON.stringify([f.package, f.row, f.module]);
+    const style = { border: '1px solid currentColor', borderRadius: 6, padding: '6px 10px', background: 'transparent', color: 'inherit', font: 'inherit' };
+    let focusPackage = null;
+    function Panel({ ctx }) {
+      const [zh, setZh] = React.useState(() => ctx.locale.getSnapshot().active.startsWith('zh'));
+      const t = (a, b) => zh ? a : b;
+      const [catalog, setCatalog] = React.useState(null), [selected, setSelected] = React.useState([]);
+      const [forms, setForms] = React.useState([]), [omit, setOmit] = React.useState([]);
+      const [mode, setMode] = React.useState('plugins'), [name, setName] = React.useState('My DSH setup');
+      const [generated, setGenerated] = React.useState(null), [source, setSource] = React.useState('');
+      const [preview, setPreview] = React.useState(null), [confirmed, setConfirmed] = React.useState(false);
+      const [report, setReport] = React.useState(null), [lastPlan, setLastPlan] = React.useState(null);
+      const [busy, setBusy] = React.useState(false), [error, setError] = React.useState('');
+      const lifetime = React.useRef(null);
+      async function rpc(endpoint, payload) {
+        const result = await ctx.connection.rpc.call('/dsh-blueprint', endpoint, payload, lifetime.current?.signal);
+        if (!result.ok) throw new Error(result.error.message);
+        return result.value;
+      }
+      async function run(fn) {
+        setBusy(true); setError('');
+        try { await fn(); } catch (e) { setError(e instanceof Error ? e.message : 'Operation failed'); }
+        finally { setBusy(false); }
+      }
+      async function load() {
+        const data = await rpc('catalog', {}); setCatalog(data);
+        const selection = data.packages.filter(p => !p.readonly && !p.reason && (!focusPackage || p.name === focusPackage)).map(p => p.name);
+        setSelected(selection); setForms(data.forms.filter(f => f.builtin || selection.includes(f.package)).map(idOf));
+        setOmit([]); setGenerated(null); focusPackage = null;
+      }
+      React.useEffect(() => {
+        lifetime.current = new AbortController();
+        const off = ctx.locale.subscribe(() => setZh(ctx.locale.getSnapshot().active.startsWith('zh')));
+        void run(load);
+        return () => { off(); lifetime.current.abort(); };
+      }, []);
+      const button = (label, action, disabled = false) => h('button', { type: 'button', style, disabled: busy || disabled, onClick: () => run(action) }, label);
+      const toggle = (list, value) => list.includes(value) ? list.filter(v => v !== value) : [...list, value];
+      const check = (label, checked, onChange, disabled = false) => h('label', { style: { display: 'flex', alignItems: 'start', gap: 8, padding: '5px 0', overflowWrap: 'anywhere' } },
+        h('input', { type: 'checkbox', checked, disabled: busy || disabled, onChange }), label);
+      function updateSource(value) { setSource(value); setPreview(null); setConfirmed(false); setReport(null); }
+      const code = value => h('pre', { style: { overflow: 'auto', maxHeight: 360, whiteSpace: 'pre-wrap', overflowWrap: 'anywhere', padding: 12, border: '1px solid currentColor', borderRadius: 6 } }, JSON.stringify(value, null, 2));
+      return h('section', { 'aria-label': t('蓝图导入与导出', 'Blueprint import and export'), style: { display: 'grid', gap: 14, minWidth: 0 } },
+        h('p', null, t('分享插件组合和官方 Config／Settings 暴露的可编辑设置。不读取自定义页面、自建存储、会话或凭据库。', 'Share plugins and editable settings exposed by official Config/Settings. Custom pages, private storage, sessions and credential stores are not read.')),
+        error && h('p', { role: 'alert', style: { border: '1px solid currentColor', padding: 10 } }, error),
+        busy && h('p', { role: 'status' }, t('正在处理；安装进度也可在官方插件管理器中查看。', 'Working. Native package installation progress is also available in the official manager.')),
+        h('h3', null, t('导出蓝图', 'Export blueprint')),
+        button(t('刷新插件与原生设置', 'Refresh plugins and native settings'), load),
+        h('label', null, t('名称 ', 'Name '), h('input', { style, value: name, maxLength: 120, disabled: busy, onChange: e => { setName(e.target.value); setGenerated(null); } })),
+        h('label', null, t('分享范围 ', 'Share '), h('select', { style, value: mode, disabled: busy, onChange: e => { setMode(e.target.value); setGenerated(null); } },
+          h('option', { value: 'plugins' }, t('仅插件组合和顺序', 'Plugins and order only')),
+          h('option', { value: 'settings' }, t('插件组合及设置', 'Plugins and settings')))),
+        catalog && h('div', null, catalog.packages.map(p => h('div', { key: p.name }, check(
+          `${p.name}@${p.version ?? '?'}${p.reason ? ` (${p.reason})` : ''}${p.readonly ? t('（宿主管理，不导出）', ' (host-managed)') : ''}`,
+          selected.includes(p.name), () => { setSelected(toggle(selected, p.name)); setGenerated(null); }, p.readonly || Boolean(p.reason))))),
+        mode === 'settings' && catalog && h('div', null,
+          h('p', null, t('以官方可编辑字段为准，不推断自定义页面的可见字段。普通字段默认包含；可以取消任一表单或字段。请检查未标记的私密内容。', 'The official editable fields define scope, not custom-page visibility. Ordinary fields are included by default. Uncheck any form or field and review unmarked private text.')),
+          catalog.forms.filter(f => f.builtin || selected.includes(f.package)).map(f => h('details', { key: idOf(f) },
+            h('summary', null, `${f.row} · ${f.package}`),
+            check(t('包含此原生配置', 'Include these native settings'), forms.includes(idOf(f)), () => { setForms(toggle(forms, idOf(f))); setGenerated(null); }),
+            f.fields.map(field => {
+              const key = JSON.stringify([idOf(f), field.path]);
+              return h('div', { key }, check(`${field.path.join('.')} = ${JSON.stringify(field.value)}`, !omit.includes(key), () => { setOmit(toggle(omit, key)); setGenerated(null); }, !forms.includes(idOf(f))));
+            }), f.omitted.length > 0 && code(f.omitted))),
+        ),
+        catalog?.warnings?.length > 0 && h('details', null, h('summary', null, t('未导出的项目与限制', 'Unavailable configurations and limits')), code(catalog.warnings)),
+        button(t('生成并预览', 'Generate and review'), async () => setGenerated(await rpc('generate', {
+          mode, name, packages: selected,
+          forms: forms.filter(id => catalog.forms.some(f => idOf(f) === id && (f.builtin || selected.includes(f.package)))),
+          omit: omit.map(key => { const [form, path] = JSON.parse(key); return { form, path }; }),
+        })), !catalog || !name.trim()),
+        generated && h('div', null, code(generated.blueprint),
+          h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: 8 } },
+            button(t('复制分享码', 'Copy share code'), () => navigator.clipboard.writeText(generated.code)),
+            button(t('保存 JSON', 'Save JSON'), async () => {
+              const url = URL.createObjectURL(new Blob([generated.json], { type: 'application/json' }));
+              const a = document.createElement('a'); a.href = url; a.download = 'setup.dsh-blueprint.json'; a.click();
+              setTimeout(() => URL.revokeObjectURL(url), 1000);
+            })),
+          h('details', null, h('summary', null, t('分享码（也可手动复制）', 'Share code (manual copy)')), h('textarea', { readOnly: true, value: generated.code, rows: 4, style: { ...style, width: '100%', boxSizing: 'border-box' } }))),
+        h('hr'), h('h3', null, t('导入到当前 profile', 'Import into the current profile')),
+        h('p', null, t('不会新建空间或删除现有插件。蓝图中的插件会保持相对顺序；需要重排时放在未选插件之后。', 'No spaces are created and no existing packages are removed. Imported bundles retain their relative order; reordered bundles follow unselected bundles.')),
+        h('label', null, t('读取蓝图文件 ', 'Read blueprint file '), h('input', { type: 'file', accept: '.json,.txt', disabled: busy, onChange: e => { const file = e.target.files?.[0]; if (file) void run(async () => {
+          if (file.size > 2 * 1024 * 1024) throw new Error('File exceeds 2 MiB');
+          updateSource(new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(await file.arrayBuffer()));
+        }); } })),
+        h('textarea', { 'aria-label': t('JSON 或分享码', 'JSON or share code'), value: source, rows: 7, disabled: busy,
+          maxLength: 2 * 1024 * 1024, style: { ...style, width: '100%', boxSizing: 'border-box' }, onChange: e => updateSource(e.target.value) }),
+        button(t('预览导入变更', 'Preview import changes'), async () => { setConfirmed(false); setPreview(await rpc('preview', { text: source })); }, !source.trim()),
+        preview && h('div', null,
+          preview.blockers.length > 0 && h('div', { role: 'alert' }, code(preview.blockers)),
+          code({ stage: preview.stage, operations: preview.operations, finalOrder: preview.order }),
+          preview.next && h('p', null, t('这一步仅安装／启用插件。完成后再次预览，核对真实配置字段后再确认写入设置。', 'This stage only installs/enables plugins. Preview again afterwards to review the live configuration fields before writing settings.')),
+          check(t('我已核对变更，并信任这些插件代码。安装可能运行先前已授权的构建脚本；启用会执行插件。', 'I reviewed the changes and trust the plugin code. Installation may run previously approved build scripts; enabling executes plugins.'), confirmed, () => setConfirmed(!confirmed)),
+          button(t('确认执行本次变更', 'Apply these changes'), async () => {
+            const id = preview.planId; setLastPlan(id);
+            const result = await rpc('apply', { planId: id, confirmed: true }); setReport(result); setPreview(null); setConfirmed(false);
+          }, !preview.planId || !confirmed)),
+        report && h('div', { role: 'status' }, h('strong', null, t('执行结果', 'Execution result')), code(report),
+          report.next && h('p', null, t('请再次点击“预览导入变更”以继续设置阶段。', 'Select Preview import changes again to continue with settings.'))),
+        lastPlan && button(t('读取该次执行结果（不重试执行）', 'Read this execution result (no replay)'), async () => {
+          const result = await rpc('result', { planId: lastPlan });
+          if (!result) throw new Error(t('结果尚未生成或服务已重启；请检查官方管理器，不要假定操作未发生。', 'No retained result yet, or the service restarted. Check the official manager; do not assume nothing changed.'));
+          setReport(result);
+        }),
+      );
+    }
+    return {
+      inject: ['slots', 'locale', 'connection', 'pluginNavigation'],
+      apply(ctx) {
+        ctx.slots.inject('plugins.bundle.config', () => ctx.slots.register({ name: 'plugins.bundle.config', key: PACKAGE }, () => h(Panel, { ctx })));
+        ctx.slots.inject('plugins.detail.actions', () => ctx.slots.register({ name: 'plugins.detail.actions', id: 'klarkxy-blueprint-share', order: 40 }, ({ subject }) => {
+          if (subject.kind !== 'bundle' || subject.pkg.name === PACKAGE) return null;
+          return h('button', { type: 'button', style, onClick: () => { focusPackage = subject.pkg.name; ctx.pluginNavigation.openBundle(PACKAGE); } }, ctx.locale.getSnapshot().active.startsWith('zh') ? '分享蓝图' : 'Share blueprint');
+        }));
+      },
+    };
+  },
+});

package/codec.mjs

@@ -0,0 +1,103 @@
+// Adapted from dsh-spaces blueprint-codec.ts (MIT); see NOTICE.md.
+import { deflateRawSync, inflateRawSync } from 'node:zlib';
+export const MAX_JSON = 1024 * 1024;
+export const MAX_SHARE = 2 * MAX_JSON;
+export class BlueprintError extends Error {
+  constructor(code, message) { super(message); this.name = 'BlueprintError'; this.code = code; }
+}
+export function fail(code, message) { throw new BlueprintError(code, message); }
+export const plain = value => value !== null && typeof value === 'object' && !Array.isArray(value)
+  && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+export const forbidden = key => ['__proto__', 'prototype', 'constructor'].includes(key);
+
+/** Strict JSON with duplicate-member, depth, Unicode and numeric checks. Never evaluates code. */
+export function parseJson(text) {
+  if (typeof text !== 'string') fail('json', 'Expected JSON text.');
+  if (Buffer.byteLength(text) > MAX_JSON) fail('size', 'JSON exceeds 1 MiB.');
+  let i = 0;
+  const error = () => fail('json', `Invalid JSON near offset ${i}.`);
+  const ws = () => { while (/[ \t\r\n]/.test(text[i] ?? '\0')) i++; };
+  function str() {
+    const start = i++;
+    while (i < text.length) {
+      const c = text[i++];
+      if (c === '\\') { i++; continue; }
+      if (c === '"') {
+        let s; try { s = JSON.parse(text.slice(start, i)); } catch { error(); }
+        for (let n = 0; n < s.length; n++) {
+          const u = s.charCodeAt(n);
+          if (u >= 0xd800 && u <= 0xdbff) {
+            const v = s.charCodeAt(++n);
+            if (!(v >= 0xdc00 && v <= 0xdfff)) error();
+          } else if (u >= 0xdc00 && u <= 0xdfff) error();
+        }
+        return s;
+      }
+    }
+    error();
+  }
+  function value(depth) {
+    ws();
+    if (depth > 64 && (text[i] === '{' || text[i] === '[')) fail('depth', 'JSON exceeds 64 container levels.');
+    const c = text[i];
+    if (c === '"') return str();
+    if (c === '{' || c === '[') {
+      const array = c === '[', out = array ? [] : {}, keys = new Set();
+      const end = array ? ']' : '}'; i++; ws();
+      if (text[i] === end) { i++; return out; }
+      while (i < text.length) {
+        let key;
+        if (!array) {
+          ws(); if (text[i] !== '"') error(); key = str();
+          if (keys.has(key)) fail('duplicate', 'Duplicate JSON object member.');
+          if (forbidden(key)) fail('key', 'Unsafe object member.');
+          keys.add(key); ws(); if (text[i++] !== ':') error();
+        }
+        const child = value(depth + 1);
+        if (array) out.push(child); else out[key] = child;
+        ws(); if (text[i] === end) { i++; return out; }
+        if (text[i++] !== ',') error();
+      }
+      error();
+    }
+    for (const [token, v] of [['true', true], ['false', false], ['null', null]]) {
+      if (text.startsWith(token, i)) { i += token.length; return v; }
+    }
+    const match = /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?/.exec(text.slice(i));
+    if (!match) error(); i += match[0].length;
+    const n = Number(match[0]);
+    if (!Number.isFinite(n) || (Number.isInteger(n) && !Number.isSafeInteger(n))) fail('number', 'Unsafe JSON number.');
+    return Object.is(n, -0) ? 0 : n;
+  }
+  const out = value(1); ws(); if (i !== text.length) error(); return out;
+}
+
+export function decode(text) {
+  if (typeof text !== 'string' || Buffer.byteLength(text) > MAX_SHARE) fail('size', 'Input exceeds 2 MiB.');
+  text = text.replace(/^[ \t\r\n]+|[ \t\r\n]+$/g, '');
+  if (text.startsWith('DSHBP1:')) fail('legacy', 'Spaces v1 creates spaces. It is not a current-profile import; export v2 from the plugin manager.');
+  if (!text.startsWith('DSHBP')) return parseJson(text);
+  const m = /^DSHBP2:([JZ]):([A-Za-z0-9_-]+)$/.exec(text);
+  if (!m) fail('encoding', 'Unsupported blueprint code version or encoding.');
+  let bytes = Buffer.from(m[2], 'base64url');
+  if (bytes.toString('base64url') !== m[2]) fail('base64', 'Noncanonical Base64url.');
+  if (m[1] === 'Z') {
+    let result;
+    try { result = inflateRawSync(bytes, { maxOutputLength: MAX_JSON, info: true }); }
+    catch { fail('deflate', 'Invalid or oversized raw DEFLATE payload.'); }
+    if (result.engine.bytesWritten !== bytes.length) fail('deflate', 'Trailing DEFLATE data.');
+    bytes = result.buffer;
+  }
+  if (bytes.length > MAX_JSON) fail('size', 'Decoded JSON exceeds 1 MiB.');
+  let json; try { json = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(bytes); }
+  catch { fail('utf8', 'Invalid UTF-8.'); }
+  return parseJson(json);
+}
+export function encode(value, mode = 'shortest') {
+  if (!['J', 'Z', 'shortest'].includes(mode)) fail('encoding', 'Unsupported encoding.');
+  const json = JSON.stringify(value); parseJson(json);
+  const bytes = Buffer.from(json), j = `DSHBP2:J:${bytes.toString('base64url')}`;
+  if (mode === 'J') return j;
+  const z = `DSHBP2:Z:${deflateRawSync(bytes).toString('base64url')}`;
+  return mode === 'Z' || z.length < j.length ? z : j;
+}

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: klarkxy-blueprint
+      name: '@klarkxy/dsh-blueprint'

package/engine.mjs

@@ -0,0 +1,172 @@
+import { randomUUID } from 'node:crypto';
+import { decode, encode, fail } from './codec.mjs';
+import { validate, closed, array, text, path, identity, equal, overlaps, prefix, publicFields, policy, get } from './blueprint.mjs';
+
+function changesConnection(at, before, after) {
+  if (equal(before, after)) return false;
+  if (at.some(p => /^(?:base[_-]?url|endpoint|url|host|api[_-]?key[_-]?env)$/i.test(p))) return true;
+  const keys = value => value !== null && typeof value === 'object' ? Object.keys(value) : [];
+  // Whole-container edits must also protect nested additions, removals and replacements.
+  return [...new Set([...keys(before), ...keys(after)])]
+    .some(key => changesConnection([...at, key], get(before, [key]), get(after, [key])));
+}
+
+export class BlueprintEngine {
+  constructor(port, now = Date.now) { this.port = port; this.now = now; this.plans = new Map(); this.results = new Map(); this.busy = false; }
+  fields(form) {
+    const result = publicFields(form, form.policy), fields = [];
+    for (const field of result.fields) {
+      if (this.port.allows(form, field.path, field.value)) fields.push(field);
+      else result.omitted.push({ path: field.path, reason: 'not-native-editable' });
+    }
+    return { fields, omitted: result.omitted };
+  }
+  async catalog() {
+    const s = await this.port.snapshot();
+    return {
+      packages: s.packages.map(({ name, version, source, enabled, readonly, reason }) => ({ name, version, source, enabled, readonly, reason })),
+      forms: s.forms.map(f => ({ package: f.package, row: f.row, module: f.module, builtin: f.builtin, ...this.fields(f) })),
+      warnings: s.warnings,
+    };
+  }
+  async generate(request) {
+    closed(request, ['packages', 'forms', 'omit', 'mode', 'name'], 'export request');
+    if (!['plugins', 'settings'].includes(request.mode)) fail('mode', 'Choose plugins or settings.');
+    const selected = new Set(array(request.packages, 'selected packages', 128).map(n => text(n, 'package')));
+    const selectedForms = new Set(array(request.forms ?? [], 'selected forms').map(n => text(n, 'form', 2000)));
+    const omit = array(request.omit ?? [], 'omitted fields', 2048);
+    for (const o of omit) { closed(o, ['form', 'path'], 'omitted field'); text(o.form, 'form', 2000); path(o.path); }
+    const s = await this.port.snapshot(), packages = [];
+    for (const name of selected) {
+      const p = s.packages.find(p => p.name === name);
+      if (!p || p.readonly || !p.source || p.reason) fail('package', `Cannot export ${name}; inspect its status in the plugin manager.`);
+      packages.push({ name, version: p.version, source: p.source });
+    }
+    // Native order, not checkbox order or alphabetical UI card order.
+    packages.sort((a, b) => s.packages.findIndex(p => p.name === a.name) - s.packages.findIndex(p => p.name === b.name));
+    const blueprint = {
+      kind: 'dsh-blueprint', formatVersion: 2, metadata: { name: text(request.name, 'name', 120), version: '1.0.0' },
+      packages, bundles: s.order.filter(n => selected.has(n)),
+    };
+    const omitted = [];
+    if (request.mode === 'settings') {
+      blueprint.settings = [];
+      for (const id of selectedForms) {
+        const f = s.forms.find(f => identity(f) === id);
+        if (!f || (!selected.has(f.package) && !f.builtin)) fail('form', 'Selected form is not available for the selected packages.');
+        const result = this.fields(f);
+        const fields = result.fields.filter(field => !omit.some(o => o.form === id && overlaps(o.path, field.path)));
+        omitted.push(...result.omitted.map(o => ({ form: id, ...o })));
+        if (fields.length) blueprint.settings.push({ package: f.package, row: f.row, module: f.module, fields });
+      }
+      blueprint.rows = s.rows.filter(r => selected.has(r.package) && !r.readonly)
+        .map(({ package: pkg, row, module, enabled }) => ({ package: pkg, row, module, enabled }));
+    }
+    const checked = validate(blueprint);
+    return { blueprint: checked, json: JSON.stringify(checked, null, 2), code: encode(checked), omitted, warnings: s.warnings };
+  }
+  async preview(request) {
+    closed(request, ['text'], 'preview request');
+    const bp = validate(decode(request.text));
+    const s = await this.port.snapshot(), operations = [], blockers = [];
+    const selected = new Set(bp.packages.map(p => p.name));
+    for (const p of bp.packages) {
+      const current = s.packages.find(x => x.name === p.name);
+      if (current) {
+        if (current.readonly || current.reason || current.source !== p.source || current.version !== p.version) blockers.push(`${p.name}: protected, unsupported source or different version; resolve it in the official manager first.`);
+      } else if (p.source !== 'npm') blockers.push(`${p.name}: this host does not supply the requested built-in bundle.`);
+      else {
+        const inspected = await this.port.inspect(`${p.name}@${p.version}`);
+        if (inspected.status !== 'accepted' || inspected.bundle !== true || inspected.name !== p.name || inspected.version !== p.version) blockers.push(`${p.name}: the official manager did not confirm this exact bundle.`);
+        else operations.push({ type: 'install', name: p.name, version: p.version });
+      }
+    }
+    const currentOrder = s.order.filter(n => selected.has(n));
+    const reorder = !equal(currentOrder, bp.bundles);
+    if (reorder) {
+      for (const name of currentOrder) operations.push({ type: 'bundle', name, enabled: false });
+      for (const name of bp.bundles) operations.push({ type: 'bundle', name, enabled: true });
+    }
+    const packageStage = operations.length > 0;
+    const settingsRequested = (bp.settings?.length ?? 0) + (bp.rows?.length ?? 0) > 0;
+    if (!packageStage) {
+      for (const config of bp.settings ?? []) {
+        const form = s.forms.find(f => identity(f) === identity(config));
+        if (!form || (!selected.has(form.package) && !form.builtin)) { blockers.push(`${config.row}: no matching native editable Settings form on this host; custom configuration is not imported.`); continue; }
+        const rules = policy(form.policy), edits = [];
+        for (const field of config.fields) {
+          const denied = (form.secrets ?? []).some(secret => overlaps(secret.path, field.path))
+            || rules.exclude.some(p => overlaps(p, field.path))
+            || rules.include !== null && !rules.include.some(p => prefix(p, field.path));
+          if (denied || !this.port.allows(form, field.path, field.value)) { blockers.push(`${config.row}/${field.path.join('/')}: not a shareable editable field.`); continue; }
+          if (equal(get(form.value, field.path), field.value)) continue;
+          if (changesConnection(field.path, get(form.value, field.path), field.value)) {
+            blockers.push(`${config.row}: changing a connection target while retaining a credential requires rebinding in the official configuration page.`); continue;
+          }
+          edits.push({ op: 'set', path: field.path, value: field.value });
+        }
+        if (edits.length) operations.push({ type: 'settings', package: config.package, row: config.row, module: config.module, revision: form.revision, edits });
+      }
+      for (const row of bp.rows ?? []) {
+        const current = s.rows.find(r => identity(r) === identity(row));
+        if (!current || current.readonly) { blockers.push(`${row.row}: unavailable or protected row.`); continue; }
+        if (current.enabled !== row.enabled) operations.push({ type: 'row', entryId: current.entryId, row: row.row, enabled: row.enabled });
+      }
+    }
+    // Inspection can involve network I/O. Bind the plan only if the observed profile stayed unchanged.
+    if ((await this.port.snapshot()).stamp !== s.stamp) fail('stale', 'Profile changed while preparing the preview.');
+    const result = {
+      stage: packageStage ? 'packages' : 'settings', blockers,
+      operations, next: packageStage && settingsRequested ? 'preview-settings' : null,
+      order: reorder ? [...s.order.filter(n => !selected.has(n)), ...bp.bundles] : s.order,
+      notice: 'No packages are removed. Native installation may execute previously approved package scripts. Enabling bundles executes plugin code. Settings are additive field edits, not a full environment clone.',
+    };
+    if (blockers.length) return { ...result, planId: null };
+    for (const [id, p] of this.plans) if (p.expires <= this.now()) this.plans.delete(id);
+    if (this.plans.size >= 8) fail('capacity', 'Too many outstanding previews. Let an old preview expire.');
+    const planId = randomUUID();
+    this.plans.set(planId, { ...result, stamp: s.stamp, expires: this.now() + 300_000 });
+    return { ...result, planId };
+  }
+  async apply(planId, signal = new AbortController().signal) {
+    text(planId, 'plan id');
+    if (this.results.has(planId)) return this.results.get(planId);
+    if (this.busy) fail('busy', 'A blueprint operation is already running.');
+    const p = this.plans.get(planId);
+    if (!p || p.expires <= this.now()) { this.plans.delete(planId); fail('expired', 'Preview expired or was already consumed.'); }
+    this.busy = true;
+    const report = { planId, status: 'applied', next: p.next, steps: [] };
+    try {
+      if ((await this.port.snapshot()).stamp !== p.stamp) fail('stale', 'Profile changed after preview.');
+      this.plans.delete(planId);
+      let stamp = p.stamp;
+      for (const operation of p.operations) {
+        if (signal.aborted) { report.status = 'interrupted'; break; }
+        try {
+          const before = await this.port.snapshot();
+          if (before.stamp !== stamp) { report.status = 'conflict'; break; }
+          const outcome = await this.port.execute(operation, signal);
+          report.steps.push({ type: operation.type, target: operation.name ?? operation.row, outcome });
+          if (outcome.application && outcome.application !== 'applied') { report.status = outcome.application; break; }
+          const after = await this.port.snapshot();
+          if (!this.port.verify(operation, after)) { report.status = 'verification-failed'; break; }
+          stamp = after.stamp;
+        } catch (e) {
+          // Plugin validation errors can contain submitted values or credentials. Never echo arbitrary messages.
+          if (report.steps.length === p.operations.indexOf(operation)) report.steps.push({ type: operation.type, target: operation.name ?? operation.row, outcome: { application: 'failed', code: 'operation-failed' } });
+          report.status = 'failed'; break;
+        }
+      }
+      if (report.status === 'applied') {
+        try { if (!equal((await this.port.snapshot()).order, p.order)) report.status = 'verification-failed'; }
+        catch { report.status = 'verification-failed'; }
+      }
+      report.remaining = p.operations.length - report.steps.length;
+      if (report.status !== 'applied') report.next = null;
+      this.results.set(planId, report);
+      if (this.results.size > 8) this.results.delete(this.results.keys().next().value);
+      return report;
+    } finally { this.busy = false; }
+  }
+  dispose() { this.plans.clear(); this.results.clear(); }
+}

package/index.mjs

@@ -0,0 +1,33 @@
+import { BlueprintError, MAX_SHARE } from './codec.mjs';
+import { closed, text } from './blueprint.mjs';
+import { BlueprintEngine } from './engine.mjs';
+import { officialPort } from './official.mjs';
+export const name = 'dsh-blueprint';
+export const inject = ['connection', 'pluginManager', 'profileContext', 'pluginPackages', 'settings', 'loader'];
+export function apply(ctx) {
+  const engine = new BlueprintEngine(officialPort(ctx)), lifetime = new AbortController();
+  ctx.effect(() => () => { lifetime.abort(); engine.dispose(); });
+  // The official Connection registry supplies authentication and the Host/Origin fence.
+  ctx.connection.rpc.handle('/dsh-blueprint', async (endpoint, payload, signal) => {
+    try {
+      if (Buffer.byteLength(JSON.stringify(payload) ?? '') > MAX_SHARE + 65536) throw new BlueprintError('size', 'Request too large.');
+      const combined = AbortSignal.any([signal, lifetime.signal]); combined.throwIfAborted();
+      let value;
+      switch (endpoint) {
+        case 'catalog': closed(payload, [], 'catalog request'); value = await engine.catalog(); break;
+        case 'generate': value = await engine.generate(payload); break;
+        case 'preview': value = await engine.preview(payload); break;
+        case 'apply':
+          closed(payload, ['planId', 'confirmed'], 'apply request');
+          if (payload.confirmed !== true) throw new BlueprintError('confirmation', 'Explicit confirmation is required.');
+          value = await engine.apply(text(payload.planId, 'plan id'), combined); break;
+        case 'result': closed(payload, ['planId'], 'result request'); value = engine.results.get(text(payload.planId, 'plan id')) ?? null; break;
+        default: throw new BlueprintError('endpoint', 'Unknown blueprint endpoint.');
+      }
+      return { ok: true, value };
+    } catch (e) {
+      return { ok: false, error: { code: e instanceof BlueprintError ? e.code : 'operation-failed',
+        message: e instanceof BlueprintError ? e.message : 'The operation failed. Review the official plugin manager; no automatic retry was performed.', details: {} } };
+    }
+  });
+}

package/locale/en.json

@@ -0,0 +1 @@
+{"meta":{"name":"Blueprints","description":"Share and import plugin combinations and configuration presets in the official plugin manager."}}

package/locale/zh.json

@@ -0,0 +1 @@
+{"meta":{"name":"蓝图","description":"在官方插件管理器内分享、导入插件组合与配置预设。"}}

package/official.mjs

@@ -0,0 +1,113 @@
+/** Official DSH adapter. No private Spaces APIs, filesystem writes, shell commands or credential reads. */
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createHash, randomUUID } from 'node:crypto';
+import { PACKAGE, closed, exactVersion, identity, equal, get, policy, schemaAllows } from './blueprint.mjs';
+import { parseJson, plain, fail } from './codec.mjs';
+// Native Settings descriptors are the data contract. UI slots and custom
+// pages are presentation only: never inspect them to infer a storage schema.
+function cleanResult(r) {
+  if (!r || !['applied', 'restart-required', 'overridden', 'failed', 'cancelled'].includes(r.application)) fail('native-contract', 'Unsupported native management result.');
+  return { application: r.application, changed: r.changed,
+    ...(r.error ? { code: r.error.code } : {}),
+    ...(r.pendingBuilds?.length ? { pendingBuilds: r.pendingBuilds } : {}) };
+}
+export function officialPort(ctx) {
+  const manager = ctx.pluginManager;
+  for (const name of ['listBundles', 'listPlugins', 'inspect', 'installBundle', 'setBundleEnabled', 'setPluginEnabled']) {
+    if (typeof manager?.[name] !== 'function') fail('capability', `Official pluginManager.${name} is required.`);
+  }
+  if (typeof ctx.settings?.describe !== 'function' || typeof ctx.settings?.mutate !== 'function'
+    || typeof ctx.loader?.entries !== 'function' || !ctx.profileContext?.dir) fail('capability', 'Official profile-backed Settings and Loader services are required.');
+  const manifestPath = join(ctx.profileContext.dir, 'package.json');
+  async function snapshot() {
+    const before = readFileSync(manifestPath, 'utf8');
+    const manifest = parseJson(before);
+    const [nativeBundles, nativeRows] = await Promise.all([manager.listBundles(), manager.listPlugins()]);
+    const descriptors = ctx.settings.describe({ redactSecrets: true });
+    if (!Array.isArray(descriptors) || descriptors.some(d => d.applies !== 'live' || !Array.isArray(d.secrets))) fail('capability', 'This host lacks the redacted, profile-backed Settings form contract.');
+    const packages = nativeBundles.map(b => {
+      const readonly = Boolean(b.readOnlyReason || b.name === PACKAGE || b.rows.some(r => r.moduleName === PACKAGE)
+        || !b.installed && !b.optional);
+      const spec = manifest.dependencies?.[b.name];
+      // Only registry dependencies can honestly be exported as npm identities. Local/git/tarball sources stay unsupported.
+      const registry = typeof spec === 'string' && /^[0-9A-Za-z*~^<>=|.+ -]+$/.test(spec);
+      const source = b.installed ? registry ? 'npm' : null : 'builtin';
+      const reason = b.error ? 'native-bundle-error' : !exactVersion(b.version) ? 'unknown-exact-version' : !source ? 'non-registry-source' : null;
+      return { name: b.name, version: b.version ?? null, source, enabled: b.enabled, readonly, reason };
+    });
+    const order = manifest.dsh?.profile?.bundles;
+    if (!Array.isArray(order) || order.some(n => typeof n !== 'string')) fail('profile', 'No native ordered bundle manifest.');
+    const rows = [], forms = [], warnings = [];
+    const entries = [...ctx.loader.entries()];
+    const policies = new Map();
+    for (const b of nativeBundles) {
+      let declarations = {};
+      try {
+        const dir = ctx.pluginPackages?.packageOf(b.name, pathToFileURL(manifestPath).href)?.dir;
+        if (!dir) throw new Error('unresolved');
+        const meta = parseJson(readFileSync(join(dir, 'package.json'), 'utf8'));
+        if (meta.name !== b.name || meta.version !== b.version) throw new Error('identity');
+        if (meta.dshBlueprint !== undefined) {
+          closed(meta.dshBlueprint, ['version', 'entries'], 'blueprint contribution');
+          if (meta.dshBlueprint.version !== 1 || !plain(meta.dshBlueprint.entries)) throw new Error('policy');
+          declarations = meta.dshBlueprint.entries;
+          for (const v of Object.values(declarations)) policy(v);
+        }
+        policies.set(b.name, declarations);
+      } catch { warnings.push(`${b.name}: configuration policy could not be read safely; only the package list is available.`); }
+      for (const row of b.rows) {
+        const native = nativeRows.find(r => r.entryId === row.entryId);
+        if (native) rows.push({ package: b.name, row: row.rowId, module: row.moduleName, entryId: native.entryId,
+          enabled: native.enabled, readonly: Boolean(native.readOnlyReason || b.name === PACKAGE) });
+      }
+    }
+    for (const d of descriptors) {
+      const owners = nativeBundles.flatMap(b => b.rows.filter(r => r.rowId === d.ns).map(r => ({ b, r })));
+      if (owners.length !== 1) { warnings.push(`${d.ns}: native configuration ownership is ambiguous or unavailable.`); continue; }
+      const { b, r } = owners[0];
+      if (b.name === PACKAGE || !policies.has(b.name)) continue;
+      const native = nativeRows.find(n => n.entryId === r.entryId);
+      const entry = entries.find(e => e.id === r.entryId && e.options.id === d.ns && e.options.name === r.moduleName);
+      const schema = entry?.fiber?.runtime?.Config;
+      if (!native || !native.enabled || native.moduleName !== r.moduleName || native.readOnlyReason || !schema || !plain(d.value)) { warnings.push(`${d.ns}: native configuration is not safely addressable.`); continue; }
+      forms.push({ package: b.name, row: d.ns, module: r.moduleName, builtin: !b.installed,
+        value: d.value, secrets: d.secrets, revision: d.revision, schema, policy: policies.get(b.name)[d.ns] });
+    }
+    for (const p of packages) {
+      if (!p.readonly && !forms.some(f => f.package === p.name)) warnings.push(`${p.name}: no supported native editable Settings form; custom pages and storage are outside blueprint scope.`);
+    }
+    if (readFileSync(manifestPath, 'utf8') !== before) fail('stale', 'Profile changed while reading the catalog.');
+    const stamp = createHash('sha256').update(JSON.stringify({ manifest: before, packages, rows,
+      forms: forms.map(f => [identity(f), f.revision, f.policy ?? null]) })).digest('hex');
+    return { packages, order, rows, forms, warnings, stamp };
+  }
+  return {
+    snapshot,
+    inspect: spec => manager.inspect(spec),
+    allows: (form, at, proposed) => schemaAllows(form.schema, at, proposed),
+    async execute(op, signal) {
+      if (signal.aborted) fail('interrupted', 'Operation interrupted.');
+      if (op.type === 'install') {
+        const requestId = randomUUID();
+        // Script grants are never supplied by a blueprint. Native policy remains the authority.
+        const stop = () => { if (typeof manager.cancelInstall === 'function') void manager.cancelInstall(requestId).catch(() => {}); };
+        signal.addEventListener('abort', stop, { once: true });
+        try { return cleanResult(await manager.installBundle(`${op.name}@${op.version}`, { enabled: false, requestId })); }
+        finally { signal.removeEventListener('abort', stop); }
+      }
+      if (op.type === 'bundle') return cleanResult(await manager.setBundleEnabled(op.name, op.enabled));
+      if (op.type === 'row') return cleanResult(await manager.setPluginEnabled(op.entryId, op.enabled));
+      if (op.type === 'settings') { await ctx.settings.mutate(op.row, op.edits, op.revision); return { application: 'applied' }; }
+      fail('operation', 'Unsupported operation.');
+    },
+    verify(op, s) {
+      if (op.type === 'install') return s.packages.some(p => p.name === op.name && p.version === op.version && p.source === 'npm' && !p.reason);
+      if (op.type === 'bundle') return s.packages.some(p => p.name === op.name && p.enabled === op.enabled);
+      if (op.type === 'row') return s.rows.some(r => r.entryId === op.entryId && r.enabled === op.enabled);
+      const form = s.forms.find(f => identity(f) === identity(op));
+      return Boolean(form && op.edits.every(edit => equal(get(form.value, edit.path), edit.value)));
+    },
+  };
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@klarkxy/dsh-blueprint",
+  "version": "0.1.0-alpha.2",
+  "description": "Import and export plugin blueprints from the official DSH plugin manager.",
+  "type": "module",
+  "main": "index.mjs",
+  "exports": {
+    ".": "./index.mjs",
+    "./core": "./blueprint.mjs",
+    "./codec": "./codec.mjs",
+    "./client": "./client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "files": [
+    "*.mjs",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/*.json",
+    "README*.md",
+    "NOTICE.md",
+    "LICENSE",
+    "ACCEPTANCE.md",
+    "SETTINGS-SCOPE.md"
+  ],
+  "scripts": {
+    "build": "node --check index.mjs && node --check client.js && node --check official.mjs && node --check engine.mjs && node --check blueprint.mjs && node --check codec.mjs",
+    "test": "node --test tests/*.test.mjs"
+  },
+  "engines": {
+    "node": ">=22",
+    "dsh": ">=0.1.7-0 <0.2.0"
+  },
+  "license": "MIT",
+  "author": "klarkxy",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/klarkxy/dsh-plugins.git",
+    "directory": "plugins/dsh-blueprint"
+  },
+  "homepage": "https://klarkxy.github.io/dsh-plugins/plugins/blueprint/",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-plugin-manager",
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-connection"
+      ]
+    }
+  },
+  "dshRelease": {
+    "contentHash": "f2612ba3162fb21206dfa2f290d95585fa4b289651784093535a47e1f9c91179"
+  }
+}