@decohere/create 0.0.1-dev.17 → 0.0.1-dev.19

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PackageJson", {
+    enumerable: true,
+    get: function() {
+        return PackageJson;
+    }
+});
+const _version = require("../version.js");
+const _const = require("./const.js");
+class PackageJson {
+    name;
+    key = _const.WELL_KNOWN_FILES.PACKAGE_JSON;
+    _dependencies;
+    _devDependencies;
+    constructor(name){
+        this.name = name;
+        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"
+        };
+        this._devDependencies = {
+            "@decohere/terminal": _version.CREATE_VERSION,
+            typescript: "^6.0.3",
+            "@biomejs/biome": "^2.0.0"
+        };
+    }
+    addDependency(name, version) {
+        this._dependencies[name] = version;
+        return this;
+    }
+    addDevDependency(name, version) {
+        this._devDependencies[name] = version;
+        return this;
+    }
+    files() {
+        return [
+            {
+                filePath: "package.json",
+                content: JSON.stringify({
+                    name: this.name,
+                    version: "0.0.1",
+                    type: "module",
+                    scripts: {
+                        build: "forge build",
+                        "build:watch": "forge build --watch",
+                        dev: "flux serve"
+                    },
+                    dependencies: this._dependencies,
+                    devDependencies: this._devDependencies
+                }, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,126 @@
+"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();
+    /** Derived from the basename of targetDir. */ get name() {
+        return (0, _nodepath.basename)(this.targetDir);
+    }
+    /** 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);
+    }
+    /** 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/create/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\n\t/** Derived from the basename of targetDir. */\n\tpublic get name(): string {\n\t\treturn basename(this.targetDir);\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 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/** 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","basename","_projects","addProject","project","getProject","find","p","undefined","pm","scaffold","allFiles","Promise","file","fullPath","join","mkdir","dirname","recursive","writeFile"],"mappings":";;;;;;;;;;;QAkEaA;eAAAA;;QAvDAC;eAAAA;;QA+BSC;eAAAA;;;0BA1CW;0BACO;AAUjC,MAAMD;;IACKE,UAAU,IAAIC,MAAkC;IAChDC,SAAuB,EAAE,CAAC;IAE3C,YAAmB,AAAgBC,GAAW,CAAE;aAAbA,MAAAA;IAAc;IAE1CC,SAA+BC,KAAQ,EAAK;QAClD,IAAI,CAACL,OAAO,CAACM,GAAG,CAACD,MAAME,GAAG,EAAEF;QAC5B,OAAOA;IACR;IAEOG,QAAQC,QAA4B,EAAQ;QAClD,IAAI,CAACP,MAAM,CAACQ,IAAI,IAAID,SAASE,KAAK;QAClC,OAAO,IAAI;IACZ;IAEOC,SAAuCL,GAAW,EAAiB;QACzE,OAAO,IAAI,CAACP,OAAO,CAACa,GAAG,CAACN;IACzB;IAEOO,UAAwCC,IAAiC,EAAO;QACtF,OAAO;eAAI,IAAI,CAACf,OAAO,CAACgB,MAAM;SAAG,CAACC,MAAM,CAAC,CAACC,IAAcA,aAAaH;IACtE;IAEA,0DAA0D,GAC1D,AAAOJ,QAAsB;QAC5B,MAAMQ,MAAM;eAAI,IAAI,CAACjB,MAAM;eAAK;mBAAI,IAAI,CAACF,OAAO,CAACgB,MAAM;aAAG,CAACI,OAAO,CAAC,CAACF,IAAMA,EAAEP,KAAK;SAAI;QACrF,OAAOQ,IAAIE,GAAG,CAAC,CAACC,IAAO,CAAA;gBAAEC,UAAU,GAAG,IAAI,CAACpB,GAAG,CAAC,CAAC,EAAEmB,EAAEC,QAAQ,EAAE;gBAAEC,SAASF,EAAEE,OAAO;YAAC,CAAA;IACpF;AACD;AAEO,MAAezB;IACLY,QAAsB,EAAE,CAAC;IAClCc,YAAoBC,QAAQC,GAAG,GAAG;IAEzC,4CAA4C,GAC5C,IAAWC,OAAe;QACzB,OAAOC,IAAAA,kBAAQ,EAAC,IAAI,CAACJ,SAAS;IAC/B;IAEA,yEAAyE,GACzE,AAAOjB,QAAQC,QAA4B,EAAQ;QAClD,IAAI,CAACE,KAAK,CAACD,IAAI,IAAID,SAASE,KAAK;QACjC,OAAO,IAAI;IACZ;AASD;AAEO,MAAMd,yBAAyBE;IACpBC,UAAU,IAAIC,MAAkC;IAChD6B,YAA+B,EAAE,CAAC;IAEnD,8BAA8B,GAC9B,AAAOC,WAAWC,OAAwB,EAAmB;QAC5D,IAAI,CAACF,SAAS,CAACpB,IAAI,CAACsB;QACpB,OAAOA;IACR;IAEA,oEAAoE,GACpE,AAAOC,WAAW9B,GAAW,EAA+B;QAC3D,OAAO,IAAI,CAAC2B,SAAS,CAACI,IAAI,CAAC,CAACC,IAAMA,EAAEhC,GAAG,KAAKA;IAC7C;IAEA,+CAA+C,GAC/C,AAAOC,SAA+BC,KAAQ,EAAK;QAClD,IAAI,CAACL,OAAO,CAACM,GAAG,CAACD,MAAME,GAAG,EAAEF;QAC5B,OAAOA;IACR;IAEA;;;EAGC,GACD,AAAOO,SAAuCL,GAAW,EAAiB;QACzE,MAAMW,IAAI,IAAI,CAAClB,OAAO,CAACa,GAAG,CAACN;QAC3B,IAAIW,MAAMkB,WAAW,OAAOlB;QAC5B,KAAK,MAAMc,WAAW,IAAI,CAACF,SAAS,CAAE;YACrC,MAAMO,KAAKL,QAAQpB,QAAQ,CAAIL;YAC/B,IAAI8B,OAAOD,WAAW,OAAOC;QAC9B;QACA,OAAOD;IACR;IAEA;;;EAGC,GACD,AAAOtB,UAAwCC,IAAiC,EAAO;QACtF,OAAO;eACH;mBAAI,IAAI,CAACf,OAAO,CAACgB,MAAM;aAAG,CAACC,MAAM,CAAC,CAACC,IAAcA,aAAaH;eAC9D,IAAI,CAACe,SAAS,CAACV,OAAO,CAAC,CAACe,IAAMA,EAAErB,SAAS,CAACC;SAC7C;IACF;IAEA,8EAA8E,GAC9E,MAAauB,WAA0B;QACtC,MAAMC,WAAW;eACb,IAAI,CAAC5B,KAAK;eACV;mBAAI,IAAI,CAACX,OAAO,CAACgB,MAAM;aAAG,CAACI,OAAO,CAAC,CAACF,IAAMA,EAAEP,KAAK;eACjD,IAAI,CAACmB,SAAS,CAACV,OAAO,CAAC,CAACe,IAAMA,EAAExB,KAAK;SACxC;QAED,MAAM6B,QAAQrB,GAAG,CAChBoB,SAASlB,GAAG,CAAC,OAAOoB;YACnB,MAAMC,WAAWC,IAAAA,cAAI,EAAC,IAAI,CAAClB,SAAS,EAAEgB,KAAKlB,QAAQ;YACnD,MAAMqB,IAAAA,eAAK,EAACC,IAAAA,iBAAO,EAACH,WAAW;gBAAEI,WAAW;YAAK;YACjD,MAAMC,IAAAA,mBAAS,EAACL,UAAUD,KAAKjB,OAAO;QACvC;IAEF;AACD"}

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL3RzY29uZmlnLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdFTExfS05PV05fRklMRVMgfSBmcm9tIFwiLi9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4vc291cmNlLWZpbGUuanNcIjtcblxuZXhwb3J0IGNsYXNzIFRzQ29uZmlnIGltcGxlbWVudHMgS2V5ZWRNb2RlbCB7XG5cdHB1YmxpYyByZWFkb25seSBrZXkgPSBXRUxMX0tOT1dOX0ZJTEVTLlRTQ09ORklHO1xuXG5cdHB1YmxpYyBmaWxlcygpOiBTb3VyY2VGaWxlW10ge1xuXHRcdHJldHVybiBbXG5cdFx0XHR7XG5cdFx0XHRcdGZpbGVQYXRoOiBcInRzY29uZmlnLmpzb25cIixcblx0XHRcdFx0Y29udGVudDogSlNPTi5zdHJpbmdpZnkoXG5cdFx0XHRcdFx0e1xuXHRcdFx0XHRcdFx0Y29tcGlsZXJPcHRpb25zOiB7XG5cdFx0XHRcdFx0XHRcdHRhcmdldDogXCJFUzIwMjJcIixcblx0XHRcdFx0XHRcdFx0bW9kdWxlOiBcIk5vZGVOZXh0XCIsXG5cdFx0XHRcdFx0XHRcdG1vZHVsZVJlc29sdXRpb246IFwiTm9kZU5leHRcIixcblx0XHRcdFx0XHRcdFx0c3RyaWN0OiB0cnVlLFxuXHRcdFx0XHRcdFx0XHRza2lwTGliQ2hlY2s6IHRydWUsXG5cdFx0XHRcdFx0XHRcdGV4cGVyaW1lbnRhbERlY29yYXRvcnM6IHRydWUsXG5cdFx0XHRcdFx0XHRcdGVtaXREZWNvcmF0b3JNZXRhZGF0YTogdHJ1ZSxcblx0XHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0fSxcblx0XHRcdFx0XHRudWxsLFxuXHRcdFx0XHRcdDIsXG5cdFx0XHRcdCksXG5cdFx0XHR9LFxuXHRcdF07XG5cdH1cbn1cbiJdLCJuYW1lcyI6WyJUc0NvbmZpZyIsImtleSIsIldFTExfS05PV05fRklMRVMiLCJUU0NPTkZJRyIsImZpbGVzIiwiZmlsZVBhdGgiLCJjb250ZW50IiwiSlNPTiIsInN0cmluZ2lmeSIsImNvbXBpbGVyT3B0aW9ucyIsInRhcmdldCIsIm1vZHVsZSIsIm1vZHVsZVJlc29sdXRpb24iLCJzdHJpY3QiLCJza2lwTGliQ2hlY2siLCJleHBlcmltZW50YWxEZWNvcmF0b3JzIiwiZW1pdERlY29yYXRvck1ldGFkYXRhIl0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7dUJBSG9CO0FBRzFCLE1BQU1BO0lBQ0lDLE1BQU1DLHVCQUFnQixDQUFDQyxRQUFRLENBQUM7SUFFekNDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBU0MsS0FBS0MsU0FBUyxDQUN0QjtvQkFDQ0MsaUJBQWlCO3dCQUNoQkMsUUFBUTt3QkFDUkMsUUFBUTt3QkFDUkMsa0JBQWtCO3dCQUNsQkMsUUFBUTt3QkFDUkMsY0FBYzt3QkFDZEMsd0JBQXdCO3dCQUN4QkMsdUJBQXVCO29CQUN4QjtnQkFDRCxHQUNBLE1BQ0E7WUFFRjtTQUNBO0lBQ0Y7QUFDRCJ9

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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL3ZzY29kZS1zZXR0aW5ncy5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBWU0NvZGVTZXR0aW5ncyBpbXBsZW1lbnRzIEtleWVkTW9kZWwge1xuXHRwdWJsaWMgcmVhZG9ubHkga2V5ID0gV0VMTF9LTk9XTl9GSUxFUy5WU0NPREVfU0VUVElOR1M7XG5cblx0cHVibGljIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgdGl0bGU6IHN0cmluZykge31cblxuXHRwdWJsaWMgZmlsZXMoKTogU291cmNlRmlsZVtdIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIudnNjb2RlL3NldHRpbmdzLmpzb25cIixcblx0XHRcdFx0Y29udGVudDogSlNPTi5zdHJpbmdpZnkoXG5cdFx0XHRcdFx0e1xuXHRcdFx0XHRcdFx0XCJ3aW5kb3cudGl0bGVcIjogYCR7dGhpcy50aXRsZX1cXCR7c2VwYXJhdG9yfVxcJHthY3RpdmVFZGl0b3JTaG9ydH1gLFxuXHRcdFx0XHRcdFx0XCJ3aW5kb3cudGl0bGVTZXBhcmF0b3JcIjogXCIgfCBcIixcblx0XHRcdFx0XHR9LFxuXHRcdFx0XHRcdG51bGwsXG5cdFx0XHRcdFx0Mixcblx0XHRcdFx0KSxcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIlZTQ29kZVNldHRpbmdzIiwia2V5IiwiV0VMTF9LTk9XTl9GSUxFUyIsIlZTQ09ERV9TRVRUSU5HUyIsInRpdGxlIiwiZmlsZXMiLCJmaWxlUGF0aCIsImNvbnRlbnQiLCJKU09OIiwic3RyaW5naWZ5Il0sIm1hcHBpbmdzIjoiOzs7OytCQUdhQTs7O2VBQUFBOzs7dUJBSG9CO0FBRzFCLE1BQU1BOztJQUNJQyxNQUFNQyx1QkFBZ0IsQ0FBQ0MsZUFBZSxDQUFDO0lBRXZELFlBQW1CLEFBQWlCQyxLQUFhLENBQUU7YUFBZkEsUUFBQUE7SUFBZ0I7SUFFN0NDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBU0MsS0FBS0MsU0FBUyxDQUN0QjtvQkFDQyxnQkFBZ0IsR0FBRyxJQUFJLENBQUNMLEtBQUssQ0FBQyxrQ0FBa0MsQ0FBQztvQkFDakUseUJBQXlCO2dCQUMxQixHQUNBLE1BQ0E7WUFFRjtTQUNBO0lBQ0Y7QUFDRCJ9

package/commonjs/src/runner.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "runInBuilder", {
+    enumerable: true,
+    get: function() {
+        return runInBuilder;
+    }
+});
+const _nodechild_process = require("node:child_process");
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _version = require("./version.js");
+const BUILDER_IMAGE = `ghcr.io/decohere/scaffold:${_version.CREATE_VERSION}`;
+function runInBuilder(opts) {
+    const targetDir = (0, _nodepath.resolve)(opts.d ?? ".");
+    (0, _nodefs.mkdirSync)(targetDir, {
+        recursive: true
+    });
+    // Ensure Docker is available.
+    try {
+        (0, _nodechild_process.execFileSync)("docker", [
+            "info"
+        ], {
+            stdio: "pipe"
+        });
+    } catch  {
+        console.error("\n  Docker is required to scaffold a Decohere project.\n" + "  Install Docker Desktop: https://www.docker.com/products/docker-desktop\n");
+        process.exit(1);
+    }
+    const volumes = [
+        "-v",
+        `${targetDir}:/workspace`
+    ];
+    console.log("  Running scaffolding in a sandboxed container...\n");
+    const result = (0, _nodechild_process.spawnSync)("docker", [
+        "run",
+        "--rm",
+        "-it",
+        ...volumes,
+        "-e",
+        "DECOHERE_BUILDER=1",
+        "-w",
+        "/workspace",
+        BUILDER_IMAGE,
+        "webapi",
+        "-d",
+        "."
+    ], {
+        stdio: "inherit"
+    });
+    process.exit(result.status ?? 0);
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvcnVubmVyLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGV4ZWNGaWxlU3luYywgc3Bhd25TeW5jIH0gZnJvbSBcIm5vZGU6Y2hpbGRfcHJvY2Vzc1wiO1xuaW1wb3J0IHsgbWtkaXJTeW5jIH0gZnJvbSBcIm5vZGU6ZnNcIjtcbmltcG9ydCB7IHJlc29sdmUgfSBmcm9tIFwibm9kZTpwYXRoXCI7XG5pbXBvcnQgeyBDUkVBVEVfVkVSU0lPTiB9IGZyb20gXCIuL3ZlcnNpb24uanNcIjtcblxuY29uc3QgQlVJTERFUl9JTUFHRSA9IGBnaGNyLmlvL2RlY29oZXJlL3NjYWZmb2xkOiR7Q1JFQVRFX1ZFUlNJT059YDtcblxuLyoqXG4gKiBSdW4gdGhlIHNjYWZmb2xkIGluc2lkZSBhIHByZS1idWlsdCBEb2NrZXIgYnVpbGRlciBpbWFnZS5cbiAqXG4gKiBDYWxsZWQgd2hlbiBgREVDT0hFUkVfQlVJTERFUmAgaXMgbm90IHNldCDigJQgaS5lLiB0aGUgQ0xJIGlzIHJ1bm5pbmcgb24gdGhlXG4gKiBob3N0LCBvdXRzaWRlIHRoZSBjb250YWluZXIuIE1vdW50cyB0aGUgdGFyZ2V0IGRpcmVjdG9yeSBhcyBgL3dvcmtzcGFjZWAgc29cbiAqIHRoZSBzY2FmZm9sZGVkIGZpbGVzIGFyZSB3cml0dGVuIGJhY2sgdG8gdGhlIGhvc3QgZmlsZXN5c3RlbS5cbiAqXG4gKiBJZiBgfi8uY29uZmlnL2F1dGgwYCBleGlzdHMgb24gdGhlIGhvc3QgdGhlIGRpcmVjdG9yeSBpcyBhbHNvIG1vdW50ZWQgc29cbiAqIHRoZSBhdXRoMCBDTEkgaW5zaWRlIHRoZSBjb250YWluZXIgY2FuIHJldXNlIGV4aXN0aW5nIGNyZWRlbnRpYWxzIHNpbGVudGx5LlxuICovXG5leHBvcnQgZnVuY3Rpb24gcnVuSW5CdWlsZGVyKG9wdHM6IHsgZD86IHN0cmluZyB9KTogbmV2ZXIge1xuXHRjb25zdCB0YXJnZXREaXIgPSByZXNvbHZlKG9wdHMuZCA/PyBcIi5cIik7XG5cdG1rZGlyU3luYyh0YXJnZXREaXIsIHsgcmVjdXJzaXZlOiB0cnVlIH0pO1xuXG5cdC8vIEVuc3VyZSBEb2NrZXIgaXMgYXZhaWxhYmxlLlxuXHR0cnkge1xuXHRcdGV4ZWNGaWxlU3luYyhcImRvY2tlclwiLCBbXCJpbmZvXCJdLCB7IHN0ZGlvOiBcInBpcGVcIiB9KTtcblx0fSBjYXRjaCB7XG5cdFx0Y29uc29sZS5lcnJvcihcblx0XHRcdFwiXFxuICBEb2NrZXIgaXMgcmVxdWlyZWQgdG8gc2NhZmZvbGQgYSBEZWNvaGVyZSBwcm9qZWN0LlxcblwiICtcblx0XHRcdFx0XCIgIEluc3RhbGwgRG9ja2VyIERlc2t0b3A6IGh0dHBzOi8vd3d3LmRvY2tlci5jb20vcHJvZHVjdHMvZG9ja2VyLWRlc2t0b3BcXG5cIixcblx0XHQpO1xuXHRcdHByb2Nlc3MuZXhpdCgxKTtcblx0fVxuXG5cdGNvbnN0IHZvbHVtZXM6IHN0cmluZ1tdID0gW1wiLXZcIiwgYCR7dGFyZ2V0RGlyfTovd29ya3NwYWNlYF07XG5cblx0Y29uc29sZS5sb2coXCIgIFJ1bm5pbmcgc2NhZmZvbGRpbmcgaW4gYSBzYW5kYm94ZWQgY29udGFpbmVyLi4uXFxuXCIpO1xuXG5cdGNvbnN0IHJlc3VsdCA9IHNwYXduU3luYyhcblx0XHRcImRvY2tlclwiLFxuXHRcdFtcblx0XHRcdFwicnVuXCIsXG5cdFx0XHRcIi0tcm1cIixcblx0XHRcdFwiLWl0XCIsXG5cdFx0XHQuLi52b2x1bWVzLFxuXHRcdFx0XCItZVwiLFxuXHRcdFx0XCJERUNPSEVSRV9CVUlMREVSPTFcIixcblx0XHRcdFwiLXdcIixcblx0XHRcdFwiL3dvcmtzcGFjZVwiLFxuXHRcdFx0QlVJTERFUl9JTUFHRSxcblx0XHRcdFwid2ViYXBpXCIsXG5cdFx0XHRcIi1kXCIsXG5cdFx0XHRcIi5cIixcblx0XHRdLFxuXHRcdHsgc3RkaW86IFwiaW5oZXJpdFwiIH0sXG5cdCk7XG5cblx0cHJvY2Vzcy5leGl0KHJlc3VsdC5zdGF0dXMgPz8gMCk7XG59XG4iXSwibmFtZXMiOlsicnVuSW5CdWlsZGVyIiwiQlVJTERFUl9JTUFHRSIsIkNSRUFURV9WRVJTSU9OIiwib3B0cyIsInRhcmdldERpciIsInJlc29sdmUiLCJkIiwibWtkaXJTeW5jIiwicmVjdXJzaXZlIiwiZXhlY0ZpbGVTeW5jIiwic3RkaW8iLCJjb25zb2xlIiwiZXJyb3IiLCJwcm9jZXNzIiwiZXhpdCIsInZvbHVtZXMiLCJsb2ciLCJyZXN1bHQiLCJzcGF3blN5bmMiLCJzdGF0dXMiXSwibWFwcGluZ3MiOiI7Ozs7K0JBaUJnQkE7OztlQUFBQTs7O21DQWpCd0I7d0JBQ2Q7MEJBQ0Y7eUJBQ087QUFFL0IsTUFBTUMsZ0JBQWdCLENBQUMsMEJBQTBCLEVBQUVDLHVCQUFjLEVBQUU7QUFZNUQsU0FBU0YsYUFBYUcsSUFBb0I7SUFDaEQsTUFBTUMsWUFBWUMsSUFBQUEsaUJBQU8sRUFBQ0YsS0FBS0csQ0FBQyxJQUFJO0lBQ3BDQyxJQUFBQSxpQkFBUyxFQUFDSCxXQUFXO1FBQUVJLFdBQVc7SUFBSztJQUV2Qyw4QkFBOEI7SUFDOUIsSUFBSTtRQUNIQyxJQUFBQSwrQkFBWSxFQUFDLFVBQVU7WUFBQztTQUFPLEVBQUU7WUFBRUMsT0FBTztRQUFPO0lBQ2xELEVBQUUsT0FBTTtRQUNQQyxRQUFRQyxLQUFLLENBQ1osNkRBQ0M7UUFFRkMsUUFBUUMsSUFBSSxDQUFDO0lBQ2Q7SUFFQSxNQUFNQyxVQUFvQjtRQUFDO1FBQU0sR0FBR1gsVUFBVSxXQUFXLENBQUM7S0FBQztJQUUzRE8sUUFBUUssR0FBRyxDQUFDO0lBRVosTUFBTUMsU0FBU0MsSUFBQUEsNEJBQVMsRUFDdkIsVUFDQTtRQUNDO1FBQ0E7UUFDQTtXQUNHSDtRQUNIO1FBQ0E7UUFDQTtRQUNBO1FBQ0FkO1FBQ0E7UUFDQTtRQUNBO0tBQ0EsRUFDRDtRQUFFUyxPQUFPO0lBQVU7SUFHcEJHLFFBQVFDLElBQUksQ0FBQ0csT0FBT0UsTUFBTSxJQUFJO0FBQy9CIn0=

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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

package/commonjs/src/version.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "CREATE_VERSION", {
+    enumerable: true,
+    get: function() {
+        return CREATE_VERSION;
+    }
+});
+const _nodemodule = require("node:module");
+const _nodepath = require("node:path");
+const _nodeurl = require("node:url");
+const _require = (0, _nodemodule.createRequire)(require("url").pathToFileURL(__filename).toString());
+function resolveCreateVersion() {
+    let dir = (0, _nodepath.dirname)((0, _nodeurl.fileURLToPath)(require("url").pathToFileURL(__filename).toString()));
+    for(let i = 0; i < 5; i++){
+        try {
+            const pkg = _require((0, _nodepath.join)(dir, "package.json"));
+            if (pkg.name === "@decohere/create") {
+                return pkg.version ?? "0.0.1-dev";
+            }
+        } catch  {}
+        const parent = (0, _nodepath.dirname)(dir);
+        if (parent === dir) break;
+        dir = parent;
+    }
+    return "0.0.1-dev";
+}
+const CREATE_VERSION = resolveCreateVersion();
+
+//# sourceMappingURL=data:application/json;base64,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