archicat 0.1.0 → 0.1.2

package/dist/cli/index.mjs

@@ -1,28 +1,1512 @@
-import{createRequire as e}from"node:module";import{Console as t}from"@buildplease/core/node";import n from"node:fs";import r from"node:path";import i from"typescript";import{createJiti as a}from"jiti";const o={packageName:`archicat`,configFileName:`archicat.config.ts`,root:`.`,outDir:`.archicat`,alias:{},definitions:{moduleFileName:`archicat.module.ts`,libraryFileName:`archicat.library.ts`,appFileName:`archicat.app.ts`},generated:{modulesDirName:`modules`,librariesDirName:`libraries`,typesDirName:`types`,reportsDirName:`reports`,buildReportFileName:`build.report.json`,graphReportFileName:`graph.report.json`,tsconfigFileName:`tsconfig.json`,typesInclude:`./types/**/*.d.ts`,ignoredDirectoryNames:[`node_modules`,`.git`,`.archicat`,`dist`,`build`,`coverage`]},typescript:{consumerTsconfigFileName:`tsconfig.json`,tsConfig:{include:[],exclude:[],files:[]}},modules:{include:[`./src/modules`],alias:`#modules`},libraries:{include:[],alias:`#library`},apps:{include:[]}};function s(e){let t=n.readFileSync(e,`utf8`),r=i.parseConfigFileTextToJson(e,t);if(r.error)throw Error(te(r.error));if(r.config==null||typeof r.config!=`object`||Array.isArray(r.config))throw Error(`Invalid tsconfig object: ${e}`);return r.config}function c(e,t=`tsconfig`){let n=e.compilerOptions;if(n==null)return{};if(typeof n!=`object`||Array.isArray(n))throw Error(`Tsconfig compilerOptions must be an object: ${t}`);return n}function l(e,t){let n=e.extends;if(n===void 0)return[];if(typeof n==`string`)return[d(t,n)];if(Array.isArray(n)&&n.every(e=>typeof e==`string`))return n.map(e=>d(t,e));throw Error(`Tsconfig extends must be a string or string array: ${t}`)}function u(t,n){return r.isAbsolute(n)||n.startsWith(`.`)?ee(r.resolve(t,n),n):f(e(r.join(t,o.configFileName)),n,n)}function d(t,n){return r.isAbsolute(n)||n.startsWith(`.`)?ee(r.resolve(r.dirname(t),n),t):f(e(t),n,t)}function f(e,t,n){for(let n of p(t))try{return e.resolve(n)}catch{continue}throw Error(`Unable to resolve tsconfig extends "${t}": ${n}`)}function ee(e,t){for(let t of p(e))if(n.existsSync(t)&&n.statSync(t).isFile())return t;throw Error(`Unable to resolve tsconfig extends "${e}": ${t}`)}function p(e){return[e,`${e}.json`,r.join(e,o.typescript.consumerTsconfigFileName)]}function te(e){let t=i.flattenDiagnosticMessageText(e.messageText,`
-`);if(e.file&&e.start!==void 0){let n=e.file.getLineAndCharacterOfPosition(e.start);return`${e.file.fileName}:${n.line+1}:${n.character+1} - ${t}`}return t}async function ne(e,t=o.configFileName){let i=r.resolve(e,t);if(!n.existsSync(i))throw Error(`Archicat config was not found: ${i}`);let a=await re(i,e);ue(a,i);let s=ie(a);me(s.modules.alias,s.libraries.alias,i);let c=r.resolve(e,s.root),l=r.resolve(c,s.outDir),u=r.resolve(l,o.generated.reportsDirName),d=le(c,s.typescript.tsConfig.extends);return{configFilePath:i,rootDir:c,outDir:l,reportsDir:u,...d?{tsconfigPath:d}:{},resolvedConfig:s}}async function re(e,t){return await a(t,{interopDefault:!0,extensions:[`.js`,`.cjs`,`.mjs`,`.ts`,`.cts`,`.mts`,`.json`]}).import(e,{default:!0})}function ie(e){return{root:e.root??o.root,outDir:e.outDir??o.outDir,typescript:ae(e),alias:{...o.alias,...e.alias??{}},modules:oe(e.modules),libraries:se(e.libraries),apps:ce(e.apps)}}function ae(e){let t=e.typescript?.tsConfig,n=o.typescript.tsConfig,r={include:[...t?.include??n.include],exclude:[...t?.exclude??n.exclude],files:[...t?.files??n.files]};return t?.extends&&(r.extends=t.extends),{tsConfig:r}}function oe(e){return{include:[...e?.include??o.modules.include],alias:e?.alias??o.modules.alias}}function se(e){return{include:[...e?.include??o.libraries.include],alias:e?.alias??o.libraries.alias}}function ce(e){return{include:[...e?.include??o.apps.include]}}function le(e,t){if(t)return u(e,t)}function ue(e,t){if(typeof e!=`object`||!e)throw Error(`Invalid Archicat config: ${t}`);let n=e;m(n.root,`root`,t),m(n.outDir,`outDir`,t),_(n.typescript,`typescript`,t),_(n.modules,`modules`,t),_(n.libraries,`libraries`,t),_(n.apps,`apps`,t),de(n.typescript?.tsConfig,t),h(n.modules?.include,`modules.include`,t),h(n.libraries?.include,`libraries.include`,t),h(n.apps?.include,`apps.include`,t),g(n.modules?.alias,`modules.alias`,t),g(n.libraries?.alias,`libraries.alias`,t),pe(n.alias,`alias`,t)}function de(e,t){if(e===void 0)return;if(typeof e!=`object`||!e||Array.isArray(e))throw Error(`Archicat config typescript.tsConfig must be an object: ${t}`);let n=e;m(n.extends,`typescript.tsConfig.extends`,t),h(n.include,`typescript.tsConfig.include`,t),h(n.exclude,`typescript.tsConfig.exclude`,t),h(n.files,`typescript.tsConfig.files`,t),fe(n.compilerOptions,t)}function fe(e,t){if(e===void 0)return;if(typeof e!=`object`||!e||Array.isArray(e))throw Error(`Archicat config typescript.tsConfig.compilerOptions must be an object: ${t}`);let n=e;if(Object.hasOwn(n,`paths`))throw Error(`Archicat config typescript.tsConfig.compilerOptions.paths is not supported. Move aliases into archicat.config.ts alias.`);if(Object.hasOwn(n,`baseUrl`))throw Error(`Archicat config typescript.tsConfig.compilerOptions.baseUrl is not supported. Move aliases into archicat.config.ts alias.`);if(Object.keys(n).length>0)throw Error(`Archicat config typescript.tsConfig.compilerOptions is not supported. Put compiler options in the base or app tsconfig.`)}function m(e,t,n){if(e!==void 0&&(typeof e!=`string`||e.trim()===``))throw Error(`Archicat ${t} must be a non-empty string when defined: ${n}`)}function h(e,t,n){if(e!==void 0&&(!Array.isArray(e)||e.some(e=>typeof e!=`string`||e.trim()===``)))throw Error(`Archicat config ${t} must be an array of non-empty strings: ${n}`)}function g(e,t,n){if(e!==void 0&&(typeof e!=`string`||e.trim()===``||e.includes(`*`)||e.endsWith(`/`)))throw Error(`Archicat config ${t} must be a non-empty alias without wildcard or trailing slash: ${n}`)}function pe(e,t,n){if(e!==void 0){if(typeof e!=`object`||!e||Array.isArray(e))throw Error(`Archicat config ${t} must be an object of non-empty string aliases: ${n}`);for(let[r,i]of Object.entries(e))if(r.trim()===``||typeof i!=`string`||i.trim()===``)throw Error(`Archicat config ${t} must contain non-empty string aliases: ${n}`)}}function _(e,t,n){if(e!==void 0&&(typeof e!=`object`||!e||Array.isArray(e)))throw Error(`Archicat config ${t} must be an object: ${n}`)}function me(e,t,n){if(e===t||e.startsWith(`${t}/`)||t.startsWith(`${e}/`))throw Error(`Archicat module and library aliases must use separate roots: "${e}" and "${t}" (${n})`)}function v(e){return e.split(r.sep).join(`/`)}function he(e,t){let n=r.dirname(e),i=r.parse(t),a=r.join(i.dir,i.name),o=v(r.relative(n,a));return o.startsWith(`.`)||(o=`./${o}`),`${o}.js`}function y(e,t){let n=r.relative(t,e);return n===``||!!n&&!n.startsWith(`..`)&&!r.isAbsolute(n)}function ge(e,t){let n=b(e),r=b(t);if(r===n||!y(r,n))throw Error(`Archicat outDir must be a directory inside the project root: ${t}`)}function b(e){let t=r.resolve(e),i=[],a=t;for(;!n.existsSync(a);){let e=r.dirname(a);if(e===a)return t;i.unshift(r.basename(a)),a=e}return r.join(n.realpathSync(a),...i)}function x(e){return e.replace(/\.(?:js|mjs|cjs|ts|mts|cts|tsx)$/u,``)}function S(e,t){return v(r.relative(e,t))}function C(e,t,n,r=[]){let i=t.flatMap(t=>_e(e,t,n,r));return Array.from(new Set(i)).sort((e,t)=>e.localeCompare(t))}function _e(e,t,i,a){let o=r.resolve(e,t);if(t.includes(`*`))return ye(e,t).filter(e=>!a.some(t=>y(e,t))).filter(e=>r.basename(e)===i);if(!n.existsSync(o))return[];let s=n.statSync(o);return s.isFile()?r.basename(o)===i?[o]:[]:s.isDirectory()?ve(o,i,a):[]}function ve(e,t,i){let a=[],o=n.readdirSync(e,{withFileTypes:!0});for(let n of o){if(xe(n.name))continue;let o=r.join(e,n.name);if(!i.some(e=>y(o,e))){if(n.isDirectory()){a.push(...ve(o,t,i));continue}n.isFile()&&n.name===t&&a.push(o)}}return a}function ye(e,t){let i=r.resolve(e,t).split(r.sep);if(i.filter(e=>e.includes(`*`)).length!==1)throw Error(`Archicat supports exactly one wildcard segment per include pattern: ${t}`);let a=i.findIndex(e=>e.includes(`*`)),o=i.slice(0,a).join(r.sep)||r.sep,s=i[a]??`*`,c=i.slice(a+1),l=be(s);return n.existsSync(o)?n.readdirSync(o,{withFileTypes:!0}).filter(e=>e.isDirectory()).filter(e=>l.test(e.name)).map(e=>r.join(o,e.name,...c)).filter(e=>n.existsSync(e)&&n.statSync(e).isFile()):[]}function be(e){let t=e.replace(/[.+?^${}()|[\]\\]/gu,`\\$&`).replace(/\*/gu,`.*`);return RegExp(`^${t}$`,`u`)}function xe(e){return o.generated.ignoredDirectoryNames.includes(e)}async function w(e,t){switch(t){case`module`:return Se(e);case`library`:return Ce(e);case`app`:return we(e)}}async function Se(e){let t=await T(e,r.dirname(e));return E(t,e,`module`),{kind:`module`,contractFilePath:e,definitionDir:r.dirname(e),contract:t}}async function Ce(e){let t=await T(e,r.dirname(e));return E(t,e,`library`),{kind:`library`,contractFilePath:e,definitionDir:r.dirname(e),contract:t}}async function we(e){let t=await T(e,r.dirname(e));return E(t,e,`app`),{kind:`app`,contractFilePath:e,definitionDir:r.dirname(e),contract:t}}async function T(e,t){return await a(t,{interopDefault:!0,extensions:[`.js`,`.cjs`,`.mjs`,`.ts`,`.cts`,`.mts`,`.json`]}).import(e,{default:!0})}function E(e,t,n){if(typeof e!=`object`||!e)throw Error(`Invalid Archicat ${n} definition: ${t}`);let r=e;if(r.kind!==n)throw Error(`Archicat ${n} file must export a ${n} definition: ${t}`);if(typeof r.name!=`string`||r.name.trim()===``)throw Error(`Archicat ${n} must define a non-empty name: ${t}`);if(n===`app`){k(r.root,`root`,t),O(r.dependencies,t,n);return}let i=r;D(i.api,`api`,t,n),D(i.impl,`impl`,t,n)}function D(e,t,n,r){if(typeof e!=`object`||!e)throw Error(`Archicat ${r}.${t} must be a surface object: ${n}`);k(e.root,`${t}.root`,n),O(e.dependencies,n,`${r}.${t}`)}function O(e,t,n){if(!Array.isArray(e)||e.some(e=>typeof e!=`string`||e.trim()===``))throw Error(`Archicat ${n} dependencies must be an array of non-empty strings: ${t}`)}function k(e,t,n){if(e!==void 0&&(typeof e!=`string`||e.trim()===``))throw Error(`Archicat ${t} must be a non-empty string when defined: ${n}`)}function Te(e){let t=new Map;for(let n of e){let e=t.get(n.from)??[];e.push(n.to),t.set(n.from,e)}let n=new Set,r=new Set;for(let e of t.keys())A(e,t,n,r,[])}function A(e,t,n,r,i){if(!r.has(e)){if(n.has(e)){let t=i.indexOf(e),n=[...i.slice(t<0?0:t),e];throw Error(`Cyclic Archicat dependency detected: ${n.join(` -> `)}`)}n.add(e);for(let a of t.get(e)??[])A(a,t,n,r,[...i,e]);n.delete(e),r.add(e)}}function Ee(e){let t=/^(module|library)\.([a-z][a-z0-9-]*)\.(api|impl)$/u.exec(e);if(t)return{kind:t[1],name:t[2],surface:t[3]}}function j(e,t,n){let r=Ee(t);if(!r)throw Error(`${M(e)} declares invalid dependency target "${t}".`);if(!n.has(t))throw Error(`${M(e)} declares unknown dependency "${t}".`);if(e.target===t)throw Error(`${M(e)} cannot depend on itself: ${t}`);if(e.surface===`api`&&r.surface===`impl`)throw Error(`${M(e)} cannot depend on implementation target "${t}" from an API surface.`)}function M(e){return e.kind===`app`?`App "${e.name}"`:`${De(e.kind)} "${e.name}" ${e.surface}`}function De(e){return`${e.charAt(0).toUpperCase()}${e.slice(1)}`}function Oe(e,t){let n=t.filter(e=>e.kind===`module`).map(t=>ke(e,t)),r=t.filter(e=>e.kind===`library`).map(t=>Ae(e,t)),i=t.filter(e=>e.kind===`app`).map(e=>je(e)),a=[...n,...r];Ne([...a,...i]);let o=Me(a,i);return Pe(a,i,o.targets),Te(o.dependencies),{rootDir:e.rootDir,outDir:e.outDir,reportsDir:e.reportsDir,...e.tsconfigPath?{tsconfigPath:e.tsconfigPath}:{},configFilePath:e.configFilePath,config:e.resolvedConfig,modules:n,libraries:r,apps:i,definitions:a,graph:o}}function ke(e,t){let{contract:n,contractFilePath:i,definitionDir:a}=t;F(n.name,i,`module`);let s=n.api.root?P(a,n.api.root,`api`,n.name):void 0,c=n.impl.root?P(a,n.impl.root,`impl`,n.name):void 0,l=`${e.resolvedConfig.modules.alias}/${n.name}`,u=`${l}/api`,d=`${l}/impl`;return{kind:`module`,name:n.name,apiTarget:`module.${n.name}.api`,implTarget:`module.${n.name}.impl`,alias:u,aliasGlob:`${u}/*`,implAlias:d,implAliasGlob:`${d}/*`,contractFilePath:i,definitionDir:a,api:N(s,n.api.dependencies,r.join(e.outDir,o.generated.modulesDirName,n.name,`api`)),impl:N(c,n.impl.dependencies,r.join(e.outDir,o.generated.modulesDirName,n.name,`impl`))}}function Ae(e,t){let{contract:n,contractFilePath:i,definitionDir:a}=t;F(n.name,i,`library`);let s=n.api.root?P(a,n.api.root,`api`,n.name):void 0,c=n.impl.root?P(a,n.impl.root,`impl`,n.name):void 0,l=`${e.resolvedConfig.libraries.alias}/${n.name}`,u=`${l}/api`,d=`${l}/impl`;return{kind:`library`,name:n.name,apiTarget:`library.${n.name}.api`,implTarget:`library.${n.name}.impl`,alias:u,aliasGlob:`${u}/*`,implAlias:d,implAliasGlob:`${d}/*`,contractFilePath:i,definitionDir:a,api:N(s,n.api.dependencies,r.join(e.outDir,o.generated.librariesDirName,n.name,`api`)),impl:N(c,n.impl.dependencies,r.join(e.outDir,o.generated.librariesDirName,n.name,`impl`))}}function je(e){let{contract:t,contractFilePath:n,definitionDir:r}=e;return F(t.name,n,`app`),{kind:`app`,name:t.name,target:`app.${t.name}`,contractFilePath:n,rootPath:t.root?P(r,t.root,`app`,t.name):r,dependencies:[...t.dependencies]}}function N(e,t,n){return{...e?{rootPath:e}:{},mirrorRootPath:n,dependencies:[...t]}}function P(e,t,i,a){let o=r.resolve(e,t);if(!n.existsSync(o))throw Error(`Definition "${a}" declares ${i} root that does not exist: ${o}`);if(!n.statSync(o).isDirectory())throw Error(`Definition "${a}" declares ${i} root that is not a directory: ${o}`);return o}function Me(e,t){let n=e.flatMap(e=>[{key:e.apiTarget,surface:`api`},{key:e.implTarget,surface:`impl`}]),r=[...e.flatMap(e=>[...e.api.dependencies.map(t=>({from:e.apiTarget,to:t,origin:`declared`})),...e.impl.dependencies.map(t=>({from:e.implTarget,to:t,origin:`declared`}))]),...t.flatMap(e=>e.dependencies.map(t=>({from:e.target,to:t,origin:`declared`})))];return{targets:n,dependencies:[...e.map(e=>({from:e.implTarget,to:e.apiTarget,origin:`derived`})),...r]}}function F(e,t,n){if(!/^[a-z][a-z0-9-]*$/u.test(e))throw Error(`Invalid Archicat ${n} name "${e}" in ${t}. Use ^[a-z][a-z0-9-]*$`)}function Ne(e){let t=new Map;for(let n of e){let e=`${n.kind}.${n.name}`,r=t.get(e);if(r)throw Error(`Duplicate Archicat ${n.kind} name "${n.name}" in ${r} and ${n.contractFilePath}`);t.set(e,n.contractFilePath)}}function Pe(e,t,n){let r=new Set(n.map(e=>e.key));for(let t of e){for(let e of t.api.dependencies)j(Fe(t,`api`),e,r);for(let e of t.impl.dependencies)j(Fe(t,`impl`),e,r)}for(let e of t)for(let t of e.dependencies)j({kind:`app`,name:e.name,surface:`app`,target:e.target},t,r)}function Fe(e,t){return{kind:e.kind,name:e.name,surface:t,target:t===`api`?e.apiTarget:e.implTarget}}async function Ie(e,t){let n=await ne(e,t),r=C(n.rootDir,n.resolvedConfig.modules.include,o.definitions.moduleFileName,[n.outDir]),i=C(n.rootDir,n.resolvedConfig.libraries.include,o.definitions.libraryFileName,[n.outDir]),a=C(n.rootDir,n.resolvedConfig.apps.include,o.definitions.appFileName,[n.outDir]);if(r.length===0&&i.length===0&&a.length===0)throw Error(`No Archicat definition files matched configured include roots.`);return Oe(n,[...await Promise.all(r.map(e=>w(e,`module`))),...await Promise.all(i.map(e=>w(e,`library`))),...await Promise.all(a.map(e=>w(e,`app`)))])}function Le(e){let t=[];Re(t,`Modules`,e.modules.length,e.modules,e.graph.dependencies),Re(t,`Libraries`,e.libraries.length,e.libraries,e.graph.dependencies),t.push(`Apps: ${e.apps.length}`),e.apps.length>0&&t.push(``);for(let n of e.apps)t.push(n.name),t.push(`  app: ${n.target}`),I(t,e.graph.dependencies.filter(e=>e.from===n.target),`  dependsOn`),t.push(``);return ze(t)}function Re(e,t,n,r,i){e.push(`${t}: ${n}`),r.length>0&&e.push(``);for(let t of r)e.push(t.name),e.push(`  api: ${t.apiTarget}`),I(e,i.filter(e=>e.from===t.apiTarget),`  api dependsOn`),e.push(`  impl: ${t.implTarget}`),I(e,i.filter(e=>e.from===t.implTarget),`  impl dependsOn`),e.push(``)}function I(e,t,n){if(t.length===0){e.push(`${n}: none`);return}e.push(`${n}:`);for(let n of t){let t=n.origin===`derived`?` (derived)`:``;e.push(`    ${n.to}${t}`)}}function ze(e){for(;e.at(-1)===``;)e.pop();return e}async function Be(e,t){return{exitCode:0,lines:Le(await Ie(t,e.config)).map(e=>({kind:`info`,message:e}))}}function Ve(e){return[...He(e),...Xe(e)]}function He(e){let t=Ze(e);if(!n.existsSync(t))return[`Consumer tsconfig was not found: ${t}`];let r=[],i=Ue(t,r);if(!i)return r;let a=We(i,t,r);return a?(Ge(r,e,i),Ke(r,a),qe(r,a),Je(r,a),Ye(r,i),r):r}function Ue(e,t){try{return s(e)}catch(e){t.push(`Failed to parse consumer tsconfig: ${tt(e)}`);return}}function We(e,t,n){try{return c(e,t)}catch(e){n.push(tt(e));return}}function Ge(e,t,n){let r=$e(t);n.extends!==r&&e.push(`Consumer tsconfig should extend ${r} for generated Archicat aliases to work.`)}function Ke(e,t){let n=t.rootDir;(n===`src`||n===`./src`)&&e.push(`compilerOptions.rootDir is set to src. Generated Archicat files live outside src and may break tsc.`)}function qe(e,t){Object.hasOwn(t,`paths`)&&e.push(`compilerOptions.paths should move to archicat.config.ts alias. Consumer tsconfig paths can override generated Archicat aliases.`)}function Je(e,t){Object.hasOwn(t,`baseUrl`)&&e.push(`compilerOptions.baseUrl is not supported. Move aliases into archicat.config.ts alias.`)}function Ye(e,t){(t.include!==void 0||t.exclude!==void 0||t.files!==void 0)&&e.push(`Consumer tsconfig include/exclude/files should move to archicat.config.ts typescript.tsConfig so generated Archicat types stay included.`)}function Xe(e){let t=[];for(let i of e.definitions){let e=r.join(i.definitionDir,`api`),a=r.join(i.definitionDir,`impl`);!i.api.rootPath&&n.existsSync(e)&&t.push(`${L(i.kind)} "${i.name}" has a physical api directory but its contract omits api.root. Archicat treats the public API as empty.`),!i.impl.rootPath&&n.existsSync(a)&&t.push(`${L(i.kind)} "${i.name}" has a physical impl directory but its contract omits impl.root. Archicat treats the implementation as no-op.`)}return t}function Ze(e){return r.join(e.rootDir,o.typescript.consumerTsconfigFileName)}function Qe(e){return r.join(e.outDir,o.generated.tsconfigFileName)}function $e(e){let t=v(r.relative(e.rootDir,Qe(e)));return et(t)||(t=`./${t}`),t}function et(e){return e.startsWith(`./`)||e.startsWith(`../`)}function tt(e){return e instanceof Error?e.message:String(e)}function L(e){return`${e.charAt(0).toUpperCase()}${e.slice(1)}`}function nt(e,t){ge(e,t),rt(e,t),n.rmSync(t,{recursive:!0,force:!0}),n.mkdirSync(t,{recursive:!0})}function R(e,t){n.mkdirSync(r.dirname(e),{recursive:!0}),n.writeFileSync(e,t,`utf8`)}function z(e,t){R(e,`${JSON.stringify(t,null,2)}\n`)}function rt(e,t){if(!(!n.existsSync(t)||n.readdirSync(t).length===0)&&!it(e,t))throw Error(`Archicat refuses to replace a non-owned outDir: ${t}`)}function it(e,t){let i=r.join(t,o.generated.reportsDirName,o.generated.buildReportFileName);if(!n.existsSync(i))return!1;try{let a=JSON.parse(n.readFileSync(i,`utf8`));return a.generatedBy===`archicat`&&a.schemaVersion===2&&typeof a.outputs?.outDir==`string`&&r.resolve(e,a.outputs.outDir)===r.resolve(t)}catch{return!1}}function at(e){let t=e.graph.targets.map(e=>e.key),n=e.graph.targets.filter(e=>e.surface===`api`).map(e=>e.key),i=o.packageName,a=`import '${i}';
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import ts from "typescript";
+import { createJiti } from "jiti";
+import consola from "consola";
 
-declare module '${i}' {
-${B(`ArchicatModuleApiDependencies`,n)}
+//#region src-internal/configuration/archicat-defaults.ts
+const ArchicatDefaults = {
+	packageName: "archicat",
+	configFileName: "archicat.config.ts",
+	root: ".",
+	outDir: ".archicat",
+	alias: {},
+	definitions: {
+		moduleFileName: "archicat.module.ts",
+		libraryFileName: "archicat.library.ts",
+		appFileName: "archicat.app.ts"
+	},
+	generated: {
+		modulesDirName: "modules",
+		librariesDirName: "libraries",
+		typesDirName: "types",
+		reportsDirName: "reports",
+		buildReportFileName: "build.report.json",
+		graphReportFileName: "graph.report.json",
+		tsconfigFileName: "tsconfig.json",
+		typesInclude: "./types/**/*.d.ts",
+		ignoredDirectoryNames: [
+			"node_modules",
+			".git",
+			".archicat",
+			"dist",
+			"build",
+			"coverage"
+		]
+	},
+	typescript: {
+		consumerTsconfigFileName: "tsconfig.json",
+		tsConfig: {
+			include: [],
+			exclude: [],
+			files: []
+		}
+	},
+	modules: {
+		include: ["./src/modules"],
+		alias: "#modules"
+	},
+	libraries: {
+		include: [],
+		alias: "#library"
+	},
+	apps: { include: [] }
+};
 
-${B(`ArchicatModuleImplDependencies`,t)}
+//#endregion
+//#region src-internal/tsconfig/tsconfig-utils.ts
+function readTsconfigFile(tsconfigPath) {
+	const raw = fs.readFileSync(tsconfigPath, "utf8");
+	const parsed = ts.parseConfigFileTextToJson(tsconfigPath, raw);
+	if (parsed.error) throw new Error(formatTsDiagnostic(parsed.error));
+	if (parsed.config == null || typeof parsed.config !== "object" || Array.isArray(parsed.config)) throw new Error(`Invalid tsconfig object: ${tsconfigPath}`);
+	return parsed.config;
+}
+function readTsconfigCompilerOptions(tsconfig, source = "tsconfig") {
+	const compilerOptions = tsconfig.compilerOptions;
+	if (compilerOptions == null) return {};
+	if (typeof compilerOptions !== "object" || Array.isArray(compilerOptions)) throw new Error(`Tsconfig compilerOptions must be an object: ${source}`);
+	return compilerOptions;
+}
+function readTsconfigExtendsPaths(tsconfig, tsconfigPath) {
+	const extended = tsconfig.extends;
+	if (extended === void 0) return [];
+	if (typeof extended === "string") return [resolveTsconfigExtends(tsconfigPath, extended)];
+	if (Array.isArray(extended) && extended.every((entry) => typeof entry === "string")) return extended.map((entry) => resolveTsconfigExtends(tsconfigPath, entry));
+	throw new Error(`Tsconfig extends must be a string or string array: ${tsconfigPath}`);
+}
+function resolveProjectTsconfig(rootDir, configuredExtends) {
+	if (path.isAbsolute(configuredExtends) || configuredExtends.startsWith(".")) return resolveTsconfigFile(path.resolve(rootDir, configuredExtends), configuredExtends);
+	return resolvePackageTsconfig(createRequire(path.join(rootDir, ArchicatDefaults.configFileName)), configuredExtends, configuredExtends);
+}
+function resolveTsconfigExtends(tsconfigPath, extended) {
+	if (path.isAbsolute(extended) || extended.startsWith(".")) return resolveTsconfigFile(path.resolve(path.dirname(tsconfigPath), extended), tsconfigPath);
+	return resolvePackageTsconfig(createRequire(tsconfigPath), extended, tsconfigPath);
+}
+function resolvePackageTsconfig(resolver, value, source) {
+	for (const candidate of makeTsconfigCandidates(value)) try {
+		return resolver.resolve(candidate);
+	} catch {
+		continue;
+	}
+	throw new Error(`Unable to resolve tsconfig extends "${value}": ${source}`);
+}
+function resolveTsconfigFile(candidate, source) {
+	for (const entry of makeTsconfigCandidates(candidate)) if (fs.existsSync(entry) && fs.statSync(entry).isFile()) return entry;
+	throw new Error(`Unable to resolve tsconfig extends "${candidate}": ${source}`);
+}
+function makeTsconfigCandidates(value) {
+	return [
+		value,
+		`${value}.json`,
+		path.join(value, ArchicatDefaults.typescript.consumerTsconfigFileName)
+	];
+}
+function formatTsDiagnostic(diagnostic) {
+	const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+	if (diagnostic.file && diagnostic.start !== void 0) {
+		const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+		return `${diagnostic.file.fileName}:${position.line + 1}:${position.character + 1} - ${message}`;
+	}
+	return message;
+}
+
+//#endregion
+//#region src-internal/configuration/load-config.ts
+async function loadArchicatConfig(cwd, configFileName = ArchicatDefaults.configFileName) {
+	const configFilePath = path.resolve(cwd, configFileName);
+	if (!fs.existsSync(configFilePath)) throw new Error(`Archicat config was not found: ${configFilePath}`);
+	const config = await importDefault$1(configFilePath, cwd);
+	assertArchicatConfig(config, configFilePath);
+	const resolvedConfig = resolveConfig(config);
+	assertDistinctReservedAliases(resolvedConfig.modules.alias, resolvedConfig.libraries.alias, configFilePath);
+	const rootDir = path.resolve(cwd, resolvedConfig.root);
+	const outDir = path.resolve(rootDir, resolvedConfig.outDir);
+	const reportsDir = path.resolve(outDir, ArchicatDefaults.generated.reportsDirName);
+	const tsconfigPath = resolveTsconfigPath(rootDir, resolvedConfig.typescript.tsConfig.extends);
+	return {
+		configFilePath,
+		rootDir,
+		outDir,
+		reportsDir,
+		...tsconfigPath ? { tsconfigPath } : {},
+		resolvedConfig
+	};
+}
+async function importDefault$1(filePath, rootDir) {
+	return await createJiti(rootDir, {
+		interopDefault: true,
+		extensions: [
+			".js",
+			".cjs",
+			".mjs",
+			".ts",
+			".cts",
+			".mts",
+			".json"
+		]
+	}).import(filePath, { default: true });
+}
+function resolveConfig(config) {
+	return {
+		root: config.root ?? ArchicatDefaults.root,
+		outDir: config.outDir ?? ArchicatDefaults.outDir,
+		typescript: resolveTypeScriptConfig(config),
+		alias: {
+			...ArchicatDefaults.alias,
+			...config.alias ?? {}
+		},
+		modules: resolveModulesConfig(config.modules),
+		libraries: resolveLibrariesConfig(config.libraries),
+		apps: resolveAppsConfig(config.apps)
+	};
+}
+function resolveTypeScriptConfig(config) {
+	const tsConfig = config.typescript?.tsConfig;
+	const defaults = ArchicatDefaults.typescript.tsConfig;
+	const resolvedTsConfig = {
+		include: [...tsConfig?.include ?? defaults.include],
+		exclude: [...tsConfig?.exclude ?? defaults.exclude],
+		files: [...tsConfig?.files ?? defaults.files]
+	};
+	if (tsConfig?.extends) resolvedTsConfig.extends = tsConfig.extends;
+	return { tsConfig: resolvedTsConfig };
+}
+function resolveModulesConfig(config) {
+	return {
+		include: [...config?.include ?? ArchicatDefaults.modules.include],
+		alias: config?.alias ?? ArchicatDefaults.modules.alias
+	};
+}
+function resolveLibrariesConfig(config) {
+	return {
+		include: [...config?.include ?? ArchicatDefaults.libraries.include],
+		alias: config?.alias ?? ArchicatDefaults.libraries.alias
+	};
+}
+function resolveAppsConfig(config) {
+	return { include: [...config?.include ?? ArchicatDefaults.apps.include] };
+}
+function resolveTsconfigPath(rootDir, configuredExtends) {
+	if (!configuredExtends) return;
+	return resolveProjectTsconfig(rootDir, configuredExtends);
+}
+function assertArchicatConfig(input, filePath) {
+	if (input == null || typeof input !== "object") throw new Error(`Invalid Archicat config: ${filePath}`);
+	const config = input;
+	assertOptionalNonEmptyString$1(config.root, "root", filePath);
+	assertOptionalNonEmptyString$1(config.outDir, "outDir", filePath);
+	assertOptionalObject(config.typescript, "typescript", filePath);
+	assertOptionalObject(config.modules, "modules", filePath);
+	assertOptionalObject(config.libraries, "libraries", filePath);
+	assertOptionalObject(config.apps, "apps", filePath);
+	assertOptionalTsConfig(config.typescript?.tsConfig, filePath);
+	assertOptionalInclude(config.modules?.include, "modules.include", filePath);
+	assertOptionalInclude(config.libraries?.include, "libraries.include", filePath);
+	assertOptionalInclude(config.apps?.include, "apps.include", filePath);
+	assertOptionalImportAlias(config.modules?.alias, "modules.alias", filePath);
+	assertOptionalImportAlias(config.libraries?.alias, "libraries.alias", filePath);
+	assertOptionalAlias(config.alias, "alias", filePath);
+}
+function assertOptionalTsConfig(value, filePath) {
+	if (value === void 0) return;
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new Error(`Archicat config typescript.tsConfig must be an object: ${filePath}`);
+	const config = value;
+	assertOptionalNonEmptyString$1(config.extends, "typescript.tsConfig.extends", filePath);
+	assertOptionalInclude(config.include, "typescript.tsConfig.include", filePath);
+	assertOptionalInclude(config.exclude, "typescript.tsConfig.exclude", filePath);
+	assertOptionalInclude(config.files, "typescript.tsConfig.files", filePath);
+	assertNoUnsupportedCompilerOptions(config.compilerOptions, filePath);
+}
+function assertNoUnsupportedCompilerOptions(value, filePath) {
+	if (value === void 0) return;
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new Error(`Archicat config typescript.tsConfig.compilerOptions must be an object: ${filePath}`);
+	const compilerOptions = value;
+	if (Object.hasOwn(compilerOptions, "paths")) throw new Error("Archicat config typescript.tsConfig.compilerOptions.paths is not supported. Move aliases into archicat.config.ts alias.");
+	if (Object.hasOwn(compilerOptions, "baseUrl")) throw new Error("Archicat config typescript.tsConfig.compilerOptions.baseUrl is not supported. Move aliases into archicat.config.ts alias.");
+	if (Object.keys(compilerOptions).length > 0) throw new Error("Archicat config typescript.tsConfig.compilerOptions is not supported. Put compiler options in the base or app tsconfig.");
+}
+function assertOptionalNonEmptyString$1(value, key, filePath) {
+	if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) throw new Error(`Archicat ${key} must be a non-empty string when defined: ${filePath}`);
+}
+function assertOptionalInclude(value, key, filePath) {
+	if (value !== void 0 && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim() === ""))) throw new Error(`Archicat config ${key} must be an array of non-empty strings: ${filePath}`);
+}
+function assertOptionalImportAlias(value, key, filePath) {
+	if (value === void 0) return;
+	if (typeof value !== "string" || value.trim() === "" || value.includes("*") || value.endsWith("/")) throw new Error(`Archicat config ${key} must be a non-empty alias without wildcard or trailing slash: ${filePath}`);
+}
+function assertOptionalAlias(value, key, filePath) {
+	if (value === void 0) return;
+	if (value == null || typeof value !== "object" || Array.isArray(value)) throw new Error(`Archicat config ${key} must be an object of non-empty string aliases: ${filePath}`);
+	for (const [alias, target] of Object.entries(value)) if (alias.trim() === "" || typeof target !== "string" || target.trim() === "") throw new Error(`Archicat config ${key} must contain non-empty string aliases: ${filePath}`);
+}
+function assertOptionalObject(value, key, filePath) {
+	if (value !== void 0 && (value == null || typeof value !== "object" || Array.isArray(value))) throw new Error(`Archicat config ${key} must be an object: ${filePath}`);
+}
+function assertDistinctReservedAliases(moduleAlias, libraryAlias, filePath) {
+	if (moduleAlias === libraryAlias || moduleAlias.startsWith(`${libraryAlias}/`) || libraryAlias.startsWith(`${moduleAlias}/`)) throw new Error(`Archicat module and library aliases must use separate roots: "${moduleAlias}" and "${libraryAlias}" (${filePath})`);
+}
+
+//#endregion
+//#region src-internal/path/path-utils.ts
+function normalizePath(value) {
+	return value.split(path.sep).join("/");
+}
+function toPosixRelativeImport(fromFilePath, targetFilePath) {
+	const fromDir = path.dirname(fromFilePath);
+	const parsedTarget = path.parse(targetFilePath);
+	const targetWithoutExtension = path.join(parsedTarget.dir, parsedTarget.name);
+	let relative = normalizePath(path.relative(fromDir, targetWithoutExtension));
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return `${relative}.js`;
+}
+function isPathInside(childPath, parentPath) {
+	const relative = path.relative(parentPath, childPath);
+	return relative === "" || !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function assertSafeGeneratedDirectory(rootDir, directoryPath) {
+	const root = resolvePhysicalPath(rootDir);
+	const directory = resolvePhysicalPath(directoryPath);
+	if (directory === root || !isPathInside(directory, root)) throw new Error(`Archicat outDir must be a directory inside the project root: ${directoryPath}`);
+}
+function resolvePhysicalPath(filePath) {
+	const absolutePath = path.resolve(filePath);
+	const missing = [];
+	let currentPath = absolutePath;
+	while (!fs.existsSync(currentPath)) {
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) return absolutePath;
+		missing.unshift(path.basename(currentPath));
+		currentPath = parentPath;
+	}
+	return path.join(fs.realpathSync(currentPath), ...missing);
+}
+function stripKnownExtension(filePath) {
+	return filePath.replace(/\.(?:js|mjs|cjs|ts|mts|cts|tsx)$/u, "");
+}
+function makeRelativeDisplayPath(rootDir, filePath) {
+	return normalizePath(path.relative(rootDir, filePath));
+}
+
+//#endregion
+//#region src-internal/definitions/discover-definition-files.ts
+function discoverDefinitionFiles(rootDir, includes, markerFileName, excludedRootPaths = []) {
+	const files = includes.flatMap((include) => expandInclude(rootDir, include, markerFileName, excludedRootPaths));
+	return Array.from(new Set(files)).sort((a, b) => a.localeCompare(b));
+}
+function expandInclude(rootDir, include, markerFileName, excludedRootPaths) {
+	const resolved = path.resolve(rootDir, include);
+	if (include.includes("*")) return expandSingleStarPattern(rootDir, include).filter((filePath) => !excludedRootPaths.some((excludedRootPath) => isPathInside(filePath, excludedRootPath))).filter((filePath) => path.basename(filePath) === markerFileName);
+	if (!fs.existsSync(resolved)) return [];
+	const stat = fs.statSync(resolved);
+	if (stat.isFile()) return path.basename(resolved) === markerFileName ? [resolved] : [];
+	if (!stat.isDirectory()) return [];
+	return findMarkerFiles(resolved, markerFileName, excludedRootPaths);
+}
+function findMarkerFiles(rootPath, markerFileName, excludedRootPaths) {
+	const result = [];
+	const entries = fs.readdirSync(rootPath, { withFileTypes: true });
+	for (const entry of entries) {
+		if (shouldSkip(entry.name)) continue;
+		const entryPath = path.join(rootPath, entry.name);
+		if (excludedRootPaths.some((excludedRootPath) => isPathInside(entryPath, excludedRootPath))) continue;
+		if (entry.isDirectory()) {
+			result.push(...findMarkerFiles(entryPath, markerFileName, excludedRootPaths));
+			continue;
+		}
+		if (entry.isFile() && entry.name === markerFileName) result.push(entryPath);
+	}
+	return result;
+}
+function expandSingleStarPattern(rootDir, pattern) {
+	const parts = path.resolve(rootDir, pattern).split(path.sep);
+	if (parts.filter((part) => part.includes("*")).length !== 1) throw new Error(`Archicat supports exactly one wildcard segment per include pattern: ${pattern}`);
+	const starIndex = parts.findIndex((part) => part.includes("*"));
+	const beforeStar = parts.slice(0, starIndex).join(path.sep) || path.sep;
+	const wildcard = parts[starIndex] ?? "*";
+	const afterStar = parts.slice(starIndex + 1);
+	const regexp = makeWildcardRegExp(wildcard);
+	if (!fs.existsSync(beforeStar)) return [];
+	return fs.readdirSync(beforeStar, { withFileTypes: true }).filter((entry) => entry.isDirectory()).filter((entry) => regexp.test(entry.name)).map((entry) => path.join(beforeStar, entry.name, ...afterStar)).filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+}
+function makeWildcardRegExp(pattern) {
+	const escaped = pattern.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replace(/\*/gu, ".*");
+	return new RegExp(`^${escaped}$`, "u");
+}
+function shouldSkip(name) {
+	return ArchicatDefaults.generated.ignoredDirectoryNames.includes(name);
+}
+
+//#endregion
+//#region src-internal/definitions/load-definition.ts
+async function loadArchicatDefinition(filePath, kind) {
+	switch (kind) {
+		case "module": return loadArchicatModule(filePath);
+		case "library": return loadArchicatLibrary(filePath);
+		case "app": return loadArchicatApp(filePath);
+	}
+}
+async function loadArchicatModule(filePath) {
+	const contract = await importDefault(filePath, path.dirname(filePath));
+	assertArchicatDefinition(contract, filePath, "module");
+	return {
+		kind: "module",
+		contractFilePath: filePath,
+		definitionDir: path.dirname(filePath),
+		contract
+	};
+}
+async function loadArchicatLibrary(filePath) {
+	const contract = await importDefault(filePath, path.dirname(filePath));
+	assertArchicatDefinition(contract, filePath, "library");
+	return {
+		kind: "library",
+		contractFilePath: filePath,
+		definitionDir: path.dirname(filePath),
+		contract
+	};
+}
+async function loadArchicatApp(filePath) {
+	const contract = await importDefault(filePath, path.dirname(filePath));
+	assertArchicatDefinition(contract, filePath, "app");
+	return {
+		kind: "app",
+		contractFilePath: filePath,
+		definitionDir: path.dirname(filePath),
+		contract
+	};
+}
+async function importDefault(filePath, rootDir) {
+	return await createJiti(rootDir, {
+		interopDefault: true,
+		extensions: [
+			".js",
+			".cjs",
+			".mjs",
+			".ts",
+			".cts",
+			".mts",
+			".json"
+		]
+	}).import(filePath, { default: true });
+}
+function assertArchicatDefinition(input, filePath, expectedKind) {
+	if (input == null || typeof input !== "object") throw new Error(`Invalid Archicat ${expectedKind} definition: ${filePath}`);
+	const definition = input;
+	if (definition.kind !== expectedKind) throw new Error(`Archicat ${expectedKind} file must export a ${expectedKind} definition: ${filePath}`);
+	if (typeof definition.name !== "string" || definition.name.trim() === "") throw new Error(`Archicat ${expectedKind} must define a non-empty name: ${filePath}`);
+	if (expectedKind === "app") {
+		assertOptionalNonEmptyString(definition.root, "root", filePath);
+		assertDependencyArray(definition.dependencies, filePath, expectedKind);
+		return;
+	}
+	const surfaced = definition;
+	assertSurface(surfaced.api, "api", filePath, expectedKind);
+	assertSurface(surfaced.impl, "impl", filePath, expectedKind);
+}
+function assertSurface(surface, surfaceName, filePath, definitionKind) {
+	if (surface == null || typeof surface !== "object") throw new Error(`Archicat ${definitionKind}.${surfaceName} must be a surface object: ${filePath}`);
+	assertOptionalNonEmptyString(surface.root, `${surfaceName}.root`, filePath);
+	assertDependencyArray(surface.dependencies, filePath, `${definitionKind}.${surfaceName}`);
+}
+function assertDependencyArray(value, filePath, owner) {
+	if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string" || entry.trim() === "")) throw new Error(`Archicat ${owner} dependencies must be an array of non-empty strings: ${filePath}`);
+}
+function assertOptionalNonEmptyString(value, key, filePath) {
+	if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) throw new Error(`Archicat ${key} must be a non-empty string when defined: ${filePath}`);
+}
+
+//#endregion
+//#region src-internal/dependency-graph/detect-dependency-cycles.ts
+function assertNoDependencyCycles(dependencies) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const dependency of dependencies) {
+		const targets = graph.get(dependency.from) ?? [];
+		targets.push(dependency.to);
+		graph.set(dependency.from, targets);
+	}
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	for (const node of graph.keys()) visit(node, graph, visiting, visited, []);
+}
+function visit(node, graph, visiting, visited, stack) {
+	if (visited.has(node)) return;
+	if (visiting.has(node)) {
+		const cycleStart = stack.indexOf(node);
+		const cycle = [...stack.slice(cycleStart < 0 ? 0 : cycleStart), node];
+		throw new Error(`Cyclic Archicat dependency detected: ${cycle.join(" -> ")}`);
+	}
+	visiting.add(node);
+	for (const target of graph.get(node) ?? []) visit(target, graph, visiting, visited, [...stack, node]);
+	visiting.delete(node);
+	visited.add(node);
+}
+
+//#endregion
+//#region src-internal/dependency-graph/parse-dependency-target.ts
+function parseDependencyTarget(target) {
+	const match = /^(module|library)\.([a-z][a-z0-9-]*)\.(api|impl)$/u.exec(target);
+	if (!match) return;
+	return {
+		kind: match[1],
+		name: match[2],
+		surface: match[3]
+	};
+}
+
+//#endregion
+//#region src-internal/dependency-graph/validate-dependency-rules.ts
+function validateDeclaredDependency(owner, dependency, knownTargets) {
+	const target = parseDependencyTarget(dependency);
+	if (!target) throw new Error(`${formatOwner$1(owner)} declares invalid dependency target "${dependency}".`);
+	if (!knownTargets.has(dependency)) throw new Error(`${formatOwner$1(owner)} declares unknown dependency "${dependency}".`);
+	if (owner.target === dependency) throw new Error(`${formatOwner$1(owner)} cannot depend on itself: ${dependency}`);
+	if (owner.surface === "api" && target.surface === "impl") throw new Error(`${formatOwner$1(owner)} cannot depend on implementation target "${dependency}" from an API surface.`);
+}
+function formatOwner$1(owner) {
+	if (owner.kind === "app") return `App "${owner.name}"`;
+	return `${capitalize$2(owner.kind)} "${owner.name}" ${owner.surface}`;
+}
+function capitalize$2(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+
+//#endregion
+//#region src-internal/resolver/resolve-project.ts
+function resolveArchicatProject(loadedConfig, loadedDefinitions) {
+	const modules = loadedDefinitions.filter((definition) => definition.kind === "module").map((definition) => resolveModule(loadedConfig, definition));
+	const libraries = loadedDefinitions.filter((definition) => definition.kind === "library").map((definition) => resolveLibrary(loadedConfig, definition));
+	const apps = loadedDefinitions.filter((definition) => definition.kind === "app").map((definition) => resolveApp(definition));
+	const definitions = [...modules, ...libraries];
+	assertUniqueDefinitionNames([...definitions, ...apps]);
+	const graph = buildGraph(definitions, apps);
+	assertDependencyReferences(definitions, apps, graph.targets);
+	assertNoDependencyCycles(graph.dependencies);
+	return {
+		rootDir: loadedConfig.rootDir,
+		outDir: loadedConfig.outDir,
+		reportsDir: loadedConfig.reportsDir,
+		...loadedConfig.tsconfigPath ? { tsconfigPath: loadedConfig.tsconfigPath } : {},
+		configFilePath: loadedConfig.configFilePath,
+		config: loadedConfig.resolvedConfig,
+		modules,
+		libraries,
+		apps,
+		definitions,
+		graph
+	};
+}
+function resolveModule(loadedConfig, loadedModule) {
+	const { contract, contractFilePath, definitionDir } = loadedModule;
+	assertValidName(contract.name, contractFilePath, "module");
+	const apiRootPath = contract.api.root ? resolveDeclaredRoot(definitionDir, contract.api.root, "api", contract.name) : void 0;
+	const implRootPath = contract.impl.root ? resolveDeclaredRoot(definitionDir, contract.impl.root, "impl", contract.name) : void 0;
+	const aliasBase = `${loadedConfig.resolvedConfig.modules.alias}/${contract.name}`;
+	const apiAlias = `${aliasBase}/api`;
+	const implAlias = `${aliasBase}/impl`;
+	return {
+		kind: "module",
+		name: contract.name,
+		apiTarget: `module.${contract.name}.api`,
+		implTarget: `module.${contract.name}.impl`,
+		alias: apiAlias,
+		aliasGlob: `${apiAlias}/*`,
+		implAlias,
+		implAliasGlob: `${implAlias}/*`,
+		contractFilePath,
+		definitionDir,
+		api: resolveSurface(apiRootPath, contract.api.dependencies, path.join(loadedConfig.outDir, ArchicatDefaults.generated.modulesDirName, contract.name, "api")),
+		impl: resolveSurface(implRootPath, contract.impl.dependencies, path.join(loadedConfig.outDir, ArchicatDefaults.generated.modulesDirName, contract.name, "impl"))
+	};
+}
+function resolveLibrary(loadedConfig, loadedLibrary) {
+	const { contract, contractFilePath, definitionDir } = loadedLibrary;
+	assertValidName(contract.name, contractFilePath, "library");
+	const apiRootPath = contract.api.root ? resolveDeclaredRoot(definitionDir, contract.api.root, "api", contract.name) : void 0;
+	const implRootPath = contract.impl.root ? resolveDeclaredRoot(definitionDir, contract.impl.root, "impl", contract.name) : void 0;
+	const aliasBase = `${loadedConfig.resolvedConfig.libraries.alias}/${contract.name}`;
+	const apiAlias = `${aliasBase}/api`;
+	const implAlias = `${aliasBase}/impl`;
+	return {
+		kind: "library",
+		name: contract.name,
+		apiTarget: `library.${contract.name}.api`,
+		implTarget: `library.${contract.name}.impl`,
+		alias: apiAlias,
+		aliasGlob: `${apiAlias}/*`,
+		implAlias,
+		implAliasGlob: `${implAlias}/*`,
+		contractFilePath,
+		definitionDir,
+		api: resolveSurface(apiRootPath, contract.api.dependencies, path.join(loadedConfig.outDir, ArchicatDefaults.generated.librariesDirName, contract.name, "api")),
+		impl: resolveSurface(implRootPath, contract.impl.dependencies, path.join(loadedConfig.outDir, ArchicatDefaults.generated.librariesDirName, contract.name, "impl"))
+	};
+}
+function resolveApp(loadedApp) {
+	const { contract, contractFilePath, definitionDir } = loadedApp;
+	assertValidName(contract.name, contractFilePath, "app");
+	return {
+		kind: "app",
+		name: contract.name,
+		target: `app.${contract.name}`,
+		contractFilePath,
+		rootPath: contract.root ? resolveDeclaredRoot(definitionDir, contract.root, "app", contract.name) : definitionDir,
+		dependencies: [...contract.dependencies]
+	};
+}
+function resolveSurface(rootPath, dependencies, mirrorRootPath) {
+	return {
+		...rootPath ? { rootPath } : {},
+		mirrorRootPath,
+		dependencies: [...dependencies]
+	};
+}
+function resolveDeclaredRoot(definitionDir, relativeRoot, kind, name) {
+	const resolved = path.resolve(definitionDir, relativeRoot);
+	if (!fs.existsSync(resolved)) throw new Error(`Definition "${name}" declares ${kind} root that does not exist: ${resolved}`);
+	if (!fs.statSync(resolved).isDirectory()) throw new Error(`Definition "${name}" declares ${kind} root that is not a directory: ${resolved}`);
+	return resolved;
+}
+function buildGraph(definitions, apps) {
+	const targets = definitions.flatMap((definition) => [{
+		key: definition.apiTarget,
+		surface: "api"
+	}, {
+		key: definition.implTarget,
+		surface: "impl"
+	}]);
+	const declaredDependencies = [...definitions.flatMap((definition) => [...definition.api.dependencies.map((dependency) => ({
+		from: definition.apiTarget,
+		to: dependency,
+		origin: "declared"
+	})), ...definition.impl.dependencies.map((dependency) => ({
+		from: definition.implTarget,
+		to: dependency,
+		origin: "declared"
+	}))]), ...apps.flatMap((app) => app.dependencies.map((dependency) => ({
+		from: app.target,
+		to: dependency,
+		origin: "declared"
+	})))];
+	return {
+		targets,
+		dependencies: [...definitions.map((definition) => ({
+			from: definition.implTarget,
+			to: definition.apiTarget,
+			origin: "derived"
+		})), ...declaredDependencies]
+	};
+}
+function assertValidName(name, filePath, kind) {
+	if (!/^[a-z][a-z0-9-]*$/u.test(name)) throw new Error(`Invalid Archicat ${kind} name "${name}" in ${filePath}. Use ^[a-z][a-z0-9-]*$`);
+}
+function assertUniqueDefinitionNames(definitions) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		const key = `${definition.kind}.${definition.name}`;
+		const current = seen.get(key);
+		if (current) throw new Error(`Duplicate Archicat ${definition.kind} name "${definition.name}" in ${current} and ${definition.contractFilePath}`);
+		seen.set(key, definition.contractFilePath);
+	}
+}
+function assertDependencyReferences(definitions, apps, targets) {
+	const targetKeys = new Set(targets.map((target) => target.key));
+	for (const definition of definitions) {
+		for (const dependency of definition.api.dependencies) validateDeclaredDependency(makeOwner(definition, "api"), dependency, targetKeys);
+		for (const dependency of definition.impl.dependencies) validateDeclaredDependency(makeOwner(definition, "impl"), dependency, targetKeys);
+	}
+	for (const app of apps) for (const dependency of app.dependencies) validateDeclaredDependency({
+		kind: "app",
+		name: app.name,
+		surface: "app",
+		target: app.target
+	}, dependency, targetKeys);
+}
+function makeOwner(definition, surface) {
+	return {
+		kind: definition.kind,
+		name: definition.name,
+		surface,
+		target: surface === "api" ? definition.apiTarget : definition.implTarget
+	};
+}
+
+//#endregion
+//#region src-internal/context/load-project.ts
+async function loadArchicatProject(cwd, configFileName) {
+	const loadedConfig = await loadArchicatConfig(cwd, configFileName);
+	const moduleFiles = discoverDefinitionFiles(loadedConfig.rootDir, loadedConfig.resolvedConfig.modules.include, ArchicatDefaults.definitions.moduleFileName, [loadedConfig.outDir]);
+	const libraryFiles = discoverDefinitionFiles(loadedConfig.rootDir, loadedConfig.resolvedConfig.libraries.include, ArchicatDefaults.definitions.libraryFileName, [loadedConfig.outDir]);
+	const appFiles = discoverDefinitionFiles(loadedConfig.rootDir, loadedConfig.resolvedConfig.apps.include, ArchicatDefaults.definitions.appFileName, [loadedConfig.outDir]);
+	if (moduleFiles.length === 0 && libraryFiles.length === 0 && appFiles.length === 0) throw new Error("No Archicat definition files matched configured include roots.");
+	const loadedDefinitions = [
+		...await Promise.all(moduleFiles.map((file) => loadArchicatDefinition(file, "module"))),
+		...await Promise.all(libraryFiles.map((file) => loadArchicatDefinition(file, "library"))),
+		...await Promise.all(appFiles.map((file) => loadArchicatDefinition(file, "app")))
+	];
+	return resolveArchicatProject(loadedConfig, loadedDefinitions);
+}
+
+//#endregion
+//#region src-internal/graph/format-project-graph.ts
+function formatProjectGraph(project) {
+	const lines = [];
+	pushSection(lines, "Modules", project.modules.length, project.modules, project.graph.dependencies);
+	pushSection(lines, "Libraries", project.libraries.length, project.libraries, project.graph.dependencies);
+	lines.push(`Apps: ${project.apps.length}`);
+	if (project.apps.length > 0) lines.push("");
+	for (const app of project.apps) {
+		lines.push(app.name);
+		lines.push(`  app: ${app.target}`);
+		pushDependencies(lines, project.graph.dependencies.filter((dependency) => dependency.from === app.target), "  dependsOn");
+		lines.push("");
+	}
+	return trimTrailingEmptyLines(lines);
+}
+function pushSection(lines, title, count, definitions, dependencies) {
+	lines.push(`${title}: ${count}`);
+	if (definitions.length > 0) lines.push("");
+	for (const definition of definitions) {
+		lines.push(definition.name);
+		lines.push(`  api: ${definition.apiTarget}`);
+		pushDependencies(lines, dependencies.filter((dependency) => dependency.from === definition.apiTarget), "  api dependsOn");
+		lines.push(`  impl: ${definition.implTarget}`);
+		pushDependencies(lines, dependencies.filter((dependency) => dependency.from === definition.implTarget), "  impl dependsOn");
+		lines.push("");
+	}
+}
+function pushDependencies(lines, dependencies, label) {
+	if (dependencies.length === 0) {
+		lines.push(`${label}: none`);
+		return;
+	}
+	lines.push(`${label}:`);
+	for (const dependency of dependencies) {
+		const suffix = dependency.origin === "derived" ? " (derived)" : "";
+		lines.push(`    ${dependency.to}${suffix}`);
+	}
+}
+function trimTrailingEmptyLines(lines) {
+	while (lines.at(-1) === "") lines.pop();
+	return lines;
+}
+
+//#endregion
+//#region src-cli/commands/run-graph-command.ts
+async function runGraphCommand(options, cwd) {
+	const project = await loadArchicatProject(cwd, options.config);
+	return {
+		exitCode: 0,
+		lines: formatProjectGraph(project).map((message) => ({
+			kind: "info",
+			message
+		}))
+	};
+}
+
+//#endregion
+//#region src-cli/output/cli-output.ts
+var CliOutput = class {
+	log(message) {
+		consola.log(message);
+	}
+	info(message) {
+		consola.info(message);
+	}
+	success(message) {
+		consola.success(message);
+	}
+	warning(message) {
+		consola.warn(message);
+	}
+	error(message) {
+		consola.error(message);
+	}
+	emptyLine() {
+		consola.log("");
+	}
+	title(product, command, rows = []) {
+		consola.log([`${product} ${command}`, ...formatRows(rows)].join("\n"));
+	}
+	panel(title, rows, badge) {
+		const heading = badge === void 0 ? title : `${title} (${badge})`;
+		consola.log([heading, ...formatRows(rows)].join("\n"));
+	}
+	step(label, message) {
+		return `${label}: ${message}`;
+	}
+	duration(milliseconds) {
+		if (milliseconds < 1e3) return `${milliseconds}ms`;
+		const seconds = milliseconds / 1e3;
+		return `${seconds.toFixed(seconds < 10 ? 2 : 1)}s`;
+	}
+};
+function formatRows(rows) {
+	if (rows.length === 0) return [];
+	const width = Math.max(...rows.map((row) => row.label.length));
+	return rows.map((row) => `  ${row.label.padEnd(width)}  ${String(row.value)}`);
+}
+
+//#endregion
+//#region src-internal/doctor/doctor.ts
+function doctorProject(project) {
+	return checkPhysicalOmissions(project);
+}
+function checkPhysicalOmissions(project) {
+	const issues = [];
+	for (const definition of project.definitions) {
+		const apiPath = path.join(definition.definitionDir, "api");
+		const implPath = path.join(definition.definitionDir, "impl");
+		if (!definition.api.rootPath && fs.existsSync(apiPath)) issues.push(`${capitalize$1(definition.kind)} "${definition.name}" has a physical api directory but its contract omits api.root. Archicat treats the public API as empty.`);
+		if (!definition.impl.rootPath && fs.existsSync(implPath)) issues.push(`${capitalize$1(definition.kind)} "${definition.name}" has a physical impl directory but its contract omits impl.root. Archicat treats the implementation as no-op.`);
+	}
+	return issues;
+}
+function capitalize$1(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+
+//#endregion
+//#region src-internal/generator/file-writer.ts
+function resetDirectory(rootDir, directoryPath) {
+	assertSafeGeneratedDirectory(rootDir, directoryPath);
+	assertReplaceableDirectory(rootDir, directoryPath);
+	fs.rmSync(directoryPath, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(directoryPath, { recursive: true });
+}
+function writeTextFile(filePath, content) {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, content, "utf8");
+}
+function writeJsonFile(filePath, value) {
+	writeTextFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+function assertReplaceableDirectory(rootDir, directoryPath) {
+	if (!fs.existsSync(directoryPath) || fs.readdirSync(directoryPath).length === 0) return;
+	if (isOwnedGeneratedDirectory(rootDir, directoryPath)) return;
+	throw new Error(`Archicat refuses to replace a non-owned outDir: ${directoryPath}`);
+}
+function isOwnedGeneratedDirectory(rootDir, directoryPath) {
+	const reportPath = path.join(directoryPath, ArchicatDefaults.generated.reportsDirName, ArchicatDefaults.generated.buildReportFileName);
+	if (!fs.existsSync(reportPath)) return false;
+	try {
+		const report = JSON.parse(fs.readFileSync(reportPath, "utf8"));
+		return report.generatedBy === "archicat" && report.schemaVersion === 2 && typeof report.outputs?.outDir === "string" && path.resolve(rootDir, report.outputs.outDir) === path.resolve(directoryPath);
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src-internal/generator/generate-graph-types.ts
+function generateGraphTypes(project) {
+	const allTargets = project.graph.targets.map((target) => target.key);
+	const apiTargets = project.graph.targets.filter((target) => target.surface === "api").map((target) => target.key);
+	const packageName = ArchicatDefaults.packageName;
+	const content = `import '${packageName}';
+
+declare module '${packageName}' {
+${renderInterface("ArchicatModuleApiDependencies", apiTargets)}
 
-${B(`ArchicatLibraryApiDependencies`,n)}
+${renderInterface("ArchicatModuleImplDependencies", allTargets)}
 
-${B(`ArchicatLibraryImplDependencies`,t)}
+${renderInterface("ArchicatLibraryApiDependencies", apiTargets)}
 
-${B(`ArchicatAppDependencies`,t)}
+${renderInterface("ArchicatLibraryImplDependencies", allTargets)}
+
+${renderInterface("ArchicatAppDependencies", allTargets)}
 }
 
 export {};
-`;R(r.join(e.outDir,o.generated.typesDirName,`graph.d.ts`),a)}function B(e,t){return`  interface ${e} {\n${Array.from(new Set(t)).sort((e,t)=>e.localeCompare(t)).map(e=>`    '${e}': true;`).join(`
-`)}\n  }`}function V(e){return n.existsSync(e)?n.statSync(e).isFile()?H(e)?[e]:[]:U(e).filter(H).sort((e,t)=>e.localeCompare(t)):[]}function H(e){return/\.(?:ts|mts|cts|tsx)$/u.test(e)&&!/\.d\.(?:ts|mts|cts)$/u.test(e)}function U(e){let t=[],i=n.readdirSync(e,{withFileTypes:!0});for(let n of i){let i=r.join(e,n.name);if(n.isDirectory()){t.push(...U(i));continue}n.isFile()&&t.push(i)}return t}function ot(e){let t=i.createSourceFile(e,n.readFileSync(e,`utf8`),i.ScriptTarget.Latest,!0),r=[],a=e=>{if(i.isImportDeclaration(e)&&i.isStringLiteral(e.moduleSpecifier)&&r.push({moduleSpecifier:e.moduleSpecifier.text,kind:`import`}),i.isExportDeclaration(e)&&e.moduleSpecifier&&i.isStringLiteral(e.moduleSpecifier)&&r.push({moduleSpecifier:e.moduleSpecifier.text,kind:`export`}),i.isCallExpression(e)&&e.expression.kind===i.SyntaxKind.ImportKeyword){let[t]=e.arguments;t&&i.isStringLiteral(t)&&r.push({moduleSpecifier:t.text,kind:`dynamic-import`})}i.forEachChild(e,a)};return a(t),r}function st(e){let t=i.createSourceFile(e,n.readFileSync(e,`utf8`),i.ScriptTarget.Latest,!0),r=!1,a=e=>{if(!r){if(i.isExportAssignment(e)&&!e.isExportEquals){r=!0;return}if(ct(e)){r=!0;return}if(i.isExportDeclaration(e)&&e.exportClause&&i.isNamedExports(e.exportClause))for(let t of e.exportClause.elements){let e=t.name.text,n=t.propertyName?.text;if(e==="default"||n==="default"){r=!0;return}}i.forEachChild(e,a)}};return a(t),r}function ct(e){let t=i.canHaveModifiers(e)?i.getModifiers(e):void 0;if(!t)return!1;let n=t.some(e=>e.kind===i.SyntaxKind.ExportKeyword),r=t.some(e=>e.kind===i.SyntaxKind.DefaultKeyword);return n&&r}function lt(e){for(let t of e)ut(t.api),dt(t)}function ut(e){if(!e.rootPath){W(r.join(e.mirrorRootPath,`index.ts`));return}let t=new Set;for(let n of V(e.rootPath)){let i=v(r.relative(e.rootPath,n));t.add(i),G(r.join(e.mirrorRootPath,i),n)}t.has(`index.ts`)||W(r.join(e.mirrorRootPath,`index.ts`))}function dt(e){let t=e.impl.rootPath?ft(e.impl.rootPath):void 0;if(t){G(r.join(e.impl.mirrorRootPath,`index.ts`),t);return}let n=e.kind===`module`?`ArchicatModuleImplementation`:`ArchicatLibraryImplementation`,i=`${K()}
-export const ${n} = {
-  name: '${e.name}',
+`;
+	writeTextFile(path.join(project.outDir, ArchicatDefaults.generated.typesDirName, "graph.d.ts"), content);
+}
+function renderInterface(name, entries) {
+	return `  interface ${name} {\n${Array.from(new Set(entries)).sort((a, b) => a.localeCompare(b)).map((entry) => `    '${entry}': true;`).join("\n")}\n  }`;
+}
+
+//#endregion
+//#region src-internal/scanner/file-scanner.ts
+function listTypeScriptFiles(rootPath) {
+	if (!fs.existsSync(rootPath)) return [];
+	if (fs.statSync(rootPath).isFile()) return isTypeScriptSourceFile(rootPath) ? [rootPath] : [];
+	return walk(rootPath).filter(isTypeScriptSourceFile).sort((a, b) => a.localeCompare(b));
+}
+function isTypeScriptSourceFile(filePath) {
+	return /\.(?:ts|mts|cts|tsx)$/u.test(filePath) && !/\.d\.(?:ts|mts|cts)$/u.test(filePath);
+}
+function walk(rootPath) {
+	const result = [];
+	const entries = fs.readdirSync(rootPath, { withFileTypes: true });
+	for (const entry of entries) {
+		const entryPath = path.join(rootPath, entry.name);
+		if (entry.isDirectory()) {
+			result.push(...walk(entryPath));
+			continue;
+		}
+		if (entry.isFile()) result.push(entryPath);
+	}
+	return result;
+}
+
+//#endregion
+//#region src-internal/scanner/import-scanner.ts
+function scanImports(filePath) {
+	const source = ts.createSourceFile(filePath, fs.readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
+	const imports = [];
+	const visit = (node) => {
+		if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) imports.push({
+			moduleSpecifier: node.moduleSpecifier.text,
+			kind: "import"
+		});
+		if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) imports.push({
+			moduleSpecifier: node.moduleSpecifier.text,
+			kind: "export"
+		});
+		if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+			const [argument] = node.arguments;
+			if (argument && ts.isStringLiteral(argument)) imports.push({
+				moduleSpecifier: argument.text,
+				kind: "dynamic-import"
+			});
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return imports;
+}
+function hasDefaultExport(filePath) {
+	const source = ts.createSourceFile(filePath, fs.readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
+	let found = false;
+	const visit = (node) => {
+		if (found) return;
+		if (ts.isExportAssignment(node) && !node.isExportEquals) {
+			found = true;
+			return;
+		}
+		if (hasExportDefaultModifiers(node)) {
+			found = true;
+			return;
+		}
+		if (ts.isExportDeclaration(node) && node.exportClause && ts.isNamedExports(node.exportClause)) for (const element of node.exportClause.elements) {
+			const exportedName = element.name.text;
+			const sourceName = element.propertyName?.text;
+			if (exportedName === "default" || sourceName === "default") {
+				found = true;
+				return;
+			}
+		}
+		ts.forEachChild(node, visit);
+	};
+	visit(source);
+	return found;
+}
+function hasExportDefaultModifiers(node) {
+	const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+	if (!modifiers) return false;
+	const hasExport = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+	const hasDefault = modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+	return hasExport && hasDefault;
+}
+
+//#endregion
+//#region src-internal/generator/generate-mirrors.ts
+function generateMirrors(definitions) {
+	for (const definition of definitions) {
+		generateApiMirror(definition.api);
+		generateImplMirror(definition);
+	}
+}
+function generateApiMirror(surface) {
+	if (!surface.rootPath) {
+		writeEmptyMirror(path.join(surface.mirrorRootPath, "index.ts"));
+		return;
+	}
+	const mirroredPaths = /* @__PURE__ */ new Set();
+	for (const sourceFilePath of listTypeScriptFiles(surface.rootPath)) {
+		const relativePath = normalizePath(path.relative(surface.rootPath, sourceFilePath));
+		mirroredPaths.add(relativePath);
+		writeMirrorFile(path.join(surface.mirrorRootPath, relativePath), sourceFilePath);
+	}
+	if (!mirroredPaths.has("index.ts")) writeEmptyMirror(path.join(surface.mirrorRootPath, "index.ts"));
+}
+function generateImplMirror(definition) {
+	const indexPath = definition.impl.rootPath ? findIndexFile(definition.impl.rootPath) : void 0;
+	if (indexPath) {
+		writeMirrorFile(path.join(definition.impl.mirrorRootPath, "index.ts"), indexPath);
+		return;
+	}
+	const constName = definition.kind === "module" ? "ArchicatModuleImplementation" : "ArchicatLibraryImplementation";
+	const content = `${makeMirrorHeader()}
+export const ${constName} = {
+  name: '${definition.name}',
 } as const;
 
-export default ${n};
-`;R(r.join(e.impl.mirrorRootPath,`index.ts`),i)}function W(e){R(e,`${K()}export {};\n`)}function G(e,t){let n=he(e,t),r=st(t)?`export { default } from '${n}';\n`:``;R(e,`${K()}
-export * from '${n}';
-${r}`)}function ft(e){for(let t of[`index.ts`,`index.mts`,`index.cts`,`index.tsx`]){let i=r.join(e,t);if(n.existsSync(i)&&n.statSync(i).isFile())return i}}function K(){return`// Mirrored by Archicat.
-`}function pt(e){z(r.join(e.reportsDir,o.generated.buildReportFileName),mt(e)),z(r.join(e.reportsDir,o.generated.graphReportFileName),ht(e))}function mt(e){return{generatedBy:`archicat`,schemaVersion:2,aliases:{module:e.config.modules.alias,library:e.config.libraries.alias},outputs:{outDir:S(e.rootDir,e.outDir),reportsDir:S(e.rootDir,e.reportsDir)},targets:e.graph.targets.map(e=>e.key),definitions:[...e.definitions.map(t=>gt(e,t)),...e.apps.map(t=>({kind:t.kind,name:t.name,targets:{app:t.target},aliases:{},dependencies:t.dependencies,contractFilePath:S(e.rootDir,t.contractFilePath),source:{root:S(e.rootDir,t.rootPath)},mirror:{}}))],dependencies:e.graph.dependencies}}function ht(e){return{generatedBy:`archicat`,schemaVersion:1,targets:e.graph.targets.map(e=>e.key),dependencies:e.graph.dependencies}}function gt(e,t){return{kind:t.kind,name:t.name,targets:{api:t.apiTarget,impl:t.implTarget},aliases:{api:t.alias,impl:t.implAlias},dependencies:{api:t.api.dependencies,impl:t.impl.dependencies},contractFilePath:S(e.rootDir,t.contractFilePath),source:{root:S(e.rootDir,t.definitionDir),api:t.api.rootPath?S(e.rootDir,t.api.rootPath):void 0,impl:t.impl.rootPath?S(e.rootDir,t.impl.rootPath):void 0},mirror:{api:S(e.rootDir,t.api.mirrorRootPath),impl:S(e.rootDir,t.impl.mirrorRootPath)}}}function _t(e){Dt(e.tsconfigPath),z(r.join(e.outDir,o.generated.tsconfigFileName),vt(e))}function vt(e){let t={compilerOptions:yt(e),include:xt(e)},n=bt(e),r=St(e),i=Ct(e);return n&&(t.extends=n),r.length>0&&(t.exclude=r),i.length>0&&(t.files=i),t}function yt(e){let t=Tt(e),n=wt(e);return jt(e,t,n),{paths:{...t,...n}}}function bt(e){return e.tsconfigPath?J(e.outDir,e.tsconfigPath):void 0}function xt(e){return Et([...q(e,e.config.typescript.tsConfig.include),o.generated.typesInclude])}function St(e){return q(e,e.config.typescript.tsConfig.exclude)}function Ct(e){return q(e,e.config.typescript.tsConfig.files)}function wt(e){let t={};for(let n of e.definitions)n.api.rootPath&&(t[n.aliasGlob]=[J(e.outDir,r.join(n.api.rootPath,`*`))]),n.impl.rootPath&&(t[n.implAliasGlob]=[J(e.outDir,r.join(n.impl.rootPath,`*`))]);return t}function Tt(e){let t={};for(let[n,i]of Object.entries(e.config.alias)){let a=r.isAbsolute(i)?i:r.resolve(e.rootDir,i);t[n]=[J(e.outDir,a)]}return t}function q(e,t){return t.map(t=>{let n=r.isAbsolute(t)?t:r.resolve(e.rootDir,t);return J(e.outDir,n)})}function J(e,t){let n=v(r.relative(e,t));return n.startsWith(`.`)||(n=`./${n}`),n}function Et(e){return[...new Set(e)]}function Dt(e){e&&Ot(e,new Set,new Set)}function Ot(e,t,n){let i=r.resolve(e);if(n.has(i))return;if(t.has(i))throw Error(`Circular tsconfig extends chain detected: ${i}`);t.add(i);let a=s(i),o=c(a,i);kt(o,i),At(o,i);for(let e of l(a,i))Ot(e,t,n);t.delete(i),n.add(i)}function kt(e,t){if(Object.hasOwn(e,`paths`))throw Error(`Base tsconfig compilerOptions.paths is not supported by Archicat. Move aliases into archicat.config.ts alias: ${t}`)}function At(e,t){if(Object.hasOwn(e,`baseUrl`))throw Error(`Base tsconfig compilerOptions.baseUrl is not supported by Archicat. Move aliases into archicat.config.ts alias: ${t}`)}function jt(e,t,n){let r=Object.keys(t),i=Object.keys(n),a=[e.config.modules.alias,e.config.libraries.alias];for(let e of r){if(i.includes(e))throw Error(`Alias conflict: archicat.config.ts alias already defines "${e}", but Archicat needs it.`);for(let t of a)if(e===t||e===`${t}/*`||e.startsWith(`${t}/`))throw Error(`Alias conflict: archicat.config.ts alias "${e}" is inside Archicat reserved alias "${t}". Remove the alias or configure another module/library alias.`)}}function Mt(e){nt(e.rootDir,e.outDir),n.mkdirSync(r.join(e.outDir,o.generated.modulesDirName),{recursive:!0}),n.mkdirSync(r.join(e.outDir,o.generated.librariesDirName),{recursive:!0}),n.mkdirSync(r.join(e.outDir,o.generated.typesDirName),{recursive:!0}),n.mkdirSync(e.reportsDir,{recursive:!0}),lt(e.definitions),at(e),_t(e),pt(e)}function Nt(e){let t=Bt(e.graph.dependencies),n=[],r=[...e.definitions.flatMap(e=>[...e.api.rootPath?V(e.api.rootPath):[],...e.impl.rootPath?V(e.impl.rootPath):[]]),...e.apps.flatMap(e=>V(e.rootPath))];for(let i of r){let r=It(e,i);if(r)for(let a of ot(i)){let o=Ft(e,t,r,i,a.moduleSpecifier);o&&n.push(o)}}return n}function Pt(e){return`${e.filePath}\n  import: ${e.importPath}\n  ${e.message}`}function Ft(e,t,n,r,i){let a=Rt(e,i);if(a)return Y(e,r,i,`Unsupported Archicat alias "${i}". Use an explicit file import under "${a.apiAlias}/*" or "${a.implAlias}/*".`);let o=Lt(e,i);if(o)return zt(n,o)||Vt(t,n.target,o.target)?void 0:Y(e,r,i,`${X(n)} imports "${o.target}" but does not declare a dependency that allows it.`);if(!i.startsWith(`.`)&&!i.startsWith(`/`))return;let s=It(e,Ht(r,i));if(!(!s||s.target===n.target))return Y(e,r,i,`${X(n)} imports ${X(s)} through a source path. Use an Archicat alias instead.`)}function It(e,t){let n=x(t);for(let t of e.definitions){if(t.api.rootPath&&y(n,x(t.api.rootPath)))return{kind:t.kind,name:t.name,surface:`api`,target:t.apiTarget};if(t.impl.rootPath&&y(n,x(t.impl.rootPath)))return{kind:t.kind,name:t.name,surface:`impl`,target:t.implTarget}}for(let t of e.apps)if(y(n,x(t.rootPath)))return{kind:`app`,name:t.name,surface:`app`,target:t.target}}function Lt(e,t){for(let n of e.definitions){if(t.startsWith(`${n.implAlias}/`))return{kind:n.kind,name:n.name,surface:`impl`,target:n.implTarget};if(t.startsWith(`${n.alias}/`))return{kind:n.kind,name:n.name,surface:`api`,target:n.apiTarget}}}function Rt(e,t){for(let n of e.definitions){let r=`${n.kind===`module`?e.config.modules.alias:e.config.libraries.alias}/${n.name}`,i=n.implAlias;if(t===r||t===n.alias||t===i||t.startsWith(`${r}/`)&&!t.startsWith(`${n.alias}/`)&&!t.startsWith(`${i}/`))return{apiAlias:n.alias,implAlias:i}}}function zt(e,t){return e.kind===t.kind&&e.name===t.name&&t.surface===`api`}function Bt(e){let t=new Map;for(let n of e){let e=t.get(n.from)??[];e.push(n.to),t.set(n.from,e)}return t}function Vt(e,t,n){let r=new Set,i=[t];for(;i.length>0;){let t=i.shift();if(t){if(t===n)return!0;r.has(t)||(r.add(t),i.push(...e.get(t)??[]))}}return!1}function Ht(e,t){return x(t.startsWith(`/`)?t:r.resolve(r.dirname(e),t))}function Y(e,t,n,r){return{filePath:S(e.rootDir,t),importPath:n,message:r}}function X(e){return e.kind===`app`?`App "${e.name}"`:`${Ut(e.kind)} "${e.name}" ${e.surface}`}function Ut(e){return`${e.charAt(0).toUpperCase()}${e.slice(1)}`}const Wt=new t;async function Z(e,t,n){let r=Date.now(),i=await Ie(n,t.config),a=Jt(e,n,i),o=[],s=[];if((e===`doctor`||e===`generate`)&&s.push(...Gt(i)),e===`validate`||e===`generate`){let e=Kt(i);if(s.push(...e.lines),e.exitCode!==0)return qt(a,o,s,e.exitCode,r)}return e===`generate`&&(Mt(i),o.push({kind:`panel`,title:`mirrored`,rows:[{label:`modules`,value:i.modules.length},{label:`libraries`,value:i.libraries.length},{label:`apps`,value:i.apps.length}]})),qt(a,o,s,0,r)}function Gt(e){let t=Ve(e);return t.length===0?[{kind:`success`,label:`doctor`,message:`Project diagnostics passed`}]:[{kind:`warning`,label:`doctor`,message:`Project diagnostics completed with warnings`},...t.map(e=>({kind:`warning`,message:`  ${e}`}))]}function Kt(e){let t=Nt(e);return t.length===0?{exitCode:0,lines:[{kind:`success`,label:`validate`,message:`Architecture boundaries passed`}]}:{exitCode:1,lines:[{kind:`error`,label:`validate`,message:`Architecture validation failed`},...t.map(e=>({kind:`error`,message:Pt(e)}))]}}function qt(e,t,n,r,i){let a=r===0?{kind:`success`,label:`done`,message:`Completed in ${Wt.duration(Date.now()-i)}`}:{kind:`error`,label:`failed`,message:`Failed in ${Wt.duration(Date.now()-i)}`};return{exitCode:r,lines:[e,...t,...n,a,{kind:`info`,message:``}]}}function Jt(e,t,n){return{kind:`title`,product:`ArchiCat`,command:e,rows:[{label:`config`,value:Yt(t,n.configFilePath)},{label:`output`,value:Yt(t,n.outDir)}]}}function Yt(e,t){let n=r.relative(e,t);return!n||n.startsWith(`..`)?t:n}const Q=new t;async function Xt(e=process.argv.slice(2),t=process.cwd()){let[n,...r]=e;try{let e=await Zt(n,tn(r),t);if(!e)return;Qt(e),process.exitCode=e.exitCode}catch(e){Q.error(e instanceof Error?e.message:String(e)),process.exitCode=1}}async function Zt(e,t,n){switch(e){case`generate`:return await Z(`generate`,t,n);case`validate`:case`check`:return await Z(`validate`,t,n);case`graph`:return await Be(t,n);case`doctor`:return await Z(`doctor`,t,n);case`help`:case`--help`:case`-h`:case void 0:en();return;default:return Q.error(`Unknown command: ${e}`),en(),{exitCode:1,lines:[]}}}function Qt(e){for(let t of e.lines)$t(t)}function $t(e){switch(e.kind){case`title`:Q.title(e.product,e.command,e.rows??[]);return;case`panel`:Q.panel(e.title,e.rows,e.badge);return;case`success`:Q.success($(e));return;case`info`:if(e.message.length===0){Q.emptyLine();return}Q.info($(e));return;case`warning`:Q.warn($(e));return;case`error`:Q.error($(e));return}}function $(e){return e.label?Q.step(e.label,e.message):e.message}function en(){Q.log([`ArchiCat`,``,`Usage:`,`  archicat generate [--config archicat.config.ts]`,`  archicat validate [--config archicat.config.ts]`,`  archicat graph [--config archicat.config.ts]`,`  archicat doctor [--config archicat.config.ts]`,``,`Aliases:`,`  archicat check    -> archicat validate`,``].join(`
-`))}function tn(e){let t={};for(let n=0;n<e.length;n+=1){let r=e[n];if(r===`--config`||r===`-c`){let i=e[n+1];if(!i)throw Error(`${r} requires a value.`);t.config=i,n+=1}}return t}export{Xt as runMain};
+export default ${constName};
+`;
+	writeTextFile(path.join(definition.impl.mirrorRootPath, "index.ts"), content);
+}
+function writeEmptyMirror(filePath) {
+	writeTextFile(filePath, `${makeMirrorHeader()}export {};\n`);
+}
+function writeMirrorFile(targetFilePath, sourceFilePath) {
+	const sourceImport = toPosixRelativeImport(targetFilePath, sourceFilePath);
+	const defaultExport = hasDefaultExport(sourceFilePath) ? `export { default } from '${sourceImport}';\n` : "";
+	writeTextFile(targetFilePath, `${makeMirrorHeader()}
+export * from '${sourceImport}';
+${defaultExport}`);
+}
+function findIndexFile(rootPath) {
+	for (const fileName of [
+		"index.ts",
+		"index.mts",
+		"index.cts",
+		"index.tsx"
+	]) {
+		const filePath = path.join(rootPath, fileName);
+		if (fs.existsSync(filePath) && fs.statSync(filePath).isFile()) return filePath;
+	}
+}
+function makeMirrorHeader() {
+	return "// Mirrored by Archicat.\n";
+}
+
+//#endregion
+//#region src-internal/generator/generate-report.ts
+function generateReport(project) {
+	writeJsonFile(path.join(project.reportsDir, ArchicatDefaults.generated.buildReportFileName), makeBuildReport(project));
+	writeJsonFile(path.join(project.reportsDir, ArchicatDefaults.generated.graphReportFileName), makeGraphReport(project));
+}
+function makeBuildReport(project) {
+	return {
+		generatedBy: "archicat",
+		schemaVersion: 2,
+		aliases: {
+			module: project.config.modules.alias,
+			library: project.config.libraries.alias
+		},
+		outputs: {
+			outDir: makeRelativeDisplayPath(project.rootDir, project.outDir),
+			reportsDir: makeRelativeDisplayPath(project.rootDir, project.reportsDir)
+		},
+		targets: project.graph.targets.map((target) => target.key),
+		definitions: [...project.definitions.map((definition) => makeDefinitionReport(project, definition)), ...project.apps.map((app) => ({
+			kind: app.kind,
+			name: app.name,
+			targets: { app: app.target },
+			aliases: {},
+			dependencies: app.dependencies,
+			contractFilePath: makeRelativeDisplayPath(project.rootDir, app.contractFilePath),
+			source: { root: makeRelativeDisplayPath(project.rootDir, app.rootPath) },
+			mirror: {}
+		}))],
+		dependencies: project.graph.dependencies
+	};
+}
+function makeGraphReport(project) {
+	return {
+		generatedBy: "archicat",
+		schemaVersion: 1,
+		targets: project.graph.targets.map((target) => target.key),
+		dependencies: project.graph.dependencies
+	};
+}
+function makeDefinitionReport(project, definition) {
+	return {
+		kind: definition.kind,
+		name: definition.name,
+		targets: {
+			api: definition.apiTarget,
+			impl: definition.implTarget
+		},
+		aliases: {
+			api: definition.alias,
+			impl: definition.implAlias
+		},
+		dependencies: {
+			api: definition.api.dependencies,
+			impl: definition.impl.dependencies
+		},
+		contractFilePath: makeRelativeDisplayPath(project.rootDir, definition.contractFilePath),
+		source: {
+			root: makeRelativeDisplayPath(project.rootDir, definition.definitionDir),
+			api: definition.api.rootPath ? makeRelativeDisplayPath(project.rootDir, definition.api.rootPath) : void 0,
+			impl: definition.impl.rootPath ? makeRelativeDisplayPath(project.rootDir, definition.impl.rootPath) : void 0
+		},
+		mirror: {
+			api: makeRelativeDisplayPath(project.rootDir, definition.api.mirrorRootPath),
+			impl: makeRelativeDisplayPath(project.rootDir, definition.impl.mirrorRootPath)
+		}
+	};
+}
+
+//#endregion
+//#region src-internal/generator/generate-tsconfig.ts
+function generateTsconfig(project) {
+	assertSupportedBaseTsconfigChain(project.tsconfigPath);
+	writeJsonFile(path.join(project.outDir, ArchicatDefaults.generated.tsconfigFileName), makeGeneratedTsconfig(project));
+}
+function makeGeneratedTsconfig(project) {
+	const tsconfig = {
+		compilerOptions: makeCompilerOptions(project),
+		include: makeInclude(project)
+	};
+	const extendedTsconfig = makeExtends(project);
+	const exclude = makeExclude(project);
+	const files = makeFiles(project);
+	if (extendedTsconfig) tsconfig.extends = extendedTsconfig;
+	if (exclude.length > 0) tsconfig.exclude = exclude;
+	if (files.length > 0) tsconfig.files = files;
+	return tsconfig;
+}
+function makeCompilerOptions(project) {
+	const userAliasPaths = makeConfiguredAliasPaths(project);
+	const archicatPaths = makeArchicatAliasPaths(project);
+	assertNoAliasConflicts(project, userAliasPaths, archicatPaths);
+	return { paths: {
+		...userAliasPaths,
+		...archicatPaths
+	} };
+}
+function makeExtends(project) {
+	return project.tsconfigPath ? makeRelativeTsconfigPath(project.outDir, project.tsconfigPath) : void 0;
+}
+function makeInclude(project) {
+	return unique([...rewriteProjectPaths(project, project.config.typescript.tsConfig.include), ArchicatDefaults.generated.typesInclude]);
+}
+function makeExclude(project) {
+	return rewriteProjectPaths(project, project.config.typescript.tsConfig.exclude);
+}
+function makeFiles(project) {
+	return rewriteProjectPaths(project, project.config.typescript.tsConfig.files);
+}
+function makeArchicatAliasPaths(project) {
+	const paths = {};
+	for (const definition of project.definitions) {
+		if (definition.api.rootPath) paths[definition.aliasGlob] = [makeRelativeTsconfigPath(project.outDir, path.join(definition.api.rootPath, "*"))];
+		if (definition.impl.rootPath) paths[definition.implAliasGlob] = [makeRelativeTsconfigPath(project.outDir, path.join(definition.impl.rootPath, "*"))];
+	}
+	return paths;
+}
+function makeConfiguredAliasPaths(project) {
+	const result = {};
+	for (const [alias, target] of Object.entries(project.config.alias)) {
+		const absolute = path.isAbsolute(target) ? target : path.resolve(project.rootDir, target);
+		result[alias] = [makeRelativeTsconfigPath(project.outDir, absolute)];
+	}
+	return result;
+}
+function rewriteProjectPaths(project, values) {
+	return values.map((value) => {
+		const absolute = path.isAbsolute(value) ? value : path.resolve(project.rootDir, value);
+		return makeRelativeTsconfigPath(project.outDir, absolute);
+	});
+}
+function makeRelativeTsconfigPath(fromDir, targetPath) {
+	let relative = normalizePath(path.relative(fromDir, targetPath));
+	if (!relative.startsWith(".")) relative = `./${relative}`;
+	return relative;
+}
+function unique(values) {
+	return [...new Set(values)];
+}
+function assertSupportedBaseTsconfigChain(tsconfigPath) {
+	if (!tsconfigPath) return;
+	validateBaseTsconfig(tsconfigPath, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set());
+}
+function validateBaseTsconfig(tsconfigPath, visiting, visited) {
+	const resolvedPath = path.resolve(tsconfigPath);
+	if (visited.has(resolvedPath)) return;
+	if (visiting.has(resolvedPath)) throw new Error(`Circular tsconfig extends chain detected: ${resolvedPath}`);
+	visiting.add(resolvedPath);
+	const config = readTsconfigFile(resolvedPath);
+	const compilerOptions = readTsconfigCompilerOptions(config, resolvedPath);
+	assertNoBaseTsconfigPaths(compilerOptions, resolvedPath);
+	assertNoBaseTsconfigBaseUrl(compilerOptions, resolvedPath);
+	for (const extendedPath of readTsconfigExtendsPaths(config, resolvedPath)) validateBaseTsconfig(extendedPath, visiting, visited);
+	visiting.delete(resolvedPath);
+	visited.add(resolvedPath);
+}
+function assertNoBaseTsconfigPaths(compilerOptions, tsconfigPath) {
+	if (Object.hasOwn(compilerOptions, "paths")) throw new Error(`Base tsconfig compilerOptions.paths is not supported by Archicat. Move aliases into archicat.config.ts alias: ${tsconfigPath}`);
+}
+function assertNoBaseTsconfigBaseUrl(compilerOptions, tsconfigPath) {
+	if (Object.hasOwn(compilerOptions, "baseUrl")) throw new Error(`Base tsconfig compilerOptions.baseUrl is not supported by Archicat. Move aliases into archicat.config.ts alias: ${tsconfigPath}`);
+}
+function assertNoAliasConflicts(project, userAliases, archicatPaths) {
+	const configuredAliases = Object.keys(userAliases);
+	const archicatAliases = Object.keys(archicatPaths);
+	const reservedAliases = [project.config.modules.alias, project.config.libraries.alias];
+	for (const alias of configuredAliases) {
+		if (archicatAliases.includes(alias)) throw new Error(`Alias conflict: archicat.config.ts alias already defines "${alias}", but Archicat needs it.`);
+		for (const reservedAlias of reservedAliases) if (alias === reservedAlias || alias === `${reservedAlias}/*` || alias.startsWith(`${reservedAlias}/`)) throw new Error(`Alias conflict: archicat.config.ts alias "${alias}" is inside Archicat reserved alias "${reservedAlias}". Remove the alias or configure another module/library alias.`);
+	}
+}
+
+//#endregion
+//#region src-internal/generator/generator.ts
+function generateArtifacts(project) {
+	resetDirectory(project.rootDir, project.outDir);
+	fs.mkdirSync(path.join(project.outDir, ArchicatDefaults.generated.modulesDirName), { recursive: true });
+	fs.mkdirSync(path.join(project.outDir, ArchicatDefaults.generated.librariesDirName), { recursive: true });
+	fs.mkdirSync(path.join(project.outDir, ArchicatDefaults.generated.typesDirName), { recursive: true });
+	fs.mkdirSync(project.reportsDir, { recursive: true });
+	generateMirrors(project.definitions);
+	generateGraphTypes(project);
+	generateTsconfig(project);
+	generateReport(project);
+}
+
+//#endregion
+//#region src-internal/validator/validator.ts
+function validateProject(project) {
+	const graph = makeDependencyGraph(project.graph.dependencies);
+	const violations = [];
+	const sourceFiles = [...project.definitions.flatMap((definition) => [...definition.api.rootPath ? listTypeScriptFiles(definition.api.rootPath) : [], ...definition.impl.rootPath ? listTypeScriptFiles(definition.impl.rootPath) : []]), ...project.apps.flatMap((app) => listTypeScriptFiles(app.rootPath))];
+	for (const filePath of sourceFiles) {
+		const owner = findOwner(project, filePath);
+		if (!owner) continue;
+		for (const scannedImport of scanImports(filePath)) {
+			const violation = validateImport(project, graph, owner, filePath, scannedImport.moduleSpecifier);
+			if (violation) violations.push(violation);
+		}
+	}
+	return violations;
+}
+function formatViolation(violation) {
+	return `${violation.filePath}\n  import: ${violation.importPath}\n  ${violation.message}`;
+}
+function validateImport(project, graph, owner, filePath, importPath) {
+	const unsupportedAlias = resolveUnsupportedArchicatAlias(project, importPath);
+	if (unsupportedAlias) return makeViolation(project, filePath, importPath, `Unsupported Archicat alias "${importPath}". Use an explicit file import under "${unsupportedAlias.apiAlias}/*" or "${unsupportedAlias.implAlias}/*".`);
+	const target = resolveAlias(project, importPath);
+	if (target) {
+		if (isOwnApiImport(owner, target) || canReach(graph, owner.target, target.target)) return;
+		return makeViolation(project, filePath, importPath, `${formatOwner(owner)} imports "${target.target}" but does not declare a dependency that allows it.`);
+	}
+	if (!importPath.startsWith(".") && !importPath.startsWith("/")) return;
+	const targetOwner = findOwner(project, resolveImportPath(filePath, importPath));
+	if (!targetOwner || targetOwner.target === owner.target) return;
+	return makeViolation(project, filePath, importPath, `${formatOwner(owner)} imports ${formatOwner(targetOwner)} through a source path. Use an Archicat alias instead.`);
+}
+function findOwner(project, filePath) {
+	const extensionless = stripKnownExtension(filePath);
+	for (const definition of project.definitions) {
+		if (definition.api.rootPath && isPathInside(extensionless, stripKnownExtension(definition.api.rootPath))) return {
+			kind: definition.kind,
+			name: definition.name,
+			surface: "api",
+			target: definition.apiTarget
+		};
+		if (definition.impl.rootPath && isPathInside(extensionless, stripKnownExtension(definition.impl.rootPath))) return {
+			kind: definition.kind,
+			name: definition.name,
+			surface: "impl",
+			target: definition.implTarget
+		};
+	}
+	for (const app of project.apps) if (isPathInside(extensionless, stripKnownExtension(app.rootPath))) return {
+		kind: "app",
+		name: app.name,
+		surface: "app",
+		target: app.target
+	};
+}
+function resolveAlias(project, importPath) {
+	for (const definition of project.definitions) {
+		if (importPath.startsWith(`${definition.implAlias}/`)) return {
+			kind: definition.kind,
+			name: definition.name,
+			surface: "impl",
+			target: definition.implTarget
+		};
+		if (importPath.startsWith(`${definition.alias}/`)) return {
+			kind: definition.kind,
+			name: definition.name,
+			surface: "api",
+			target: definition.apiTarget
+		};
+	}
+}
+function resolveUnsupportedArchicatAlias(project, importPath) {
+	for (const definition of project.definitions) {
+		const prefix = `${definition.kind === "module" ? project.config.modules.alias : project.config.libraries.alias}/${definition.name}`;
+		const implAlias = definition.implAlias;
+		if (importPath === prefix || importPath === definition.alias || importPath === implAlias) return {
+			apiAlias: definition.alias,
+			implAlias
+		};
+		if (importPath.startsWith(`${prefix}/`) && !importPath.startsWith(`${definition.alias}/`) && !importPath.startsWith(`${implAlias}/`)) return {
+			apiAlias: definition.alias,
+			implAlias
+		};
+	}
+}
+function isOwnApiImport(owner, target) {
+	return owner.kind === target.kind && owner.name === target.name && target.surface === "api";
+}
+function makeDependencyGraph(dependencies) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const dependency of dependencies) {
+		const targets = graph.get(dependency.from) ?? [];
+		targets.push(dependency.to);
+		graph.set(dependency.from, targets);
+	}
+	return graph;
+}
+function canReach(graph, from, to) {
+	const visited = /* @__PURE__ */ new Set();
+	const queue = [from];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (!current) continue;
+		if (current === to) return true;
+		if (visited.has(current)) continue;
+		visited.add(current);
+		queue.push(...graph.get(current) ?? []);
+	}
+	return false;
+}
+function resolveImportPath(filePath, importPath) {
+	return stripKnownExtension(importPath.startsWith("/") ? importPath : path.resolve(path.dirname(filePath), importPath));
+}
+function makeViolation(project, filePath, importPath, message) {
+	return {
+		filePath: makeRelativeDisplayPath(project.rootDir, filePath),
+		importPath,
+		message
+	};
+}
+function formatOwner(owner) {
+	if (owner.kind === "app") return `App "${owner.name}"`;
+	return `${capitalize(owner.kind)} "${owner.name}" ${owner.surface}`;
+}
+function capitalize(value) {
+	return `${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+
+//#endregion
+//#region src-cli/commands/run-project-command.ts
+const output$1 = new CliOutput();
+async function runProjectCommand(command, options, cwd) {
+	const startedAt = Date.now();
+	const project = await loadArchicatProject(cwd, options.config);
+	const title = makeTitle(command, cwd, project);
+	const panels = [];
+	const lines = [];
+	if (command === "doctor" || command === "generate") lines.push(...makeDoctorLines(project));
+	if (command === "validate" || command === "generate") {
+		const validation = makeValidationResult(project);
+		lines.push(...validation.lines);
+		if (validation.exitCode !== 0) return finishResult(title, panels, lines, validation.exitCode, startedAt);
+	}
+	if (command === "generate") {
+		generateArtifacts(project);
+		panels.push({
+			kind: "panel",
+			title: "mirrored",
+			rows: [
+				{
+					label: "modules",
+					value: project.modules.length
+				},
+				{
+					label: "libraries",
+					value: project.libraries.length
+				},
+				{
+					label: "apps",
+					value: project.apps.length
+				}
+			]
+		});
+	}
+	return finishResult(title, panels, lines, 0, startedAt);
+}
+function makeDoctorLines(project) {
+	const issues = doctorProject(project);
+	if (issues.length === 0) return [{
+		kind: "success",
+		label: "doctor",
+		message: "Project diagnostics passed"
+	}];
+	return [{
+		kind: "warning",
+		label: "doctor",
+		message: "Project diagnostics completed with warnings"
+	}, ...issues.map((message) => ({
+		kind: "warning",
+		message: `  ${message}`
+	}))];
+}
+function makeValidationResult(project) {
+	const violations = validateProject(project);
+	if (violations.length === 0) return {
+		exitCode: 0,
+		lines: [{
+			kind: "success",
+			label: "validate",
+			message: "Architecture boundaries passed"
+		}]
+	};
+	return {
+		exitCode: 1,
+		lines: [{
+			kind: "error",
+			label: "validate",
+			message: "Architecture validation failed"
+		}, ...violations.map((violation) => ({
+			kind: "error",
+			message: formatViolation(violation)
+		}))]
+	};
+}
+function finishResult(title, panels, lines, exitCode, startedAt) {
+	const status = exitCode === 0 ? {
+		kind: "success",
+		label: "done",
+		message: `Completed in ${output$1.duration(Date.now() - startedAt)}`
+	} : {
+		kind: "error",
+		label: "failed",
+		message: `Failed in ${output$1.duration(Date.now() - startedAt)}`
+	};
+	return {
+		exitCode,
+		lines: [
+			title,
+			...panels,
+			...lines,
+			status,
+			{
+				kind: "info",
+				message: ""
+			}
+		]
+	};
+}
+function makeTitle(command, cwd, project) {
+	return {
+		kind: "title",
+		product: "ArchiCat",
+		command,
+		rows: [{
+			label: "config",
+			value: formatPath(cwd, project.configFilePath)
+		}, {
+			label: "output",
+			value: formatPath(cwd, project.outDir)
+		}]
+	};
+}
+function formatPath(cwd, filePath) {
+	const relativePath = path.relative(cwd, filePath);
+	if (!relativePath || relativePath.startsWith("..")) return filePath;
+	return relativePath;
+}
+
+//#endregion
+//#region src-cli/run-main.ts
+const output = new CliOutput();
+async function runMain(argv = process.argv.slice(2), cwd = process.cwd()) {
+	const [command, ...rest] = argv;
+	try {
+		const result = await runCommand(command, parseOptions(rest), cwd);
+		if (!result) return;
+		printResult(result);
+		process.exitCode = result.exitCode;
+	} catch (error) {
+		output.error(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+}
+async function runCommand(command, options, cwd) {
+	switch (command) {
+		case "generate": return await runProjectCommand("generate", options, cwd);
+		case "validate":
+		case "check": return await runProjectCommand("validate", options, cwd);
+		case "graph": return await runGraphCommand(options, cwd);
+		case "doctor": return await runProjectCommand("doctor", options, cwd);
+		case "help":
+		case "--help":
+		case "-h":
+		case void 0:
+			printHelp();
+			return;
+		default:
+			output.error(`Unknown command: ${command}`);
+			printHelp();
+			return {
+				exitCode: 1,
+				lines: []
+			};
+	}
+}
+function printResult(result) {
+	for (const line of result.lines) printLine(line);
+}
+function printLine(line) {
+	switch (line.kind) {
+		case "title":
+			output.title(line.product, line.command, line.rows ?? []);
+			return;
+		case "panel":
+			output.panel(line.title, line.rows, line.badge);
+			return;
+		case "success":
+			output.success(formatStatusLine(line));
+			return;
+		case "info":
+			if (line.message.length === 0) {
+				output.emptyLine();
+				return;
+			}
+			output.info(formatStatusLine(line));
+			return;
+		case "warning":
+			output.warning(formatStatusLine(line));
+			return;
+		case "error":
+			output.error(formatStatusLine(line));
+			return;
+	}
+}
+function formatStatusLine(line) {
+	return line.label ? output.step(line.label, line.message) : line.message;
+}
+function printHelp() {
+	output.log([
+		"ArchiCat",
+		"",
+		"Usage:",
+		"  archicat generate [--config archicat.config.ts]",
+		"  archicat validate [--config archicat.config.ts]",
+		"  archicat graph [--config archicat.config.ts]",
+		"  archicat doctor [--config archicat.config.ts]",
+		"",
+		"Aliases:",
+		"  archicat check    -> archicat validate",
+		""
+	].join("\n"));
+}
+function parseOptions(args) {
+	const options = {};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === "--config" || arg === "-c") {
+			const value = args[index + 1];
+			if (!value) throw new Error(`${arg} requires a value.`);
+			options.config = value;
+			index += 1;
+		}
+	}
+	return options;
+}
+
+//#endregion
+export { runMain };