aub-workspace 0.3.0

package/vendor/aub/scripts/handoff-package.lib.mjs

@@ -0,0 +1,111 @@
+import JSZip from 'jszip';
+
+export const HANDOFF_FORMAT_VERSION = '1.2.0';
+export const HANDOFF_AGENT_ENTRYPOINT = 'AGENT-README.md';
+
+export async function createHandoffArchive({
+  blueprint,
+  markdown,
+  genericPrompt,
+  codexPrompt,
+  agentGuide,
+  agentGuideZhHant,
+  reportTemplate,
+  reportSchema,
+  viewportImages,
+  extensionRegistry,
+  generatedAt = new Date().toISOString(),
+}) {
+  const zip = new JSZip();
+  const screenId = blueprint.screen.id;
+  const hasExtensionRegistry = typeof extensionRegistry === 'string' && extensionRegistry.trim().length > 0;
+  const agentGuideText = agentGuide.replace('./agent-handoff.zh-Hant.md', './AGENT-README.zh-Hant.md');
+  const files = {
+    [HANDOFF_AGENT_ENTRYPOINT]: ensureTrailingNewline(
+      hasExtensionRegistry ? appendExtensionRegistryNote(agentGuideText) : agentGuideText
+    ),
+    'AGENT-README.zh-Hant.md': ensureTrailingNewline(
+      agentGuideZhHant.replace('./agent-handoff.md', './AGENT-README.md')
+    ),
+    [`${screenId}.ui.json`]: `${JSON.stringify(blueprint, null, 2)}\n`,
+    [`${screenId}.ui.md`]: ensureTrailingNewline(markdown),
+    [`${screenId}.agent.md`]: ensureTrailingNewline(genericPrompt),
+    [`${screenId}.codex.md`]: ensureTrailingNewline(codexPrompt),
+    'implementation-report.template.json': `${JSON.stringify(reportTemplate, null, 2)}\n`,
+    'implementation-report.schema.json': `${JSON.stringify(reportSchema, null, 2)}\n`,
+  };
+
+  if (hasExtensionRegistry) {
+    files['aub.registry.json'] = ensureTrailingNewline(extensionRegistry);
+  }
+
+  for (const [viewportId, dataUrl] of Object.entries(viewportImages)) {
+    files[`screenshots/${viewportId}.png`] = dataUrlToBytes(dataUrl);
+  }
+
+  const manifestFiles = {};
+  for (const [path, content] of Object.entries(files)) {
+    const bytes = typeof content === 'string' ? new TextEncoder().encode(content) : content;
+    manifestFiles[path] = {
+      sha256: await sha256(bytes),
+      bytes: bytes.byteLength,
+    };
+    zip.file(path, content);
+  }
+
+  const manifest = {
+    format: 'aub-handoff',
+    format_version: HANDOFF_FORMAT_VERSION,
+    blueprint_version: blueprint.version,
+    screen_id: screenId,
+    generated_at: generatedAt,
+    agent_entrypoint: HANDOFF_AGENT_ENTRYPOINT,
+    extension_registry: hasExtensionRegistry ? 'aub.registry.json' : null,
+    viewports: blueprint.viewports,
+    files: manifestFiles,
+  };
+  zip.file('manifest.json', `${JSON.stringify(manifest, null, 2)}\n`);
+
+  return {
+    bytes: await zip.generateAsync({
+      type: 'uint8array',
+      compression: 'DEFLATE',
+      compressionOptions: { level: 6 },
+    }),
+    manifest,
+  };
+}
+
+function appendExtensionRegistryNote(agentGuide) {
+  const note = [
+    '',
+    '## Custom component types',
+    '',
+    'This handoff includes `aub.registry.json`, which declares namespaced extension',
+    'component types (`team:component`) used by this blueprint. Treat every node `type`',
+    'that contains a colon as a project-defined component: resolve its meaning and',
+    'container/leaf behavior from `aub.registry.json` — never guess. When an entry',
+    'declares `implementations`, reuse the matching production component, import path,',
+    'and prop mappings instead of recreating it. Validate with',
+    '`aub validate <file> --registry ./aub.registry.json`.',
+    '',
+  ].join('\n');
+  return `${agentGuide.replace(/\n+$/, '')}\n${note}`;
+}
+
+function ensureTrailingNewline(value) {
+  return value.endsWith('\n') ? value : `${value}\n`;
+}
+
+function dataUrlToBytes(dataUrl) {
+  const base64 = dataUrl.split(',')[1] ?? '';
+  const binary = atob(base64);
+  return Uint8Array.from(binary, (character) => character.charCodeAt(0));
+}
+
+async function sha256(bytes) {
+  const stableBytes = new Uint8Array(bytes.byteLength);
+  stableBytes.set(bytes);
+  const buffer = await crypto.subtle.digest('SHA-256', stableBytes);
+  return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, '0')).join('');
+}

package/vendor/aub/scripts/implementation-report.lib.d.mts

@@ -0,0 +1,21 @@
+export type Blueprint = Record<string, any>;
+export type ImplementationReport = Record<string, any>;
+
+export function createImplementationReportTemplate(blueprint: Blueprint): ImplementationReport;
+
+export interface VerifyImplementationReportResult {
+  ready: boolean;
+  errors: string[];
+  summary: {
+    nodes_total: number;
+    nodes_mapped: number;
+    acceptance_total: number;
+    acceptance_passed: number;
+    unresolved: number;
+  };
+}
+
+export function verifyImplementationReport(
+  blueprint: Blueprint,
+  report: ImplementationReport
+): VerifyImplementationReportResult;

package/vendor/aub/scripts/implementation-report.lib.mjs

@@ -0,0 +1,97 @@
+export function createImplementationReportTemplate(blueprint) {
+  return {
+    format: 'aub-implementation-report',
+    format_version: '1.0.0',
+    blueprint: {
+      screen_id: blueprint.screen.id,
+      version: blueprint.version,
+    },
+    implementation: {
+      framework: '',
+      route: '',
+      files: [],
+    },
+    node_mappings: blueprint.nodes.map((node) => ({
+      node_id: node.id,
+      status: 'unmapped',
+      component: node.type,
+      file: '',
+      selector: `[data-aub-node="${node.id}"]`,
+      notes: '',
+    })),
+    acceptance_results: blueprint.acceptance.map((item) => ({
+      acceptance_id: item.id,
+      status: 'needs-review',
+      evidence: [],
+      notes: '',
+    })),
+    unresolved: [],
+  };
+}
+
+export function verifyImplementationReport(blueprint, report) {
+  const errors = [];
+  if (report.blueprint?.screen_id !== blueprint.screen.id) {
+    errors.push(`Report screen_id "${report.blueprint?.screen_id ?? ''}" does not match "${blueprint.screen.id}".`);
+  }
+  if (report.blueprint?.version !== blueprint.version) {
+    errors.push(`Report Blueprint version "${report.blueprint?.version ?? ''}" does not match "${blueprint.version}".`);
+  }
+
+  const nodeIds = new Set(blueprint.nodes.map((node) => node.id));
+  const mappingById = uniqueById(report.node_mappings ?? [], 'node_id', errors);
+  for (const nodeId of nodeIds) {
+    const mapping = mappingById.get(nodeId);
+    if (!mapping) errors.push(`Missing node mapping: ${nodeId}`);
+    else if (mapping.status !== 'mapped' || !mapping.file?.trim()) {
+      errors.push(`Node is not mapped to a file: ${nodeId}`);
+    }
+  }
+  for (const nodeId of mappingById.keys()) {
+    if (!nodeIds.has(nodeId)) errors.push(`Unknown node mapping: ${nodeId}`);
+  }
+
+  const acceptanceById = new Map(blueprint.acceptance.map((item) => [item.id, item]));
+  const resultById = uniqueById(report.acceptance_results ?? [], 'acceptance_id', errors);
+  for (const [acceptanceId, acceptance] of acceptanceById) {
+    const result = resultById.get(acceptanceId);
+    if (!result) {
+      errors.push(`Missing acceptance result: ${acceptanceId}`);
+      continue;
+    }
+    if (result.status !== 'pass') {
+      errors.push(`${acceptance.priority} acceptance is not passing: ${acceptanceId} (${result.status})`);
+    }
+    if (!Array.isArray(result.evidence) || result.evidence.length === 0) {
+      errors.push(`Acceptance result has no evidence: ${acceptanceId}`);
+    }
+  }
+  for (const acceptanceId of resultById.keys()) {
+    if (!acceptanceById.has(acceptanceId)) errors.push(`Unknown acceptance result: ${acceptanceId}`);
+  }
+  if ((report.unresolved ?? []).length > 0) {
+    errors.push(`Report has ${report.unresolved.length} unresolved item(s).`);
+  }
+
+  return {
+    ready: errors.length === 0,
+    errors,
+    summary: {
+      nodes_total: blueprint.nodes.length,
+      nodes_mapped: [...mappingById.values()].filter((item) => item.status === 'mapped' && item.file?.trim()).length,
+      acceptance_total: blueprint.acceptance.length,
+      acceptance_passed: [...resultById.values()].filter((item) => item.status === 'pass').length,
+      unresolved: report.unresolved?.length ?? 0,
+    },
+  };
+}
+
+function uniqueById(items, field, errors) {
+  const map = new Map();
+  for (const item of items) {
+    const id = item?.[field];
+    if (map.has(id)) errors.push(`Duplicate ${field}: ${id}`);
+    else map.set(id, item);
+  }
+  return map;
+}

package/vendor/aub/scripts/import-angular-component.mjs

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+
+import { readFile, readdir, stat, writeFile } from 'node:fs/promises';
+import { extname, relative, resolve } from 'node:path';
+import { importAngularComponent } from './angular-importer.lib.mjs';
+
+const args = process.argv.slice(2);
+const options = parseArgs(args);
+if (options.sources.length === 0 || !options.output) {
+  console.error('Usage: pnpm import:angular -- <file-or-directory...> --output screen.ui.json [--entry app-selector]');
+  process.exit(2);
+}
+
+const cwd = process.cwd();
+const sourcePaths = await expandSources(options.sources);
+const files = await Promise.all(sourcePaths.map(async (path) => ({
+  path: relative(commonBase(sourcePaths), path).replace(/\\/g, '/'),
+  content: await readFile(path, 'utf8'),
+})));
+const result = await importAngularComponent(files, { entry: options.entry });
+await writeFile(resolve(options.output), `${JSON.stringify(result.blueprint, null, 2)}\n`, 'utf8');
+
+const warnings = result.diagnostics.filter((item) => item.severity === 'warning').length;
+console.error(`✓ imported ${files.length} files into ${options.output}`);
+console.error(`  ${result.blueprint.nodes.length} nodes, ${result.blueprint.interactions.length} interactions, ${warnings} warnings`);
+
+function parseArgs(values) {
+  const result = { sources: [], entry: undefined, output: undefined };
+  for (let index = 0; index < values.length; index += 1) {
+    if (values[index] === '--entry') result.entry = values[++index];
+    else if (values[index] === '--output' || values[index] === '-o') result.output = values[++index];
+    else result.sources.push(values[index]);
+  }
+  return result;
+}
+
+async function expandSources(sources) {
+  const result = [];
+  for (const source of sources) {
+    const path = resolve(cwd, source);
+    const info = await stat(path);
+    if (info.isDirectory()) result.push(...await walk(path));
+    else if (isSource(path)) result.push(path);
+  }
+  return [...new Set(result)].sort();
+}
+
+async function walk(directory) {
+  const result = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    const path = resolve(directory, entry.name);
+    if (entry.isDirectory()) result.push(...await walk(path));
+    else if (isSource(path)) result.push(path);
+  }
+  return result;
+}
+
+function isSource(path) {
+  return ['.html', '.scss', '.css', '.ts'].includes(extname(path).toLowerCase())
+    && !/\.spec\.ts$/i.test(path);
+}
+
+function commonBase(paths) {
+  if (paths.length === 1) return resolve(paths[0], '..');
+  const parts = paths.map((path) => resolve(path).split('/'));
+  const common = [];
+  for (let index = 0; index < Math.min(...parts.map((value) => value.length)); index += 1) {
+    if (parts.every((value) => value[index] === parts[0][index])) common.push(parts[0][index]);
+    else break;
+  }
+  return common.join('/') || '/';
+}

package/vendor/aub/scripts/import-design-bridge.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, resolve } from 'node:path';
+import Ajv2020 from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import { importDesignBridge } from './design-bridge.lib.mjs';
+import { buildKnownTypes } from './registry.lib.mjs';
+import { validateBlueprintSemantics } from './validate-blueprint.lib.mjs';
+
+const args = process.argv.slice(2);
+const inputPath = args.find((arg) => !arg.startsWith('-'));
+const outputIndex = args.findIndex((arg) => arg === '--output' || arg === '-o');
+const registryIndex = args.findIndex((arg) => arg === '--registry');
+const outputPath = outputIndex >= 0 ? args[outputIndex + 1] : undefined;
+const registryPath = registryIndex >= 0 ? args[registryIndex + 1] : undefined;
+
+if (!inputPath || !outputPath) {
+  console.error('Usage: pnpm import:design -- <file.aub.bridge.json> --output <screen.ui.json> [--registry aub.registry.json]');
+  process.exit(2);
+}
+
+const root = resolve(import.meta.dirname, '..');
+const [bridgeSchema, blueprintSchema, input] = await Promise.all([
+  readFile(resolve(root, 'schema/design-bridge.schema.json'), 'utf8').then(JSON.parse),
+  readFile(resolve(root, 'schema/ui-blueprint.schema.json'), 'utf8').then(JSON.parse),
+  readFile(resolve(inputPath), 'utf8').then(JSON.parse),
+]);
+const ajv = new Ajv2020({ allErrors: true, strict: true });
+addFormats(ajv);
+ajv.addSchema(blueprintSchema);
+const validateBridge = ajv.compile(bridgeSchema);
+if (!validateBridge(input)) {
+  for (const error of validateBridge.errors ?? []) {
+    console.error(`  ${error.instancePath || '(root)'} ${error.message}`);
+  }
+  process.exit(1);
+}
+
+const result = importDesignBridge(input);
+const validateBlueprint = ajv.getSchema(blueprintSchema.$id);
+const schemaOk = validateBlueprint(result.blueprint);
+const knownTypes = await buildKnownTypes({
+  extensionPath: registryPath ? resolve(registryPath) : null,
+  startDir: dirname(resolve(inputPath)),
+});
+const semanticErrors = schemaOk
+  ? validateBlueprintSemantics(result.blueprint, { knownTypes: knownTypes.knownTypes })
+  : [];
+if (!schemaOk || semanticErrors.length > 0) {
+  for (const error of validateBlueprint.errors ?? []) {
+    console.error(`  ${error.instancePath || '(root)'} ${error.message}`);
+  }
+  for (const error of semanticErrors) console.error(`  semantic: ${error}`);
+  process.exit(1);
+}
+
+await writeFile(resolve(outputPath), `${JSON.stringify(result.blueprint, null, 2)}\n`, 'utf8');
+console.error(`✓ imported ${input.source.kind} frame ${input.source.frame_id} into ${outputPath}`);
+console.error(`  ${result.blueprint.nodes.length} semantic nodes with complete source mapping`);

package/vendor/aub/scripts/lock-blueprint.lib.d.mts

@@ -0,0 +1,23 @@
+export interface BlueprintLock {
+  $schema: string;
+  version: string;
+  source_file: string;
+  exported_at: string;
+  source_editor_version: string;
+  hashes: Record<string, string>;
+  counts: {
+    nodes: number;
+    interactions: number;
+    responsive: number;
+    acceptance: number;
+  };
+}
+
+export function createBlueprintLock(
+  blueprint: Record<string, any>,
+  options?: {
+    sourceFile?: string;
+    exportedAt?: string;
+    sourceEditorVersion?: string;
+  }
+): BlueprintLock;

package/vendor/aub/scripts/lock-blueprint.lib.mjs

@@ -0,0 +1,58 @@
+import { createHash } from 'node:crypto';
+
+export function createBlueprintLock(
+  blueprint,
+  {
+    sourceFile = '',
+    exportedAt = new Date().toISOString(),
+    sourceEditorVersion = '0.3.0',
+  } = {}
+) {
+  const sortedIds = [...blueprint.nodes.map((node) => node.id)].sort();
+  const layoutSubset = blueprint.nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    layout: node.layout ?? null,
+    placements: node.placements ?? null,
+  }));
+  const treeSubset = blueprint.nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    parent_id: node.parent_id,
+    children: node.children ?? [],
+  }));
+
+  return {
+    $schema: 'https://henrylau1103.github.io/AUB/schema/ui-blueprint-lock.schema.json',
+    version: blueprint.version,
+    source_file: sourceFile,
+    exported_at: exportedAt,
+    source_editor_version: sourceEditorVersion,
+    hashes: {
+      blueprint: sha256(stableStringify(blueprint)),
+      node_ids: sha256(stableStringify(sortedIds)),
+      layout: sha256(stableStringify(layoutSubset)),
+      design_system: sha256(stableStringify(blueprint.design_system ?? null)),
+      component_tree: sha256(stableStringify(treeSubset)),
+      interactions: sha256(stableStringify(blueprint.interactions ?? [])),
+      acceptance: sha256(stableStringify(blueprint.acceptance ?? [])),
+    },
+    counts: {
+      nodes: blueprint.nodes.length,
+      interactions: (blueprint.interactions ?? []).length,
+      responsive: (blueprint.responsive ?? []).length,
+      acceptance: (blueprint.acceptance ?? []).length,
+    },
+  };
+}
+
+function sha256(value) {
+  return `sha256:${createHash('sha256').update(value).digest('hex')}`;
+}
+
+function stableStringify(value) {
+  if (value === null || typeof value !== 'object') return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`;
+  const keys = Object.keys(value).sort();
+  return `{${keys.map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(',')}}`;
+}

package/vendor/aub/scripts/lock-blueprint.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// Lock a UI Blueprint into a frozen acceptance snapshot (plan §6.4).
+// Usage: node scripts/lock-blueprint.mjs <input.ui.json> <output.ui.lock.json>
+//
+// The lock file contains SHA-256 hashes of structural subsets plus provenance.
+// If any of these change after the lock is created, the design has drifted
+// and agents should NOT silently apply the change.
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { createBlueprintLock } from './lock-blueprint.lib.mjs';
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length !== 2) {
+    console.error('Usage: node scripts/lock-blueprint.mjs <input.ui.json> <output.ui.lock.json>');
+    process.exit(2);
+  }
+  const [inputPath, outputPath] = args;
+  const blueprint = JSON.parse(await readFile(resolve(inputPath), 'utf8'));
+
+  const lock = createBlueprintLock(blueprint, {
+    sourceFile: inputPath,
+  });
+
+  await writeFile(resolve(outputPath), JSON.stringify(lock, null, 2) + '\n', 'utf8');
+  console.error(`✓ wrote ${outputPath}`);
+  for (const [k, v] of Object.entries(lock.hashes)) {
+    console.error(`    ${k}: ${v.slice(0, 16)}...`);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/vendor/aub/scripts/migrate-blueprint-cli.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// Upgrade a Blueprint to the current schema version.
+// Usage: node scripts/migrate-blueprint-cli.mjs <input.ui.json|yaml> <output.ui.json|yaml>
+
+import { readFile, writeFile } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import yaml from 'js-yaml';
+import { migrateBlueprint } from './migrate-blueprint.mjs';
+
+const [inputPath, outputPath] = process.argv.slice(2);
+if (!inputPath || !outputPath) {
+  console.error('Usage: node scripts/migrate-blueprint-cli.mjs <input.ui.json|yaml> <output.ui.json|yaml>');
+  process.exit(2);
+}
+
+const inputExtension = extname(inputPath).toLowerCase();
+const outputExtension = extname(outputPath).toLowerCase();
+const raw = await readFile(resolve(inputPath), 'utf8');
+const source = inputExtension === '.yaml' || inputExtension === '.yml'
+  ? yaml.load(raw)
+  : JSON.parse(raw);
+const migrated = migrateBlueprint(source);
+const output = outputExtension === '.yaml' || outputExtension === '.yml'
+  ? yaml.dump(migrated, { noRefs: true, lineWidth: 120, sortKeys: false })
+  : `${JSON.stringify(migrated, null, 2)}\n`;
+
+await writeFile(resolve(outputPath), output, 'utf8');
+console.error(`✓ migrated ${inputPath} → ${outputPath}`);

package/vendor/aub/scripts/migrate-blueprint.d.mts

@@ -0,0 +1,5 @@
+import type { Blueprint, DesignSystem } from '../schema/types.js';
+
+export const CURRENT_VERSION: string;
+export function migrateBlueprint(input: unknown): Blueprint;
+export function defaultDesignSystem(): DesignSystem;

package/vendor/aub/scripts/migrate-blueprint.mjs

@@ -0,0 +1,95 @@
+const CURRENT_VERSION = '0.3.0';
+
+export function migrateBlueprint(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new TypeError('Blueprint must be an object.');
+  }
+
+  const sourceVersion = typeof input.version === 'string' ? input.version : '0.1.0';
+  if (!['0.1.0', '0.2.0', CURRENT_VERSION].includes(sourceVersion)) {
+    throw new Error(`Unsupported Blueprint version: ${sourceVersion}`);
+  }
+
+  const blueprint = structuredClone(input);
+  blueprint.version = CURRENT_VERSION;
+  blueprint.design_system ??= defaultDesignSystem();
+  blueprint.nodes = Array.isArray(blueprint.nodes)
+    ? blueprint.nodes.map((node) => migrateNode(node))
+    : [];
+
+  return blueprint;
+}
+
+export function defaultDesignSystem() {
+  return {
+    name: 'AUB Neutral',
+    colors: {
+      'surface.canvas': '#f8fafc',
+      'surface.panel': '#ffffff',
+      'surface.subtle': '#f1f5f9',
+      'text.primary': '#0f172a',
+      'text.secondary': '#64748b',
+      'border.default': '#cbd5e1',
+      'action.primary': '#2563eb',
+      'action.primary.text': '#ffffff',
+      'status.success': '#047857',
+      'status.warning': '#b45309',
+      'status.danger': '#b91c1c'
+    },
+    typography: {
+      'heading.page': '700 28px/1.2 system-ui',
+      'heading.section': '650 18px/1.3 system-ui',
+      'body.default': '400 14px/1.5 system-ui',
+      'body.small': '400 12px/1.4 system-ui',
+      'label.default': '600 12px/1.3 system-ui'
+    },
+    spacing: {
+      'space.1': '4px',
+      'space.2': '8px',
+      'space.3': '12px',
+      'space.4': '16px',
+      'space.5': '24px',
+      'space.6': '32px'
+    },
+    radii: {
+      'radius.control': '6px',
+      'radius.panel': '8px',
+      'radius.round': '999px'
+    },
+    shadows: {
+      'shadow.panel': '0 8px 24px rgba(15, 23, 42, 0.12)',
+      'shadow.overlay': '0 18px 48px rgba(15, 23, 42, 0.22)'
+    }
+  };
+}
+
+function migrateNode(input) {
+  const node = { ...input };
+  if (node.layout) {
+    node.layout = {
+      mode: node.layout.mode ?? 'auto',
+      ...node.layout
+    };
+  }
+  if (node.placements && typeof node.placements === 'object') {
+    node.placements = Object.fromEntries(
+      Object.entries(node.placements).map(([viewport, placement]) => [
+        viewport,
+        normalizePlacement(placement)
+      ])
+    );
+  }
+  return node;
+}
+
+function normalizePlacement(input) {
+  const placement = { ...input };
+  for (const key of ['x', 'y', 'width', 'height']) {
+    if (typeof placement[key] !== 'number' || !Number.isFinite(placement[key])) {
+      throw new Error(`Invalid placement.${key}`);
+    }
+  }
+  return placement;
+}
+
+export { CURRENT_VERSION };

package/vendor/aub/scripts/package-workspace-cli.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { cp, mkdir, rm, stat } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+const packageRoot = join(repoRoot, 'packages', 'workspace-cli');
+const vendorRoot = join(packageRoot, 'vendor', 'aub');
+
+async function assertDir(path, label) {
+  try {
+    const info = await stat(path);
+    if (!info.isDirectory()) throw new Error(`${label} is not a directory: ${path}`);
+  } catch {
+    throw new Error(`${label} is missing. Build first with: pnpm workspace:package`);
+  }
+}
+
+await assertDir(join(repoRoot, 'apps', 'mcp-server', 'dist'), 'MCP server dist');
+await assertDir(join(repoRoot, 'apps', 'editor', 'dist'), 'Editor dist');
+
+await rm(vendorRoot, { recursive: true, force: true });
+await mkdir(vendorRoot, { recursive: true });
+
+await cp(join(repoRoot, 'schema'), join(vendorRoot, 'schema'), { recursive: true });
+await cp(join(repoRoot, 'scripts'), join(vendorRoot, 'scripts'), { recursive: true });
+await mkdir(join(vendorRoot, 'docs'), { recursive: true });
+await cp(join(repoRoot, 'docs', 'agent-handoff.md'), join(vendorRoot, 'docs', 'agent-handoff.md'));
+await cp(join(repoRoot, 'docs', 'agent-handoff.zh-Hant.md'), join(vendorRoot, 'docs', 'agent-handoff.zh-Hant.md'));
+await cp(join(repoRoot, 'docs', 'template-authoring-agent.md'), join(vendorRoot, 'docs', 'template-authoring-agent.md'));
+await cp(join(repoRoot, 'apps', 'mcp-server', 'dist'), join(vendorRoot, 'apps', 'mcp-server', 'dist'), { recursive: true });
+await cp(join(repoRoot, 'apps', 'editor', 'dist'), join(vendorRoot, 'apps', 'editor', 'dist'), { recursive: true });
+
+console.error(`Prepared aub-workspace vendor payload at ${vendorRoot}`);