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

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

@@ -0,0 +1,30 @@
+/**
+ * Builder for a YAML config file (e.g. config/config.yaml or config/config.dev.yaml).
+ *
+ * Starts with a base section passed to the constructor. Features call
+ * `addSection(yaml)` during their scaffold phase to append their own block.
+ * `files()` joins all sections with a blank line separator.
+ */ export class ConfigYaml {
+    key;
+    filePath;
+    _sections = [];
+    constructor(key, filePath, baseContent){
+        this.key = key;
+        this.filePath = filePath;
+        this._sections.push(baseContent);
+    }
+    addSection(yaml) {
+        this._sections.push(yaml);
+        return this;
+    }
+    files() {
+        return [
+            {
+                filePath: this.filePath,
+                content: this._sections.join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/models/const.js

@@ -0,0 +1,19 @@
+export const WELL_KNOWN_FILES = {
+    VSCODE_SETTINGS: "VSCODE_SETTINGS",
+    LAUNCH_JSON: "LAUNCH_JSON",
+    DOCKER_COMPOSE: "DOCKER_COMPOSE",
+    DEVCONTAINER_JSON: "DEVCONTAINER_JSON",
+    DOCKERFILE: "DOCKERFILE",
+    PACKAGE_JSON: "PACKAGE_JSON",
+    API_PACKAGE_JSON: "API_PACKAGE_JSON",
+    TSCONFIG: "TSCONFIG",
+    MAIN_TS: "MAIN_TS",
+    CONTROLLER_TS: "CONTROLLER_TS",
+    CONFIG_YAML: "CONFIG_YAML",
+    CONFIG_DEV_YAML: "CONFIG_DEV_YAML",
+    GITIGNORE: "GITIGNORE",
+    AUTH_CONFIG: "AUTH_CONFIG",
+    ENV_FILE: "ENV_FILE"
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbnN0LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBjb25zdCBXRUxMX0tOT1dOX0ZJTEVTID0ge1xuXHRWU0NPREVfU0VUVElOR1M6IFwiVlNDT0RFX1NFVFRJTkdTXCIsXG5cdExBVU5DSF9KU09OOiBcIkxBVU5DSF9KU09OXCIsXG5cdERPQ0tFUl9DT01QT1NFOiBcIkRPQ0tFUl9DT01QT1NFXCIsXG5cdERFVkNPTlRBSU5FUl9KU09OOiBcIkRFVkNPTlRBSU5FUl9KU09OXCIsXG5cdERPQ0tFUkZJTEU6IFwiRE9DS0VSRklMRVwiLFxuXHRQQUNLQUdFX0pTT046IFwiUEFDS0FHRV9KU09OXCIsXG5cdEFQSV9QQUNLQUdFX0pTT046IFwiQVBJX1BBQ0tBR0VfSlNPTlwiLFxuXHRUU0NPTkZJRzogXCJUU0NPTkZJR1wiLFxuXHRNQUlOX1RTOiBcIk1BSU5fVFNcIixcblx0Q09OVFJPTExFUl9UUzogXCJDT05UUk9MTEVSX1RTXCIsXG5cdENPTkZJR19ZQU1MOiBcIkNPTkZJR19ZQU1MXCIsXG5cdENPTkZJR19ERVZfWUFNTDogXCJDT05GSUdfREVWX1lBTUxcIixcblx0R0lUSUdOT1JFOiBcIkdJVElHTk9SRVwiLFxuXHRBVVRIX0NPTkZJRzogXCJBVVRIX0NPTkZJR1wiLFxuXHRFTlZfRklMRTogXCJFTlZfRklMRVwiLFxufTtcbiJdLCJuYW1lcyI6WyJXRUxMX0tOT1dOX0ZJTEVTIiwiVlNDT0RFX1NFVFRJTkdTIiwiTEFVTkNIX0pTT04iLCJET0NLRVJfQ09NUE9TRSIsIkRFVkNPTlRBSU5FUl9KU09OIiwiRE9DS0VSRklMRSIsIlBBQ0tBR0VfSlNPTiIsIkFQSV9QQUNLQUdFX0pTT04iLCJUU0NPTkZJRyIsIk1BSU5fVFMiLCJDT05UUk9MTEVSX1RTIiwiQ09ORklHX1lBTUwiLCJDT05GSUdfREVWX1lBTUwiLCJHSVRJR05PUkUiLCJBVVRIX0NPTkZJRyIsIkVOVl9GSUxFIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE1BQU1BLG1CQUFtQjtJQUMvQkMsaUJBQWlCO0lBQ2pCQyxhQUFhO0lBQ2JDLGdCQUFnQjtJQUNoQkMsbUJBQW1CO0lBQ25CQyxZQUFZO0lBQ1pDLGNBQWM7SUFDZEMsa0JBQWtCO0lBQ2xCQyxVQUFVO0lBQ1ZDLFNBQVM7SUFDVEMsZUFBZTtJQUNmQyxhQUFhO0lBQ2JDLGlCQUFpQjtJQUNqQkMsV0FBVztJQUNYQyxhQUFhO0lBQ2JDLFVBQVU7QUFDWCxFQUFFIn0=

package/es6/src/models/container-image.model.js

@@ -0,0 +1,84 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+// Everything before the final USER instruction. Features insert RUN steps here.
+const DOCKERFILE_BASE = `FROM node:24
+
+ARG USERNAME=node
+
+# System tools: jq + ripgrep for scripting/search, python3 for AI tooling,
+# gh for GitHub workflows, curl/gnupg for package sources.
+RUN apt-get update \\
+    && apt-get install -y --no-install-recommends ca-certificates curl gnupg jq ripgrep python3 \\
+    && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg -o /usr/share/keyrings/githubcli-archive-keyring.gpg \\
+    && chmod go+r /usr/share/keyrings/githubcli-archive-keyring.gpg \\
+    && echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" > /etc/apt/sources.list.d/github-cli.list \\
+    && apt-get update \\
+    && apt-get install -y --no-install-recommends gh \\
+    && rm -rf /var/lib/apt/lists/*
+
+RUN npm install --global npm@latest \\
+    && npm add --global pnpm@10
+
+RUN mkdir -p /home/\${USERNAME}/.config/pnpm /home/\${USERNAME}/.pnpm-store \\
+    && chown -R \${USERNAME}:\${USERNAME} /home/\${USERNAME}/.config /home/\${USERNAME}/.pnpm-store \\
+    && printf "store-dir=/home/\${USERNAME}/.pnpm-store\\n" > /home/\${USERNAME}/.config/pnpm/rc
+
+# Pre-create workspace node_modules so the named volume mount is owned by the user
+RUN mkdir -p /workspace/node_modules && chown \${USERNAME}:\${USERNAME} /workspace/node_modules
+
+RUN mkdir /commandhistory && touch /commandhistory/.bash_history \\
+    && chown -R \${USERNAME} /commandhistory
+
+RUN SNIPPET="export PROMPT_COMMAND='history -a' && export HISTFILE=/commandhistory/.bash_history" \\
+    && echo "$SNIPPET" >> "/home/\${USERNAME}/.bashrc"
+
+# VS Code js-debug bug: bootloader.js in workspaceStorage is only created when
+# the user manually toggles Auto Attach settings. On a fresh container it is
+# missing, which crashes every Node command. Fix: if the injected path is
+# missing, substitute the stable bootloader from the VS Code server extension
+# directory (always present once the server is installed).
+RUN cat <<'EOF' >> "/home/\${USERNAME}/.bashrc"
+if [[ -n "\${NODE_OPTIONS:-}" && "\${NODE_OPTIONS}" == *"bootloader.js"* ]]; then
+    _bootloader_path="$(printf '%s\\n' "$NODE_OPTIONS" | sed -n 's/.*--require[= ]\\([^[:space:]]*bootloader\\.js\\).*/\\1/p')"
+    if [[ -n "\${_bootloader_path}" && ! -f "\${_bootloader_path}" ]]; then
+        _stable_bootloader="$(find /vscode/vscode-server /home/node/.vscode-server/extensions -name "bootloader.js" -path "*/ms-vscode.js-debug/*" 2>/dev/null | head -1)"
+        if [[ -n "\${_stable_bootloader}" ]]; then
+            NODE_OPTIONS="\${NODE_OPTIONS//\${_bootloader_path}/\${_stable_bootloader}}"
+        else
+            NODE_OPTIONS="$(printf '%s\\n' "$NODE_OPTIONS" | sed -E 's#(^| )--require(=| )[[:graph:]]*bootloader\\.js( |$)# #g; s#  +# #g; s#^ ##; s# $##')"
+            unset VSCODE_INSPECTOR_OPTIONS
+        fi
+        export NODE_OPTIONS
+        if [[ -z "$NODE_OPTIONS" ]]; then
+            unset NODE_OPTIONS
+        fi
+    fi
+    unset _bootloader_path _stable_bootloader
+fi
+EOF
+`;
+const DOCKERFILE_USER = `\nUSER \${USERNAME}\n`;
+/**
+ * Builder for `.devcontainer/Dockerfile`.
+ *
+ * Features call `addRunStep(cmd)` during their scaffold phase to append
+ * additional `RUN` instructions before the final `USER` instruction.
+ * `files()` assembles the complete Dockerfile content at render time.
+ */ export class DockerfileModel {
+    key = WELL_KNOWN_FILES.DOCKERFILE;
+    _runSteps = [];
+    /** Append a RUN instruction (pass the command, not the RUN keyword). */ addRunStep(cmd) {
+        this._runSteps.push(cmd);
+        return this;
+    }
+    files() {
+        const extras = this._runSteps.length > 0 ? `\n${this._runSteps.map((s)=>`RUN ${s}`).join("\n\n")}\n` : "";
+        return [
+            {
+                filePath: ".devcontainer/Dockerfile",
+                content: DOCKERFILE_BASE + extras + DOCKERFILE_USER
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2NvbnRhaW5lci1pbWFnZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbi8vIEV2ZXJ5dGhpbmcgYmVmb3JlIHRoZSBmaW5hbCBVU0VSIGluc3RydWN0aW9uLiBGZWF0dXJlcyBpbnNlcnQgUlVOIHN0ZXBzIGhlcmUuXG5jb25zdCBET0NLRVJGSUxFX0JBU0UgPSBgRlJPTSBub2RlOjI0XG5cbkFSRyBVU0VSTkFNRT1ub2RlXG5cbiMgU3lzdGVtIHRvb2xzOiBqcSArIHJpcGdyZXAgZm9yIHNjcmlwdGluZy9zZWFyY2gsIHB5dGhvbjMgZm9yIEFJIHRvb2xpbmcsXG4jIGdoIGZvciBHaXRIdWIgd29ya2Zsb3dzLCBjdXJsL2dudXBnIGZvciBwYWNrYWdlIHNvdXJjZXMuXG5SVU4gYXB0LWdldCB1cGRhdGUgXFxcXFxuICAgICYmIGFwdC1nZXQgaW5zdGFsbCAteSAtLW5vLWluc3RhbGwtcmVjb21tZW5kcyBjYS1jZXJ0aWZpY2F0ZXMgY3VybCBnbnVwZyBqcSByaXBncmVwIHB5dGhvbjMgXFxcXFxuICAgICYmIGN1cmwgLWZzU0wgaHR0cHM6Ly9jbGkuZ2l0aHViLmNvbS9wYWNrYWdlcy9naXRodWJjbGktYXJjaGl2ZS1rZXlyaW5nLmdwZyAtbyAvdXNyL3NoYXJlL2tleXJpbmdzL2dpdGh1YmNsaS1hcmNoaXZlLWtleXJpbmcuZ3BnIFxcXFxcbiAgICAmJiBjaG1vZCBnbytyIC91c3Ivc2hhcmUva2V5cmluZ3MvZ2l0aHViY2xpLWFyY2hpdmUta2V5cmluZy5ncGcgXFxcXFxuICAgICYmIGVjaG8gXCJkZWIgW2FyY2g9JChkcGtnIC0tcHJpbnQtYXJjaGl0ZWN0dXJlKSBzaWduZWQtYnk9L3Vzci9zaGFyZS9rZXlyaW5ncy9naXRodWJjbGktYXJjaGl2ZS1rZXlyaW5nLmdwZ10gaHR0cHM6Ly9jbGkuZ2l0aHViLmNvbS9wYWNrYWdlcyBzdGFibGUgbWFpblwiID4gL2V0Yy9hcHQvc291cmNlcy5saXN0LmQvZ2l0aHViLWNsaS5saXN0IFxcXFxcbiAgICAmJiBhcHQtZ2V0IHVwZGF0ZSBcXFxcXG4gICAgJiYgYXB0LWdldCBpbnN0YWxsIC15IC0tbm8taW5zdGFsbC1yZWNvbW1lbmRzIGdoIFxcXFxcbiAgICAmJiBybSAtcmYgL3Zhci9saWIvYXB0L2xpc3RzLypcblxuUlVOIG5wbSBpbnN0YWxsIC0tZ2xvYmFsIG5wbUBsYXRlc3QgXFxcXFxuICAgICYmIG5wbSBhZGQgLS1nbG9iYWwgcG5wbUAxMFxuXG5SVU4gbWtkaXIgLXAgL2hvbWUvXFwke1VTRVJOQU1FfS8uY29uZmlnL3BucG0gL2hvbWUvXFwke1VTRVJOQU1FfS8ucG5wbS1zdG9yZSBcXFxcXG4gICAgJiYgY2hvd24gLVIgXFwke1VTRVJOQU1FfTpcXCR7VVNFUk5BTUV9IC9ob21lL1xcJHtVU0VSTkFNRX0vLmNvbmZpZyAvaG9tZS9cXCR7VVNFUk5BTUV9Ly5wbnBtLXN0b3JlIFxcXFxcbiAgICAmJiBwcmludGYgXCJzdG9yZS1kaXI9L2hvbWUvXFwke1VTRVJOQU1FfS8ucG5wbS1zdG9yZVxcXFxuXCIgPiAvaG9tZS9cXCR7VVNFUk5BTUV9Ly5jb25maWcvcG5wbS9yY1xuXG4jIFByZS1jcmVhdGUgd29ya3NwYWNlIG5vZGVfbW9kdWxlcyBzbyB0aGUgbmFtZWQgdm9sdW1lIG1vdW50IGlzIG93bmVkIGJ5IHRoZSB1c2VyXG5SVU4gbWtkaXIgLXAgL3dvcmtzcGFjZS9ub2RlX21vZHVsZXMgJiYgY2hvd24gXFwke1VTRVJOQU1FfTpcXCR7VVNFUk5BTUV9IC93b3Jrc3BhY2Uvbm9kZV9tb2R1bGVzXG5cblJVTiBta2RpciAvY29tbWFuZGhpc3RvcnkgJiYgdG91Y2ggL2NvbW1hbmRoaXN0b3J5Ly5iYXNoX2hpc3RvcnkgXFxcXFxuICAgICYmIGNob3duIC1SIFxcJHtVU0VSTkFNRX0gL2NvbW1hbmRoaXN0b3J5XG5cblJVTiBTTklQUEVUPVwiZXhwb3J0IFBST01QVF9DT01NQU5EPSdoaXN0b3J5IC1hJyAmJiBleHBvcnQgSElTVEZJTEU9L2NvbW1hbmRoaXN0b3J5Ly5iYXNoX2hpc3RvcnlcIiBcXFxcXG4gICAgJiYgZWNobyBcIiRTTklQUEVUXCIgPj4gXCIvaG9tZS9cXCR7VVNFUk5BTUV9Ly5iYXNocmNcIlxuXG4jIFZTIENvZGUganMtZGVidWcgYnVnOiBib290bG9hZGVyLmpzIGluIHdvcmtzcGFjZVN0b3JhZ2UgaXMgb25seSBjcmVhdGVkIHdoZW5cbiMgdGhlIHVzZXIgbWFudWFsbHkgdG9nZ2xlcyBBdXRvIEF0dGFjaCBzZXR0aW5ncy4gT24gYSBmcmVzaCBjb250YWluZXIgaXQgaXNcbiMgbWlzc2luZywgd2hpY2ggY3Jhc2hlcyBldmVyeSBOb2RlIGNvbW1hbmQuIEZpeDogaWYgdGhlIGluamVjdGVkIHBhdGggaXNcbiMgbWlzc2luZywgc3Vic3RpdHV0ZSB0aGUgc3RhYmxlIGJvb3Rsb2FkZXIgZnJvbSB0aGUgVlMgQ29kZSBzZXJ2ZXIgZXh0ZW5zaW9uXG4jIGRpcmVjdG9yeSAoYWx3YXlzIHByZXNlbnQgb25jZSB0aGUgc2VydmVyIGlzIGluc3RhbGxlZCkuXG5SVU4gY2F0IDw8J0VPRicgPj4gXCIvaG9tZS9cXCR7VVNFUk5BTUV9Ly5iYXNocmNcIlxuaWYgW1sgLW4gXCJcXCR7Tk9ERV9PUFRJT05TOi19XCIgJiYgXCJcXCR7Tk9ERV9PUFRJT05TfVwiID09ICpcImJvb3Rsb2FkZXIuanNcIiogXV07IHRoZW5cbiAgICBfYm9vdGxvYWRlcl9wYXRoPVwiJChwcmludGYgJyVzXFxcXG4nIFwiJE5PREVfT1BUSU9OU1wiIHwgc2VkIC1uICdzLy4qLS1yZXF1aXJlWz0gXVxcXFwoW15bOnNwYWNlOl1dKmJvb3Rsb2FkZXJcXFxcLmpzXFxcXCkuKi9cXFxcMS9wJylcIlxuICAgIGlmIFtbIC1uIFwiXFwke19ib290bG9hZGVyX3BhdGh9XCIgJiYgISAtZiBcIlxcJHtfYm9vdGxvYWRlcl9wYXRofVwiIF1dOyB0aGVuXG4gICAgICAgIF9zdGFibGVfYm9vdGxvYWRlcj1cIiQoZmluZCAvdnNjb2RlL3ZzY29kZS1zZXJ2ZXIgL2hvbWUvbm9kZS8udnNjb2RlLXNlcnZlci9leHRlbnNpb25zIC1uYW1lIFwiYm9vdGxvYWRlci5qc1wiIC1wYXRoIFwiKi9tcy12c2NvZGUuanMtZGVidWcvKlwiIDI+L2Rldi9udWxsIHwgaGVhZCAtMSlcIlxuICAgICAgICBpZiBbWyAtbiBcIlxcJHtfc3RhYmxlX2Jvb3Rsb2FkZXJ9XCIgXV07IHRoZW5cbiAgICAgICAgICAgIE5PREVfT1BUSU9OUz1cIlxcJHtOT0RFX09QVElPTlMvL1xcJHtfYm9vdGxvYWRlcl9wYXRofS9cXCR7X3N0YWJsZV9ib290bG9hZGVyfX1cIlxuICAgICAgICBlbHNlXG4gICAgICAgICAgICBOT0RFX09QVElPTlM9XCIkKHByaW50ZiAnJXNcXFxcbicgXCIkTk9ERV9PUFRJT05TXCIgfCBzZWQgLUUgJ3MjKF58ICktLXJlcXVpcmUoPXwgKVtbOmdyYXBoOl1dKmJvb3Rsb2FkZXJcXFxcLmpzKCB8JCkjICNnOyBzIyAgKyMgI2c7IHMjXiAjIzsgcyMgJCMjJylcIlxuICAgICAgICAgICAgdW5zZXQgVlNDT0RFX0lOU1BFQ1RPUl9PUFRJT05TXG4gICAgICAgIGZpXG4gICAgICAgIGV4cG9ydCBOT0RFX09QVElPTlNcbiAgICAgICAgaWYgW1sgLXogXCIkTk9ERV9PUFRJT05TXCIgXV07IHRoZW5cbiAgICAgICAgICAgIHVuc2V0IE5PREVfT1BUSU9OU1xuICAgICAgICBmaVxuICAgIGZpXG4gICAgdW5zZXQgX2Jvb3Rsb2FkZXJfcGF0aCBfc3RhYmxlX2Jvb3Rsb2FkZXJcbmZpXG5FT0ZcbmA7XG5cbmNvbnN0IERPQ0tFUkZJTEVfVVNFUiA9IGBcXG5VU0VSIFxcJHtVU0VSTkFNRX1cXG5gO1xuXG4vKipcbiAqIEJ1aWxkZXIgZm9yIGAuZGV2Y29udGFpbmVyL0RvY2tlcmZpbGVgLlxuICpcbiAqIEZlYXR1cmVzIGNhbGwgYGFkZFJ1blN0ZXAoY21kKWAgZHVyaW5nIHRoZWlyIHNjYWZmb2xkIHBoYXNlIHRvIGFwcGVuZFxuICogYWRkaXRpb25hbCBgUlVOYCBpbnN0cnVjdGlvbnMgYmVmb3JlIHRoZSBmaW5hbCBgVVNFUmAgaW5zdHJ1Y3Rpb24uXG4gKiBgZmlsZXMoKWAgYXNzZW1ibGVzIHRoZSBjb21wbGV0ZSBEb2NrZXJmaWxlIGNvbnRlbnQgYXQgcmVuZGVyIHRpbWUuXG4gKi9cbmV4cG9ydCBjbGFzcyBEb2NrZXJmaWxlTW9kZWwgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuRE9DS0VSRklMRTtcblx0cHJpdmF0ZSByZWFkb25seSBfcnVuU3RlcHM6IHN0cmluZ1tdID0gW107XG5cblx0LyoqIEFwcGVuZCBhIFJVTiBpbnN0cnVjdGlvbiAocGFzcyB0aGUgY29tbWFuZCwgbm90IHRoZSBSVU4ga2V5d29yZCkuICovXG5cdHB1YmxpYyBhZGRSdW5TdGVwKGNtZDogc3RyaW5nKTogdGhpcyB7XG5cdFx0dGhpcy5fcnVuU3RlcHMucHVzaChjbWQpO1xuXHRcdHJldHVybiB0aGlzO1xuXHR9XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0Y29uc3QgZXh0cmFzID1cblx0XHRcdHRoaXMuX3J1blN0ZXBzLmxlbmd0aCA+IDBcblx0XHRcdFx0PyBgXFxuJHt0aGlzLl9ydW5TdGVwcy5tYXAoKHMpID0+IGBSVU4gJHtzfWApLmpvaW4oXCJcXG5cXG5cIil9XFxuYFxuXHRcdFx0XHQ6IFwiXCI7XG5cdFx0cmV0dXJuIFtcblx0XHRcdHtcblx0XHRcdFx0ZmlsZVBhdGg6IFwiLmRldmNvbnRhaW5lci9Eb2NrZXJmaWxlXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IERPQ0tFUkZJTEVfQkFTRSArIGV4dHJhcyArIERPQ0tFUkZJTEVfVVNFUixcblx0XHRcdH0sXG5cdFx0XTtcblx0fVxufVxuIl0sIm5hbWVzIjpbIldFTExfS05PV05fRklMRVMiLCJET0NLRVJGSUxFX0JBU0UiLCJET0NLRVJGSUxFX1VTRVIiLCJEb2NrZXJmaWxlTW9kZWwiLCJrZXkiLCJET0NLRVJGSUxFIiwiX3J1blN0ZXBzIiwiYWRkUnVuU3RlcCIsImNtZCIsInB1c2giLCJmaWxlcyIsImV4dHJhcyIsImxlbmd0aCIsIm1hcCIsInMiLCJqb2luIiwiZmlsZVBhdGgiLCJjb250ZW50Il0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxnQkFBZ0IsUUFBUSxhQUFhO0FBRzlDLGdGQUFnRjtBQUNoRixNQUFNQyxrQkFBa0IsQ0FBQzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQXVEekIsQ0FBQztBQUVELE1BQU1DLGtCQUFrQixDQUFDLHFCQUFxQixDQUFDO0FBRS9DOzs7Ozs7Q0FNQyxHQUNELE9BQU8sTUFBTUM7SUFDSUMsTUFBTUosaUJBQWlCSyxVQUFVLENBQUM7SUFDakNDLFlBQXNCLEVBQUUsQ0FBQztJQUUxQyxzRUFBc0UsR0FDdEUsQUFBT0MsV0FBV0MsR0FBVyxFQUFRO1FBQ3BDLElBQUksQ0FBQ0YsU0FBUyxDQUFDRyxJQUFJLENBQUNEO1FBQ3BCLE9BQU8sSUFBSTtJQUNaO0lBRU9FLFFBQXNCO1FBQzVCLE1BQU1DLFNBQ0wsSUFBSSxDQUFDTCxTQUFTLENBQUNNLE1BQU0sR0FBRyxJQUNyQixDQUFDLEVBQUUsRUFBRSxJQUFJLENBQUNOLFNBQVMsQ0FBQ08sR0FBRyxDQUFDLENBQUNDLElBQU0sQ0FBQyxJQUFJLEVBQUVBLEdBQUcsRUFBRUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDLEdBQzNEO1FBQ0osT0FBTztZQUNOO2dCQUNDQyxVQUFVO2dCQUNWQyxTQUFTaEIsa0JBQWtCVSxTQUFTVDtZQUNyQztTQUNBO0lBQ0Y7QUFDRCJ9

package/es6/src/models/dev-container.model.js

@@ -0,0 +1,68 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+/**
+ * Model for `.devcontainer/devcontainer.json`.
+ *
+ * Features call builder methods (`addExtension`, `forwardPort`, etc.) during
+ * their configure phase. `MonoRepoScaffold` calls `files()` at render time.
+ */ export class DevContainer {
+    key = WELL_KNOWN_FILES.DEVCONTAINER_JSON;
+    _extensions = [];
+    _ports = [];
+    _mounts;
+    _postStartCommand;
+    _useCompose = false;
+    constructor(){
+        this._mounts = [
+            "source=..,target=/workspace,type=bind,consistency=cached"
+        ];
+        this.forwardPort(3000);
+    }
+    addExtension(...ids) {
+        this._extensions.push(...ids);
+        return this;
+    }
+    forwardPort(...ports) {
+        this._ports.push(...ports);
+        return this;
+    }
+    setPostStartCommand(cmd) {
+        this._postStartCommand = cmd;
+        return this;
+    }
+    useCompose() {
+        this._useCompose = true;
+        return this;
+    }
+    files() {
+        const config = {};
+        if (this._useCompose) {
+            config.dockerComposeFile = "docker-compose.yml";
+            config.service = "devcontainer";
+            config.workspaceFolder = "/workspace";
+        }
+        if (this._mounts) {
+            config.mounts = this._mounts;
+        }
+        if (this._extensions.length > 0) {
+            config.customizations = {
+                vscode: {
+                    extensions: this._extensions
+                }
+            };
+        }
+        if (this._ports.length > 0) {
+            config.forwardPorts = this._ports;
+        }
+        if (this._postStartCommand) {
+            config.postStartCommand = this._postStartCommand;
+        }
+        return [
+            {
+                filePath: ".devcontainer/devcontainer.json",
+                content: JSON.stringify(config, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/models/env-file.model.js

@@ -0,0 +1,29 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+/**
+ * Accumulates key=value pairs and renders them as a `.env` file.
+ *
+ * Register once in the workspace; features call `addEntry` during their
+ * scaffold phase to contribute environment variables. The final file is
+ * written at render time when `workspace.scaffold()` is called.
+ */ export class EnvFile {
+    key = WELL_KNOWN_FILES.ENV_FILE;
+    _entries = new Map();
+    addEntry(key, value) {
+        this._entries.set(key, value);
+        return this;
+    }
+    files() {
+        if (this._entries.size === 0) return [];
+        const content = [
+            ...this._entries.entries()
+        ].map(([k, v])=>`${k}=${v}`).join("\n") + "\n";
+        return [
+            {
+                filePath: ".env",
+                content
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,22 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class Gitignore {
+    key = WELL_KNOWN_FILES.GITIGNORE;
+    ignoreList = [
+        "node_modules",
+        "dist",
+        ".pnpm-store",
+        ".env",
+        ".env.local",
+        ".DS_Store"
+    ];
+    files() {
+        return [
+            {
+                filePath: ".gitignore",
+                content: this.ignoreList.join("\n")
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2dpdGlnbm9yZS5tb2RlbC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBXRUxMX0tOT1dOX0ZJTEVTIH0gZnJvbSBcIi4vY29uc3QuanNcIjtcbmltcG9ydCB0eXBlIHsgS2V5ZWRNb2RlbCwgU291cmNlRmlsZSB9IGZyb20gXCIuL3NvdXJjZS1maWxlLmpzXCI7XG5cbmV4cG9ydCBjbGFzcyBHaXRpZ25vcmUgaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuR0lUSUdOT1JFO1xuXHRwcml2YXRlIGlnbm9yZUxpc3QgPSBbXG5cdFx0XCJub2RlX21vZHVsZXNcIixcblx0XHRcImRpc3RcIixcblx0XHRcIi5wbnBtLXN0b3JlXCIsXG5cdFx0XCIuZW52XCIsXG5cdFx0XCIuZW52LmxvY2FsXCIsXG5cdFx0XCIuRFNfU3RvcmVcIixcblx0XTtcblxuXHRwdWJsaWMgZmlsZXMoKTogU291cmNlRmlsZVtdIHtcblx0XHRyZXR1cm4gW1xuXHRcdFx0e1xuXHRcdFx0XHRmaWxlUGF0aDogXCIuZ2l0aWdub3JlXCIsXG5cdFx0XHRcdGNvbnRlbnQ6IHRoaXMuaWdub3JlTGlzdC5qb2luKFwiXFxuXCIpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiV0VMTF9LTk9XTl9GSUxFUyIsIkdpdGlnbm9yZSIsImtleSIsIkdJVElHTk9SRSIsImlnbm9yZUxpc3QiLCJmaWxlcyIsImZpbGVQYXRoIiwiY29udGVudCIsImpvaW4iXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGdCQUFnQixRQUFRLGFBQWE7QUFHOUMsT0FBTyxNQUFNQztJQUNJQyxNQUFNRixpQkFBaUJHLFNBQVMsQ0FBQztJQUN6Q0MsYUFBYTtRQUNwQjtRQUNBO1FBQ0E7UUFDQTtRQUNBO1FBQ0E7S0FDQSxDQUFDO0lBRUtDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBUyxJQUFJLENBQUNILFVBQVUsQ0FBQ0ksSUFBSSxDQUFDO1lBQy9CO1NBQ0E7SUFDRjtBQUNEIn0=

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

@@ -0,0 +1,42 @@
+import { WELL_KNOWN_FILES } from "./const.js";
+export class LaunchJson {
+    key = WELL_KNOWN_FILES.LAUNCH_JSON;
+    files() {
+        return [
+            {
+                filePath: ".vscode/launch.json",
+                content: JSON.stringify({
+                    version: "0.2.0",
+                    configurations: [
+                        {
+                            name: "Build",
+                            type: "node",
+                            request: "launch",
+                            runtimeExecutable: "pnpm",
+                            runtimeArgs: [
+                                "build"
+                            ],
+                            console: "integratedTerminal",
+                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                            cwd: "${workspaceFolder}"
+                        },
+                        {
+                            name: "Serve / Dev",
+                            type: "node",
+                            request: "launch",
+                            runtimeExecutable: "pnpm",
+                            runtimeArgs: [
+                                "dev"
+                            ],
+                            console: "integratedTerminal",
+                            // biome-ignore lint/suspicious/noTemplateCurlyInString: VS Code variable
+                            cwd: "${workspaceFolder}"
+                        }
+                    ]
+                }, null, 2)
+            }
+        ];
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL2xhdW5jaC1qc29uLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFdFTExfS05PV05fRklMRVMgfSBmcm9tIFwiLi9jb25zdC5qc1wiO1xuaW1wb3J0IHR5cGUgeyBLZXllZE1vZGVsLCBTb3VyY2VGaWxlIH0gZnJvbSBcIi4vc291cmNlLWZpbGUuanNcIjtcblxuZXhwb3J0IGNsYXNzIExhdW5jaEpzb24gaW1wbGVtZW50cyBLZXllZE1vZGVsIHtcblx0cHVibGljIHJlYWRvbmx5IGtleSA9IFdFTExfS05PV05fRklMRVMuTEFVTkNIX0pTT047XG5cblx0cHVibGljIGZpbGVzKCk6IFNvdXJjZUZpbGVbXSB7XG5cdFx0cmV0dXJuIFtcblx0XHRcdHtcblx0XHRcdFx0ZmlsZVBhdGg6IFwiLnZzY29kZS9sYXVuY2guanNvblwiLFxuXHRcdFx0XHRjb250ZW50OiBKU09OLnN0cmluZ2lmeShcblx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHR2ZXJzaW9uOiBcIjAuMi4wXCIsXG5cdFx0XHRcdFx0XHRjb25maWd1cmF0aW9uczogW1xuXHRcdFx0XHRcdFx0XHR7XG5cdFx0XHRcdFx0XHRcdFx0bmFtZTogXCJCdWlsZFwiLFxuXHRcdFx0XHRcdFx0XHRcdHR5cGU6IFwibm9kZVwiLFxuXHRcdFx0XHRcdFx0XHRcdHJlcXVlc3Q6IFwibGF1bmNoXCIsXG5cdFx0XHRcdFx0XHRcdFx0cnVudGltZUV4ZWN1dGFibGU6IFwicG5wbVwiLFxuXHRcdFx0XHRcdFx0XHRcdHJ1bnRpbWVBcmdzOiBbXCJidWlsZFwiXSxcblx0XHRcdFx0XHRcdFx0XHRjb25zb2xlOiBcImludGVncmF0ZWRUZXJtaW5hbFwiLFxuXHRcdFx0XHRcdFx0XHRcdC8vIGJpb21lLWlnbm9yZSBsaW50L3N1c3BpY2lvdXMvbm9UZW1wbGF0ZUN1cmx5SW5TdHJpbmc6IFZTIENvZGUgdmFyaWFibGVcblx0XHRcdFx0XHRcdFx0XHRjd2Q6IFwiJHt3b3Jrc3BhY2VGb2xkZXJ9XCIsXG5cdFx0XHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0XHRcdHtcblx0XHRcdFx0XHRcdFx0XHRuYW1lOiBcIlNlcnZlIC8gRGV2XCIsXG5cdFx0XHRcdFx0XHRcdFx0dHlwZTogXCJub2RlXCIsXG5cdFx0XHRcdFx0XHRcdFx0cmVxdWVzdDogXCJsYXVuY2hcIixcblx0XHRcdFx0XHRcdFx0XHRydW50aW1lRXhlY3V0YWJsZTogXCJwbnBtXCIsXG5cdFx0XHRcdFx0XHRcdFx0cnVudGltZUFyZ3M6IFtcImRldlwiXSxcblx0XHRcdFx0XHRcdFx0XHRjb25zb2xlOiBcImludGVncmF0ZWRUZXJtaW5hbFwiLFxuXHRcdFx0XHRcdFx0XHRcdC8vIGJpb21lLWlnbm9yZSBsaW50L3N1c3BpY2lvdXMvbm9UZW1wbGF0ZUN1cmx5SW5TdHJpbmc6IFZTIENvZGUgdmFyaWFibGVcblx0XHRcdFx0XHRcdFx0XHRjd2Q6IFwiJHt3b3Jrc3BhY2VGb2xkZXJ9XCIsXG5cdFx0XHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0XHRdLFxuXHRcdFx0XHRcdH0sXG5cdFx0XHRcdFx0bnVsbCxcblx0XHRcdFx0XHQyLFxuXHRcdFx0XHQpLFxuXHRcdFx0fSxcblx0XHRdO1xuXHR9XG59XG4iXSwibmFtZXMiOlsiV0VMTF9LTk9XTl9GSUxFUyIsIkxhdW5jaEpzb24iLCJrZXkiLCJMQVVOQ0hfSlNPTiIsImZpbGVzIiwiZmlsZVBhdGgiLCJjb250ZW50IiwiSlNPTiIsInN0cmluZ2lmeSIsInZlcnNpb24iLCJjb25maWd1cmF0aW9ucyIsIm5hbWUiLCJ0eXBlIiwicmVxdWVzdCIsInJ1bnRpbWVFeGVjdXRhYmxlIiwicnVudGltZUFyZ3MiLCJjb25zb2xlIiwiY3dkIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxnQkFBZ0IsUUFBUSxhQUFhO0FBRzlDLE9BQU8sTUFBTUM7SUFDSUMsTUFBTUYsaUJBQWlCRyxXQUFXLENBQUM7SUFFNUNDLFFBQXNCO1FBQzVCLE9BQU87WUFDTjtnQkFDQ0MsVUFBVTtnQkFDVkMsU0FBU0MsS0FBS0MsU0FBUyxDQUN0QjtvQkFDQ0MsU0FBUztvQkFDVEMsZ0JBQWdCO3dCQUNmOzRCQUNDQyxNQUFNOzRCQUNOQyxNQUFNOzRCQUNOQyxTQUFTOzRCQUNUQyxtQkFBbUI7NEJBQ25CQyxhQUFhO2dDQUFDOzZCQUFROzRCQUN0QkMsU0FBUzs0QkFDVCx5RUFBeUU7NEJBQ3pFQyxLQUFLO3dCQUNOO3dCQUNBOzRCQUNDTixNQUFNOzRCQUNOQyxNQUFNOzRCQUNOQyxTQUFTOzRCQUNUQyxtQkFBbUI7NEJBQ25CQyxhQUFhO2dDQUFDOzZCQUFNOzRCQUNwQkMsU0FBUzs0QkFDVCx5RUFBeUU7NEJBQ3pFQyxLQUFLO3dCQUNOO3FCQUNBO2dCQUNGLEdBQ0EsTUFDQTtZQUVGO1NBQ0E7SUFDRjtBQUNEIn0=

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

@@ -0,0 +1,60 @@
+import { CREATE_VERSION } from "../version.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;
+    constructor(name){
+        this.name = name;
+        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"
+        };
+        this._devDependencies = {
+            "@decohere/terminal": 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/es6/src/models/project.model.js

@@ -0,0 +1,111 @@
+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();
+    /** Derived from the basename of targetDir. */ get name() {
+        return 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;
+    }
+}
+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);
+    }
+    /** 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/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":["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","MonoRepoScaffold","_projects","addProject","project","getProject","find","p","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,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS9zcmMvbW9kZWxzL3NvdXJjZS1maWxlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgU291cmNlRmlsZVByb3ZpZGVyIHtcblx0ZmlsZXMoKTogU291cmNlRmlsZVtdO1xufVxuXG4vKiogQSBTb3VyY2VGaWxlUHJvdmlkZXIgdGhhdCBrbm93cyBpdHMgb3duIHJlZ2lzdHJhdGlvbiBrZXkuICovXG5leHBvcnQgaW50ZXJmYWNlIEtleWVkTW9kZWwgZXh0ZW5kcyBTb3VyY2VGaWxlUHJvdmlkZXIge1xuXHRyZWFkb25seSBrZXk6IHN0cmluZztcbn1cblxuZXhwb3J0IHR5cGUgU291cmNlRmlsZSA9IHtcblx0ZmlsZVBhdGg6IHN0cmluZztcblx0Y29udGVudDogc3RyaW5nO1xufTtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxXQUdFIn0=

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

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