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

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PackageJson () {
+        return PackageJson;
+    },
+    get sortStringMap () {
+        return sortStringMap;
+    }
+});
+const _nodefs = require("node:fs");
+const _version = require("../version.js");
+const _const = require("../webapi/const.js");
+const _const1 = require("./const.js");
+class PackageJson {
+    name;
+    key = _const1.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 ?? [
+            _const.DEFAULT_WEBAPI_NAME
+        ];
+        const first = apiNames[0] ?? _const.DEFAULT_WEBAPI_NAME;
+        const startEntry = options?.startEntry ?? (0, _const.webapiReleaseEntry)(first);
+        const workspaceName = options?.workspaceName ?? stripApiSuffix(name);
+        const namedOrMany = apiNames.length > 1 || first !== _const.DEFAULT_WEBAPI_NAME;
+        this._scripts = {
+            build: "forge build --configuration release",
+            "build:watch": "forge build --watch",
+            start: `node ${startEntry}`,
+            dev: namedOrMany ? fluxDevScript(workspaceName, first, (0, _const.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 ${(0, _const.webapiReleaseEntry)(apiName)}`;
+            this._scripts[`dev:${apiName}`] = fluxDevScript(workspaceName, apiName, (0, _const.webapiPort)(index));
+        }
+        this._dependencies = {
+            "@decohere/cortex": _version.CREATE_VERSION,
+            "@decohere/crucible": _version.CREATE_VERSION,
+            "@decohere/nexus": _version.CREATE_VERSION,
+            "@decohere/protocol": _version.CREATE_VERSION,
+            "@decohere/scribe": _version.CREATE_VERSION,
+            "@decohere/scribe-pino": _version.CREATE_VERSION,
+            "pino-pretty": "^13.0.0",
+            "pino-roll": "^4.0.0"
+        };
+        this._devDependencies = {
+            "@decohere/forge": _version.CREATE_VERSION,
+            "@decohere/cli": _version.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((0, _nodefs.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;
+}
+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 ${(0, _const.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":["PackageJson","sortStringMap","key","WELL_KNOWN_FILES","PACKAGE_JSON","_dependencies","_devDependencies","_scripts","_version","_type","_rest","name","options","apiNames","DEFAULT_WEBAPI_NAME","first","startEntry","webapiReleaseEntry","workspaceName","stripApiSuffix","namedOrMany","length","build","start","dev","fluxDevScript","webapiPort","typecheck","test","index","apiName","entries","CREATE_VERSION","typescript","vitest","fromFile","filePath","raw","JSON","parse","readFileSync","pkg","version","type","asStringMap","scripts","dependencies","devDependencies","reserved","Set","Object","fromEntries","filter","has","addDependency","addDevDependency","addScript","command","hasScript","files","content","stringify","endsWith","slice","value","result","entry","map","sort","left","right","localeCompare","port","webapiPackageName"],"mappings":"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"}

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get MonoRepoScaffold () {
+        return MonoRepoScaffold;
+    },
+    get ProjectScaffold () {
+        return ProjectScaffold;
+    },
+    get WorkspaceScaffold () {
+        return WorkspaceScaffold;
+    }
+});
+const _promises = require("node:fs/promises");
+const _nodepath = require("node:path");
+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
+            }));
+    }
+}
+class WorkspaceScaffold {
+    files = [];
+    targetDir = process.cwd();
+    _name;
+    /** Project name — host directory basename, not the in-container mount path. */ get name() {
+        return this._name ?? (0, _nodepath.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;
+    }
+}
+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 = (0, _nodepath.join)(this.targetDir, file.filePath);
+            await (0, _promises.mkdir)((0, _nodepath.dirname)(fullPath), {
+                recursive: true
+            });
+            await (0, _promises.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":["MonoRepoScaffold","ProjectScaffold","WorkspaceScaffold","_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","targetDir","process","cwd","_name","name","basename","setName","_projects","addProject","project","getProject","find","p","getProjects","undefined","pm","scaffold","allFiles","Promise","file","fullPath","join","mkdir","dirname","recursive","writeFile"],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TsConfig", {
+    enumerable: true,
+    get: function() {
+        return TsConfig;
+    }
+});
+const _const = require("./const.js");
+class TsConfig {
+    key = _const.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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdHNjb25maWcubW9kZWwudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgV0VMTF9LTk9XTl9GSUxFUyB9IGZyb20gXCIuL2NvbnN0LmpzXCI7XG5pbXBvcnQgdHlwZSB7IEtleWVkTW9kZWwsIFNvdXJjZUZpbGUgfSBmcm9tIFwiLi9zb3VyY2UtZmlsZS5qc1wiO1xuXG5leHBvcnQgY2xhc3MgVHNDb25maWcgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuVFNDT05GSUc7XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0cmV0dXJuIFtcblx0XHRcdHtcblx0XHRcdFx0ZmlsZVBhdGg6IFwidHNjb25maWcuanNvblwiLFxuXHRcdFx0XHRjb250ZW50OiBKU09OLnN0cmluZ2lmeShcblx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHRjb21waWxlck9wdGlvbnM6IHtcblx0XHRcdFx0XHRcdFx0dGFyZ2V0OiBcIkVTMjAyMlwiLFxuXHRcdFx0XHRcdFx0XHRtb2R1bGU6IFwiTm9kZU5leHRcIixcblx0XHRcdFx0XHRcdFx0bW9kdWxlUmVzb2x1dGlvbjogXCJOb2RlTmV4dFwiLFxuXHRcdFx0XHRcdFx0XHRzdHJpY3Q6IHRydWUsXG5cdFx0XHRcdFx0XHRcdHNraXBMaWJDaGVjazogdHJ1ZSxcblx0XHRcdFx0XHRcdFx0ZXhwZXJpbWVudGFsRGVjb3JhdG9yczogdHJ1ZSxcblx0XHRcdFx0XHRcdFx0ZW1pdERlY29yYXRvck1ldGFkYXRhOiB0cnVlLFxuXHRcdFx0XHRcdFx0fSxcblx0XHRcdFx0XHR9LFxuXHRcdFx0XHRcdG51bGwsXG5cdFx0XHRcdFx0Mixcblx0XHRcdFx0KSxcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIlRzQ29uZmlnIiwia2V5IiwiV0VMTF9LTk9XTl9GSUxFUyIsIlRTQ09ORklHIiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJKU09OIiwic3RyaW5naWZ5IiwiY29tcGlsZXJPcHRpb25zIiwidGFyZ2V0IiwibW9kdWxlIiwibW9kdWxlUmVzb2x1dGlvbiIsInN0cmljdCIsInNraXBMaWJDaGVjayIsImV4cGVyaW1lbnRhbERlY29yYXRvcnMiLCJlbWl0RGVjb3JhdG9yTWV0YWRhdGEiXSwibWFwcGluZ3MiOiI7Ozs7K0JBR2FBOzs7ZUFBQUE7Ozt1QkFIb0I7QUFHMUIsTUFBTUE7SUFDSUMsTUFBTUMsdUJBQWdCLENBQUNDLFFBQVEsQ0FBQztJQUV6Q0MsUUFBc0I7UUFDNUIsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTQyxLQUFLQyxTQUFTLENBQ3RCO29CQUNDQyxpQkFBaUI7d0JBQ2hCQyxRQUFRO3dCQUNSQyxRQUFRO3dCQUNSQyxrQkFBa0I7d0JBQ2xCQyxRQUFRO3dCQUNSQyxjQUFjO3dCQUNkQyx3QkFBd0I7d0JBQ3hCQyx1QkFBdUI7b0JBQ3hCO2dCQUNELEdBQ0EsTUFDQTtZQUVGO1NBQ0E7SUFDRjtBQUNEIn0=

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VitestConfig", {
+    enumerable: true,
+    get: function() {
+        return VitestConfig;
+    }
+});
+const _const = require("./const.js");
+class VitestConfig {
+    key = _const.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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdml0ZXN0LWNvbmZpZy5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBWaXRlc3RDb25maWcgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuVklURVNUX0NPTkZJRztcblxuXHRwdWJsaWMgZmlsZXMoKTogU291cmNlRmlsZVtdIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCJ2aXRlc3QuY29uZmlnLnRzXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IFtcblx0XHRcdFx0XHQnaW1wb3J0IHsgZm9yZ2VCdWlsZCB9IGZyb20gXCJAZGVjb2hlcmUvZm9yZ2Uvdml0ZXN0XCI7Jyxcblx0XHRcdFx0XHQnaW1wb3J0IHsgZGVmaW5lQ29uZmlnIH0gZnJvbSBcInZpdGVzdC9jb25maWdcIjsnLFxuXHRcdFx0XHRcdFwiXCIsXG5cdFx0XHRcdFx0XCJleHBvcnQgZGVmYXVsdCBkZWZpbmVDb25maWcoe1wiLFxuXHRcdFx0XHRcdCdcXHRwbHVnaW5zOiBbZm9yZ2VCdWlsZCh7IGxvZ0xldmVsOiBcInNpbGVudFwiIH0pXSwnLFxuXHRcdFx0XHRcdFwiXFx0dGVzdDoge1wiLFxuXHRcdFx0XHRcdCdcXHRcXHRpbmNsdWRlOiBbXCJwcm9qZWN0cy8qKi8qLnt0ZXN0LHNwZWN9Lj8oY3xtKVtqdF1zPyh4KVwiXSwnLFxuXHRcdFx0XHRcdFwiXFx0fSxcIixcblx0XHRcdFx0XHRcIn0pO1wiLFxuXHRcdFx0XHRcdFwiXCIsXG5cdFx0XHRcdF0uam9pbihcIlxcblwiKSxcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIlZpdGVzdENvbmZpZyIsImtleSIsIldFTExfS05PV05fRklMRVMiLCJWSVRFU1RfQ09ORklHIiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJqb2luIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7dUJBSG9CO0FBRzFCLE1BQU1BO0lBQ0lDLE1BQU1DLHVCQUFnQixDQUFDQyxhQUFhLENBQUM7SUFFOUNDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBUztvQkFDUjtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtvQkFDQTtpQkFDQSxDQUFDQyxJQUFJLENBQUM7WUFDUjtTQUNBO0lBQ0Y7QUFDRCJ9

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "VSCodeSettings", {
+    enumerable: true,
+    get: function() {
+        return VSCodeSettings;
+    }
+});
+const _const = require("./const.js");
+class VSCodeSettings {
+    title;
+    key = _const.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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9tb2RlbHMvdnNjb2RlLXNldHRpbmdzLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdFTExfS05PV05fRklMRVMgfSBmcm9tIFwiLi9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4vc291cmNlLWZpbGUuanNcIjtcblxuZXhwb3J0IGNsYXNzIFZTQ29kZVNldHRpbmdzIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHB1YmxpYyByZWFkb25seSBrZXkgPSBXRUxMX0tOT1dOX0ZJTEVTLlZTQ09ERV9TRVRUSU5HUztcblxuXHRwdWJsaWMgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSB0aXRsZTogc3RyaW5nKSB7fVxuXG5cdHB1YmxpYyBmaWxlcygpOiBTb3VyY2VGaWxlW10ge1xuXHRcdHJldHVybiBbXG5cdFx0XHR7XG5cdFx0XHRcdGZpbGVQYXRoOiBcIi52c2NvZGUvc2V0dGluZ3MuanNvblwiLFxuXHRcdFx0XHRjb250ZW50OiBKU09OLnN0cmluZ2lmeShcblx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHRcIndpbmRvdy50aXRsZVwiOiBgJHt0aGlzLnRpdGxlfVxcJHtzZXBhcmF0b3J9XFwke2FjdGl2ZUVkaXRvclNob3J0fWAsXG5cdFx0XHRcdFx0XHRcIndpbmRvdy50aXRsZVNlcGFyYXRvclwiOiBcIiB8IFwiLFxuXHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0bnVsbCxcblx0XHRcdFx0XHQyLFxuXHRcdFx0XHQpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiVlNDb2RlU2V0dGluZ3MiLCJrZXkiLCJXRUxMX0tOT1dOX0ZJTEVTIiwiVlNDT0RFX1NFVFRJTkdTIiwidGl0bGUiLCJmaWxlcyIsImZpbGVQYXRoIiwiY29udGVudCIsIkpTT04iLCJzdHJpbmdpZnkiXSwibWFwcGluZ3MiOiI7Ozs7K0JBR2FBOzs7ZUFBQUE7Ozt1QkFIb0I7QUFHMUIsTUFBTUE7O0lBQ0lDLE1BQU1DLHVCQUFnQixDQUFDQyxlQUFlLENBQUM7SUFFdkQsWUFBbUIsQUFBaUJDLEtBQWEsQ0FBRTthQUFmQSxRQUFBQTtJQUFnQjtJQUU3Q0MsUUFBc0I7UUFDNUIsT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTQyxLQUFLQyxTQUFTLENBQ3RCO29CQUNDLGdCQUFnQixHQUFHLElBQUksQ0FBQ0wsS0FBSyxDQUFDLGtDQUFrQyxDQUFDO29CQUNqRSx5QkFBeUI7Z0JBQzFCLEdBQ0EsTUFDQTtZQUVGO1NBQ0E7SUFDRjtBQUNEIn0=

package/commonjs/src/program.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get createProgram () {
+        return createProgram;
+    },
+    get runCli () {
+        return runCli;
+    }
+});
+const _commander = require("commander");
+const _apiname = require("./webapi/api-name.js");
+const _clioptions = require("./webapi/cli-options.js");
+function createProgram() {
+    const program = new _commander.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");
+    (0, _clioptions.addWebapiFeatureOptions)(create.command("webapi").argument("[directory]", "Target directory (default: -d or current directory)").option("--name <slug>", "API name under projects/ (repeatable; default: api)", _clioptions.collectName, [])).action(async (directory, _opts, cmd)=>{
+        await (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(directory, cmd.optsWithGlobals()));
+    });
+    (0, _clioptions.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 (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(undefined, cmd.optsWithGlobals(), {
+            names: [
+                name
+            ],
+            add: true
+        }));
+    });
+    return program;
+}
+async function runCli(argv = process.argv) {
+    try {
+        await createProgram().parseAsync(argv);
+    } catch (err) {
+        if (err instanceof _commander.CommanderError) {
+            process.exit(err.exitCode);
+        }
+        if (err instanceof _apiname.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,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

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

@@ -0,0 +1,19 @@
+/**
+ * Resolve scaffold destination: positional `webapi my-app` wins over `-d`.
+ * `npm create … webapi -d my-app` drops `-d` (npm loglevel) and forwards `my-app`.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "resolveTargetDir", {
+    enumerable: true,
+    get: function() {
+        return resolveTargetDir;
+    }
+});
+function resolveTargetDir(positional, flag) {
+    const dir = positional?.trim() || flag?.trim() || ".";
+    return dir;
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjYWZmb2xkL3NyYy9yZXNvbHZlLXRhcmdldC1kaXIudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXNvbHZlIHNjYWZmb2xkIGRlc3RpbmF0aW9uOiBwb3NpdGlvbmFsIGB3ZWJhcGkgbXktYXBwYCB3aW5zIG92ZXIgYC1kYC5cbiAqIGBucG0gY3JlYXRlIOKApiB3ZWJhcGkgLWQgbXktYXBwYCBkcm9wcyBgLWRgIChucG0gbG9nbGV2ZWwpIGFuZCBmb3J3YXJkcyBgbXktYXBwYC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHJlc29sdmVUYXJnZXREaXIocG9zaXRpb25hbD86IHN0cmluZywgZmxhZz86IHN0cmluZyk6IHN0cmluZyB7XG5cdGNvbnN0IGRpciA9IHBvc2l0aW9uYWw/LnRyaW0oKSB8fCBmbGFnPy50cmltKCkgfHwgXCIuXCI7XG5cdHJldHVybiBkaXI7XG59XG4iXSwibmFtZXMiOlsicmVzb2x2ZVRhcmdldERpciIsInBvc2l0aW9uYWwiLCJmbGFnIiwiZGlyIiwidHJpbSJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDOzs7OytCQUNlQTs7O2VBQUFBOzs7QUFBVCxTQUFTQSxpQkFBaUJDLFVBQW1CLEVBQUVDLElBQWE7SUFDbEUsTUFBTUMsTUFBTUYsWUFBWUcsVUFBVUYsTUFBTUUsVUFBVTtJQUNsRCxPQUFPRDtBQUNSIn0=

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ScaffoldService", {
+    enumerable: true,
+    get: function() {
+        return ScaffoldService;
+    }
+});
+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);
+        }
+    }
+}
+const ScaffoldService = {
+    scaffold
+};
+
+//# sourceMappingURL=data:application/json;base64,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