@vanillaskyai/video 0.1.0

package/dist/cli.js

@@ -0,0 +1,1681 @@
+#!/usr/bin/env node
+import "./chunk-YC5MFXA5.js";
+import "./chunk-FQ47WXAJ.js";
+import "./chunk-EVG2ZYIY.js";
+import {
+  isTemplatePropertyFormatSupported,
+  validateTemplateSchemaValue
+} from "./chunk-352ZZCET.js";
+import {
+  getBuiltinTemplateMetadata,
+  listBuiltinTemplateMetadata
+} from "./chunk-CHLGW22F.js";
+import {
+  assertTemplateTransitionMetadata
+} from "./chunk-2E6T633S.js";
+import {
+  BUILTIN_TEMPLATE_MANIFEST
+} from "./chunk-W2XJKG6C.js";
+import {
+  getTemplateDefaults,
+  isMeaningfullyPresentTemplateValue,
+  summarizeTemplateVariables,
+  templateVariableNotation
+} from "./chunk-73NTSFFI.js";
+
+// src/cli/index.ts
+import { resolve as resolve7 } from "path";
+
+// src/cli/registry.ts
+import { randomUUID } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname, join as join2, resolve as resolve2 } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/safe-path.ts
+import { lstatSync, realpathSync } from "fs";
+import { join, relative, resolve, sep } from "path";
+function lstatIfPresent(path) {
+  try {
+    return lstatSync(path);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function safeProjectPath(cwd, target) {
+  const root = resolve(cwd);
+  const destination = resolve(root, target);
+  const pathFromRoot = relative(root, destination);
+  if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep}`)) {
+    throw new Error(`Write target escapes the project: ${target}`);
+  }
+  const rootStat = lstatIfPresent(root);
+  if (!rootStat) throw new Error(`Project directory does not exist: ${root}`);
+  if (rootStat.isSymbolicLink()) throw new Error("Project writes cannot use a symbolic-link project root");
+  if (!rootStat.isDirectory()) throw new Error(`Project path is not a directory: ${root}`);
+  const realRoot = realpathSync(root);
+  const segments = pathFromRoot.split(sep).filter(Boolean);
+  let current = root;
+  for (const segment of segments) {
+    current = join(current, segment);
+    const stat = lstatIfPresent(current);
+    if (!stat) return destination;
+    if (stat.isSymbolicLink()) {
+      throw new Error(`Write target contains a symbolic link: ${relative(root, current)}`);
+    }
+    const realCurrent = realpathSync(current);
+    const realPathFromRoot = relative(realRoot, realCurrent);
+    if (realPathFromRoot === ".." || realPathFromRoot.startsWith(`..${sep}`)) {
+      throw new Error(`Write target escapes the project: ${relative(root, current)}`);
+    }
+  }
+  return destination;
+}
+
+// src/cli/registry.ts
+function defaultRegistryDir() {
+  const sourceCandidate = fileURLToPath(new URL("../../registry/items/", import.meta.url));
+  const distributionCandidate = fileURLToPath(new URL("../registry/items/", import.meta.url));
+  return existsSync(sourceCandidate) ? sourceCandidate : distributionCandidate;
+}
+function readItem(registryDir, name) {
+  if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(name)) throw new Error(`Invalid registry item: ${name}`);
+  const path = join2(registryDir, `${name}.json`);
+  if (!existsSync(path)) throw new Error(`Unknown template or registry item: ${name}`);
+  return JSON.parse(readFileSync(path, "utf8"));
+}
+function readTemplateItem(registryDir, name) {
+  let item2;
+  try {
+    item2 = readItem(registryDir, name);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Unknown template or registry item:")) {
+      throw new Error(`Unknown template: ${name}`);
+    }
+    if (error instanceof Error && error.message.startsWith("Invalid registry item:")) {
+      throw new Error(`Invalid template: ${name}`);
+    }
+    throw error;
+  }
+  if (item2.meta?.vanillasky?.layer !== "template") throw new Error(`${item2.name} is not a template`);
+  return item2;
+}
+function dependencyName(value) {
+  return value.startsWith("@vanillasky/") ? value.slice("@vanillasky/".length) : value;
+}
+function safeDestination(cwd, target) {
+  return safeProjectPath(cwd, target);
+}
+function planCustomerFile(planned, target, content) {
+  const existing = planned.get(target);
+  if (existing != null && existing !== content) {
+    throw new Error(`Registry items provide conflicting content for ${target}`);
+  }
+  planned.set(target, content);
+}
+function registryTarget(file) {
+  if (file.target) return file.target;
+  return file.path.replace(/^src\/lib\//, "vanillasky/");
+}
+function primaryTemplateFile(item2) {
+  return item2.files?.find((file) => /scene-templates\/.*\.tsx$/.test(file.path));
+}
+function templateDefinition(item2) {
+  const templateFile = primaryTemplateFile(item2);
+  if (!templateFile) throw new Error(`Template ${item2.name} has no render component`);
+  const metadata = item2.meta?.vanillasky ?? {};
+  const canonical = getBuiltinTemplateMetadata(item2.name);
+  const schema = canonical?.schema ?? metadata.schema;
+  if (!schema) throw new Error(`Template ${item2.name} has no JSON Schema contract`);
+  return canonical ?? {
+    id: item2.name,
+    label: item2.title ?? item2.name,
+    description: item2.description ?? "",
+    useWhen: String(metadata.useWhen ?? item2.description ?? ""),
+    usesGlobalTextEffect: false,
+    usesGlobalTransition: false,
+    usesGlobalBackgroundEffect: false,
+    schema,
+    ...metadata.jobs == null ? {} : { jobs: metadata.jobs },
+    ...metadata.register == null ? {} : { register: metadata.register },
+    ...metadata.textCanvas == null ? {} : { textCanvas: metadata.textCanvas },
+    ...metadata.minDuration == null ? {} : { minDuration: metadata.minDuration },
+    ...metadata.preferredDuration == null ? {} : { preferredDuration: metadata.preferredDuration }
+  };
+}
+function materializedTemplateMetadata(item2) {
+  const definition = templateDefinition(item2);
+  const {
+    schema,
+    label = definition.id,
+    description = "",
+    usesGlobalTextEffect = false,
+    usesGlobalTransition = false,
+    usesGlobalBackgroundEffect = false,
+    ...definitionWithoutDefaults
+  } = definition;
+  return {
+    label,
+    description,
+    usesGlobalTextEffect,
+    usesGlobalTransition,
+    usesGlobalBackgroundEffect,
+    ...definitionWithoutDefaults,
+    schema: {
+      ...schema,
+      additionalProperties: schema.additionalProperties ?? false
+    }
+  };
+}
+function templateSource(item2) {
+  const templateFile = primaryTemplateFile(item2);
+  if (!templateFile) throw new Error(`Template ${item2.name} has no render component`);
+  const component = templateFile.content.match(/export const (\w+Template)\b/)?.[1];
+  if (!component) throw new Error(`Cannot identify the component exported by ${item2.name}`);
+  const definition = templateDefinition(item2);
+  const definitionLines = JSON.stringify(definition, null, 2).split("\n").slice(1, -1);
+  definitionLines[definitionLines.length - 1] += ",";
+  let componentSource = templateFile.content.replace(/(from\s+["'])\.\//g, "$1../scene-templates/").replace(/(import\(\s*["'])\.\//g, "$1../scene-templates/").replace(
+    new RegExp(`export const ${component}: React\\.FC<SceneTemplateProps> = \\(\\{([\\s\\S]*?)\\n\\}\\) => \\{`),
+    `export const ${component} = ({$1
+}: SceneTemplateProps) => {`
+  );
+  if (!componentSource.includes("React.")) {
+    componentSource = componentSource.replace(/^import (?:\* as )?React from ["']react["'];\n/m, "");
+  }
+  return [
+    `import { defineTemplate } from "@vanillaskyai/video/templates";`,
+    "",
+    componentSource.trim(),
+    "",
+    `export const ${item2.name}Template = defineTemplate({`,
+    ...definitionLines,
+    `  component: ${component},`,
+    "});",
+    ""
+  ].join("\n");
+}
+function listRegistryTemplates(registryDir = defaultRegistryDir()) {
+  return readdirSync(registryDir).filter((name) => name.endsWith(".json")).map((name) => readItem(registryDir, name.slice(0, -5))).filter((item2) => item2.meta?.vanillasky?.layer === "template").map((item2) => {
+    const canonical = getBuiltinTemplateMetadata(item2.name);
+    return {
+      id: item2.name,
+      title: item2.title ?? item2.name,
+      description: canonical?.useWhen ?? item2.description ?? ""
+    };
+  }).sort((left, right) => left.id.localeCompare(right.id));
+}
+function listInstalledTemplates(cwd) {
+  const templatesDirectory = join2(resolve2(cwd), "vanillasky/templates");
+  if (!existsSync(templatesDirectory)) return [];
+  return [...new Set(readdirSync(templatesDirectory, { withFileTypes: true }).filter((entry) => entry.isFile() && /^[A-Za-z][A-Za-z0-9_-]*\.(?:ts|tsx)$/.test(entry.name)).map((entry) => entry.name.replace(/\.(?:ts|tsx)$/, "")))].sort((left, right) => left.localeCompare(right));
+}
+function plannedChanges(cwd, planned) {
+  const changes = [];
+  for (const [path, after] of planned) {
+    const destination = safeDestination(cwd, path);
+    if (!existsSync(destination)) {
+      changes.push({ path, action: "create", after });
+      continue;
+    }
+    const before = readFileSync(destination, "utf8");
+    if (before !== after) changes.push({ path, action: "update", before, after });
+  }
+  return changes;
+}
+function applyChanges(cwd, changes) {
+  for (const change of changes) {
+    const destination = safeDestination(cwd, change.path);
+    mkdirSync(dirname(destination), { recursive: true });
+    safeProjectPath(cwd, destination);
+    const temporary = join2(
+      dirname(destination),
+      `.${basename(destination)}.vanillasky-tmp-${randomUUID()}`
+    );
+    try {
+      writeFileSync(temporary, change.after, { encoding: "utf8", flag: "wx" });
+      safeProjectPath(cwd, destination);
+      renameSync(temporary, destination);
+    } finally {
+      if (existsSync(temporary)) unlinkSync(temporary);
+    }
+  }
+}
+function addRegistryTemplates(options) {
+  const cwd = resolve2(options.cwd);
+  const registryDir = options.registryDir ?? defaultRegistryDir();
+  const requested = [...new Set(options.names)];
+  const requestedItems = requested.map((name) => readTemplateItem(registryDir, name));
+  const installed = new Set(listInstalledTemplates(cwd));
+  const planned = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const installItem = (name) => {
+    if (visited.has(name)) return;
+    visited.add(name);
+    const item2 = readItem(registryDir, name);
+    const primary = item2.meta?.vanillasky?.layer === "template" ? primaryTemplateFile(item2) : void 0;
+    for (const dependency of item2.registryDependencies ?? []) {
+      installItem(dependencyName(dependency));
+    }
+    for (const file of item2.files ?? []) {
+      if (file === primary) continue;
+      const target = registryTarget(file);
+      planCustomerFile(planned, target, file.content);
+    }
+  };
+  for (const item2 of requestedItems) {
+    installItem(item2.name);
+    planCustomerFile(
+      planned,
+      `vanillasky/templates/${item2.name}.tsx`,
+      templateSource(item2)
+    );
+  }
+  const changes = plannedChanges(cwd, planned);
+  const updates = changes.filter((change) => change.action === "update");
+  if (!options.dryRun && !options.overwrite && updates.length > 0) {
+    throw new Error(`Refusing to overwrite customer-owned file: ${updates[0]?.path}`);
+  }
+  if (!options.dryRun) applyChanges(cwd, changes);
+  const templateChanges = new Set(changes.filter((change) => /^vanillasky\/templates\/.*\.tsx$/.test(change.path)).map((change) => change.path.slice("vanillasky/templates/".length, -".tsx".length)));
+  const added = requested.filter((name) => !installed.has(name) && templateChanges.has(name));
+  const updated = requested.filter((name) => installed.has(name) && templateChanges.has(name));
+  return {
+    added,
+    updated,
+    files: changes.map(({ path }) => path),
+    changes,
+    previewTemplates: requestedItems.map((item2) => ({
+      sourcePath: `vanillasky/templates/${item2.name}.tsx`,
+      exportName: `${item2.name}Template`,
+      importPath: `./templates/${item2.name}`,
+      metadata: materializedTemplateMetadata(item2)
+    }))
+  };
+}
+
+// src/cli/sync.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { lstatSync as lstatSync2 } from "fs";
+import { mkdir, open, readFile, rename, unlink } from "fs/promises";
+import { basename as basename3, dirname as dirname2, join as join4, relative as relative3, resolve as resolve4 } from "path";
+
+// src/cli/project-templates.ts
+import { realpathSync as realpathSync2 } from "fs";
+import { readdir } from "fs/promises";
+import { createRequire } from "module";
+import { basename as basename2, join as join3, relative as relative2, resolve as resolve3, sep as sep2 } from "path";
+import { pathToFileURL } from "url";
+
+// src/cli/trusted-source-process.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_OUTPUT_BYTES = 1024 * 1024;
+var TrustedSourceProcessError = class extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.name = "TrustedSourceProcessError";
+    this.kind = kind;
+  }
+};
+function minimalEnvironment() {
+  const names = ["PATH", "SYSTEMROOT", "WINDIR", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL"];
+  return Object.fromEntries(names.flatMap((name) => process.env[name] == null ? [] : [[name, process.env[name]]]));
+}
+function delay(milliseconds) {
+  return new Promise((resolve8) => setTimeout(resolve8, milliseconds));
+}
+function signalProcessGroup(pid, signal) {
+  try {
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    const code = error.code;
+    if (code === "ESRCH" || code === "EPERM") return false;
+    throw error;
+  }
+}
+async function stopProcessGroup(pid) {
+  if (!signalProcessGroup(pid, "SIGTERM")) return;
+  await delay(100);
+  if (signalProcessGroup(pid, 0)) {
+    signalProcessGroup(pid, "SIGKILL");
+    await delay(25);
+  }
+}
+async function runTrustedSourceProcess(args, options) {
+  if (process.platform === "win32") {
+    throw new Error(
+      "Project template execution is not supported on Windows because portable process-tree cleanup cannot be guaranteed. Use --builtin from Windows or run project template commands in WSL."
+    );
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const maxOutputBytes = options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+  const operation = options.operation ?? "loading";
+  let cleanup;
+  let processId;
+  const result = new Promise((resolve8, reject) => {
+    const child = spawn(process.execPath, [...args], {
+      cwd: options.cwd,
+      detached: true,
+      env: minimalEnvironment(),
+      stdio: ["ignore", "pipe", "pipe", "pipe"]
+    });
+    processId = child.pid;
+    const protocol = [];
+    const diagnostics = [];
+    let outputBytes = 0;
+    let failure;
+    let settled = false;
+    const fail = (error) => {
+      if (failure) return;
+      failure = error;
+      if (child.pid != null) cleanup = stopProcessGroup(child.pid);
+    };
+    const collect = (target) => (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      outputBytes += buffer.byteLength;
+      if (outputBytes > maxOutputBytes) {
+        fail(new TrustedSourceProcessError("output", `${operation} output exceeded ${maxOutputBytes} bytes`));
+        return;
+      }
+      target.push(buffer);
+    };
+    child.stdout?.on("data", collect(diagnostics));
+    child.stderr?.on("data", collect(diagnostics));
+    const protocolStream = child.stdio[3];
+    if (protocolStream && "on" in protocolStream) protocolStream.on("data", collect(protocol));
+    const timer = setTimeout(() => {
+      fail(new TrustedSourceProcessError("timeout", `${operation} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      reject(error);
+    });
+    child.on("close", (code, signal) => {
+      clearTimeout(timer);
+      if (settled) return;
+      settled = true;
+      if (failure) {
+        reject(failure);
+        return;
+      }
+      if (code !== 0) {
+        const detail = Buffer.concat(diagnostics).toString("utf8").trim();
+        reject(new TrustedSourceProcessError(
+          "exit",
+          detail || `template loader exited with ${code ?? signal ?? "an error"}`
+        ));
+        return;
+      }
+      resolve8(Buffer.concat(protocol).toString("utf8"));
+    });
+  });
+  try {
+    return await result;
+  } finally {
+    if (processId != null) await (cleanup ?? stopProcessGroup(processId));
+  }
+}
+
+// src/cli/project-templates.ts
+var nodeModulesMarker = `${sep2}node_modules${sep2}`;
+var MAX_TEMPLATE_SOURCES = 128;
+var LOADER_CONCURRENCY = 4;
+var TEMPLATE_LOADER = String.raw`
+const sourceUrl = process.argv[1];
+const { writeSync } = await import("node:fs");
+const writeProtocol = (value) => writeSync(3, value);
+for (const method of ["log", "info", "warn", "error", "debug", "dir", "trace"]) console[method] = () => undefined;
+const loaded = await import(sourceUrl + "?vanillasky=loader");
+const isTemplate = (value) =>
+  typeof value === "object" && value != null &&
+  typeof value.id === "string" && typeof value.component === "function" &&
+  typeof value.schema === "object" && value.schema != null &&
+  value.schema.type === "object" && typeof value.schema.properties === "object";
+const entries = Object.entries(loaded);
+if (loaded.default && typeof loaded.default === "object" && !isTemplate(loaded.default)) {
+  for (const entry of Object.entries(loaded.default)) {
+    if (!entries.some(([name]) => name === entry[0])) entries.push(entry);
+  }
+}
+const templates = entries.filter(([, value]) => isTemplate(value));
+if (templates.length !== 1) {
+  throw new Error("must export exactly one template created with defineTemplate (found " + templates.length + ")");
+}
+const [exportName, template] = templates[0];
+const { component, examples, ...rawMetadata } = template;
+const metadata = Object.fromEntries(Object.entries(rawMetadata).filter(([, value]) => value !== undefined));
+const seen = new Set();
+function assertJson(value, path) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return;
+    throw new Error(path + " must contain only finite JSON numbers");
+  }
+  if (typeof value !== "object") throw new Error(path + " contains a non-serializable " + typeof value);
+  if (seen.has(value)) throw new Error(path + " contains a circular value");
+  seen.add(value);
+  if (Array.isArray(value)) value.forEach((entry, index) => assertJson(entry, path + "[" + index + "]"));
+  else {
+    if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
+      throw new Error(path + " contains a non-serializable object");
+    }
+    for (const [key, entry] of Object.entries(value)) assertJson(entry, path + "." + key);
+  }
+  seen.delete(value);
+}
+assertJson(metadata, "template metadata");
+if (examples !== undefined) assertJson(examples, "template examples");
+writeProtocol(JSON.stringify({ exportName, metadata, examples }));
+`;
+async function sourceFiles(templatesDirectory) {
+  let entries;
+  try {
+    entries = await readdir(templatesDirectory, { withFileTypes: true });
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+  const linkedSource = entries.find((entry) => entry.isSymbolicLink() && /\.(?:ts|tsx)$/.test(entry.name));
+  if (linkedSource) throw new Error(`Template source cannot be a symbolic link: ${linkedSource.name}`);
+  const files = entries.filter((entry) => entry.isFile() && /\.(?:ts|tsx)$/.test(entry.name)).map((entry) => join3(templatesDirectory, entry.name)).sort((left, right) => left.localeCompare(right));
+  if (files.length > MAX_TEMPLATE_SOURCES) {
+    throw new Error(`A project may contain at most ${MAX_TEMPLATE_SOURCES} template source files (found ${files.length}).`);
+  }
+  return files;
+}
+function resolveProjectTsxRuntime(resolveModule = (specifier) => createRequire(import.meta.url).resolve(specifier)) {
+  let resolvedLoader;
+  try {
+    resolvedLoader = resolveModule("tsx");
+  } catch {
+    throw new Error(
+      "Source-owned template commands require the optional TSX compiler. Install it in your project with: npm install --save-dev tsx"
+    );
+  }
+  const nodeModulesIndex = resolvedLoader.lastIndexOf(nodeModulesMarker);
+  const dependencyRoot = nodeModulesIndex < 0 ? resolve3(resolvedLoader, "..") : resolvedLoader.slice(0, nodeModulesIndex + nodeModulesMarker.length - 1);
+  return { dependencyRoot, loader: pathToFileURL(resolvedLoader).href };
+}
+function sanitizeTrustedSourceDiagnostic(value, cwd, dependencyRoot) {
+  const roots = [...new Set([resolve3(cwd), realpathSync2(cwd), dependencyRoot].filter((root) => Boolean(root)))].sort((left, right) => right.length - left.length);
+  let safe = value;
+  for (const root of roots) {
+    const replacement = root === dependencyRoot ? "<dependency>" : ".";
+    safe = safe.split(root).join(replacement).split(pathToFileURL(root).href).join(replacement);
+  }
+  return safe;
+}
+async function mapWithConcurrency(values, concurrency, transform) {
+  if (!Number.isInteger(concurrency) || concurrency < 1) throw new Error("Loader concurrency must be a positive integer");
+  const results = new Array(values.length);
+  let next = 0;
+  const worker = async () => {
+    while (next < values.length) {
+      const index = next;
+      next += 1;
+      results[index] = await transform(values[index], index);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, worker));
+  return results;
+}
+async function loadTemplate(filePath, cwd, options, runtime) {
+  const displayPath = relative2(cwd, filePath);
+  let serialized;
+  try {
+    const sourceUrl = pathToFileURL(filePath).href;
+    const stdout = await runTrustedSourceProcess([
+      "--import",
+      runtime.loader,
+      "--input-type=module",
+      "--eval",
+      TEMPLATE_LOADER,
+      sourceUrl
+    ], { cwd, timeoutMs: options.timeoutMs, maxOutputBytes: options.maxOutputBytes });
+    serialized = JSON.parse(stdout);
+  } catch (error) {
+    const detail = error instanceof TrustedSourceProcessError || error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not load ${displayPath}: ${sanitizeTrustedSourceDiagnostic(detail, cwd, runtime.dependencyRoot)}`);
+  }
+  return {
+    exportName: serialized.exportName,
+    filePath,
+    importPath: `./templates/${basename2(filePath).replace(/\.(?:ts|tsx)$/, "")}`,
+    metadata: serialized.metadata,
+    ...Object.hasOwn(serialized, "examples") ? { examples: serialized.examples } : {}
+  };
+}
+async function discoverProjectTemplates(cwd, options = {}) {
+  const root = resolve3(cwd);
+  const templatesDirectory = safeProjectPath(root, "vanillasky/templates");
+  const excluded = new Set((options.excludeSourcePaths ?? []).map((path) => resolve3(path)));
+  const files = (await sourceFiles(templatesDirectory)).filter((file) => !excluded.has(resolve3(file)));
+  for (const file of files) safeProjectPath(root, file);
+  if (files.length === 0) return [];
+  const runtime = resolveProjectTsxRuntime();
+  const discovered = await mapWithConcurrency(
+    files,
+    LOADER_CONCURRENCY,
+    (file) => loadTemplate(file, root, options, runtime)
+  );
+  const byId = /* @__PURE__ */ new Map();
+  for (const template of discovered) {
+    const duplicate = byId.get(template.metadata.id);
+    if (duplicate) {
+      throw new Error(
+        `Duplicate template id ${JSON.stringify(template.metadata.id)} in ${relative2(cwd, duplicate.filePath)} and ${relative2(cwd, template.filePath)}`
+      );
+    }
+    byId.set(template.metadata.id, template);
+  }
+  return discovered;
+}
+
+// src/cli/sync.ts
+var GENERATED_NOTICE = "// Generated by `vanillasky sync`. Do not edit.\n";
+function browserSource(templates) {
+  const imports = templates.map(({ exportName, importPath }, index) => exportName === "default" ? `import template${index} from ${JSON.stringify(importPath)};` : `import { ${exportName} as template${index} } from ${JSON.stringify(importPath)};`);
+  const names = templates.map((_, index) => `template${index}`);
+  return [
+    GENERATED_NOTICE.trimEnd(),
+    'import { createTemplateRegistry } from "@vanillaskyai/video/templates";',
+    ...imports,
+    "",
+    `export const definitions = [${names.join(", ")}];`,
+    "export const templates = createTemplateRegistry({ definitions });",
+    ""
+  ].join("\n");
+}
+function serverSource(templates) {
+  const metadata = JSON.stringify(templates.map(({ metadata: value }) => value), null, 2);
+  return [
+    GENERATED_NOTICE.trimEnd(),
+    'import { createServerTemplateRegistry } from "@vanillaskyai/video/server";',
+    'import type { ServerTemplateMetadata } from "@vanillaskyai/video/server";',
+    "",
+    `const templateMetadata: ServerTemplateMetadata[] = ${metadata};`,
+    "export const templates = createServerTemplateRegistry({ templates: templateMetadata });",
+    ""
+  ].join("\n");
+}
+async function currentSource(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function generatedOutputs(cwd, discovered) {
+  const vanillaskyDirectory = join4(cwd, "vanillasky");
+  return [
+    { path: join4(vanillaskyDirectory, "index.ts"), source: browserSource(discovered) },
+    { path: join4(vanillaskyDirectory, "server.ts"), source: serverSource(discovered) }
+  ];
+}
+async function previewTemplateSync(options) {
+  const cwd = resolve4(options.cwd);
+  const replacements = new Set(options.templates.map(({ sourcePath }) => safeProjectPath(cwd, sourcePath)));
+  const installed = await discoverProjectTemplates(cwd, { excludeSourcePaths: [...replacements] });
+  const proposed = options.templates.map((template) => ({
+    ...template,
+    filePath: safeProjectPath(cwd, template.sourcePath)
+  }));
+  const templates = [...installed, ...proposed].sort((left, right) => left.filePath.localeCompare(right.filePath));
+  const byId = /* @__PURE__ */ new Map();
+  for (const template of templates) {
+    const duplicate = byId.get(template.metadata.id);
+    if (duplicate) {
+      throw new Error(
+        `Duplicate template id ${JSON.stringify(template.metadata.id)} in ${relative3(cwd, duplicate.filePath)} and ${relative3(cwd, template.filePath)}`
+      );
+    }
+    byId.set(template.metadata.id, template);
+  }
+  const changes = [];
+  for (const output of generatedOutputs(cwd, templates)) {
+    safeProjectPath(cwd, output.path);
+    const before = await currentSource(output.path);
+    if (before === output.source) continue;
+    changes.push({
+      path: relative3(cwd, output.path),
+      action: before == null ? "create" : "update",
+      ...before == null ? {} : { before },
+      after: output.source
+    });
+  }
+  return changes;
+}
+async function inspectGeneratedTemplateStatus(cwd, discovered) {
+  const root = resolve4(cwd);
+  const stale = [];
+  for (const output of generatedOutputs(root, discovered)) {
+    safeProjectPath(root, output.path);
+    if (await currentSource(output.path) !== output.source) stale.push(relative3(root, output.path));
+  }
+  return {
+    browser: { path: "vanillasky/index.ts", current: !stale.includes("vanillasky/index.ts") },
+    server: { path: "vanillasky/server.ts", current: !stale.includes("vanillasky/server.ts") },
+    current: stale.length === 0,
+    stale
+  };
+}
+async function unlinkIfPresent(path) {
+  try {
+    await unlink(path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+async function writeStagedFile(path, source) {
+  const handle = await open(path, "wx", 420);
+  try {
+    await handle.writeFile(source, "utf8");
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+}
+async function writeOutputsTransactionally(cwd, outputs, renameFile, unlinkFile) {
+  const planned = outputs.map((output) => {
+    safeProjectPath(cwd, output.path);
+    const nonce = randomUUID2();
+    const directory = dirname2(output.path);
+    return {
+      ...output,
+      temporary: join4(directory, `.${basename3(output.path)}.vanillasky-stage-${nonce}`),
+      backup: join4(directory, `.${basename3(output.path)}.vanillasky-backup-${nonce}`),
+      hadPrevious: lstatSync2(output.path, { throwIfNoEntry: false }) != null,
+      backupCreated: false,
+      installed: false
+    };
+  });
+  try {
+    for (const output of planned) {
+      safeProjectPath(cwd, output.temporary);
+      safeProjectPath(cwd, output.backup);
+      await writeStagedFile(output.temporary, output.source);
+    }
+    for (const output of planned) {
+      safeProjectPath(cwd, output.path);
+      if (output.hadPrevious) {
+        await renameFile(output.path, output.backup);
+        output.backupCreated = true;
+      }
+      await renameFile(output.temporary, output.path);
+      output.installed = true;
+    }
+  } catch (error) {
+    for (const output of [...planned].reverse()) {
+      if (output.installed) await unlinkIfPresent(output.path);
+      if (output.backupCreated) await rename(output.backup, output.path);
+      await unlinkIfPresent(output.temporary);
+    }
+    throw error;
+  }
+  const warnings = [];
+  for (const output of planned) {
+    try {
+      await unlinkFile(output.backup);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        warnings.push(`Could not remove transaction backup: ${relative3(cwd, output.backup)}`);
+      }
+    }
+  }
+  return warnings;
+}
+async function syncTemplates(options = {}) {
+  const cwd = resolve4(options.cwd ?? process.cwd());
+  const vanillaskyDirectory = join4(cwd, "vanillasky");
+  const discovered = await discoverProjectTemplates(cwd, { timeoutMs: options.timeoutMs });
+  const outputs = generatedOutputs(cwd, discovered);
+  for (const output of outputs) safeProjectPath(cwd, output.path);
+  const drifted = [];
+  let warnings = [];
+  for (const output of outputs) {
+    if (await currentSource(output.path) !== output.source) drifted.push(relative3(cwd, output.path));
+  }
+  if (options.check && drifted.length > 0) {
+    throw new Error(`Generated template files are out of date: ${drifted.join(", ")}. Run \`vanillasky sync\`.`);
+  }
+  if (!options.check && drifted.length > 0) {
+    await mkdir(vanillaskyDirectory, { recursive: true });
+    const changedOutputs = outputs.filter((output) => drifted.includes(relative3(cwd, output.path)));
+    for (const output of changedOutputs) safeProjectPath(cwd, output.path);
+    warnings = await writeOutputsTransactionally(cwd, changedOutputs, options.renameFile ?? rename, options.unlinkFile ?? unlink);
+  }
+  return {
+    changed: drifted.length > 0,
+    files: drifted,
+    templates: discovered.map(({ metadata }) => metadata.id),
+    warnings
+  };
+}
+
+// src/cli/check.ts
+import { createHash } from "crypto";
+import { join as join5, relative as relative4, resolve as resolve5 } from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var DEFAULT_TIMEOUT_MS2 = 15e3;
+var checkRuntimeUrl = new URL("./check-runtime.js", import.meta.url).href;
+var JOBS = new Set(BUILTIN_TEMPLATE_MANIFEST.flatMap(({ jobs }) => jobs));
+var REGISTERS = new Set(BUILTIN_TEMPLATE_MANIFEST.map(({ register }) => register));
+var TEXT_CANVASES = new Set(BUILTIN_TEMPLATE_MANIFEST.map(({ textCanvas }) => textCanvas));
+var FAMILIES = new Set(BUILTIN_TEMPLATE_MANIFEST.map(({ family }) => family));
+var CONTENT_UNITS = new Set(BUILTIN_TEMPLATE_MANIFEST.map(({ timing }) => timing.contentUnit));
+var PROPERTY_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "format",
+  "enum",
+  "title",
+  "description",
+  "default",
+  "examples",
+  "minItems",
+  "maxItems",
+  "minLength",
+  "maxLength",
+  "minimum",
+  "maximum",
+  "items",
+  "properties",
+  "required",
+  "additionalProperties"
+]);
+var SCHEMA_KEYS = /* @__PURE__ */ new Set(["type", "properties", "required", "additionalProperties", "x-vanillasky"]);
+var SCHEMA_EXTENSION_KEYS = /* @__PURE__ */ new Set(["requiresStat", "allowsStockMedia", "requiredAnyOf"]);
+var METADATA_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "label",
+  "description",
+  "category",
+  "family",
+  "jobs",
+  "register",
+  "useWhen",
+  "avoidWhen",
+  "usesGlobalTextEffect",
+  "usesGlobalTransition",
+  "transitionTiming",
+  "usesGlobalBackgroundEffect",
+  "textCanvas",
+  "schema",
+  "minDuration",
+  "preferredDuration",
+  "timing"
+]);
+function assertJson(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (Number.isFinite(value)) return;
+    throw new Error(`${path} must contain only finite JSON numbers`);
+  }
+  if (typeof value !== "object") throw new Error(`${path} contains a non-serializable ${typeof value}`);
+  if (seen.has(value)) throw new Error(`${path} contains a circular value`);
+  seen.add(value);
+  if (Array.isArray(value)) value.forEach((entry, index) => assertJson(entry, `${path}[${index}]`, seen));
+  else {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) throw new Error(`${path} contains a non-serializable object`);
+    for (const [key, entry] of Object.entries(value)) assertJson(entry, `${path}.${key}`, seen);
+  }
+  seen.delete(value);
+}
+function validateRequired(required, properties, path) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const key of required ?? []) {
+    if (typeof key !== "string" || !Object.hasOwn(properties, key)) throw new Error(`${path} references undeclared property ${JSON.stringify(key)}`);
+    if (seen.has(key)) throw new Error(`${path} contains duplicate property ${JSON.stringify(key)}`);
+    seen.add(key);
+  }
+}
+function validateProperty(property, path, optional) {
+  if (!property || typeof property !== "object" || Array.isArray(property)) throw new Error(`${path} must be an object`);
+  for (const key of Object.keys(property)) if (!PROPERTY_KEYS.has(key)) throw new Error(`${path}.${key} is not supported`);
+  if (!property.type || !["string", "number", "integer", "boolean", "array", "object"].includes(property.type)) {
+    throw new Error(`${path}.type must be a supported JSON Schema type`);
+  }
+  if (property.format !== void 0 && !isTemplatePropertyFormatSupported(property.format, property.type)) {
+    throw new Error(`${path}.format is not supported`);
+  }
+  for (const key of ["title", "description"]) {
+    if (property[key] !== void 0 && typeof property[key] !== "string") throw new Error(`${path}.${key} must be string`);
+  }
+  if (property.examples !== void 0 && !Array.isArray(property.examples)) throw new Error(`${path}.examples must be an array`);
+  if (property.type !== "string") {
+    for (const key of ["enum", "minLength", "maxLength"]) if (property[key] !== void 0) throw new Error(`${path}.${key} is only supported for strings`);
+  }
+  if (property.type !== "number" && property.type !== "integer") {
+    for (const key of ["minimum", "maximum"]) if (property[key] !== void 0) throw new Error(`${path}.${key} is only supported for numbers`);
+  }
+  if (property.type !== "array") {
+    for (const key of ["minItems", "maxItems"]) if (property[key] !== void 0) throw new Error(`${path}.${key} is only supported for arrays`);
+  }
+  if (property.enum !== void 0 && (!Array.isArray(property.enum) || property.enum.length === 0 || property.enum.some((value) => typeof value !== "string"))) {
+    throw new Error(`${path}.enum must contain one or more strings`);
+  }
+  for (const key of ["minItems", "maxItems", "minLength", "maxLength"]) {
+    const value = property[key];
+    if (value !== void 0 && (!Number.isInteger(value) || value < 0)) throw new Error(`${path}.${key} must be a non-negative integer`);
+  }
+  for (const key of ["minimum", "maximum"]) {
+    const value = property[key];
+    if (value !== void 0 && !Number.isFinite(value)) throw new Error(`${path}.${key} must be finite`);
+  }
+  if (property.minItems != null && property.maxItems != null && property.minItems > property.maxItems) throw new Error(`${path}.minItems must not exceed maxItems`);
+  if (property.minLength != null && property.maxLength != null && property.minLength > property.maxLength) throw new Error(`${path}.minLength must not exceed maxLength`);
+  if (property.minimum != null && property.maximum != null && property.minimum > property.maximum) throw new Error(`${path}.minimum must not exceed maximum`);
+  if (property.type === "array") {
+    if (!property.items) throw new Error(`${path}.items is required for arrays`);
+    validateProperty(property.items, `${path}.items`, false);
+  } else if (property.items !== void 0) throw new Error(`${path}.items is only supported for arrays`);
+  if (property.type === "object") {
+    if (!property.properties || typeof property.properties !== "object" || Array.isArray(property.properties)) throw new Error(`${path}.properties must be an object`);
+    if (property.required !== void 0 && !Array.isArray(property.required)) throw new Error(`${path}.required must be an array`);
+    if (property.additionalProperties !== void 0 && typeof property.additionalProperties !== "boolean") throw new Error(`${path}.additionalProperties must be boolean`);
+    validateRequired(property.required, property.properties, `${path}.required`);
+    const required = new Set(property.required ?? []);
+    for (const [name, child] of Object.entries(property.properties)) validateProperty(child, `${path}.properties.${name}`, !required.has(name));
+  } else if (property.properties !== void 0 || property.required !== void 0 || property.additionalProperties !== void 0) {
+    throw new Error(`${path} object keywords require type object`);
+  }
+  if (property.default !== void 0) {
+    assertJson(property.default, `${path}.default`);
+    validateTemplateSchemaValue(property, property.default, `${path}.default`, {
+      allowEmptyOptionalMedia: true,
+      optional
+    });
+  }
+  for (const [index, example] of (property.examples ?? []).entries()) {
+    assertJson(example, `${path}.examples[${index}]`);
+    validateTemplateSchemaValue(property, example, `${path}.examples[${index}]`, {
+      allowEmptyOptionalMedia: true,
+      optional
+    });
+  }
+}
+function validateSchema(schema) {
+  for (const key of Object.keys(schema)) if (!SCHEMA_KEYS.has(key)) throw new Error(`schema.${key} is not supported`);
+  if (schema.type !== "object" || !schema.properties || typeof schema.properties !== "object" || Array.isArray(schema.properties)) {
+    throw new Error("schema must describe an object with properties");
+  }
+  if (schema.required !== void 0 && !Array.isArray(schema.required)) throw new Error("schema.required must be an array");
+  validateRequired(schema.required, schema.properties, "schema.required");
+  if (schema.additionalProperties !== void 0 && typeof schema.additionalProperties !== "boolean") throw new Error("schema.additionalProperties must be boolean");
+  const extension = schema["x-vanillasky"];
+  if (extension !== void 0) {
+    if (!extension || typeof extension !== "object" || Array.isArray(extension)) throw new Error("schema.x-vanillasky must be an object");
+    for (const key of Object.keys(extension)) if (!SCHEMA_EXTENSION_KEYS.has(key)) throw new Error(`schema.x-vanillasky.${key} is not supported`);
+    for (const key of ["requiresStat", "allowsStockMedia"]) {
+      if (extension[key] !== void 0 && typeof extension[key] !== "boolean") throw new Error(`schema.x-vanillasky.${key} must be boolean`);
+    }
+    if (extension.requiredAnyOf !== void 0) {
+      if (!Array.isArray(extension.requiredAnyOf)) throw new Error("schema.x-vanillasky.requiredAnyOf must be an array");
+      for (const [groupIndex, group] of extension.requiredAnyOf.entries()) {
+        const path = `schema.x-vanillasky.requiredAnyOf[${groupIndex}]`;
+        if (!Array.isArray(group) || group.length === 0) throw new Error(`${path} must contain at least one property`);
+        for (const field of group) {
+          if (typeof field !== "string" || !Object.hasOwn(schema.properties, field)) {
+            throw new Error(`${path} references undeclared property ${JSON.stringify(field)}`);
+          }
+        }
+      }
+    }
+  }
+  const required = new Set(schema.required ?? []);
+  for (const [name, property] of Object.entries(schema.properties)) validateProperty(property, `schema.properties.${name}`, !required.has(name));
+}
+function validateVariables(schema, variables, path, enforceRequiredAnyOf) {
+  assertJson(variables, path);
+  for (const required2 of schema.required ?? []) if (!Object.hasOwn(variables, required2)) throw new Error(`${path}.${required2} is required`);
+  if (schema.additionalProperties === false) {
+    for (const key of Object.keys(variables)) if (!Object.hasOwn(schema.properties, key)) throw new Error(`${path}.${key} is not declared`);
+  }
+  const required = new Set(schema.required ?? []);
+  for (const [key, property] of Object.entries(schema.properties)) {
+    if (Object.hasOwn(variables, key)) validateTemplateSchemaValue(property, variables[key], `${path}.${key}`, {
+      allowEmptyOptionalMedia: true,
+      optional: !required.has(key)
+    });
+  }
+  if (enforceRequiredAnyOf) {
+    for (const group of schema["x-vanillasky"]?.requiredAnyOf ?? []) {
+      if (group.some((field) => Object.hasOwn(variables, field) && isMeaningfullyPresentTemplateValue(variables[field]))) continue;
+      throw new Error(`${path} requires a non-empty value for ${group.join(" or ")}`);
+    }
+  }
+}
+function validateTemplate(template, cwd) {
+  const metadata = template.metadata;
+  const file = relative4(cwd, template.filePath);
+  const fail = (message) => {
+    throw new Error(`${file}: ${message}`);
+  };
+  try {
+    for (const key of Object.keys(metadata)) if (!METADATA_KEYS.has(key)) throw new Error(`metadata.${key} is not supported`);
+    if (!/^[A-Za-z][A-Za-z0-9_-]*$/.test(metadata.id)) throw new Error(`invalid template id ${JSON.stringify(metadata.id)}`);
+    if (typeof metadata.useWhen !== "string" || !metadata.useWhen.trim()) throw new Error("useWhen must be a non-empty string");
+    for (const key of ["label", "description", "avoidWhen"]) if (metadata[key] !== void 0 && typeof metadata[key] !== "string") throw new Error(`${key} must be string`);
+    if (metadata.category !== void 0 && metadata.category !== null && typeof metadata.category !== "string") throw new Error("category must be string or null");
+    for (const key of ["usesGlobalTextEffect", "usesGlobalTransition", "usesGlobalBackgroundEffect"]) {
+      if (typeof metadata[key] !== "boolean") throw new Error(`${key} must be boolean`);
+    }
+    assertTemplateTransitionMetadata(metadata);
+    if (metadata.jobs !== void 0) {
+      if (!Array.isArray(metadata.jobs) || metadata.jobs.some((job) => !JOBS.has(job))) throw new Error("jobs contains an unsupported value");
+      const jobs = /* @__PURE__ */ new Set();
+      for (const job of metadata.jobs) {
+        if (jobs.has(job)) throw new Error(`jobs contains duplicate value ${JSON.stringify(job)}`);
+        jobs.add(job);
+      }
+    }
+    if (metadata.register !== void 0 && !REGISTERS.has(metadata.register)) throw new Error("register contains an unsupported value");
+    if (metadata.textCanvas !== void 0 && !TEXT_CANVASES.has(metadata.textCanvas)) throw new Error("textCanvas contains an unsupported value");
+    if (metadata.family !== void 0 && !FAMILIES.has(metadata.family)) throw new Error("family contains an unsupported value");
+    for (const key of ["minDuration", "preferredDuration"]) {
+      const duration = metadata[key];
+      if (duration !== void 0 && (!Number.isFinite(duration) || duration <= 0)) throw new Error(`${key} must be finite and positive`);
+    }
+    if (metadata.minDuration != null && metadata.preferredDuration != null && metadata.minDuration > metadata.preferredDuration) {
+      throw new Error("minDuration must not exceed preferredDuration");
+    }
+    validateSchema(metadata.schema);
+    if (metadata.timing !== void 0) {
+      if (!metadata.timing || typeof metadata.timing !== "object" || Array.isArray(metadata.timing)) throw new Error("timing must be an object");
+      for (const key of Object.keys(metadata.timing)) if (!(/* @__PURE__ */ new Set(["contentFields", "contentUnit"])).has(key)) throw new Error(`timing.${key} is not supported`);
+      if (!Array.isArray(metadata.timing.contentFields) || metadata.timing.contentFields.length === 0) throw new Error("timing.contentFields must contain at least one schema property");
+      const timingFields = /* @__PURE__ */ new Set();
+      for (const field of metadata.timing.contentFields) {
+        if (typeof field !== "string" || !Object.hasOwn(metadata.schema.properties, field)) throw new Error(`timing.contentFields references undeclared property ${JSON.stringify(field)}`);
+        if (timingFields.has(field)) throw new Error(`timing.contentFields contains duplicate property ${JSON.stringify(field)}`);
+        timingFields.add(field);
+      }
+      if (!CONTENT_UNITS.has(metadata.timing.contentUnit)) throw new Error("timing.contentUnit contains an unsupported value");
+    }
+    const defaults = getTemplateDefaults(metadata.schema);
+    if (template.examples !== void 0 && !Array.isArray(template.examples)) throw new Error("examples must be an array");
+    const supplied = template.examples ?? [];
+    for (const [index, value] of supplied.entries()) {
+      if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`examples[${index}] must be a plain object`);
+      for (const key of Object.keys(value)) if (!(/* @__PURE__ */ new Set(["name", "variables"])).has(key)) throw new Error(`examples[${index}].${key} is not supported`);
+      const candidate = value;
+      if (!candidate.variables || typeof candidate.variables !== "object" || Array.isArray(candidate.variables)) {
+        throw new Error(`example ${JSON.stringify(candidate.name)} variables must be a plain object`);
+      }
+    }
+    const examples = supplied.length > 0 ? supplied.map(({ name, variables }) => ({
+      name,
+      variables: { ...defaults, ...variables },
+      enforceRequiredAnyOf: true
+    })) : [{ name: "defaults", variables: defaults, enforceRequiredAnyOf: false }];
+    const names = /* @__PURE__ */ new Set();
+    for (const example of examples) {
+      if (typeof example.name !== "string" || !example.name.trim()) throw new Error("example names must be non-empty strings");
+      if (names.has(example.name)) throw new Error(`duplicate example name ${JSON.stringify(example.name)}`);
+      names.add(example.name);
+      validateVariables(
+        metadata.schema,
+        example.variables,
+        `example ${JSON.stringify(example.name)}`,
+        example.enforceRequiredAnyOf
+      );
+    }
+    return examples;
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+}
+var RENDER_LOADER = String.raw`
+const [runtimeUrl, payload] = process.argv.slice(1);
+const { writeSync } = await import("node:fs");
+for (const method of ["log", "info", "warn", "error", "debug", "dir", "trace"]) console[method] = () => undefined;
+const { renderTemplateChecks } = await import(runtimeUrl);
+const result = await renderTemplateChecks(JSON.parse(payload));
+writeSync(3, JSON.stringify(result));
+`;
+async function renderExample(template, example, cwd, timeoutMs, maxOutputBytes, runtime) {
+  try {
+    const payload = JSON.stringify({
+      sourceUrl: pathToFileURL2(template.filePath).href,
+      exportName: template.exportName,
+      templateId: template.metadata.id,
+      exampleName: example.name,
+      variables: example.variables,
+      duration: template.metadata.preferredDuration ?? template.metadata.minDuration ?? 5,
+      timeoutMs
+    });
+    const output = await runTrustedSourceProcess([
+      "--import",
+      runtime.loader,
+      "--input-type=module",
+      "--eval",
+      RENDER_LOADER,
+      checkRuntimeUrl,
+      payload
+    ], { cwd, timeoutMs, maxOutputBytes, operation: "template rendering" });
+    return JSON.parse(output).renders;
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not render ${relative4(cwd, template.filePath)}: ${sanitizeTrustedSourceDiagnostic(detail, cwd, runtime.dependencyRoot)}`);
+  }
+}
+var REGISTRY_LOADER = String.raw`
+const [browserUrl, serverUrl] = process.argv.slice(1);
+const { writeSync } = await import("node:fs");
+for (const method of ["log", "info", "warn", "error", "debug", "dir", "trace"]) console[method] = () => undefined;
+const browser = await import(browserUrl + "?check=" + Date.now());
+const server = await import(serverUrl + "?check=" + Date.now());
+writeSync(3, JSON.stringify({
+  browser: browser.templates.listTemplateMetadata(),
+  server: server.templates.listTemplateMetadata(),
+}));
+`;
+function stable(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(stable).join(",")}]`;
+  return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${stable(child)}`).join(",")}}`;
+}
+async function verifyGeneratedParity(cwd, expected, timeoutMs, maxOutputBytes, runtime) {
+  try {
+    const output = await runTrustedSourceProcess([
+      "--import",
+      runtime.loader,
+      "--input-type=module",
+      "--eval",
+      REGISTRY_LOADER,
+      pathToFileURL2(join5(cwd, "vanillasky/index.ts")).href,
+      pathToFileURL2(join5(cwd, "vanillasky/server.ts")).href
+    ], { cwd, timeoutMs, maxOutputBytes, operation: "generated registry parity" });
+    const loaded = JSON.parse(output);
+    const expectedFingerprint = createHash("sha256").update(stable(expected)).digest("hex");
+    for (const [entrypoint, metadata] of Object.entries(loaded)) {
+      const fingerprint = createHash("sha256").update(stable(metadata)).digest("hex");
+      if (fingerprint !== expectedFingerprint) {
+        throw new Error(`${entrypoint} registry metadata/IDs/order fingerprint differs from template sources`);
+      }
+    }
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`Generated registry parity failed: ${sanitizeTrustedSourceDiagnostic(detail, cwd, runtime.dependencyRoot)}`);
+  }
+}
+async function checkTemplates(options = {}) {
+  const cwd = resolve5(options.cwd ?? process.cwd());
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS2;
+  const templates = await discoverProjectTemplates(cwd, {
+    timeoutMs,
+    maxOutputBytes: options.maxOutputBytes
+  });
+  if (templates.length === 0) throw new Error("No templates found in vanillasky/templates.");
+  const runtime = resolveProjectTsxRuntime();
+  const examples = templates.map((template) => ({ template, examples: validateTemplate(template, cwd) }));
+  await syncTemplates({ cwd, check: true, timeoutMs });
+  let renders = 0;
+  for (const item2 of examples) {
+    for (const example of item2.examples) {
+      renders += await renderExample(item2.template, example, cwd, timeoutMs, options.maxOutputBytes, runtime);
+    }
+  }
+  await verifyGeneratedParity(cwd, templates.map(({ metadata }) => metadata), timeoutMs, options.maxOutputBytes, runtime);
+  return {
+    templates: templates.length,
+    examples: examples.reduce((count, item2) => count + item2.examples.length, 0),
+    renders
+  };
+}
+
+// src/cli/create.ts
+import { link, lstat, mkdir as mkdir2, open as open2, rmdir, unlink as unlink2 } from "fs/promises";
+import { join as join6, relative as relative5, resolve as resolve6 } from "path";
+var TEMPLATE_ID = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var MAX_TEMPLATE_ID_BYTES = 128;
+var WINDOWS_RESERVED_BASENAME = /^(?:CON|PRN|AUX|NUL|COM[1-9]|LPT[1-9])$/i;
+var temporaryFileSequence = 0;
+function titleFor(id) {
+  return id.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").split(" ").filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join(" ");
+}
+function sourceFor(id) {
+  const title = titleFor(id);
+  const titleLiteral = JSON.stringify(title);
+  return `import { defineTemplate } from "@vanillaskyai/video/templates";
+
+export const template = defineTemplate({
+  id: ${JSON.stringify(id)},
+  label: ${titleLiteral},
+  description: "A focused headline and supporting detail for a grounded visual response.",
+  useWhen: "Use when the response should emphasize ${title} with one concise supporting detail.",
+  schema: {
+    type: "object",
+    properties: {
+      title: {
+        type: "string",
+        title: "Headline",
+        description: "The main grounded point the viewer should remember.",
+        minLength: 1,
+        maxLength: 72,
+        default: ${titleLiteral},
+      },
+      subtitle: {
+        type: "string",
+        title: "Supporting detail",
+        description: "One concise detail that explains or grounds the headline.",
+        minLength: 1,
+        maxLength: 140,
+        default: "A visual response grounded in the available context.",
+      },
+    },
+    required: ["title", "subtitle"],
+    additionalProperties: false,
+  } as const,
+  examples: [{
+    name: "${title} update",
+    variables: {
+      title: ${titleLiteral},
+      subtitle: "A visual response grounded in the available context.",
+    },
+  }],
+  minDuration: 3,
+  preferredDuration: 5,
+  component: ({ variables, progress, width, height, safeZone }) => {
+    const isPortrait = height >= width;
+    const reveal = Math.max(0, Math.min(1, progress * 1.5));
+    const contentWidth = isPortrait
+      ? width - safeZone.left - safeZone.right
+      : Math.min(width * 0.72, 960);
+
+    return <section style={{
+      boxSizing: "border-box",
+      width,
+      height,
+      padding: safeZone.top + "px " + safeZone.right + "px " + safeZone.bottom + "px " + safeZone.left + "px",
+      display: "grid",
+      placeItems: "center",
+      overflow: "hidden",
+      color: "#ffffff",
+      background: "linear-gradient(145deg, #15112b 0%, #382f73 55%, #7658d6 100%)",
+      fontFamily: "Inter, ui-sans-serif, system-ui, sans-serif",
+    }}>
+      <div style={{
+        width: contentWidth,
+        opacity: reveal,
+        transform: "translateY(" + Math.round((1 - reveal) * 24) + "px)",
+        textAlign: isPortrait ? "left" : "center",
+      }}>
+        <h1 style={{
+          margin: 0,
+          fontSize: Math.max(34, Math.min(width * (isPortrait ? 0.1 : 0.065), 88)),
+          lineHeight: 0.98,
+          letterSpacing: "-0.045em",
+        }}>
+          {variables.title}
+        </h1>
+        <p style={{
+          margin: Math.max(18, height * 0.035) + "px 0 0",
+          maxWidth: isPortrait ? "100%" : 760,
+          fontSize: Math.max(18, Math.min(width * 0.03, 34)),
+          lineHeight: 1.35,
+          color: "rgba(255, 255, 255, 0.78)",
+        }}>
+          {variables.subtitle}
+        </p>
+      </div>
+    </section>;
+  },
+});
+`;
+}
+async function status(path) {
+  try {
+    return await lstat(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+async function assertDirectoryOrMissing(path, displayPath) {
+  const existing = await status(path);
+  if (!existing) return false;
+  if (existing.isSymbolicLink()) throw new Error(`Refusing to create through symbolic link: ${displayPath}`);
+  if (!existing.isDirectory()) throw new Error(`Template path ancestor is not a directory: ${displayPath}`);
+  return true;
+}
+async function removeCreatedDirectories(paths) {
+  for (const path of [...paths].reverse()) {
+    try {
+      await rmdir(path);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTEMPTY") throw error;
+    }
+  }
+}
+async function createTemplate(options) {
+  const cwd = resolve6(options.cwd ?? process.cwd());
+  const { id } = options;
+  if (!TEMPLATE_ID.test(id)) {
+    throw new Error(`Invalid template id: ${JSON.stringify(id)}. Use a letter first, followed by letters, numbers, _ or -.`);
+  }
+  if (Buffer.byteLength(id, "utf8") > MAX_TEMPLATE_ID_BYTES) {
+    throw new Error(`Invalid template id: template ids must be at most ${MAX_TEMPLATE_ID_BYTES} UTF-8 bytes.`);
+  }
+  const windowsBasename = `${id}.tsx`.replace(/[ .]+$/u, "").split(".", 1)[0];
+  if (WINDOWS_RESERVED_BASENAME.test(windowsBasename)) {
+    throw new Error(`Invalid template id: ${JSON.stringify(id)}. This name is reserved on Windows.`);
+  }
+  const vanillaskyDirectory = join6(cwd, "vanillasky");
+  const templatesDirectory = join6(vanillaskyDirectory, "templates");
+  const destination = join6(templatesDirectory, `${id}.tsx`);
+  const destinationPath = relative5(cwd, destination);
+  const createdDirectories = [];
+  for (const target of [destination, join6(vanillaskyDirectory, "index.ts"), join6(vanillaskyDirectory, "server.ts")]) {
+    safeProjectPath(cwd, target);
+  }
+  for (const [path, displayPath] of [
+    [vanillaskyDirectory, "vanillasky"],
+    [templatesDirectory, "vanillasky/templates"]
+  ]) {
+    if (!await assertDirectoryOrMissing(path, displayPath)) {
+      try {
+        await mkdir2(path);
+        createdDirectories.push(path);
+      } catch (error) {
+        if (error.code !== "EEXIST") throw error;
+        await assertDirectoryOrMissing(path, displayPath);
+      }
+    }
+    safeProjectPath(cwd, destination);
+  }
+  const existingDestination = await status(destination);
+  if (existingDestination?.isSymbolicLink()) {
+    await removeCreatedDirectories(createdDirectories);
+    throw new Error(`Refusing to replace symbolic link: ${destinationPath}`);
+  }
+  if (existingDestination) {
+    await removeCreatedDirectories(createdDirectories);
+    throw new Error(`Template already exists: ${destinationPath}`);
+  }
+  const temporary = join6(templatesDirectory, `.${id}.${process.pid}.${temporaryFileSequence += 1}.tmp`);
+  let temporaryExists = false;
+  let createdIdentity;
+  try {
+    const handle = await open2(temporary, "wx", 420);
+    temporaryExists = true;
+    try {
+      await handle.writeFile(sourceFor(id), "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    try {
+      await link(temporary, destination);
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new Error(`Template already exists: ${destinationPath}`);
+      }
+      throw error;
+    }
+    const created = await lstat(destination, { bigint: true });
+    createdIdentity = { dev: created.dev, ino: created.ino };
+    await unlink2(temporary);
+    temporaryExists = false;
+    const result = await (options.sync ?? syncTemplates)({ cwd });
+    const templates = typeof result === "object" && result != null && "templates" in result && Array.isArray(result.templates) ? result.templates.length : 1;
+    const warnings = typeof result === "object" && result != null && "warnings" in result && Array.isArray(result.warnings) ? result.warnings.filter((warning) => typeof warning === "string") : [];
+    return { path: destinationPath, templates, ...warnings.length > 0 ? { warnings } : {} };
+  } catch (error) {
+    if (temporaryExists) {
+      try {
+        await unlink2(temporary);
+      } catch (cleanupError) {
+        if (cleanupError.code !== "ENOENT") throw cleanupError;
+      }
+    }
+    if (createdIdentity) {
+      const current = await status(destination);
+      if (current && !current.isSymbolicLink()) {
+        const identity = await lstat(destination, { bigint: true });
+        if (identity.dev === createdIdentity.dev && identity.ino === createdIdentity.ino) await unlink2(destination);
+      }
+    }
+    await removeCreatedDirectories(createdDirectories);
+    throw error;
+  }
+}
+
+// src/cli/catalog.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join7 } from "path";
+function item(metadata, origin, generated) {
+  const useWhen = metadata.useWhen ?? metadata.description ?? "";
+  const current = generated == null ? null : generated.browser && generated.server;
+  return {
+    id: metadata.id,
+    title: metadata.label ?? metadata.id,
+    origin,
+    status: origin === "built-in" ? "available" : current ? "current" : "stale",
+    useWhen,
+    summary: metadata.description ?? "",
+    planner: {
+      useWhen,
+      ...metadata.avoidWhen == null ? {} : { avoidWhen: metadata.avoidWhen }
+    },
+    schema: metadata.schema,
+    schemaSummary: summarizeTemplateVariables(metadata.schema),
+    ...metadata.family == null ? {} : { family: metadata.family },
+    ...metadata.jobs == null ? {} : { jobs: metadata.jobs },
+    ...metadata.register == null ? {} : { register: metadata.register },
+    duration: {
+      ...metadata.minDuration == null ? {} : { min: metadata.minDuration },
+      ...metadata.preferredDuration == null ? {} : { preferred: metadata.preferredDuration }
+    },
+    generated: {
+      browser: { path: "vanillasky/index.ts", current: generated?.browser ?? null },
+      server: { path: "vanillasky/server.ts", current: generated?.server ?? null },
+      current
+    },
+    wiring: { applicationImportsInspected: false, verified: false }
+  };
+}
+function builtinTemplateCatalog() {
+  return listBuiltinTemplateMetadata().map((metadata) => item(metadata, "built-in", null)).sort((left, right) => left.id.localeCompare(right.id));
+}
+function hasProjectTemplateSources(cwd) {
+  const directory = join7(cwd, "vanillasky/templates");
+  if (!existsSync2(directory)) return false;
+  return readdirSync2(directory, { withFileTypes: true }).some((entry) => (entry.isFile() || entry.isSymbolicLink()) && /\.(?:ts|tsx)$/.test(entry.name));
+}
+async function effectiveTemplateCatalog(cwd) {
+  const builtins = builtinTemplateCatalog();
+  const discovered = await discoverProjectTemplates(cwd);
+  if (discovered.length === 0) return builtins;
+  const generated = await inspectGeneratedTemplateStatus(cwd, discovered);
+  const byId = new Map(builtins.map((entry) => [entry.id, entry]));
+  for (const template of discovered) {
+    byId.set(template.metadata.id, item(template.metadata, "project", {
+      browser: generated.browser.current,
+      server: generated.server.current
+    }));
+  }
+  return [...byId.values()].sort((left, right) => left.id.localeCompare(right.id));
+}
+function findBuiltinTemplate(id) {
+  return builtinTemplateCatalog().find((entry) => entry.id === id);
+}
+async function findEffectiveTemplate(cwd, id) {
+  return (await effectiveTemplateCatalog(cwd)).find((entry) => entry.id === id);
+}
+
+// src/cli/index.ts
+function help() {
+  return [
+    "VanillaSky source-owned templates",
+    "",
+    "Usage:",
+    "  vanillasky list [--builtin] [--json]",
+    "  vanillasky describe <template> [--builtin] [--json]",
+    "  vanillasky add <template...> [--dry-run|--diff] [--overwrite]",
+    "  vanillasky add --all [--dry-run|--diff] [--overwrite]",
+    "  vanillasky sync [--check]",
+    "  vanillasky check",
+    "  vanillasky create <id>"
+  ].join("\n");
+}
+function unknownOption(command, args, allowed) {
+  const known = new Set(allowed);
+  const unknown = args.find((arg) => arg.startsWith("-") && !known.has(arg));
+  return unknown ? `Unknown ${command} option: ${unknown}` : void 0;
+}
+function compactDiff(change) {
+  const before = change.before?.split("\n") ?? [];
+  const after = change.after.split("\n");
+  let prefix = 0;
+  while (prefix < before.length && prefix < after.length && before[prefix] === after[prefix]) prefix += 1;
+  let suffix = 0;
+  while (suffix < before.length - prefix && suffix < after.length - prefix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) suffix += 1;
+  const removed = before.slice(prefix, before.length - suffix);
+  const added = after.slice(prefix, after.length - suffix);
+  return [
+    `--- ${change.path}`,
+    `+++ ${change.path}`,
+    `@@ -${prefix + 1},${removed.length} +${prefix + 1},${added.length} @@`,
+    ...removed.map((line) => `-${line}`),
+    ...added.map((line) => `+${line}`)
+  ].join("\n");
+}
+function sanitizeTerminalOutput(value) {
+  return [...value].filter((character) => {
+    const code = character.charCodeAt(0);
+    return code > 159 || code > 31 && code < 127 || code === 9 || code === 10;
+  }).join("");
+}
+function runVanillaSkyCli(argv, environment = {}) {
+  const output = environment.write ?? console.log;
+  const write = (line) => output(sanitizeTerminalOutput(line));
+  const cwd = resolve7(environment.cwd ?? process.cwd());
+  const [command, ...args] = argv;
+  if (command === "create") {
+    return (async () => {
+      try {
+        const unknown = unknownOption("create", args, []);
+        if (unknown) throw new Error(unknown);
+        if (args.length === 0) throw new Error("Choose one template id. Usage: vanillasky create <id>.");
+        if (args.length > 1) throw new Error(`Unexpected create argument: ${args[1]}`);
+        const id = args[0];
+        const result = await createTemplate({ cwd, id });
+        write(`Created template: ${result.path}`);
+        write(`Synced ${result.templates} template${result.templates === 1 ? "" : "s"} to vanillasky/index.ts and vanillasky/server.ts.`);
+        write(`Source: ${result.path}`);
+        write("Validate templates: vanillasky check");
+        for (const warning of result.warnings ?? []) write(`Warning: ${warning}`);
+        return 0;
+      } catch (error) {
+        write(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+    })();
+  }
+  if (command === "check") {
+    return (async () => {
+      try {
+        const unknown = unknownOption("check", args, []);
+        if (unknown) throw new Error(unknown);
+        if (args.length > 0) throw new Error(`Unexpected check argument: ${args[0]}`);
+        const result = await checkTemplates({ cwd });
+        write(`Checked ${result.templates} template${result.templates === 1 ? "" : "s"}, ${result.examples} example${result.examples === 1 ? "" : "s"}, and ${result.renders} deterministic renders.`);
+        write("Generated browser/server registries match. Application imports were not inspected.");
+        return 0;
+      } catch (error) {
+        write(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+    })();
+  }
+  if (command === "sync") {
+    return (async () => {
+      try {
+        const unknown = unknownOption("sync", args, ["--check"]);
+        if (unknown) throw new Error(unknown);
+        const result = await syncTemplates({ cwd, check: args.includes("--check") });
+        if (args.includes("--check")) {
+          write("Template entrypoints are up to date.");
+        } else {
+          const count = result.templates.length;
+          write(`Synced ${count} template${count === 1 ? "" : "s"} to vanillasky/index.ts and vanillasky/server.ts.`);
+        }
+        for (const warning of result.warnings) write(`Warning: ${warning}`);
+        return 0;
+      } catch (error) {
+        write(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+    })();
+  }
+  if (command === "list") {
+    const unknown = unknownOption("list", args, ["--builtin", "--json"]);
+    if (unknown) {
+      write(unknown);
+      return 1;
+    }
+    const positional = args.filter((arg) => !["--builtin", "--json"].includes(arg));
+    if (positional.length > 0) {
+      write(`Unexpected list argument: ${positional[0]}`);
+      return 1;
+    }
+    const render = (items) => {
+      if (args.includes("--json")) write(JSON.stringify(items.map((item2) => ({
+        id: item2.id,
+        title: item2.title,
+        origin: item2.origin,
+        status: item2.status,
+        useWhen: item2.useWhen,
+        summary: item2.summary
+      })), null, 2));
+      else {
+        write("ID	ORIGIN	STATUS	USE WHEN");
+        for (const item2 of items) write(`${item2.id}	${item2.origin}	${item2.status}	${item2.useWhen}`);
+      }
+      return 0;
+    };
+    if (args.includes("--builtin") || !hasProjectTemplateSources(cwd)) return render(builtinTemplateCatalog());
+    return effectiveTemplateCatalog(cwd).then(render).catch((error) => {
+      write(error instanceof Error ? error.message : String(error));
+      return 1;
+    });
+  }
+  if (command === "add") {
+    const allowed = ["--all", "--dry-run", "--diff", "--overwrite"];
+    const unknown = unknownOption("add", args, allowed);
+    if (unknown) {
+      write(unknown);
+      return 1;
+    }
+    const dryRun = args.includes("--dry-run");
+    const showDiff = args.includes("--diff");
+    if (dryRun && showDiff) {
+      write("Choose either --dry-run or --diff.");
+      return 1;
+    }
+    const addAll = args.includes("--all");
+    const positional = args.filter((arg) => !allowed.includes(arg));
+    if (addAll && positional.length > 0) {
+      write("Use either named templates or --all.");
+      return 1;
+    }
+    const names = addAll ? listRegistryTemplates().map(({ id }) => id) : positional;
+    if (names.length === 0) {
+      write("Choose at least one template. Run `vanillasky list` to see the catalog.");
+      return 1;
+    }
+    return (async () => {
+      try {
+        const preview = dryRun || showDiff;
+        const result = addRegistryTemplates({
+          cwd,
+          names,
+          dryRun: preview,
+          overwrite: args.includes("--overwrite")
+        });
+        const changes = preview ? [...result.changes, ...await previewTemplateSync({ cwd, templates: result.previewTemplates })] : result.changes;
+        if (showDiff) {
+          if (changes.length === 0) write("No changes.");
+          else for (const change of changes) write(compactDiff(change));
+          return 0;
+        }
+        if (dryRun) {
+          if (result.added.length > 0) write(`Would add ${result.added.join(", ")}.`);
+          if (result.updated.length > 0) write(`Would update ${result.updated.join(", ")}.`);
+          if (changes.length === 0) write("No changes.");
+          else for (const change of changes) write(`${change.action}	${change.path}`);
+          return 0;
+        }
+        await syncTemplates({ cwd });
+        if (result.added.length > 0) write(`Added ${result.added.join(", ")}.`);
+        if (result.updated.length > 0) write(`Updated ${result.updated.join(", ")}.`);
+        if (result.added.length === 0 && result.updated.length === 0) {
+          write("Those templates are already installed.");
+        }
+        const templateSources = result.files.filter((file) => /^vanillasky\/templates\/.*\.tsx$/.test(file));
+        if (templateSources.length > 0) {
+          write(`${templateSources.length === 1 ? "Template source" : "Template sources"}: ${templateSources.join(", ")}`);
+        }
+        return 0;
+      } catch (error) {
+        write(error instanceof Error ? error.message : String(error));
+        return 1;
+      }
+    })();
+  }
+  if (command === "describe") {
+    const unknown = unknownOption("describe", args, ["--builtin", "--json"]);
+    if (unknown) {
+      write(unknown);
+      return 1;
+    }
+    const names = args.filter((arg) => arg !== "--json" && arg !== "--builtin");
+    if (names.length > 1) {
+      write(`Unexpected describe argument: ${names[1]}`);
+      return 1;
+    }
+    const name = names[0];
+    const render = (item2) => {
+      if (!item2) {
+        write(`Unknown template: ${name ?? ""}. Run \`vanillasky list\` to see the catalog.`);
+        return 1;
+      }
+      if (args.includes("--json")) {
+        write(JSON.stringify(item2, null, 2));
+        return 0;
+      }
+      write(`${item2.id} \u2014 ${item2.title}`);
+      if (item2.summary) write(item2.summary);
+      write(`Origin	${item2.origin}`);
+      write(`Status	${item2.status}`);
+      write(`Use when	${item2.planner.useWhen}`);
+      if (item2.planner.avoidWhen) write(`Avoid when	${item2.planner.avoidWhen}`);
+      if (item2.family) write(`Family	${item2.family}`);
+      if (item2.jobs) write(`Jobs	${item2.jobs.join(", ")}`);
+      if (item2.register) write(`Register	${item2.register}`);
+      const duration = [
+        item2.duration.min == null ? void 0 : `${item2.duration.min}s minimum`,
+        item2.duration.preferred == null ? void 0 : `${item2.duration.preferred}s preferred`
+      ].filter(Boolean).join(", ");
+      if (duration) write(`Duration	${duration}`);
+      write(`Generated browser	${item2.generated.browser.path}	${item2.generated.browser.current == null ? "not applicable" : item2.generated.browser.current ? "current" : "stale"}`);
+      write(`Generated server	${item2.generated.server.path}	${item2.generated.server.current == null ? "not applicable" : item2.generated.server.current ? "current" : "stale"}`);
+      write(`Generated files	${item2.generated.current == null ? "not applicable to packaged templates" : item2.generated.current ? "current" : "stale"}`);
+      write("Application wiring	not inspected or verified");
+      for (const [fieldName, property] of Object.entries(item2.schema.properties)) {
+        const required = item2.schema.required?.includes(fieldName) === true;
+        const notation = templateVariableNotation(property, required).replace(/!$/, "");
+        write(`${fieldName}	${notation}	${required ? "required" : "optional"}	${property.description ?? ""}`);
+      }
+      return 0;
+    };
+    if (!name) return render(void 0);
+    if (args.includes("--builtin") || !hasProjectTemplateSources(cwd)) return render(findBuiltinTemplate(name));
+    return findEffectiveTemplate(cwd, name).then(render).catch((error) => {
+      write(error instanceof Error ? error.message : String(error));
+      return 1;
+    });
+  }
+  write(help());
+  return command == null || command === "help" || command === "--help" || command === "-h" ? 0 : 1;
+}
+
+// src/cli.ts
+process.exitCode = await runVanillaSkyCli(process.argv.slice(2));