@microi.net/cli 6.1.6 → 6.1.8

package/skills/microi-system-delivery/references/progressive-03-/345/256/211/345/205/250/344/270/216/350/267/250/347/253/257/351/252/214/346/224/266.md

@@ -2,70 +2,70 @@
 
 > 原规则按适用范围无损迁移；触发对应工作时必须完整读取相关章节。
 
-<!-- microi-progressive:chunk id=microi-system-delivery-002 sha256=b4cd10b169b54235314d170c8e74f17bf6bcb5f658d0d4d2e10c73dc8aa37ef7 -->
-## 平台安全与存量兼容验收（强制）
-
-AI 零代码交付不能只验证管理员帐号和页面能打开。任何涉及 FormEngine、菜单、角色、子表、文件、SaaS 或登录协议的交付，都必须按以下服务端边界设计和验收：
-
-### FormEngine 混合授权
-
-- Token 只完成身份认证，不是任意表的访问凭证。浏览器、UniApp、SDK 等外部请求必须继续校验表、菜单、角色、操作权限和数据范围。
-- 显式 `_SysMenuId` / `ModuleEngineKey` 进入精确菜单校验；伪造、传错或借用其它表菜单时失败关闭，不能退回兼容推断。
-- 为兼容存量前端 V8，无菜单请求由后端从当前用户真正拥有的菜单授权快照中推断目标表权限。没有候选菜单、范围无法安全合并或解析失败时失败关闭；不要要求所有历史项目一次性补 `_SysMenuId`。
-- 标准 PC facade 只给当前菜单绑定的当前表注入菜单 Id，跨表调用不借用主表菜单。没有菜单入口的 SDK/定制页才使用最小【高级表权限】。
-- 后端接口引擎、后端表单 V8 和平台内部调用由服务端建立可信上下文，不要求 `_SysMenuId`；客户端伪造 `_TrustedServerInvocation` 或 `_InvokeType:'Server'` 不能获得信任。
-- `TableChild` 使用父记录范围内委托：验证父菜单、父表字段配置、子菜单、父记录数据范围和外键，并由服务端强制注入外键。隐藏子菜单不要求存量角色逐个补权限。
-- 菜单 `SqlWhere` / `SqlJoin` 只约束列表、计数、导出等集合查询；单行详情只校验同表菜单访问权。主表写入由 `Add` / `Edit` / `Del` / `Import` 专项权限控制，不把查询范围追加到写入 SQL，也不因查询 Join 拒绝。行级写业务限制放在后端表单 V8 或专用接口引擎。
-
-### 保护表、控制面与缓存
-
-- 平台表按 `PlatformResourceSecurity` 的管理员专用、只读委托、按角色管理三类校验，不使用过时的统一硬拒绝清单。`sys_apiengine` 的标准 FormEngine 管理按真实菜单/表操作授权，不能因 `Level < 9999` 拒绝已获授权的开发角色；无授权、伪造菜单、匿名和撤权必须拒绝。
-- 接口代码写权限只授予可信开发角色；任务、Redis 等其它控制面门禁、接口运行权限和 MCP 专用开发权限仍独立执行，不能只靠前端隐藏菜单，也不能从接口管理菜单权限推导其它控制面权限。
-- 权限缓存使用按 `OsClient` 隔离的共享 Redis `epoch`、用户快照、短 TTL L1/L2。用户/角色/菜单/权限变化后提升 `epoch`；验收至少使用两个节点确认无需清 Redis或重启即可生效。
-- Upgrade15 只清理普通角色的保护表直接授权，不能删除正常业务菜单权限。
-
-### 上传、私有文件与 SaaS
-
-- 上传业务默认值为 100 MB/文件、200 MB/次、10 文件、2 GB/帐号/日、20 GB/租户/日。有效值只按当前租户 `sys_osclients` → 代码安全默认值解析，租户可以提高或降低业务默认值；不得为上传开关、额度或硬上限新增 API 环境变量或 `appsettings` 节点。最终仍受代码内不可突破的灾难保护、HTTP/Multipart/Form 和反向代理上限约束。共享 Redis 原子预留，Redis 故障失败关闭。
-- 无字段上下文的普通交互式上传默认私有桶，一级安全目录为 `file`、`img`、`avatar`、`editor`；可由管理员在普通 `sys_config.HdfsUploadRules` 按真实角色授权业务目录与公有权限。通配符必须有界并先校验实际路径，保留目录与跨租户不能放行。标准表单仍按权威字段配置执行。可信后端 V8 仍受全局文件大小硬上限。
-- 普通客户端私有文件签名必须提交 `FormEngineKey`、`FormDataId`、`FieldId`、`SysMenuId` 并验证记录字段真实引用；不能把后端 `V8.Method.GetPrivateFileUrl({FilePathName})` 的可信调用方式照搬到浏览器。
-- Upgrade16 六个上传字段全部可空，空值保持老租户兼容；升级后回读字段元数据、租户值并刷新 SaaS 缓存。
-- `V8.OsClientModel` / `V8.SysConfig` 只使用脱敏副本，不返回整个对象。新租户不能复制主租户整条 `sys_osclients`；数据库、认证、Redis、存储、MQ/MQTT、搜索凭据必须独立创建或由服务端托管。
-- Redis 管理器只允许超级管理员使用当前租户或已保存连接；匿名/temporary 任意 Host 连接必须拒绝，MCP 写操作必须 `confirmExecution`，禁止传递 Redis 密码。
-
-### 网络、登录和发布兼容
-
-- `CorsAllowOrigins` 和全局 CORS 来源都为空时默认允许任意来源；配置后才按精确来源/通配符收紧。CORS 不是鉴权边界。
-- 严格 SSRF 默认关闭，未配置时不得拒绝存量非 HTTP(S)、URL 凭据、私网、云元数据和重定向调用；显式启用后才执行严格拦截与精确主机白名单。
-- 登录 RSA 仅避免密码在请求体直接显示，HTTPS 才是安全边界。必须保留历史 RSA fallback，专属公私钥成对切换，不能因删除旧常量造成所有客户无法登录。
-- 登录传 `_ClientType`，请求携带稳定 `did`，每次响应接收 `authorization`。多标签续签 single-flight；`TokenReplaced` 先检查新 Token，旧响应不能清掉新登录态。
-- 安全升级不得删除私有子 Git 的 `Microi.Server/Microi.net/License/keys/`。授权签名资产与登录 RSA 用途不同，禁止以安全清理为由混删。
-- 不得修改默认 CORS/SSRF/RSA 行为后只用新装环境验收；必须覆盖旧前端、历史 V8、滚动升级和至少两个节点。
-
-### 安全自动化最低断言
-
-1. 普通角色保护表读写、伪造菜单、伪造可信标记均失败。
-2. 真实菜单、历史无菜单推断和父记录范围内 TableChild 均成功，跨父记录失败。
-3. 查询范围在列表、计数、导出中生效；详情按同表菜单访问权成功；有写权限的单表/Join 模块写入成功，无写权限失败，后端 V8 行级业务校验可回滚。
-4. 节点 A 改权限后节点 B 无需重启生效。
-5. 上传大小/数量/双日额度、多节点并发和 Redis 故障行为正确。
-6. 私有文件跨菜单/记录/字段失败，授权访问成功，匿名失败。
-7. CORS 空配置兼容、配置后收紧；SSRF 默认兼容、严格模式拦截。
-8. 历史 RSA fallback 和专属匹配密钥均可登录；并发续签不反复退出。
-9. SaaS 脱敏投影不包含基础设施密钥，Redis anonymous/temporary/非管理员管理失败。
-
+<!-- microi-progressive:chunk id=microi-system-delivery-002 sha256=1cf73c1365e3f8245b2069f5f2e24bcbfdc7f6e67c0f13524998b16f7bbf029b -->
+## 平台安全与存量兼容验收（强制）
+
+AI 零代码交付不能只验证管理员帐号和页面能打开。任何涉及 FormEngine、菜单、角色、子表、文件、SaaS 或登录协议的交付，都必须按以下服务端边界设计和验收：
+
+### FormEngine 混合授权
+
+- Token 只完成身份认证，不是任意表的访问凭证。浏览器、UniApp、SDK 等外部请求必须继续校验表、菜单、角色、操作权限和数据范围。
+- 显式 `_SysMenuId` / `ModuleEngineKey` 进入精确菜单校验；伪造、传错或借用其它表菜单时失败关闭，不能退回兼容推断。
+- 为兼容存量前端 V8，无菜单请求由后端从当前用户真正拥有的菜单授权快照中推断目标表权限。没有候选菜单、范围无法安全合并或解析失败时失败关闭；不要要求所有历史项目一次性补 `_SysMenuId`。
+- 标准 PC facade 只给当前菜单绑定的当前表注入菜单 Id，跨表调用不借用主表菜单。没有菜单入口的 SDK/定制页才使用最小【高级表权限】。
+- 后端接口引擎、后端表单 V8 和平台内部调用由服务端建立可信上下文，不要求 `_SysMenuId`；客户端伪造 `_TrustedServerInvocation` 或 `_InvokeType:'Server'` 不能获得信任。
+- `TableChild` 使用父记录范围内委托：验证父菜单、父表字段配置、子菜单、父记录数据范围和外键，并由服务端强制注入外键。隐藏子菜单不要求存量角色逐个补权限。
+- 菜单 `SqlWhere` / `SqlJoin` 只约束列表、计数、导出等集合查询；单行详情只校验同表菜单访问权。主表写入由 `Add` / `Edit` / `Del` / `Import` 专项权限控制，不把查询范围追加到写入 SQL，也不因查询 Join 拒绝。行级写业务限制放在后端表单 V8 或专用接口引擎。
+
+### 保护表、控制面与缓存
+
+- 平台表按 `PlatformResourceSecurity` 的管理员专用、只读委托、按角色管理三类校验，不使用过时的统一硬拒绝清单。`sys_apiengine` 的标准 FormEngine 管理按真实菜单/表操作授权，不能因 `Level < 9999` 拒绝已获授权的开发角色；无授权、伪造菜单、匿名和撤权必须拒绝。
+- 接口代码写权限只授予可信开发角色；任务、Redis 等其它控制面门禁、接口运行权限和 MCP 专用开发权限仍独立执行，不能只靠前端隐藏菜单，也不能从接口管理菜单权限推导其它控制面权限。
+- 权限缓存使用按 `OsClient` 隔离的共享 Redis `epoch`、用户快照、短 TTL L1/L2。用户/角色/菜单/权限变化后提升 `epoch`；验收至少使用两个节点确认无需清 Redis或重启即可生效。
+- Upgrade15 只清理普通角色的保护表直接授权，不能删除正常业务菜单权限。
+
+### 上传、私有文件与 SaaS
+
+- 上传业务默认值为 100 MB/文件、200 MB/次、10 文件、2 GB/帐号/日、20 GB/租户/日。有效值只按当前租户 `sys_osclients` → 代码安全默认值解析，租户可以提高或降低业务默认值；不得为上传开关、额度或硬上限新增 API 环境变量或 `appsettings` 节点。最终仍受代码内不可突破的灾难保护、HTTP/Multipart/Form 和反向代理上限约束。共享 Redis 原子预留，Redis 故障失败关闭。
+- 无字段上下文的普通交互式上传默认私有桶，一级安全目录为 `file`、`img`、`avatar`、`editor`；可由管理员在普通 `sys_config.HdfsUploadRules` 按真实角色授权业务目录与公有权限。通配符必须有界并先校验实际路径，保留目录与跨租户不能放行。标准表单仍按权威字段配置执行。可信后端 V8 仍受全局文件大小硬上限。
+- 普通客户端私有文件签名必须提交 `FormEngineKey`、`FormDataId`、`FieldId`、`SysMenuId` 并验证记录字段真实引用；不能把后端 `V8.Method.GetPrivateFileUrl({FilePathName})` 的可信调用方式照搬到浏览器。
+- Upgrade16 六个上传字段全部可空，空值保持老租户兼容；升级后回读字段元数据、租户值并刷新 SaaS 缓存。
+- `V8.OsClientModel` / `V8.SysConfig` 只使用脱敏副本，不返回整个对象。新租户不能复制主租户整条 `sys_osclients`；数据库、认证、Redis、存储、MQ/MQTT、搜索凭据必须独立创建或由服务端托管。
+- Redis 管理器只允许超级管理员使用当前租户或已保存连接；匿名/temporary 任意 Host 连接必须拒绝，MCP 写操作必须 `confirmExecution`，禁止传递 Redis 密码。
+
+### 网络、登录和发布兼容
+
+- `CorsAllowOrigins` 和全局 CORS 来源都为空时默认允许任意来源；配置后才按精确来源/通配符收紧。CORS 不是鉴权边界。
+- 严格 SSRF 默认关闭，未配置时不得拒绝存量非 HTTP(S)、URL 凭据、私网、云元数据和重定向调用；显式启用后才执行严格拦截与精确主机白名单。
+- 登录 RSA 仅避免密码在请求体直接显示，HTTPS 才是安全边界。必须保留历史 RSA fallback，专属公私钥成对切换，不能因删除旧常量造成所有客户无法登录。
+- 登录传 `_ClientType`，请求携带稳定 `did`，每次响应接收 `authorization`。多标签续签 single-flight；`TokenReplaced` 先检查新 Token，旧响应不能清掉新登录态。
+- 安全升级不得删除私有子 Git 的 `Microi.Server/Microi.net/License/keys/`。授权签名资产与登录 RSA 用途不同，禁止以安全清理为由混删。
+- 不得修改默认 CORS/SSRF/RSA 行为后只用新装环境验收；必须覆盖旧前端、历史 V8、滚动升级和至少两个节点。
+
+### 安全自动化最低断言
+
+1. 普通角色保护表读写、伪造菜单、伪造可信标记均失败。
+2. 真实菜单、历史无菜单推断和父记录范围内 TableChild 均成功，跨父记录失败。
+3. 查询范围在列表、计数、导出中生效；详情按同表菜单访问权成功；有写权限的单表/Join 模块写入成功，无写权限失败，后端 V8 行级业务校验可回滚。
+4. 节点 A 改权限后节点 B 无需重启生效。
+5. 上传大小/数量/双日额度、多节点并发和 Redis 故障行为正确。
+6. 私有文件跨菜单/记录/字段失败，授权访问成功，匿名失败。
+7. CORS 空配置兼容、配置后收紧；SSRF 默认兼容、严格模式拦截。
+8. 历史 RSA fallback 和专属匹配密钥均可登录；并发续签不反复退出。
+9. SaaS 脱敏投影不包含基础设施密钥，Redis anonymous/temporary/非管理员管理失败。
+
 <!-- /microi-progressive:chunk -->
-<!-- microi-progressive:chunk id=microi-system-delivery-003 sha256=479ccdb65450c7741b052a30d8e4a11917bc19d80bf9b4ac89ea00092b4aaa73 -->
-## 前端交付检查清单
-
-- 底部 tabBar 图标不 404。
-- 首页、分类、详情、Banner、头像、订单凭证图全部真实加载。
-- 主题切换是全局生效，不是只对一个页面生效。
-- 列表页和详情页显示同一主体名称、头像、状态，不能列表对、详情错。
-- 关联人名不得退化成“卖家BMB9”“匿名卖家”等可推断 Id 的兜底，除非确实无数据。
-- 关键业务资产不得默认选中第一条，必须用户手动选择。
-- 自己不能抢自己的单，不能约自己的单，必须给明确提示。
-- 消息/待办/约单/审核类提醒必须有未读角标，已读后消失。
-- 订单状态角标只给需要处理的状态，不给“全部/已完成/已取消”等静态分类堆数字。
-
+<!-- microi-progressive:chunk id=microi-system-delivery-003 sha256=8e2891f2a149d6828b653b9f0735ea39a4df5ba60178c79f0e5b0065ce72ee84 -->
+## 前端交付检查清单
+
+- 底部 tabBar 图标不 404。
+- 首页、分类、详情、Banner、头像、订单凭证图全部真实加载。
+- 主题切换是全局生效，不是只对一个页面生效。
+- 列表页和详情页显示同一主体名称、头像、状态，不能列表对、详情错。
+- 关联人名不得退化成“卖家BMB9”“匿名卖家”等可推断 Id 的兜底，除非确实无数据。
+- 关键业务资产不得默认选中第一条，必须用户手动选择。
+- 自己不能抢自己的单，不能约自己的单，必须给明确提示。
+- 消息/待办/约单/审核类提醒必须有未读角标，已读后消失。
+- 订单状态角标只给需要处理的状态，不给“全部/已完成/已取消”等静态分类堆数字。
+
 <!-- /microi-progressive:chunk -->

package/skills/microi.v8.js

@@ -569,12 +569,394 @@ function installDatePrototypeCompat() {
   }
 }
 
+// BEGIN GENERATED PUBLIC RESOURCE ROUTER; source SHA256 d90207991f19b46429dc21a654e2915e1b4fd6e96f191cede20485d823f3a975
+const createSdkPublicResourceClient = (() => {
+// 公有资源路由的纯校验器与实际消费者桥接；私有分支继续走既有授权接口。
+const HASH = /^[a-f0-9]{64}$/;
+const IDENTIFIER = /^[a-zA-Z0-9_-]{1,64}$/;
+const BLOCKED = /^(?:\.git|\.env|private|private-source|privatesource|source|_origin)$/i;
+
+function key(value) {
+  if (typeof value !== 'string' || !value || value.length > 1000 || /[\\%?#:\u0000-\u001f\u007f]/.test(value)
+      || value.split('/').some(part => !part || part === '.' || part === '..' || BLOCKED.test(part)) || /\.map$/i.test(value)) throw Error('InvalidPublicObjectKey');
+  encodeURIComponent(value); // Reject malformed UTF-16 rather than changing the key.
+  return value;
+}
+const encodeKey = value => value.split('/').map(encodeURIComponent).join('/');
+function plainBase(value, originOnly = false) {
+  if (typeof value !== 'string' || /[\\%?#@\u0000-\u0020\u007f]/.test(value)) throw Error('InvalidPublicBinding');
+  const parsed = new URL(value);
+  if (parsed.protocol !== 'https:' || parsed.username || parsed.password || parsed.search || parsed.hash
+      || (originOnly && parsed.pathname !== '/')) throw Error('InvalidPublicBinding');
+  return value.replace(/\/+$/, '');
+}
+function bindingSnapshot(binding) {
+  if (!binding || !IDENTIFIER.test(binding.tenant) || !IDENTIFIER.test(binding.storageOwnerTenant)
+      || !HASH.test(binding.targetConfigHash) || !/^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/.test(binding.publicBucket)
+      || binding.publicBucket.includes('..') || binding.publicBucket === binding.privateBucket) throw Error('InvalidPublicBinding');
+  const value = { tenant: binding.tenant, storageOwnerTenant: binding.storageOwnerTenant.toLowerCase(),
+    primaryBase: plainBase(binding.primaryBase), backupOrigin: plainBase(binding.backupOrigin, true),
+    publicBucket: binding.publicBucket, targetConfigHash: binding.targetConfigHash,
+    sourceMappings: (binding.sourceMappings || []).map(item => ({ origin: plainBase(item.origin, true),
+      pathPrefix: item.pathPrefix ? key(item.pathPrefix.replace(/\/+$/, '')) + '/' : '' })) };
+  if (!value.sourceMappings.length || value.sourceMappings.length > 20) throw Error('InvalidPublicBinding');
+  return { ...value, identity: JSON.stringify(value) };
+}
+function legacyPublicFallback(input, binding) {
+  if (!input || input.private === true || typeof input.path !== 'string') return '';
+  const path = input.path;
+  try {
+    if (/^https?:/i.test(path)) {
+      const url = new URL(path);
+      return !/[\\\u0000-\u0020\u007f]/.test(path) && !url.username && !url.password ? path : '';
+    }
+    if (path.startsWith('//') || path.startsWith('.')) return '';
+    if (/[\\\u0000-\u001f\u007f]/.test(path)) return '';
+    const relative = path.startsWith('/') ? path.slice(1) : path;
+    const decoratedAt = relative.search(/[?#]/);
+    const rawKey = decoratedAt < 0 ? relative : relative.slice(0, decoratedAt);
+    const suffix = decoratedAt < 0 ? '' : relative.slice(decoratedAt);
+    const objectKey = key(rawKey.split('/').map(part => decodeURIComponent(part)).join('/'));
+    return plainBase(binding?.primaryBase) + '/' + encodeKey(objectKey) + suffix;
+  } catch { return ''; }
+}
+function identify(input, binding) {
+  if (!input || input.private === true) return { input, accepted: false, reason: 'PrivateRoutingNotSupported', primaryUrl: '' };
+  const path = input.path;
+  try {
+    if (typeof path !== 'string' || !path) throw Error('InvalidInput');
+    if (/^https?:/i.test(path)) {
+      if (/[\\?#@\u0000-\u001f\u007f]/.test(path)) throw Error('SignedOrDecoratedUrlNotEligible');
+      const parsed = new URL(path);
+      const mapping = binding.sourceMappings.find(value => new URL(value.origin).origin === parsed.origin);
+      if (!mapping || parsed.protocol !== 'https:') throw Error('UnmanagedOrigin');
+      // Check raw path before URL() can normalize dot segments.
+      const begin = path.indexOf('/', path.indexOf('://') + 3);
+      if (begin < 0) throw Error('ObjectKeyMissing');
+      const objectKey = key(path.slice(begin + 1).split('/').map(part => {
+        const decoded = decodeURIComponent(part);
+        if (/[\/%\\?#:\u0000-\u001f\u007f]/.test(decoded)) throw Error('InvalidEncodedPath');
+        return decoded;
+      }).join('/'));
+      if (!objectKey.startsWith(mapping.pathPrefix)) throw Error('BucketPrefixMismatch');
+      return { accepted: true, objectKey: key(objectKey.slice(mapping.pathPrefix.length)), primaryUrl: path };
+    }
+    // Protocol-relative, traversal and double-slash paths are never interpreted
+    // as the configured public bucket. A single leading slash is legacy input.
+    if (path.startsWith('//') || path.startsWith('.')) throw Error('UnmanagedRelativePath');
+    const objectKey = key(path.startsWith('/') ? path.slice(1) : path);
+    return { accepted: true, objectKey, primaryUrl: binding.primaryBase + '/' + encodeKey(objectKey) };
+  } catch (error) { return { accepted: false, reason: error.message, primaryUrl: legacyPublicFallback(input, binding) }; }
+}
+function original(item, reason) {
+  return Object.freeze({ useBackup: false, url: item.primaryUrl, primaryUrl: item.primaryUrl,
+    objectKey: item.objectKey || null, reason });
+}
+function acceptedRoute(row, item, binding, time) {
+  if (!row || row.UseBackup !== true || row.ObjectKey !== item.objectKey || !HASH.test(row.SourceRevision)
+      || !HASH.test(row.ResourceId) || row.TargetConfigHash !== binding.targetConfigHash
+      || !Number.isSafeInteger(row.ExpiresAtUtc) || row.ExpiresAtUtc * 1000 <= time
+      || row.ExpiresAtUtc * 1000 > time + 300000 || typeof row.Url !== 'string' || /[?#@\\]/.test(row.Url)) return null;
+  const prefix = binding.backupOrigin + '/' + binding.publicBucket + '/_microi-hotspot/public/v3/'
+    + binding.storageOwnerTenant + '/' + row.ResourceId + '/' + row.SourceRevision + '/';
+  if (!row.Url.startsWith(prefix)) return null;
+  const rest = row.Url.slice(prefix.length), slash = rest.indexOf('/');
+  if (!/^[a-f0-9]{32}$/.test(rest.slice(0, slash)) || rest.slice(slash + 1) !== encodeKey(item.objectKey)) return null;
+  return Object.freeze({ useBackup: true, url: row.Url, primaryUrl: item.primaryUrl, objectKey: item.objectKey,
+    expiresAt: row.ExpiresAtUtc * 1000, reason: 'VerifiedPublicReplica' });
+}
+
+function createPublicResourceRouter({ getBinding, resolveBatch, now = Date.now, maxEntries = 512, timeoutMs = 5000 }) {
+  if (typeof getBinding !== 'function' || typeof resolveBatch !== 'function' || !Number.isInteger(maxEntries)
+      || maxEntries < 1 || maxEntries > 10000 || !Number.isInteger(timeoutMs)
+      || timeoutMs < 1 || timeoutMs > 30000) throw Error('InvalidRouterDependencies');
+  const cache = new Map(), pending = new Map(), cooldown = new Map();
+  const cacheKey = (binding, item) => binding.identity + '\n' + item.objectKey;
+  const put = (map, id, value) => { map.delete(id); map.set(id, value); while (map.size > maxEntries) map.delete(map.keys().next().value); };
+  function cached(binding, item) {
+    const id = cacheKey(binding, item), time = now();
+    if ((cooldown.get(id) || 0) > time) return original(item, 'BackupFailureCooldown');
+    const hit = cache.get(id);
+    if (hit && hit.until > time) return hit.route.useBackup ? Object.freeze({ ...hit.route, primaryUrl: item.primaryUrl }) : original(item, hit.route.reason);
+    cache.delete(id); cooldown.delete(id); return null;
+  }
+  function snapshot() { return bindingSnapshot(getBinding()); }
+  function fallback(input) { try { return legacyPublicFallback(input, getBinding()); } catch { return legacyPublicFallback(input, null); } }
+
+  async function resolveMany(inputs) {
+    if (!Array.isArray(inputs) || inputs.length > 100) throw Error('ResourceBatchLimitExceeded');
+    let binding;
+    try { binding = snapshot(); }
+    catch { return inputs.map(item => original({ primaryUrl: fallback(item) }, 'BackupBindingUnavailable')); }
+    const work = [], created = [];
+    const tasks = inputs.map(input => {
+      const item = identify(input, binding);
+      if (!item.accepted) return Promise.resolve(original(item, item.reason));
+      const known = cached(binding, item); if (known) return Promise.resolve(known);
+      const id = cacheKey(binding, item);
+      if (pending.has(id)) return pending.get(id).then(route => Object.freeze({ ...route, primaryUrl: item.primaryUrl,
+        url: route.useBackup ? route.url : item.primaryUrl }));
+      let done; const promise = new Promise(resolve => { done = resolve; });
+      pending.set(id, promise); work.push(item); created.push({ item, id, done, promise }); return promise;
+    });
+    if (work.length) {
+      // Do not pass secrets, arbitrary URLs or a caller-selected storage endpoint.
+      const controller = new AbortController(); let timer;
+      Promise.race([
+        Promise.resolve().then(() => resolveBatch({ ObjectKeys: work.map(item => item.objectKey), OsClient: binding.tenant }, { signal: controller.signal })),
+        new Promise((_, reject) => { timer = setTimeout(() => reject(Error('ResolverTimeout')), timeoutMs); })
+      ])
+        .then(response => {
+          let current; try { current = snapshot(); } catch { current = null; }
+          const data = response?.Code === 1 ? response.Data : null;
+          const valid = current?.identity === binding.identity && data?.Protocol === 'GenericPublicResourceRoutes/1'
+            && data.TargetConfigHash === binding.targetConfigHash && Array.isArray(data.Routes) && data.Routes.length <= 100;
+          const rows = new Map(), duplicates = new Set();
+          if (valid) for (const row of data.Routes) {
+            if (rows.has(row?.ObjectKey)) duplicates.add(row.ObjectKey);
+            rows.set(row?.ObjectKey, row);
+          }
+          for (const job of created) {
+            const time = now();
+            const route = valid && !duplicates.has(job.item.objectKey)
+              ? acceptedRoute(rows.get(job.item.objectKey), job.item, binding, time) : null;
+            const selected = (cooldown.get(job.id) || 0) > time ? original(job.item, 'BackupFailureCooldown')
+              : route || original(job.item, current?.identity !== binding.identity ? 'TenantOrBindingChanged' : 'VerifiedRouteUnavailable');
+            put(cache, job.id, { route: selected, until: selected.useBackup ? selected.expiresAt : time + 15000 });
+            job.done(selected);
+          }
+        })
+        .catch(() => {
+          for (const job of created) { const route = original(job.item, 'ResolverUnavailable');
+            put(cache, job.id, { route, until: now() + 15000 }); job.done(route); }
+        })
+        .finally(() => { clearTimeout(timer); controller.abort();
+          for (const job of created) if (pending.get(job.id) === job.promise) pending.delete(job.id); });
+    }
+    return Promise.all(tasks);
+  }
+  return Object.freeze({
+    resolveMany,
+    async resolve(input) { return (await resolveMany([input]))[0]; },
+    // Sync compatibility is cache-only. Callers must pre-resolve before assigning
+    // src/href if their FIRST request must avoid the original CDN/OSS endpoint.
+    peek(input) {
+      try { const binding = snapshot(), item = identify(input, binding);
+        return item.accepted ? cached(binding, item) || original(item, 'NotResolvedYet') : original(item, item.reason); }
+      catch { return original({ primaryUrl: fallback(input) }, 'BackupBindingUnavailable'); }
+    },
+    reportFailure(input) {
+      try { const binding = snapshot(), item = identify(input, binding);
+        if (!item.accepted) return original(item, item.reason);
+        const id = cacheKey(binding, item); cache.delete(id); put(cooldown, id, now() + 30000);
+        return original(item, 'BackupFailureCooldown'); }
+      catch { return original({ primaryUrl: fallback(input) }, 'BackupBindingUnavailable'); }
+    },
+    clear() { cache.clear(); cooldown.clear(); }
+  });
+}
+
+/**
+ * DiyCommon 与真实批量解析器的桥接。配置只从当前租户的原生 Binding 回读，
+ * 不将 SaaS 私桶名/凭据塞入前端。首次 src 赋值必须等待 resolve。
+ */
+function createExactAliasRouter({ getBinding, post, now }) {
+  const cache = new Map(), pending = new Map(), cooldown = new Map(); let queue = [], scheduled = false;
+  const put = (map, id, value) => { map.delete(id); map.set(id, value); while (map.size > 512) map.delete(map.keys().next().value); };
+  function pick(input) {
+    try {
+      const raw = getBinding(), b = bindingSnapshot(raw);
+      if (input?.private !== false || raw.aliasUrlRoutingProtocol !== 'PublicSourceUrlRoutes/1'
+          || typeof input.path !== 'string' || !input.path.startsWith('https://') || /[\\?#@\u0000-\u0020\u007f]/.test(input.path)) return null;
+      const origin = new URL(input.path).origin;
+      if (!raw.aliasCandidates.includes(origin)) return null;
+      // Only parse the exact key here. Candidate membership is not authorization:
+      // the server must revalidate this complete SourceUrl before returning NAS.
+      const item = identify(input, { ...b, sourceMappings: [{ origin, pathPrefix: '' }] });
+      return item.accepted ? { ...item, input, origin, binding: b, id: b.identity + '\nURL:' + input.path } : null;
+    } catch { return null; }
+  }
+  async function flush() {
+    scheduled = false; const jobs = queue; queue = [];
+    while (jobs.length) {
+      const origins = new Set(), batch = [];
+      const identity = jobs[0].item.binding.identity;
+      for (let index = 0; index < jobs.length && batch.length < 100;) {
+        const job = jobs[index];
+        if (job.item.binding.identity !== identity) { index++; continue; }
+        if (!origins.has(job.item.origin) && origins.size === 2) { index++; continue; }
+        origins.add(job.item.origin); batch.push(...jobs.splice(index, 1));
+      }
+      let response, timer;
+      try { response = await Promise.race([post({ PublicUrls: batch.map(x => x.item.input.path), OsClient: batch[0].item.binding.tenant }),
+        new Promise((_, reject) => { timer = setTimeout(() => reject(Error('AliasResolverTimeout')), 5000); })]); }
+      catch { response = null; }
+      finally { clearTimeout(timer); }
+      for (const job of batch) {
+        const item = job.item, current = pick(item.input), time = now(), data = response?.Code === 1 ? response.Data : null;
+        const rows = data?.Protocol === 'PublicSourceUrlRoutes/1' && data.TargetConfigHash === item.binding.targetConfigHash
+          && Array.isArray(data.Routes) && data.Routes.length <= 100
+          ? data.Routes.filter(x => x && typeof x === 'object' && !Array.isArray(x) && x.SourceUrl === item.input.path) : [];
+        const row = rows.length === 1 ? rows[0] : null;
+        const accepted = current?.id === item.id && row?.SourceOrigin === item.origin && HASH.test(row.SourceRoutingFingerprint)
+          && row.ExpiresAtUtc * 1000 <= time + 60000 ? acceptedRoute(row, item, item.binding, time) : null;
+        const route = (cooldown.get(item.id) || 0) > time ? original(item, 'BackupFailureCooldown')
+          : accepted || original(item, 'VerifiedAliasRouteUnavailable');
+        put(cache, item.id, { route, until: route.useBackup ? route.expiresAt : time + 15000 });
+        pending.delete(item.id); job.done(route);
+      }
+    }
+  }
+  return {
+    eligible: input => !!pick(input),
+    async resolve(input) {
+      const item = pick(input); if (!item) return null;
+      if ((cooldown.get(item.id) || 0) > now()) return original(item, 'BackupFailureCooldown');
+      const old = cache.get(item.id); if (old && old.until > now()) return old.route;
+      if (pending.has(item.id)) return pending.get(item.id);
+      let done; const result = new Promise(resolve => { done = resolve; }); pending.set(item.id, result);
+      queue.push({ item, done }); if (!scheduled) { scheduled = true; queueMicrotask(flush); } return result;
+    },
+    reportFailure(input) { const item = pick(input); if (!item) return null;
+      cache.delete(item.id); put(cooldown, item.id, now() + 30000); return original(item, 'BackupFailureCooldown'); },
+    clear() { cache.clear(); cooldown.clear(); }
+  };
+}
+
+function createPublicResourceClient({ getContext, post, now = Date.now, fetchHead = globalThis.fetch }) {
+  let active = '', binding = null, bootstrap = null, expires = 0, generation = 0;
+  let queue = [], scheduled = false;
+  const context = () => {
+    const value = getContext() || {};
+    return { tenant: value.tenant, primaryBase: value.primaryBase?.replace(/\/+$/, ''),
+      backupOrigin: value.backupOrigin?.replace(/\/+$/, '') };
+  };
+  const signature = value => JSON.stringify(value);
+  const router = createPublicResourceRouter({ getBinding: () => binding || context(), resolveBatch: data => post(data), now });
+  const aliases = createExactAliasRouter({ getBinding: () => binding, post, now });
+  const fallback = input => Object.freeze({ useBackup: false,
+    url: legacyPublicFallback(input, context()), primaryUrl: legacyPublicFallback(input, context()), reason: 'BindingUnavailable' });
+  async function ensureBinding() {
+    const current = context(), id = signature(current);
+    if (active !== id) { active = id; binding = null; bootstrap = null; expires = 0; generation++; router.clear(); aliases.clear(); }
+    if (binding && expires > now()) return true;
+    if (!binding && expires > now()) return false;
+    if (bootstrap) return bootstrap;
+    if (!current.backupOrigin || !IDENTIFIER.test(current.tenant || '')) return false;
+    const revision = generation;
+    const run = (async () => {
+      let timer;
+      try {
+        const response = await Promise.race([post({ ObjectKeys: [], OsClient: current.tenant }),
+          new Promise((_, reject) => { timer = setTimeout(() => reject(Error('BindingTimeout')), 5000); })]);
+        const data = response?.Data, source = data?.Binding;
+        if (generation !== revision || signature(context()) !== id || response?.Code !== 1 || data?.Protocol !== 'GenericPublicResourceRoutes/1' || !source
+            || source.PrimaryBase?.replace(/\/+$/, '') !== current.primaryBase
+            || source.BackupOrigin?.replace(/\/+$/, '') !== current.backupOrigin
+            || source.TargetConfigHash !== data.TargetConfigHash) return false;
+        const candidate = { tenant: current.tenant, storageOwnerTenant: source.StorageOwnerTenant,
+          primaryBase: source.PrimaryBase, backupOrigin: source.BackupOrigin, publicBucket: source.PublicBucket,
+          privateBucket: '', targetConfigHash: source.TargetConfigHash,
+          aliasUrlRoutingProtocol: source.AliasUrlRoutingProtocol,
+          aliasCandidates: source.AliasUrlRoutingProtocol === 'PublicSourceUrlRoutes/1'
+            ? (source.AliasCandidates || []).map(row => plainBase(row.Origin, true)) : [],
+          sourceMappings: (source.SourceMappings || []).map(row => ({ origin: row.Origin, pathPrefix: row.PathPrefix || '' })) };
+        if (candidate.aliasCandidates.length > 50 || new Set(candidate.aliasCandidates).size !== candidate.aliasCandidates.length) return false;
+        bindingSnapshot(candidate);
+        binding = candidate; expires = now() + 60000; return true;
+      } catch { return false; }
+      finally { clearTimeout(timer); }
+    })();
+    bootstrap = run;
+    try { const ready = await run;
+      if (!ready && revision === generation && signature(context()) === id) { binding = null; expires = now() + 15000; }
+      return ready;
+    } finally { if (bootstrap === run) bootstrap = null; }
+  }
+  async function flush() {
+    scheduled = false; const jobs = queue; queue = [];
+    for (let start = 0; start < jobs.length; start += 100) {
+      const slice = jobs.slice(start, start + 100);
+      try { const routes = await router.resolveMany(slice.map(job => job.input));
+        slice.forEach((job, index) => job.done(signature(context()) === job.context ? routes[index] : fallback(job.input))); }
+      catch { slice.forEach(job => job.done(fallback(job.input))); }
+    }
+  }
+  async function resolve(input) {
+    // 只有明确公有输入才触发任何匿名解析；旧 Limit 缺失由调用者保持原兼容分支。
+    if (!input || input.private !== false) return Object.freeze({ useBackup: false, url: '', primaryUrl: '', reason: 'ExplicitPublicRequired' });
+    const id = signature(context());
+    if (!await ensureBinding() || id !== signature(context())) return fallback(input);
+    if (aliases.eligible(input)) {
+      const revision = generation, route = await aliases.resolve(input);
+      return revision === generation && id === signature(context()) ? route || fallback(input) : fallback(input);
+    }
+    return await new Promise(done => { queue.push({ input, done, context: id });
+      if (!scheduled) { scheduled = true; queueMicrotask(flush); } });
+  }
+  const reportFailure = input => input?.private === false ? aliases.reportFailure(input) || router.reportFailure(input) : fallback({ private: true });
+  return Object.freeze({ resolve,
+    resolveMany(inputs) { return Promise.all(inputs.map(resolve)); },
+    reportFailure,
+    async resolveForNavigation(input) {
+      const id = signature(context()), route = await resolve(input);
+      if (id !== signature(context())) return fallback(input);
+      if (!route.useBackup) return route;
+      const revision = generation;
+      if (!(route.expiresAt > now())) return fallback(input);
+      // 新窗口无法监听跨域导航失败。打开前只做一次有界 HEAD，失败回原地址，不循环重试。
+      const controller = new AbortController(), timer = setTimeout(() => controller.abort(), 3000);
+      try {
+        const response = await fetchHead(route.url, { method: 'HEAD', credentials: 'omit', redirect: 'error', signal: controller.signal });
+        if (id !== signature(context()) || revision !== generation || !(route.expiresAt > now())) return fallback(input);
+        return response.ok ? route : reportFailure(input);
+      } catch { return reportFailure(input); }
+      finally { clearTimeout(timer); }
+    },
+    clear() { generation++; binding = null; bootstrap = null; expires = 0; router.clear(); aliases.clear(); }
+  });
+}
+
+// 历史 Limit 缺失不是公开声明，不能据此新增匿名 NAS 访问。
+function isExplicitPublicResource(metadata, configuredLimit) {
+  return metadata && typeof metadata === 'object' && Object.hasOwn(metadata, 'Limit')
+    ? metadata.Limit === false : configuredLimit === false;
+}
+
+/** 表单实例、租户、记录、字段及文件身份共同限定异步地址赋值。 */
+function createPublicResourceAssignmentGuard({ getContext, contains }) {
+  const pending = new Map(); let disposed = false;
+  const current = ticket => {
+    if (disposed || pending.get(ticket.key) !== ticket) return false;
+    const context = getContext();
+    return Object.keys(ticket.context).every(name => context[name] === ticket.context[name])
+      && contains(ticket.path, ticket.fileId);
+  };
+  return Object.freeze({
+    begin(key, path, fileId = null) {
+      const ticket = { key, path, fileId, context: { ...getContext() }, route: null, fallbackUsed: false };
+      pending.set(key, ticket); return ticket;
+    },
+    current,
+    get(key) { return pending.get(key); },
+    tickets() { return [...pending.values()]; },
+    invalidate(key) { pending.delete(key); },
+    clear() { pending.clear(); },
+    dispose() { disposed = true; pending.clear(); }
+  });
+}
+
+return createPublicResourceClient;
+})();
+// END GENERATED PUBLIC RESOURCE ROUTER
+
 export function createMicroiV8(options = {}) {
   // 运行时配置可通过 createMicroiV8(options) 或 client.configure(next) 覆盖。
   let config = {
     apiBase: '',
     webBase: '',
     fileServer: '',
+    fileServerBak: '',
     osClient: '',
     token: '',
     clientType: getUni() ? 'Mobile' : 'PC',
@@ -606,6 +988,9 @@ export function createMicroiV8(options = {}) {
 
   // 更新配置后立即刷新并发队列，保证 maxConcurrent 热更新生效。
   function configure(next = {}) {
+    if (['apiBase','osClient','fileServer','fileServerBak'].some(key => Object.prototype.hasOwnProperty.call(next,key) && next[key] !== config[key])) {
+      sdkPublicResourceEpoch++; sdkPublicResourceClient?.clear();
+    }
     config = { ...config, ...next };
     if (Object.prototype.hasOwnProperty.call(next, 'maxConcurrent')) {
       runQueued = createQueue(config.maxConcurrent);
@@ -961,6 +1346,63 @@ export function createMicroiV8(options = {}) {
   }
 
   // 资源地址统一过滤占位图，并兼容 HDFS 私有文件、FileServer 和绝对地址。
+  // Public media selection is asynchronous. assetUrl remains a synchronous legacy API.
+  let sdkPublicResourceClient = null;
+  let sdkPublicResourceEpoch = 0;
+  function sdkPublicMetadata(value, path, depth = 0) {
+    if (depth > 8 || value == null) return null;
+    if (typeof value === 'string' && /^[\[{]/.test(value.trim())) {
+      try { return sdkPublicMetadata(JSON.parse(value), path, depth + 1); } catch { return null; }
+    }
+    if (Array.isArray(value)) {
+      for (const entry of value) { const selected = sdkPublicMetadata(entry, path, depth + 1); if (selected) return selected; }
+      return null;
+    }
+    return typeof value === 'object' && extractUploadPath(value) === path ? value : null;
+  }
+  function sdkPublicInputAllowed(value, options = {}) {
+    const path = extractUploadPath(value), meta = sdkPublicMetadata(value, path);
+    if (options.private === true || (meta && (
+      (Object.prototype.hasOwnProperty.call(meta, 'Limit') && meta.Limit !== false)
+      || meta.Private === true || meta.IsPrivate === true || meta.Public === false))) return false;
+    return options.private === false || meta?.Limit === false || meta?.Public === true;
+  }
+  function sdkPublicContext() {
+    return { tenant: config.osClient, primaryBase: config.fileServer || '',
+      backupOrigin: config.fileServerBak || client.SysConfig?.FileServerBak || '' };
+  }
+  function sdkPublicIdentity() {
+    return JSON.stringify([sdkPublicResourceEpoch, config.apiBase, sdkPublicContext()]);
+  }
+  function getSdkPublicResourceClient() {
+    if (!sdkPublicResourceClient) sdkPublicResourceClient = createSdkPublicResourceClient({
+      getContext: sdkPublicContext,
+      post: data => apiEngineRun('mci-file-resource-public-url', data, { checkCode: false, silentError: true, timeout: 5000 })
+    });
+    return sdkPublicResourceClient;
+  }
+  async function resolvePublicResource(value, options = {}) {
+    const path = extractUploadPath(value);
+    if (!path || isBlockedAsset(path) || !sdkPublicInputAllowed(value, options))
+      return { useBackup: false, url: '', primaryUrl: '', reason: 'ExplicitPublicRequired' };
+    // Local files and API-owned protected/runtime endpoints keep their existing transport.
+    if (/^(?:data:|blob:|file:|\.?\/static\/)/i.test(path) || /^\/?(?:file\/|micro-app\/v3(?:\/|$))/i.test(path))
+      return { useBackup: false, url: assetUrl(value), primaryUrl: assetUrl(value), reason: 'LocalOrApiResource' };
+    const identity = sdkPublicIdentity(), publicClient = getSdkPublicResourceClient();
+    const route = options.navigation === true
+      ? await publicClient.resolveForNavigation({ path, private: false })
+      : await publicClient.resolve({ path, private: false });
+    // The portable SDK also binds the API base, which is not a public storage binding field.
+    return identity === sdkPublicIdentity() ? route
+      : { useBackup: false, url: '', primaryUrl: '', reason: 'ClientContextChanged' };
+  }
+  function reportPublicResourceFailure(value, options = {}) {
+    if (!sdkPublicInputAllowed(value, options)) return { useBackup: false, url: '', primaryUrl: '', reason: 'ExplicitPublicRequired' };
+    const path = extractUploadPath(value);
+    return sdkPublicResourceClient?.reportFailure({ path, private: false })
+      || { useBackup: false, url: assetUrl(value), primaryUrl: assetUrl(value), reason: 'PrimaryFallback' };
+  }
+
   function assetUrl(value) {
     const picked = extractUploadPath(value);
     if (!picked || isBlockedAsset(picked)) return '';
@@ -999,6 +1441,7 @@ export function createMicroiV8(options = {}) {
   async function resolveFileUrl(filePathName, options = {}) {
     const path = extractUploadPath(filePathName);
     if (!path || isBlockedAsset(path)) return '';
+    if (sdkPublicInputAllowed(filePathName, options)) return (await resolvePublicResource(filePathName, options)).url;
     if (/^(https?:|blob:|data:|file:)/i.test(path)) return assetUrl(path);
     // 文件实际私有标记和私有字段上下文优先，禁止因字段曾改为公有而错误降级 CDN。
     const privateAccess = options.private === true || hasPrivateUploadFlag(filePathName);
@@ -1534,6 +1977,8 @@ export function createMicroiV8(options = {}) {
     setCurrentUser: setUser,
     getCurrentUser: getUser,
     assetUrl,
+    resolvePublicResource,
+    reportPublicResourceFailure,
     sanitizeAssetUrl: assetUrl,
     resolveAssetUrl: assetUrl,
     resolveAvatarUrl: resolveFileUrl,