@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.81

package/es6/src/models/package-json.model.js

@@ -0,0 +1,137 @@
+import { readFileSync } from "node:fs";
+import { CREATE_VERSION } from "../version.js";
+import { DEFAULT_WEBAPI_NAME, webapiPackageName, webapiPort, webapiReleaseEntry } from "../webapi/const.js";
+import { WELL_KNOWN_FILES } from "./const.js";
+/**
+ * Builder for the root `package.json`.
+ *
+ * Starts with the core API dependencies. Features call `addDependency` /
+ * `addDevDependency` during their scaffold phase to inject their own deps
+ * before `files()` is called at render time.
+ */ export class PackageJson {
+    name;
+    key = WELL_KNOWN_FILES.PACKAGE_JSON;
+    _dependencies;
+    _devDependencies;
+    _scripts;
+    _version = "0.0.1";
+    _type = "module";
+    _rest = {};
+    constructor(name, options){
+        this.name = name;
+        const apiNames = options?.apiNames ?? [
+            DEFAULT_WEBAPI_NAME
+        ];
+        const first = apiNames[0] ?? DEFAULT_WEBAPI_NAME;
+        const startEntry = options?.startEntry ?? webapiReleaseEntry(first);
+        const workspaceName = options?.workspaceName ?? stripApiSuffix(name);
+        const namedOrMany = apiNames.length > 1 || first !== DEFAULT_WEBAPI_NAME;
+        this._scripts = {
+            build: "forge build --configuration release",
+            "build:watch": "forge build --watch",
+            start: `node ${startEntry}`,
+            dev: namedOrMany ? fluxDevScript(workspaceName, first, webapiPort(0)) : "flux serve",
+            "lint:check": "biome check .",
+            typecheck: "forge typecheck",
+            test: "vitest run --passWithNoTests"
+        };
+        for (const [index, apiName] of apiNames.entries()){
+            this._scripts[`start:${apiName}`] = `node ${webapiReleaseEntry(apiName)}`;
+            this._scripts[`dev:${apiName}`] = fluxDevScript(workspaceName, apiName, webapiPort(index));
+        }
+        this._dependencies = {
+            "@decohere/cortex": CREATE_VERSION,
+            "@decohere/crucible": CREATE_VERSION,
+            "@decohere/nexus": CREATE_VERSION,
+            "@decohere/protocol": CREATE_VERSION,
+            "@decohere/scribe": CREATE_VERSION,
+            "@decohere/scribe-pino": CREATE_VERSION,
+            "pino-pretty": "^13.0.0",
+            "pino-roll": "^4.0.0"
+        };
+        this._devDependencies = {
+            "@decohere/forge": CREATE_VERSION,
+            "@decohere/cli": CREATE_VERSION,
+            typescript: "^6.0.3",
+            "@biomejs/biome": "^2.0.0",
+            vitest: "^3.2.4"
+        };
+    }
+    /** Load an existing root package.json so `webapi add` can merge scripts/deps. */ static fromFile(filePath) {
+        const raw = JSON.parse(readFileSync(filePath, "utf8"));
+        const pkg = new PackageJson(typeof raw.name === "string" ? raw.name : "app", {
+            apiNames: []
+        });
+        pkg._version = typeof raw.version === "string" ? raw.version : "0.0.1";
+        pkg._type = typeof raw.type === "string" ? raw.type : "module";
+        pkg._scripts = {
+            ...asStringMap(raw.scripts)
+        };
+        pkg._dependencies = {
+            ...asStringMap(raw.dependencies)
+        };
+        pkg._devDependencies = {
+            ...asStringMap(raw.devDependencies)
+        };
+        const reserved = new Set([
+            "name",
+            "version",
+            "type",
+            "scripts",
+            "dependencies",
+            "devDependencies"
+        ]);
+        pkg._rest = Object.fromEntries(Object.entries(raw).filter(([key])=>!reserved.has(key)));
+        return pkg;
+    }
+    addDependency(name, version) {
+        this._dependencies[name] = version;
+        return this;
+    }
+    addDevDependency(name, version) {
+        this._devDependencies[name] = version;
+        return this;
+    }
+    addScript(name, command) {
+        this._scripts[name] = command;
+        return this;
+    }
+    hasScript(name) {
+        return typeof this._scripts[name] === "string";
+    }
+    files() {
+        return [
+            {
+                filePath: "package.json",
+                content: JSON.stringify({
+                    name: this.name,
+                    version: this._version,
+                    type: this._type,
+                    ...this._rest,
+                    scripts: this._scripts,
+                    dependencies: sortStringMap(this._dependencies),
+                    devDependencies: sortStringMap(this._devDependencies)
+                }, null, 2)
+            }
+        ];
+    }
+}
+function stripApiSuffix(name) {
+    return name.endsWith(".api") ? name.slice(0, -".api".length) : name;
+}
+function asStringMap(value) {
+    if (value == null || typeof value !== "object") return {};
+    const result = {};
+    for (const [key, entry] of Object.entries(value)){
+        if (typeof entry === "string") result[key] = entry;
+    }
+    return result;
+}
+/** Stable A→Z key order for package.json dependency maps. */ export function sortStringMap(map) {
+    return Object.fromEntries(Object.entries(map).sort(([left], [right])=>left.localeCompare(right, "en")));
+}
+function fluxDevScript(workspaceName, apiName, port) {
+    return `PORT=${port} flux serve --project ${webapiPackageName(workspaceName, apiName)}`;
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/models/package-json.model.ts"],"sourcesContent":["import { readFileSync } from \"node:fs\";\nimport { CREATE_VERSION } from \"../version.js\";\nimport {\n\tDEFAULT_WEBAPI_NAME,\n\twebapiPackageName,\n\twebapiPort,\n\twebapiReleaseEntry,\n} from \"../webapi/const.js\";\nimport { WELL_KNOWN_FILES } from \"./const.js\";\nimport type { KeyedModel, SourceFile } from \"./source-file.js\";\n\nexport type PackageJsonOptions = {\n\tstartEntry?: string;\n\t/** API slugs in this workspace. Drives `start:<name>` / `dev:<name>`. */\n\tapiNames?: readonly string[];\n\t/** Host workspace name used in `@<workspace>/<api>` for flux `--project`. */\n\tworkspaceName?: string;\n};\n\n/**\n * Builder for the root `package.json`.\n *\n * Starts with the core API dependencies. Features call `addDependency` /\n * `addDevDependency` during their scaffold phase to inject their own deps\n * before `files()` is called at render time.\n */\nexport class PackageJson implements KeyedModel {\n\tpublic readonly key = WELL_KNOWN_FILES.PACKAGE_JSON;\n\n\tprivate _dependencies: Record<string, string>;\n\tprivate _devDependencies: Record<string, string>;\n\tprivate _scripts: Record<string, string>;\n\tprivate _version = \"0.0.1\";\n\tprivate _type = \"module\";\n\tprivate _rest: Record<string, unknown> = {};\n\n\tpublic constructor(\n\t\tprivate readonly name: string,\n\t\toptions?: PackageJsonOptions,\n\t) {\n\t\tconst apiNames = options?.apiNames ?? [DEFAULT_WEBAPI_NAME];\n\t\tconst first = apiNames[0] ?? DEFAULT_WEBAPI_NAME;\n\t\tconst startEntry = options?.startEntry ?? webapiReleaseEntry(first);\n\t\tconst workspaceName = options?.workspaceName ?? stripApiSuffix(name);\n\t\tconst namedOrMany = apiNames.length > 1 || first !== DEFAULT_WEBAPI_NAME;\n\n\t\tthis._scripts = {\n\t\t\tbuild: \"forge build --configuration release\",\n\t\t\t\"build:watch\": \"forge build --watch\",\n\t\t\tstart: `node ${startEntry}`,\n\t\t\tdev: namedOrMany ? fluxDevScript(workspaceName, first, webapiPort(0)) : \"flux serve\",\n\t\t\t\"lint:check\": \"biome check .\",\n\t\t\ttypecheck: \"forge typecheck\",\n\t\t\ttest: \"vitest run --passWithNoTests\",\n\t\t};\n\t\tfor (const [index, apiName] of apiNames.entries()) {\n\t\t\tthis._scripts[`start:${apiName}`] = `node ${webapiReleaseEntry(apiName)}`;\n\t\t\tthis._scripts[`dev:${apiName}`] = fluxDevScript(\n\t\t\t\tworkspaceName,\n\t\t\t\tapiName,\n\t\t\t\twebapiPort(index),\n\t\t\t);\n\t\t}\n\t\tthis._dependencies = {\n\t\t\t\"@decohere/cortex\": CREATE_VERSION,\n\t\t\t\"@decohere/crucible\": CREATE_VERSION,\n\t\t\t\"@decohere/nexus\": CREATE_VERSION,\n\t\t\t\"@decohere/protocol\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe\": CREATE_VERSION,\n\t\t\t\"@decohere/scribe-pino\": CREATE_VERSION,\n\t\t\t\"pino-pretty\": \"^13.0.0\",\n\t\t\t\"pino-roll\": \"^4.0.0\",\n\t\t};\n\t\tthis._devDependencies = {\n\t\t\t\"@decohere/forge\": CREATE_VERSION,\n\t\t\t\"@decohere/cli\": CREATE_VERSION,\n\t\t\ttypescript: \"^6.0.3\",\n\t\t\t\"@biomejs/biome\": \"^2.0.0\",\n\t\t\tvitest: \"^3.2.4\",\n\t\t};\n\t}\n\n\t/** Load an existing root package.json so `webapi add` can merge scripts/deps. */\n\tpublic static fromFile(filePath: string): PackageJson {\n\t\tconst raw = JSON.parse(readFileSync(filePath, \"utf8\")) as Record<string, unknown>;\n\t\tconst pkg = new PackageJson(typeof raw.name === \"string\" ? raw.name : \"app\", {\n\t\t\tapiNames: [],\n\t\t});\n\t\tpkg._version = typeof raw.version === \"string\" ? raw.version : \"0.0.1\";\n\t\tpkg._type = typeof raw.type === \"string\" ? raw.type : \"module\";\n\t\tpkg._scripts = { ...asStringMap(raw.scripts) };\n\t\tpkg._dependencies = { ...asStringMap(raw.dependencies) };\n\t\tpkg._devDependencies = { ...asStringMap(raw.devDependencies) };\n\t\tconst reserved = new Set([\n\t\t\t\"name\",\n\t\t\t\"version\",\n\t\t\t\"type\",\n\t\t\t\"scripts\",\n\t\t\t\"dependencies\",\n\t\t\t\"devDependencies\",\n\t\t]);\n\t\tpkg._rest = Object.fromEntries(Object.entries(raw).filter(([key]) => !reserved.has(key)));\n\t\treturn pkg;\n\t}\n\n\tpublic addDependency(name: string, version: string): this {\n\t\tthis._dependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addDevDependency(name: string, version: string): this {\n\t\tthis._devDependencies[name] = version;\n\t\treturn this;\n\t}\n\n\tpublic addScript(name: string, command: string): this {\n\t\tthis._scripts[name] = command;\n\t\treturn this;\n\t}\n\n\tpublic hasScript(name: string): boolean {\n\t\treturn typeof this._scripts[name] === \"string\";\n\t}\n\n\tpublic files(): SourceFile[] {\n\t\treturn [\n\t\t\t{\n\t\t\t\tfilePath: \"package.json\",\n\t\t\t\tcontent: JSON.stringify(\n\t\t\t\t\t{\n\t\t\t\t\t\tname: this.name,\n\t\t\t\t\t\tversion: this._version,\n\t\t\t\t\t\ttype: this._type,\n\t\t\t\t\t\t...this._rest,\n\t\t\t\t\t\tscripts: this._scripts,\n\t\t\t\t\t\tdependencies: sortStringMap(this._dependencies),\n\t\t\t\t\t\tdevDependencies: sortStringMap(this._devDependencies),\n\t\t\t\t\t},\n\t\t\t\t\tnull,\n\t\t\t\t\t2,\n\t\t\t\t),\n\t\t\t},\n\t\t];\n\t}\n}\n\nfunction stripApiSuffix(name: string): string {\n\treturn name.endsWith(\".api\") ? name.slice(0, -\".api\".length) : name;\n}\n\nfunction asStringMap(value: unknown): Record<string, string> {\n\tif (value == null || typeof value !== \"object\") return {};\n\tconst result: Record<string, string> = {};\n\tfor (const [key, entry] of Object.entries(value)) {\n\t\tif (typeof entry === \"string\") result[key] = entry;\n\t}\n\treturn result;\n}\n\n/** Stable A→Z key order for package.json dependency maps. */\nexport function sortStringMap(map: Record<string, string>): Record<string, string> {\n\treturn Object.fromEntries(\n\t\tObject.entries(map).sort(([left], [right]) => left.localeCompare(right, \"en\")),\n\t);\n}\n\nfunction fluxDevScript(workspaceName: string, apiName: string, port: number): string {\n\treturn `PORT=${port} flux serve --project ${webapiPackageName(workspaceName, apiName)}`;\n}\n"],"names":["readFileSync","CREATE_VERSION","DEFAULT_WEBAPI_NAME","webapiPackageName","webapiPort","webapiReleaseEntry","WELL_KNOWN_FILES","PackageJson","key","PACKAGE_JSON","_dependencies","_devDependencies","_scripts","_version","_type","_rest","name","options","apiNames","first","startEntry","workspaceName","stripApiSuffix","namedOrMany","length","build","start","dev","fluxDevScript","typecheck","test","index","apiName","entries","typescript","vitest","fromFile","filePath","raw","JSON","parse","pkg","version","type","asStringMap","scripts","dependencies","devDependencies","reserved","Set","Object","fromEntries","filter","has","addDependency","addDevDependency","addScript","command","hasScript","files","content","stringify","sortStringMap","endsWith","slice","value","result","entry","map","sort","left","right","localeCompare","port"],"mappings":"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"}

package/es6/src/models/project.model.js

@@ -0,0 +1,119 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { basename, dirname, join } from "node:path";
+/**
+ * A sub-unit of the monorepo (e.g. `projects/api`).
+ *
+ * Models and files registered here produce paths relative to `dir`. The parent
+ * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so
+ * models remain unaware of where they live in the repo.
+ */ export class ProjectScaffold {
+    dir;
+    _models = new Map();
+    _files = [];
+    constructor(dir){
+        this.dir = dir;
+    }
+    addModel(model) {
+        this._models.set(model.key, model);
+        return model;
+    }
+    addFile(provider) {
+        this._files.push(...provider.files());
+        return this;
+    }
+    getModel(key) {
+        return this._models.get(key);
+    }
+    getModels(ctor) {
+        return [
+            ...this._models.values()
+        ].filter((m)=>m instanceof ctor);
+    }
+    /** Returns all files with `dir/` prepended to each path. */ files() {
+        const all = [
+            ...this._files,
+            ...[
+                ...this._models.values()
+            ].flatMap((m)=>m.files())
+        ];
+        return all.map((f)=>({
+                filePath: `${this.dir}/${f.filePath}`,
+                content: f.content
+            }));
+    }
+}
+export class WorkspaceScaffold {
+    files = [];
+    targetDir = process.cwd();
+    _name;
+    /** Project name — host directory basename, not the in-container mount path. */ get name() {
+        return this._name ?? basename(this.targetDir);
+    }
+    setName(name) {
+        this._name = name;
+        return this;
+    }
+    /** Add an ad-hoc file provider whose output is included at render time. */ addFile(provider) {
+        this.files.push(...provider.files());
+        return this;
+    }
+}
+export class MonoRepoScaffold extends WorkspaceScaffold {
+    _models = new Map();
+    _projects = [];
+    /** Register a named project. */ addProject(project) {
+        this._projects.push(project);
+        return project;
+    }
+    /** Retrieve a previously-registered project by its directory path. */ getProject(dir) {
+        return this._projects.find((p)=>p.dir === dir);
+    }
+    /** All registered projects, in registration order. */ getProjects() {
+        return this._projects;
+    }
+    /** Register a named model at workspace level. */ addModel(model) {
+        this._models.set(model.key, model);
+        return model;
+    }
+    /**
+	 * Retrieve a model by key. Searches workspace models first, then all
+	 * registered projects in order.
+	 */ getModel(key) {
+        const m = this._models.get(key);
+        if (m !== undefined) return m;
+        for (const project of this._projects){
+            const pm = project.getModel(key);
+            if (pm !== undefined) return pm;
+        }
+        return undefined;
+    }
+    /**
+	 * Retrieve all models of a given type. Searches workspace models and all
+	 * projects, so features can discover controllers across multiple projects.
+	 */ getModels(ctor) {
+        return [
+            ...[
+                ...this._models.values()
+            ].filter((m)=>m instanceof ctor),
+            ...this._projects.flatMap((p)=>p.getModels(ctor))
+        ];
+    }
+    /** Render all models and projects into files, then write everything to disk. */ async scaffold() {
+        const allFiles = [
+            ...this.files,
+            ...[
+                ...this._models.values()
+            ].flatMap((m)=>m.files()),
+            ...this._projects.flatMap((p)=>p.files())
+        ];
+        await Promise.all(allFiles.map(async (file)=>{
+            const fullPath = join(this.targetDir, file.filePath);
+            await mkdir(dirname(fullPath), {
+                recursive: true
+            });
+            await writeFile(fullPath, file.content);
+        }));
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scaffold/src/models/project.model.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { basename, dirname, join } from \"node:path\";\nimport type { KeyedModel, SourceFile, SourceFileProvider } from \"./source-file.js\";\n\n/**\n * A sub-unit of the monorepo (e.g. `projects/api`).\n *\n * Models and files registered here produce paths relative to `dir`. The parent\n * `MonoRepoScaffold` calls `files()` and prepends `dir/` to every path, so\n * models remain unaware of where they live in the repo.\n */\nexport class ProjectScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _files: SourceFile[] = [];\n\n\tpublic constructor(public readonly dir: string) {}\n\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis._files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\treturn this._models.get(key) as T | undefined;\n\t}\n\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [...this._models.values()].filter((m): m is T => m instanceof ctor);\n\t}\n\n\t/** Returns all files with `dir/` prepended to each path. */\n\tpublic files(): SourceFile[] {\n\t\tconst all = [...this._files, ...[...this._models.values()].flatMap((m) => m.files())];\n\t\treturn all.map((f) => ({ filePath: `${this.dir}/${f.filePath}`, content: f.content }));\n\t}\n}\n\nexport abstract class WorkspaceScaffold {\n\tpublic readonly files: SourceFile[] = [];\n\tpublic targetDir: string = process.cwd();\n\tprivate _name: string | undefined;\n\n\t/** Project name — host directory basename, not the in-container mount path. */\n\tpublic get name(): string {\n\t\treturn this._name ?? basename(this.targetDir);\n\t}\n\n\tpublic setName(name: string): this {\n\t\tthis._name = name;\n\t\treturn this;\n\t}\n\n\t/** Add an ad-hoc file provider whose output is included at render time. */\n\tpublic addFile(provider: SourceFileProvider): this {\n\t\tthis.files.push(...provider.files());\n\t\treturn this;\n\t}\n\n\tpublic abstract addModel<T extends KeyedModel>(model: T): T;\n\tpublic abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;\n\tpublic abstract getModels<T extends SourceFileProvider>(\n\t\tctor: new (...args: never[]) => T,\n\t): T[];\n\tpublic abstract getProject(dir: string): ProjectScaffold | undefined;\n\tpublic abstract getProjects(): readonly ProjectScaffold[];\n\tpublic abstract scaffold(): Promise<void> | void;\n}\n\nexport class MonoRepoScaffold extends WorkspaceScaffold {\n\tprivate readonly _models = new Map<string, SourceFileProvider>();\n\tprivate readonly _projects: ProjectScaffold[] = [];\n\n\t/** Register a named project. */\n\tpublic addProject(project: ProjectScaffold): ProjectScaffold {\n\t\tthis._projects.push(project);\n\t\treturn project;\n\t}\n\n\t/** Retrieve a previously-registered project by its directory path. */\n\tpublic getProject(dir: string): ProjectScaffold | undefined {\n\t\treturn this._projects.find((p) => p.dir === dir);\n\t}\n\n\t/** All registered projects, in registration order. */\n\tpublic getProjects(): readonly ProjectScaffold[] {\n\t\treturn this._projects;\n\t}\n\n\t/** Register a named model at workspace level. */\n\tpublic addModel<T extends KeyedModel>(model: T): T {\n\t\tthis._models.set(model.key, model);\n\t\treturn model;\n\t}\n\n\t/**\n\t * Retrieve a model by key. Searches workspace models first, then all\n\t * registered projects in order.\n\t */\n\tpublic getModel<T extends SourceFileProvider>(key: string): T | undefined {\n\t\tconst m = this._models.get(key) as T | undefined;\n\t\tif (m !== undefined) return m;\n\t\tfor (const project of this._projects) {\n\t\t\tconst pm = project.getModel<T>(key);\n\t\t\tif (pm !== undefined) return pm;\n\t\t}\n\t\treturn undefined;\n\t}\n\n\t/**\n\t * Retrieve all models of a given type. Searches workspace models and all\n\t * projects, so features can discover controllers across multiple projects.\n\t */\n\tpublic getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[] {\n\t\treturn [\n\t\t\t...[...this._models.values()].filter((m): m is T => m instanceof ctor),\n\t\t\t...this._projects.flatMap((p) => p.getModels(ctor)),\n\t\t];\n\t}\n\n\t/** Render all models and projects into files, then write everything to disk. */\n\tpublic async scaffold(): Promise<void> {\n\t\tconst allFiles = [\n\t\t\t...this.files,\n\t\t\t...[...this._models.values()].flatMap((m) => m.files()),\n\t\t\t...this._projects.flatMap((p) => p.files()),\n\t\t];\n\n\t\tawait Promise.all(\n\t\t\tallFiles.map(async (file) => {\n\t\t\t\tconst fullPath = join(this.targetDir, file.filePath);\n\t\t\t\tawait mkdir(dirname(fullPath), { recursive: true });\n\t\t\t\tawait writeFile(fullPath, file.content);\n\t\t\t}),\n\t\t);\n\t}\n}\n"],"names":["mkdir","writeFile","basename","dirname","join","ProjectScaffold","_models","Map","_files","dir","addModel","model","set","key","addFile","provider","push","files","getModel","get","getModels","ctor","values","filter","m","all","flatMap","map","f","filePath","content","WorkspaceScaffold","targetDir","process","cwd","_name","name","setName","MonoRepoScaffold","_projects","addProject","project","getProject","find","p","getProjects","undefined","pm","scaffold","allFiles","Promise","file","fullPath","recursive"],"mappings":"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"}

package/es6/src/models/source-file.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvc291cmNlLWZpbGUudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGludGVyZmFjZSBTb3VyY2VGaWxlUHJvdmlkZXIge1xuXHRmaWxlcygpOiBTb3VyY2VGaWxlW107XG59XG5cbi8qKiBBIFNvdXJjZUZpbGVQcm92aWRlciB0aGF0IGtub3dzIGl0cyBvd24gcmVnaXN0cmF0aW9uIGtleS4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgS2V5ZWRNb2RlbCBleHRlbmRzIFNvdXJjZUZpbGVQcm92aWRlciB7XG5cdHJlYWRvbmx5IGtleTogc3RyaW5nO1xufVxuXG5leHBvcnQgdHlwZSBTb3VyY2VGaWxlID0ge1xuXHRmaWxlUGF0aDogc3RyaW5nO1xuXHRjb250ZW50OiBzdHJpbmc7XG59O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVNBLFdBR0UifQ==

package/es6/src/models/tsconfig.model.js

@@ -0,0 +1,24 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class TsConfig {
+    key = WELL_KNOWN_FILES.TSCONFIG;
+    files() {
+        return [
+            {
+                filePath: "tsconfig.json",
+                content: JSON.stringify({
+                    compilerOptions: {
+                        target: "ES2022",
+                        module: "NodeNext",
+                        moduleResolution: "NodeNext",
+                        strict: true,
+                        skipLibCheck: true,
+                        experimentalDecorators: true,
+                        emitDecoratorMetadata: true
+                    }
+                }, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdHNjb25maWcubW9kZWwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgV0VMTF9LTk9XTl9GSUxFUyB9IGZyb20gXCIuL2NvbnN0LmpzXCI7XG5pbXBvcnQgdHlwZSB7IEtleWVkTW9kZWwsIFNvdXJjZUZpbGUgfSBmcm9tIFwiLi9zb3VyY2UtZmlsZS5qc1wiO1xuXG5leHBvcnQgY2xhc3MgVHNDb25maWcgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuVFNDT05GSUc7XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0cmV0dXJuIFtcblx0XHRcdHtcblx0XHRcdFx0ZmlsZVBhdGg6IFwidHNjb25maWcuanNvblwiLFxuXHRcdFx0XHRjb250ZW50OiBKU09OLnN0cmluZ2lmeShcblx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHRjb21waWxlck9wdGlvbnM6IHtcblx0XHRcdFx0XHRcdFx0dGFyZ2V0OiBcIkVTMjAyMlwiLFxuXHRcdFx0XHRcdFx0XHRtb2R1bGU6IFwiTm9kZU5leHRcIixcblx0XHRcdFx0XHRcdFx0bW9kdWxlUmVzb2x1dGlvbjogXCJOb2RlTmV4dFwiLFxuXHRcdFx0XHRcdFx0XHRzdHJpY3Q6IHRydWUsXG5cdFx0XHRcdFx0XHRcdHNraXBMaWJDaGVjazogdHJ1ZSxcblx0XHRcdFx0XHRcdFx0ZXhwZXJpbWVudGFsRGVjb3JhdG9yczogdHJ1ZSxcblx0XHRcdFx0XHRcdFx0ZW1pdERlY29yYXRvck1ldGFkYXRhOiB0cnVlLFxuXHRcdFx0XHRcdFx0fSxcblx0XHRcdFx0XHR9LFxuXHRcdFx0XHRcdG51bGwsXG5cdFx0XHRcdFx0Mixcblx0XHRcdFx0KSxcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIldFTExfS05PV05fRklMRVMiLCJUc0NvbmZpZyIsImtleSIsIlRTQ09ORklHIiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJKU09OIiwic3RyaW5naWZ5IiwiY29tcGlsZXJPcHRpb25zIiwidGFyZ2V0IiwibW9kdWxlIiwibW9kdWxlUmVzb2x1dGlvbiIsInN0cmljdCIsInNraXBMaWJDaGVjayIsImV4cGVyaW1lbnRhbERlY29yYXRvcnMiLCJlbWl0RGVjb3JhdG9yTWV0YWRhdGEiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGdCQUFnQixRQUFRLGFBQWE7QUFHOUMsT0FBTyxNQUFNQztJQUNJQyxNQUFNRixpQkFBaUJHLFFBQVEsQ0FBQztJQUV6Q0MsUUFBc0I7UUFDNUIsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTQyxLQUFLQyxTQUFTLENBQ3RCO29CQUNDQyxpQkFBaUI7d0JBQ2hCQyxRQUFRO3dCQUNSQyxRQUFRO3dCQUNSQyxrQkFBa0I7d0JBQ2xCQyxRQUFRO3dCQUNSQyxjQUFjO3dCQUNkQyx3QkFBd0I7d0JBQ3hCQyx1QkFBdUI7b0JBQ3hCO2dCQUNELEdBQ0EsTUFDQTtZQUVGO1NBQ0E7SUFDRjtBQUNEIn0=

package/es6/src/models/vitest-config.model.js

@@ -0,0 +1,25 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class VitestConfig {
+    key = WELL_KNOWN_FILES.VITEST_CONFIG;
+    files() {
+        return [
+            {
+                filePath: "vitest.config.ts",
+                content: [
+                    'import { forgeBuild } from "@decohere/forge/vitest";',
+                    'import { defineConfig } from "vitest/config";',
+                    "",
+                    "export default defineConfig({",
+                    '\tplugins: [forgeBuild({ logLevel: "silent" })],',
+                    "\ttest: {",
+                    '\t\tinclude: ["projects/**/*.{test,spec}.?(c|m)[jt]s?(x)"],',
+                    "\t},",
+                    "});",
+                    ""
+                ].join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdml0ZXN0LWNvbmZpZy5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBWaXRlc3RDb25maWcgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuVklURVNUX0NPTkZJRztcblxuXHRwdWJsaWMgZmlsZXMoKTogU291cmNlRmlsZVtdIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCJ2aXRlc3QuY29uZmlnLnRzXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IFtcblx0XHRcdFx0XHQnaW1wb3J0IHsgZm9yZ2VCdWlsZCB9IGZyb20gXCJAZGVjb2hlcmUvZm9yZ2Uvdml0ZXN0XCI7Jyxcblx0XHRcdFx0XHQnaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcInZpdGVzdC9jb25maWdcIjsnLFxuXHRcdFx0XHRcdFwiXCIsXG5cdFx0XHRcdFx0XCJleHBvcnQgZGVmYXVsdCBkZWZpbmVDb25maWcoe1wiLFxuXHRcdFx0XHRcdCdcXHRwbHVnaW5zOiBbZm9yZ2VCdWlsZCh7IGxvZ0xldmVsOiBcInNpbGVudFwiIH0pXSwnLFxuXHRcdFx0XHRcdFwiXFx0dGVzdDoge1wiLFxuXHRcdFx0XHRcdCdcXHRcXHRpbmNsdWRlOiBbXCJwcm9qZWN0cy8qKi8qLnt0ZXN0LHNwZWN9Lj8oY3xtKVtqdF1zPyh4KVwiXSwnLFxuXHRcdFx0XHRcdFwiXFx0fSxcIixcblx0XHRcdFx0XHRcIn0pO1wiLFxuXHRcdFx0XHRcdFwiXCIsXG5cdFx0XHRcdF0uam9pbihcIlxcblwiKSxcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIldFTExfS05PV05fRklMRVMiLCJWaXRlc3RDb25maWciLCJrZXkiLCJWSVRFU1RfQ09ORklHIiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJqb2luIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxnQkFBZ0IsUUFBUSxhQUFhO0FBRzlDLE9BQU8sTUFBTUM7SUFDSUMsTUFBTUYsaUJBQWlCRyxhQUFhLENBQUM7SUFFOUNDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBUztvQkFDUjtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtpQkFDQSxDQUFDQyxJQUFJLENBQUM7WUFDUjtTQUNBO0lBQ0Y7QUFDRCJ9

package/es6/src/models/vscode-settings.model.js

@@ -0,0 +1,21 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class VSCodeSettings {
+    title;
+    key = WELL_KNOWN_FILES.VSCODE_SETTINGS;
+    constructor(title){
+        this.title = title;
+    }
+    files() {
+        return [
+            {
+                filePath: ".vscode/settings.json",
+                content: JSON.stringify({
+                    "window.title": `${this.title}\${separator}\${activeEditorShort}`,
+                    "window.titleSeparator": " | "
+                }, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdnNjb2RlLXNldHRpbmdzLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdFTExfS05PV05fRklMRVMgfSBmcm9tIFwiLi9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4vc291cmNlLWZpbGUuanNcIjtcblxuZXhwb3J0IGNsYXNzIFZTQ29kZVNldHRpbmdzIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHB1YmxpYyByZWFkb25seSBrZXkgPSBXRUxMX0tOT1dOX0ZJTEVTLlZTQ09ERV9TRVRUSU5HUztcblxuXHRwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSB0aXRsZTogc3RyaW5nKSB7fVxuXG5cdHB1YmxpYyBmaWxlcygpOiBTb3VyY2VGaWxlW10ge1xuXHRcdHJldHVybiBbXG5cdFx0XHR7XG5cdFx0XHRcdGZpbGVQYXRoOiBcIi52c2NvZGUvc2V0dGluZ3MuanNvblwiLFxuXHRcdFx0XHRjb250ZW50OiBKU09OLnN0cmluZ2lmeShcblx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHRcIndpbmRvdy50aXRsZVwiOiBgJHt0aGlzLnRpdGxlfVxcJHtzZXBhcmF0b3J9XFwke2FjdGl2ZUVkaXRvclNob3J0fWAsXG5cdFx0XHRcdFx0XHRcIndpbmRvdy50aXRsZVNlcGFyYXRvclwiOiBcIiB8IFwiLFxuXHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0bnVsbCxcblx0XHRcdFx0XHQyLFxuXHRcdFx0XHQpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiV0VMTF9LTk9XTl9GSUxFUyIsIlZTQ29kZVNldHRpbmdzIiwia2V5IiwiVlNDT0RFX1NFVFRJTkdTIiwidGl0bGUiLCJmaWxlcyIsImZpbGVQYXRoIiwiY29udGVudCIsIkpTT04iLCJzdHJpbmdpZnkiXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGdCQUFnQixRQUFRLGFBQWE7QUFHOUMsT0FBTyxNQUFNQzs7SUFDSUMsTUFBTUYsaUJBQWlCRyxlQUFlLENBQUM7SUFFdkQsWUFBbUIsQUFBaUJDLEtBQWEsQ0FBRTthQUFmQSxRQUFBQTtJQUFnQjtJQUU3Q0MsUUFBc0I7UUFDNUIsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTQyxLQUFLQyxTQUFTLENBQ3RCO29CQUNDLGdCQUFnQixHQUFHLElBQUksQ0FBQ0wsS0FBSyxDQUFDLGtDQUFrQyxDQUFDO29CQUNqRSx5QkFBeUI7Z0JBQzFCLEdBQ0EsTUFDQTtZQUVGO1NBQ0E7SUFDRjtBQUNEIn0=

package/es6/src/program.js

@@ -0,0 +1,39 @@
+import { Command, CommanderError } from "commander";
+import { CreateCliError } from "./webapi/api-name.js";
+import { addWebapiFeatureOptions, collectName, runScaffoldApi, toApiOptions } from "./webapi/cli-options.js";
+export function createProgram() {
+    const program = new Command();
+    program.exitOverride();
+    program.name("decohere").description("Decohere CLI").option("-d <directory>", "Target directory (default: current directory)", ".");
+    const create = program.command("create").description("Create a new Decohere workspace");
+    addWebapiFeatureOptions(create.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--name <slug>", "API name under projects/ (repeatable; default: api)", collectName, [])).action(async (directory, _opts, cmd)=>{
+        await runScaffoldApi(toApiOptions(directory, cmd.optsWithGlobals()));
+    });
+    addWebapiFeatureOptions(program.command("add").description("Add to an existing Decohere workspace").command("api").argument("<name>", "API name under projects/")).action(async (name, _opts, cmd)=>{
+        await runScaffoldApi(toApiOptions(undefined, cmd.optsWithGlobals(), {
+            names: [
+                name
+            ],
+            add: true
+        }));
+    });
+    return program;
+}
+export async function runCli(argv = process.argv) {
+    try {
+        await createProgram().parseAsync(argv);
+    } catch (err) {
+        if (err instanceof CommanderError) {
+            process.exit(err.exitCode);
+        }
+        if (err instanceof CreateCliError) {
+            console.error(`\n  ${err.message}\n`);
+            process.exit(1);
+        }
+        console.error(err);
+        process.exit(1);
+    }
+    process.exit(process.exitCode ?? 0);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9wcm9ncmFtLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbW1hbmQsIENvbW1hbmRlckVycm9yIH0gZnJvbSBcImNvbW1hbmRlclwiO1xuaW1wb3J0IHsgQ3JlYXRlQ2xpRXJyb3IgfSBmcm9tIFwiLi93ZWJhcGkvYXBpLW5hbWUuanNcIjtcbmltcG9ydCB7XG5cdGFkZFdlYmFwaUZlYXR1cmVPcHRpb25zLFxuXHRjb2xsZWN0TmFtZSxcblx0cnVuU2NhZmZvbGRBcGksXG5cdHRvQXBpT3B0aW9ucyxcbn0gZnJvbSBcIi4vd2ViYXBpL2NsaS1vcHRpb25zLmpzXCI7XG5cbmV4cG9ydCBmdW5jdGlvbiBjcmVhdGVQcm9ncmFtKCk6IENvbW1hbmQge1xuXHRjb25zdCBwcm9ncmFtID0gbmV3IENvbW1hbmQoKTtcblx0cHJvZ3JhbS5leGl0T3ZlcnJpZGUoKTtcblx0cHJvZ3JhbVxuXHRcdC5uYW1lKFwiZGVjb2hlcmVcIilcblx0XHQuZGVzY3JpcHRpb24oXCJEZWNvaGVyZSBDTElcIilcblx0XHQub3B0aW9uKFwiLWQgPGRpcmVjdG9yeT5cIiwgXCJUYXJnZXQgZGlyZWN0b3J5IChkZWZhdWx0OiBjdXJyZW50IGRpcmVjdG9yeSlcIiwgXCIuXCIpO1xuXG5cdGNvbnN0IGNyZWF0ZSA9IHByb2dyYW0uY29tbWFuZChcImNyZWF0ZVwiKS5kZXNjcmlwdGlvbihcIkNyZWF0ZSBhIG5ldyBEZWNvaGVyZSB3b3Jrc3BhY2VcIik7XG5cdGFkZFdlYmFwaUZlYXR1cmVPcHRpb25zKFxuXHRcdGNyZWF0ZVxuXHRcdFx0LmNvbW1hbmQoXCJ3ZWJhcGlcIilcblx0XHRcdC5hcmd1bWVudChcIltkaXJlY3RvcnldXCIsIFwiVGFyZ2V0IGRpcmVjdG9yeSAoZGVmYXVsdDogLWQgb3IgY3VycmVudCBkaXJlY3RvcnkpXCIpXG5cdFx0XHQub3B0aW9uKFxuXHRcdFx0XHRcIi0tbmFtZSA8c2x1Zz5cIixcblx0XHRcdFx0XCJBUEkgbmFtZSB1bmRlciBwcm9qZWN0cy8gKHJlcGVhdGFibGU7IGRlZmF1bHQ6IGFwaSlcIixcblx0XHRcdFx0Y29sbGVjdE5hbWUsXG5cdFx0XHRcdFtdIGFzIHN0cmluZ1tdLFxuXHRcdFx0KSxcblx0KS5hY3Rpb24oYXN5bmMgKGRpcmVjdG9yeTogc3RyaW5nIHwgdW5kZWZpbmVkLCBfb3B0czogdW5rbm93biwgY21kOiBDb21tYW5kKSA9PiB7XG5cdFx0YXdhaXQgcnVuU2NhZmZvbGRBcGkodG9BcGlPcHRpb25zKGRpcmVjdG9yeSwgY21kLm9wdHNXaXRoR2xvYmFscygpKSk7XG5cdH0pO1xuXG5cdGFkZFdlYmFwaUZlYXR1cmVPcHRpb25zKFxuXHRcdHByb2dyYW1cblx0XHRcdC5jb21tYW5kKFwiYWRkXCIpXG5cdFx0XHQuZGVzY3JpcHRpb24oXCJBZGQgdG8gYW4gZXhpc3RpbmcgRGVjb2hlcmUgd29ya3NwYWNlXCIpXG5cdFx0XHQuY29tbWFuZChcImFwaVwiKVxuXHRcdFx0LmFyZ3VtZW50KFwiPG5hbWU+XCIsIFwiQVBJIG5hbWUgdW5kZXIgcHJvamVjdHMvXCIpLFxuXHQpLmFjdGlvbihhc3luYyAobmFtZTogc3RyaW5nLCBfb3B0czogdW5rbm93biwgY21kOiBDb21tYW5kKSA9PiB7XG5cdFx0YXdhaXQgcnVuU2NhZmZvbGRBcGkoXG5cdFx0XHR0b0FwaU9wdGlvbnModW5kZWZpbmVkLCBjbWQub3B0c1dpdGhHbG9iYWxzKCksIHsgbmFtZXM6IFtuYW1lXSwgYWRkOiB0cnVlIH0pLFxuXHRcdCk7XG5cdH0pO1xuXG5cdHJldHVybiBwcm9ncmFtO1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gcnVuQ2xpKGFyZ3Y6IHN0cmluZ1tdID0gcHJvY2Vzcy5hcmd2KTogUHJvbWlzZTx2b2lkPiB7XG5cdHRyeSB7XG5cdFx0YXdhaXQgY3JlYXRlUHJvZ3JhbSgpLnBhcnNlQXN5bmMoYXJndik7XG5cdH0gY2F0Y2ggKGVycikge1xuXHRcdGlmIChlcnIgaW5zdGFuY2VvZiBDb21tYW5kZXJFcnJvcikge1xuXHRcdFx0cHJvY2Vzcy5leGl0KGVyci5leGl0Q29kZSk7XG5cdFx0fVxuXHRcdGlmIChlcnIgaW5zdGFuY2VvZiBDcmVhdGVDbGlFcnJvcikge1xuXHRcdFx0Y29uc29sZS5lcnJvcihgXFxuICAke2Vyci5tZXNzYWdlfVxcbmApO1xuXHRcdFx0cHJvY2Vzcy5leGl0KDEpO1xuXHRcdH1cblx0XHRjb25zb2xlLmVycm9yKGVycik7XG5cdFx0cHJvY2Vzcy5leGl0KDEpO1xuXHR9XG5cdHByb2Nlc3MuZXhpdChwcm9jZXNzLmV4aXRDb2RlID8/IDApO1xufVxuIl0sIm5hbWVzIjpbIkNvbW1hbmQiLCJDb21tYW5kZXJFcnJvciIsIkNyZWF0ZUNsaUVycm9yIiwiYWRkV2ViYXBpRmVhdHVyZU9wdGlvbnMiLCJjb2xsZWN0TmFtZSIsInJ1blNjYWZmb2xkQXBpIiwidG9BcGlPcHRpb25zIiwiY3JlYXRlUHJvZ3JhbSIsInByb2dyYW0iLCJleGl0T3ZlcnJpZGUiLCJuYW1lIiwiZGVzY3JpcHRpb24iLCJvcHRpb24iLCJjcmVhdGUiLCJjb21tYW5kIiwiYXJndW1lbnQiLCJhY3Rpb24iLCJkaXJlY3RvcnkiLCJfb3B0cyIsImNtZCIsIm9wdHNXaXRoR2xvYmFscyIsInVuZGVmaW5lZCIsIm5hbWVzIiwiYWRkIiwicnVuQ2xpIiwiYXJndiIsInByb2Nlc3MiLCJwYXJzZUFzeW5jIiwiZXJyIiwiZXhpdCIsImV4aXRDb2RlIiwiY29uc29sZSIsImVycm9yIiwibWVzc2FnZSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsT0FBTyxFQUFFQyxjQUFjLFFBQVEsWUFBWTtBQUNwRCxTQUFTQyxjQUFjLFFBQVEsdUJBQXVCO0FBQ3RELFNBQ0NDLHVCQUF1QixFQUN2QkMsV0FBVyxFQUNYQyxjQUFjLEVBQ2RDLFlBQVksUUFDTiwwQkFBMEI7QUFFakMsT0FBTyxTQUFTQztJQUNmLE1BQU1DLFVBQVUsSUFBSVI7SUFDcEJRLFFBQVFDLFlBQVk7SUFDcEJELFFBQ0VFLElBQUksQ0FBQyxZQUNMQyxXQUFXLENBQUMsZ0JBQ1pDLE1BQU0sQ0FBQyxrQkFBa0IsaURBQWlEO0lBRTVFLE1BQU1DLFNBQVNMLFFBQVFNLE9BQU8sQ0FBQyxVQUFVSCxXQUFXLENBQUM7SUFDckRSLHdCQUNDVSxPQUNFQyxPQUFPLENBQUMsVUFDUkMsUUFBUSxDQUFDLGVBQWUsdURBQ3hCSCxNQUFNLENBQ04saUJBQ0EsdURBQ0FSLGFBQ0EsRUFBRSxHQUVIWSxNQUFNLENBQUMsT0FBT0MsV0FBK0JDLE9BQWdCQztRQUM5RCxNQUFNZCxlQUFlQyxhQUFhVyxXQUFXRSxJQUFJQyxlQUFlO0lBQ2pFO0lBRUFqQix3QkFDQ0ssUUFDRU0sT0FBTyxDQUFDLE9BQ1JILFdBQVcsQ0FBQyx5Q0FDWkcsT0FBTyxDQUFDLE9BQ1JDLFFBQVEsQ0FBQyxVQUFVLDZCQUNwQkMsTUFBTSxDQUFDLE9BQU9OLE1BQWNRLE9BQWdCQztRQUM3QyxNQUFNZCxlQUNMQyxhQUFhZSxXQUFXRixJQUFJQyxlQUFlLElBQUk7WUFBRUUsT0FBTztnQkFBQ1o7YUFBSztZQUFFYSxLQUFLO1FBQUs7SUFFNUU7SUFFQSxPQUFPZjtBQUNSO0FBRUEsT0FBTyxlQUFlZ0IsT0FBT0MsT0FBaUJDLFFBQVFELElBQUk7SUFDekQsSUFBSTtRQUNILE1BQU1sQixnQkFBZ0JvQixVQUFVLENBQUNGO0lBQ2xDLEVBQUUsT0FBT0csS0FBSztRQUNiLElBQUlBLGVBQWUzQixnQkFBZ0I7WUFDbEN5QixRQUFRRyxJQUFJLENBQUNELElBQUlFLFFBQVE7UUFDMUI7UUFDQSxJQUFJRixlQUFlMUIsZ0JBQWdCO1lBQ2xDNkIsUUFBUUMsS0FBSyxDQUFDLENBQUMsSUFBSSxFQUFFSixJQUFJSyxPQUFPLENBQUMsRUFBRSxDQUFDO1lBQ3BDUCxRQUFRRyxJQUFJLENBQUM7UUFDZDtRQUNBRSxRQUFRQyxLQUFLLENBQUNKO1FBQ2RGLFFBQVFHLElBQUksQ0FBQztJQUNkO0lBQ0FILFFBQVFHLElBQUksQ0FBQ0gsUUFBUUksUUFBUSxJQUFJO0FBQ2xDIn0=

package/es6/src/resolve-target-dir.js

@@ -0,0 +1,9 @@
+/**
+ * Resolve scaffold destination: positional `webapi my-app` wins over `-d`.
+ * `npm create … webapi -d my-app` drops `-d` (npm loglevel) and forwards `my-app`.
+ */ export function resolveTargetDir(positional, flag) {
+    const dir = positional?.trim() || flag?.trim() || ".";
+    return dir;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9yZXNvbHZlLXRhcmdldC1kaXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXNvbHZlIHNjYWZmb2xkIGRlc3RpbmF0aW9uOiBwb3NpdGlvbmFsIGB3ZWJhcGkgbXktYXBwYCB3aW5zIG92ZXIgYC1kYC5cbiAqIGBucG0gY3JlYXRlIOKApiB3ZWJhcGkgLWQgbXktYXBwYCBkcm9wcyBgLWRgIChucG0gbG9nbGV2ZWwpIGFuZCBmb3J3YXJkcyBgbXktYXBwYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVUYXJnZXREaXIocG9zaXRpb25hbD86IHN0cmluZywgZmxhZz86IHN0cmluZyk6IHN0cmluZyB7XG5cdGNvbnN0IGRpciA9IHBvc2l0aW9uYWw/LnRyaW0oKSB8fCBmbGFnPy50cmltKCkgfHwgXCIuXCI7XG5cdHJldHVybiBkaXI7XG59XG4iXSwibmFtZXMiOlsicmVzb2x2ZVRhcmdldERpciIsInBvc2l0aW9uYWwiLCJmbGFnIiwiZGlyIiwidHJpbSJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBQ0QsT0FBTyxTQUFTQSxpQkFBaUJDLFVBQW1CLEVBQUVDLElBQWE7SUFDbEUsTUFBTUMsTUFBTUYsWUFBWUcsVUFBVUYsTUFBTUUsVUFBVTtJQUNsRCxPQUFPRDtBQUNSIn0=

package/es6/src/services/scaffold.service.js

@@ -0,0 +1,52 @@
+async function scaffold(workspace, cliOptions, features) {
+    const options = await getAllOptions(workspace, cliOptions, features);
+    // Features mutate workspace models first, then workspace renders to disk.
+    await scaffoldFeatures(workspace, options, features);
+    await scaffoldWorkspace(workspace, options);
+    // Post-write phase: install deps, print final messages, etc.
+    await finalizeFeatures(workspace, options, features);
+}
+async function scaffoldWorkspace(workspace, _options) {
+    await workspace.scaffold();
+}
+/**
+ * Iterate features in order, calling `getOptions` on each.
+ * Each feature receives the running merged options so later features can
+ * branch on decisions made by earlier ones (e.g. database choice affects auth).
+ * Results are shallow-merged, so features only need to return what they own.
+ */ async function getAllOptions(workspace, cliOptions, features) {
+    let options = {
+        ...cliOptions
+    };
+    for (const feature of features){
+        const featureOptions = await feature.getOptions(workspace, options);
+        options = {
+            ...options,
+            ...featureOptions
+        };
+    }
+    return options;
+}
+/**
+ * Iterate features in order, calling `scaffold` with the fully-resolved options.
+ * All option-gathering is complete before any scaffolding begins.
+ */ async function scaffoldFeatures(workspace, options, features) {
+    for (const feature of features){
+        await feature.scaffold(workspace, options);
+    }
+}
+/**
+ * Iterate features in order, calling `finalize` on each (if defined).
+ * All files are on disk by this point.
+ */ async function finalizeFeatures(workspace, options, features) {
+    for (const feature of features){
+        if (feature.finalize) {
+            await feature.finalize(workspace, options);
+        }
+    }
+}
+export const ScaffoldService = {
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/version.js

@@ -0,0 +1,36 @@
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const _require = createRequire(import.meta.url);
+const DEFAULT_CREATE_VERSION = "0.0.1-dev";
+const DEFAULT_CREATE_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/create";
+const DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY = "ghcr.io/typesmiths/decohere/devcontainer";
+function resolveCreateMetadata() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require(join(dir, "package.json"));
+            if (pkg.name === "@decohere/scaffold") {
+                return {
+                    version: pkg.version ?? DEFAULT_CREATE_VERSION,
+                    imageRepository: pkg.decohere?.dockerImageRepository ?? DEFAULT_CREATE_IMAGE_REPOSITORY,
+                    devcontainerImageRepository: pkg.decohere?.devcontainerImageRepository ?? DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+                };
+            }
+        } catch  {}
+        const parent = dirname(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return {
+        version: DEFAULT_CREATE_VERSION,
+        imageRepository: DEFAULT_CREATE_IMAGE_REPOSITORY,
+        devcontainerImageRepository: DEFAULT_DEVCONTAINER_IMAGE_REPOSITORY
+    };
+}
+const createMetadata = resolveCreateMetadata();
+/** Version of @decohere/create, used to pin scaffolded @decohere/* dependencies. */ export const CREATE_VERSION = createMetadata.version;
+/** Canonical published Docker repository for the @decohere/create builder image. */ export const CREATE_IMAGE_REPOSITORY = createMetadata.imageRepository;
+/** Published app Dev Container base (`docker pull` updates shared layers). */ export const DEVCONTAINER_IMAGE_REPOSITORY = createMetadata.devcontainerImageRepository;
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/webapi/api-name.js

@@ -0,0 +1,59 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DEFAULT_WEBAPI_NAME } from "./const.js";
+/** Lowercase npm-safe directory slug: `billing`, `admin-api`. */ export const API_NAME_PATTERN = /^[a-z][a-z0-9-]*$/;
+export class CreateCliError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "CreateCliError";
+    }
+}
+export function assertValidApiName(name) {
+    if (!API_NAME_PATTERN.test(name)) {
+        throw new CreateCliError(`Invalid API name "${name}". Use a lowercase slug starting with a letter, then letters, digits, or hyphens (e.g. billing).`);
+    }
+}
+/** Default `["api"]` when the caller omitted `--name`. Rejects duplicates and invalid slugs. */ export function parseApiNames(raw) {
+    const names = raw != null && raw.length > 0 ? [
+        ...raw
+    ] : [
+        DEFAULT_WEBAPI_NAME
+    ];
+    const seen = new Set();
+    for (const name of names){
+        assertValidApiName(name);
+        if (seen.has(name)) {
+            throw new CreateCliError(`Duplicate API name "${name}".`);
+        }
+        seen.add(name);
+    }
+    return names;
+}
+export function isDecohereWorkspace(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        const build = pkg.scripts?.build;
+        return typeof build === "string" && build.includes("forge");
+    } catch  {
+        return false;
+    }
+}
+/** Directory names under `projects/` that already have a `package.json`. */ export function listExistingApiNames(dir) {
+    const projectsDir = join(dir, "projects");
+    try {
+        return readdirSync(projectsDir, {
+            withFileTypes: true
+        }).filter((entry)=>entry.isDirectory() && existsSync(join(projectsDir, entry.name, "package.json"))).map((entry)=>entry.name).sort();
+    } catch  {
+        return [];
+    }
+}
+/** `billing` → `BILLING`, `admin-api` → `ADMIN_API` — prefix for `{PREFIX}_DB_HOST`. */ export function apiEnvPrefix(apiName) {
+    return apiName.replace(/-/g, "_").toUpperCase();
+}
+export function apiNameFromProjectDir(dir) {
+    const slash = dir.lastIndexOf("/");
+    return slash >= 0 ? dir.slice(slash + 1) : dir;
+}
+
+//# sourceMappingURL=data:application/json;base64,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