@heybox/hb-sdk 0.9.0-alpha.1 → 0.9.0-alpha.10

package/dist/cli-chunks/{remote-9-tyxq6l.cjs → remote-2oOP8M5C.cjs}

@@ -1,18 +1,18 @@
 'use strict';
 
-var runtimePermissionEnv = require('./runtime-permission-env-B-GwDDT7.cjs');
-var context = require('./context-D_L2-Hla.cjs');
+var runtimePermissionEnv = require('./runtime-permission-env-GH_vWEVx.cjs');
+var context = require('./context--dJRx4eH.cjs');
 var promises = require('node:readline/promises');
-var index = require('./index-d1cUUoR9.cjs');
-var session = require('./session-mMVA3395.cjs');
+var index = require('./index-CYxcLlON.cjs');
+var session = require('./session-DrhTp-x-.cjs');
 var childProcess = require('node:child_process');
 var fs = require('node:fs');
 var fs$1 = require('node:fs/promises');
 var path = require('node:path');
 var node_crypto = require('node:crypto');
 require('node:zlib');
-var runtimeGate = require('./runtime-gate-BfAGMrE2.cjs');
-require('./version-hsUgRL0I.cjs');
+var runtimeGate = require('./runtime-gate-CNBf6Zkh.cjs');
+require('./version-DA6v9R62.cjs');
 require('node:async_hooks');
 require('sharp');
 require('node:module');
@@ -68,6 +68,14 @@ async function postHeyboxApi(pathWithQuery, body, session$1, runtime) {
 
 const CREATE_USER_MINIPROGRAM_UPLOAD_SESSION_API_PATH = '/mall/developer/user_miniprogram/version/upload_session/create';
 const RECORD_USER_MINIPROGRAM_UPLOAD_RESULT_API_PATH = '/mall/developer/user_miniprogram/version/upload_session/record';
+const COMPANION_FINALIZATION_TIMEOUT_MS = 30 * 60_000;
+async function authorizeCompanionUpload(options, runtime = {}) {
+    const result = await postUserMiniprogramVersionForm('/mall/developer/user_miniprogram/version/upload_session/companion_authorization', options, { version: options.version, session_id: options.sessionId, relative_paths: options.relativePaths.join(','), artifact_protocol_version: '2' }, runtime);
+    if (!result.bucket || !result.region || !Array.isArray(result.keys) || !result.tmp_secret_id || !result.tmp_secret_key || !result.session_token || !(result.expired_time > result.start_time)) {
+        throw new Error('Companion 上传凭证响应不完整');
+    }
+    return result;
+}
 async function precheckUserMiniprogramVersion(options, runtime = {}) {
     return postUserMiniprogramVersionForm(runtimePermissionEnv.PRECHECK_USER_MINIPROGRAM_VERSION_API_PATH, options, {
         // 构建前轻预检不携带独立资料；权威准入读取构建 Manifest。
@@ -78,11 +86,12 @@ async function precheckUserMiniprogramVersion(options, runtime = {}) {
     }, runtime);
 }
 async function submitUserMiniprogramAudit(options, runtime = {}) {
-    return postUserMiniprogramVersionForm(runtimePermissionEnv.SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, options, { session_id: options.sessionId, preflight_token: options.preflightToken }, runtime);
+    return postUserMiniprogramVersionForm(runtimePermissionEnv.SUBMIT_USER_MINIPROGRAM_AUDIT_API_PATH, options, { session_id: options.sessionId, preflight_token: options.preflightToken, artifact_protocol_version: '2' }, runtime);
 }
 async function createUserMiniprogramUploadSession(options, runtime = {}) {
     return postUserMiniprogramVersionForm(CREATE_USER_MINIPROGRAM_UPLOAD_SESSION_API_PATH, options, {
         version: options.version,
+        artifact_protocol_version: '2',
         artifact_signature: options.artifactSignature,
         files: JSON.stringify(options.files),
         manifest: JSON.stringify(options.manifest),
@@ -91,11 +100,27 @@ async function createUserMiniprogramUploadSession(options, runtime = {}) {
     }, runtime);
 }
 async function recordUserMiniprogramUploadResult(options, runtime = {}) {
-    await postUserMiniprogramVersionForm(RECORD_USER_MINIPROGRAM_UPLOAD_RESULT_API_PATH, options, {
+    const fields = {
         version: options.version,
+        artifact_protocol_version: '2',
         session_id: options.sessionId,
         files: JSON.stringify(options.files),
-    }, runtime);
+    };
+    const deadline = Date.now() + COMPANION_FINALIZATION_TIMEOUT_MS;
+    for (;;) {
+        const result = await postUserMiniprogramVersionForm(RECORD_USER_MINIPROGRAM_UPLOAD_RESULT_API_PATH, options, fields, runtime);
+        if (result.artifact_protocol_version !== 2 || !Array.isArray(result.companion_files)) {
+            throw new Error('服务端未返回产物协议 v2 Finalize 状态');
+        }
+        const failed = result.companion_files.find((file) => file.state === 'failed');
+        if (failed)
+            throw new Error(failed.error || `Companion 归档验证失败：${failed.relative_path}`);
+        if (result.complete)
+            return;
+        if (Date.now() >= deadline)
+            throw new Error('Companion 归档验证超时，请稍后重试');
+        await new Promise((resolve) => setTimeout(resolve, Math.max(250, Math.min(result.retry_after_ms || 1000, 5000))));
+    }
 }
 async function postUserMiniprogramVersionForm(path, options, fields, runtime) {
     const fetchImpl = runtime.fetchImpl ?? fetch;
@@ -134,17 +159,21 @@ async function runUpload(options, runtime = {}) {
         createCosClient = ({ uploadToken }) => createDefaultCosClient(uploadToken, COS);
     }
     const orderedFiles = runtimePermissionEnv.prepareMiniappArtifactFiles(options.files);
-    const batches = chunkUploadFiles(orderedFiles, runtimePermissionEnv.MINIAPP_UPLOAD_BATCH_SIZE);
+    const batches = [false, true].flatMap(companion => chunkUploadFiles(orderedFiles.filter(file => file.relativePath.startsWith('companions/') === companion), runtimePermissionEnv.MINIAPP_UPLOAD_BATCH_SIZE));
     await logger.task(`正在上传 ${orderedFiles.length} 个文件`, async (taskContext) => {
         logger.debug(`上传并发数: ${concurrency}`);
         logger.debug(`上传批次数: ${batches.length}`);
         let completed = 0;
         for (let batchIndex = 0; batchIndex < batches.length; batchIndex += 1) {
             const batch = batches[batchIndex];
+            const companion = batch[0].relativePath.startsWith('companions/');
+            const grant = companion ? await (runtime.authorizeCompanionUpload ?? authorizeCompanionUpload)({
+                session: options.session, miniProgramId: options.miniProgramId, version: options.version, sessionId: options.uploadSessionId, relativePaths: batch.map(file => file.relativePath),
+            }, { baseUrl: runtime.baseUrl, fetchImpl }) : undefined;
             logger.debug(`正在处理上传批次 ${batchIndex + 1}/${batches.length}，文件数: ${batch.length}`);
             logger.debug('正在获取 CDN 上传信息');
             const fileInfos = createUploadFileInfos(batch);
-            const uploadInfo = await getCDNUploadInfo$1({
+            const uploadInfo = grant ?? await getCDNUploadInfo$1({
                 session: options.session,
                 scope: runtimePermissionEnv.MINIAPP_UPLOAD_SCOPE,
                 fileInfos,
@@ -157,7 +186,10 @@ async function runUpload(options, runtime = {}) {
             logger.debug('正在获取本批 CDN 上传凭证');
             let uploadToken;
             try {
-                uploadToken = await getCDNUploadToken$1({
+                uploadToken = grant ? {
+                    credentials: { tmpSecretId: grant.tmp_secret_id, tmpSecretKey: grant.tmp_secret_key, sessionToken: grant.session_token },
+                    startTime: grant.start_time, expiredTime: grant.expired_time,
+                } : await getCDNUploadToken$1({
                     session: options.session,
                     bucket: uploadInfo.bucket,
                     keys: indexedFiles.map(item => item.key),
@@ -186,6 +218,11 @@ async function runUpload(options, runtime = {}) {
                             Body: createReadStream(uploadTask.file.absolutePath),
                             ContentLength: uploadTask.file.size,
                             ContentType: uploadTask.file.mimeType,
+                            ...(companion ? { Headers: { 'x-cos-forbid-overwrite': 'true' } } : {}),
+                        }).catch(error => {
+                            if (companion && isExistingCompanionObject(error))
+                                return;
+                            throw error;
                         });
                         successfulKeys.push(uploadTask.key);
                         completed += 1;
@@ -203,7 +240,8 @@ async function runUpload(options, runtime = {}) {
             await Promise.all(workers);
             if (successfulKeys.length > 0) {
                 logger.debug('正在确认 CDN 上传结果');
-                await postCDNUploadCallback$1({ session: options.session, keys: successfulKeys, isFinished: true }, { baseUrl: runtime.baseUrl, fetchImpl });
+                if (!companion)
+                    await postCDNUploadCallback$1({ session: options.session, keys: successfulKeys, isFinished: true }, { baseUrl: runtime.baseUrl, fetchImpl });
                 await recordUserMiniprogramUploadResult$1({
                     session: options.session,
                     miniProgramId: options.miniProgramId,
@@ -227,6 +265,12 @@ function chunkUploadFiles(files, batchSize) {
     }
     return batches;
 }
+function isExistingCompanionObject(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const value = error;
+    return Number(value.statusCode) === 409 && value.code === 'ObjectAlreadyExists';
+}
 function createUploadFileInfos(files) {
     return files.map((file) => ({
         name: file.relativePath.split('/').pop() ?? file.relativePath,
@@ -264,7 +308,7 @@ function createDefaultCosClient(uploadToken, COS) {
             return new Promise((resolve, reject) => {
                 cos.putObject(params, (err, result) => {
                     if (err) {
-                        reject(err instanceof Error ? err : new Error(readErrorMessage(err)));
+                        reject(err);
                         return;
                     }
                     resolve(result);
@@ -274,7 +318,7 @@ function createDefaultCosClient(uploadToken, COS) {
     };
 }
 async function loadCosConstructor() {
-    const cosModule = await Promise.resolve().then(function () { return require('./index-CakUTosC.cjs'); }).then(function (n) { return n.index; });
+    const cosModule = await Promise.resolve().then(function () { return require('./index-CnOLdO_-.cjs'); }).then(function (n) { return n.index; });
     return cosModule.default;
 }
 function formatSize(bytes) {
@@ -519,6 +563,9 @@ const MIME_BY_EXT = {
     '.woff': 'font/woff',
     '.woff2': 'font/woff2',
 };
+function formatDeployBytes(bytes) {
+    return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
+}
 async function runDeployCommand(options, runtime = {}) {
     const logger = runtime.logger ?? index.createCliLogger();
     const cwd = runtime.cwd ?? process.cwd();
@@ -691,24 +738,43 @@ async function runDeployCommand(options, runtime = {}) {
                 }
                 if (!result.preflight_token)
                     throw new Error('服务端未返回 preflight_token，请先升级服务端');
+                if (result.artifact_protocol_version !== 2) {
+                    throw new Error('创建上传会话失败：服务端不支持产物协议 v2，请升级服务端后重试');
+                }
                 if (result.file_receipt_version !== 1) {
                     throw new Error('创建上传会话失败：服务端不支持文件完整性 receipt v1，请升级服务端后重试');
                 }
-                const resolved = runtimePermissionEnv.resolveMiniappUploadSessionFiles(artifactReceipt.files, Array.isArray(result.files) ? result.files : [], Array.isArray(result.uploaded_keys) ? result.uploaded_keys : []);
+                if (!Array.isArray(result.files) || !Array.isArray(result.uploaded_keys) || !Array.isArray(result.reused_companion_files)) {
+                    throw new Error('创建上传会话失败：服务端返回的产物协议 v2 文件清单不完整');
+                }
+                const resolved = runtimePermissionEnv.resolveMiniappUploadSessionFiles(artifactReceipt.files, result.files, result.uploaded_keys, result.reused_companion_files);
                 return {
                     preflightToken: result.preflight_token,
                     sessionId: result.session_id.trim(),
                     files: resolved.files,
                     missingFiles: resolved.missingFiles,
+                    reusedCompanionFiles: resolved.reusedCompanionFiles,
                 };
             }, { successText: '上传会话已就绪' });
             uploadSessionId = createdUploadSession.sessionId;
             preflightToken = createdUploadSession.preflightToken;
             const uploadedCount = createdUploadSession.files.length - createdUploadSession.missingFiles.length;
             if (uploadedCount > 0) {
-                logger.debug(`复用已上传文件: ${uploadedCount}/${createdUploadSession.files.length}`);
+                logger.debug(`会话内已上传文件: ${uploadedCount}/${createdUploadSession.files.length}`);
             }
+            const reusedBytes = createdUploadSession.reusedCompanionFiles.reduce((sum, file) => sum + file.size, 0);
+            const uploadBytes = createdUploadSession.missingFiles.reduce((sum, { file }) => sum + file.size, 0);
+            logger.info(`Companion Blob 复用: ${createdUploadSession.reusedCompanionFiles.length} 个，免上传 ${formatDeployBytes(reusedBytes)}；实际待上传 ${formatDeployBytes(uploadBytes)}`);
             try {
+                const missingKeys = new Set(createdUploadSession.missingFiles.map(item => item.key));
+                const uploadedCompanions = createdUploadSession.files.filter(item => item.file.relativePath.startsWith('companions/') && !missingKeys.has(item.key));
+                for (let index = 0; index < uploadedCompanions.length; index += runtimePermissionEnv.MINIAPP_UPLOAD_BATCH_SIZE) {
+                    await (runtime.recordUserMiniprogramUploadResult ?? recordUserMiniprogramUploadResult)({
+                        session: session$1, miniProgramId, version, sessionId: uploadSessionId,
+                        files: uploadedCompanions.slice(index, index + runtimePermissionEnv.MINIAPP_UPLOAD_BATCH_SIZE)
+                            .map(({ file }) => ({ path: file.relativePath, size: file.size, sha256: file.sha256 })),
+                    }, { baseUrl: apiBaseUrl, fetchImpl: runtime.fetchImpl });
+                }
                 if (createdUploadSession.missingFiles.length > 0) {
                     await assertDeployUploadFilesStillMatchSignature({
                         computeMiniappArtifactReceipt: runtime.computeMiniappArtifactReceipt ?? computeMiniappArtifactReceipt,

package/dist/cli-chunks/{runtime-gate-BfAGMrE2.cjs → runtime-gate-CNBf6Zkh.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var runtimePermissionEnv = require('./runtime-permission-env-B-GwDDT7.cjs');
+var runtimePermissionEnv = require('./runtime-permission-env-GH_vWEVx.cjs');
 
 // Shorthands
 /**
@@ -27,6 +27,13 @@ function parse(html, options) {
 const RUNTIME_GATE_MARKER = 'data-heybox-runtime-gate';
 const RUNTIME_GATE_STYLE_MARKER = 'data-heybox-runtime-gate-style';
 const RUNTIME_GATE_BOOTSTRAP_MARKER = 'data-heybox-runtime-gate-bootstrap';
+/**
+ * 检查 HTML 是否包含 Runtime Gate 的三个结构标记。
+ *
+ * @param html - 待检查的完整 HTML 文本，使用 HTML parser 解析。
+ * @returns Gate、隐藏样式及 bootstrap 标记均出现时返回 `true`，否则返回 `false`。
+ * @remarks 只识别标记，不验证脚本内容、标记所在节点或宿主握手；不能据此判断页面安全或实际可运行。
+ */
 function hasMiniappRuntimeGate(html) {
     const document = parse(html);
     let hasGate = false;

package/dist/cli-chunks/{runtime-permission-env-B-GwDDT7.cjs → runtime-permission-env-GH_vWEVx.cjs}

@@ -2,11 +2,18 @@
 
 var fs = require('node:fs');
 var path = require('node:path');
-var version = require('./version-hsUgRL0I.cjs');
+var version = require('./version-DA6v9R62.cjs');
 require('node:crypto');
 var node_async_hooks = require('node:async_hooks');
 
-/** 校验配置或产物中的类别，省略与显式非法值严格区分。 */
+/**
+ * 校验项目配置或产物中的小程序类别。
+ *
+ * @param value - 待校验值，只接受 `tool`、`game`、`other` 或 `undefined`；不做 trim 或大小写转换。
+ * @param sourceLabel - 错误消息中的字段来源，默认 `package.json#heybox.category`。
+ * @returns 合法类别原值；输入 `undefined` 时返回 `undefined`，由发布流程另行检查是否必填。
+ * @throws `Error` 输入为其他值（包括 null 或空字符串）时抛出带字段来源的错误。
+ */
 function parseMiniappCategory(value, sourceLabel = 'package.json#heybox.category') {
     if (value === undefined)
         return undefined;
@@ -2802,7 +2809,14 @@ var semverExports = requireSemver();
 
 const BASIC_INFO_MAX_BYTES = 10 * 1024 * 1024;
 const BASIC_INFO_MAX_PIXELS = 40_000_000;
-/** 按 NFKC 和 Unicode 空白规范化名称，并校验 1–40 个字符及禁用字符。 */
+/**
+ * 规范化并校验小程序展示名称。
+ *
+ * @param raw - 原始名称，必须是字符串。
+ * @returns NFKC 规范化、去除首尾 Unicode White_Space 后的名称；不折叠规范化后的内部空白。
+ * @throws `Error` 输入不是字符串，或规范化后不是 1–40 个 Unicode code point、不含文字或数字，或包含控制字符、
+ * 格式字符、行/段分隔符以及 HTML 特殊字符 `<`、`>`、`&`、双引号或单引号时抛出。
+ */
 function normalizeBasicInfoName(raw) {
     if (typeof raw !== 'string')
         throw new Error('heybox.name 必须是字符串');
@@ -2823,7 +2837,17 @@ function validateBasicInfoPath(raw) {
         throw new Error('资料图片仅支持 JPEG、PNG、GIF、WebP');
     return raw;
 }
-/** 解析项目或构建资料；仅早于 0.8.2 且三项全部缺失时返回 undefined。 */
+/**
+ * 校验项目声明或 Manifest 中的小程序展示资料。
+ *
+ * @param value - `package.json#heybox` 或 Manifest 对象，读取 `name`、`icon`、`coverImages`。
+ * @param sdkVersion - 产物 SDK 版本，默认 `0.8.2`；用于判断历史产物是否允许缺失全部资料。
+ * @returns 名称规范化后的新资料对象；仅版本早于 `0.8.2` 且三项均无自有属性时返回 `undefined`。
+ * @throws `Error` SDK 版本非法、资料字段不齐、名称/图片路径非法，或封面不是 1–5 个互不重复的路径时抛出。
+ * @remarks
+ * 图片路径必须使用 `/` 分隔的非空相对路径，扩展名为 JPEG、PNG、GIF 或 WebP；拒绝 URL、点段、
+ * 控制字符和构建/缓存等保留目录。此函数只校验声明，不读取文件，也不验证图片字节、尺寸或存在性。
+ */
 function parseMiniappBasicInfo(value, sdkVersion = '0.8.2') {
     sdkVersion = sdkVersion.trim();
     if (!semverExports.valid(sdkVersion) || sdkVersion.startsWith('v') || sdkVersion.includes('+'))
@@ -3576,6 +3600,16 @@ function parseMiniappManifestJson(raw, sourceLabel = 'manifest.json') {
         hadBom,
     };
 }
+/**
+ * 校验发布 Manifest 并返回规范化后的已知字段。
+ *
+ * @param manifest - 从构建产物读取的 Manifest，图片和 Companion 路径相对构建目录。
+ * @returns 新对象：规范化版本、名称、平台与游戏绑定，省略空绑定及未声明的可选字段；不保留未知字段。
+ * @throws `Error` 版本、平台、资料、权限、窗口、游戏绑定或生成的 Companion 声明非法，以及类别缺失时抛出。
+ * @remarks
+ * 不修改输入对象，不执行文件 I/O；不会验证图片/归档是否存在、内容摘要是否匹配，也不查询远端发布资格。
+ * 成功仅表示 Manifest 字段通过校验，不能替代文件检查与服务端发布预检。
+ */
 function validateMiniappManifestForDeploy(manifest) {
     const version = validateMiniappManifestVersion(manifest.version, 'manifest.version');
     const sdkVersion = validateSdkVersion(manifest.sdkVersion, 'manifest.sdkVersion');
@@ -3608,6 +3642,7 @@ function validateGeneratedCompanions(value) {
         return undefined;
     if (!isRecord$2(value) || Object.keys(value).length === 0)
         throw new Error('manifest.companions 必须是非空对象');
+    let descriptorCount = 0;
     for (const [alias, definition] of Object.entries(value)) {
         if (!/^[a-z][a-z0-9-]{0,31}$/.test(alias) ||
             !isRecord$2(definition) ||
@@ -3621,6 +3656,9 @@ function validateGeneratedCompanions(value) {
             Object.keys(definition.targets).length === 0)
             throw new Error(`manifest.companions.${alias} 不合法`);
         for (const [target, artifact] of Object.entries(definition.targets)) {
+            descriptorCount += 1;
+            if (descriptorCount > 64)
+                throw new Error('manifest.companions 最多允许 64 个 target 描述符');
             if (isRecord$2(artifact) && artifact.elevation === 'required') {
                 throw new Error(`manifest.companions.${alias}.targets.${target}.elevation V1 仅支持 none，暂不支持管理员权限启动`);
             }
@@ -12087,30 +12125,13 @@ const textEncoder = new TextEncoder();
 /**
  * 将扫描到的相对路径转换为统一的 `/` 分隔形式。
  *
- * @param relativePath - 待整理的构建产物路径。TypeScript 入口声明为字符串；JavaScript 运行时会
- * 先计算 `relativePath || ''`，再通过 `String(...)` 强制转换。
- * @returns 仅统一分隔符形态的新字符串：所有 `\\` 转为 `/`，所有前导 `/` 被删除，其余连续
- * `/` 合并为一个。空字符串以及运行时传入的 `undefined`、`null`、`false`、`0`、`NaN` 等
- * falsy 值返回 `''`；truthy 非字符串按标准 `String(value)` 结果继续整理。
+ * @param relativePath - 待整理的构建产物路径。
+ * @returns 反斜杠转为 `/`、删除前导 `/`、合并连续 `/` 后的新字符串；空输入返回空字符串。
  *
  * @remarks
- * 这是面向 build/deploy 文件扫描结果的**格式 helper**，不是路径安全校验或 canonical path
- * parser。它不会 trim、URL decode、Unicode normalize、解析盘符，也不会拒绝或消解 `.` / `..`
- * segment、控制字符、Windows drive prefix 或尾随 `/`。例如 `/etc/passwd` 会变成
- * `etc/passwd`，`C:\\temp\\app.js` 会变成 `C:/temp/app.js`，`assets/../secret/` 仍保留点段
- * 和尾随 slash；调用方不能根据返回值推断原输入是安全相对路径。
- *
- * SDK 的 build/deploy 流程会把扫描路径先用本函数统一分隔符，再分别使用
- * {@link relativePathContainsNodeModulesSegment} 排除完整 `node_modules` 目录段、用
- * {@link shouldUploadDistFile} 过滤根 `manifest.json` / `.DS_Store` / source map。`hb-sdk build`
- * 随后校验大小预算；`hb-sdk remote deploy` 还会在签名和上传前通过
- * `validateUploadPaths()`、`prepareMiniappArtifactFiles()` 或
- * `validateMiniappUploadPathLengths()` 执行真正的空路径、点段、控制字符、重复和长度校验。
- * 这些步骤不能由本函数单独替代；`shouldUploadDistFile()` 也不会自行检查 `node_modules`。
- *
- * 不要把本函数与 `@heybox/hb-sdk/protocol` 的 `isMiniProgramRelativePath()` 混用：协议 guard
- * 不做转换，只接受已经规范的非空字符串，并拒绝前导/尾随 `/`、反斜杠、空 segment、`.`、
- * `..` 与控制字符；本函数则会改写部分非法形态并保留其余不安全内容。
+ * 仅整理文本格式，不做路径安全校验：保留点段、控制字符、盘符和尾随 `/`，不 trim 或 URL decode。
+ * 上传前仍需校验路径安全、唯一性与长度。协议 `isMiniProgramRelativePath()` 则只校验、不改写输入。
+ * JavaScript 非字符串输入按 `String(relativePath || '')` 转换，falsy 值回退为空串。
  *
  * @example
  * ```ts
@@ -12118,8 +12139,6 @@ const textEncoder = new TextEncoder();
  *
  * normalizeRelativePath('///dist\\assets//app.js'); // 'dist/assets/app.js'
  * normalizeRelativePath('assets/../secret///'); // 'assets/../secret/'，仍需安全校验
- * normalizeRelativePath(123 as unknown as string); // '123'，JavaScript 运行时强制转换
- * normalizeRelativePath(0 as unknown as string); // ''，falsy 值先回退为空串
  * ```
  *
  * @see {@link relativePathContainsNodeModulesSegment}
@@ -12135,40 +12154,21 @@ function normalizeRelativePath(relativePath) {
 /**
  * 判断路径中是否包含大小写不敏感的完整 `node_modules` 目录段。
  *
- * @param relativePath - 待检查的构建产物路径。函数先通过 {@link normalizeRelativePath} 把
- * 反斜杠改为 `/`、删除前导 `/` 并合并连续 `/`，再按 `/` 分段。
- * @returns 至少一个非空段大小写不敏感地等于完整 `node_modules` 时返回 `true`；空路径、
- * 空段及 `node_modules.txt`、`node_modules-old`、`@node_modules` 等相似名称返回 `false`。
+ * @param relativePath - 构建产物路径，先按 {@link normalizeRelativePath} 整理分隔符再分段比较。
+ * @returns 任意目录段大小写不敏感地等于 `node_modules` 时返回 `true`；空路径和相似名称返回 `false`。
  *
  * @remarks
- * 比较使用每个非空 segment 的 `toLowerCase() === 'node_modules'`，因此根目录或任意深度的
- * `node_modules`、`NODE_MODULES`、`Node_Modules` 都会命中。前导和重复 slash 会先被
- * `normalizeRelativePath` 整理；尾随 slash 产生的空段会被忽略。
- *
- * 这是同步、无副作用的**单一 predicate**，只回答“规范化后的文本是否包含该完整段”。它
- * 不 trim segment、不进行 URL/percent decode、Unicode normalize 或文件系统解析。例如
- * `node_modules%2Fpkg/index.js`、`%6eode_modules/pkg.js` 和 `node_modules.txt` 都不会命中；调用方
- * 不应传 URL，也不能把未命中解释为路径安全。
- *
- * 本函数不会拒绝或消解 `.` / `..`、绝对路径、Windows drive prefix、控制字符、空路径、
- * symlink、重复路径或超长路径。`assets/../node_modules/pkg.js` 仍会命中，因为点段保持原样；
- * 不含 `node_modules` 的危险路径则仍可能返回 `false`。签名或上传前必须继续执行对应的上传
- * 路径规范、唯一性和长度校验。
- *
- * SDK build/deploy 会在文件扫描后用本函数拒绝整个 `node_modules` 树，再用
- * {@link shouldUploadDistFile} 排除根 `manifest.json`、`.DS_Store` 和 source map。build 随后
- * 校验大小预算；deploy 还会执行上传路径安全、唯一性、长度与签名校验。这些步骤互不替代：`shouldUploadDistFile()` 本身不检查
- * `node_modules`，本函数也不决定普通文件是否应该上传。
+ * 只检查目录段文本，不 trim、URL decode 或解析文件系统。未命中不表示路径安全；点段仍保留。
+ * SDK 用它排除 `node_modules` 树，再用 {@link shouldUploadDistFile} 过滤其他不上传的文件；
+ * 路径安全、唯一性、长度与上传大小需分别校验。
  *
  * @example
  * ```ts
  * import { relativePathContainsNodeModulesSegment } from '@heybox/hb-sdk/miniapp-publish';
  *
  * relativePathContainsNodeModulesSegment('dist\\NODE_MODULES/pkg/index.js'); // true
- * relativePathContainsNodeModulesSegment('dist//vendor///node_modules/'); // true
  * relativePathContainsNodeModulesSegment('dist/node_modules.txt'); // false
  * relativePathContainsNodeModulesSegment('dist/node_modules%2Fpkg.js'); // false，不做 URL decode
- * relativePathContainsNodeModulesSegment('assets/../secret.js'); // false，但这不代表路径安全
  * ```
  *
  * @see [normalizeRelativePath](/reference/symbols/miniapp-publish/functions/normalizeRelativePath)
@@ -12469,8 +12469,9 @@ function createMiniappArtifactFileHeader(file) {
  * 校验服务端 session 文件映射，并计算仍需上传的文件。
  *
  * @param localFiles - 本地构建产物 receipt；除 `relativePath` 和 `size` 外，每项必须包含 64 位小写十六进制 `sha256`。
- * @param serverFiles - 服务端签发的文件映射；数量、路径、大小和 SHA-256 必须与本地产物一一一致。
+ * @param serverFiles - 服务端签发的会话文件映射；与复用的 Companion 合起来必须覆盖本地产物。
  * @param uploadedKeys - 服务端已确认上传成功的 key；每个值都必须属于当前会话，重复值会被去重。
+ * @param reusedCompanionFiles - 已验证 Blob 引用；仅允许当前产物中的 Companion 文件。
  * @returns
  * 包含三个字段的对象：`files` 是按路径 UTF-8 字节序排列的全部 `{ file, key }` 映射，
  * `missingFiles` 是其中尚未确认上传的映射，`uploadedKeys` 是去重后的已上传 key。
@@ -12486,15 +12487,38 @@ function createMiniappArtifactFileHeader(file) {
  *     sha256: 'a'.repeat(64),
  *   }],
  *   [],
+ *   [],
  * );
  *
  * console.log(resolved.missingFiles.length); // 1
  * ```
  */
-function resolveMiniappUploadSessionFiles(localFiles, serverFiles, uploadedKeys) {
+function resolveMiniappUploadSessionFiles(localFiles, serverFiles, uploadedKeys, reusedCompanionFiles) {
     const preparedFiles = prepareMiniappArtifactFiles(localFiles);
-    if (serverFiles.length !== preparedFiles.length) {
-        throw new Error(`上传会话文件数量异常：期望 ${preparedFiles.length}，实际 ${serverFiles.length}`);
+    if (serverFiles.length + reusedCompanionFiles.length !== preparedFiles.length) {
+        throw new Error(`上传会话文件数量异常：期望 ${preparedFiles.length}，实际 ${serverFiles.length + reusedCompanionFiles.length}`);
+    }
+    const localByPath = new Map(preparedFiles.map((file) => [file.relativePath, file]));
+    const reused = new Map();
+    for (const reference of reusedCompanionFiles) {
+        const relativePath = normalizeMiniappArtifactRelativePath(reference.relative_path);
+        const local = localByPath.get(relativePath);
+        if (!relativePath.startsWith('companions/') || !local) {
+            throw new Error(`上传会话返回了不属于当前 Companion 产物的 Blob 引用：${relativePath}`);
+        }
+        if (reused.has(relativePath)) {
+            throw new Error(`上传会话返回重复 Blob 引用：${relativePath}`);
+        }
+        if (!Number.isSafeInteger(reference.size) || reference.size < 0 || reference.size !== local.size) {
+            throw new Error(`上传会话 Blob 文件大小与本地构建不一致：${relativePath}`);
+        }
+        if (!('sha256' in local) || !/^[a-f0-9]{64}$/.test(reference.sha256) || reference.sha256 !== local.sha256) {
+            throw new Error(`上传会话 Blob 文件 SHA-256 与本地构建不一致：${relativePath}`);
+        }
+        if (typeof reference.blob_id !== 'string' || !reference.blob_id.trim()) {
+            throw new Error(`上传会话 Blob 引用 ID 无效：${relativePath}`);
+        }
+        reused.set(relativePath, reference);
     }
     const mappings = new Map();
     const serverSizes = new Map();
@@ -12505,6 +12529,9 @@ function resolveMiniappUploadSessionFiles(localFiles, serverFiles, uploadedKeys)
         if (mappings.has(relativePath)) {
             throw new Error(`上传会话返回重复文件路径：${relativePath}`);
         }
+        if (reused.has(relativePath)) {
+            throw new Error(`上传会话同时返回文件 key 和 Blob 引用：${relativePath}`);
+        }
         const key = String(serverFile.key || '');
         if (!key) {
             throw new Error(`上传会话未返回文件 key：${relativePath}`);
@@ -12525,7 +12552,8 @@ function resolveMiniappUploadSessionFiles(localFiles, serverFiles, uploadedKeys)
         serverHashes.set(relativePath, sha256);
         knownKeys.add(key);
     }
-    const files = preparedFiles.map((file) => {
+    const sessionFiles = preparedFiles.filter((file) => !reused.has(file.relativePath));
+    const files = sessionFiles.map((file) => {
         const key = mappings.get(file.relativePath);
         if (!key) {
             throw new Error(`上传会话缺少文件映射：${file.relativePath}`);
@@ -12550,6 +12578,7 @@ function resolveMiniappUploadSessionFiles(localFiles, serverFiles, uploadedKeys)
         files,
         missingFiles: files.filter((file) => !completed.has(file.key)),
         uploadedKeys: [...completed],
+        reusedCompanionFiles: [...reused.values()],
     };
 }
 /**

package/dist/cli-chunks/{session-mMVA3395.cjs → session-DrhTp-x-.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./index-d1cUUoR9.cjs');
+var index = require('./index-CYxcLlON.cjs');
 var node_crypto = require('node:crypto');
 var path = require('node:path');
 var require$$0$2 = require('fs');

package/dist/cli-chunks/{skill-BhUlKvyY.cjs → skill-NfC1c0iQ.cjs}

@@ -1,10 +1,10 @@
 'use strict';
 
-var version = require('./version-hsUgRL0I.cjs');
+var version = require('./version-DA6v9R62.cjs');
 var fs = require('node:fs/promises');
 var path = require('node:path');
 var childProcess = require('node:child_process');
-var index = require('./index-d1cUUoR9.cjs');
+var index = require('./index-CYxcLlON.cjs');
 require('node:module');
 require('node:fs');
 require('path');

package/dist/cli-chunks/{version-hsUgRL0I.cjs → version-DA6v9R62.cjs}

@@ -3,6 +3,6 @@
 /** 构建时替换为当前发布包的实际版本。 */
 const HB_SDK_VERSION = typeof undefined === 'string'
     ? undefined
-    : '0.9.0-alpha.1';
+    : '0.9.0-alpha.10';
 
 exports.HB_SDK_VERSION = HB_SDK_VERSION;

package/dist/cli.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var index = require('./cli-chunks/index-d1cUUoR9.cjs');
+var index = require('./cli-chunks/index-CYxcLlON.cjs');
 require('node:module');
 require('node:fs');
 require('node:fs/promises');