@chenchaolong/plugin-trade-compliance-workbench 1.0.1 → 1.0.3

package/dist/lib/workbench-view.provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workbench-view.provider.d.ts","sourceRoot":"","sources":["../../src/lib/workbench-view.provider.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,+BAA+B,EAAE,MAAM,wBAAwB,CAAA;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,EAAE,0BAA0B,EAAE,MAAM,4BAA4B,CAAA;AASvE,qBAEa,oCAAoC;IACnC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAmC,OAAO,CAAC,QAAQ,CAAC,UAAU;IAAoB,OAAO,CAAC,QAAQ,CAAC,OAAO;gBAAjH,OAAO,EAAE,+BAA+B,EAAmB,UAAU,EAAE,gBAAgB,EAAmB,OAAO,EAAE,0BAA0B;IAE1K,QAAQ,CAAC,OAAO,EAAE,GAAG;IAErB,gBAAgB,CAAC,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAatC,uBAAuB,CAAC,QAAQ,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG;;;;IAYtE,WAAW,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQtD,iBAAiB,CAAC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoCjF,qBAAqB,CAAC,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBtG"}
+{"version":3,"file":"workbench-view.provider.d.ts","sourceRoot":"","sources":["../../src/lib/workbench-view.provider.ts"],"names":[],"mappings":"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"}

package/dist/lib/workbench-view.provider.js

@@ -1,25 +1,32 @@
-import { __decorate, __metadata } from "tslib";
-import { Injectable } from '@nestjs/common';
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, Injectable, Optional } from '@nestjs/common';
 import { createRequire } from 'node:module';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readFile } from 'node:fs/promises';
-import { renderRemoteReactIframeHtml, ViewExtensionProvider } from '@xpert-ai/plugin-sdk';
+import { PLUGIN_CONFIG_RESOLVER_TOKEN, renderRemoteReactIframeHtml, RequestContext, ViewExtensionProvider } from '@xpert-ai/plugin-sdk';
+import { PermissionsEnum } from '@xpert-ai/contracts';
+import XLSX from 'xlsx';
 import { FIXED_SLOT, FEATURE, ICON, MAIN_SLOT, PLUGIN_NAME, REMOTE_ENTRY_KEY, TOOL_NAMES, VIEW_KEY, VIEW_PROVIDER_KEY } from './constants.js';
 import { TradeComplianceWorkbenchService } from './workbench.service.js';
-import { SalesFileService } from './sales-file.service.js';
+import { MAX_EDITED_WORKBOOK_BYTES, SalesFileService } from './sales-file.service.js';
 import { TradeComplianceFileStorage } from './adapters/file-storage.js';
 import { extractDocumentText } from './adapters/document-text-extractor.js';
 import { getHsBianmaCodeDetail, searchHsBianmaCodes } from './adapters/hsbianma.provider.js';
-import { DomainError, DomainErrorCodes, SourceFileFormats } from './types.js';
+import { DomainError, DomainErrorCodes, SalesFileTypes, SourceFileFormats } from './types.js';
+import { parseAnalyticsQuery, parseBankAccountType, parseExpectedRevision, parseRestoreSettingsInput, parseSettingsType } from './runtime-validation.js';
+import { TradeComplianceDemoDataService } from './demo-data.service.js';
+import { resolveTradeComplianceConfig } from './trade-compliance.config.js';
 const moduleDir = dirname(fileURLToPath(import.meta.url));
 const requireFromHere = createRequire(import.meta.url);
 const text = (en_US, zh_Hans) => ({ en_US, zh_Hans });
 let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewProvider {
-    constructor(service, salesFiles, storage) {
+    constructor(service, salesFiles, storage, demoData, configResolver) {
         this.service = service;
         this.salesFiles = salesFiles;
         this.storage = storage;
+        this.demoData = demoData;
+        this.configResolver = configResolver;
     }
     supports(context) { return context.hostType === 'agent'; }
     getViewManifests(_context, slot) {
@@ -38,22 +45,78 @@ let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewPro
     async getRemoteComponentEntry(_context, viewKey, component) {
         if (viewKey !== VIEW_KEY || component.entry !== REMOTE_ENTRY_KEY)
             return { html: '<!doctype html><html><body>Unsupported component.</body></html>', contentType: 'text/html; charset=utf-8' };
-        const [appScript, editorScript, editorCss, reactUmd, reactDomUmd] = await Promise.all([
+        const [appScript, appCss, reactUmd, reactDomUmd] = await Promise.all([
             readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'app.js'), 'utf8'),
-            readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'editor.js'), 'utf8'),
-            readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'editor.css'), 'utf8'),
+            readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'app.css'), 'utf8'),
             readPackageFile('react', 'umd/react.production.min.js'), readPackageFile('react-dom', 'umd/react-dom.production.min.js')
         ]);
-        const spreadsheetRuntime = `(()=>{const style=document.createElement('style');style.textContent=${JSON.stringify(editorCss)};document.head.appendChild(style)})();\n${editorScript}\n${appScript}`;
-        return { html: renderRemoteReactIframeHtml({ title: '外贸合规工作台', lang: 'zh-Hans', reactUmd, reactDomUmd, appScript: spreadsheetRuntime }), contentType: 'text/html; charset=utf-8' };
+        return { html: renderRemoteReactIframeHtml({ title: '外贸合规工作台', lang: 'zh-Hans', reactUmd, reactDomUmd, appScript, appCss: sanitizeIframeCss(appCss) }), contentType: 'text/html; charset=utf-8' };
     }
     async getViewData(context, _viewKey, query) {
         const scope = scopeFromContext(context);
-        const all = { page: 1, pageSize: 200, search: query?.search, parameters: query?.parameters ?? {} };
-        const [dashboard, controlledGoods, controlledBatches, sanctionedCompanies, sanctionBatches, suppliers, purchaseOrders, purchaseLines, customers, customerContracts, derivedSalesOrders, generatedFiles, settings, analytics, importTasks] = await Promise.all([
-            this.service.dashboard(scope), this.service.listControlledGoods(scope, all), this.service.listControlledBatches(scope, all), this.service.listSanctionedCompanies(scope, all), this.service.listSanctionBatches(scope, all), this.service.listSuppliers(scope, all), this.service.listPurchaseOrders(scope, undefined, all), this.service.listPurchaseLines(scope, undefined, all), this.service.listCustomers(scope, all), this.service.listCustomerContracts(scope, all), this.service.listDerivedSalesOrders(scope), this.service.listGeneratedFiles(scope, all), this.service.settings(scope), this.service.analytics(scope, { ...(query?.parameters ?? {}), search: query?.search }), this.service.listImportTasks(scope, all)
+        const parameters = record(query?.parameters);
+        const collection = stringValue(parameters.collection);
+        if (collection) {
+            const pageQuery = { page: numberValue(query?.page, 1), pageSize: numberValue(query?.pageSize, 20), parameters: record(parameters.filters) };
+            if (collection === 'controlledGoods')
+                return { collection, ...await this.service.listControlledGoods(scope, pageQuery) };
+            if (collection === 'sanctionedCompanies')
+                return { collection, ...await this.service.listSanctionedCompanies(scope, pageQuery) };
+            if (collection === 'suppliers')
+                return { collection, ...await this.service.listSuppliers(scope, pageQuery) };
+            if (collection === 'purchaseOrders') {
+                const supplierId = requiredString(parameters.supplierId, 'supplierId');
+                const [page, supplier, metrics] = await Promise.all([
+                    this.service.listPurchaseOrders(scope, supplierId, pageQuery),
+                    this.service.getSupplier(scope, supplierId),
+                    this.service.getSupplierProcurementMetrics(scope, supplierId)
+                ]);
+                return { collection, ...page, supplier, metrics };
+            }
+            if (collection === 'purchaseLines') {
+                const purchaseOrderId = requiredString(parameters.purchaseOrderId, 'purchaseOrderId');
+                const [page, order] = await Promise.all([
+                    this.service.listPurchaseLines(scope, purchaseOrderId, pageQuery),
+                    this.service.getPurchaseOrder(scope, purchaseOrderId)
+                ]);
+                return { collection, ...page, order, supplier: await this.service.getSupplier(scope, order.supplierId) };
+            }
+            if (collection === 'customerContracts')
+                return { collection, ...await this.service.listCustomerContracts(scope, pageQuery) };
+            if (collection === 'salesCustomers')
+                return { collection, ...await this.service.listSalesCustomers(scope, pageQuery) };
+            if (collection === 'salesOrders')
+                return { collection, ...await this.service.listSalesOrders(scope, requiredString(parameters.customerId, 'customerId'), pageQuery) };
+            if (collection === 'salesLines') {
+                const [customerContractId, purchaseOrderId] = salesOrderKey(requiredString(parameters.orderKey, 'orderKey'));
+                return { collection, ...await this.service.listSalesLines(scope, { customerId: requiredString(parameters.customerId, 'customerId'), customerContractId, purchaseOrderId, ...pageQuery }) };
+            }
+            if (collection === 'salesFileOrders')
+                return { collection, ...await this.service.listSalesFileOrders(scope, pageQuery) };
+            if (collection === 'generatedFiles')
+                return { collection, ...await this.service.listGeneratedFiles(scope, { ...pageQuery, parameters: { ...pageQuery.parameters, customerContractId: parameters.customerContractId, purchaseOrderId: parameters.purchaseOrderId } }) };
+            if (collection === 'analytics')
+                return { collection, ...await this.service.analytics(scope, parseAnalyticsQuery({ mode: parameters.mode, dimension: parameters.dimension, filters: record(parameters.filters), page: query?.page, pageSize: query?.pageSize })) };
+            if (collection === 'settings')
+                return { collection, ...await this.service.settings(scope) };
+            if (collection === 'customerContractAnalysis')
+                return { collection, ...await this.service.getCustomerContractReanalysisResult(scope, requiredString(parameters.runId, 'runId')) };
+            if (collection === 'importTask')
+                return { collection, ...await this.service.getImportTaskResult(scope, requiredString(parameters.taskId, 'taskId')) };
+            if (collection === 'importIssues')
+                return { collection, ...await this.service.listImportIssues(scope, {
+                        documentType: catalogDocumentType(parameters.documentType), batchId: requiredString(parameters.batchId, 'batchId'), issueType: importIssueType(parameters.issueType), page: pageQuery.page, pageSize: pageQuery.pageSize
+                    }) };
+            throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的数据集合', { collection });
+        }
+        const all = { page: 1, pageSize: 200, search: query?.search, parameters };
+        const catalogPage = { page: 1, pageSize: 20, parameters: {} };
+        const [dashboard, controlledGoods, controlledBatches, sanctionedCompanies, sanctionBatches, customers, derivedSalesOrders, generatedFiles, settings, analytics, importTasks] = await Promise.all([
+            this.service.dashboard(scope), this.service.listControlledGoods(scope, catalogPage), this.service.listControlledBatches(scope, all), this.service.listSanctionedCompanies(scope, catalogPage), this.service.listSanctionBatches(scope, all), this.service.listCustomers(scope, all), this.service.listDerivedSalesOrders(scope), this.service.listGeneratedFiles(scope, all), this.service.settings(scope), this.service.analytics(scope, { mode: 'PURCHASE', dimension: 'SUPPLIER', filters: {}, page: 1, pageSize: 20 }), this.service.listImportTasks(scope, all)
         ]);
-        return { items: [], total: 0, summary: { dashboard, controlledGoods, controlledBatches, sanctionedCompanies, sanctionBatches, suppliers, purchaseOrders, purchaseLines, customers, customerContracts, derivedSalesOrders, generatedFiles, settings, analytics, importTasks } };
+        const emptyCollection = { items: [], total: 0, page: 1, pageSize: 20 };
+        const uploadPolicy = { maxUploadMb: resolveTradeComplianceConfig(this.configResolver, scope.organizationId).storage.maxUploadMb };
+        return { items: [], total: 0, summary: { uploadPolicy, dashboard, controlledGoods, controlledBatches, sanctionedCompanies, sanctionBatches, suppliers: emptyCollection, purchaseOrders: emptyCollection, purchaseLines: emptyCollection, customers, customerContracts: emptyCollection, derivedSalesOrders, generatedFiles, settings, analytics, importTasks } };
     }
     async executeViewAction(context, _viewKey, actionKey, request) {
         const scope = scopeFromContext(context);
@@ -62,6 +125,22 @@ let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewPro
             let data;
             switch (actionKey) {
                 case 'refresh': return { success: true, refresh: true, message: text('Refreshed', '已刷新') };
+                case 'load_excel_editor_runtime': {
+                    const [script, editorCss] = await Promise.all([
+                        readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'editor.js'), 'utf8'),
+                        readFile(join(moduleDir, 'remote-components', REMOTE_ENTRY_KEY, 'editor.css'), 'utf8')
+                    ]);
+                    data = { script, css: sanitizeIframeCss(editorCss) };
+                    break;
+                }
+                case 'seed_demo_data': {
+                    RequestContext.hasPermission(PermissionsEnum.ORG_DEMO_EDIT, true);
+                    parseDemoSeedInput(input);
+                    if (!this.demoData)
+                        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '演示数据服务不可用');
+                    data = await this.demoData.seed(scope);
+                    break;
+                }
                 case 'save_controlled_goods':
                     data = await this.service.saveControlledGoods(scope, input);
                     break;
@@ -104,21 +183,64 @@ let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewPro
                 case 'get_customer_contract_review':
                     data = await this.service.getCustomerContractReview(scope, requiredString(input.id, 'id'));
                     break;
-                case 'update_customer_contract_review':
-                    data = await this.service.updateCustomerContractReview(scope, requiredString(input.id, 'id'), input);
+                case 'update_customer_contract_review': {
+                    const parsed = customerContractReviewUpdate(request?.input);
+                    data = await this.service.updateCustomerContractReview(scope, parsed.id, parsed.update);
+                    break;
+                }
+                case 'reanalyze_customer_contract': {
+                    const started = await this.service.startCustomerContractReanalysis(scope, { reviewSource: customerContractReviewSource(input.reviewSource), id: stringValue(input.id), importTaskId: stringValue(input.importTaskId) });
+                    const proposedCommand = started.run.executionCommand ?? buildCustomerContractReanalysisCommand(started);
+                    const run = await this.service.saveCustomerContractReanalysisExecution(scope, started.run.id, proposedCommand);
+                    if (!run.executionCommand)
+                        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重新分析任务缺少已持久化的执行命令');
+                    data = { run, commands: [run.executionCommand], polling: { intervalMs: 2000, timeoutMs: 1200000 } };
+                    break;
+                }
+                case 'mark_customer_contract_reanalysis_dispatched':
+                    data = await this.service.markCustomerContractReanalysisDispatched(scope, requiredString(input.runId, 'runId'));
+                    break;
+                case 'mark_customer_contract_reanalysis_failed':
+                    data = await this.service.markCustomerContractReanalysisFailed(scope, requiredString(input.runId, 'runId'), { errorCode: requiredString(input.errorCode, 'errorCode'), errorMessage: requiredString(input.errorMessage, 'errorMessage') });
                     break;
                 case 'delete_entity':
                     data = await this.service.softDelete(scope, requiredString(input.entityType, 'entityType'), requiredString(input.id, 'id'));
                     break;
-                case 'save_settings':
-                    data = await this.service.saveSettings(scope, input.settingsType, record(input.values));
+                case 'save_settings': {
+                    const settingsType = parseSettingsType(input.settingsType);
+                    data = await this.service.saveSettings(scope, settingsType, record(input.values), parseExpectedRevision(input.expectedRevision, settingsType === 'rate'));
+                    break;
+                }
+                case 'restore_settings_default':
+                    data = await this.service.restoreSettingsDefault(scope, parseRestoreSettingsInput(input));
+                    break;
+                case 'delete_settings_rate': {
+                    const settingsType = parseSettingsType(input.settingsType);
+                    if (settingsType !== 'rate')
+                        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '删除月度汇率必须使用 rate 设置类型', { settingsType });
+                    data = await this.service.deleteMonthlyRate(scope, { id: requiredString(input.id, 'id'), expectedRevision: parseExpectedRevision(input.expectedRevision) });
+                    break;
+                }
+                case 'discard_company_logo': {
+                    const logoFileId = requiredString(input.logoFileId, 'logoFileId');
+                    await this.service.discardCompanyLogoDraft(scope, logoFileId);
+                    data = { logoFileId };
+                    break;
+                }
+                case 'export_analytics': {
+                    const result = await this.service.exportAnalytics(scope, parseAnalyticsQuery({ mode: input.mode, dimension: input.dimension, filters: input.filters, page: 1, pageSize: 20 }));
+                    data = { fileName: result.fileName, mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', base64: result.buffer.toString('base64') };
+                    break;
+                }
+                case 'preflight_sales_file':
+                    data = await this.salesFiles.preflight(scope, salesFileGenerationInput(input));
                     break;
                 case 'generate_sales_file':
-                    data = await this.salesFiles.generate(scope, input);
+                    data = await this.salesFiles.generate(scope, salesFileGenerationInput(input));
                     break;
                 case 'download_sales_file': {
                     const result = await this.salesFiles.download(scope, requiredString(input.id, 'id'));
-                    data = { fileName: result.item.fileName, mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', base64: result.buffer.toString('base64') };
+                    data = { fileName: result.item.fileName, storageFileId: result.item.storageFileId, editVersion: result.item.editVersion, mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', base64: result.buffer.toString('base64') };
                     break;
                 }
                 case 'download_import_issues': {
@@ -126,19 +248,39 @@ let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewPro
                     data = { fileName: result.fileName, mimeType: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', base64: result.buffer.toString('base64') };
                     break;
                 }
+                case 'retry_import_task':
+                    data = await this.startCatalogRetry(scope, requiredString(input.taskId, 'taskId'));
+                    break;
+                case 'mark_import_command_dispatched':
+                    data = await this.service.markImportCommandDispatched(scope, requiredString(input.taskId, 'taskId'));
+                    break;
                 case 'download_source_file': {
-                    const buffer = await this.storage.read(requiredString(input.sourceFileId, 'sourceFileId'));
-                    data = { fileName: requiredString(input.fileName, 'fileName'), mimeType: 'application/octet-stream', base64: buffer.toString('base64') };
+                    const descriptor = await this.service.getSourceFileDescriptor(scope, requiredString(input.sourceFileId, 'sourceFileId'));
+                    const buffer = await this.storage.read(descriptor.sourceFileId);
+                    data = { fileName: descriptor.sourceFileName, mimeType: mimeTypeForFile(descriptor.sourceFileName), base64: buffer.toString('base64') };
                     break;
                 }
-                case 'save_edited_sales_file':
-                    data = await this.salesFiles.saveEditedWorkbook(scope, requiredString(input.id, 'id'), Buffer.from(requiredString(input.base64, 'base64'), 'base64'));
+                case 'preview_source_file': {
+                    const descriptor = await this.service.getSourceFileDescriptor(scope, requiredString(input.sourceFileId, 'sourceFileId'));
+                    const buffer = await this.storage.read(descriptor.sourceFileId);
+                    data = await sourcePreview(descriptor.sourceFileName, buffer);
                     break;
+                }
+                case 'save_edited_sales_file': {
+                    const base64 = requiredString(input.base64, 'base64');
+                    if (base64.length > Math.ceil(MAX_EDITED_WORKBOOK_BYTES / 3) * 4)
+                        throw new DomainError(DomainErrorCodes.FILE_TOO_LARGE, '编辑后的工作簿不能超过 20 MB');
+                    const buffer = Buffer.from(base64, 'base64');
+                    if (buffer.length > MAX_EDITED_WORKBOOK_BYTES)
+                        throw new DomainError(DomainErrorCodes.FILE_TOO_LARGE, '编辑后的工作簿不能超过 20 MB');
+                    data = await this.salesFiles.saveEditedWorkbook(scope, requiredString(input.id, 'id'), buffer, { editVersion: requiredNonNegativeInteger(input.editVersion, 'editVersion'), expectedStorageFileId: requiredString(input.expectedStorageFileId, 'expectedStorageFileId') });
+                    break;
+                }
                 case 'search_hs_code':
-                    data = await searchHsBianmaCodes({ keywords: requiredString(input.keywords, 'keywords'), page: numberValue(input.page, 1), filterFailureCode: true, displayChapter: false, displayEnName: true }, hsConfig());
+                    data = await searchHsBianmaCodes({ keywords: requiredString(input.keywords, 'keywords'), page: numberValue(input.page, 1), filterFailureCode: true, displayChapter: false, displayEnName: true }, this.hsConfig(scope));
                     break;
                 case 'get_hs_code_detail':
-                    data = await getHsBianmaCodeDetail({ code: stringValue(input.code), detailUrl: stringValue(input.detailUrl) }, hsConfig());
+                    data = { ...await getHsBianmaCodeDetail({ code: stringValue(input.code), detailUrl: stringValue(input.detailUrl) }, this.hsConfig(scope)), queriedAt: new Date().toISOString() };
                     break;
                 default: throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的操作', { actionKey });
             }
@@ -153,43 +295,96 @@ let TradeComplianceWorkbenchViewProvider = class TradeComplianceWorkbenchViewPro
             return failure(new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的视图'));
         const scope = scopeFromContext(context);
         const input = record(request?.input);
+        let task;
         try {
-            const fileName = fileNameOf(file, input);
-            const format = formatOf(fileName);
-            const size = Number(file?.size ?? 0);
-            if (!format)
-                throw new DomainError(DomainErrorCodes.UNSUPPORTED_FILE_FORMAT, '仅支持 PDF、Word、Excel 和常见图片格式');
-            if (size > 20 * 1024 * 1024)
-                throw new DomainError(DomainErrorCodes.FILE_TOO_LARGE, '文件不能超过 20 MB');
-            const buffer = bufferOf(file) ?? await bufferFromPath(input);
+            const buffer = bufferOf(file);
             if (!buffer?.length)
                 throw new DomainError(DomainErrorCodes.INVALID_INPUT, '无法读取上传文件内容');
+            if (actionKey === 'upload_company_logo') {
+                if (buffer.length > 2 * 1024 * 1024)
+                    throw new DomainError(DomainErrorCodes.FILE_TOO_LARGE, '公司 Logo 不能超过 2 MB');
+                const fileName = fileNameOf(file, input);
+                const format = validateSourceFile(fileName, String(file?.mimetype ?? file?.type ?? ''), buffer);
+                if (format !== 'PNG' && format !== 'JPEG')
+                    throw new DomainError(DomainErrorCodes.UNSUPPORTED_FILE_FORMAT, '公司 Logo 仅支持 PNG、JPG/JPEG');
+                const asset = await this.service.createCompanyLogoDraft(scope, buffer, fileName);
+                return { success: true, refresh: false, message: text('Logo uploaded', '公司 Logo 上传成功'), data: { logoFileId: asset.id } };
+            }
+            const maxUploadMb = resolveTradeComplianceConfig(this.configResolver, scope.organizationId).storage.maxUploadMb;
+            if (buffer.length > maxUploadMb * 1024 * 1024)
+                throw new DomainError(DomainErrorCodes.FILE_TOO_LARGE, `文件不能超过 ${maxUploadMb} MB`);
+            const fileName = fileNameOf(file, input);
+            const format = validateSourceFile(fileName, String(file?.mimetype ?? file?.type ?? ''), buffer);
+            const sourcePlatformFileId = platformFileId(file, input);
+            if (!sourcePlatformFileId)
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '上传文件缺少平台文件标识，请重新上传');
             const documentType = documentTypeForAction(actionKey);
             const storageFileId = await this.storage.save(buffer, fileName, 'uploads');
-            const task = await this.service.createImportTask(scope, { documentType, sourceFileId: storageFileId, sourceFileName: fileName, sourceFileFormat: format, status: 'EXTRACTING' });
+            const executionInput = executionInputForAction(actionKey, input);
+            task = await this.service.createImportTask(scope, { documentType, sourceFileId: storageFileId, sourceFileName: fileName, sourceFileFormat: format, sourcePlatformFileId, executionInput, status: 'EXTRACTING' });
             let extracted = { text: '', chunks: [], kind: 'image', originalLength: 0 };
             if (!['PNG', 'JPEG', 'WEBP'].includes(format))
                 extracted = await extractDocumentText({ buffer, fileName, mimeType: file?.mimetype ?? file?.type, maxChars: 100000 });
             const parsingTask = await this.service.markImportTaskParsing(scope, task.id);
             const command = buildAssistantCommand({ actionKey, file, input, task, extracted, catalogType: input.catalogType, replaceBatchId: input.replaceBatchId });
+            await this.service.saveImportTaskExecution(scope, task.id, command);
             return { success: true, refresh: false, message: text('Parsing started', '文件已进入解析中，请勿重复操作'), data: { task: parsingTask, commands: [command], polling: { intervalMs: 2000, timeoutMs: 1200000 } } };
         }
         catch (error) {
+            if (task?.id)
+                await this.service.markImportTaskFailed(scope, task.id, { errorCode: error instanceof DomainError ? error.code : DomainErrorCodes.INVALID_INPUT, errorMessage: error instanceof Error ? error.message : String(error) });
             return failure(error);
         }
     }
+    async startCatalogRetry(scope, sourceTaskId) {
+        let task;
+        try {
+            task = await this.service.createRetryImportTask(scope, sourceTaskId);
+            const buffer = await this.storage.read(task.sourceFileId);
+            let extracted = { text: '', chunks: [], kind: 'image', originalLength: 0 };
+            if (!['PNG', 'JPEG', 'WEBP'].includes(task.sourceFileFormat))
+                extracted = await extractDocumentText({ buffer, fileName: task.sourceFileName, maxChars: 100000 });
+            if (!task.sourcePlatformFileId)
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '源文件缺少平台文件标识，无法重新解析');
+            const executionInput = task.executionInput;
+            if (!executionInput)
+                throw new DomainError(DomainErrorCodes.INVALID_INPUT, '重试任务缺少执行参数');
+            const file = { name: task.sourceFileName, size: buffer.length, fileAssetId: task.sourcePlatformFileId, fileId: task.sourcePlatformFileId };
+            const input = { ...executionInput, fileAssetId: task.sourcePlatformFileId };
+            const command = buildAssistantCommand({ actionKey: executionInput.actionKey, file, input, task, extracted, catalogType: executionInput.catalogType, replaceBatchId: executionInput.replaceBatchId });
+            const parsingTask = await this.service.markImportTaskParsing(scope, task.id);
+            await this.service.saveImportTaskExecution(scope, task.id, command);
+            return { task: parsingTask, commands: [command], polling: { intervalMs: 2000, timeoutMs: 1200000 } };
+        }
+        catch (error) {
+            if (task?.id)
+                await this.service.markImportTaskFailed(scope, task.id, { errorCode: error instanceof DomainError ? error.code : DomainErrorCodes.INVALID_INPUT, errorMessage: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    hsConfig(scope) {
+        return resolveTradeComplianceConfig(this.configResolver, scope.organizationId).hsBianma;
+    }
 };
 TradeComplianceWorkbenchViewProvider = __decorate([
     Injectable(),
     ViewExtensionProvider(VIEW_PROVIDER_KEY),
-    __metadata("design:paramtypes", [TradeComplianceWorkbenchService, SalesFileService, TradeComplianceFileStorage])
+    __param(3, Optional()),
+    __param(4, Optional()),
+    __param(4, Inject(PLUGIN_CONFIG_RESOLVER_TOKEN)),
+    __metadata("design:paramtypes", [TradeComplianceWorkbenchService,
+        SalesFileService,
+        TradeComplianceFileStorage,
+        TradeComplianceDemoDataService, Object])
 ], TradeComplianceWorkbenchViewProvider);
 export { TradeComplianceWorkbenchViewProvider };
 function actionManifests() {
     const invoke = (key, label, icon = 'ri-edit-line') => ({ key, label: text(key, label), icon, actionType: 'invoke' });
     const upload = (key, label) => ({ ...invoke(key, label, 'ri-upload-cloud-line'), transport: 'file', placement: 'toolbar' });
-    return [invoke('refresh', '刷新', 'ri-refresh-line'), upload('upload_controlled_catalog', '上传管控目录'), upload('upload_sanction_catalog', '上传制裁目录'), upload('upload_purchase_contract', '上传采购合同'), upload('upload_customer_contract', '上传客户合同'),
-        ...['save_controlled_goods', 'update_controlled_goods', 'save_sanctioned_company', 'update_sanctioned_company', 'save_purchase_review', 'save_customer_contract_review', 'update_supplier', 'update_purchase_order', 'add_purchase_line', 'update_purchase_line', 'update_customer', 'save_customer_profit_rate', 'save_derived_manual_data', 'get_customer_contract_review', 'update_customer_contract_review', 'delete_entity', 'save_settings', 'generate_sales_file', 'download_sales_file', 'download_import_issues', 'download_source_file', 'save_edited_sales_file', 'search_hs_code', 'get_hs_code_detail'].map(key => invoke(key, key))];
+    const fileInvoke = (key, label) => ({ ...invoke(key, label, 'ri-upload-cloud-line'), transport: 'file' });
+    return [invoke('refresh', '刷新', 'ri-refresh-line'), upload('upload_controlled_catalog', '上传管控目录'), upload('upload_sanction_catalog', '上传制裁目录'), upload('upload_purchase_contract', '上传采购合同'), upload('upload_customer_contract', '上传客户合同'), fileInvoke('upload_company_logo', '上传公司 Logo'),
+        { ...invoke('seed_demo_data', 'seed_demo_data'), permissions: [PermissionsEnum.ORG_DEMO_EDIT] },
+        ...['load_excel_editor_runtime', 'save_controlled_goods', 'update_controlled_goods', 'save_sanctioned_company', 'update_sanctioned_company', 'retry_import_task', 'mark_import_command_dispatched', 'save_purchase_review', 'save_customer_contract_review', 'update_supplier', 'update_purchase_order', 'add_purchase_line', 'update_purchase_line', 'update_customer', 'save_customer_profit_rate', 'save_derived_manual_data', 'get_customer_contract_review', 'update_customer_contract_review', 'reanalyze_customer_contract', 'mark_customer_contract_reanalysis_dispatched', 'mark_customer_contract_reanalysis_failed', 'delete_entity', 'save_settings', 'restore_settings_default', 'delete_settings_rate', 'discard_company_logo', 'export_analytics', 'preflight_sales_file', 'generate_sales_file', 'download_sales_file', 'download_import_issues', 'download_source_file', 'preview_source_file', 'save_edited_sales_file', 'search_hs_code', 'get_hs_code_detail'].map(key => invoke(key, key))];
 }
 function buildAssistantCommand({ actionKey, file, input, task, extracted, catalogType, replaceBatchId }) {
     const toolName = actionKey === 'upload_controlled_catalog' ? TOOL_NAMES.saveControlledCatalog : actionKey === 'upload_sanction_catalog' ? TOOL_NAMES.saveSanctionCatalog : actionKey === 'upload_purchase_contract' ? TOOL_NAMES.savePurchaseDraft : TOOL_NAMES.saveCustomerContractDraft;
@@ -198,17 +393,179 @@ function buildAssistantCommand({ actionKey, file, input, task, extracted, catalo
     const fixed = JSON.stringify({ importTaskId: task.id, sourceFileId: task.sourceFileId, sourceFileName: task.sourceFileName, catalogType, replaceBatchId });
     return { commandKey: 'assistant.chat.send_message', payload: { text: `请解析上传的外贸合规文件。${requirements}\n解析完成后必须调用工具 ${toolName} 保存结果，以下固定参数必须原样传入：${fixed}\n统一使用中文说明，不要遗漏文件中的记录。${source}`, clientMessageId: `trade-compliance:${task.id}`, files: [assistantFile(file, input, task.sourceFileName)], followUpMode: 'queue', state: { tradeComplianceWorkbench: { actionKey, importTaskId: task.id } } } };
 }
-function assistantFile(file, input, fileName) { const workspace = record(input.workspaceFile); return { id: input.fileAssetId ?? input.fileId ?? file?.fileAssetId ?? file?.fileId, fileId: input.fileAssetId ?? input.fileId ?? file?.fileAssetId ?? file?.fileId, fileAssetId: input.fileAssetId ?? input.fileId ?? file?.fileAssetId ?? file?.fileId, workspacePath: workspace.workspacePath ?? input.workspacePath, filePath: workspace.filePath ?? input.filePath, name: fileName, originalName: fileName, mimeType: file?.mimetype ?? file?.type, size: file?.size, role: 'source_file' }; }
+function buildCustomerContractReanalysisCommand(started) {
+    if (started.run.promptVersion !== 'CUSTOMER_CLAUSE_V1')
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的客户合同重新分析提示版本');
+    const fixed = JSON.stringify({ analysisRunId: started.run.id });
+    const clauses = JSON.stringify(started.clauses.map(clause => ({ clauseType: clause.clauseType, extractionStatus: clause.extractionStatus, reviewedText: clause.reviewedText, sourceText: clause.sourceText, sourceLocation: clause.sourceLocation, sourceContent: clause.sourceContent })));
+    return { commandKey: 'assistant.chat.send_message', payload: { text: `请重新分析客户合同七类关键条款。必须按 clauseType 返回风险等级、中文风险提示和修改建议，并调用工具 ${TOOL_NAMES.saveCustomerContractReanalysis} 保存结果。固定参数必须原样传入：${fixed}\n待分析条款：${clauses}`, clientMessageId: `trade-compliance:customer-reanalysis:${started.run.id}`, followUpMode: 'queue', state: { tradeComplianceWorkbench: { actionKey: 'reanalyze_customer_contract', analysisRunId: started.run.id } } } };
+}
+function assistantFile(file, input, fileName) {
+    const fileAssetId = input.fileAssetId ?? input.fileId ?? file?.fileAssetId ?? file?.fileId;
+    const storageFileId = input.storageFileId ?? file?.storageFileId;
+    return { id: fileAssetId, fileId: fileAssetId, fileAssetId, ...(storageFileId ? { storageFileId } : {}), name: fileName, originalName: fileName, mimeType: file?.mimetype ?? file?.type, size: file?.size, role: 'source_file' };
+}
+function platformFileId(file, input) { const value = input.fileAssetId ?? input.fileId ?? file?.fileAssetId ?? file?.fileId; return value ? String(value) : null; }
+function executionInputForAction(actionKey, input) {
+    const typedActionKey = documentActionKey(actionKey);
+    const catalogType = input.catalogType === 'DUAL_USE' || input.catalogType === 'OVERSEAS_SANCTION' ? input.catalogType : undefined;
+    if (typedActionKey === 'upload_controlled_catalog' && !catalogType)
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '管控目录任务缺少目录类型');
+    return { actionKey: typedActionKey, ...(catalogType ? { catalogType } : {}), ...(input.replaceBatchId ? { replaceBatchId: String(input.replaceBatchId) } : {}) };
+}
+function documentActionKey(actionKey) { documentTypeForAction(actionKey); return actionKey; }
+function catalogDocumentType(value) { if (value === 'CONTROLLED_CATALOG' || value === 'SANCTION_CATALOG')
+    return value; throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的目录文档类型'); }
+function importIssueType(value) { if (value === 'DUPLICATE' || value === 'INVALID')
+    return value; throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的导入问题类型'); }
+function customerContractReviewSource(value) { if (value === 'IMPORT_DRAFT' || value === 'EXISTING_CONTRACT')
+    return value; throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的客户合同审核来源'); }
+function salesOrderKey(value) { const parts = value.split(':'); if (parts.length !== 2 || parts.some(part => !part))
+    throw new DomainError(DomainErrorCodes.INVALID_INPUT, '销售订单标识无效'); return parts; }
+function salesFileGenerationInput(input) {
+    if (!SalesFileTypes.includes(input.fileType))
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '销售文件类型无效');
+    const fileType = input.fileType;
+    const bankType = input.bankType == null ? undefined : parseBankAccountType(input.bankType);
+    return { customerContractId: requiredString(input.customerContractId, 'customerContractId'), purchaseOrderId: requiredString(input.purchaseOrderId, 'purchaseOrderId'), fileType, ...(bankType ? { bankType } : {}) };
+}
+function requiredNonNegativeInteger(value, field) { const parsed = Number(value); if (!Number.isInteger(parsed) || parsed < 0)
+    throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${field} 必须是非负整数`); return parsed; }
 function documentTypeForAction(action) { const map = { upload_controlled_catalog: 'CONTROLLED_CATALOG', upload_sanction_catalog: 'SANCTION_CATALOG', upload_purchase_contract: 'PURCHASE_CONTRACT', upload_customer_contract: 'CUSTOMER_CONTRACT' }; const value = map[action]; if (!value)
     throw new DomainError(DomainErrorCodes.INVALID_INPUT, '不支持的上传操作', { action }); return value; }
 function formatOf(fileName) { const extension = fileName.split('.').pop()?.toUpperCase(); const normalized = extension === 'JPG' ? 'JPEG' : extension; return SourceFileFormats.includes(normalized) ? normalized : null; }
+export function validateSourceFile(fileName, mimeType, buffer) {
+    const extensionFormat = formatOf(fileName);
+    const mimeFormat = formatForMimeType(mimeType);
+    const signatureFormat = formatForSignature(buffer);
+    if (!extensionFormat)
+        throw new DomainError(DomainErrorCodes.UNSUPPORTED_FILE_FORMAT, '仅支持 PDF、Word、Excel 和常见图片格式');
+    if (extensionFormat !== mimeFormat || extensionFormat !== signatureFormat) {
+        throw new DomainError(DomainErrorCodes.UNSUPPORTED_FILE_FORMAT, '文件扩展名、MIME 类型与文件签名不一致');
+    }
+    return extensionFormat;
+}
+function formatForMimeType(mimeType) {
+    const formats = {
+        'application/pdf': 'PDF',
+        'application/msword': 'DOC',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document': 'DOCX',
+        'application/vnd.ms-excel': 'XLS',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet': 'XLSX',
+        'image/png': 'PNG',
+        'image/jpeg': 'JPEG',
+        'image/webp': 'WEBP'
+    };
+    return formats[mimeType.trim().toLowerCase()] ?? null;
+}
+function formatForSignature(buffer) {
+    if (buffer.subarray(0, 5).equals(Buffer.from('%PDF-')))
+        return 'PDF';
+    if (buffer.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+        return 'PNG';
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+        return 'JPEG';
+    if (buffer.length >= 12 && buffer.subarray(0, 4).toString('ascii') === 'RIFF' && buffer.subarray(8, 12).toString('ascii') === 'WEBP')
+        return 'WEBP';
+    if (buffer.subarray(0, 8).equals(Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1]))) {
+        let names;
+        try {
+            const container = XLSX.CFB.read(buffer, { type: 'buffer' });
+            names = container.FileIndex.filter((entry) => entry.type === 2).map((entry) => String(entry.name));
+        }
+        catch {
+            return null;
+        }
+        const isWord = names.includes('WordDocument');
+        const isExcel = names.includes('Workbook') || names.includes('Book');
+        if (isWord !== isExcel)
+            return isWord ? 'DOC' : 'XLS';
+        return null;
+    }
+    if (buffer.length >= 4 && [[0x03, 0x04], [0x05, 0x06], [0x07, 0x08]].some(([third, fourth]) => buffer[0] === 0x50 && buffer[1] === 0x4b && buffer[2] === third && buffer[3] === fourth)) {
+        let container;
+        try {
+            container = XLSX.CFB.read(buffer, { type: 'buffer' });
+        }
+        catch {
+            return null;
+        }
+        const entries = container.FileIndex
+            .map((entry, index) => entry.type === 2 ? packageEntryName(container.FullPaths[index]) : null)
+            .filter((name) => Boolean(name));
+        if (!entries.includes('[Content_Types].xml'))
+            return null;
+        const isWord = entries.some(name => name.startsWith('word/'));
+        const isExcel = entries.some(name => name.startsWith('xl/'));
+        if (isWord !== isExcel)
+            return isWord ? 'DOCX' : 'XLSX';
+    }
+    return null;
+}
+function packageEntryName(fullPath) { const value = String(fullPath ?? '').replace(/\\/g, '/'); const rootSeparator = value.indexOf('/'); return rootSeparator < 0 ? value : value.slice(rootSeparator + 1); }
+function mimeTypeForFile(fileName) { const format = formatOf(fileName); return format === 'PDF' ? 'application/pdf' : format === 'PNG' ? 'image/png' : format === 'JPEG' ? 'image/jpeg' : format === 'WEBP' ? 'image/webp' : format === 'DOC' ? 'application/msword' : format === 'DOCX' ? 'application/vnd.openxmlformats-officedocument.wordprocessingml.document' : format === 'XLS' ? 'application/vnd.ms-excel' : format === 'XLSX' ? 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' : 'application/octet-stream'; }
 function scopeFromContext(context) { if (!context.tenantId || !context.organizationId)
     throw new DomainError(DomainErrorCodes.INVALID_INPUT, '请求上下文缺少租户或组织标识'); return { tenantId: context.tenantId, organizationId: context.organizationId, userId: context.userId }; }
+function parseDemoSeedInput(input) {
+    if (Object.keys(input).length !== 1 || input.confirmation !== 'INIT_DEMO_DATA') {
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, '初始化演示数据必须提供精确确认值 INIT_DEMO_DATA');
+    }
+    return { confirmation: input.confirmation };
+}
 function success(data) { return { success: true, message: text('Saved', '已保存'), data, refresh: true }; }
 function failure(error) { const domain = error instanceof DomainError ? error : new DomainError(DomainErrorCodes.INVALID_INPUT, error instanceof Error ? error.message : String(error)); return { success: false, message: text(domain.message, domain.message), error: { code: domain.code, message: domain.message, details: domain.details }, refresh: false }; }
 function record(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }
 function requiredString(value, field) { const result = String(value ?? '').trim(); if (!result)
     throw new DomainError(DomainErrorCodes.INVALID_INPUT, `缺少 ${field}`); return result; }
+function customerContractReviewUpdate(value) {
+    const payload = objectInput(value, '客户合同审核载荷');
+    const contractInput = objectInput(payload.contract, '合同信息');
+    const contract = {
+        contractNo: typedRequiredString(contractInput.contractNo, '客户合同编码')
+    };
+    if ('signedAt' in contractInput)
+        contract.signedAt = nullableString(contractInput.signedAt, '签订日期');
+    if ('contractAmountReviewCny' in contractInput)
+        contract.contractAmountReviewCny = nullableDecimalString(contractInput.contractAmountReviewCny, '人民币预审合同金额');
+    const update = { contract };
+    if ('customer' in payload)
+        update.customer = objectInput(payload.customer, '客户信息');
+    if ('clauses' in payload) {
+        if (!Array.isArray(payload.clauses))
+            throw new DomainError(DomainErrorCodes.INVALID_INPUT, '合同条款必须是数组');
+        update.clauses = payload.clauses;
+    }
+    if ('customerTransferConfirmation' in payload)
+        update.customerTransferConfirmation = objectInput(payload.customerTransferConfirmation, '客户转移确认');
+    return { id: typedRequiredString(payload.id, '客户合同标识'), update };
+}
+function objectInput(value, label) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${label}必须是对象`);
+    return value;
+}
+function typedRequiredString(value, label) {
+    if (typeof value !== 'string')
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${label}必须是字符串`);
+    const result = value.trim();
+    if (!result)
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${label}不能为空`);
+    return result;
+}
+function nullableString(value, label) {
+    if (value == null)
+        return null;
+    if (typeof value !== 'string')
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${label}必须是字符串`);
+    return value.trim() || null;
+}
+function nullableDecimalString(value, label) {
+    if (value == null)
+        return null;
+    if (typeof value !== 'string' || !/^(?:0|[1-9]\d{0,15})(?:\.\d{1,4})?$/.test(value.trim()))
+        throw new DomainError(DomainErrorCodes.INVALID_INPUT, `${label}必须是最多四位小数的非负数字符串`);
+    return value.trim();
+}
 function stringValue(value) { const result = String(value ?? '').trim(); return result || undefined; }
 function numberValue(value, fallback) { const result = Number(value); return Number.isFinite(result) ? result : fallback; }
 function fileNameOf(file, input) { return String(file?.originalname ?? file?.name ?? input.fileName ?? 'uploaded-file'); }
@@ -216,7 +573,26 @@ function bufferOf(file) { const value = file?.buffer; if (Buffer.isBuffer(value)
     return value; if (value instanceof ArrayBuffer)
     return Buffer.from(value); if (ArrayBuffer.isView(value))
     return Buffer.from(value.buffer, value.byteOffset, value.byteLength); return null; }
-async function bufferFromPath(input) { const workspace = record(input.workspaceFile); const path = stringValue(workspace.workspacePath ?? workspace.filePath ?? input.workspacePath ?? input.filePath); return path ? readFile(path) : null; }
 async function readPackageFile(packageName, filePath) { const root = dirname(requireFromHere.resolve(`${packageName}/package.json`)); return readFile(join(root, filePath), 'utf8'); }
-function hsConfig() { return { baseUrl: process.env.TRADE_COMPLIANCE_HS_BASE_URL, timeoutMs: Number(process.env.TRADE_COMPLIANCE_HS_TIMEOUT_MS || 15000) }; }
+async function sourcePreview(fileName, buffer) {
+    const format = formatForSignature(buffer);
+    if (format === 'PDF' || format === 'PNG' || format === 'JPEG' || format === 'WEBP') {
+        return { previewKind: 'URL', fileName, mimeType: mimeTypeForFormat(format), base64: buffer.toString('base64') };
+    }
+    if (format === 'DOC' || format === 'DOCX' || format === 'XLS' || format === 'XLSX') {
+        const extracted = await extractDocumentText({ buffer, fileName, mimeType: mimeTypeForFormat(format), maxChars: 100000 });
+        const content = (extracted.chunks?.join('\n\n') ?? extracted.text ?? '').trim();
+        if (!content)
+            return { previewKind: 'UNAVAILABLE', fileName, message: '该 Office 文件未提取到可预览文本' };
+        return { previewKind: 'TEXT', fileName, content };
+    }
+    return { previewKind: 'UNAVAILABLE', fileName, message: '该源文件暂无法在线预览' };
+}
+function mimeTypeForFormat(format) {
+    const values = {
+        PDF: 'application/pdf', DOC: 'application/msword', DOCX: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', XLS: 'application/vnd.ms-excel', XLSX: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', PNG: 'image/png', JPEG: 'image/jpeg', WEBP: 'image/webp'
+    };
+    return values[format];
+}
+export function sanitizeIframeCss(css) { return css.replace(/<\/style/gi, (match) => `<\\/${match.slice(2)}`); }
 //# sourceMappingURL=workbench-view.provider.js.map