openyida 2026.10.20 → 2026.10.21

package/lib/print-template/builder.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const { object, fail, json, safe, label, content } = require('./model');
+const codes = require('./codes');
+const TYPES = new Set(['value', 'date', 'img', 'table', 'commonCheckbox', 'yidaApproveNode']);
+const FONTS = ['宋体', 'Arial', '新宋', '微软雅黑', '黑体'];
+// The native PDF renderer recognizes these editor values, not localized font labels.
+const FONT_VALUES = { 宋体: 'SimSun', Arial: 'Arial Unicode MS', 新宋: 'NSimSun', 微软雅黑: 'Microsoft YaHei', 黑体: 'SimHei' };
+
+/** Escape literal values in XHTML and native dynamic-field attributes. */
+function escape(value) {
+  return String(value ?? '').replace(/[&<>"']/g, ch => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' }[ch]));
+}
+
+/** Fail on unrecognized configuration instead of silently dropping requested features. */
+function keys(value, allowed, name) {
+  if (!object(value) || Object.keys(value).some(key => !allowed.includes(key))) { fail('INVALID_CONFIG', name); }
+}
+
+/** Build printable field groups from the same dictionaries consumed by the native editor. */
+function fields(raw, codeCapability = { enabled: false, reason: 'capability_unverified' }) {
+  if (!object(raw) || !Array.isArray(raw.formField) && !Array.isArray(raw.forms) || !Array.isArray(raw.systemField)) {
+    fail('INVALID_RESPONSE', 'print dictionary');
+  }
+  const normalize = (items, group, parent) => (items || []).map(item => ({ ...item, label: label(item.description), group,
+    ...(codes.eligible(item) ? { codeFormats: codeCapability.enabled ? [...codes.FORMATS] : [],
+      codeUnavailableReason: codeCapability.enabled ? null : codeCapability.reason } : {}),
+    parentKey: parent || null, children: normalize(item.children, group, item.key) }));
+  return [...normalize(raw.formField, 'form'), ...normalize(raw.systemField, 'system'),
+    ...normalize(raw.remarkRecord ? [raw.remarkRecord] : [], 'system'), ...normalize(raw.approvedNode, 'approval'),
+    ...(raw.forms || []).flatMap(form => normalize(form.formField, 'form', form.id).map(item => ({ ...item, formKey: form.id })))];
+}
+
+/** Resolve exact IDs or unambiguous names, scoped to a parent table when supplied. */
+function resolve(items, ref) {
+  if (typeof ref !== 'string' || !ref) { fail('INVALID_CONFIG', 'field reference'); }
+  const byId = items.filter(item => item.key === ref);
+  const matches = byId.length ? byId : items.filter(item => item.label === ref);
+  if (matches.length !== 1) { fail('FIELD_REFERENCE', ref, { candidates: matches.map(item => ({ key: item.key, label: item.label })) }); }
+  return matches[0];
+}
+
+/** Reject executable HTML/Velocity input; native macros remain data references only. */
+function html(value) {
+  if (typeof value !== 'string' || /<\s*\/?\s*(?:script|iframe|object|embed|form|link|meta|style)\b|\bon\w+\s*=|javascript\s*:|data\s*:|#\s*(?:set|evaluate|parse|include|foreach|if|macro)\b|\$!?\{/i.test(value)) {
+    fail('INVALID_CONFIG', 'static XHTML');
+  }
+  return value;
+}
+
+/** Validate a complete native body while preserving advanced native attributes verbatim. */
+function validateNative(raw, dictionary) {
+  const result = content(raw);
+  safe(result);
+  const attrs = result.termJsonAttr;
+  const entries = result.dictionaryList;
+  const ids = attrs.map(item => item?.id);
+  if (ids.some(id => typeof id !== 'string' || !/^[\w-]+$/.test(id)) || new Set(ids).size !== ids.length
+    || entries.length !== attrs.length || new Set(entries.map(item => item.id)).size !== entries.length) {
+    fail('INVALID_CONFIG', 'native component IDs');
+  }
+  const all = [];
+  const visit = items => items.forEach(item => { all.push(item); visit(item.children || []); });
+  visit(dictionary);
+  for (const attr of attrs) {
+    const entry = entries.find(item => item.id === attr.id);
+    const code = entry && codes.resolveNative(entry.key, all);
+    const labelKey = typeof attr.content === 'string' && /exttype="label"/.test(attr.content)
+      ? /fieldkey="([^"]+)"/.exec(attr.content)?.[1] : null;
+    if (!TYPES.has(attr.type) || !entry || entry.type !== attr.type || (code ? attr.type !== 'img' : !all.some(field => field.key === (labelKey || entry.key)))
+      || typeof attr.content !== 'string' || !result.termContents.includes(` #macro_${attr.id} `)) {
+      fail('INVALID_CONFIG', `native component: ${attr.id}`);
+    }
+    // Native placeholders use ${label} in disabled input values. They are never evaluated locally.
+    html(attr.content.replace(/\$!?\{[^}]*\}/g, 'FIELD'));
+    // Repeating tables keep child image keys inside the parent macro, outside dictionaryList.
+    for (const [input] of attr.content.matchAll(/<input\b[^>]*>/gi)) {
+      const key = /\bkey\s*=\s*(["'])(.*?)\1/i.exec(input)?.[2];
+      if (codes.resolveNative(key, all) && !/\bkeytype\s*=\s*(["'])img\1/i.test(input)) {
+        fail('INVALID_CONFIG', 'native code image');
+      }
+    }
+  }
+  const macros = [...result.termContents.matchAll(/#macro_([\w-]+)/g)].map(match => match[1]);
+  if (macros.some(id => !ids.includes(id))) { fail('INVALID_CONFIG', 'unresolved macro'); }
+  html(result.termContents.replace(/ #macro_[\w-]+ /g, 'FIELD'));
+  return { termContents: result.termContents, termJsonAttr: attrs, dictionaryList: entries };
+}
+
+/** Compile named sections into the existing editor's native macros, never browser-only placeholders. */
+function build(config, dictionary) {
+  keys(config, ['title', 'style', 'font', 'fontSize', 'width', 'blocks'], 'document');
+  const theme = config.style || 'document';
+  if (!['document', 'compact', 'formal'].includes(theme) || config.font !== undefined && !FONTS.includes(config.font)
+    || config.title !== undefined && typeof config.title !== 'string'
+    || config.fontSize !== undefined && (!Number.isFinite(config.fontSize) || config.fontSize < 8 || config.fontSize > 72)
+    || config.width !== undefined && (!Number.isFinite(config.width) || config.width < 160 || config.width > 2000)
+    || !Array.isArray(config.blocks) || !config.blocks.length) { fail('INVALID_CONFIG', 'document style / blocks'); }
+  const padding = theme === 'compact' ? '3px 5px' : '7px 9px';
+  const border = theme === 'formal' ? '#333333' : '#777777';
+  const cellStyle = `border:1px solid ${border};padding:${padding};vertical-align:top;`;
+  const tableStyle = `border-collapse:collapse;width:100%;border:1px solid ${border};`;
+  const termJsonAttr = [];
+  const dictionaryList = [];
+  let counter = 0;
+  const next = type => `${type}_${++counter}`;
+  const scalar = (field, options = {}, nested = false) => {
+    if (options.render !== undefined) { field = codes.transform(field, options.render); }
+    if (field.type === 'commonCheckbox') {
+      if (nested || !Array.isArray(field.children) || !field.children.length) { fail('UNSUPPORTED', `checkbox: ${field.label}`); }
+      const id = next('commonCheckbox');
+      const body = `<span id="${id}" key="${escape(field.key)}" contenteditable="false" class="render-commonCheckbox">${field.children.map(child => `<label key="${escape(child.key)}" keytype="${escape(child.type)}" keydescription="${escape(child.label)}">☐\${${escape(child.label)}}</label>`).join(' ')}</span>`;
+      termJsonAttr.push({ id, type: 'commonCheckbox', content: body });
+      dictionaryList.push({ id, type: 'commonCheckbox', key: field.key, description: field.label });
+      return ` #macro_${id} `;
+    }
+    if (!['value', 'date', 'img'].includes(field.type)) { fail('UNSUPPORTED', `${field.label}: ${field.type}`); }
+    const id = next(field.type);
+    let extra = '';
+    const width = options.width ?? (field.codeFormat === 'qrcode' ? 128 : field.codeFormat === 'barcode' ? 240 : undefined);
+    const height = options.height ?? (field.codeFormat === 'qrcode' ? 128 : field.codeFormat === 'barcode' ? 80 : undefined);
+    if (field.type === 'date') {
+      const format = options.format || 'yyyy-MM-dd';
+      if (!(field.children || []).some(child => child.key === format)) { fail('INVALID_CONFIG', `date format: ${format}`); }
+      extra += ` dateformat="${escape(format)}"`;
+    } else if (options.format !== undefined) { fail('INVALID_CONFIG', `format: ${field.label}`); }
+    if (width !== undefined || height !== undefined) {
+      if (field.type !== 'img' || [width, height].filter(v => v !== undefined).some(v => !Number.isFinite(v) || v <= 0 || v > 2000)) {
+        fail('INVALID_CONFIG', 'image dimensions');
+      }
+      extra += width ? ` width="${width}" td-width="${Number.isInteger(width) ? `${width}.0` : width}"` : '';
+      extra += height ? ` height="${height}" td-height="${Number.isInteger(height) ? `${height}.0` : height}"` : '';
+    }
+    const input = `<input id="${id}" key="${escape(field.key)}" keytype="${field.type}" type="text" disabled="disabled" class="render-${field.type}" style="border:0;background-color:transparent;color:inherit;font:inherit;" title="${escape(field.label)}(${escape(field.key)})" value="\${${escape(field.label)}}"${extra}/>`;
+    if (nested) { return input; }
+    termJsonAttr.push({ id, type: field.type, content: input });
+    dictionaryList.push({ id, type: field.type, key: field.key, description: field.label });
+    return ` #macro_${id} `;
+  };
+  const dynamic = (ref, options = {}) => {
+    const field = resolve(dictionary, ref);
+    if (field.type === 'table' || field.group === 'approval') {
+      if (['format', 'width', 'height', 'render'].some(key => options[key] !== undefined)) { fail('INVALID_CONFIG', 'table options'); }
+      const id = next(field.group === 'approval' ? 'yidaApproveNode' : 'table');
+      const selected = options.columns || field.children.map(child => child.key);
+      if (!Array.isArray(selected) || !selected.length) { fail('INVALID_CONFIG', 'table columns'); }
+      const columns = selected.map(col => {
+        if (typeof col === 'string') { col = { field: col }; }
+        keys(col, ['field', 'label', 'format', 'width', 'height', 'render'], 'table column');
+        return { ...col, definition: resolve(field.children, col.field) };
+      });
+      const row = `<tr class="render-table row">${columns.map(col => `<td style="${cellStyle}">${scalar(col.definition, col, true)}</td>`).join('')}</tr>`;
+      const head = `<tr class="render-table head">${columns.map(col => `<td style="${cellStyle}">${escape(col.label ?? col.definition.label)}</td>`).join('')}</tr>`;
+      const type = field.group === 'approval' ? 'yidaApproveNode' : 'table';
+      const body = type === 'table'
+        ? `<table id="${id}" key="${escape(field.key)}" class="render-table" style="${tableStyle}"><tbody>${head}${row}</tbody></table>`
+        : `<div id="${id}" key="${escape(field.key)}" class="render-yidaApproveNode"><div>${columns.map(col => `<p>${escape(col.label ?? col.definition.label)}：${scalar(col.definition, col, true)}</p>`).join('')}</div></div>`;
+      termJsonAttr.push({ id, type, content: body });
+      dictionaryList.push({ id, type, key: field.key, description: field.label });
+      return ` #macro_${id} `;
+    }
+    return scalar(field, options);
+  };
+  const blocks = config.blocks.map(block => {
+    if (!object(block)) { fail('INVALID_CONFIG', 'block'); }
+    if (block.type === 'heading' || block.type === 'text') {
+      keys(block, ['type', 'text', 'align'], block.type);
+      if (typeof block.text !== 'string' || block.align && !['left', 'center', 'right'].includes(block.align)) { fail('INVALID_CONFIG', block.type); }
+      const tag = block.type === 'heading' ? 'h2' : 'p';
+      return `<${tag} style="text-align:${block.align || 'left'};">${escape(block.text)}</${tag}>`;
+    }
+    if (block.type === 'fields') {
+      keys(block, ['type', 'fields', 'columns'], 'fields block');
+      const count = block.columns ?? 1;
+      if (![1, 2, 3, 4].includes(count) || !Array.isArray(block.fields) || !block.fields.length) { fail('INVALID_CONFIG', 'fields block'); }
+      const cells = block.fields.map(ref => {
+        const item = typeof ref === 'string' ? { field: ref } : ref;
+        keys(item, ['field', 'label', 'format', 'width', 'height', 'render'], 'field');
+        const field = resolve(dictionary, item.field);
+        if (field.type === 'table' || field.group === 'approval') { fail('INVALID_CONFIG', 'use table block'); }
+        return `<td style="${cellStyle}width:${100 / count}%;">${escape(item.label ?? field.label)}：${dynamic(item.field, item)}</td>`;
+      });
+      const rows = [];
+      for (let i = 0; i < cells.length; i += count) { rows.push(`<tr>${cells.slice(i, i + count).join('')}${`<td style="${cellStyle}"></td>`.repeat(Math.max(0, count - cells.slice(i, i + count).length))}</tr>`); }
+      return `<table style="${tableStyle}"><tbody>${rows.join('')}</tbody></table>`;
+    }
+    if (block.type === 'table' || block.type === 'field') {
+      keys(block, ['type', 'field', 'columns', 'format', 'width', 'height', 'render'], block.type);
+      const field = resolve(dictionary, block.field);
+      if (block.type === 'table' && field.type !== 'table' && field.group !== 'approval') { fail('INVALID_CONFIG', 'table field'); }
+      if (block.columns !== undefined && field.type !== 'table' && field.group !== 'approval') { fail('INVALID_CONFIG', 'columns require table'); }
+      return dynamic(block.field, block);
+    }
+    if (codes.FORMATS.includes(block.type)) {
+      keys(block, ['type', 'field', 'width', 'height'], block.type);
+      const width = block.width ?? (block.type === 'qrcode' ? 128 : 240);
+      const height = block.height ?? (block.type === 'qrcode' ? 128 : 80);
+      const macro = dynamic(block.field, { render: block.type, width, height });
+      return `<table style="border-collapse:collapse;width:${width}px;"><tbody><tr><td style="width:${width}px;height:${height}px;padding:0;border:0;">${macro}</td></tr></tbody></table>`;
+    }
+    if (block.type === 'html') {
+      keys(block, ['type', 'html'], 'html block');
+      // Static XHTML supports arbitrary arrangements; dynamic tokens must resolve to live fields.
+      const result = html(block.html).replace(/\{\{([^{}]+)\}\}/g, (_, ref) => dynamic(ref.trim()));
+      if (/\{\{|\}\}/.test(result)) { fail('INVALID_CONFIG', 'unclosed field token'); }
+      return result;
+    }
+    if (block.type === 'image') {
+      keys(block, ['type', 'url', 'width', 'height'], 'image block');
+      if (typeof block.url !== 'string' || !/^https:\/\//.test(block.url) || [block.width, block.height].filter(v => v !== undefined).some(v => !Number.isFinite(v) || v <= 0 || v > 2000)) { fail('INVALID_CONFIG', 'image'); }
+      return `<p><img src="${escape(block.url)}"${block.width ? ` width="${block.width}"` : ''}${block.height ? ` height="${block.height}"` : ''}/></p>`;
+    }
+    if (block.type === 'divider') { keys(block, ['type'], 'divider'); return '<hr/>'; }
+    fail('UNSUPPORTED', `block: ${block.type}`);
+  });
+  const title = config.title ? `<h1 style="text-align:center;">${escape(config.title)}</h1>` : '';
+  const termContents = `<div style="font-family:${FONT_VALUES[config.font || '宋体']};font-size:${config.fontSize || 14}px;line-height:1.6;${config.width ? `width:${config.width}px;` : ''}">${title}${blocks.join('<p></p>')}</div>`;
+  return validateNative({ termContents, termJsonAttr, dictionaryList }, dictionary);
+}
+
+/** Accept authored documents or complete native exports; partial native bodies are rejected. */
+function compile(raw, dictionary) {
+  if (object(raw) && Object.hasOwn(raw, 'document')) {
+    keys(raw, ['document'], 'config');
+    return build(raw.document, dictionary);
+  }
+  keys(raw, ['termContents', 'termJsonAttr', 'dictionaryList'], 'native config');
+  if (['termContents', 'termJsonAttr', 'dictionaryList'].some(key => !Object.hasOwn(raw, key))) { fail('INVALID_CONFIG', 'complete native config required'); }
+  return validateNative({ ...raw, termJsonAttr: json(raw.termJsonAttr, 'termJsonAttr'), dictionaryList: json(raw.dictionaryList, 'dictionaryList') }, dictionary);
+}
+
+module.exports = { fields, resolve, build, compile, validateNative, escape };

package/lib/print-template/codes.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const { fail, object, unwrap } = require('./model');
+const FORMATS = ['qrcode', 'barcode'];
+const PREFIXES = ['textField', 'numberField', 'selectField', 'radioField', 'serialNo'];
+const CODE_EDITIONS = new Set(['pro', 'vip', 'isv', 'hybrid_cloud']);
+
+/** Match the native editor's field-code whitelist, without enabling unrelated field types. */
+function eligible(field) {
+  return typeof field?.key === 'string' && PREFIXES.some(prefix => field.key.startsWith(prefix))
+    && !/\.(qrcode|barcode)$/.test(field.key);
+}
+
+/** Read the existing edition and rollout gate; never change entitlements or gray configuration. */
+async function capabilities(client) {
+  const results = await Promise.allSettled([
+    client.get('/query/commodity/getSimpleCommodityInfo.json', {}).then(response => unwrap(response, 'getSimpleCommodityInfo')),
+    client.get('/query/compromiseDing/orgInGray.json', { grayKey: 'yida_fe_print_support_qrcode' }).then(response => unwrap(response, 'orgInGray')),
+  ]);
+  const edition = results[0].status === 'fulfilled' && object(results[0].value)
+    ? String(results[0].value.corpVersion || '').toLowerCase() : '';
+  const gray = results[1].status === 'fulfilled' && typeof results[1].value === 'boolean' ? results[1].value : null;
+  const enabled = CODE_EDITIONS.has(edition) && gray === true;
+  return { enabled, edition, gray, reason: enabled ? null : !edition ? 'edition_unverified'
+    : !CODE_EDITIONS.has(edition) ? 'edition_not_supported' : gray === false ? 'feature_not_enabled' : 'feature_unverified' };
+}
+
+/** Derive the native .qrcode/.barcode image key from a live, eligible field. */
+function transform(field, format) {
+  if (!FORMATS.includes(format) || !eligible(field)) { fail('UNSUPPORTED', `field code: ${field?.label || field?.key}`); }
+  if (!field.codeFormats?.includes(format)) {
+    fail('CODE_UNAVAILABLE', `${format}: ${field.codeUnavailableReason || 'capability_unverified'}`);
+  }
+  return { ...field, key: `${field.key}.${format}`, label: `${field.label}.${format === 'qrcode' ? '二维码' : '条形码'}`, type: 'img', codeFormat: format };
+}
+
+/** Validate derived keys in native exports as strictly as authored code blocks. */
+function resolveNative(key, dictionary) {
+  const match = typeof key === 'string' && /^(.*)\.(qrcode|barcode)$/.exec(key);
+  if (!match) { return null; }
+  const field = dictionary.find(item => item.key === match[1]);
+  if (!field) { fail('FIELD_REFERENCE', match[1]); }
+  return transform(field, match[2]);
+}
+
+module.exports = { FORMATS, eligible, capabilities, transform, resolveNative };

package/lib/print-template/contract.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const readActions = ['list', 'inspect', 'fields', 'files'];
+const writeActions = ['create', 'copy', 'save', 'restore', 'settings', 'status', 'order', 'render'];
+const usage = 'print-template <list|inspect|fields|build|create|copy|save|restore|settings|status|order|render|files> <appType> <formUuid> [templateId] [--config <file>] [--scene <order|quotation|delivery|receipt|approval|codes>] [--bindings <file>] [--name <title>] [--expected-hash <hash>] [--backup <file>] [--out <file>] [--status START|STOP] [--instance <id>] [--page <n>] [--size <n>] [--allow-permission-change] [--json] | print-template <list|render> --detail-url <url> [--template-id <id>] [--json]';
+
+/** Shared manifest metadata keeps ordinary and managed agents on the same native contract. */
+const printTemplateCommand = ['print-template', ['print-template'], usage, 'print_template.description', {
+  output: 'json',
+  managedRun: { scope: 'actions', actions: {
+    ...Object.fromEntries([...readActions, 'build'].map(action => [action, { scope: 'app', appPosition: 1 }])),
+    ...Object.fromEntries(writeActions.filter(action => action !== 'render').map(action => [action,
+      { scope: 'app', appPosition: 1, mutation: { operation: 'update_form', formUuidPosition: 2 } }])),
+    // PDF generation is explicit and may consume storage; managed app runs cannot invoke it.
+    render: { scope: 'denied', reason: 'native_pdf_generation' },
+  } },
+  examples: ['openyida print-template list --detail-url "https://tenant.aliwork.com/APP_XXX/formDetail/FORM_XXX?formInstId=FINST_XXX" --json',
+    'openyida print-template render --detail-url "https://tenant.aliwork.com/APP_XXX/formDetail/FORM_XXX?formInstId=FINST_XXX" --template-id 123 --json',
+    'openyida print-template fields APP_XXX FORM_XXX --json',
+    'openyida print-template build APP_XXX FORM_XXX --scene quotation --bindings quote-fields.json --out quote.json --json',
+    'openyida print-template create APP_XXX FORM_XXX --name "报价单" --config quote.json --json',
+    'openyida print-template save APP_XXX FORM_XXX 123 --config quote.json --expected-hash <inspect-hash> --json'],
+  notes: ['Native rich-text YiDA printing only; Word, DingDang and government printing use different editors. build compiles a named-field document or validates a complete native body, without saving it. build --scene selects one of six reusable samples and --bindings maps semantic roles to actual field names/IDs before validation. create --config validates first, creates and saves content; failures after creation expose createdTemplateId and must be resumed with inspect/save instead of repeated create. qrcode/barcode blocks and field/column render options use native dynamic image keys, with validated field prefixes, current edition and feature availability. fields reports codeFormats; barcode values must follow native character limits and are never silently rewritten. inspect --out exports a full snapshot; restore restores its content only to the same target. save is immediately effective, with no separate publish action. Hashes are required for updates; body saves also send the native gmtModified concurrency token when present. Every remote mutation backs up first, never retries, and verifies readback. Uncertain create/copy results must be inspected before retrying. settings preserves untranslated locales and does not change roleData unless supplied with --allow-permission-change. Built-in default template body cannot be edited. render requests one native PDF and returns a file ID, not proof of generation or physical printing; files lists generation records. list --instance and --detail-url use the runtime record-authorized template list instead of the administration list; render uses that same list and never reads an admin-only template body. URL mode only accepts known native detail routes and the authenticated origin; template choice is explicit. It prints record data through native templates, not arbitrary website pixels. No edition/quota changes. Custom CSS, fixed pages, paper size, margins, headers/footers and automatic totals are not guaranteed by this legacy editor.'],
+}];
+
+const printTemplateEffects = { mutates_yida: true, mutates_local: true, read_actions: readActions,
+  mutating_actions: ['build', ...writeActions], note: 'build only writes an optional local output; inspect/fields write local exports only with --out.' };
+const printTemplatePermission = { preauthorized_actions: ['build', 'create', 'copy', 'save', 'restore', 'status', 'order'],
+  ask_actions: ['settings', 'render'] };
+
+module.exports = { printTemplateCommand, printTemplateEffects, printTemplatePermission, usage };

package/lib/print-template/detail.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const { fail } = require('./model');
+
+/** Parse native record links as identifiers only; never fetch arbitrary URLs or forward their query. */
+function parse(value) {
+  let url;
+  try { url = new URL(value); } catch (_) { fail('INVALID_CONFIG', 'detail URL'); }
+  if (!['https:', 'http:'].includes(url.protocol) || url.username || url.password || url.hash) { fail('INVALID_CONFIG', 'native detail URL'); }
+  for (const key of ['appType', 'formUuid', 'formInstId', 'activityId']) {
+    if (url.searchParams.getAll(key).length > 1) { fail('INVALID_CONFIG', `duplicate ${key}`); }
+  }
+  const modern = /^\/(APP_[\w-]+)\/(formDetail|processDetail)\/(FORM[_-][\w-]+)\/?$/.exec(url.pathname);
+  const legacy = /^\/alibaba\/(?:web|mobile)\/(APP_[\w-]+)\/inst\/(formEdit|taskDetail)\.html$/.exec(url.pathname);
+  if (!modern && !legacy) { fail('UNSUPPORTED', 'native formDetail/processDetail link required'); }
+  const appType = (modern || legacy)[1];
+  const formUuid = modern ? modern[3] : url.searchParams.get('formUuid');
+  const instance = url.searchParams.get('formInstId');
+  const activityId = url.searchParams.get('activityId');
+  if (!/^FORM[_-][\w-]+$/.test(formUuid || '') || !/^[\w-]+$/.test(instance || '')
+    || activityId !== null && !/^[\w-]+$/.test(activityId)
+    || url.searchParams.has('appType') && url.searchParams.get('appType') !== appType
+    || url.searchParams.has('formUuid') && url.searchParams.get('formUuid') !== formUuid) { fail('INVALID_CONFIG', 'detail target'); }
+  return { appType, formUuid, instance, ...(activityId ? { activityId } : {}), origin: url.origin,
+    kind: modern ? modern[2] : legacy[2] === 'formEdit' ? 'formDetail' : 'processDetail' };
+}
+
+/** Refuse cross-organization routing; authenticate to the link's environment before printing. */
+function verifyOrigin(target, client) {
+  const base = client.getAuthRef?.()?.baseUrl;
+  let origin;
+  try { origin = new URL(base).origin; } catch (_) { fail('TARGET_MISMATCH', 'authenticated origin unavailable'); }
+  if (origin !== target.origin) { fail('TARGET_MISMATCH', 'detail URL origin differs from authenticated environment'); }
+}
+
+module.exports = { parse, verifyOrigin };

package/lib/print-template/model.js

@@ -0,0 +1,97 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { CliError } = require('../core/cli-error');
+const { t } = require('../core/i18n');
+const { resolveProjectRoot } = require('../core/utils');
+
+const object = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/** Fail with a stable code; platform failures retain their native diagnostic. */
+function fail(code, detail, details) {
+  throw new CliError(t('print_template.error', detail), { code: `PRINT_TEMPLATE_${code}`, details });
+}
+
+/** Parse JSON strings used by the native print editor without evaluating them. */
+function json(value, label) {
+  try { return typeof value === 'string' ? JSON.parse(value) : value; }
+  catch (_) { return fail('INVALID_CONFIG', label); }
+}
+
+/** Reject prototype keys recursively, including imported native configurations. */
+function safe(value) {
+  if (!value || typeof value !== 'object') { return; }
+  for (const key of Object.keys(value)) {
+    if (['__proto__', 'constructor', 'prototype'].includes(key)) { fail('INVALID_CONFIG', key); }
+    safe(value[key]);
+  }
+}
+
+/** Normalize translated labels without discarding the original locale object. */
+function label(value) {
+  let parsed = value;
+  if (typeof value === 'string') {
+    try { parsed = JSON.parse(value); } catch (_) { return value; }
+  }
+  return object(parsed) ? parsed.zh_CN || parsed.en_US || parsed.key || '' : String(parsed ?? '');
+}
+
+/** Canonical object key ordering for stale-edit fingerprints. */
+function stable(value) {
+  if (Array.isArray(value)) { return value.map(stable); }
+  return object(value) ? Object.fromEntries(Object.keys(value).sort().map(key => [key, stable(value[key])])) : value;
+}
+
+/** Compare authored values while allowing the server to add nullable dictionary metadata. */
+function matches(expected, actual) {
+  if (Array.isArray(expected)) { return Array.isArray(actual) && actual.length === expected.length && expected.every((value, i) => matches(value, actual[i])); }
+  if (object(expected)) { return object(actual) && Object.entries(expected).every(([key, value]) => matches(value, actual[key])); }
+  return expected === actual;
+}
+
+/** Normalize only the native content fields; missing content means an unsaved template. */
+function content(raw) {
+  if (!object(raw)) { fail('INVALID_RESPONSE', 'template content'); }
+  if (!Object.keys(raw).length) { return { termContents: '', termJsonAttr: [], dictionaryList: [], gmtModified: null }; }
+  const result = { ...raw, termJsonAttr: json(raw.termJsonAttr ?? [], 'termJsonAttr'),
+    dictionaryList: json(raw.dictionaryList ?? [], 'dictionaryList') };
+  if (typeof result.termContents !== 'string' || !Array.isArray(result.termJsonAttr) || !Array.isArray(result.dictionaryList)) {
+    fail('INVALID_RESPONSE', 'termContents / termJsonAttr / dictionaryList');
+  }
+  safe(result);
+  return result;
+}
+
+/** Hash metadata and body together, including the server concurrency timestamp. */
+function hash(snapshot) {
+  return crypto.createHash('sha256').update(JSON.stringify(stable({ template: snapshot.template, content: snapshot.content }))).digest('hex');
+}
+
+/** Write exports/backups exclusively and keep business configuration private on disk. */
+function write(value, filename, kind = 'backup') {
+  const output = filename ? path.resolve(filename) : path.join(resolveProjectRoot().projectRoot,
+    '.cache', 'openyida', 'print-template', `${kind}-${Date.now()}-${crypto.randomUUID()}.json`);
+  fs.mkdirSync(path.dirname(output), { recursive: true });
+  fs.writeFileSync(output, JSON.stringify(value, null, 2) + '\n', { flag: 'wx', mode: 0o600 });
+  return output;
+}
+
+/** Load explicit user-authored input; never consume arbitrary files as instructions. */
+function read(filename) {
+  const result = json(fs.readFileSync(path.resolve(filename), 'utf8'), filename);
+  safe(result);
+  return result;
+}
+
+/** Strictly recognize native success envelopes, including auth sentinels and false payloads. */
+function unwrap(response, endpoint) {
+  if (!response || response.success !== true || response.__needLogin || response.__csrfExpired || response.content === false) {
+    fail('API_ERROR', response?.errorMsg || response?.message || endpoint,
+      { endpoint, platformErrorCode: response?.errorCode, needLogin: !!response?.__needLogin });
+  }
+  return response.content;
+}
+
+module.exports = { object, fail, json, safe, label, stable, matches, content, hash, write, read, unwrap };