@appinit/cli 1.1.0 → 1.3.0

package/dist/index.js

@@ -1,25 +1,3796 @@
 #!/usr/bin/env node
-import {existsSync}from'fs';import He,{readFile}from'fs/promises';import*as z from'path';import z__default from'path';import {isatty}from'tty';import p from'kleur';import {exec}from'child_process';import Ve,{promisify}from'util';import S from'process';import {spinner,multiselect,confirm,select,isCancel,cancel,text}from'@clack/prompts';import rt from'os';import nt from'mri';var M=process.stdout?.columns||80;process.stdout?.rows||24;var A=async e=>existsSync(e),F=e=>readFile(e,"utf8");function Oe(e){return e.replace(/\\/g,"/")}function x(e,t){return Oe(z.join(e,t))}var O=e=>e.replace(/-([a-zA-Z0-9])/g,(t,n)=>n.toUpperCase());var D=()=>!!process.env.npm_lifecycle_event;async function L(){try{if(process.env.DOCKER||process.env.CONTAINER||await A("/.dockerenv"))return !0;if(await A("/proc/1/cgroup")){let e=await F("/proc/1/cgroup");if(e.includes("docker")||e.includes("container"))return !0}return !1}catch{return  false}}var U=e=>["turborepo","nx","monorepo"].includes(e);var d=()=>["CI","GITHUB_ACTIONS","BITBUCKET_PIPELINES","BUILDKITE","GITLAB_CI","CIRCLECI","JENKINS_HOME"].some(e=>process.env[e]==="true");async function De(e){return !((e??{}).nonInteractive||!process.stdin.isTTY||!process.stdout.isTTY||d()||D()||await L())}var _=De;var y=!!(process.stdout&&process.stdout.isTTY&&isatty(1));process.platform==="win32";var T={brand:p.cyan,primary:p.cyan,success:p.green,danger:p.red,warning:p.yellow,info:p.blue,dim:p.gray,red:p.red,green:p.green,yellow:p.yellow,blue:p.blue,cyan:p.cyan,magenta:p.magenta,gray:p.gray};({bgRed:p.bgRed,bgGreen:p.bgGreen,bgYellow:p.bgYellow,bgBlue:p.bgBlue,bgMagenta:p.bgMagenta,bgCyan:p.bgCyan,bgWhite:p.bgWhite,bgBlack:p.bgBlack});var b={bold:e=>p.bold(e),italic:e=>p.italic(e),underline:e=>p.underline(e),apply:(...e)=>t=>e.reduce((n,a)=>a(n),t)};var $={default:{brand:e=>p.cyan().bold(e),primary:e=>p.cyan(e),success:e=>p.green().bold(e),danger:e=>p.red().bold(e),warning:e=>p.yellow().bold(e),info:e=>p.blue(e),dim:e=>p.gray(e)},dark:{brand:e=>p.magenta().bold(e),primary:e=>p.white(e),success:e=>p.green(e),danger:e=>p.red(e),warning:e=>p.yellow(e),info:e=>p.cyan(e),dim:e=>p.gray(e)},neon:{brand:e=>p.magenta().bold().underline(e),primary:e=>p.green().bold(e),success:e=>p.cyan().bold(e),danger:e=>p.red().bold(e),warning:e=>p.yellow().bold().underline(e),info:e=>p.blue().bold(e),dim:e=>p.gray(e)},mono:{brand:e=>e,primary:e=>e,success:e=>e,danger:e=>e,warning:e=>e,info:e=>e,dim:e=>e}};var Ue="default";var l=new Proxy({},{get(e,t){return $[Ue][t]}});promisify(exec);var V={silent:0,error:1,warn:2,info:3,debug:4,success:5},B=S.env.APPINIT_LOG_LEVEL||"info",Be=S.env.APPINIT_LOG==="json",ze=S.env.APPINIT_DEBUG==="1",R=S.env.NO_COLOR!=="1";function g(e){let t=V[B];return V[e]<=t}function Ge(e){return e?Ve.inspect(e,{colors:R,depth:5}):""}function k(e,t,n){let a=new Date().toISOString();if(Be)return JSON.stringify({ts:a,level:e,message:t,meta:n});let o=e.toUpperCase();if(R)switch(e){case "debug":o=l.info(o);break;case "info":o=l.primary(o);break;case "warn":o=l.warning(o);break;case "error":o=l.danger(o);break;}let r=R?l.dim(a):a,i=n?" "+Ge(n):"";return `${r} ${o} ${b.bold(t)}${i}`}var v={debug(e,t){ze&&g("debug")&&console.debug(k("debug",e,t));},info(e,t){g("info")&&console.info(k("info",e,t));},warn(e,t){g("warn")&&console.warn(k("warn",e,t));},error(e,t){g("error")&&console.error(k("error",e,t));},raw(e){B!=="silent"&&console.log(e);},step(e){g("info")&&console.log(k("info",`\u25B6 ${e}`));},title(e){g("info")&&console.log(`
-`+l.brand(b.bold(`\u{1F680} ${e}`))+`
-`);},success(e){g("info")&&console.log(`
-`+l.success(b.bold(`\u2714 ${e}`))+`
-`);}};var We=[["pnpm","pnpm-lock.yaml"],["yarn","yarn.lock"],["bun","bun.lockb"],["npm","package-lock.json"]];async function G(e){let t=z__default.resolve(e);for(let[n,a]of We)try{return await He.access(z__default.join(t,a)),n}catch{}return "npm"}var Je=/[&|<>*?!%^"'$;{}()=@]/,Ye=/^(con|prn|aux|nul|com[1-9]|lpt[1-9])$/i;function H(e){let t=z__default.basename(e);return Ye.test(t)?`The folder name "${t}" is reserved on Windows.`:Je.test(e)?`The path contains forbidden characters: & | < > * ? ! % ^ " ' $ ; { } ( ) = @`:/[. ]$/.test(t)?"Folder name cannot end with a dot or space.":/\/\s|\s\//.test(e.replace(/\\/g,"/"))?"Folder path contains invalid spacing around slashes.":null}async function W(e){let t=process.stdout.columns||80,n="\u2500".repeat(Math.min(t,60));console.log(""),console.log(l.success(n)),console.log(l.success("\u2728  Project created successfully!")),console.log("");let a=await G(e),o="",r="";switch(a){case "pnpm":o="pnpm install",r="pnpm dev";break;case "yarn":o="yarn",r="yarn dev";break;case "bun":o="bun install",r="bun dev";break;default:case "npm":o="npm install",r="npm run dev";break}console.log(b.bold("\u{1F449}  Next steps:")),console.log(`  ${l.primary(`cd ${e}`)}`),console.log(`  ${l.primary(o)}`),console.log(`  ${l.primary(r)}`),console.log(""),console.log(l.dim("\u{1F4A1} You\u2019re ready to start building your app.")),console.log(l.dim("\u{1F4A1} Use `appinit add` to include packs, modules, and capabilities.")),console.log(l.dim("\u{1F4A1} Need help? Run `appinit help`")),console.log(""),console.log(l.success(n)),console.log("");}var qe=`
-   \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2557\u2588\u2588\u2588\u2557   \u2588\u2588\u2557\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557
-  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2550\u2550\u2588\u2588\u2554\u2550\u2550\u255D
-  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551\u2588\u2588\u2554\u2588\u2588\u2557 \u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
-  \u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2557\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
-  \u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551 \u255A\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
-  \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u2550\u2550\u255D\u255A\u2550\u255D   \u255A\u2550\u255D
-`;async function K(){for(let e of qe.trimEnd().split(`
-`))console.log(e);}var Qe="AppInit OS",Ze="Developer Operating System",J=false;async function Y(e){if(J||d()||!y)return;J=true,console.log(""),await _(e.flags??{})&&M>=72&&(await K(),console.log("")),console.log(l.brand(`${Qe} \u2014 ${Ze}`)),console.log(l.primary(l.dim(`v${e.version}`))),console.log("");}function q(e){console.log("AppInit OS \u2014 Developer Operating System"),console.log(`v${e}`),console.log(""),console.log(`Usage:
-  appinit create <project-name>   Create project (guided or fast)
-  appinit add <capability>        Add AI, DB, auth, UI, etc.
-  appinit doctor                  Analyze & validate project
-  appinit deploy                  Deploy via supported targets
-  appinit ai                      AI engineering helpers
-
-Example:
-  appinit create my-app
-`);}var et=process.platform==="win32";function Q(e){let{text:t,color:n="brand",indicator:a="dots",quiet:o}=e,r=!!(o||d()||!y);et&&!process.env.TERM_PROGRAM&&(r=true);let i=s=>typeof n=="function"?n(s):l[n]?l[n](s):T[n]?T[n](s):s;if(r)return console.log(l.dim(`\u203A ${t}`)),{start(){},stop(){},success(s){console.log(l.success(`\u2714 ${s??t}`));},error(s){console.log(l.danger(`\u2716 ${s??t}`));},message(s){console.log(l.dim(`\u203A ${s}`));},persist(s){console.log(s);},async run(s){try{let m=await s();return console.log(l.success(`\u2714 ${t}`)),m}catch(m){throw console.log(l.danger(`\u2716 ${t}`)),m}}};let c=spinner({indicator:a});return {start(s){c.start(i(s??t));},stop(s){c.stop(i(s??t));},success(s){c.stop(l.success(s??t));},error(s){c.stop(l.danger(s??t));},message(s){c.message(i(s));},persist(s){c.stop(s);},async run(s){try{let m=await s();return c.stop(l.success(t)),m}catch(m){throw c.stop(l.danger(t)),m}}}}function Z(e){let t=e.flags?.quiet||d()||!y;function n(o){let r=Q({text:o,color:"primary",quiet:t});return {start(i){r.start(i??o);},success(i){r.success(i??o);},error(i){r.error(i??o);},message(i){r.message(i);},async run(i){try{r.start(o);let c=await i();return r.success(o),c}catch(c){throw r.error(o),c}}}}function a(o){return console.log(l.brand(`
-${o}
-`)),{title:o,step(r){return n(r)},complete(r){console.log(l.success(`\u2714 ${r??o}`));},error(r){console.log(l.danger(`\u2716 ${r??o}`));}}}return {group:a,step:n}}var X={version:"1.1.0"};function ee(){return ((process.argv[1]??"").split(/[/\\]/).pop()??"").replace(/\.(js|ts|mjs|cjs)$/i,"")||"appinit"}function w(){return X?.version}async function te(e){let t=process.cwd(),n=x(rt.homedir(),".appinit/cache");return {cwd:t,cacheDir:n,command:e.name,flags:e.flags,args:e.args,cliName:ee(),cliVersion:process.env.APPINIT_CLI_VERSION??w(),runtime:"cli",outputMode:e.flags.json?"json":"text",interactive:!e.flags.nonInteractive,logger:v,spinner:void 0,task:{createManager:()=>Z(e)}}}var oe=["help","version","nonInteractive","skipInstall","skipGit","skipDefaultPacks","dryRun","force","quiet"],ae=["template","projectType"],re={"non-interactive":"nonInteractive","skip-install":"skipInstall","skip-git":"skipGit","project-type":"projectType","skip-default-packs":"skipDefaultPacks","dry-run":"dryRun"},ne={help:"help",h:"help",version:"version",v:"version",json:"json",f:"force",q:"quiet","non-interactive":"nonInteractive","skip-install":"skipInstall","skip-git":"skipGit","project-type":"projectType","dry-run":"dryRun"},I={quiet:false,verbose:false,debug:false,nonInteractive:false,skipInstall:false,skipGit:false,json:"",projectType:"frontend",skipDefaultPacks:false,dryRun:false,force:false};function ie(e){let t=e.splice(2),n=nt(t,{boolean:oe.map(r=>r.toLowerCase()),string:ae.map(r=>r.toLowerCase()),default:I}),a=String(n._?.[0]??"help"),o=ot(n);return {name:a,args:t,flags:o}}function ot(e){let t={...I};for(let[n,a]of Object.entries(e)){if(n==="_"||typeof n!="string")continue;let o=at(n);if(o){if(n.startsWith("no-")){t[o]=false;continue}t[o]=a;}}return t}function at(e){if(!e)return "";if(e=e.replace(/^--?/,"").toLowerCase(),ne[e])return ne[e];if(e in re)return re[e];let t=O(e);return t in I||oe.includes(t)||ae.includes(t)?t:""}function se(e){isCancel(e)&&(cancel("Operation cancelled."),process.exit(1));}async function le(e){let t=await text({message:e.message,initialValue:e.initial});return isCancel(t)&&(cancel("Operation cancelled."),process.exit(1)),t}async function ce(e,t={}){let a=(typeof e.choices=="function"?await e.choices(t):e.choices??[]).map(r=>({label:r.label??r.title??String(r.value),value:r.value,hint:r.hint})),o=await select({...e,initialValue:e.initialValue,options:a});return isCancel(o)&&(cancel("Operation cancelled."),process.exit(1)),o}async function pe(e){let t=await confirm({...e,message:e.message});return se(t),t}async function ue(e,t={}){let a=(typeof e.choices=="function"?await e.choices(t):e.choices??[]).map(r=>({label:r.label??r.title??String(r.value),value:r.value,hint:r.hint})),o=await multiselect({...e,options:a});return se(o),o}async function f(e,t={},n){let a={...t};for(let o of e){if(typeof o.when=="function"&&!await o.when(a))continue;let r;switch(o.type){case "text":r=await le(o);break;case "select":r=await ce(o,a);break;case "confirm":case "toggle":r=await pe(o);break;case "multiselect":r=await ue(o,a);break;default:throw new Error(`Unsupported prompt type "${o.type}`)}if(typeof o.format=="function"&&(r=o.format(r)),typeof o.validate=="function"){let i=await o.validate(r);if(i!==true)throw new Error(`Validation failed for "${o.name}": ${i}`)}a[o.name]=r;}return a}var me=[{label:"React",value:"react",hint:"**The most popular library.** Component-based UI with a huge ecosystem (often paired with Vite or Next.js)."},{label:"Next.js",value:"next",hint:"**Production-ready full-stack React framework.** Excellent for SSR, routing, and APIs."},{label:"Vue",value:"vue",hint:"**Progressive and approachable framework.** Fully-featured with great official libraries (Vue Router, Pinia)."},{label:"Svelte",value:"svelte",hint:"**The compiler.** No virtual DOM. Generates highly optimized vanilla JS for faster runtime performance."},{label:"Angular",value:"angular",hint:"**Opinionated, full-featured framework.** Best for large-scale enterprise applications with built-in tooling."},{label:"SolidJS",value:"solid",hint:"**Fine-grained reactivity.** High performance using compiled JSX and actual DOM nodes, no Virtual DOM."},{label:"Qwik",value:"qwik",hint:"Focuses on **Resumability** to achieve near-instant loading times by lazy loading and resuming application state."},{label:"Astro",value:"astro",hint:"An **all-in-one framework** for building fast, content-focused websites using 'Islands of Interactivity'."},{label:"Framer Motion",value:"framer",hint:"Used primarily for **animation and interactive design.** Not a general-purpose framework, but a powerful animation library."},{label:"React Router",value:"react-router",hint:"A declarative routing library for React (often associated with **Remix** full-stack framework)."},{label:"None",value:"none",hint:"**Vanilla JavaScript/TypeScript.** No framework or library required."}];var de=[{label:"Next.js",value:"next",hint:"**The leading React full-stack framework.** Excellent for server-side rendering (SSR), static site generation (SSG), and API routes."},{label:"Remix",value:"react-router",hint:"**Full-stack React framework built on web standards.** Focuses on route-level data fetching and seamless integration with React Router."},{label:"SvelteKit",value:"svelte",hint:"**The full-stack Svelte framework.** Extremely fast, uses a compiler approach, and offers flexible adapters for deployment."},{label:"Nuxt (Vue)",value:"vue",hint:"**The full-stack Vue framework.** Rich feature set including file-system routing, auto-imports, and powerful module ecosystem."}];var fe=[{label:"Express",value:"express",hint:"**Most popular Node backend.** Simple routing, middleware based, huge ecosystem."},{label:"Koa",value:"koa",hint:"A **minimalist framework** designed by the Express team. Smaller footprint, uses `async/await` for cleaner middleware flow and better error handling."},{label:"Fastify",value:"fastify",hint:"**High-performance & plugin-based.** Best for APIs requiring throughput."},{label:"NestJS",value:"nest",hint:"**Enterprise-grade architecture.** Built-in DI, modules, and scalable structure."},{label:"AdonisJS",value:"adonis",hint:"A **full-featured, opinionated MVC framework** inspired by Laravel/Rails. Comes with its own ORM, CLI, and authentication built-in."},{label:"Hono (Edge-optimized)",value:"hono",hint:"**Tiny + ultra fast for edge runtimes.** Perfect for Cloudflare, Deno, Bun."},{label:"Elysia (Bun)",value:"elysia",hint:"**Deep Bun integration.** Modern type-safe router + middleware."},{label:"None",value:"none",hint:"Choose this if you intend to use a different framework or build your server from scratch."}],ge=[{label:"REST",value:"rest",hint:"**Standard + universal.** Works everywhere and easy to scale gradually."},{label:"tRPC",value:"trpc",hint:"**Full end-to-end types.** Great with React/Next fullstack workflows."},{label:"GraphQL",value:"graphql",hint:"**Flexible querying.** Best for complex relational or mobile apps."}],he=[{label:"Monolith",value:"monolith",hint:"**Single, unified unit.** All components (UI, logic, data) are in one codebase and deployed together. **Simple to develop initially**."},{label:"Modular",value:"modular",hint:"A Monolith where code is **logically separated** into independent modules (features/domains) within the *same* codebase. Easier to maintain than a traditional Monolith."},{label:"Microservices",value:"microservices",hint:"**Independent, specialized services.** Each feature runs as its own separate application with its own database, communicating via APIs. **Highly scalable and fault-tolerant**."},{label:"None",value:"none",hint:"No default architecture"}];var ye={name:"backend",priority:40,condition:(e,t)=>["next","framer","nuxt"].includes(t.frontendFramework)?false:["backend","fullstack"].includes(t.projectType??""),handler:async(e,t,n)=>{if(!e.interactive){let r=e.savedConfig??{};return {backendFramework:n.backendFramework??r.backendFramework??"express",apiStyle:n.apiStyle??r.apiStyle??"rest",backendMode:n.backendMode??r.backendMode??"none"}}return await f([{type:"select",name:"backendFramework",message:"\u{1F9F1} Backend Framework:",choices:fe,initialValue:n.backendFramework??"express"},{type:"select",name:"apiStyle",message:"\u{1F50C} API Style:",choices:ge,initialValue:n.apiStyle??"rest"},{type:"select",name:"backendMode",message:"\u2699\uFE0F Backend Architecture Mode:",choices:he,initialValue:n.backendMode??"none"}],n)}};var be={name:"environment",priority:55,handler:async(e,t,n)=>{let a=e.interactive,o={packageManager:n.packageManager??"pnpm",workspace:n.workspace??"single"};return a?await f([{type:"select",name:"packageManager",message:"\u{1F4E6} Package manager:",choices:pt,initial:n.packageManager??"pnpm"},{type:"select",name:"workspace",message:"\u{1F9E9} Workspace type:",choices:ut,initial:n.workspace??"single"}],n):o}},pt=[{label:"npm",value:"npm",hint:"The **default and most widely-adopted** package manager for Node.js. Great for simplicity and maximum package compatibility."},{label:"pnpm",value:"pnpm",hint:"Focuses on **disk-space efficiency and speed** using content-addressable storage (hard links). Excellent for monorepos."},{label:"yarn",value:"yarn",hint:"Known for **speed, reliability, and monorepo support** (workspaces). Yarn 2+ introduced the Plug'n'Play (PnP) architecture."},{label:"bun",value:"bun",hint:"A **blazingly fast** all-in-one JavaScript runtime, bundler, and package manager. Best for performance-critical or new projects."}],ut=[{label:"Single project",value:"single",hint:"A **traditional project structure** where all code lives in one package. Simple and easy to manage for small-to-medium applications."},{label:"Turborepo (monorepo)",value:"turborepo",hint:"A fast, lightweight build system by Vercel for monorepos. Focuses on **caching and remote computation**."},{label:"Nx (monorepo)",value:"nx",hint:"A **powerful, full-featured monorepo toolkit** that uses a deep graph to understand project dependencies for faster builds and better tooling."},{label:"Lerna (monorepo)",value:"lerna",hint:"A classic tool to manage JavaScript monorepos. Best for **publishing multiple packages** from a single repository."}];var ve={name:"framework",priority:2,condition:(e,t)=>t.projectType==="frontend"||t.projectType==="fullstack",handler:async(e,t,n)=>{let a=e.interactive,o=n.projectType,r=n.frontendFramework??t.frontendFramework??"react",i=o==="fullstack";return a?{frontendFramework:(await f([{type:"select",name:"frontendFramework",message:`\u2699\uFE0F ${i?"Fullstack":"Frontend"} Framework:`,choices:i?de:me,initial:r??(i?"next":"react")}],n)).frontendFramework}:{frontendFramework:r}}};var we=[{label:"MIT",value:"MIT",hint:"A short, permissive license with conditions only requiring preservation of copyright and license notices. Great for maximum compatibility."},{label:"Apache-2.0",value:"Apache-2.0",hint:"A permissive license similar to MIT, but providing an express grant of patent rights from contributors to users."},{label:"GPL-3.0",value:"GPL-3.0",hint:"A strong copyleft license. If you modify or redistribute code under this license, you must also release your source code under GPL-3.0."},{label:"Unlicense",value:"Unlicense",hint:"Dedicates the work to the public domain, offering the fewest restrictions possible."},{label:"Other",value:"Other",hint:"Choose this if your license is not listed above and you will provide details later."}];var ke=[{label:"Frontend Application",value:"frontend",hint:"**A pure client-side application (SPA).** Good for UIs, dashboards, and static sites that consume an existing external API."},{label:"Backend API",value:"backend",hint:"A **server-only project** dedicated to data, business logic, and API endpoints (e.g., using Node.js, Python, or Go)."},{label:"Fullstack (UI + API)",value:"fullstack",hint:"**The modern monolith.** A single project containing both the user interface and the API/server logic (e.g., Next.js, SvelteKit)."},{label:"Library / SDK",value:"library",hint:"A **reusable package** of code meant to be published to NPM and used by other applications (e.g., component library, utility functions)."},{label:"CLI Tool",value:"cli",hint:"A **command-line application** that runs in the terminal. Excellent for automation, deployment, or scaffold generation."}];var j=e=>String(e).trim().toLowerCase().replace(/\s+/g,"-").replace(/[^a-z0-9-_]/g,"").replace(/^-+|-+$/g,"");var h=(...e)=>e.find(t=>t!=null&&t!=="");function xe(e,t,n){let a=n.projectType??t.projectType;return a==="library"||a==="cli"||U(t?.workspaceTool)}var P=e=>{if(typeof e!="string")return null;let t=e.trim().replace(/^@/,"");return t?`@${t}`:null};function Se(e){if(!e||typeof e!="string")return "Name cannot be empty";let t=e.trim();if(!t.length)return "Name cannot be empty";if(/\s/.test(t))return "Spaces are not allowed \u2014 use dash or underscore";if(/[A-Z]/.test(t))return "Use lowercase letters only (npm package rule)";if(/[~'!()*]/.test(t))return "Name contains forbidden characters ~ ' ! ( ) *";if(/[<>:\"\\|?*]/.test(t))return 'Name contains Windows-forbidden characters < > : " \\ | ? *';if(/[/.]$/.test(t))return "Name cannot end with a dot or slash";if(t.startsWith("@")){if(!/^@[a-z0-9\-_]+\/[a-z0-9\-_]+$/.test(t))return "Invalid scoped package. Use @scope/name"}else if(!/^[a-z0-9\-_]+$/.test(t))return "Use only letters, numbers, dash (-), and underscore (_)";return ["node_modules","favicon","core","con","aux","nul","prn"].includes(t.toLowerCase())?`"${t}" is a reserved name`:true}var Pe={name:"meta",priority:1,before(e){console.log("I am meta pack");},handler:async(e,t,n)=>{let a=e.savedConfig??{},o=e.interactive,r={projectName:h(t.projectName,n.projectName,a.projectName,"appinit-app"),projectType:h(t.projectType,n.projectType,a.projectType,"frontend"),description:h(t.description,n.description,a.description,""),licenseType:h(t.licenseType,n.licenseType,a.licenseType,"MIT"),author:h(t.author,n.author,a.author,"appinit"),packageScope:P(h(t.packageScope,n.packageScope,a.packageScope,"@"))};if(!o)return r;let i=[];(!t.projectName||t.projectName.trim()==="")&&i.push({type:"text",name:"projectName",message:"\u{1F9F1} Project name:",initial:a.projectName??"my-appinit-app",format:s=>s?j(s):null,validate:s=>Se(j(s||""))}),i.push({type:"text",name:"description",message:"\u{1F4DD} Short description:",initial:r.description,defaultValue:""},{type:"text",name:"author",message:"\u{1F464} Author (name/email):",initial:r.author,defaultValue:"appinit"},{type:"select",name:"licenseType",message:"\u{1F4DC} License:",choices:we,initial:r.licenseType},{type:"select",name:"projectType",message:"\u{1F4E6} Project type:",choices:ke,initial:r.projectType}),xe(e,t,n)&&i.push({type:"text",name:"packageScope",message:"\u{1F4E6} Package scope (optional, without @):",initial:a.packageScope?.replace?.(/^@/,"")??"",format:s=>s?P(s):null});let c=await f(i,n);return c.packageScope&&(c.packageScope=P(c.packageScope)),{...r,...c}}};var mt=[Pe,ve,be,ye];async function Ce(e,t){let n=e.args[1],a=e.logger,o=[],r={},i={projectName:n,projectType:e.flags.projectType};e.flags.skipDefaultPacks||(o=[...mt]),Array.isArray(t)&&(o=[...o,...t]),o.sort((c,s)=>(c.priority??100)-(s.priority??100)),Object.freeze(o),i.hooks?.beforeAll&&await i.hooks.beforeAll(i,r);for(let c of o)try{if(c.condition&&!await c.condition(i,r)){a.info(`\u23ED\uFE0F  Skipping pack: ${c.name}`);continue}i.hooks?.beforeEach&&await i.hooks.beforeEach(c,i,r),c.before&&await c.before(e,i,r);let s=await c.handler(e,i,r);console.log("PACK-",r,c.name,s),s&&typeof s=="object"&&Object.assign(r,s),c.after&&await c.after(e,i,r),i.hooks?.afterEach&&await i.hooks.afterEach(c,i,r);}catch(s){throw a.error(`\u274C Pack failed: "${c.name}"`),a.error(`Reason: ${s.message}`),s}return i.hooks?.afterAll&&await i.hooks.afterAll(i,r),r}var Ae={name:"create",description:"Create new AppInit project",async run(e){let {args:t,task:n,logger:a}=e,o=t[1]??"";n.createManager();await Y({version:w()});let i;try{i=await Ce(e);}catch(je){a?.error("\u274C Prompt engine failed"),a?.error(String(je)),process.exit(1);}console.log("An",i),e.answers=i;let c=i.projectName,s=x(e.cwd,c),m=H(s);m&&(a?.error(`\u274C Invalid target directory: ${s}`),a?.error(`Reason: ${m}`),process.exit(1)),console.log("COnfig",e),W(o);}};var Te={name:"help",description:"",async run(e){return q(w())}};var Re={create:Ae,help:Te};async function Ie(e,t){let n=Re[e];return n||(v.error(`Unknown command: ${e}`),process.exit(1)),n.run(t)}function Ne(e){return e?["init","new"].includes(e)?"create":e.toLowerCase():"help"}async function Ee(e){let t=ie(e),n=Ne(t.name),a=await te(t);try{await Ie(n,a);}catch(o){v.error(`CLI command failed, ${o}`),process.exitCode=1;}}function To(e){Ee(e);}export{To as start};
+
+// src/index.ts
+import { stdin, stdout } from "process";
+import { createInterface } from "readline/promises";
+
+// src/args.ts
+function parseVariable(value) {
+  const separator = value.indexOf("=");
+  if (separator <= 0) throw new Error(`Invalid --var "${value}". Expected key=value.`);
+  const key = value.slice(0, separator).trim();
+  const raw = value.slice(separator + 1);
+  if (!/^[a-zA-Z_][a-zA-Z0-9_.-]*$/.test(key)) throw new Error(`Invalid variable name "${key}".`);
+  let parsed = raw;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+  }
+  return [key, parsed];
+}
+function parseCreateArguments(args) {
+  const positional = [];
+  const variables = {};
+  let dryRun = false;
+  let yes = false;
+  let template;
+  let templateDirectory;
+  let install = false;
+  let git = false;
+  let packageManager;
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index];
+    if (argument === "--dry-run") dryRun = true;
+    else if (argument === "--install") install = true;
+    else if (argument === "--git") git = true;
+    else if (argument === "--package-manager") {
+      const value = args[++index];
+      if (!value) throw new Error("--package-manager requires pnpm, npm, yarn, or bun.");
+      if (value !== "pnpm" && value !== "npm" && value !== "yarn" && value !== "bun") throw new Error(`Unsupported package manager "${value}". Choose pnpm, npm, yarn, or bun.`);
+      packageManager = value;
+    } else if (argument === "--yes" || argument === "-y") yes = true;
+    else if (argument === "--template" || argument === "-t") {
+      const value = args[++index];
+      if (!value) throw new Error(`${argument} requires a template reference.`);
+      template = value;
+    } else if (argument === "--template-dir") {
+      const value = args[++index];
+      if (!value) throw new Error("--template-dir requires a directory.");
+      templateDirectory = value;
+    } else if (argument === "--var") {
+      const value = args[++index];
+      if (!value) throw new Error("--var requires key=value.");
+      const [key, parsed] = parseVariable(value);
+      if (Object.hasOwn(variables, key)) throw new Error(`Variable "${key}" was provided more than once.`);
+      variables[key] = parsed;
+    } else if (argument.startsWith("-")) {
+      throw new Error(`Unknown option: ${argument}`);
+    } else positional.push(argument);
+  }
+  if (positional.length > 2) throw new Error('Too many arguments. Run "appinit create --help".');
+  if (positional.length === 2 && template) {
+    throw new Error("Do not combine --template with two positional arguments; use <template> <target>.");
+  }
+  return Object.freeze({
+    ...positional.length === 2 ? { template: positional[0], target: positional[1] } : {},
+    ...positional.length === 1 ? { target: positional[0] } : {},
+    ...template ? { template } : {},
+    dryRun,
+    yes,
+    ...templateDirectory ? { templateDirectory } : {},
+    variables: Object.freeze(variables),
+    install,
+    git,
+    ...packageManager ? { packageManager } : {}
+  });
+}
+
+// src/context.ts
+import { readFile as readFile3 } from "fs/promises";
+import path8 from "path";
+
+// ../os/src/runtime/fs/is-binary-file.ts
+import path from "path";
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".bmp",
+  ".svg",
+  ".svgz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".ogg",
+  ".webm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".tgz",
+  ".rar",
+  ".7z",
+  ".pdf",
+  ".exe",
+  ".dll",
+  ".bin"
+]);
+function isBinaryFile(filePath) {
+  return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+// ../os/src/runtime/fs/path.ts
+import path2 from "path";
+
+// ../os/src/runtime/fs/traversal.ts
+import { lstat, readdir } from "fs/promises";
+import path3 from "path";
+import picomatch from "picomatch";
+async function readDirRecursive(root, options = {}) {
+  const {
+    prefix = "",
+    ignores = [],
+    mode = "relative"
+  } = options;
+  const absoluteRoot = path3.resolve(root);
+  const normalizedPrefix = prefix ? path3.posix.normalize(prefix.replace(/\\/g, "/")) : "";
+  if (normalizedPrefix === ".." || normalizedPrefix.startsWith("../") || path3.posix.isAbsolute(normalizedPrefix)) {
+    throw new Error("Traversal prefix must remain inside the root directory.");
+  }
+  const isIgnored = ignores.length > 0 ? picomatch(ignores, { dot: true }) : () => false;
+  const results = [];
+  async function walk2(directory, relativeDirectory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const relativePath = path3.posix.join(relativeDirectory, entry.name);
+      if (isIgnored(relativePath)) continue;
+      const absolutePath = path3.join(directory, entry.name);
+      let details;
+      try {
+        details = await lstat(absolutePath);
+      } catch (error) {
+        if (error.code === "ENOENT") continue;
+        throw error;
+      }
+      if (details.isSymbolicLink()) continue;
+      if (details.isDirectory()) {
+        await walk2(absolutePath, relativePath);
+      } else if (details.isFile()) {
+        results.push(
+          mode === "absolute" ? absolutePath : relativePath
+        );
+      }
+    }
+  }
+  await walk2(absoluteRoot, normalizedPrefix);
+  return results.sort((a, b) => a.localeCompare(b));
+}
+
+// ../os/src/runtime/vfs/freeze-vfs.ts
+function freezeVFS(vfs) {
+  for (const file of vfs.list()) {
+    Object.freeze(file);
+  }
+  return vfs;
+}
+
+// ../os/src/runtime/vfs/vfs.ts
+import path4 from "path";
+function normalizeVfsDestination(destination) {
+  if (typeof destination !== "string" || destination.trim().length === 0 || destination.includes("\0")) {
+    throw new Error("VFS destination must be a non-empty relative path.");
+  }
+  const portable = destination.replace(/\\/g, "/");
+  if (portable.startsWith("/") || portable.startsWith("//") || /^[a-zA-Z]:/.test(portable)) {
+    throw new Error(`VFS destination must be relative: ${destination}`);
+  }
+  let normalized = path4.posix.normalize(portable);
+  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  if (normalized === "." || normalized === ".." || normalized.startsWith("../") || path4.posix.isAbsolute(normalized)) {
+    throw new Error(`VFS destination escapes the project root: ${destination}`);
+  }
+  return normalized;
+}
+var VirtualFileSystem = class {
+  files = /* @__PURE__ */ new Map();
+  add(file) {
+    const destination = normalizeVfsDestination(file.dest);
+    if (this.files.has(destination)) {
+      throw new Error(`VFS conflict: file already exists at ${destination}`);
+    }
+    this.files.set(destination, { ...file, dest: destination });
+  }
+  get(destination) {
+    return this.files.get(normalizeVfsDestination(destination));
+  }
+  list() {
+    return this.files.values();
+  }
+  remove(destination) {
+    return this.files.delete(normalizeVfsDestination(destination));
+  }
+  updateContent(destination, content) {
+    const file = this.get(destination);
+    if (!file) return;
+    if (Object.isFrozen(file)) {
+      throw new Error(`Attempted to mutate frozen VFS file: ${destination}`);
+    }
+    file.content = content;
+  }
+  get size() {
+    return this.files.size;
+  }
+};
+
+// ../os/src/engine/execute-file-operations.ts
+import {
+  lstat as lstat2,
+  mkdir,
+  mkdtemp,
+  realpath,
+  rename,
+  rm,
+  rmdir,
+  writeFile
+} from "fs/promises";
+import path5 from "path";
+function normalizeDestination(value) {
+  if (typeof value !== "string" || value.length === 0 || value.includes("\0")) {
+    throw new Error("Destination must be a non-empty relative path.");
+  }
+  const portable = value.replace(/\\/g, "/");
+  if (portable.startsWith("/") || /^[a-zA-Z]:/.test(portable)) {
+    throw new Error("Absolute destinations are not allowed.");
+  }
+  if (portable.split("/").some((segment) => segment === ".." || segment === ".")) {
+    throw new Error("Dot and parent-directory segments are not allowed.");
+  }
+  return normalizeVfsDestination(portable);
+}
+async function exists(filePath) {
+  try {
+    await lstat2(filePath);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
+}
+async function ensureSafeTargetDirectory(targetRoot, relativeDirectory) {
+  let current = targetRoot;
+  if (!relativeDirectory) return;
+  for (const segment of relativeDirectory.split(/[\\/]+/).filter(Boolean)) {
+    current = path5.join(current, segment);
+    if (await exists(current)) {
+      const info = await lstat2(current);
+      if (info.isSymbolicLink()) {
+        throw new Error(`Target path contains a symbolic link: ${current}`);
+      }
+      if (!info.isDirectory()) {
+        throw new Error(`Target path component is not a directory: ${current}`);
+      }
+    } else {
+      await mkdir(current);
+    }
+  }
+}
+async function ensureSafeTargetRoot(targetDirectory) {
+  const absolute = path5.resolve(targetDirectory);
+  const parent = path5.dirname(absolute);
+  await mkdir(parent, { recursive: true });
+  const canonicalParent = await realpath(parent);
+  const root = path5.join(canonicalParent, path5.basename(absolute));
+  if (await exists(root)) {
+    const info = await lstat2(root);
+    if (info.isSymbolicLink()) throw new Error("Target directory must not be a symbolic link.");
+    if (!info.isDirectory()) throw new Error("Target path exists and is not a directory.");
+  } else {
+    await mkdir(root);
+  }
+  return await realpath(root);
+}
+async function executeFileOperations(targetDirectory, operations, options = {}) {
+  const diagnostics = [];
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const operation of operations) {
+    try {
+      const destination = normalizeDestination(operation.destination);
+      if (seen.has(destination)) {
+        diagnostics.push({
+          code: "EXECUTION_DUPLICATE_PATH",
+          message: `Execution plan contains duplicate destination "${destination}".`,
+          destination
+        });
+      } else {
+        seen.add(destination);
+        normalized.push({ ...operation, destination });
+      }
+    } catch (error) {
+      diagnostics.push({
+        code: "EXECUTION_INVALID_PATH",
+        message: error instanceof Error ? error.message : String(error),
+        destination: operation.destination
+      });
+    }
+  }
+  if (diagnostics.length > 0) {
+    return Object.freeze({
+      ok: false,
+      dryRun: options.dryRun === true,
+      writtenFiles: Object.freeze([]),
+      overwrittenFiles: Object.freeze([]),
+      diagnostics: Object.freeze(diagnostics)
+    });
+  }
+  if (typeof targetDirectory !== "string" || targetDirectory.trim().length === 0) {
+    return Object.freeze({
+      ok: false,
+      dryRun: options.dryRun === true,
+      writtenFiles: Object.freeze([]),
+      overwrittenFiles: Object.freeze([]),
+      diagnostics: Object.freeze([{
+        code: "EXECUTION_INVALID_TARGET",
+        message: "Target directory must be a non-empty path."
+      }])
+    });
+  }
+  if (options.dryRun) {
+    return Object.freeze({
+      ok: true,
+      dryRun: true,
+      writtenFiles: Object.freeze(normalized.map((item) => item.destination)),
+      overwrittenFiles: Object.freeze([]),
+      diagnostics: Object.freeze([])
+    });
+  }
+  const targetExistedBeforeExecution = await exists(path5.resolve(targetDirectory));
+  let targetRoot;
+  try {
+    targetRoot = await ensureSafeTargetRoot(targetDirectory);
+  } catch (error) {
+    return Object.freeze({
+      ok: false,
+      dryRun: false,
+      writtenFiles: Object.freeze([]),
+      overwrittenFiles: Object.freeze([]),
+      diagnostics: Object.freeze([{
+        code: "EXECUTION_INVALID_TARGET",
+        message: error instanceof Error ? error.message : String(error)
+      }])
+    });
+  }
+  const parent = path5.dirname(targetRoot);
+  const stagingRoot = await mkdtemp(path5.join(parent, ".appinit-stage-"));
+  const payloadRoot = path5.join(stagingRoot, "payload");
+  const backupRoot = path5.join(stagingRoot, "backup");
+  await mkdir(payloadRoot);
+  await mkdir(backupRoot);
+  const writtenFiles = [];
+  const overwrittenFiles = [];
+  const installed = [];
+  const backups = [];
+  const createdDirectories = [];
+  try {
+    for (const operation of normalized) {
+      const stagedPath = path5.join(payloadRoot, ...operation.destination.split("/"));
+      await mkdir(path5.dirname(stagedPath), { recursive: true });
+      await writeFile(stagedPath, operation.content);
+    }
+    for (const operation of normalized) {
+      const destinationPath = path5.join(targetRoot, ...operation.destination.split("/"));
+      const relativeParent = path5.dirname(operation.destination);
+      const before = /* @__PURE__ */ new Set();
+      let cursor = targetRoot;
+      for (const segment of relativeParent === "." ? [] : relativeParent.split("/")) {
+        cursor = path5.join(cursor, segment);
+        if (!await exists(cursor)) before.add(cursor);
+      }
+      await ensureSafeTargetDirectory(targetRoot, relativeParent);
+      for (const directory of before) createdDirectories.push(directory);
+      if (await exists(destinationPath)) {
+        const info = await lstat2(destinationPath);
+        if (info.isSymbolicLink()) {
+          throw new Error(`Refusing to overwrite symbolic link: ${operation.destination}`);
+        }
+        if (!info.isFile()) {
+          throw new Error(`Destination exists and is not a regular file: ${operation.destination}`);
+        }
+        const backupPath = path5.join(backupRoot, ...operation.destination.split("/"));
+        await mkdir(path5.dirname(backupPath), { recursive: true });
+        await rename(destinationPath, backupPath);
+        backups.push({ backup: backupPath, destination: destinationPath });
+        overwrittenFiles.push(operation.destination);
+      } else {
+        writtenFiles.push(operation.destination);
+      }
+      const stagedPath = path5.join(payloadRoot, ...operation.destination.split("/"));
+      await rename(stagedPath, destinationPath);
+      installed.push(destinationPath);
+    }
+    await rm(stagingRoot, { recursive: true, force: true });
+    return Object.freeze({
+      ok: true,
+      dryRun: false,
+      writtenFiles: Object.freeze(writtenFiles),
+      overwrittenFiles: Object.freeze(overwrittenFiles),
+      diagnostics: Object.freeze([])
+    });
+  } catch (error) {
+    const rollbackErrors = [];
+    for (const destination of installed.reverse()) {
+      await rm(destination, { force: true }).catch((rollbackError) => {
+        rollbackErrors.push(`Could not remove "${destination}": ${String(rollbackError)}`);
+      });
+    }
+    for (const item of backups.reverse()) {
+      await mkdir(path5.dirname(item.destination), { recursive: true }).catch((rollbackError) => {
+        rollbackErrors.push(`Could not recreate parent for "${item.destination}": ${String(rollbackError)}`);
+      });
+      await rename(item.backup, item.destination).catch((rollbackError) => {
+        rollbackErrors.push(`Could not restore "${item.destination}": ${String(rollbackError)}`);
+      });
+    }
+    for (const directory of createdDirectories.reverse()) {
+      await rmdir(directory).catch(() => void 0);
+    }
+    if (!targetExistedBeforeExecution) {
+      await rmdir(targetRoot).catch(() => void 0);
+    }
+    await rm(stagingRoot, { recursive: true, force: true }).catch((rollbackError) => {
+      rollbackErrors.push(`Could not remove staging directory: ${String(rollbackError)}`);
+    });
+    const cause = error instanceof Error ? error.message : String(error);
+    return Object.freeze({
+      ok: false,
+      dryRun: false,
+      writtenFiles: Object.freeze([]),
+      overwrittenFiles: Object.freeze([]),
+      diagnostics: Object.freeze([{
+        code: "EXECUTION_COMMIT_FAILED",
+        message: rollbackErrors.length > 0 ? `${cause}. Rollback also reported: ${rollbackErrors.join("; ")}` : cause
+      }])
+    });
+  }
+}
+
+// ../kernel/src/execution/phase.ts
+var LIFECYCLE_ORDER = [
+  "detect",
+  "validate",
+  "resolve",
+  "plan",
+  "execute",
+  "verify",
+  "report"
+];
+
+// ../kernel/src/template/manifest.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set([
+  "schemaVersion",
+  "id",
+  "version",
+  "kind",
+  "atsVersion",
+  "name",
+  "description",
+  "category",
+  "language",
+  "packageName",
+  "renderer",
+  "paths",
+  "tags",
+  "requires",
+  "provides",
+  "conflicts"
+]);
+var TEMPLATE_KINDS = /* @__PURE__ */ new Set([
+  "project",
+  "module",
+  "capability",
+  "preset",
+  "composition"
+]);
+var SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var ID_PATTERN = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+var ATS_PATTERN = /^\d+\.\d+$/;
+var PACKAGE_NAME_PATTERN = /^(?:@[a-z0-9][a-z0-9._-]*\/)?[a-z0-9][a-z0-9._-]*$/;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isSafeRelativePath(value) {
+  if (!isNonEmptyString(value) || value.includes("\\") || value.startsWith("/")) {
+    return false;
+  }
+  const segments = value.replace(/^\.\//, "").split("/");
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+}
+function validateTemplateManifest(value) {
+  const errors = [];
+  if (!isRecord(value)) {
+    return { valid: false, errors: ["Manifest must be a JSON object."] };
+  }
+  for (const key of Object.keys(value)) {
+    if (!ALLOWED_KEYS.has(key)) errors.push(`Unknown manifest field: ${key}`);
+  }
+  if (value.schemaVersion !== 1) {
+    errors.push("schemaVersion must be 1.");
+  }
+  if (!isNonEmptyString(value.id) || !ID_PATTERN.test(value.id)) {
+    errors.push("id must use lowercase dot- or hyphen-separated identifiers.");
+  }
+  if (!isNonEmptyString(value.version) || !SEMVER_PATTERN.test(value.version)) {
+    errors.push("version must be a valid semantic version.");
+  }
+  if (!isNonEmptyString(value.kind) || !TEMPLATE_KINDS.has(value.kind)) {
+    errors.push("kind must be project, module, capability, preset, or composition.");
+  }
+  if (!isNonEmptyString(value.atsVersion) || !ATS_PATTERN.test(value.atsVersion)) {
+    errors.push("atsVersion must use the MAJOR.MINOR format (for example, 2.0).");
+  }
+  if (!isNonEmptyString(value.name)) errors.push("name is required.");
+  if (!isNonEmptyString(value.description)) errors.push("description is required.");
+  if (!isNonEmptyString(value.category)) errors.push("category is required.");
+  if (!isNonEmptyString(value.language)) errors.push("language is required.");
+  if (!isNonEmptyString(value.packageName) || !PACKAGE_NAME_PATTERN.test(value.packageName)) {
+    errors.push("packageName must be a valid npm package name.");
+  }
+  if (!isRecord(value.renderer)) {
+    errors.push("renderer must be an object.");
+  } else if (value.renderer.engine !== "liquid" && value.renderer.engine !== "none") {
+    errors.push('renderer.engine must be "liquid" or "none".');
+  }
+  if (!isRecord(value.paths)) {
+    errors.push("paths must be an object.");
+  } else {
+    if (!isSafeRelativePath(value.paths.template)) {
+      errors.push("paths.template must be a safe relative path.");
+    }
+    for (const key of ["variables", "hooks"]) {
+      if (value.paths[key] !== void 0 && !isSafeRelativePath(value.paths[key])) {
+        errors.push(`paths.${key} must be a safe relative path when provided.`);
+      }
+    }
+  }
+  if (!Array.isArray(value.tags) || !value.tags.every((tag) => isNonEmptyString(tag))) {
+    errors.push("tags must be an array of non-empty strings.");
+  }
+  for (const key of ["requires", "provides", "conflicts"]) {
+    const entries = value[key];
+    if (entries === void 0) continue;
+    if (!Array.isArray(entries) || !entries.every((entry) => isNonEmptyString(entry))) {
+      errors.push(`${key} must be an array of non-empty strings when provided.`);
+      continue;
+    }
+    if (new Set(entries).size !== entries.length) {
+      errors.push(`${key} must not contain duplicate entries.`);
+    }
+  }
+  if (errors.length > 0) return { valid: false, errors };
+  return {
+    valid: true,
+    errors: [],
+    manifest: value
+  };
+}
+
+// ../kernel/src/template/registry.ts
+var CATALOG_KEYS = /* @__PURE__ */ new Set(["schemaVersion", "updatedAt", "templates"]);
+var ENTRY_KEYS = /* @__PURE__ */ new Set([
+  "id",
+  "version",
+  "name",
+  "description",
+  "category",
+  "language",
+  "tags",
+  "archive"
+]);
+var ARCHIVE_KEYS = /* @__PURE__ */ new Set(["url", "sha256"]);
+var ID_PATTERN2 = /^[a-z0-9]+(?:[.-][a-z0-9]+)*$/;
+var SEMVER_PATTERN2 = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+var SHA256_PATTERN = /^[a-f0-9]{64}$/;
+var MAX_CATALOG_ENTRIES = 1e4;
+var MAX_TEXT_LENGTH = 2e3;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isText(value) {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= MAX_TEXT_LENGTH;
+}
+function hasOnlyKeys(value, allowed, prefix, errors) {
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) errors.push(`Unknown ${prefix} field: ${key}`);
+  }
+}
+function isHttpsUrl(value) {
+  if (typeof value !== "string" || value.length > 4096) return false;
+  try {
+    const url = new URL(value);
+    return url.protocol === "https:" && url.hostname.length > 0 && url.username.length === 0 && url.password.length === 0 && url.hash.length === 0;
+  } catch {
+    return false;
+  }
+}
+function isIsoDateTime(value) {
+  if (typeof value !== "string" || value.length > 64 || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/.test(value)) {
+    return false;
+  }
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) return false;
+  const fraction = /\.(\d{1,3})Z$/.exec(value)?.[1] ?? "";
+  const normalized = value.replace(
+    /(?:\.\d{1,3})?Z$/,
+    "." + fraction.padEnd(3, "0") + "Z"
+  );
+  return new Date(timestamp).toISOString() === normalized;
+}
+function validateTemplateRegistryCatalog(value) {
+  const errors = [];
+  if (!isRecord2(value)) {
+    return { valid: false, errors: ["Registry catalog must be a JSON object."] };
+  }
+  hasOnlyKeys(value, CATALOG_KEYS, "catalog", errors);
+  if (value.schemaVersion !== 1) {
+    errors.push("schemaVersion must be 1.");
+  }
+  if (value.updatedAt !== void 0 && !isIsoDateTime(value.updatedAt)) {
+    errors.push("updatedAt must be an ISO-8601 UTC timestamp.");
+  }
+  if (!Array.isArray(value.templates)) {
+    errors.push("templates must be an array.");
+    return { valid: false, errors };
+  }
+  if (value.templates.length > MAX_CATALOG_ENTRIES) {
+    errors.push(`templates must contain no more than ${MAX_CATALOG_ENTRIES} entries.`);
+    return { valid: false, errors };
+  }
+  const identities = /* @__PURE__ */ new Set();
+  value.templates.forEach((entry, index) => {
+    const prefix = `templates[${index}]`;
+    if (!isRecord2(entry)) {
+      errors.push(`${prefix} must be an object.`);
+      return;
+    }
+    hasOnlyKeys(entry, ENTRY_KEYS, prefix, errors);
+    if (!isText(entry.id) || !ID_PATTERN2.test(entry.id)) {
+      errors.push(`${prefix}.id must use lowercase dot- or hyphen-separated identifiers.`);
+    }
+    if (!isText(entry.version) || !SEMVER_PATTERN2.test(entry.version)) {
+      errors.push(`${prefix}.version must be a valid semantic version.`);
+    }
+    for (const key of ["name", "description", "category", "language"]) {
+      if (!isText(entry[key])) errors.push(`${prefix}.${key} must be a non-empty string.`);
+    }
+    if (!Array.isArray(entry.tags) || !entry.tags.every((tag) => isText(tag))) {
+      errors.push(`${prefix}.tags must be an array of non-empty strings.`);
+    } else if (new Set(entry.tags).size !== entry.tags.length) {
+      errors.push(`${prefix}.tags must not contain duplicate entries.`);
+    }
+    if (!isRecord2(entry.archive)) {
+      errors.push(`${prefix}.archive must be an object.`);
+    } else {
+      hasOnlyKeys(entry.archive, ARCHIVE_KEYS, `${prefix}.archive`, errors);
+      if (!isHttpsUrl(entry.archive.url)) {
+        errors.push(`${prefix}.archive.url must be an HTTPS URL without credentials or a fragment.`);
+      }
+      if (typeof entry.archive.sha256 !== "string" || !SHA256_PATTERN.test(entry.archive.sha256)) {
+        errors.push(`${prefix}.archive.sha256 must be a lowercase 64-character SHA-256 digest.`);
+      }
+    }
+    if (typeof entry.id === "string" && typeof entry.version === "string" && ID_PATTERN2.test(entry.id) && SEMVER_PATTERN2.test(entry.version)) {
+      const identity = `${entry.id}@${entry.version}`;
+      if (identities.has(identity)) {
+        errors.push(`${prefix} duplicates template ${identity}.`);
+      }
+      identities.add(identity);
+    }
+  });
+  if (errors.length > 0) return { valid: false, errors };
+  return {
+    valid: true,
+    errors: [],
+    catalog: value
+  };
+}
+
+// ../kernel/src/plan/execution-plan-validator.ts
+var phaseOrder = new Map(LIFECYCLE_ORDER.map((phase, index) => [phase, index]));
+
+// ../os/src/engine/validation/validate-execution-intent.ts
+var EXECUTION_KINDS = /* @__PURE__ */ new Set(["scaffold", "generate", "preview", "validate"]);
+var INVOCATION_MODES = /* @__PURE__ */ new Set(["user", "author", "ci", "system"]);
+var ARTIFACT_KINDS = /* @__PURE__ */ new Set([
+  "preset",
+  "module",
+  "project",
+  "template",
+  "capability",
+  "composition"
+]);
+function isRecord3(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const valid2 = value.every((entry) => isJsonValue(entry, seen));
+    seen.delete(value);
+    return valid2;
+  }
+  if (!isRecord3(value)) return false;
+  const valid = Object.values(value).every((entry) => isJsonValue(entry, seen));
+  seen.delete(value);
+  return valid;
+}
+function validateExecutionIntent(input) {
+  const diagnostics = [];
+  const add = (code, message, field) => {
+    diagnostics.push({ code, message, ...field ? { field } : {} });
+  };
+  if (!isRecord3(input)) {
+    add("INTENT_INVALID_SHAPE", "Execution intent must be a plain object.");
+    return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
+  }
+  if (typeof input.executionKind !== "string" || !EXECUTION_KINDS.has(input.executionKind)) {
+    add("INTENT_INVALID_EXECUTION_KIND", "executionKind must be scaffold, generate, preview, or validate.", "executionKind");
+  }
+  if (typeof input.executionMode !== "string" || !INVOCATION_MODES.has(input.executionMode)) {
+    add("INTENT_INVALID_INVOCATION_MODE", "executionMode must be user, author, ci, or system.", "executionMode");
+  }
+  if (typeof input.artifactKind !== "string" || !ARTIFACT_KINDS.has(input.artifactKind)) {
+    add("INTENT_INVALID_ARTIFACT_KIND", "artifactKind must be a supported AppInit artifact kind.", "artifactKind");
+  }
+  if (typeof input.rootDir !== "string" || input.rootDir.trim().length === 0) {
+    add("INTENT_ROOT_REQUIRED", "rootDir must be a non-empty string.", "rootDir");
+  }
+  const kind = input.executionKind;
+  if ((kind === "scaffold" || kind === "generate") && (typeof input.targetDir !== "string" || input.targetDir.trim().length === 0)) {
+    add("INTENT_TARGET_REQUIRED", `targetDir is required for executionKind "${kind}".`, "targetDir");
+  }
+  if ((kind === "scaffold" || kind === "generate" || kind === "preview") && (typeof input.templateRef !== "string" || input.templateRef.trim().length === 0)) {
+    add("INTENT_TEMPLATE_REQUIRED", `templateRef is required for executionKind "${kind}".`, "templateRef");
+  }
+  if (input.variables !== void 0 && (!isRecord3(input.variables) || !isJsonValue(input.variables))) {
+    add("INTENT_VARIABLES_INVALID", "variables must be a plain JSON-serializable object.", "variables");
+  }
+  if (input.flags !== void 0) {
+    if (!isRecord3(input.flags)) {
+      add("INTENT_FLAGS_INVALID", "flags must be a plain object.", "flags");
+    } else {
+      for (const key of ["dryRun", "debug", "skipInstall", "watch", "author"]) {
+        if (input.flags[key] !== void 0 && typeof input.flags[key] !== "boolean") {
+          add("INTENT_FLAGS_INVALID", `flags.${key} must be a boolean when provided.`, `flags.${key}`);
+        }
+      }
+      const unknownFlags = Object.keys(input.flags).filter(
+        (key) => !["dryRun", "debug", "skipInstall", "watch", "author"].includes(key)
+      );
+      for (const key of unknownFlags) {
+        add("INTENT_FLAGS_INVALID", `Unknown execution flag "${key}".`, `flags.${key}`);
+      }
+    }
+  }
+  if (diagnostics.length > 0) {
+    return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
+  }
+  return Object.freeze({
+    ok: true,
+    diagnostics: Object.freeze([]),
+    intent: input
+  });
+}
+
+// ../os/src/engine/render/filters.ts
+function registerAppInitFilters(engine2) {
+  engine2.registerFilter(
+    "kebab",
+    (value) => String(value).trim().replace(/\s+/g, "-").toLowerCase()
+  );
+  engine2.registerFilter(
+    "camel",
+    (value) => String(value).replace(/-([a-z])/g, (_match, letter) => letter.toUpperCase())
+  );
+  engine2.registerFilter("json", (value) => JSON.stringify(value, null, 2));
+}
+
+// ../os/src/engine/render/render-liquid.ts
+import { Liquid } from "liquidjs";
+var engine = new Liquid({
+  strictVariables: true,
+  strictFilters: true,
+  ownPropertyOnly: true,
+  lenientIf: false
+});
+registerAppInitFilters(engine);
+async function renderLiquid(template, context) {
+  return engine.parseAndRender(template, context);
+}
+
+// ../os/src/engine/render/render-with-engine.ts
+function getPath(context, key) {
+  return key.split(".").reduce((value, segment) => {
+    if (value === null || typeof value !== "object" || !Object.prototype.hasOwnProperty.call(value, segment)) {
+      return void 0;
+    }
+    return value[segment];
+  }, context);
+}
+function assertNoLiquidSyntax(content, filePath, engine2) {
+  if (/\{\{|\{%|\{\#/s.test(content)) {
+    throw new Error(`Liquid syntax is not allowed in ${filePath} when renderer is "${engine2}".`);
+  }
+}
+function replaceDatPlaceholders(content, variables) {
+  return content.replace(/%%\s*([\w.-]+)\s*%%/g, (_match, key) => {
+    const value = getPath(variables, key);
+    return value == null ? "" : typeof value === "object" ? JSON.stringify(value) : String(value);
+  });
+}
+async function renderWithEngine(engine2, template, variables, filePath = "<virtual>") {
+  if (engine2 === "liquid") return replaceDatPlaceholders(await renderLiquid(template, variables), variables);
+  if (engine2 === "none") {
+    assertNoLiquidSyntax(template, filePath, engine2);
+    return replaceDatPlaceholders(template, variables);
+  }
+  throw new Error(`Unsupported template engine: ${engine2}`);
+}
+
+// ../os/src/engine/render/render-file.ts
+async function renderFile(options) {
+  const { file, engine: engine2, variables } = options;
+  if (file.binary) {
+    if (!Buffer.isBuffer(file.content)) throw new Error(`Binary template file "${file.dest}" must contain Buffer data.`);
+    return { dest: file.dest, content: Buffer.from(file.content) };
+  }
+  if (typeof file.content !== "string") {
+    throw new Error(`Text template file "${file.dest}" must contain string data.`);
+  }
+  if (!file.render) return { dest: file.dest, content: file.content };
+  return {
+    dest: file.dest,
+    content: await renderWithEngine(engine2, file.content, variables, file.dest)
+  };
+}
+
+// ../os/src/engine/render/validate-variables.ts
+function validateTemplateVariables(variables, schema = {}) {
+  const errors = [];
+  if (variables === null || typeof variables !== "object" || Array.isArray(variables) || Object.getPrototypeOf(variables) !== Object.prototype && Object.getPrototypeOf(variables) !== null) {
+    return { valid: false, errors: ["Variables must be a plain object."] };
+  }
+  const values = variables;
+  for (const [key, rule] of Object.entries(schema)) {
+    const value = values[key];
+    if (value === void 0 || value === null) {
+      if (rule.required) errors.push(`"${key}" is required.`);
+      continue;
+    }
+    const validType = rule.type === "array" && Array.isArray(value) || rule.type === "object" && value !== null && typeof value === "object" && !Array.isArray(value) || rule.type !== "array" && rule.type !== "object" && typeof value === rule.type;
+    if (!validType) {
+      errors.push(`"${key}" must be a ${rule.type}.`);
+      continue;
+    }
+    if (typeof value === "string") {
+      if (rule.minLength !== void 0 && value.length < rule.minLength) errors.push(`"${key}" must contain at least ${rule.minLength} characters.`);
+      if (rule.maxLength !== void 0 && value.length > rule.maxLength) errors.push(`"${key}" must contain at most ${rule.maxLength} characters.`);
+    }
+    if (rule.enum && !rule.enum.some((allowed) => Object.is(allowed, value))) {
+      errors.push(`"${key}" must be one of: ${rule.enum.join(", ")}.`);
+    }
+  }
+  return Object.freeze({ valid: errors.length === 0, errors: Object.freeze(errors) });
+}
+
+// ../os/src/engine/verify-generated-output.ts
+import { lstat as lstat3, readFile, readdir as readdir2, realpath as realpath2 } from "fs/promises";
+import path6 from "path";
+function isWithin(parent, child) {
+  const relative = path6.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path6.sep}`) && relative !== ".." && !path6.isAbsolute(relative);
+}
+function sameContent(actual, expected) {
+  const expectedBytes = Buffer.isBuffer(expected) ? expected : Buffer.from(expected, "utf8");
+  return actual.equals(expectedBytes);
+}
+async function verifyGeneratedOutput(targetDirectory, operations, options = {}) {
+  const diagnostics = [];
+  const expected = /* @__PURE__ */ new Map();
+  for (const operation of operations) {
+    try {
+      const destination = normalizeVfsDestination(operation.destination);
+      if (expected.has(destination)) {
+        diagnostics.push({
+          code: "VERIFY_EXPECTED_PATH_DUPLICATE",
+          destination,
+          message: `Execution plan contains duplicate expected path "${destination}".`
+        });
+      } else {
+        expected.set(destination, operation);
+      }
+    } catch (error) {
+      diagnostics.push({
+        code: "VERIFY_EXPECTED_PATH_INVALID",
+        destination: operation.destination,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  let root;
+  try {
+    const info = await lstat3(targetDirectory);
+    if (info.isSymbolicLink() || !info.isDirectory()) {
+      throw new Error("Target directory must be a real directory, not a symlink or file.");
+    }
+    root = await realpath2(targetDirectory);
+  } catch (error) {
+    diagnostics.push({
+      code: "VERIFY_TARGET_MISSING",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return Object.freeze({
+      ok: false,
+      targetDirectory,
+      expectedFiles: Object.freeze([...expected.keys()].sort()),
+      actualFiles: Object.freeze([]),
+      diagnostics: Object.freeze(diagnostics)
+    });
+  }
+  const actual = /* @__PURE__ */ new Set();
+  async function walk2(directory, relativeDirectory) {
+    let entries;
+    try {
+      entries = await readdir2(directory, { withFileTypes: true });
+    } catch (error) {
+      diagnostics.push({
+        code: "VERIFY_READ_FAILED",
+        destination: relativeDirectory || void 0,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return;
+    }
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const relative = relativeDirectory ? `${relativeDirectory}/${entry.name}` : entry.name;
+      const absolute = path6.join(directory, entry.name);
+      let info;
+      try {
+        info = await lstat3(absolute);
+      } catch (error) {
+        diagnostics.push({
+          code: "VERIFY_READ_FAILED",
+          destination: relative,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        continue;
+      }
+      if (info.isSymbolicLink()) {
+        diagnostics.push({
+          code: "VERIFY_SYMLINK_DETECTED",
+          destination: relative,
+          message: `Generated output contains a symbolic link at "${relative}".`
+        });
+        continue;
+      }
+      if (info.isDirectory()) {
+        const canonical = await realpath2(absolute);
+        if (!isWithin(root, canonical)) {
+          diagnostics.push({
+            code: "VERIFY_TARGET_INVALID",
+            destination: relative,
+            message: `Directory "${relative}" resolves outside the output root.`
+          });
+          continue;
+        }
+        await walk2(absolute, relative);
+        continue;
+      }
+      if (!info.isFile()) {
+        diagnostics.push({
+          code: "VERIFY_FILE_TYPE_MISMATCH",
+          destination: relative,
+          message: `Generated path "${relative}" is not a regular file.`
+        });
+        continue;
+      }
+      actual.add(relative);
+      const operation = expected.get(relative);
+      if (!operation) {
+        if (options.rejectUnexpectedFiles !== false) {
+          diagnostics.push({
+            code: "VERIFY_UNEXPECTED_FILE",
+            destination: relative,
+            message: `Unexpected file "${relative}" exists in generated output.`
+          });
+        }
+        continue;
+      }
+      try {
+        const content = await readFile(absolute);
+        if (!sameContent(content, operation.content)) {
+          diagnostics.push({
+            code: "VERIFY_CONTENT_MISMATCH",
+            destination: relative,
+            message: `Generated file "${relative}" does not match the rendered execution plan.`
+          });
+        }
+      } catch (error) {
+        diagnostics.push({
+          code: "VERIFY_READ_FAILED",
+          destination: relative,
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  await walk2(root, "");
+  for (const destination of expected.keys()) {
+    if (!actual.has(destination)) {
+      diagnostics.push({
+        code: "VERIFY_FILE_MISSING",
+        destination,
+        message: `Expected generated file "${destination}" is missing.`
+      });
+    }
+  }
+  return Object.freeze({
+    ok: diagnostics.length === 0,
+    targetDirectory: root,
+    expectedFiles: Object.freeze([...expected.keys()].sort()),
+    actualFiles: Object.freeze([...actual].sort()),
+    diagnostics: Object.freeze(diagnostics)
+  });
+}
+
+// ../os/src/state/appinit-state.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir2, readFile as readFile2, realpath as realpath3, rename as rename2, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import path7 from "path";
+function isWithin2(parent, child) {
+  const relative = path7.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path7.sep}`) && relative !== ".." && !path7.isAbsolute(relative);
+}
+function resolveAppInitHome(options = {}) {
+  const env = options.env ?? process.env;
+  const configuredHome = env.APPINIT_HOME;
+  if (configuredHome !== void 0) {
+    if (configuredHome.trim().length === 0) {
+      throw new Error("APPINIT_HOME must not be empty when set.");
+    }
+    return path7.resolve(configuredHome);
+  }
+  return path7.resolve(options.homeDirectory ?? homedir(), ".appinit");
+}
+async function ensureAppInitHome(homeDirectory = resolveAppInitHome()) {
+  const resolvedHome = path7.resolve(homeDirectory);
+  await mkdir2(resolvedHome, { recursive: true, mode: 448 });
+  return realpath3(resolvedHome);
+}
+function resolveAppInitPath(homeDirectory, relativePath) {
+  if (typeof relativePath !== "string" || relativePath.length === 0 || relativePath.includes("\\") || relativePath.includes("\0") || relativePath.startsWith("/") || relativePath.split("/").some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    throw new Error("AppInit state path must be a safe, non-empty relative path.");
+  }
+  const root = path7.resolve(homeDirectory);
+  const target = path7.resolve(root, ...relativePath.split("/"));
+  if (!isWithin2(root, target) || root === target) {
+    throw new Error("AppInit state path must remain inside the global state directory.");
+  }
+  return target;
+}
+async function resolveExistingStateFile(homeDirectory, relativePath) {
+  const candidate = resolveAppInitPath(homeDirectory, relativePath);
+  const root = await realpath3(homeDirectory);
+  const resolved = await realpath3(candidate);
+  if (!isWithin2(root, resolved) || root === resolved) {
+    throw new Error("AppInit state path resolves outside the global state directory.");
+  }
+  return resolved;
+}
+async function readAppInitJson(homeDirectory, relativePath) {
+  let contents;
+  try {
+    const filePath = await resolveExistingStateFile(homeDirectory, relativePath);
+    contents = await readFile2(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  try {
+    return JSON.parse(contents);
+  } catch (error) {
+    throw new Error("AppInit state file contains invalid JSON.", { cause: error });
+  }
+}
+async function ensureStateParent(homeDirectory, relativePath) {
+  const root = await ensureAppInitHome(homeDirectory);
+  const segments = relativePath.split("/");
+  let current = root;
+  for (const segment of segments.slice(0, -1)) {
+    current = path7.join(current, segment);
+    await mkdir2(current, { recursive: false, mode: 448 }).catch((error) => {
+      if (error.code !== "EEXIST") throw error;
+    });
+    const resolved = await realpath3(current);
+    if (!isWithin2(root, resolved) || root === resolved) {
+      throw new Error("AppInit state path resolves outside the global state directory.");
+    }
+    current = resolved;
+  }
+  return current;
+}
+async function writeAppInitJson(homeDirectory, relativePath, value) {
+  const candidate = resolveAppInitPath(homeDirectory, relativePath);
+  const serialized = JSON.stringify(value, null, 2);
+  if (serialized === void 0) {
+    throw new Error("AppInit state value must be JSON-serializable.");
+  }
+  const directory = await ensureStateParent(homeDirectory, relativePath);
+  const filePath = path7.join(directory, path7.basename(candidate));
+  const temporaryPath = path7.join(directory, `.${path7.basename(filePath)}.${randomUUID()}.tmp`);
+  try {
+    await writeFile2(temporaryPath, `${serialized}
+`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 384
+    });
+    await rename2(temporaryPath, filePath);
+  } catch (error) {
+    await rm2(temporaryPath, { force: true }).catch(() => void 0);
+    throw error;
+  }
+}
+
+// ../os/src/state/appinit-state-schema.ts
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function validateAppInitState(value) {
+  const errors = [];
+  if (!isRecord4(value)) {
+    return { valid: false, errors: ["State must be a JSON object."] };
+  }
+  const allowedKeys = ["schemaVersion", "projects", "lastUpdateCheck", "latestVersion"];
+  if (Object.keys(value).some((key) => !allowedKeys.includes(key))) {
+    errors.push("State contains unknown fields.");
+  }
+  const isLegacyUpdateState = !Object.prototype.hasOwnProperty.call(value, "schemaVersion") && !Object.prototype.hasOwnProperty.call(value, "projects") && (Object.prototype.hasOwnProperty.call(value, "lastUpdateCheck") || Object.prototype.hasOwnProperty.call(value, "latestVersion"));
+  const unsupportedVersion = !isLegacyUpdateState && typeof value.schemaVersion === "number" && Number.isInteger(value.schemaVersion) && value.schemaVersion > 1 ? value.schemaVersion : void 0;
+  if (!isLegacyUpdateState && value.schemaVersion !== 1) {
+    errors.push(unsupportedVersion === void 0 ? "schemaVersion must be 1." : `State uses unsupported newer schema version ${unsupportedVersion}; this AppInit version supports schema version 1.`);
+  }
+  const rawProjects = isLegacyUpdateState ? [] : value.projects;
+  if (!Array.isArray(rawProjects)) {
+    errors.push("projects must be an array.");
+  } else {
+    rawProjects.forEach((project, index) => {
+      if (!isRecord4(project)) {
+        errors.push(`projects[${index}] must be an object.`);
+        return;
+      }
+      if (Object.keys(project).some((key) => !["path", "templateId", "createdAt"].includes(key))) {
+        errors.push(`projects[${index}] contains unknown fields.`);
+      }
+      if (!isNonEmptyString2(project.path)) {
+        errors.push(`projects[${index}].path must be a non-empty string.`);
+      }
+      if (!isNonEmptyString2(project.templateId)) {
+        errors.push(`projects[${index}].templateId must be a non-empty string.`);
+      }
+      if (!isNonEmptyString2(project.createdAt) || !Number.isFinite(Date.parse(project.createdAt))) {
+        errors.push(`projects[${index}].createdAt must be a valid date string.`);
+      }
+    });
+  }
+  if (errors.length > 0) return { valid: false, errors, ...unsupportedVersion === void 0 ? {} : { unsupportedVersion } };
+  return {
+    valid: true,
+    errors: [],
+    state: {
+      ...value,
+      schemaVersion: 1,
+      projects: rawProjects
+    }
+  };
+}
+
+// src/context.ts
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function readOptionalJson(filePath, diagnostics) {
+  let source;
+  try {
+    source = await readFile3(filePath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    diagnostics.push(`Could not read ${path8.basename(filePath)}: ${error instanceof Error ? error.message : String(error)}`);
+    return void 0;
+  }
+  try {
+    const value = JSON.parse(source);
+    if (!isRecord5(value)) {
+      diagnostics.push(`${path8.basename(filePath)} must contain a JSON object.`);
+      return void 0;
+    }
+    return value;
+  } catch {
+    diagnostics.push(`${path8.basename(filePath)} contains invalid JSON.`);
+    return void 0;
+  }
+}
+function optionalString(record, key) {
+  const value = record?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function samePath(left, right) {
+  const a = path8.resolve(left);
+  const b = path8.resolve(right);
+  return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+async function readProjectContext(cwd = process.cwd()) {
+  const rootDir = path8.resolve(cwd);
+  const diagnostics = [];
+  const appinitDirectory = path8.join(rootDir, ".appinit");
+  const [packageJson, project, template, context] = await Promise.all([
+    readOptionalJson(path8.join(rootDir, "package.json"), diagnostics),
+    readOptionalJson(path8.join(appinitDirectory, "project.json"), diagnostics),
+    readOptionalJson(path8.join(appinitDirectory, "template.json"), diagnostics),
+    readOptionalJson(path8.join(appinitDirectory, "context.json"), diagnostics)
+  ]);
+  let history;
+  try {
+    const value = await readAppInitJson(resolveAppInitHome(), "state.json");
+    if (value !== void 0) {
+      const validation = validateAppInitState(value);
+      if (!validation.valid || !validation.state) {
+        diagnostics.push(`Global AppInit state is invalid: ${validation.errors.join(" ")}`);
+      } else {
+        history = validation.state.projects.find((entry) => samePath(entry.path, rootDir));
+      }
+    }
+  } catch (error) {
+    diagnostics.push(`Global AppInit state could not be read: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const packageInfo = packageJson ? {
+    ...optionalString(packageJson, "name") ? { name: optionalString(packageJson, "name") } : {},
+    ...optionalString(packageJson, "version") ? { version: optionalString(packageJson, "version") } : {}
+  } : void 0;
+  const appinit = project || template || context ? {
+    ...project ? { project } : {},
+    ...template ? { template } : {},
+    ...context ? { context } : {}
+  } : void 0;
+  return Object.freeze({
+    rootDir,
+    ...packageInfo ? { package: Object.freeze(packageInfo) } : {},
+    ...appinit ? { appinit: Object.freeze(appinit) } : {},
+    ...history ? { history } : {},
+    diagnostics: Object.freeze(diagnostics)
+  });
+}
+async function runContextCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const report = await readProjectContext(options.cwd);
+  if (options.json) {
+    io.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  io.write("AppInit Project Context\n\n");
+  io.write(`Project: ${report.package?.name ?? report.appinit?.project?.name ?? path8.basename(report.rootDir)}
+`);
+  io.write(`Path: ${report.rootDir}
+`);
+  if (report.package?.version) io.write(`Version: ${report.package.version}
+`);
+  const project = report.appinit?.project;
+  if (project) {
+    io.write("\nProject metadata (.appinit/project.json)\n");
+    for (const key of ["name", "createdAt", "cliVersion", "atsVersion"]) {
+      const value = optionalString(project, key);
+      if (value) io.write(`  ${key}: ${value}
+`);
+    }
+  }
+  const template = report.appinit?.template;
+  if (template) {
+    io.write("\nTemplate metadata (.appinit/template.json)\n");
+    for (const key of ["templateId", "version", "source", "installedAt"]) {
+      const value = optionalString(template, key);
+      if (value) io.write(`  ${key}: ${value}
+`);
+    }
+  }
+  const context = report.appinit?.context;
+  if (context) {
+    io.write("\nDeclared context (.appinit/context.json)\n");
+    for (const key of ["artifactKind", "runtime", "framework", "atsVersion"]) {
+      const value = optionalString(context, key);
+      if (value) io.write(`  ${key}: ${value}
+`);
+    }
+  }
+  if (report.history) {
+    io.write("\nGlobal project history\n");
+    io.write(`  Template: ${report.history.templateId}
+`);
+    io.write(`  Created: ${report.history.createdAt}
+`);
+  } else {
+    io.write("\nGlobal project history: no matching entry\n");
+  }
+  if (!report.appinit) io.write("\nNo .appinit project metadata found.\n");
+  if (report.diagnostics.length) {
+    io.write("\nDiagnostics\n");
+    for (const diagnostic3 of report.diagnostics) io.write(`  ! ${diagnostic3}
+`);
+  }
+}
+
+// src/create.ts
+import { lstat as lstat6, readdir as readdir4, readFile as readFile9, realpath as realpath7 } from "fs/promises";
+import path16 from "path";
+
+// ../sdk/src/resolver/resolve-template.ts
+import { realpath as realpath4, stat, readFile as readFile5 } from "fs/promises";
+import path10 from "path";
+
+// ../sdk/src/resolver/template-vfs.ts
+import { readFile as readFile4 } from "fs/promises";
+import path9 from "path";
+var IGNORED_SEGMENTS = /* @__PURE__ */ new Set([".git", "node_modules", "docs", "variables", "hooks"]);
+var STATIC_RENAMES = {
+  _gitignore: ".gitignore",
+  _npmrc: ".npmrc"
+};
+function normalizeTemplatePath(relativePath) {
+  let dest = relativePath.replace(/\\/g, "/");
+  let render = false;
+  if (dest.endsWith("__tmpl")) {
+    dest = dest.slice(0, -"__tmpl".length);
+    render = true;
+  } else if (dest.endsWith(".tmpl")) {
+    dest = dest.slice(0, -".tmpl".length);
+    render = true;
+  }
+  const segments = dest.split("/");
+  const basename = segments.pop() ?? "";
+  const renamed = STATIC_RENAMES[basename] ?? basename;
+  const normalized = [...segments, renamed].filter(Boolean).join("/");
+  return { dest: normalized, render };
+}
+async function createTemplateVFS(templateDirectory) {
+  const root = await import("fs/promises").then(({ realpath: realpath9 }) => realpath9(templateDirectory));
+  const entries = await readDirRecursive(root);
+  const vfs = new VirtualFileSystem();
+  for (const relativePath of entries) {
+    const segments = relativePath.split("/");
+    if (segments.some((segment) => IGNORED_SEGMENTS.has(segment)) || segments.at(-1) === ".DS_Store") continue;
+    const { dest, render } = normalizeTemplatePath(relativePath);
+    const absolutePath = path9.join(root, ...relativePath.split("/"));
+    const binary = isBinaryFile(absolutePath);
+    const content = binary ? await readFile4(absolutePath) : await readFile4(absolutePath, "utf8");
+    vfs.add({ dest, content, render, binary });
+  }
+  return freezeVFS(vfs);
+}
+
+// ../sdk/src/resolver/resolve-template.ts
+function isWithin3(parent, child) {
+  const relative = path10.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path10.sep}`) && relative !== ".." && !path10.isAbsolute(relative);
+}
+async function resolveTemplate(templateRoot, options = {}) {
+  const root = await realpath4(path10.resolve(templateRoot));
+  const rootInfo = await stat(root);
+  if (!rootInfo.isDirectory()) {
+    throw new Error(`Template root is not a directory: ${templateRoot}`);
+  }
+  const manifestFile = options.manifestFile ?? "appinit.template.json";
+  if (path10.isAbsolute(manifestFile) || manifestFile.includes("\\") || manifestFile.split("/").some((part) => part === ".." || part === "." || part === "")) {
+    throw new Error("Manifest filename must be a safe relative path.");
+  }
+  const manifestPath = await realpath4(path10.join(root, manifestFile));
+  if (!isWithin3(root, manifestPath)) {
+    throw new Error("Template manifest resolves outside the template root.");
+  }
+  const raw = await readFile5(manifestPath, "utf8");
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Template manifest contains invalid JSON: ${manifestPath}`, { cause: error });
+  }
+  const validation = validateTemplateManifest(value);
+  if (!validation.valid || !validation.manifest) {
+    throw new Error(`Invalid template manifest: ${validation.errors.join(" ")}`);
+  }
+  const declaredTemplatePath = path10.resolve(root, ...validation.manifest.paths.template.split("/"));
+  const templatePath = await realpath4(declaredTemplatePath);
+  if (!isWithin3(root, templatePath)) {
+    throw new Error("Declared template path resolves outside the template root.");
+  }
+  const templateInfo = await stat(templatePath);
+  if (!templateInfo.isDirectory()) {
+    throw new Error("Declared template path is not a directory.");
+  }
+  const vfs = await createTemplateVFS(templatePath);
+  return Object.freeze({ root, manifest: validation.manifest, vfs });
+}
+
+// ../sdk/src/resolver/discover-template.ts
+async function discoverTemplate(templateRef, options) {
+  if (typeof templateRef !== "string" || templateRef.trim().length === 0) {
+    throw new Error("Template reference must be a non-empty string.");
+  }
+  const root = options.templateRoots.get(templateRef);
+  if (!root) {
+    throw new Error(`Template "${templateRef}" is not present in the approved template roots.`);
+  }
+  const template = await resolveTemplate(root, {
+    ...options.manifestFile ? { manifestFile: options.manifestFile } : {}
+  });
+  const manifest = template.manifest;
+  if (manifest.id === templateRef) {
+    return Object.freeze({ template, matchedBy: "id" });
+  }
+  if (manifest.packageName === templateRef) {
+    return Object.freeze({ template, matchedBy: "packageName" });
+  }
+  throw new Error(
+    `Approved root for "${templateRef}" contains template "${manifest.id}" (${manifest.packageName}); identity mismatch.`
+  );
+}
+
+// ../sdk/src/resolver/discover-template-catalog.ts
+import { lstat as lstat4, readdir as readdir3, realpath as realpath5 } from "fs/promises";
+import path11 from "path";
+
+// ../sdk/src/resolver/variables.ts
+import { realpath as realpath6, readFile as readFile6, stat as stat2 } from "fs/promises";
+import path12 from "path";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isWithin4(parent, child) {
+  const relative = path12.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path12.sep}`) && relative !== ".." && !path12.isAbsolute(relative);
+}
+async function readJsonRecord(filePath) {
+  let value;
+  try {
+    value = JSON.parse(await readFile6(filePath, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") throw error;
+    throw new Error(`Unable to parse template variable file: ${filePath}`, { cause: error });
+  }
+  if (!isRecord6(value)) throw new Error(`Template variable file must contain a JSON object: ${filePath}`);
+  return value;
+}
+async function loadTemplateVariables(templateRoot, manifest) {
+  if (!manifest.paths.variables) return { defaults: {}, schema: {} };
+  const root = await realpath6(path12.resolve(templateRoot));
+  const directory = path12.resolve(root, ...manifest.paths.variables.split("/"));
+  let variablesRoot;
+  try {
+    variablesRoot = await realpath6(directory);
+  } catch (error) {
+    if (error.code === "ENOENT") return { defaults: {}, schema: {} };
+    throw error;
+  }
+  if (!isWithin4(root, variablesRoot)) {
+    throw new Error("Declared variables directory resolves outside the template root.");
+  }
+  if (!(await stat2(variablesRoot)).isDirectory()) {
+    throw new Error("Declared variables path is not a directory.");
+  }
+  const defaultsPath = path12.join(variablesRoot, "defaults.json");
+  const schemaPath = path12.join(variablesRoot, "schema.json");
+  const defaults = await readOptionalJson2(defaultsPath);
+  const schemaRaw = await readOptionalJson2(schemaPath);
+  const schema = {};
+  for (const [key, rule] of Object.entries(schemaRaw)) {
+    if (!isRecord6(rule)) throw new Error(`Variable schema entry "${key}" must be an object.`);
+    if (rule.type !== void 0 && !["string", "number", "boolean", "object", "array"].includes(String(rule.type))) {
+      throw new Error(`Variable schema entry "${key}" has an unsupported type.`);
+    }
+    if (rule.required !== void 0 && typeof rule.required !== "boolean") {
+      throw new Error(`Variable schema entry "${key}".required must be boolean.`);
+    }
+    if (rule.minLength !== void 0 && (!Number.isInteger(rule.minLength) || Number(rule.minLength) < 0)) {
+      throw new Error(`Variable schema entry "${key}".minLength must be a non-negative integer.`);
+    }
+    if (rule.enum !== void 0 && !Array.isArray(rule.enum)) {
+      throw new Error(`Variable schema entry "${key}".enum must be an array.`);
+    }
+    schema[key] = rule;
+  }
+  return Object.freeze({
+    defaults: Object.freeze(defaults),
+    schema: Object.freeze(schema)
+  });
+}
+async function readOptionalJson2(filePath) {
+  try {
+    return await readJsonRecord(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT") return {};
+    throw error;
+  }
+}
+function validateTemplateVariables2(values, schema) {
+  const errors = [];
+  for (const [key, rule] of Object.entries(schema)) {
+    const value = values[key];
+    if (value === void 0 || value === null) {
+      if (rule.required) errors.push(`Variable "${key}" is required.`);
+      continue;
+    }
+    if (rule.type) {
+      const valid = rule.type === "array" ? Array.isArray(value) : rule.type === "object" ? isRecord6(value) : typeof value === rule.type;
+      if (!valid || rule.type === "number" && !Number.isFinite(value)) {
+        errors.push(`Variable "${key}" must be a valid ${rule.type}.`);
+        continue;
+      }
+    }
+    if (rule.minLength !== void 0 && typeof value === "string" && value.length < rule.minLength) {
+      errors.push(`Variable "${key}" must contain at least ${rule.minLength} characters.`);
+    }
+    if (rule.enum && !rule.enum.some((allowed) => Object.is(allowed, value))) {
+      errors.push(`Variable "${key}" must be one of: ${rule.enum.map(String).join(", ")}.`);
+    }
+  }
+  return errors;
+}
+
+// ../sdk/src/resolver/template-registry-client.ts
+import { createHash, randomUUID as randomUUID2, timingSafeEqual } from "crypto";
+import { mkdir as mkdir3, readFile as readFile7, rename as rename3, rm as rm3, writeFile as writeFile3 } from "fs/promises";
+import path13 from "path";
+var DEFAULT_MAX_CATALOG_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_ARCHIVE_BYTES = 100 * 1024 * 1024;
+function assertHttpsUrl(value, label) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" || url.username || url.password || url.hash) {
+    throw new Error(`${label} must be an HTTPS URL without credentials or a fragment.`);
+  }
+  return url;
+}
+function safeSegment(value, label) {
+  if (!/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/.test(value)) {
+    throw new Error(`Invalid ${label} for registry cache path.`);
+  }
+  return value;
+}
+async function readBoundedResponse(response, maxBytes, label) {
+  if (!response.ok) throw new Error(`${label} request failed with HTTP ${response.status}.`);
+  const declaredLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
+    throw new Error(`${label} exceeds the ${maxBytes}-byte size limit.`);
+  }
+  if (!response.body) return new Uint8Array();
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxBytes) {
+        await reader.cancel();
+        throw new Error(`${label} exceeds the ${maxBytes}-byte size limit.`);
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return bytes;
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function matchesDigest(actual, expected) {
+  const actualBytes = Buffer.from(actual, "hex");
+  const expectedBytes = Buffer.from(expected, "hex");
+  return actualBytes.length === expectedBytes.length && timingSafeEqual(actualBytes, expectedBytes);
+}
+var TemplateRegistryClient = class {
+  constructor(options) {
+    this.options = options;
+    assertHttpsUrl(options.catalogUrl, "Catalog URL");
+    this.request = options.fetch ?? fetch;
+    this.maxCatalogBytes = options.maxCatalogBytes ?? DEFAULT_MAX_CATALOG_BYTES;
+    this.maxArchiveBytes = options.maxArchiveBytes ?? DEFAULT_MAX_ARCHIVE_BYTES;
+  }
+  request;
+  maxCatalogBytes;
+  maxArchiveBytes;
+  async fetchCatalog() {
+    const response = await this.request(this.options.catalogUrl, {
+      method: "GET",
+      redirect: "error",
+      headers: { accept: "application/json" }
+    });
+    const bytes = await readBoundedResponse(response, this.maxCatalogBytes, "Registry catalog");
+    let parsed;
+    try {
+      parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    } catch {
+      throw new Error("Registry catalog response is not valid UTF-8 JSON.");
+    }
+    const result = validateTemplateRegistryCatalog(parsed);
+    if (!result.valid || !result.catalog) {
+      throw new Error(`Registry catalog validation failed: ${result.errors.join("; ")}`);
+    }
+    return result.catalog;
+  }
+  async downloadTemplate(entry) {
+    safeSegment(entry.id, "template ID");
+    safeSegment(entry.version, "template version");
+    const archiveUrl = assertHttpsUrl(entry.archive.url, "Template archive URL");
+    const cacheRoot = path13.resolve(this.options.cacheDirectory);
+    const destination = path13.resolve(cacheRoot, entry.id, entry.version, "template.tar");
+    if (!destination.startsWith(cacheRoot + path13.sep)) {
+      throw new Error("Resolved template cache path escapes the configured cache directory.");
+    }
+    try {
+      const existing = await readFile7(destination);
+      const digest2 = sha256(existing);
+      if (matchesDigest(digest2, entry.archive.sha256)) {
+        return Object.freeze({ entry, path: destination, sha256: digest2, cached: true });
+      }
+      await rm3(destination, { force: true });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const response = await this.request(archiveUrl, {
+      method: "GET",
+      redirect: "error",
+      headers: { accept: "application/octet-stream, application/gzip" }
+    });
+    const bytes = await readBoundedResponse(response, this.maxArchiveBytes, "Template archive");
+    const digest = sha256(bytes);
+    if (!matchesDigest(digest, entry.archive.sha256)) {
+      throw new Error(`Template archive SHA-256 mismatch for ${entry.id}@${entry.version}.`);
+    }
+    await mkdir3(path13.dirname(destination), { recursive: true });
+    const temporary = `${destination}.${randomUUID2()}.tmp`;
+    try {
+      await writeFile3(temporary, bytes, { flag: "wx", mode: 384 });
+      await rename3(temporary, destination);
+    } catch (error) {
+      await rm3(temporary, { force: true });
+      throw error;
+    }
+    return Object.freeze({ entry, path: destination, sha256: digest, cached: false });
+  }
+};
+
+// ../sdk/src/resolver/extract-template-archive.ts
+import { lstat as lstat5, mkdir as mkdir4, open, readFile as readFile8, rename as rename4, rm as rm4 } from "fs/promises";
+import path14 from "path";
+import { gunzipSync } from "zlib";
+var BLOCK_SIZE = 512;
+var DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_MAX_EXPANDED_BYTES = 250 * 1024 * 1024;
+var FORBIDDEN_SEGMENTS = /* @__PURE__ */ new Set([".", ".."]);
+function readString(header, start, length) {
+  const end = header.indexOf(0, start);
+  const stop = end === -1 || end >= start + length ? start + length : end;
+  return header.toString("utf8", start, stop);
+}
+function readOctal(header, start, length, field) {
+  const raw = header.toString("ascii", start, start + length).replace(/\0.*$/, "").trim();
+  if (raw === "") return 0;
+  if (!/^[0-7]+$/.test(raw)) throw new Error(`Invalid tar ${field} field.`);
+  const value = Number.parseInt(raw, 8);
+  if (!Number.isSafeInteger(value)) throw new Error(`Tar ${field} exceeds supported size.`);
+  return value;
+}
+function verifyHeaderChecksum(header) {
+  const expected = readOctal(header, 148, 8, "checksum");
+  let actual = 0;
+  for (let index = 0; index < BLOCK_SIZE; index++) {
+    actual += index >= 148 && index < 156 ? 32 : header[index];
+  }
+  if (actual !== expected) throw new Error("Tar header checksum mismatch.");
+}
+function normalizeArchivePath(raw) {
+  if (!raw || raw.includes("\0") || raw.includes("\\")) {
+    throw new Error("Archive contains an empty or unsafe path.");
+  }
+  if (raw.startsWith("/") || /^[a-zA-Z]:/.test(raw) || raw.startsWith("//")) {
+    throw new Error(`Archive path must be relative: ${raw}`);
+  }
+  const segments = raw.split("/");
+  if (segments.some((segment) => FORBIDDEN_SEGMENTS.has(segment) || segment === "")) {
+    throw new Error(`Archive path contains traversal or empty segments: ${raw}`);
+  }
+  return segments.join("/");
+}
+function isZeroBlock(block) {
+  return block.every((byte) => byte === 0);
+}
+function parseTar(bytes) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  let offset = 0;
+  let zeroBlocks = 0;
+  while (offset + BLOCK_SIZE <= bytes.length) {
+    const header = bytes.subarray(offset, offset + BLOCK_SIZE);
+    offset += BLOCK_SIZE;
+    if (isZeroBlock(header)) {
+      zeroBlocks++;
+      if (zeroBlocks === 2) break;
+      continue;
+    }
+    if (zeroBlocks > 0) throw new Error("Tar archive has data after its end marker.");
+    verifyHeaderChecksum(header);
+    const name = readString(header, 0, 100);
+    const prefix = readString(header, 345, 155);
+    const rawPath = prefix ? `${prefix}/${name}` : name;
+    const typeFlag = header[156];
+    const size = readOctal(header, 124, 12, "size");
+    const mode = readOctal(header, 100, 8, "mode");
+    if ((mode & 3072) !== 0) throw new Error("Tar entries may not set setuid or setgid permissions.");
+    if (typeFlag !== 0 && typeFlag !== 48 && typeFlag !== 53) {
+      throw new Error("Tar archive contains a link, extension, or unsupported entry type.");
+    }
+    const type = typeFlag === 53 ? "directory" : "file";
+    if (type === "directory" && size !== 0) throw new Error("Tar directory entries must be empty.");
+    const normalized = normalizeArchivePath(type === "directory" && rawPath.endsWith("/") ? rawPath.slice(0, -1) : rawPath);
+    const key = process.platform === "win32" ? normalized.toLocaleLowerCase("en-US") : normalized;
+    if (seen.has(key)) throw new Error(`Tar archive contains duplicate path: ${normalized}`);
+    seen.add(key);
+    const paddedSize = Math.ceil(size / BLOCK_SIZE) * BLOCK_SIZE;
+    if (offset + paddedSize > bytes.length) throw new Error(`Tar entry is truncated: ${normalized}`);
+    entries.push({
+      path: normalized,
+      type,
+      data: type === "file" ? bytes.subarray(offset, offset + size) : Buffer.alloc(0)
+    });
+    offset += paddedSize;
+  }
+  if (zeroBlocks < 2) throw new Error("Tar archive is missing its end marker.");
+  return entries;
+}
+function isWithin5(parent, child) {
+  const relative = path14.relative(parent, child);
+  return relative === "" || !relative.startsWith(`..${path14.sep}`) && relative !== ".." && !path14.isAbsolute(relative);
+}
+async function extractTemplateArchive(options) {
+  const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+  const maxExpandedBytes = options.maxExpandedBytes ?? DEFAULT_MAX_EXPANDED_BYTES;
+  if (!Number.isSafeInteger(maxEntries) || maxEntries < 1) throw new Error("maxEntries must be a positive safe integer.");
+  if (!Number.isSafeInteger(maxExpandedBytes) || maxExpandedBytes < 1) throw new Error("maxExpandedBytes must be a positive safe integer.");
+  const archive = await readFile8(options.archivePath);
+  let tarBytes;
+  try {
+    tarBytes = archive.length >= 2 && archive[0] === 31 && archive[1] === 139 ? gunzipSync(archive, { maxOutputLength: maxExpandedBytes + maxEntries * BLOCK_SIZE * 2 }) : archive;
+  } catch (error) {
+    throw new Error("Unable to decompress template archive within the configured limit.", { cause: error });
+  }
+  const entries = parseTar(tarBytes);
+  if (entries.length > maxEntries) throw new Error(`Archive exceeds the ${maxEntries}-entry limit.`);
+  let expandedBytes = 0;
+  for (const entry of entries) {
+    expandedBytes += entry.data.byteLength;
+    if (expandedBytes > maxExpandedBytes) {
+      throw new Error(`Archive exceeds the ${maxExpandedBytes}-byte expanded-size limit.`);
+    }
+  }
+  const destination = path14.resolve(options.destination);
+  const parent = path14.dirname(destination);
+  await mkdir4(parent, { recursive: true });
+  const stage = path14.join(parent, `.appinit-extract-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}`);
+  if (!isWithin5(parent, stage) || stage === destination) throw new Error("Invalid extraction staging path.");
+  let files = 0;
+  let directories = 0;
+  try {
+    await mkdir4(stage, { recursive: false, mode: 448 });
+    for (const entry of entries) {
+      const target = path14.resolve(stage, ...entry.path.split("/"));
+      if (!isWithin5(stage, target) || target === stage) throw new Error("Archive entry escapes extraction directory.");
+      const relative = path14.relative(stage, target);
+      const segments = relative.split(path14.sep);
+      let current = stage;
+      for (const segment of segments.slice(0, -1)) {
+        current = path14.join(current, segment);
+        try {
+          const info = await lstat5(current);
+          if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Archive path traverses a non-directory entry.");
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+          await mkdir4(current, { mode: 448 });
+          directories++;
+        }
+      }
+      if (entry.type === "directory") {
+        try {
+          await mkdir4(target, { mode: 448 });
+          directories++;
+        } catch (error) {
+          if (error.code !== "EEXIST") throw error;
+          const info = await lstat5(target);
+          if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Archive directory conflicts with a file.");
+        }
+        continue;
+      }
+      const handle = await open(target, "wx", 384);
+      try {
+        await handle.writeFile(entry.data);
+      } finally {
+        await handle.close();
+      }
+      files++;
+    }
+    try {
+      await lstat5(destination);
+      throw new Error("Extraction destination already exists.");
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await rename4(stage, destination);
+    return Object.freeze({ destination, files, directories, expandedBytes });
+  } catch (error) {
+    await rm4(stage, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+// ../sdk/src/composition/resolve-composition.ts
+function stableUnique(values) {
+  return [...new Set(values)].sort((a, b) => a.localeCompare(b));
+}
+function addDiagnostic(diagnostics, diagnostic3) {
+  diagnostics.push(diagnostic3);
+}
+function topologicalOrder(ids, edges) {
+  const original = new Map(ids.map((id, index) => [id, index]));
+  const indegree = new Map(ids.map((id) => [id, 0]));
+  const outgoing = new Map(ids.map((id) => [id, /* @__PURE__ */ new Set()]));
+  for (const edge of edges) {
+    if (!outgoing.get(edge.to).has(edge.from)) {
+      outgoing.get(edge.to).add(edge.from);
+      indegree.set(edge.from, indegree.get(edge.from) + 1);
+    }
+  }
+  const queue = ids.filter((id) => indegree.get(id) === 0).sort((a, b) => original.get(a) - original.get(b));
+  const result = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    result.push(id);
+    for (const next of outgoing.get(id)) {
+      indegree.set(next, indegree.get(next) - 1);
+      if (indegree.get(next) === 0) {
+        queue.push(next);
+        queue.sort((a, b) => original.get(a) - original.get(b));
+      }
+    }
+  }
+  return result.length === ids.length ? result : void 0;
+}
+function resolveComposition(selected) {
+  const diagnostics = [];
+  const byId = /* @__PURE__ */ new Map();
+  for (const item of selected) {
+    const id = item.manifest.id;
+    if (byId.has(id)) {
+      addDiagnostic(diagnostics, {
+        code: "COMPOSITION_DUPLICATE_TEMPLATE",
+        severity: "error",
+        message: `Template ID "${id}" is selected more than once.`,
+        templateIds: [id]
+      });
+    } else {
+      byId.set(id, item);
+    }
+  }
+  if (diagnostics.some((d) => d.severity === "error")) {
+    return { diagnostics: Object.freeze(diagnostics) };
+  }
+  const templates = [...byId.values()];
+  const projectTemplates = templates.filter((item) => item.manifest.kind === "project");
+  if (projectTemplates.length > 1) {
+    addDiagnostic(diagnostics, {
+      code: "COMPOSITION_MULTIPLE_PROJECTS",
+      severity: "error",
+      message: "A composition may contain at most one project template.",
+      templateIds: projectTemplates.map((item) => item.manifest.id).sort()
+    });
+  }
+  const providers = /* @__PURE__ */ new Map();
+  for (const item of templates) {
+    for (const capability of stableUnique(item.manifest.provides ?? [])) {
+      const list = providers.get(capability) ?? [];
+      list.push(item.manifest.id);
+      providers.set(capability, list);
+    }
+  }
+  for (const list of providers.values()) list.sort((a, b) => a.localeCompare(b));
+  const edges = [];
+  for (const item of templates) {
+    const consumer = item.manifest.id;
+    for (const requirement of stableUnique(item.manifest.requires ?? [])) {
+      const matches = providers.get(requirement) ?? [];
+      if (matches.length === 0) {
+        addDiagnostic(diagnostics, {
+          code: "COMPOSITION_MISSING_PROVIDER",
+          severity: "error",
+          message: `Template "${consumer}" requires "${requirement}", but no selected template provides it.`,
+          templateIds: [consumer],
+          requirement
+        });
+      } else if (matches.length > 1) {
+        addDiagnostic(diagnostics, {
+          code: "COMPOSITION_AMBIGUOUS_PROVIDER",
+          severity: "error",
+          message: `Requirement "${requirement}" for "${consumer}" has multiple providers: ${matches.join(", ")}.`,
+          templateIds: [consumer, ...matches],
+          requirement
+        });
+      } else if (matches[0] === consumer) {
+        addDiagnostic(diagnostics, {
+          code: "COMPOSITION_CYCLE",
+          severity: "error",
+          message: `Template "${consumer}" cannot satisfy its own requirement "${requirement}".`,
+          templateIds: [consumer],
+          requirement
+        });
+      } else {
+        edges.push({ from: consumer, to: matches[0], requirement });
+      }
+    }
+  }
+  const selectedIds = new Set(byId.keys());
+  const providedCapabilities = /* @__PURE__ */ new Map();
+  for (const item of templates) {
+    for (const capability of item.manifest.provides ?? []) {
+      const owners = providedCapabilities.get(capability) ?? [];
+      owners.push(item.manifest.id);
+      providedCapabilities.set(capability, owners);
+    }
+  }
+  const reportedConflicts = /* @__PURE__ */ new Set();
+  for (const item of templates) {
+    const id = item.manifest.id;
+    for (const conflict of stableUnique(item.manifest.conflicts ?? [])) {
+      const targets = selectedIds.has(conflict) ? [conflict] : providedCapabilities.get(conflict) ?? [];
+      for (const target of targets) {
+        if (target === id) continue;
+        const pair = [id, target].sort();
+        const pairKey = pair.join("\\0");
+        if (reportedConflicts.has(pairKey)) continue;
+        reportedConflicts.add(pairKey);
+        addDiagnostic(diagnostics, {
+          code: "COMPOSITION_CONFLICT",
+          severity: "error",
+          message: `Template "${id}" conflicts with selected template "${target}" (declaration: "${conflict}").`,
+          templateIds: pair,
+          requirement: conflict
+        });
+      }
+    }
+  }
+  if (diagnostics.some((d) => d.severity === "error")) {
+    return { diagnostics: Object.freeze(diagnostics) };
+  }
+  const ids = [...byId.keys()];
+  const ordered = topologicalOrder(ids, edges);
+  if (!ordered) {
+    addDiagnostic(diagnostics, {
+      code: "COMPOSITION_CYCLE",
+      severity: "error",
+      message: "Selected templates contain a dependency cycle.",
+      templateIds: [...ids].sort()
+    });
+    return { diagnostics: Object.freeze(diagnostics) };
+  }
+  const manifestById = /* @__PURE__ */ new Map();
+  for (const [id, item] of byId) manifestById.set(id, item.manifest);
+  const plan = Object.freeze({
+    orderedTemplateIds: Object.freeze(ordered),
+    templates: Object.freeze(ordered.map((id) => manifestById.get(id))),
+    edges: Object.freeze(edges.sort(
+      (a, b) => a.from.localeCompare(b.from) || a.to.localeCompare(b.to) || a.requirement.localeCompare(b.requirement)
+    ))
+  });
+  return { plan, diagnostics: Object.freeze(diagnostics) };
+}
+
+// ../sdk/src/execution/plan-file-operations.ts
+function cloneContent(content) {
+  return typeof content === "string" ? content : Buffer.from(content);
+}
+function planFileOperations(templates, mode = "strict") {
+  const composition = resolveComposition(templates.map((template) => ({
+    manifest: template.manifest,
+    source: template.root
+  })));
+  const diagnostics = composition.diagnostics.map((diagnostic3) => ({
+    code: diagnostic3.code,
+    severity: "error",
+    message: diagnostic3.message,
+    templateIds: diagnostic3.templateIds
+  }));
+  if (!composition.plan) {
+    return { diagnostics: Object.freeze(diagnostics) };
+  }
+  const byId = new Map(templates.map((template) => [template.manifest.id, template]));
+  const operations = [];
+  const operationByPath = /* @__PURE__ */ new Map();
+  for (const templateId of composition.plan.orderedTemplateIds) {
+    const template = byId.get(templateId);
+    for (const file of template.vfs.list()) {
+      let destination;
+      try {
+        destination = normalizeVfsDestination(file.dest);
+      } catch (error) {
+        diagnostics.push({
+          code: "FILE_PATH_INVALID",
+          severity: "error",
+          message: `Template "${templateId}" contains an invalid output path "${file.dest}": ${error instanceof Error ? error.message : String(error)}`,
+          destination: file.dest,
+          templateIds: [templateId]
+        });
+        continue;
+      }
+      const existingIndex = operationByPath.get(destination);
+      if (existingIndex === void 0) {
+        operationByPath.set(destination, operations.length);
+        operations.push(Object.freeze({
+          kind: "create",
+          destination,
+          sourceTemplateId: templateId,
+          content: cloneContent(file.content),
+          render: file.render,
+          binary: file.binary,
+          replaces: Object.freeze([])
+        }));
+        continue;
+      }
+      const previous = operations[existingIndex];
+      const involved = [previous.sourceTemplateId, templateId];
+      if (mode === "strict") {
+        diagnostics.push({
+          code: "FILE_CONFLICT",
+          severity: "error",
+          message: `Multiple templates produce "${destination}": ${involved.join(", ")}.`,
+          destination,
+          templateIds: Object.freeze(involved)
+        });
+        continue;
+      }
+      diagnostics.push({
+        code: "FILE_CONFLICT",
+        severity: "warning",
+        message: `Template "${templateId}" overlays "${destination}" from "${previous.sourceTemplateId}".`,
+        destination,
+        templateIds: Object.freeze(involved)
+      });
+      operations[existingIndex] = Object.freeze({
+        kind: "overwrite",
+        destination,
+        sourceTemplateId: templateId,
+        content: cloneContent(file.content),
+        render: file.render,
+        binary: file.binary,
+        replaces: Object.freeze([...previous.replaces, previous.sourceTemplateId])
+      });
+    }
+  }
+  if (diagnostics.some((diagnostic3) => diagnostic3.severity === "error")) {
+    return { diagnostics: Object.freeze(diagnostics) };
+  }
+  const orderedTemplates = composition.plan.orderedTemplateIds.map((id) => byId.get(id));
+  const plan = Object.freeze({
+    mode,
+    orderedTemplateIds: Object.freeze([...composition.plan.orderedTemplateIds]),
+    operations: Object.freeze(operations),
+    templates: Object.freeze(orderedTemplates)
+  });
+  return { plan, diagnostics: Object.freeze(diagnostics) };
+}
+
+// ../sdk/src/execution/execute-file-plan.ts
+async function executeFilePlan(plan, targetDirectory, options = {}) {
+  return executeFileOperations(
+    targetDirectory,
+    plan.operations.map((operation) => ({
+      destination: operation.destination,
+      content: operation.content,
+      binary: operation.binary,
+      sourceTemplateId: operation.sourceTemplateId
+    })),
+    options
+  );
+}
+
+// ../sdk/src/execution/render-file-operation-plan.ts
+async function renderFileOperationPlan(plan, variablesByTemplate = /* @__PURE__ */ new Map(), schemasByTemplate = /* @__PURE__ */ new Map()) {
+  const diagnostics = [];
+  const templates = new Map(plan.templates.map((template) => [template.manifest.id, template]));
+  const validatedVariables = /* @__PURE__ */ new Map();
+  for (const template of plan.templates) {
+    const id = template.manifest.id;
+    const variables = variablesByTemplate.get(id) ?? {};
+    const validation = validateTemplateVariables(variables, schemasByTemplate.get(id));
+    if (!validation.valid) {
+      for (const message of validation.errors) {
+        diagnostics.push({ code: "RENDER_INVALID_VARIABLES", templateId: id, message });
+      }
+    } else {
+      validatedVariables.set(id, variables);
+    }
+  }
+  if (diagnostics.length > 0) {
+    return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
+  }
+  const operations = [];
+  for (const operation of plan.operations) {
+    const template = templates.get(operation.sourceTemplateId);
+    if (!template) {
+      diagnostics.push({
+        code: "RENDER_FILE_FAILED",
+        templateId: operation.sourceTemplateId,
+        destination: operation.destination,
+        message: "File operation refers to a template that is not in the composition plan."
+      });
+      continue;
+    }
+    try {
+      const rendered = await renderFile({
+        file: {
+          dest: operation.destination,
+          content: operation.content,
+          render: operation.render,
+          binary: operation.binary
+        },
+        engine: template.manifest.renderer.engine,
+        variables: validatedVariables.get(operation.sourceTemplateId) ?? {}
+      });
+      operations.push(Object.freeze({ ...operation, content: rendered.content, render: false }));
+    } catch (error) {
+      diagnostics.push({
+        code: "RENDER_FILE_FAILED",
+        templateId: operation.sourceTemplateId,
+        destination: operation.destination,
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  if (diagnostics.length > 0) {
+    return Object.freeze({ ok: false, diagnostics: Object.freeze(diagnostics) });
+  }
+  return Object.freeze({
+    ok: true,
+    plan: Object.freeze({
+      sourcePlan: plan,
+      operations: Object.freeze(operations)
+    }),
+    diagnostics: Object.freeze([])
+  });
+}
+
+// src/template-path.ts
+import { existsSync } from "fs";
+import path15 from "path";
+import { fileURLToPath } from "url";
+function resolveTemplateDirectory(override) {
+  if (override) return path15.resolve(override);
+  if (process.env.APPINIT_TEMPLATES_DIR) {
+    return path15.resolve(process.env.APPINIT_TEMPLATES_DIR);
+  }
+  const workingDirectoryTemplates = path15.resolve(process.cwd(), "templates");
+  if (existsSync(workingDirectoryTemplates)) return workingDirectoryTemplates;
+  return path15.join(path15.dirname(fileURLToPath(import.meta.url)), "templates");
+}
+
+// src/create.ts
+async function discoverApprovedRoots(directory) {
+  const canonicalRoot = await realpath7(path16.resolve(directory));
+  const entries = await readdir4(canonicalRoot, { withFileTypes: true });
+  const roots = /* @__PURE__ */ new Map();
+  for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    if (!entry.isDirectory()) continue;
+    const templateRoot = path16.join(canonicalRoot, entry.name);
+    let manifestValue;
+    try {
+      manifestValue = JSON.parse(await readFile9(path16.join(templateRoot, "appinit.template.json"), "utf8"));
+    } catch {
+      continue;
+    }
+    if (manifestValue === null || typeof manifestValue !== "object" || Array.isArray(manifestValue)) continue;
+    const manifest = manifestValue;
+    const aliases = [entry.name, manifest.id, manifest.packageName].filter((value) => typeof value === "string" && value.trim().length > 0);
+    for (const alias of aliases) {
+      const existing = roots.get(alias);
+      if (existing && existing !== templateRoot) throw new Error(`Template reference "${alias}" is ambiguous in ${canonicalRoot}.`);
+      roots.set(alias, templateRoot);
+    }
+  }
+  return roots;
+}
+async function discoverLocalTemplates(directory) {
+  const roots = await discoverApprovedRoots(directory);
+  const uniqueRoots = [...new Set(roots.values())].sort();
+  const templates = [];
+  for (const root of uniqueRoots) {
+    const manifest = JSON.parse(await readFile9(path16.join(root, "appinit.template.json"), "utf8"));
+    if (typeof manifest.id !== "string") continue;
+    try {
+      const discovered = await discoverTemplate(manifest.id, { templateRoots: roots });
+      templates.push(Object.freeze({
+        id: discovered.template.manifest.id,
+        name: discovered.template.manifest.name,
+        description: discovered.template.manifest.description,
+        category: discovered.template.manifest.category,
+        root,
+        template: discovered.template
+      }));
+    } catch {
+    }
+  }
+  return Object.freeze(templates);
+}
+async function assertSafeTarget(target) {
+  const absolute = path16.resolve(target);
+  try {
+    const info = await lstat6(absolute);
+    if (info.isSymbolicLink() || !info.isDirectory()) throw new Error("Target must be a real directory, not a symlink or file.");
+    if ((await readdir4(absolute)).length > 0) throw new Error(`Target directory is not empty: ${absolute}. Choose an empty or new directory.`);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return absolute;
+}
+async function recordProjectHistory(targetDirectory, templateId) {
+  const homeDirectory = resolveAppInitHome();
+  const existing = await readAppInitJson(homeDirectory, "state.json");
+  let state;
+  if (existing === void 0) {
+    state = { schemaVersion: 1, projects: [] };
+  } else {
+    const validation = validateAppInitState(existing);
+    if (!validation.valid || !validation.state) {
+      throw new Error(`Existing global state is invalid: ${validation.errors.join(" ")}`);
+    }
+    state = validation.state;
+  }
+  const projectPath = path16.resolve(targetDirectory);
+  const projects = state.projects.filter((project) => project.path !== projectPath);
+  projects.push({
+    path: projectPath,
+    templateId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await writeAppInitJson(homeDirectory, "state.json", {
+    ...state,
+    schemaVersion: 1,
+    projects
+  });
+}
+async function runCreateCommand(options) {
+  const targetDirectory = await assertSafeTarget(options.target);
+  const templateDirectory = resolveTemplateDirectory(options.templateDirectory);
+  const intent = {
+    executionKind: "scaffold",
+    executionMode: "user",
+    artifactKind: "project",
+    rootDir: process.cwd(),
+    targetDir: targetDirectory,
+    templateRef: options.template,
+    variables: { ...options.variables },
+    flags: { dryRun: options.dryRun }
+  };
+  const validation = validateExecutionIntent(intent);
+  if (!validation.ok) throw new Error(validation.diagnostics.map((item) => item.message).join("\n"));
+  const roots = await discoverApprovedRoots(templateDirectory);
+  const approvedRoot = roots.get(options.template);
+  if (!approvedRoot) throw new Error(`Template "${options.template}" is not present in the approved template roots.`);
+  const approvedManifest = JSON.parse(await readFile9(path16.join(approvedRoot, "appinit.template.json"), "utf8"));
+  if (typeof approvedManifest.id !== "string") throw new Error(`Template "${options.template}" has an invalid manifest identity.`);
+  const discovered = await discoverTemplate(approvedManifest.id, { templateRoots: roots });
+  const metadata = await loadTemplateVariables(discovered.template.root, discovered.template.manifest);
+  const variables = { ...metadata.defaults, ...options.variables };
+  const variableErrors = validateTemplateVariables2(variables, metadata.schema);
+  if (variableErrors.length) throw new Error(`Template variables are invalid:
+${variableErrors.map((item) => `  - ${item}`).join("\n")}`);
+  const planning = planFileOperations([discovered.template], "strict");
+  if (!planning.plan) throw new Error(`Composition planning failed:
+${planning.diagnostics.map((item) => item.message).join("\n")}`);
+  const schema = {};
+  for (const [key, rule] of Object.entries(metadata.schema)) {
+    if (rule.type) schema[key] = { type: rule.type, ...rule.required !== void 0 ? { required: rule.required } : {}, ...rule.minLength !== void 0 ? { minLength: rule.minLength } : {}, ...rule.enum ? { enum: rule.enum } : {} };
+  }
+  const templateId = discovered.template.manifest.id;
+  const rendered = await renderFileOperationPlan(
+    planning.plan,
+    /* @__PURE__ */ new Map([[templateId, variables]]),
+    /* @__PURE__ */ new Map([[templateId, schema]])
+  );
+  if (!rendered.ok || !rendered.plan) throw new Error(`Template rendering failed:
+${rendered.diagnostics.map((item) => item.message).join("\n")}`);
+  const executablePlan = { ...rendered.plan.sourcePlan, operations: rendered.plan.operations };
+  const execution = await executeFilePlan(executablePlan, targetDirectory, { dryRun: options.dryRun });
+  if (!execution.ok) throw new Error(`File execution failed:
+${execution.diagnostics.map((item) => item.message).join("\n")}`);
+  if (options.dryRun) {
+    process.stdout.write(`Dry run successful. ${execution.writtenFiles.length} file(s) would be created in ${targetDirectory}.
+`);
+    for (const destination of execution.writtenFiles) process.stdout.write(`  + ${destination}
+`);
+    return;
+  }
+  const operations = rendered.plan.operations.map((operation) => ({
+    destination: operation.destination,
+    content: operation.content,
+    binary: operation.binary,
+    sourceTemplateId: operation.sourceTemplateId
+  }));
+  const verification = await verifyGeneratedOutput(targetDirectory, operations);
+  if (!verification.ok) throw new Error(`Output was written, but verification failed. Review ${targetDirectory}:
+${verification.diagnostics.map((item) => item.message).join("\n")}`);
+  try {
+    await recordProjectHistory(targetDirectory, templateId);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Warning: project was created, but global history could not be updated: ${message}
+`);
+  }
+  process.stdout.write(`Created ${discovered.template.manifest.name} in ${targetDirectory}.
+`);
+  process.stdout.write(`Verified ${verification.actualFiles.length} generated file(s).
+`);
+}
+
+// src/finalize-project.ts
+import { access as access2, readFile as readFile11 } from "fs/promises";
+import path18 from "path";
+
+// src/finalize.ts
+import { access, readFile as readFile10 } from "fs/promises";
+import { spawn } from "child_process";
+import path17 from "path";
+var LOCKFILES = Object.freeze({
+  "pnpm-lock.yaml": "pnpm",
+  "package-lock.json": "npm",
+  "yarn.lock": "yarn",
+  "bun.lock": "bun",
+  "bun.lockb": "bun"
+});
+async function detectPackageManager(directory) {
+  try {
+    const manifest = JSON.parse(await readFile10(path17.join(directory, "package.json"), "utf8"));
+    if (typeof manifest.packageManager === "string") {
+      const declared = /^(pnpm|npm|yarn|bun)@/.exec(manifest.packageManager)?.[1];
+      if (declared) return declared;
+    }
+  } catch {
+  }
+  const detected = /* @__PURE__ */ new Set();
+  for (const [lockfile, manager] of Object.entries(LOCKFILES)) {
+    try {
+      await access(path17.join(directory, lockfile));
+      detected.add(manager);
+    } catch {
+    }
+  }
+  if (detected.size === 1) return detected.values().next().value;
+  if (detected.size > 1) return void 0;
+  const agent = process.env.npm_config_user_agent ?? "";
+  const match = /^(pnpm|npm|yarn|bun)\//.exec(agent);
+  return match?.[1];
+}
+async function isNestedInPnpmWorkspace(directory) {
+  let current = path17.dirname(path17.resolve(directory));
+  const root = path17.parse(current).root;
+  while (true) {
+    try {
+      await access(path17.join(current, "pnpm-workspace.yaml"));
+      return true;
+    } catch {
+      if (current === root) return false;
+      current = path17.dirname(current);
+    }
+  }
+}
+async function runSetupCommand(command, directory, packageManager) {
+  const executable = command === "git-init" ? "git" : packageManager;
+  if (!executable) throw new Error("A package manager must be selected before installing dependencies.");
+  const args = command === "git-init" ? ["init"] : ["install"];
+  if (command === "install" && packageManager === "pnpm" && await isNestedInPnpmWorkspace(directory)) {
+    args.push("--ignore-workspace");
+  }
+  await new Promise((resolve, reject) => {
+    const child = spawn(executable, args, {
+      cwd: directory,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.once("error", (error) => reject(new Error(`Could not start ${executable}: ${error.message}`)));
+    child.once("close", (code, signal) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${executable} ${args.join(" ")} failed${signal ? ` (signal ${signal})` : ` with exit code ${String(code)}`}.`));
+    });
+  });
+}
+
+// src/finalize-project.ts
+async function isInsideGitRepository(directory) {
+  let current = path18.resolve(directory);
+  const root = path18.parse(current).root;
+  while (true) {
+    try {
+      await access2(path18.join(current, ".git"));
+      return true;
+    } catch {
+      if (current === root) return false;
+      current = path18.dirname(current);
+    }
+  }
+}
+async function getDevScript(directory) {
+  try {
+    const manifest = JSON.parse(await readFile11(path18.join(directory, "package.json"), "utf8"));
+    return typeof manifest.scripts?.dev === "string" ? manifest.scripts.dev : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isPackageManager(value) {
+  return value === "pnpm" || value === "npm" || value === "yarn" || value === "bun";
+}
+async function finalizeProject(directory, options, io) {
+  let install = options.install;
+  let git = options.git;
+  const failures = [];
+  if (io.interactive) {
+    if (!install) install = await io.confirm("Install project dependencies now?");
+    if (!git) git = await io.confirm("Initialize a Git repository?");
+  }
+  let manager = options.packageManager ?? await detectPackageManager(directory);
+  if (install && !manager && io.interactive) {
+    const answer = (await io.ask("Package manager (pnpm/npm/yarn/bun)", "pnpm")).toLowerCase();
+    if (!isPackageManager(answer)) throw new Error(`Unsupported package manager "${answer}". Choose pnpm, npm, yarn, or bun.`);
+    manager = answer;
+  }
+  if (install) {
+    if (!manager) {
+      const message = "No package manager detected. Re-run with --package-manager <pnpm|npm|yarn|bun> --install.";
+      failures.push(message);
+      io.write(`Dependencies were not installed: ${message}
+`);
+    } else {
+      io.write(`Installing dependencies with ${manager}...
+`);
+      try {
+        await runSetupCommand("install", directory, manager);
+        io.write("Dependencies installed successfully.\n");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push(message);
+        io.write(`Dependency installation failed; generated files were preserved. ${message}
+`);
+        io.write(`Recovery: cd "${directory}" && ${manager} install
+`);
+      }
+    }
+  }
+  if (git) {
+    if (await isInsideGitRepository(directory)) {
+      io.write("Skipped Git initialization: this project is already inside a Git repository.\n");
+    } else {
+      try {
+        await runSetupCommand("git-init", directory);
+        io.write("Git repository initialized.\n");
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push(message);
+        io.write(`Git initialization failed; generated files were preserved. ${message}
+`);
+        io.write(`Recovery: cd "${directory}" && git init
+`);
+      }
+    }
+  }
+  io.write("\nNext steps:\n");
+  io.write(`  cd "${directory}"
+`);
+  if (install && manager && failures.length === 0) {
+    const devScript = await getDevScript(directory);
+    if (devScript) {
+      const run = manager === "npm" ? "npm run dev" : manager === "bun" ? "bun run dev" : `${manager} dev`;
+      io.write(`  ${run}
+`);
+    } else {
+      io.write("  Review the generated README for available scripts.\n");
+    }
+  } else {
+    io.write(`  ${manager ? manager + " install" : "Install dependencies with your package manager"}
+`);
+  }
+  if (failures.length) {
+    throw new Error(`Project files were created, but one or more setup steps failed: ${failures.join("; ")}`);
+  }
+}
+
+// src/doctor.ts
+import path22 from "path";
+
+// ../guard/src/doctor/providers.ts
+import { readdir as readdir5, readFile as readFile12 } from "fs/promises";
+import path19 from "path";
+var IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules", ".pnpm", "dist"]);
+async function walk(root, current, files) {
+  let entries;
+  try {
+    entries = await readdir5(current, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    const absolute = path19.join(current, entry.name);
+    const relative = path19.relative(root, absolute).split(path19.sep).join("/");
+    files.add(relative);
+    if (entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)) {
+      await walk(root, absolute, files);
+    }
+  }
+}
+async function readJson(filePath) {
+  try {
+    const value = JSON.parse(await readFile12(filePath, "utf8"));
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function collectDoctorSnapshot(rootDir) {
+  const root = path19.resolve(rootDir);
+  const files = /* @__PURE__ */ new Set();
+  await walk(root, root, files);
+  const packageJson = await readJson(path19.join(root, "package.json"));
+  const appinitContext = await readJson(path19.join(root, ".appinit", "context.json"));
+  const declaration = packageJson?.packageManager;
+  const declaredManager = typeof declaration === "string" ? /^(pnpm|npm|yarn|bun)@/.exec(declaration)?.[1] : void 0;
+  const lockfileManager = files.has("pnpm-lock.yaml") ? "pnpm" : files.has("package-lock.json") ? "npm" : files.has("yarn.lock") ? "yarn" : files.has("bun.lock") || files.has("bun.lockb") ? "bun" : void 0;
+  const intent = {
+    artifactKind: appinitContext?.artifactKind === "template" || appinitContext?.artifactKind === "package" ? appinitContext.artifactKind : "project",
+    atsVersion: typeof appinitContext?.atsVersion === "string" ? appinitContext.atsVersion : void 0,
+    runtime: appinitContext?.runtime === "node" || appinitContext?.runtime === "bun" || appinitContext?.runtime === "deno" ? appinitContext.runtime : void 0,
+    framework: typeof appinitContext?.framework === "string" ? appinitContext.framework : void 0
+  };
+  const dependencies = {
+    ...packageJson?.dependencies && typeof packageJson.dependencies === "object" ? packageJson.dependencies : {},
+    ...packageJson?.devDependencies && typeof packageJson.devDependencies === "object" ? packageJson.devDependencies : {}
+  };
+  return Object.freeze({
+    files,
+    dependencies: Object.freeze(dependencies),
+    packageManager: lockfileManager ?? declaredManager,
+    intent: Object.freeze(intent)
+  });
+}
+
+// ../guard/src/doctor/rules.ts
+function diagnostic(code, level, subsystem, message, hint) {
+  return { code, level, subsystem, message, hint, ruleId: code };
+}
+var builtInDoctorRules = Object.freeze([
+  {
+    id: "project.package-manager-lock",
+    run: ({ snapshot }) => {
+      const lockfiles = ["pnpm-lock.yaml", "package-lock.json", "yarn.lock", "bun.lock", "bun.lockb"].filter((file) => snapshot.files.has(file));
+      return lockfiles.length > 1 ? [
+        diagnostic(
+          "DOCTOR_MULTIPLE_LOCKFILES",
+          "warn",
+          "compatibility",
+          `Multiple package-manager lockfiles were found: ${lockfiles.join(", ")}.`,
+          "Keep the lockfile for the package manager used by this project."
+        )
+      ] : [];
+    }
+  },
+  {
+    id: "project.runtime-config",
+    run: ({ snapshot }) => {
+      const runtime = snapshot.intent.runtime;
+      if (runtime === "node" && !snapshot.files.has("package.json")) {
+        return [diagnostic(
+          "DOCTOR_NODE_PACKAGE_JSON_MISSING",
+          "warn",
+          "runtime",
+          "Node.js runtime is declared, but no package.json was found.",
+          "Add a package.json or update .appinit/context.json."
+        )];
+      }
+      if (runtime === "deno" && !snapshot.files.has("deno.json") && !snapshot.files.has("deno.jsonc")) {
+        return [diagnostic(
+          "DOCTOR_DENO_CONFIG_MISSING",
+          "warn",
+          "runtime",
+          "Deno runtime is declared, but no deno.json or deno.jsonc was found.",
+          "Add a Deno configuration file or update .appinit/context.json."
+        )];
+      }
+      if (runtime === "bun" && !snapshot.files.has("bun.lock") && !snapshot.files.has("bun.lockb")) {
+        return [diagnostic(
+          "DOCTOR_BUN_LOCK_MISSING",
+          "info",
+          "runtime",
+          "Bun runtime is declared, but no Bun lockfile was found.",
+          "Generate a Bun lockfile if this project uses Bun for dependency management."
+        )];
+      }
+      return [];
+    }
+  }
+]);
+function runDoctorRules(context, rules = builtInDoctorRules) {
+  const results = [];
+  for (const rule of rules) {
+    try {
+      results.push(...rule.run(context));
+    } catch (error) {
+      results.push(diagnostic(
+        "DOCTOR_RULE_FAILED",
+        "warn",
+        "doctor",
+        `Doctor rule "${rule.id}" could not complete: ${error instanceof Error ? error.message : String(error)}`
+      ));
+    }
+  }
+  return results;
+}
+
+// ../guard/src/doctor/doctor.ts
+import path20 from "path";
+var Doctor = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  async diagnose() {
+    const rootDir = path20.resolve(this.options.rootDir ?? process.cwd());
+    const snapshot = await collectDoctorSnapshot(rootDir);
+    const diagnostics = runDoctorRules({ rootDir, snapshot }, this.options.rules);
+    const summary = { info: 0, warn: 0, error: 0, fatal: 0 };
+    for (const item of diagnostics) summary[item.level] += 1;
+    return Object.freeze({
+      rootDir,
+      diagnostics: Object.freeze([...diagnostics]),
+      summary: Object.freeze(summary),
+      ok: diagnostics.every((item) => item.level !== "error" && item.level !== "fatal")
+    });
+  }
+};
+
+// ../guard/src/validation/validator.ts
+import path21 from "path";
+function createReport(rootDir, diagnostics) {
+  return Object.freeze({
+    rootDir,
+    diagnostics: Object.freeze([...diagnostics]),
+    hasErrors: diagnostics.some((item) => item.level === "error" || item.level === "fatal"),
+    hasWarnings: diagnostics.some((item) => item.level === "warn"),
+    hasAdvisories: diagnostics.some((item) => item.level === "info"),
+    ok: diagnostics.every((item) => item.level !== "error" && item.level !== "fatal")
+  });
+}
+async function validateProject(options = {}) {
+  const rootDir = path21.resolve(options.rootDir ?? process.cwd());
+  const snapshot = await collectDoctorSnapshot(rootDir);
+  const diagnostics = [];
+  if (snapshot.intent.runtime === "node" && !snapshot.files.has("package.json")) {
+    diagnostics.push({
+      code: "VALIDATION_NODE_PACKAGE_JSON_MISSING",
+      level: "error",
+      subsystem: "validation",
+      ruleId: "project.node-package-json",
+      filePath: "package.json",
+      message: "The project declares the Node.js runtime but package.json is missing.",
+      hint: "Add package.json or correct the runtime declaration in .appinit/context.json."
+    });
+  }
+  if (snapshot.intent.runtime === "deno" && !snapshot.files.has("deno.json") && !snapshot.files.has("deno.jsonc")) {
+    diagnostics.push({
+      code: "VALIDATION_DENO_CONFIG_MISSING",
+      level: "error",
+      subsystem: "validation",
+      ruleId: "project.deno-config",
+      message: "The project declares the Deno runtime but no Deno configuration file was found.",
+      hint: "Add deno.json or deno.jsonc, or correct the runtime declaration."
+    });
+  }
+  return createReport(rootDir, diagnostics);
+}
+async function validateTemplate(options) {
+  const rootDir = path21.resolve(options.templateDir);
+  const diagnostics = [];
+  try {
+    await resolveTemplate(rootDir);
+  } catch (error) {
+    diagnostics.push({
+      code: "VALIDATION_TEMPLATE_INVALID",
+      level: "error",
+      subsystem: "template",
+      ruleId: "template.resolve",
+      filePath: "appinit.template.json",
+      message: error instanceof Error ? error.message : String(error),
+      hint: "Check the template manifest and ensure its declared template directory exists within the template root."
+    });
+  }
+  return createReport(rootDir, diagnostics);
+}
+
+// src/doctor.ts
+async function runDoctorCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const report = await new Doctor({ rootDir: path22.resolve(options.cwd ?? process.cwd()) }).diagnose();
+  if (options.json) {
+    io.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  io.write("AppInit Doctor\n\n");
+  if (!report.diagnostics.length) io.write("  \u2713 No project issues detected.\n");
+  for (const item of report.diagnostics) {
+    const marker = item.level === "info" ? "i" : item.level === "warn" ? "!" : "\u2717";
+    io.write(`  ${marker} [${item.level.toUpperCase()}] ${item.code}: ${item.message}
+`);
+    if (item.hint) io.write(`      Hint: ${item.hint}
+`);
+  }
+  io.write(`
+Summary: ${report.summary.info} info, ${report.summary.warn} warnings, ${report.summary.error} errors
+`);
+}
+
+// src/history.ts
+async function readProjectHistory() {
+  const value = await readAppInitJson(resolveAppInitHome(), "state.json");
+  if (value === void 0) return { schemaVersion: 1, projects: [] };
+  const validation = validateAppInitState(value);
+  if (!validation.valid || !validation.state) {
+    throw new Error(`Global AppInit history is invalid: ${validation.errors.join(" ")}`);
+  }
+  return validation.state;
+}
+async function runHistoryCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const state = await readProjectHistory();
+  const projects = [...state.projects].sort(
+    (left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt)
+  );
+  if (options.json) {
+    io.write(`${JSON.stringify({ schemaVersion: state.schemaVersion, projects }, null, 2)}
+`);
+    return;
+  }
+  if (projects.length === 0) {
+    io.write("No project history found. Create a project with `appinit create` to get started.\n");
+    return;
+  }
+  io.write(`AppInit Project History (${projects.length})
+
+`);
+  projects.forEach((project, index) => {
+    io.write(
+      `${index + 1}. ${project.templateId}
+   Path: ${project.path}
+   Created: ${project.createdAt}
+
+`
+    );
+  });
+}
+
+// src/state-path.ts
+import { stat as stat3 } from "fs/promises";
+async function inspectAppInitStatePath(options = {}) {
+  const env = options.env ?? process.env;
+  const resolvedPath = resolveAppInitHome({ env, homeDirectory: options.homeDirectory });
+  let exists2 = false;
+  let isDirectory = false;
+  try {
+    const details = await stat3(resolvedPath);
+    exists2 = true;
+    isDirectory = details.isDirectory();
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return Object.freeze({
+    path: resolvedPath,
+    source: env.APPINIT_HOME === void 0 ? "default" : "APPINIT_HOME",
+    exists: exists2,
+    isDirectory
+  });
+}
+async function runStatePathCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const info = await inspectAppInitStatePath(options);
+  io.write("AppInit Global State Path\n\n");
+  io.write(`Path: ${info.path}
+`);
+  io.write(`Source: ${info.source === "default" ? "default (~/.appinit)" : "APPINIT_HOME environment variable"}
+`);
+  if (!info.exists) {
+    io.write("Status: not created yet\n");
+  } else if (!info.isDirectory) {
+    io.write("Status: path exists but is not a directory\n");
+  } else {
+    io.write("Status: directory exists\n");
+  }
+}
+
+// src/state-inspect.ts
+async function inspectAppInitState(options = {}) {
+  const env = options.env ?? process.env;
+  const home = resolveAppInitHome({ env, homeDirectory: options.homeDirectory });
+  const diagnostics = [];
+  try {
+    const value = await readAppInitJson(home, "state.json");
+    if (value === void 0) {
+      diagnostics.push("Global state file has not been created yet.");
+      return Object.freeze({
+        path: home,
+        source: env.APPINIT_HOME === void 0 ? "default" : "APPINIT_HOME",
+        stateFile: "missing",
+        diagnostics: Object.freeze(diagnostics)
+      });
+    }
+    const validation = validateAppInitState(value);
+    if (!validation.valid || !validation.state) {
+      diagnostics.push(...validation.errors);
+      return Object.freeze({
+        path: home,
+        source: env.APPINIT_HOME === void 0 ? "default" : "APPINIT_HOME",
+        stateFile: "invalid",
+        diagnostics: Object.freeze(diagnostics)
+      });
+    }
+    return Object.freeze({
+      path: home,
+      source: env.APPINIT_HOME === void 0 ? "default" : "APPINIT_HOME",
+      stateFile: "valid",
+      schemaVersion: validation.state.schemaVersion,
+      projectCount: validation.state.projects.length,
+      diagnostics: Object.freeze(diagnostics)
+    });
+  } catch (error) {
+    diagnostics.push(error instanceof Error ? error.message : String(error));
+    return Object.freeze({
+      path: home,
+      source: env.APPINIT_HOME === void 0 ? "default" : "APPINIT_HOME",
+      stateFile: "invalid",
+      diagnostics: Object.freeze(diagnostics)
+    });
+  }
+}
+async function runStateInspectCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const report = await inspectAppInitState(options);
+  if (options.json) {
+    io.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  io.write("AppInit Global State Inspection\n\n");
+  io.write(`Path: ${report.path}
+`);
+  io.write(`Source: ${report.source === "default" ? "default (~/.appinit)" : "APPINIT_HOME environment variable"}
+`);
+  io.write(`State file: ${report.stateFile}
+`);
+  if (report.schemaVersion !== void 0) io.write(`Schema version: ${report.schemaVersion}
+`);
+  if (report.projectCount !== void 0) io.write(`Recorded projects: ${report.projectCount}
+`);
+  if (report.diagnostics.length) {
+    io.write("\nDiagnostics\n");
+    for (const diagnostic3 of report.diagnostics) io.write(`  ! ${diagnostic3}
+`);
+  }
+}
+
+// src/state-doctor.ts
+import { access as access3, stat as stat4 } from "fs/promises";
+import { constants } from "fs";
+import path23 from "path";
+function diagnostic2(code, level, message, hint) {
+  return Object.freeze({ code, level, message, ...hint ? { hint } : {} });
+}
+function isMissing(error) {
+  return error.code === "ENOENT";
+}
+async function diagnoseAppInitState(options = {}) {
+  const inspection = await inspectAppInitState(options);
+  const diagnostics = [];
+  const stateRoot = inspection.path;
+  let rootIsDirectory = false;
+  try {
+    const details = await stat4(stateRoot);
+    if (!details.isDirectory()) {
+      diagnostics.push(diagnostic2(
+        "APPINIT_STATE_HOME_NOT_DIRECTORY",
+        "error",
+        "The configured global state path exists but is not a directory.",
+        "Set APPINIT_HOME to a directory or remove the conflicting file."
+      ));
+    } else {
+      rootIsDirectory = true;
+      try {
+        await access3(stateRoot, constants.R_OK | constants.X_OK);
+      } catch {
+        diagnostics.push(diagnostic2(
+          "APPINIT_STATE_HOME_NOT_ACCESSIBLE",
+          "error",
+          "The global state directory is not readable or searchable by this process.",
+          "Check directory ownership and access permissions."
+        ));
+      }
+      if (process.platform !== "win32" && (details.mode & 63) !== 0) {
+        diagnostics.push(diagnostic2(
+          "APPINIT_STATE_HOME_PERMISSIONS_BROAD",
+          "warn",
+          "The global state directory grants permissions to group or other users.",
+          "Restrict the directory to the current user (typically mode 700)."
+        ));
+      }
+    }
+  } catch (error) {
+    if (isMissing(error)) {
+      diagnostics.push(diagnostic2(
+        "APPINIT_STATE_HOME_MISSING",
+        "warn",
+        "The global state directory has not been created yet.",
+        "This is normal before AppInit first stores global state."
+      ));
+    } else {
+      diagnostics.push(diagnostic2(
+        "APPINIT_STATE_HOME_UNAVAILABLE",
+        "error",
+        "The global state directory could not be inspected.",
+        "Check the configured path and filesystem permissions."
+      ));
+    }
+  }
+  if (inspection.stateFile === "missing") {
+    diagnostics.push(diagnostic2(
+      "APPINIT_STATE_FILE_MISSING",
+      "warn",
+      "The global state file has not been created yet.",
+      "AppInit will create it when a command first needs to persist global state."
+    ));
+  } else if (inspection.stateFile === "invalid") {
+    diagnostics.push(diagnostic2(
+      "APPINIT_STATE_FILE_INVALID",
+      "error",
+      inspection.diagnostics.join(" "),
+      "Back up the file before attempting any manual recovery; this command does not repair state."
+    ));
+  } else {
+    diagnostics.push(diagnostic2(
+      "APPINIT_STATE_FILE_VALID",
+      "info",
+      `Global state file is valid (schema version ${inspection.schemaVersion}; ${inspection.projectCount} recorded projects).`
+    ));
+    if (rootIsDirectory) {
+      const filePath = path23.join(stateRoot, "state.json");
+      try {
+        const details = await stat4(filePath);
+        await access3(filePath, constants.R_OK);
+        if (process.platform !== "win32" && (details.mode & 63) !== 0) {
+          diagnostics.push(diagnostic2(
+            "APPINIT_STATE_FILE_PERMISSIONS_BROAD",
+            "warn",
+            "The global state file grants permissions to group or other users.",
+            "Restrict the file to the current user (typically mode 600)."
+          ));
+        }
+      } catch {
+        diagnostics.push(diagnostic2(
+          "APPINIT_STATE_FILE_NOT_ACCESSIBLE",
+          "error",
+          "The global state file could not be inspected or read.",
+          "Check file ownership and access permissions."
+        ));
+      }
+    }
+  }
+  const summary = Object.freeze({
+    info: diagnostics.filter((item) => item.level === "info").length,
+    warn: diagnostics.filter((item) => item.level === "warn").length,
+    error: diagnostics.filter((item) => item.level === "error").length
+  });
+  return Object.freeze({
+    path: stateRoot,
+    source: inspection.source,
+    stateFile: inspection.stateFile,
+    ok: summary.error === 0,
+    diagnostics: Object.freeze(diagnostics),
+    summary
+  });
+}
+async function runStateDoctorCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const report = await diagnoseAppInitState(options);
+  if (options.json) {
+    io.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  io.write("AppInit Global State Doctor\n\n");
+  io.write(`Path: ${report.path}
+`);
+  io.write(`Source: ${report.source === "default" ? "default (~/.appinit)" : "APPINIT_HOME environment variable"}
+`);
+  for (const item of report.diagnostics) {
+    const marker = item.level === "info" ? "i" : item.level === "warn" ? "!" : "\u2717";
+    io.write(`  ${marker} [${item.level.toUpperCase()}] ${item.code}: ${item.message}
+`);
+    if (item.hint) io.write(`      Hint: ${item.hint}
+`);
+  }
+  io.write(`
+Summary: ${report.summary.info} info, ${report.summary.warn} warnings, ${report.summary.error} errors
+`);
+}
+
+// src/template-author.ts
+import { mkdir as mkdir5, writeFile as writeFile4 } from "fs/promises";
+import path24 from "path";
+function toSlug(value) {
+  return value.toLocaleLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function toDisplayName(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toLocaleUpperCase() + part.slice(1)).join(" ");
+}
+async function createTemplateScaffold(directory) {
+  const root = path24.resolve(directory);
+  const slug = toSlug(path24.basename(root));
+  if (!slug) throw new Error("Template directory name must contain letters or numbers.");
+  const name = toDisplayName(slug);
+  const id = `custom.template-${slug}`;
+  const manifest = {
+    schemaVersion: 1,
+    id,
+    version: "0.1.0",
+    kind: "project",
+    atsVersion: "2.0",
+    name,
+    description: "A reusable AppInit project template.",
+    category: "custom",
+    language: "typescript",
+    packageName: `@appinit/template-${slug}`,
+    renderer: { engine: "liquid" },
+    paths: { template: "template", variables: "variables" },
+    tags: ["custom", "typescript"]
+  };
+  await mkdir5(path24.dirname(root), { recursive: true });
+  await mkdir5(root);
+  await mkdir5(path24.join(root, "template"));
+  await mkdir5(path24.join(root, "variables"));
+  await Promise.all([
+    writeFile4(path24.join(root, "appinit.template.json"), `${JSON.stringify(manifest, null, 2)}
+`, { flag: "wx" }),
+    writeFile4(path24.join(root, "variables", "defaults.json"), `${JSON.stringify({ projectName: slug }, null, 2)}
+`, { flag: "wx" }),
+    writeFile4(path24.join(root, "variables", "schema.json"), `${JSON.stringify({
+      projectName: { type: "string", required: true, minLength: 1 }
+    }, null, 2)}
+`, { flag: "wx" }),
+    writeFile4(path24.join(root, "template", "README.md"), `# {{ projectName }}
+
+Generated from the ${name} AppInit template.
+`, { flag: "wx" }),
+    writeFile4(path24.join(root, "README.md"), `# ${name}
+
+AppInit template authoring scaffold.
+
+- Edit \`appinit.template.json\` to update template metadata.
+- Add generated files under \`template/\`.
+- Define variable defaults and rules under \`variables/\`.
+- Validate this directory with \`appinit validate --template .\`.
+
+Preview generation with \`appinit create <template-ref> <target> --dry-run\`.
+`, { flag: "wx" })
+  ]);
+  return Object.freeze({ root, id, name });
+}
+
+// src/template-commands.ts
+import path25 from "path";
+function searchLocalTemplates(templates, query) {
+  const terms = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  if (terms.length === 0) return templates;
+  return templates.filter((template) => {
+    const manifest = template.template.manifest;
+    const searchable = [
+      template.id,
+      template.name,
+      template.description,
+      template.category,
+      manifest.language,
+      ...manifest.tags
+    ].join(" ").toLocaleLowerCase();
+    return terms.every((term) => searchable.includes(term));
+  });
+}
+function findLocalTemplate(templates, reference) {
+  const normalized = reference.trim().toLocaleLowerCase();
+  return templates.find(
+    (template) => [
+      template.id,
+      template.name,
+      template.template.manifest.packageName,
+      path25.basename(template.root)
+    ].some((value) => value?.toLocaleLowerCase() === normalized)
+  );
+}
+function formatTemplate(template) {
+  const manifest = template.template.manifest;
+  return [
+    `  ${template.id}`,
+    `    ${template.name} \u2014 ${template.description}`,
+    `    ${template.category} \xB7 ${manifest.language} \xB7 v${manifest.version}`
+  ].join("\n");
+}
+function formatTemplateList(templates, heading = "Available local templates") {
+  if (templates.length === 0)
+    return "No local templates found. Check your templates directory.";
+  return [
+    `${heading} (${templates.length})`,
+    "",
+    ...templates.map(formatTemplate),
+    ""
+  ].join("\n");
+}
+function formatTemplateInfo(template) {
+  const manifest = template.template.manifest;
+  return [
+    template.name,
+    "",
+    `ID:          ${template.id}`,
+    `Version:     ${manifest.version}`,
+    `Category:    ${template.category}`,
+    `Language:    ${manifest.language}`,
+    `Description: ${template.description}`,
+    `Tags:        ${manifest.tags.join(", ") || "\u2014"}`,
+    `Directory:   ${template.root}`,
+    ""
+  ].join("\n");
+}
+
+// src/remote-template.ts
+import { mkdir as mkdir6, realpath as realpath8, rm as rm5 } from "fs/promises";
+import path26 from "path";
+function createClient(options) {
+  return new TemplateRegistryClient({
+    catalogUrl: options.registryUrl,
+    cacheDirectory: options.cacheDirectory ?? path26.join(resolveAppInitHome(), "registry-cache"),
+    ...options.fetch ? { fetch: options.fetch } : {}
+  });
+}
+async function listRemoteTemplates(options) {
+  const catalog = await createClient(options).fetchCatalog();
+  return Object.freeze(catalog.templates.map((entry) => Object.freeze({
+    id: entry.id,
+    version: entry.version,
+    name: entry.name,
+    description: entry.description,
+    category: entry.category,
+    language: entry.language,
+    tags: entry.tags
+  })));
+}
+async function installRemoteTemplate(options) {
+  const client = createClient(options);
+  const catalog = await client.fetchCatalog();
+  const candidates = catalog.templates.filter(
+    (entry2) => entry2.id === options.templateId && (!options.version || entry2.version === options.version)
+  );
+  if (candidates.length === 0) {
+    throw new Error(`Template "${options.templateId}"${options.version ? ` version "${options.version}"` : ""} was not found in the registry.`);
+  }
+  if (candidates.length !== 1) {
+    throw new Error(`Registry contains multiple versions for "${options.templateId}". Specify --version explicitly.`);
+  }
+  const entry = candidates[0];
+  const archive = await client.downloadTemplate(entry);
+  const templatesDirectory = path26.resolve(
+    options.templatesDirectory ?? path26.join(resolveAppInitHome(), "templates")
+  );
+  const destination = path26.join(templatesDirectory, entry.id, entry.version);
+  await mkdir6(templatesDirectory, { recursive: true });
+  let extractedDirectoryCreated = false;
+  try {
+    const extracted = await extractTemplateArchive({
+      archivePath: archive.path,
+      destination
+    });
+    extractedDirectoryCreated = true;
+    const template = await resolveTemplate(extracted.destination);
+    if (template.manifest.id !== entry.id || template.manifest.version !== entry.version) {
+      throw new Error(
+        `Downloaded manifest identity mismatch: expected ${entry.id}@${entry.version}, received ${template.manifest.id}@${template.manifest.version}.`
+      );
+    }
+    const canonical = await realpath8(extracted.destination);
+    return Object.freeze({
+      id: entry.id,
+      version: entry.version,
+      directory: canonical,
+      cached: archive.cached
+    });
+  } catch (error) {
+    if (extractedDirectoryCreated) {
+      await rm5(destination, { recursive: true, force: true });
+    }
+    throw error;
+  }
+}
+
+// src/template.ts
+function output(value, json) {
+  return json ? `${JSON.stringify(value, null, 2)}
+` : String(value);
+}
+function usage() {
+  return [
+    "Usage: appinit template <init|list|info|search|remote-list|install> [arguments] [options]",
+    "",
+    "Commands:",
+    "  init <directory>     Create a starter template authoring scaffold",
+    "  list                 List validated local templates",
+    "  info <template-ref>  Show details and variable configuration",
+    "  search <query>       Search local templates by name, ID, tags, and description",
+    "  remote-list          List templates from a remote registry",
+    "  install <template-id> Download, verify, and install a registry template",
+    "",
+    "Options:",
+    "  --json                 Print machine-readable JSON",
+    "  --template-dir <path>  Use a specific local template directory",
+    "  --registry-url <url>   HTTPS registry catalog URL (required for remote commands)",
+    "  --version <version>    Install this exact template version",
+    ""
+  ].join("\n");
+}
+function parseOptions(args) {
+  const positional = [];
+  let json = false;
+  let directory;
+  let registryUrl;
+  let version;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") json = true;
+    else if (arg === "--help" || arg === "-h") positional.push("help");
+    else if (arg === "--template-dir" || arg === "--registry-url" || arg === "--version") {
+      const value = args[++index];
+      if (!value || value.startsWith("--")) throw new Error(`${arg} requires a value.`);
+      if (arg === "--template-dir") directory = value;
+      else if (arg === "--registry-url") registryUrl = value;
+      else version = value;
+    } else if (arg.startsWith("-")) throw new Error(`Unknown template option: ${arg}`);
+    else positional.push(arg);
+  }
+  return {
+    positional,
+    json,
+    ...directory ? { directory } : {},
+    ...registryUrl ? { registryUrl } : {},
+    ...version ? { version } : {}
+  };
+}
+async function runTemplateCommand(args, options = {}) {
+  const write = options.write ?? ((message) => process.stdout.write(message));
+  const parsed = parseOptions(args);
+  const [subcommand, ...rest] = parsed.positional;
+  if (!subcommand || subcommand === "--help" || subcommand === "help") {
+    write(usage());
+    return;
+  }
+  if (!["init", "list", "info", "search", "remote-list", "install"].includes(subcommand)) {
+    throw new Error(`Unknown template command "${subcommand}". Run "appinit template --help".`);
+  }
+  if (subcommand === "remote-list" || subcommand === "install") {
+    if (!parsed.registryUrl) throw new Error(`${subcommand} requires --registry-url <https-url>.`);
+    if (parsed.directory) throw new Error(`${subcommand} does not use --template-dir.`);
+    if (subcommand === "remote-list") {
+      if (rest.length) throw new Error("template remote-list does not accept positional arguments.");
+      if (parsed.version) throw new Error("template remote-list does not accept --version.");
+      const entries = await listRemoteTemplates({ registryUrl: parsed.registryUrl });
+      if (parsed.json) write(output(entries, true));
+      else if (!entries.length) write("No remote templates found.\n");
+      else write(entries.map(
+        (item) => `${item.id}@${item.version}  ${item.name}
+  ${item.description}
+  ${item.category} \xB7 ${item.language} \xB7 ${item.tags.join(", ")}`
+      ).join("\n\n") + "\n");
+      return;
+    }
+    if (rest.length !== 1) throw new Error("template install requires exactly one template ID.");
+    const installed = await installRemoteTemplate({
+      registryUrl: parsed.registryUrl,
+      templateId: rest[0],
+      ...parsed.version ? { version: parsed.version } : {}
+    });
+    if (parsed.json) write(output(installed, true));
+    else write(`Installed ${installed.id}@${installed.version}
+Directory: ${installed.directory}
+Cache: ${installed.cached ? "verified archive reused" : "downloaded and verified"}
+`);
+    return;
+  }
+  if (parsed.registryUrl || parsed.version) {
+    throw new Error("--registry-url and --version are only valid with template remote-list or template install.");
+  }
+  if (subcommand === "init") {
+    if (rest.length !== 1) throw new Error("template init requires exactly one target directory.");
+    const scaffold = await createTemplateScaffold(rest[0]);
+    if (parsed.json) write(output(scaffold, true));
+    else write(`Created template scaffold at ${scaffold.root}
+
+Template ID: ${scaffold.id}
+Next: edit the manifest and files, then run appinit validate --template ${scaffold.root}
+`);
+    return;
+  }
+  const directory = resolveTemplateDirectory(parsed.directory ?? options.templateDirectory);
+  const templates = await discoverLocalTemplates(directory);
+  if (subcommand === "list") {
+    if (rest.length) throw new Error("template list does not accept positional arguments.");
+    const entries = templates.map(({ id, name, description, category, template }) => ({
+      id,
+      name,
+      version: template.manifest.version,
+      category,
+      description
+    }));
+    if (parsed.json) write(output(entries, true));
+    else if (!entries.length) write("No valid local templates found.\n");
+    else write(entries.map((item) => `${item.id}  ${item.name} (${item.version})
+  ${item.description}`).join("\n\n") + "\n");
+    return;
+  }
+  if (subcommand === "search") {
+    const query = rest.join(" ").trim();
+    if (!query) throw new Error("template search requires a query.");
+    const matches = searchLocalTemplates(templates, query);
+    const entries = matches.map(({ id, name, description, category, template }) => ({
+      id,
+      name,
+      version: template.manifest.version,
+      category,
+      description
+    }));
+    if (parsed.json) write(output(entries, true));
+    else if (!entries.length) write(`No templates found for "${query}".
+`);
+    else write(entries.map((item) => `${item.id}  ${item.name} (${item.version})
+  ${item.description}`).join("\n\n") + "\n");
+    return;
+  }
+  if (rest.length !== 1) throw new Error("template info requires exactly one template reference.");
+  const ref = rest[0];
+  const selected = findLocalTemplate(templates, ref);
+  if (!selected) throw new Error(`Template "${ref}" was not found among valid local templates.`);
+  const variables = await loadTemplateVariables(selected.root, selected.template.manifest);
+  const details = {
+    id: selected.id,
+    name: selected.name,
+    version: selected.template.manifest.version,
+    description: selected.description,
+    category: selected.category,
+    kind: selected.template.manifest.kind,
+    language: selected.template.manifest.language,
+    packageName: selected.template.manifest.packageName,
+    atsVersion: selected.template.manifest.atsVersion,
+    tags: selected.template.manifest.tags,
+    renderer: selected.template.manifest.renderer.engine,
+    variables: { defaults: variables.defaults, schema: variables.schema }
+  };
+  if (parsed.json) write(output(details, true));
+  else {
+    write([
+      `${details.name} (${details.id})`,
+      details.description,
+      `Version: ${details.version}`,
+      `Category: ${details.category} | Kind: ${details.kind} | Language: ${details.language}`,
+      `Package: ${details.packageName}`,
+      `ATS compatibility: ${details.atsVersion}`,
+      `Renderer: ${details.renderer}`,
+      `Tags: ${details.tags.join(", ")}`,
+      `Variable defaults: ${Object.keys(variables.defaults).length}`,
+      `Variable schema: ${Object.keys(variables.schema).length}`,
+      "",
+      "Defaults:",
+      JSON.stringify(variables.defaults, null, 2),
+      "",
+      "Schema:",
+      JSON.stringify(variables.schema, null, 2),
+      ""
+    ].join("\n"));
+  }
+}
+
+// src/validate.ts
+import path27 from "path";
+async function runValidateCommand(options = {}, io = { write: (message) => process.stdout.write(message) }) {
+  const report = options.templateDir ? await validateTemplate({ templateDir: path27.resolve(options.cwd ?? process.cwd(), options.templateDir) }) : await validateProject({ rootDir: path27.resolve(options.cwd ?? process.cwd()) });
+  if (options.json) {
+    io.write(`${JSON.stringify(report, null, 2)}
+`);
+    return;
+  }
+  io.write(`AppInit Validation: ${report.rootDir}
+
+`);
+  if (!report.diagnostics.length) io.write("  \u2713 No validation issues found.\n");
+  for (const item of report.diagnostics) {
+    const marker = item.level === "info" ? "i" : item.level === "warn" ? "!" : "\u2717";
+    io.write(`  ${marker} [${item.level.toUpperCase()}] ${item.code}: ${item.message}
+`);
+    if (item.filePath) io.write(`      File: ${item.filePath}
+`);
+    if (item.hint) io.write(`      Hint: ${item.hint}
+`);
+  }
+  io.write(`
+Result: ${report.ok ? "VALID" : "INVALID"}
+`);
+}
+
+// src/wizard.ts
+import path28 from "path";
+
+// src/prompts.ts
+async function textPrompt(io, message, fallback) {
+  const answer = (await io.ask(message, fallback)).trim();
+  return answer || fallback || "";
+}
+async function confirmPrompt(io, message, fallback = false) {
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const raw = (await io.ask(`${message} (yes/no)`, fallback ? "yes" : "no")).trim().toLowerCase();
+    if (!raw) return fallback;
+    if (["y", "yes", "true"].includes(raw)) return true;
+    if (["n", "no", "false"].includes(raw)) return false;
+    io.write("Please answer yes or no.\n");
+  }
+  throw new Error(`Invalid confirmation response for "${message}".`);
+}
+async function selectPrompt(io, message, choices, fallback) {
+  if (!choices.length) throw new Error(`Prompt "${message}" has no choices.`);
+  io.write(`${message} choices: ${choices.map((value, index) => `${index + 1}) ${String(value)}`).join("  ")}
+`);
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const raw = (await io.ask(message, fallback === void 0 ? void 0 : String(fallback))).trim();
+    if (!raw && fallback !== void 0) return fallback;
+    const index = Number(raw) - 1;
+    if (Number.isInteger(index) && index >= 0 && index < choices.length) return choices[index];
+    const exact = choices.find((choice) => String(choice) === raw);
+    if (exact !== void 0) return exact;
+    io.write("Choose one of the listed values.\n");
+  }
+  throw new Error(`Invalid selection for "${message}".`);
+}
+async function schemaPrompt(io, key, rule, fallback) {
+  if (rule.enum?.length) return selectPrompt(io, key, rule.enum, fallback);
+  if (rule.type === "boolean") return confirmPrompt(io, key, fallback === true || fallback === "true");
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const isJson = rule.type === "object" || rule.type === "array";
+    const raw = await textPrompt(
+      io,
+      isJson ? `${key} (JSON)` : key,
+      fallback === void 0 ? void 0 : isJson ? JSON.stringify(fallback) : String(fallback)
+    );
+    if (!raw && fallback === void 0) return raw;
+    if (rule.type === "number") {
+      const number = Number(raw);
+      if (Number.isFinite(number)) return number;
+      io.write(`"${key}" must be a valid number.
+`);
+      continue;
+    }
+    if (isJson) {
+      try {
+        const value = JSON.parse(raw);
+        if (rule.type === "array" ? Array.isArray(value) : value !== null && typeof value === "object" && !Array.isArray(value)) {
+          return value;
+        }
+      } catch {
+      }
+      io.write(`"${key}" must be valid ${rule.type} JSON.
+`);
+      continue;
+    }
+    return raw;
+  }
+  throw new Error(`Invalid value for template variable "${key}".`);
+}
+
+// src/wizard.ts
+async function resolveGuidedCreate(options, io) {
+  const templateDirectory = resolveTemplateDirectory(options.templateDirectory);
+  const templates = await discoverLocalTemplates(templateDirectory);
+  if (!templates.length) throw new Error(`No valid local templates found in ${templateDirectory}.`);
+  let selected = options.template ? templates.find((item) => item.id === options.template || path28.basename(item.root) === options.template || item.template.manifest.packageName === options.template) : void 0;
+  if (options.template && !selected) {
+    throw new Error(`Template "${options.template}" was not found in ${templateDirectory}.`);
+  }
+  if (!selected) {
+    io.write("Available templates:\n");
+    templates.forEach((item, index2) => io.write(`  ${index2 + 1}. ${item.name} \u2014 ${item.description}
+`));
+    const answer = await textPrompt(io, "Select a template number");
+    const index = Number(answer) - 1;
+    if (!Number.isInteger(index) || index < 0 || index >= templates.length) {
+      throw new Error("Invalid template selection.");
+    }
+    selected = templates[index];
+  }
+  let target = options.target;
+  if (!target) target = await textPrompt(io, "Project name", "my-app") || "my-app";
+  const targetName = path28.basename(path28.resolve(target));
+  const metadata = await loadTemplateVariables(selected.root, selected.template.manifest);
+  const variables = { ...metadata.defaults, ...options.variables };
+  if (Object.hasOwn(metadata.schema, "projectName")) {
+    variables.projectName = options.variables.projectName ?? targetName;
+  }
+  for (const [key, rule] of Object.entries(metadata.schema)) {
+    if (Object.hasOwn(options.variables, key) || key === "projectName") continue;
+    if (options.yes || !io.interactive) continue;
+    const answer = await schemaPrompt(io, key, rule, metadata.defaults[key]);
+    if (answer !== "") variables[key] = answer;
+  }
+  const errors = validateTemplateVariables2(variables, metadata.schema);
+  if (errors.length) {
+    const details = errors.map((item) => `  - ${item}`).join("\n");
+    throw new Error(`Template variables are incomplete or invalid:
+${details}${options.yes ? "\nProvide missing values with --var key=value." : ""}`);
+  }
+  io.write("\nProject configuration\n");
+  io.write(`  Template: ${selected.name}
+  Target:   ${path28.resolve(target)}
+`);
+  for (const [key, value] of Object.entries(variables)) {
+    io.write(`  ${key}: ${typeof value === "object" ? JSON.stringify(value) : String(value)}
+`);
+  }
+  if (!options.yes && !options.dryRun && !await io.confirm("Create this project?")) {
+    io.write("Cancelled. No files were written.\n");
+    return null;
+  }
+  return Object.freeze({ ...options, template: selected.id, target, variables });
+}
+
+// src/index.ts
+var CREATE_HELP = [
+  "Usage: appinit create [project-name] [options]",
+  "       appinit create <template-ref> <target> [options]",
+  "",
+  "Create a project from a local AppInit template. Without a template,",
+  "the interactive wizard helps you choose one and configure its variables.",
+  "",
+  "Options:",
+  "  -t, --template <ref>   Select a template by directory, ID, or package name",
+  "  --var key=value        Set a template variable (repeatable)",
+  "  --template-dir <path>  Use a specific local template directory",
+  "  -y, --yes              Skip confirmation (requires all choices/values)",
+  "  --dry-run              Preview planned output without writing files",
+  "  --install              Explicitly install dependencies (headless opt-in)",
+  "  --package-manager <pm>  Choose pnpm, npm, yarn, or bun",
+  "  --git                  Explicitly initialize a Git repository",
+  "  -h, --help             Show this help",
+  "",
+  "Examples:",
+  "  appinit create",
+  "  appinit create my-api",
+  "  appinit create my-api --template backend.fastify.basic",
+  "  appinit create backend.backend-express.basic ./my-api --dry-run",
+  "  appinit create my-api --template backend.fastify.basic --yes",
+  "",
+  "Template directory defaults to ./templates or APPINIT_TEMPLATES_DIR.",
+  ""
+].join("\n");
+async function main(argv) {
+  const [command, ...args] = argv;
+  if (!command || command === "--help" || command === "-h" || command === "help") {
+    process.stdout.write([
+      "AppInit CLI",
+      "",
+      "Commands:",
+      "  appinit create [project-name]  Create a project with guided setup",
+      "  appinit template <command>     Author, discover, and install templates",
+      "  appinit doctor [--json]        Diagnose project health",
+      "  appinit history [--json]       View previously generated projects",
+      "  appinit context [--json]       Inspect current project context",
+      "  appinit state path             Show the global state directory path",
+      "  appinit state inspect [--json] Inspect global state safely",
+      "  appinit state doctor [--json]  Diagnose global state health",
+      "  appinit validate [options]     Validate a project or template",
+      "",
+      'Run "appinit create --help", "appinit template --help", "appinit doctor --help", "appinit history --help", "appinit context --help", "appinit state path --help", "appinit state inspect --help", or "appinit validate --help" for usage.',
+      ""
+    ].join("\n"));
+    return;
+  }
+  if (command === "context") {
+    if (args.includes("--help") || args.includes("-h")) {
+      stdout.write("Usage: appinit context [--json]\n\nShow metadata and global history for the current project.\n");
+      return;
+    }
+    const unknown = args.filter((arg) => arg !== "--json");
+    if (unknown.length) throw new Error("Unknown context option: " + unknown[0]);
+    await runContextCommand({ json: args.includes("--json") });
+    return;
+  }
+  if (command === "state") {
+    const [subcommand, ...stateArgs] = args;
+    if (subcommand === "doctor") {
+      if (stateArgs.includes("--help") || stateArgs.includes("-h")) {
+        stdout.write("Usage: appinit state doctor [--json]\n\nDiagnose global state health without modifying it.\n");
+        return;
+      }
+      const unknown = stateArgs.filter((arg) => arg !== "--json");
+      if (unknown.length) throw new Error(`Unknown state doctor option "${unknown[0]}".`);
+      await runStateDoctorCommand({ json: stateArgs.includes("--json") });
+      return;
+    }
+    if (subcommand === "inspect") {
+      if (stateArgs.includes("--help") || stateArgs.includes("-h")) {
+        stdout.write("Usage: appinit state inspect [--json]\n\nInspect global state without modifying it.\n");
+        return;
+      }
+      const unknown = stateArgs.filter((arg) => arg !== "--json");
+      if (unknown.length) throw new Error(`Unknown state inspect option "${unknown[0]}".`);
+      await runStateInspectCommand({ json: stateArgs.includes("--json") });
+      return;
+    }
+    if (subcommand !== "path") {
+      throw new Error('Unknown state command. Use "appinit state path", "appinit state inspect", or "appinit state doctor".');
+    }
+    if (stateArgs.includes("--help") || stateArgs.includes("-h")) {
+      stdout.write("Usage: appinit state path\n\nShow the resolved global AppInit state directory.\n");
+      return;
+    }
+    if (stateArgs.length) throw new Error(`Unknown state path option "${stateArgs[0]}".`);
+    await runStatePathCommand();
+    return;
+  }
+  if (command === "history") {
+    if (args.includes("--help") || args.includes("-h")) {
+      stdout.write("Usage: appinit history [--json]\n\nShow projects previously generated with AppInit.\n");
+      return;
+    }
+    const unknown = args.filter((arg) => arg !== "--json");
+    if (unknown.length) throw new Error(`Unknown history option "${unknown[0]}".`);
+    await runHistoryCommand({ json: args.includes("--json") });
+    return;
+  }
+  if (command === "doctor") {
+    if (args.includes("--help") || args.includes("-h")) {
+      stdout.write("Usage: appinit doctor [--json]\n\nDiagnose the current project. Doctor findings are advisory and do not block execution.\n");
+      return;
+    }
+    const unknown = args.filter((arg) => arg !== "--json");
+    if (unknown.length) throw new Error(`Unknown doctor option "${unknown[0]}".`);
+    await runDoctorCommand({ json: args.includes("--json") });
+    return;
+  }
+  if (command === "validate") {
+    if (args.includes("--help") || args.includes("-h")) {
+      stdout.write("Usage: appinit validate [--template <directory>] [--json]\n\nValidate the current project or a template directory.\n");
+      return;
+    }
+    let templateDir;
+    let json = false;
+    for (let index = 0; index < args.length; index += 1) {
+      const arg = args[index];
+      if (arg === "--json") json = true;
+      else if (arg === "--template") {
+        templateDir = args[index + 1];
+        if (!templateDir || templateDir.startsWith("--")) throw new Error("--template requires a directory.");
+        index += 1;
+      } else throw new Error(`Unknown validate option "${arg}".`);
+    }
+    await runValidateCommand({ templateDir, json });
+    return;
+  }
+  if (command === "template") {
+    await runTemplateCommand(args, { write: (message) => stdout.write(message) });
+    return;
+  }
+  if (command !== "create") {
+    throw new Error(`Unknown command "${command}". Run "appinit --help" for usage.`);
+  }
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(CREATE_HELP);
+    return;
+  }
+  const options = parseCreateArguments(args);
+  const interactive = Boolean(stdin.isTTY && stdout.isTTY);
+  if (!interactive && (!options.template || !options.target)) {
+    throw new Error("Non-interactive create requires a template and target. Use: appinit create <template-ref> <target> --yes");
+  }
+  if (!interactive && !options.yes && !options.dryRun) {
+    throw new Error("Non-interactive create requires --yes to confirm file writes.");
+  }
+  if (options.yes && (!options.template || !options.target)) {
+    throw new Error(" --yes requires both a template and target. Supply: appinit create <template-ref> <target> --yes");
+  }
+  const rl = interactive ? createInterface({ input: stdin, output: stdout }) : void 0;
+  const io = {
+    interactive,
+    ask: async (message, fallback) => {
+      if (!rl) throw new Error(`Missing value: ${message}`);
+      const suffix = fallback ? ` [${fallback}]` : "";
+      const answer = (await rl.question(`${message}${suffix}: `)).trim();
+      return answer || fallback || "";
+    },
+    confirm: async (message) => {
+      if (!rl) throw new Error("Confirmation requires an interactive terminal. Use --yes to proceed.");
+      const answer = (await rl.question(`${message} (y/N): `)).trim().toLowerCase();
+      return answer === "y" || answer === "yes";
+    },
+    write: (message) => {
+      stdout.write(message);
+    }
+  };
+  try {
+    const resolved = await resolveGuidedCreate(options, io);
+    if (resolved) {
+      await runCreateCommand(resolved);
+      if (!resolved.dryRun) await finalizeProject(resolved.target, resolved, io);
+    }
+  } finally {
+    rl?.close();
+  }
+}
+main(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`AppInit: ${message}
+`);
+  process.exitCode = 1;
+});
+export {
+  diagnoseAppInitState,
+  finalizeProject,
+  findLocalTemplate,
+  formatTemplateInfo,
+  formatTemplateList,
+  inspectAppInitState,
+  inspectAppInitStatePath,
+  installRemoteTemplate,
+  listRemoteTemplates,
+  parseCreateArguments,
+  readProjectContext,
+  readProjectHistory,
+  resolveGuidedCreate,
+  runContextCommand,
+  runCreateCommand,
+  runDoctorCommand,
+  runHistoryCommand,
+  runStateDoctorCommand,
+  runStateInspectCommand,
+  runStatePathCommand,
+  runValidateCommand,
+  searchLocalTemplates
+};