@stackonward/cli 0.0.1 → 1.0.0

package/dist/resources/templates/go-backend/api/openapi/tooling/route_contract.mjs

@@ -0,0 +1,156 @@
+import { operationEntries } from './project.mjs';
+
+export function routeContract(document) {
+  const routes = operationEntries(document).map(({ method, operation, path, pathItem }) => {
+    const parameters = [...(pathItem.parameters ?? []), ...(operation.parameters ?? [])]
+      .map((parameter) => resolveParameter(document, parameter));
+    validatePathParameters(path, parameters);
+    if (path.includes('*')) throw new Error(`OpenAPI business path cannot contain a wildcard: ${path}`);
+    return { method: method.toUpperCase(), operation_id: operation.operationId, path, parameters };
+  });
+  const identities = new Set();
+  for (const route of routes) {
+    const identity = `${route.method} ${route.path}`;
+    if (identities.has(identity)) throw new Error(`duplicate route contract: ${identity}`);
+    identities.add(identity);
+  }
+  validateAmbiguousRoutes(routes);
+  return routes.map(({ method, operation_id, path }) => ({ method, operation_id, path }));
+}
+
+function resolveParameter(document, parameter) {
+  if (!parameter?.$ref) return parameter;
+  const match = /^#\/components\/parameters\/([^/]+)$/.exec(parameter.$ref);
+  if (!match) throw new Error(`route contract contains unsupported parameter reference: ${parameter.$ref}`);
+  const name = match[1].replaceAll('~1', '/').replaceAll('~0', '~');
+  const resolved = document.components?.parameters?.[name];
+  if (!resolved || resolved.$ref) throw new Error(`route contract cannot resolve parameter reference: ${parameter.$ref}`);
+  return resolved;
+}
+
+export function validateRouteExclusions(exclusions) {
+  for (const exclusion of exclusions ?? []) {
+    if (!exclusion.startsWith('/') || /^\/(api|admin|internal)(\/|$)/.test(exclusion)) {
+      throw new Error(`forbidden route exclusion: ${exclusion}`);
+    }
+  }
+}
+
+export function reserveStaticRouteSegments(paths) {
+  const entries = Object.entries(paths ?? {});
+  for (let leftIndex = 0; leftIndex < entries.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < entries.length; rightIndex += 1) {
+      const [leftPath, leftItem] = entries[leftIndex];
+      const [rightPath, rightItem] = entries[rightIndex];
+      const leftSegments = pathSegments(leftPath);
+      const rightSegments = pathSegments(rightPath);
+      if (leftSegments.length !== rightSegments.length) continue;
+      if (leftSegments.some((segment, index) => !isParameterSegment(segment) && !isParameterSegment(rightSegments[index]) && segment !== rightSegments[index])) continue;
+      for (const method of Object.keys(leftItem).filter((key) => rightItem[key] && !['parameters'].includes(key))) {
+        if (!leftItem[method]?.responses || !rightItem[method]?.responses) continue;
+        leftSegments.forEach((leftSegment, index) => {
+          const rightSegment = rightSegments[index];
+          if (isParameterSegment(leftSegment) && !isParameterSegment(rightSegment)) excludePathValue(leftItem, method, leftSegment, rightSegment);
+          if (!isParameterSegment(leftSegment) && isParameterSegment(rightSegment)) excludePathValue(rightItem, method, rightSegment, leftSegment);
+        });
+      }
+    }
+  }
+  return paths;
+}
+
+function validatePathParameters(path, parameters) {
+  const declared = new Map(parameters.filter((parameter) => parameter.in === 'path').map((parameter) => [parameter.name, parameter]));
+  const templated = [...path.matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]);
+  for (const name of templated) {
+    const parameter = declared.get(name);
+    if (!parameter || parameter.required !== true) throw new Error(`path parameter ${name} must be declared and required for ${path}`);
+  }
+  for (const name of declared.keys()) if (!templated.includes(name)) throw new Error(`path parameter ${name} is not present in ${path}`);
+}
+
+function excludePathValue(pathItem, method, parameterSegment, value) {
+  const name = parameterSegment.slice(1, -1);
+  const parameters = [...(pathItem.parameters ?? []), ...(pathItem[method].parameters ?? [])];
+  const parameter = parameters.find((candidate) => candidate.in === 'path' && candidate.name === name);
+  if (!parameter) throw new Error(`path parameter ${name} is missing while reserving static route value`);
+  parameter.schema.not ??= { enum: [] };
+  parameter.schema.not.enum ??= [];
+  if (!parameter.schema.not.enum.includes(value)) parameter.schema.not.enum.push(value);
+  parameter.schema.not.enum.sort();
+}
+
+function isParameterSegment(segment) {
+  return /^\{[^{}]+\}$/.test(segment);
+}
+
+function validateAmbiguousRoutes(routes) {
+  const errors = [];
+  for (let leftIndex = 0; leftIndex < routes.length; leftIndex += 1) {
+    for (let rightIndex = leftIndex + 1; rightIndex < routes.length; rightIndex += 1) {
+      const left = routes[leftIndex];
+      const right = routes[rightIndex];
+      if (left.method !== right.method || left.path === right.path) continue;
+      if (routesOverlap(left, right)) {
+        errors.push(`${left.method} ${left.path} and ${right.path}`);
+      }
+    }
+  }
+  if (errors.length > 0) throw new Error(`ambiguous routes:\n- ${errors.join('\n- ')}`);
+}
+
+function routesOverlap(left, right) {
+  const leftSegments = pathSegments(left.path);
+  const rightSegments = pathSegments(right.path);
+  if (leftSegments.length !== rightSegments.length) return false;
+  return leftSegments.every((leftSegment, index) => segmentsOverlap(
+    leftSegment,
+    rightSegments[index],
+    left.parameters,
+    right.parameters,
+  ));
+}
+
+function pathSegments(path) {
+  return path.split('/').slice(1);
+}
+
+function segmentsOverlap(left, right, leftParameters, rightParameters) {
+  const leftName = parameterName(left);
+  const rightName = parameterName(right);
+  if (!leftName && !rightName) return left === right;
+  if (leftName && rightName) return parameterSchemasOverlap(parameterSchema(leftName, leftParameters), parameterSchema(rightName, rightParameters));
+  if (leftName) return schemaAcceptsLiteral(parameterSchema(leftName, leftParameters), right);
+  return schemaAcceptsLiteral(parameterSchema(rightName, rightParameters), left);
+}
+
+function parameterName(segment) {
+  return /^\{([^{}]+)\}$/.exec(segment)?.[1] ?? null;
+}
+
+function parameterSchema(name, parameters) {
+  return parameters.find((parameter) => parameter.in === 'path' && parameter.name === name)?.schema ?? {};
+}
+
+function schemaAcceptsLiteral(schema, literal) {
+  if (Array.isArray(schema.not?.enum) && schema.not.enum.some((value) => String(value) === literal)) return false;
+  if (Object.hasOwn(schema, 'const')) return String(schema.const) === literal;
+  if (Array.isArray(schema.enum)) return schema.enum.some((value) => String(value) === literal);
+  const types = Array.isArray(schema.type) ? schema.type : [schema.type].filter(Boolean);
+  if (types.includes('integer') && !/^-?\d+$/.test(literal)) return false;
+  if (types.includes('number') && !Number.isFinite(Number(literal))) return false;
+  if (schema.format === 'uuid' && !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(literal)) return false;
+  if (schema.pattern) return new RegExp(schema.pattern).test(literal);
+  return true;
+}
+
+function parameterSchemasOverlap(left, right) {
+  if (Array.isArray(left.enum) && Array.isArray(right.enum)) {
+    return left.enum.some((value) => right.enum.includes(value));
+  }
+  const leftTypes = new Set(Array.isArray(left.type) ? left.type : [left.type].filter(Boolean));
+  const rightTypes = new Set(Array.isArray(right.type) ? right.type : [right.type].filter(Boolean));
+  if (leftTypes.size === 0 || rightTypes.size === 0) return true;
+  if ([...leftTypes].some((type) => rightTypes.has(type))) return true;
+  return (leftTypes.has('integer') && rightTypes.has('number')) || (leftTypes.has('number') && rightTypes.has('integer'));
+}

package/dist/resources/templates/go-backend/api/openapi/tooling/runtime_conformance.mjs

@@ -0,0 +1,193 @@
+import { spawnSync } from 'node:child_process';
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { relative, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { contractArtifacts, readCurrentManifest } from './git_artifact_history.mjs';
+import { apiRoot, canonicalJSON, readRegistry } from './project.mjs';
+
+const backendRoot = resolve(apiRoot, '../..');
+const redoclyBin = resolve(apiRoot, 'node_modules/.bin/redocly');
+
+export async function runRuntimeConformance({ inputs, outputRoot, servers }) {
+  const registry = await readRegistry();
+  const normalizedServers = parseServerMap(servers, registry.services.map((service) => service.id));
+  const normalizedInputs = parseInputMap(inputs, registry.services.map((service) => service.id));
+  const artifactManifest = await readCurrentManifest();
+  const destination = resolve(outputRoot ?? resolve(backendRoot, 'tmp/openapi-conformance'));
+  await rm(destination, { force: true, recursive: true });
+  await mkdir(destination, { recursive: true });
+
+  const services = [];
+  for (const service of registry.services) {
+    const workflowPath = resolve(apiRoot, service.runtime_conformance);
+    const rawReportPath = resolve(destination, `${service.id}.respect.json`);
+    const result = executeRespect({
+      inputs: normalizedInputs[service.id],
+      reportPath: rawReportPath,
+      server: normalizedServers[service.id],
+      workflowPath,
+    });
+    const rawReport = await readReport(rawReportPath);
+    const matches = contractArtifacts(artifactManifest).filter((entry) => entry.service === service.id && entry.audience === 'internal');
+    if (matches.length !== 1) throw new Error(`expected one internal artifact manifest entry for ${service.id}; found ${matches.length}`);
+    const [artifact] = matches;
+    services.push({
+      artifact_sha256: artifact.sha256,
+      exit_code: result.status,
+      raw_report: relative(backendRoot, rawReportPath).replaceAll('\\', '/'),
+      request_count: reportRequestCount(rawReport),
+      server: normalizedServers[service.id],
+      service: service.id,
+      status: rawReport?.status ?? 'error',
+      workflow_count: reportWorkflowCount(rawReport),
+      workflow_file: service.runtime_conformance,
+    });
+  }
+
+  const report = {
+    generated_at: new Date().toISOString(),
+    schema_version: 1,
+    service_count: services.length,
+    services,
+    status: services.every((service) => service.exit_code === 0 && service.status === 'success') ? 'success' : 'error',
+  };
+  const reportPath = resolve(destination, 'runtime-conformance-report.json');
+  await writeFile(reportPath, canonicalJSON(report));
+  if (report.status !== 'success') {
+    const failed = services.filter((service) => service.exit_code !== 0 || service.status !== 'success');
+    throw new Error(`runtime conformance failed for: ${failed.map((service) => service.service).join(', ')}`);
+  }
+  return { report, reportPath };
+}
+
+export function parseServerMap(value, serviceIds) {
+  let parsed = value;
+  if (typeof value === 'string') {
+    try {
+      parsed = JSON.parse(value);
+    } catch (error) {
+      throw new Error(`ONEX_OPENAPI_CONFORMANCE_SERVERS must be valid JSON: ${error.message}`);
+    }
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('ONEX_OPENAPI_CONFORMANCE_SERVERS must be a JSON object');
+  }
+  const expected = new Set(serviceIds);
+  const unknown = Object.keys(parsed).filter((service) => !expected.has(service));
+  const missing = serviceIds.filter((service) => !Object.hasOwn(parsed, service));
+  if (unknown.length > 0 || missing.length > 0) {
+    throw new Error(`runtime conformance server map mismatch; missing=${missing.join(',') || '-'} unknown=${unknown.join(',') || '-'}`);
+  }
+  return Object.fromEntries(serviceIds.map((service) => [service, normalizeServerURL(parsed[service], service)]));
+}
+
+export function parseInputMap(value, serviceIds) {
+  let parsed = value;
+  if (typeof value === 'string') {
+    try {
+      parsed = JSON.parse(value);
+    } catch (error) {
+      throw new Error(`ONEX_OPENAPI_CONFORMANCE_INPUTS must be valid JSON: ${error.message}`);
+    }
+  }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('ONEX_OPENAPI_CONFORMANCE_INPUTS must be a JSON object');
+  }
+  const expected = new Set(serviceIds);
+  const unknown = Object.keys(parsed).filter((service) => !expected.has(service));
+  if (unknown.length > 0) {
+    throw new Error(`runtime conformance input map contains unknown services: ${unknown.join(',')}`);
+  }
+  const normalized = {};
+  for (const [service, serviceInputs] of Object.entries(parsed)) {
+    if (!serviceInputs || typeof serviceInputs !== 'object' || Array.isArray(serviceInputs)) {
+      throw new Error(`${service} conformance inputs must be a JSON object`);
+    }
+    normalized[service] = serviceInputs;
+  }
+  return normalized;
+}
+
+export function buildRespectChildEnv(inputs, baseEnv = process.env) {
+  const childEnv = { ...baseEnv, FORCE_COLOR: '0', NO_COLOR: '1' };
+  delete childEnv.ONEX_OPENAPI_CONFORMANCE_INPUTS;
+  delete childEnv.REDOCLY_CLI_RESPECT_INPUT;
+  if (inputs !== undefined) childEnv.REDOCLY_CLI_RESPECT_INPUT = JSON.stringify(inputs);
+  return childEnv;
+}
+
+function executeRespect({ inputs, reportPath, server, workflowPath }) {
+  const result = spawnSync(redoclyBin, [
+    'respect',
+    workflowPath,
+    '--server',
+    `service=${server}`,
+    '--json-output',
+    reportPath,
+    '--max-steps',
+    '2000',
+    '--max-fetch-timeout',
+    '40000',
+    '--execution-timeout',
+    '3600000',
+  ], {
+    cwd: apiRoot,
+    encoding: 'utf8',
+    env: buildRespectChildEnv(inputs),
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.error) throw result.error;
+  return { status: result.status ?? 1 };
+}
+
+function normalizeServerURL(value, service) {
+  if (typeof value !== 'string') throw new Error(`${service} conformance server must be a URL string`);
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${service} conformance server is not a valid URL`);
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new Error(`${service} conformance server must be an HTTP(S) base URL without credentials, query, or fragment`);
+  }
+  return url.toString().replace(/\/$/, '');
+}
+
+async function readReport(path) {
+  try {
+    return JSON.parse(await readFile(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function reportRequestCount(report) {
+  return Object.values(report?.files ?? {}).reduce((total, file) => total + (file.totalRequests ?? 0), 0);
+}
+
+function reportWorkflowCount(report) {
+  return Object.values(report?.files ?? {}).reduce((total, file) => total + (file.executedWorkflows?.length ?? 0), 0);
+}
+
+function cliServerMap() {
+  const value = process.env.ONEX_OPENAPI_CONFORMANCE_SERVERS;
+  if (!value) throw new Error('ONEX_OPENAPI_CONFORMANCE_SERVERS is required');
+  return value;
+}
+
+function cliInputMap() {
+  const value = process.env.ONEX_OPENAPI_CONFORMANCE_INPUTS;
+  if (!value) throw new Error('ONEX_OPENAPI_CONFORMANCE_INPUTS is required');
+  return value;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  const { reportPath } = await runRuntimeConformance({
+    inputs: cliInputMap(),
+    servers: cliServerMap(),
+  });
+  process.stdout.write(`Runtime conformance report: ${reportPath}\n`);
+}

package/dist/resources/templates/go-backend/api/openapi/tooling/scalar_asset_localization.mjs

@@ -0,0 +1,164 @@
+export const scalarAssetLocale = 'zh-CN';
+export const scalarAssetLocalizationRevision = 'onex-zh-CN-v1';
+
+const sectionLabels = '{All:`全部`,Auth:`身份验证`,Variables:`路径参数`,Cookies:`Cookie`,Headers:`请求头`,Query:`查询参数`,Body:`请求体`}';
+
+const localizationRules = Object.freeze([
+  replacement('`Selected Auth Type:`', '`已选身份验证方式：`'),
+  replacement('` Multiple `', '` 多种 `'),
+  replacement('`Auth Types Selected`', '`已选择多种身份验证方式`'),
+  replacement('R(`span`,{class:`sr-only`},`Select`,-1),m[6]||=z(` Auth Type `,-1)', 'R(`span`,{class:`sr-only`},`选择`,-1),m[6]||=z(`身份验证方式`,-1)'),
+  replacement('` No authentication selected `', '` 未选择身份验证方式 `'),
+  replacement('`Request Example for`', '`请求示例：`'),
+  replacement('`API Client`', '`API 调试客户端`'),
+  replacement('options:{hideOperationDefaultExamples:e.layout===`modal`}', 'options:{hideOperationDefaultExamples:e.layout===`modal`,labels:{closeGroup:`关闭分组`,httpMethod:`HTTP 方法`,openGroup:`打开分组`}}'),
+  replacement('label:`Search`,size:`sm`,onClick', 'label:`搜索`,size:`sm`,onClick'),
+  replacement('autofocus:e.layout!==`web`},null,8,[`modelValue`,`autofocus`])', 'autofocus:e.layout!==`web`,label:`输入搜索关键词`,placeholder:`搜索...`},null,8,[`modelValue`,`autofocus`])'),
+  replacement('k(t.value?`Hide`:`Show`)+` sidebar`', 'k(t.value?`隐藏侧边栏`:`显示侧边栏`)'),
+  replacement('`Server:`', '`服务器：`', 3),
+  replacement('`Copy URL`', '`复制 URL`', 2),
+  replacement('`Send`', '`发送`', 2),
+  replacement('` Send `+k(e.method)+` request to `', '`发送 `+k(e.method)+` 请求到 `', 2),
+  replacement('` Open API Client `', '` 打开 API 调试客户端 `'),
+  replacement('`Close Client`', '`关闭客户端`', 3),
+  replacement('`Request: ${', '`请求：${'),
+  replacement('`Operation settings`', '`操作设置`'),
+  replacement('default:M(()=>[z(k(n),1)])', `default:M(()=>[z(k((${sectionLabels})[n]??n),1)])`),
+  replacement('R(`span`,uQe,k(t.value),1)', `R(\`span\`,uQe,k((${sectionLabels})[t.value]??t.value),1)`),
+  replacement('title:`Authentication`', 'title:`身份验证`', 3),
+  replacement('title:`Variables`', 'title:`路径参数`'),
+  replacement('title:`Cookies`', 'title:`Cookie`'),
+  replacement('title:`Headers`', 'title:`请求头`'),
+  replacement('title:`Query Parameters`', 'title:`查询参数`'),
+  replacement('title:`Request Body`', 'title:`请求体`'),
+  replacement('text:t?`Optional`:`Required`', 'text:t?`可选`:`必需`'),
+  replacement('s.value.text===`Required`', 's.value.text===`必需`'),
+  replacement('content:"Required"', 'content:"必需"'),
+  replacement('` Bearer Token `', '` Bearer 令牌 `'),
+  replacement('placeholder:`Token`', 'placeholder:`令牌`'),
+  replacement('label:i.value?`Show Password`:`Hide Password`', 'label:i.value?`显示密码`:`隐藏密码`'),
+  replacement('k(e.label)+` Enabled`', '(e.label?k(e.label)+` `:``)+`已启用`'),
+  replacement('k(e.label)+` Key`', '(e.label?k(e.label)+` `:``)+`键`'),
+  replacement('k(e.label)+` Value`', '(e.label?k(e.label)+` `:``)+`值`'),
+  replacement('`${e.label} Key`', '(e.label?e.label+` `:``)+`键`'),
+  replacement('`${e.label} Value`', '(e.label?e.label+` `:``)+`值`'),
+  replacement('placeholder:`Key`', 'placeholder:`键`'),
+  replacement('placeholder:`Value`', 'placeholder:`值`', 2),
+  replacement('n.value?`Input is invalid`:`More Information`', 'n.value?`输入无效`:`更多信息`'),
+  replacement('content:`Clear optional parameters`', 'content:`清除可选参数`'),
+  replacement('label:`Clear Value`', 'label:`清除值`'),
+  replacement('label:e.clearLabel??`Clear Search`', 'label:e.clearLabel??`清除搜索`'),
+  replacement('label:`Clear Search`', 'label:`清除搜索`'),
+  replacement('` Clear `', '` 清除 `', 3),
+  replacement('`All `+k(e.title)', '`全部`+k(e.title)'),
+  replacement('`Code Snippet`', '`代码片段`'),
+  replacement('` (Collapsed) `', '`（已折叠）`'),
+  replacement('`Request Headers`', '`请求头`'),
+  replacement('`Response Headers`', '`响应头`'),
+  replacement('"aria-label":`Response`', '"aria-label":`响应`'),
+  replacement('` Response `', '` 响应 `'),
+  replacement('` Send Request `', '` 发送请求 `'),
+  replacement('`Header Key`', '`请求头名称`'),
+  replacement('`Header Value`', '`请求头值`'),
+  replacement('`Cookie Name`', '`Cookie 名称`'),
+  replacement('`Cookie Value`', '`Cookie 值`'),
+  replacement('` No cookies `', '` 无 Cookie `'),
+  replacement('` No headers `', '` 无请求头 `'),
+  replacement('`Global cookies are shared across the whole workspace. Click to navigate.`', '`全局 Cookie 在整个工作区共享。点击可前往管理。`'),
+  replacement('`This is a readonly property and you can not modify it! If you want to change it you have to override it or disable it using the checkbox`', '`这是只读属性，不能直接修改。如需更改，请覆盖该值或通过复选框禁用。`'),
+  replacement('`Computed at request execution`', '`在请求执行时计算`'),
+  replacement('`Select File`', '`选择文件`', 2),
+  replacement('`No Body`', '`无请求体`', 2),
+  replacement('` Delete `', '` 删除 `', 3),
+  replacement('label:`Delete ${', 'label:`删除 ${', 2),
+  replacement('label:`Edit ${', 'label:`编辑 ${'),
+  replacement('`Variable suggestions`', '`变量建议`'),
+  replacement('`Request Name`', '`请求名称`'),
+  replacement('`Path parameters must have values.`', '`路径参数必须填写值。`'),
+  replacement('` Discovery URL `', '` 发现文档 URL `'),
+  replacement('` Fetch Configuration `', '` 获取配置 `'),
+  replacement('` Access Token `', '` 访问令牌 `'),
+  replacement('` Refresh URL `', '` 刷新 URL `'),
+  replacement('` Refresh `', '` 刷新 `'),
+  replacement('` Auth URL `', '` 授权 URL `'),
+  replacement('` Token URL `', '` 令牌 URL `'),
+  replacement('` Redirect URL `', '` 重定向 URL `'),
+  replacement('` Username `', '` 用户名 `', 2),
+  replacement('` Password `', '` 密码 `', 2),
+  replacement('` Client ID `', '` 客户端 ID `'),
+  replacement('` Client Secret `', '` 客户端密钥 `'),
+  replacement('` Use PKCE `', '` 使用 PKCE `'),
+  replacement('` Credentials Location `', '` 凭证位置 `'),
+  replacement('` Authorize `', '` 授权 `', 2),
+  replacement('`Optional redirect URL`', '`可选的重定向 URL`'),
+  replacement('` Name `', '` 名称 `'),
+  replacement('` Value `', '` 值 `'),
+  replacement('` Scopes Selected `', '` 已选权限范围 `'),
+  replacement('` No Scopes Defined `', '` 未定义权限范围 `'),
+  replacement('`Add Scope`', '`添加权限范围`', 2),
+  replacement('` Deselect All `', '` 取消全选 `'),
+  replacement('` Select All `', '` 全选 `'),
+  replacement('` Name: `', '` 名称：`'),
+  replacement('` Description: `', '` 描述：`'),
+  replacement('`Read user data`', '`读取用户数据`'),
+  replacement('`Save`', '`保存`'),
+  replacement('`Edit Scope`', '`编辑权限范围`'),
+  replacement('`Scope name is required.`', '`权限范围名称为必填项。`'),
+  replacement('`Delete Security Scheme`', '`删除安全方案`'),
+  replacement('` Cancel `', '` 取消 `', 3),
+  replacement("` This cannot be undone. You're about to delete the `+k(e.label)+` security scheme from the collection. `", '`此操作无法撤销。即将从集合中删除 `+k(e.label)+` 安全方案。`'),
+  replacement('` security scheme type is not supported yet. `', '` 安全方案类型暂不支持。`'),
+  replacement('` The security scheme is missing a type, please double check your `', '`安全方案缺少类型，请检查 `'),
+  replacement('` document or Authentication Configuration `', '` 文档或身份验证配置。`'),
+  replacement('`Failed to authorize`', '`授权失败`'),
+  replacement('`Failed to refresh token`', '`刷新令牌失败`'),
+  replacement('`Failed to fetch OpenID Connect configuration`', '`获取 OpenID Connect 配置失败`'),
+  replacement('`Add Environment`', '`添加环境`'),
+  replacement('`Select Environment`', '`选择环境`'),
+  replacement('`No Environment`', '`无环境`'),
+  replacement('` Not available in this context `', '` 当前上下文不可用 `'),
+  replacement('`New Environment`', '`新建环境`'),
+  replacement('`Create Environment`', '`创建环境`'),
+  replacement('` Environments let you manage variables like API keys and base URLs across different contexts. `', '` 环境用于管理不同上下文中的 API 密钥、基础 URL 等变量。 `'),
+  replacement('`Current environment: ${', '`当前环境：${'),
+  replacement('` Add Variable `', '` 添加变量 `'),
+  replacement('`Enter a URL`', '`输入 URL`'),
+  replacement('`Request History`', '`请求历史`'),
+  replacement('`History`', '`历史记录`'),
+  replacement('`Add Server`', '`添加服务器`'),
+  replacement('`Update Servers`', '`更新服务器`'),
+  replacement('`Unknown server`', '`未知服务器`'),
+  replacement('`Response Body`', '`响应体`'),
+  replacement('`Preview unavailable`', '`无法预览`', 2),
+  replacement('` Preview `', '` 预览 `', 2),
+  replacement('` Raw `', '` 原始内容 `', 2),
+  replacement('` Binary file `', '` 二进制文件 `', 2),
+  replacement("` This response body is massive! Syntax highlighting won't work here. `", '` 响应体过大，已关闭语法高亮。 `'),
+  replacement('`Response Information, Duration:`', '`响应信息，耗时：`'),
+  replacement('`, Size:`', '`，大小：`'),
+  replacement('` Settings `', '` 设置 `'),
+  replacement('`No document selected`', '`未选择 API 文档`'),
+  replacement('`Select an operation to view details`', '`选择一个操作以查看详情`'),
+  replacement('containerAriaLabel:{default:`Notifications`}', 'containerAriaLabel:{default:`通知`}'),
+]);
+
+export function localizeScalarBrowserAsset(asset, locale = scalarAssetLocale) {
+  if (locale !== scalarAssetLocale) throw new Error(`Scalar asset locale ${locale} is not supported`);
+  let output = Buffer.isBuffer(asset) ? asset.toString('utf8') : String(asset);
+  for (const rule of localizationRules) {
+    const count = countOccurrences(output, rule.source);
+    if (count !== rule.expectedCount) {
+      throw new Error(`Scalar localization source drift for ${JSON.stringify(rule.source)}: expected ${rule.expectedCount}, found ${count}`);
+    }
+    output = output.replaceAll(rule.source, rule.target);
+  }
+  return Buffer.from(output);
+}
+
+function replacement(source, target, expectedCount = 1) {
+  return Object.freeze({ expectedCount, source, target });
+}
+
+function countOccurrences(value, search) {
+  return value.split(search).length - 1;
+}