@decohere/create 0.0.1-dev.16 → 0.0.1-dev.18

package/es6/v1/domain/context.js

@@ -0,0 +1,37 @@
+import { basename } from "node:path";
+export function modelKey(name) {
+    return {
+        _sym: Symbol(name)
+    };
+}
+/**
+ * Immutable typed store of feature models. Each feature defines its own keys
+ * (typed via `modelKey<T>()`) and writes to / reads from the store during the
+ * `configure` and `render` phases. The store is the only mechanism by which
+ * features communicate.
+ */ export class FeatureModelStore {
+    _store;
+    constructor(store){
+        this._store = store ?? new Map();
+    }
+    get(key) {
+        return this._store.get(key._sym);
+    }
+    set(key, value) {
+        const next = new Map(this._store);
+        next.set(key._sym, value);
+        return new FeatureModelStore(next);
+    }
+}
+export function createContext(targetDir, opts, template = "api") {
+    return {
+        projectName: basename(targetDir),
+        targetDir,
+        opts,
+        template,
+        models: new FeatureModelStore(),
+        controllers: []
+    };
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/devcontainer.model.js

@@ -0,0 +1,104 @@
+import { modelKey } from "./context.js";
+import { DockerfileModel } from "./dockerfile.model.js";
+export const DEVCONTAINER_KEY = modelKey("devcontainer");
+/**
+ * Live builder for `.devcontainer/devcontainer.json`.
+ *
+ * The api-core feature creates an instance in its `configure` phase.
+ * Other features (typeorm, auth0, …) call `addExtension` / `addFeature` / etc.
+ * in their own `configure` phases.  The devcontainer `render` phase calls `render()`.
+ */ export class DevcontainerModel {
+    _name;
+    _image;
+    _composeFile = null;
+    _composeService = "app";
+    _dockerfile = null;
+    _extensions = [];
+    _ports = [];
+    _postCreateCommands = [];
+    _postStartCommands = [];
+    _devcontainerFeatures = new Map();
+    constructor(name, image = "node:24"){
+        this._name = name;
+        this._image = image;
+    }
+    get image() {
+        return this._image;
+    }
+    setImage(image) {
+        this._image = image;
+        return this;
+    }
+    /** Switch to Docker Compose mode. Call from a feature that adds a compose service. */ useCompose(file = "docker-compose.yml", service = "devcontainer") {
+        this._composeFile = file;
+        this._composeService = service;
+        this._dockerfile = new DockerfileModel();
+        return this;
+    }
+    /** The Dockerfile model, available only when in compose mode. */ get dockerfile() {
+        return this._dockerfile;
+    }
+    addExtension(...ids) {
+        for (const id of ids){
+            if (!this._extensions.includes(id)) this._extensions.push(id);
+        }
+        return this;
+    }
+    forwardPort(...ports) {
+        for (const port of ports){
+            if (!this._ports.includes(port)) this._ports.push(port);
+        }
+        return this;
+    }
+    addPostCreateCommand(cmd) {
+        if (!this._postCreateCommands.includes(cmd)) this._postCreateCommands.push(cmd);
+        return this;
+    }
+    addPostStartCommand(cmd) {
+        if (!this._postStartCommands.includes(cmd)) this._postStartCommands.push(cmd);
+        return this;
+    }
+    /** Add a devcontainer Feature, e.g. `ghcr.io/devcontainers/features/node:1`. */ addFeature(id, options = {}) {
+        this._devcontainerFeatures.set(id, options);
+        return this;
+    }
+    render() {
+        const obj = {
+            name: this._name
+        };
+        if (this._composeFile) {
+            obj.dockerComposeFile = [
+                this._composeFile
+            ];
+            obj.service = this._composeService;
+            obj.workspaceFolder = "/workspace";
+            obj.mounts = [
+                "source=..,target=/workspace,type=bind,consistency=cached"
+            ];
+        } else {
+            obj.image = this._image;
+        }
+        if (this._devcontainerFeatures.size > 0) {
+            obj.features = Object.fromEntries(this._devcontainerFeatures);
+        }
+        if (this._extensions.length > 0) {
+            obj.customizations = {
+                vscode: {
+                    extensions: this._extensions
+                }
+            };
+        }
+        if (this._ports.length > 0) {
+            obj.forwardPorts = this._ports;
+        }
+        if (this._postCreateCommands.length > 0) {
+            obj.postCreateCommand = this._postCreateCommands.length === 1 ? this._postCreateCommands[0] : this._postCreateCommands.join(" && ");
+        }
+        if (this._postStartCommands.length > 0) {
+            obj.postStartCommand = this._postStartCommands.length === 1 ? this._postStartCommands[0] : this._postStartCommands.join(" && ");
+        }
+        return `${JSON.stringify(obj, null, 2)}\n`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/domain/devcontainer.model.ts"],"sourcesContent":["import { modelKey } from \"./context.js\";\nimport { DockerfileModel } from \"./dockerfile.model.js\";\n\nexport const DEVCONTAINER_KEY = modelKey<DevcontainerModel>(\"devcontainer\");\n\n/**\n * Live builder for `.devcontainer/devcontainer.json`.\n *\n * The api-core feature creates an instance in its `configure` phase.\n * Other features (typeorm, auth0, …) call `addExtension` / `addFeature` / etc.\n * in their own `configure` phases.  The devcontainer `render` phase calls `render()`.\n */\nexport class DevcontainerModel {\n\tprivate readonly _name: string;\n\tprivate _image: string;\n\tprivate _composeFile: string | null = null;\n\tprivate _composeService = \"app\";\n\tprivate _dockerfile: DockerfileModel | null = null;\n\tprivate readonly _extensions: string[] = [];\n\tprivate readonly _ports: number[] = [];\n\tprivate readonly _postCreateCommands: string[] = [];\n\tprivate readonly _postStartCommands: string[] = [];\n\tprivate readonly _devcontainerFeatures: Map<string, Record<string, unknown>> = new Map();\n\n\tpublic constructor(name: string, image = \"node:24\") {\n\t\tthis._name = name;\n\t\tthis._image = image;\n\t}\n\n\tpublic get image(): string {\n\t\treturn this._image;\n\t}\n\n\tpublic setImage(image: string): this {\n\t\tthis._image = image;\n\t\treturn this;\n\t}\n\n\t/** Switch to Docker Compose mode. Call from a feature that adds a compose service. */\n\tpublic useCompose(file = \"docker-compose.yml\", service = \"devcontainer\"): this {\n\t\tthis._composeFile = file;\n\t\tthis._composeService = service;\n\t\tthis._dockerfile = new DockerfileModel();\n\t\treturn this;\n\t}\n\n\t/** The Dockerfile model, available only when in compose mode. */\n\tpublic get dockerfile(): DockerfileModel | null {\n\t\treturn this._dockerfile;\n\t}\n\n\tpublic addExtension(...ids: string[]): this {\n\t\tfor (const id of ids) {\n\t\t\tif (!this._extensions.includes(id)) this._extensions.push(id);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic forwardPort(...ports: number[]): this {\n\t\tfor (const port of ports) {\n\t\t\tif (!this._ports.includes(port)) this._ports.push(port);\n\t\t}\n\t\treturn this;\n\t}\n\n\tpublic addPostCreateCommand(cmd: string): this {\n\t\tif (!this._postCreateCommands.includes(cmd)) this._postCreateCommands.push(cmd);\n\t\treturn this;\n\t}\n\n\tpublic addPostStartCommand(cmd: string): this {\n\t\tif (!this._postStartCommands.includes(cmd)) this._postStartCommands.push(cmd);\n\t\treturn this;\n\t}\n\n\t/** Add a devcontainer Feature, e.g. `ghcr.io/devcontainers/features/node:1`. */\n\tpublic addFeature(id: string, options: Record<string, unknown> = {}): this {\n\t\tthis._devcontainerFeatures.set(id, options);\n\t\treturn this;\n\t}\n\n\tpublic render(): string {\n\t\tconst obj: Record<string, unknown> = { name: this._name };\n\n\t\tif (this._composeFile) {\n\t\t\tobj.dockerComposeFile = [this._composeFile];\n\t\t\tobj.service = this._composeService;\n\t\t\tobj.workspaceFolder = \"/workspace\";\n\t\t\tobj.mounts = [\"source=..,target=/workspace,type=bind,consistency=cached\"];\n\t\t} else {\n\t\t\tobj.image = this._image;\n\t\t}\n\n\t\tif (this._devcontainerFeatures.size > 0) {\n\t\t\tobj.features = Object.fromEntries(this._devcontainerFeatures);\n\t\t}\n\n\t\tif (this._extensions.length > 0) {\n\t\t\tobj.customizations = {\n\t\t\t\tvscode: {\n\t\t\t\t\textensions: this._extensions,\n\t\t\t\t},\n\t\t\t};\n\t\t}\n\n\t\tif (this._ports.length > 0) {\n\t\t\tobj.forwardPorts = this._ports;\n\t\t}\n\n\t\tif (this._postCreateCommands.length > 0) {\n\t\t\tobj.postCreateCommand =\n\t\t\t\tthis._postCreateCommands.length === 1\n\t\t\t\t\t? this._postCreateCommands[0]\n\t\t\t\t\t: this._postCreateCommands.join(\" && \");\n\t\t}\n\n\t\tif (this._postStartCommands.length > 0) {\n\t\t\tobj.postStartCommand =\n\t\t\t\tthis._postStartCommands.length === 1\n\t\t\t\t\t? this._postStartCommands[0]\n\t\t\t\t\t: this._postStartCommands.join(\" && \");\n\t\t}\n\n\t\treturn `${JSON.stringify(obj, null, 2)}\\n`;\n\t}\n}\n"],"names":["modelKey","DockerfileModel","DEVCONTAINER_KEY","DevcontainerModel","_name","_image","_composeFile","_composeService","_dockerfile","_extensions","_ports","_postCreateCommands","_postStartCommands","_devcontainerFeatures","Map","name","image","setImage","useCompose","file","service","dockerfile","addExtension","ids","id","includes","push","forwardPort","ports","port","addPostCreateCommand","cmd","addPostStartCommand","addFeature","options","set","render","obj","dockerComposeFile","workspaceFolder","mounts","size","features","Object","fromEntries","length","customizations","vscode","extensions","forwardPorts","postCreateCommand","join","postStartCommand","JSON","stringify"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,eAAe;AACxC,SAASC,eAAe,QAAQ,wBAAwB;AAExD,OAAO,MAAMC,mBAAmBF,SAA4B,gBAAgB;AAE5E;;;;;;CAMC,GACD,OAAO,MAAMG;IACKC,MAAc;IACvBC,OAAe;IACfC,eAA8B,KAAK;IACnCC,kBAAkB,MAAM;IACxBC,cAAsC,KAAK;IAClCC,cAAwB,EAAE,CAAC;IAC3BC,SAAmB,EAAE,CAAC;IACtBC,sBAAgC,EAAE,CAAC;IACnCC,qBAA+B,EAAE,CAAC;IAClCC,wBAA8D,IAAIC,MAAM;IAEzF,YAAmBC,IAAY,EAAEC,QAAQ,SAAS,CAAE;QACnD,IAAI,CAACZ,KAAK,GAAGW;QACb,IAAI,CAACV,MAAM,GAAGW;IACf;IAEA,IAAWA,QAAgB;QAC1B,OAAO,IAAI,CAACX,MAAM;IACnB;IAEOY,SAASD,KAAa,EAAQ;QACpC,IAAI,CAACX,MAAM,GAAGW;QACd,OAAO,IAAI;IACZ;IAEA,oFAAoF,GACpF,AAAOE,WAAWC,OAAO,oBAAoB,EAAEC,UAAU,cAAc,EAAQ;QAC9E,IAAI,CAACd,YAAY,GAAGa;QACpB,IAAI,CAACZ,eAAe,GAAGa;QACvB,IAAI,CAACZ,WAAW,GAAG,IAAIP;QACvB,OAAO,IAAI;IACZ;IAEA,+DAA+D,GAC/D,IAAWoB,aAAqC;QAC/C,OAAO,IAAI,CAACb,WAAW;IACxB;IAEOc,aAAa,GAAGC,GAAa,EAAQ;QAC3C,KAAK,MAAMC,MAAMD,IAAK;YACrB,IAAI,CAAC,IAAI,CAACd,WAAW,CAACgB,QAAQ,CAACD,KAAK,IAAI,CAACf,WAAW,CAACiB,IAAI,CAACF;QAC3D;QACA,OAAO,IAAI;IACZ;IAEOG,YAAY,GAAGC,KAAe,EAAQ;QAC5C,KAAK,MAAMC,QAAQD,MAAO;YACzB,IAAI,CAAC,IAAI,CAAClB,MAAM,CAACe,QAAQ,CAACI,OAAO,IAAI,CAACnB,MAAM,CAACgB,IAAI,CAACG;QACnD;QACA,OAAO,IAAI;IACZ;IAEOC,qBAAqBC,GAAW,EAAQ;QAC9C,IAAI,CAAC,IAAI,CAACpB,mBAAmB,CAACc,QAAQ,CAACM,MAAM,IAAI,CAACpB,mBAAmB,CAACe,IAAI,CAACK;QAC3E,OAAO,IAAI;IACZ;IAEOC,oBAAoBD,GAAW,EAAQ;QAC7C,IAAI,CAAC,IAAI,CAACnB,kBAAkB,CAACa,QAAQ,CAACM,MAAM,IAAI,CAACnB,kBAAkB,CAACc,IAAI,CAACK;QACzE,OAAO,IAAI;IACZ;IAEA,8EAA8E,GAC9E,AAAOE,WAAWT,EAAU,EAAEU,UAAmC,CAAC,CAAC,EAAQ;QAC1E,IAAI,CAACrB,qBAAqB,CAACsB,GAAG,CAACX,IAAIU;QACnC,OAAO,IAAI;IACZ;IAEOE,SAAiB;QACvB,MAAMC,MAA+B;YAAEtB,MAAM,IAAI,CAACX,KAAK;QAAC;QAExD,IAAI,IAAI,CAACE,YAAY,EAAE;YACtB+B,IAAIC,iBAAiB,GAAG;gBAAC,IAAI,CAAChC,YAAY;aAAC;YAC3C+B,IAAIjB,OAAO,GAAG,IAAI,CAACb,eAAe;YAClC8B,IAAIE,eAAe,GAAG;YACtBF,IAAIG,MAAM,GAAG;gBAAC;aAA2D;QAC1E,OAAO;YACNH,IAAIrB,KAAK,GAAG,IAAI,CAACX,MAAM;QACxB;QAEA,IAAI,IAAI,CAACQ,qBAAqB,CAAC4B,IAAI,GAAG,GAAG;YACxCJ,IAAIK,QAAQ,GAAGC,OAAOC,WAAW,CAAC,IAAI,CAAC/B,qBAAqB;QAC7D;QAEA,IAAI,IAAI,CAACJ,WAAW,CAACoC,MAAM,GAAG,GAAG;YAChCR,IAAIS,cAAc,GAAG;gBACpBC,QAAQ;oBACPC,YAAY,IAAI,CAACvC,WAAW;gBAC7B;YACD;QACD;QAEA,IAAI,IAAI,CAACC,MAAM,CAACmC,MAAM,GAAG,GAAG;YAC3BR,IAAIY,YAAY,GAAG,IAAI,CAACvC,MAAM;QAC/B;QAEA,IAAI,IAAI,CAACC,mBAAmB,CAACkC,MAAM,GAAG,GAAG;YACxCR,IAAIa,iBAAiB,GACpB,IAAI,CAACvC,mBAAmB,CAACkC,MAAM,KAAK,IACjC,IAAI,CAAClC,mBAAmB,CAAC,EAAE,GAC3B,IAAI,CAACA,mBAAmB,CAACwC,IAAI,CAAC;QACnC;QAEA,IAAI,IAAI,CAACvC,kBAAkB,CAACiC,MAAM,GAAG,GAAG;YACvCR,IAAIe,gBAAgB,GACnB,IAAI,CAACxC,kBAAkB,CAACiC,MAAM,KAAK,IAChC,IAAI,CAACjC,kBAAkB,CAAC,EAAE,GAC1B,IAAI,CAACA,kBAAkB,CAACuC,IAAI,CAAC;QAClC;QAEA,OAAO,GAAGE,KAAKC,SAAS,CAACjB,KAAK,MAAM,GAAG,EAAE,CAAC;IAC3C;AACD"}

package/es6/v1/domain/dockerfile.model.js

@@ -0,0 +1,52 @@
+export class DockerfileModel {
+    _baseImage;
+    _runs = [];
+    constructor(baseImage = "node:24"){
+        this._baseImage = baseImage;
+    }
+    /**
+	 * Append a RUN instruction executed as root, inserted after the base
+	 * toolchain setup and before the USER switch.
+	 */ addRun(cmd) {
+        this._runs.push(cmd);
+        return this;
+    }
+    render() {
+        const extras = this._runs.length > 0 ? `\n${this._runs.map((cmd)=>`RUN ${cmd}`).join("\n\n")}\n` : "";
+        return `FROM ${this._baseImage}
+
+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"
+${extras}
+USER \${USERNAME}
+`;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/feature.js

@@ -0,0 +1,9 @@
+export const PHASES = [
+    "resolve",
+    "configure",
+    "render",
+    "integrate",
+    "finalize"
+];
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/import-map.js

@@ -0,0 +1,64 @@
+/**
+ * Groups imports from the same package, rendering mixed value+type imports
+ * as `import { A, type B } from "pkg"` rather than two separate statements.
+ */ export class ImportMap {
+    _packages = new Map();
+    _entry(pkg) {
+        const existing = this._packages.get(pkg);
+        if (existing) return existing;
+        const e = {
+            named: new Set(),
+            types: new Set(),
+            sideEffect: false
+        };
+        this._packages.set(pkg, e);
+        return e;
+    }
+    /**
+	 * Add named value imports.
+	 * Called with no names, registers a side-effect `import "pkg"`.
+	 */ add(pkg, ...names) {
+        const e = this._entry(pkg);
+        if (names.length === 0) e.sideEffect = true;
+        else for (const n of names)e.named.add(n);
+        return this;
+    }
+    /** Add type-only named imports. */ addType(pkg, ...names) {
+        const e = this._entry(pkg);
+        for (const n of names)e.types.add(n);
+        return this;
+    }
+    /**
+	 * Render to an array of import statement strings (insertion order preserved).
+	 *
+	 * - All-type package  → `import type { A, B } from "pkg";`
+	 * - All-value package → `import { A, B } from "pkg";`
+	 * - Mixed package     → `import { A, type B } from "pkg";`
+	 * - Side-effect only  → `import "pkg";`
+	 */ render() {
+        const lines = [];
+        for (const [pkg, e] of this._packages){
+            if (e.sideEffect) lines.push(`import "${pkg}";`);
+            const named = [
+                ...e.named
+            ].sort();
+            const types = [
+                ...e.types
+            ].sort();
+            if (named.length === 0 && types.length > 0) {
+                lines.push(`import type { ${types.join(", ")} } from "${pkg}";`);
+            } else if (named.length > 0 && types.length === 0) {
+                lines.push(`import { ${named.join(", ")} } from "${pkg}";`);
+            } else if (named.length > 0 && types.length > 0) {
+                const all = [
+                    ...named,
+                    ...types.map((t)=>`type ${t}`)
+                ].join(", ");
+                lines.push(`import { ${all} } from "${pkg}";`);
+            }
+        }
+        return lines;
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/index.js

@@ -0,0 +1,11 @@
+export { ClassModel } from "./class-model.js";
+export { COMPOSE_KEY, ComposeModel } from "./compose.model.js";
+export { createContext, FeatureModelStore, modelKey } from "./context.js";
+export { DEVCONTAINER_KEY, DevcontainerModel } from "./devcontainer.model.js";
+export { DockerfileModel } from "./dockerfile.model.js";
+export { PHASES } from "./feature.js";
+export { ImportMap } from "./import-map.js";
+export { ask, pick } from "./prompt.js";
+export { defineWorkflow, runWorkflow } from "./workflow.js";
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/prompt.js

@@ -0,0 +1,27 @@
+import { createInterface } from "node:readline/promises";
+export async function ask(question, fallback = "") {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const answer = (await rl.question(question)).trim();
+    rl.close();
+    return answer || fallback;
+}
+export async function pick(label, items, display) {
+    console.log(label.trimEnd());
+    for (const [i, item] of items.entries()){
+        console.log(`    ${i + 1}. ${display(item)}`);
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    const answer = (await rl.question("  > ")).trim();
+    rl.close();
+    const idx = Number.parseInt(answer, 10);
+    if (Number.isNaN(idx) || idx < 1 || idx > items.length) return null;
+    return items[idx - 1];
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/domain/workflow.js

@@ -0,0 +1,24 @@
+import { PHASES } from "./feature.js";
+export function defineWorkflow(name, features) {
+    return {
+        name,
+        features
+    };
+}
+/**
+ * Runs a workflow by iterating phases × features. Within each phase, every
+ * enabled feature's step for that phase is executed in feature order. The
+ * `enabled` predicate is re-evaluated before each phase so a feature can
+ * become active based on options set by earlier `resolve` phases.
+ */ export async function runWorkflow(workflow, ctx) {
+    for (const phase of PHASES){
+        for (const feature of workflow.features){
+            const step = feature[phase];
+            if (step == null) continue;
+            if (feature.enabled != null && !feature.enabled(ctx)) continue;
+            ctx = await step(ctx);
+        }
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/features/api-core/feature.js

@@ -0,0 +1,93 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { DEVCONTAINER_KEY, DevcontainerModel } from "../../domain/devcontainer.model.js";
+import { ask, pick } from "../../domain/index.js";
+import { createHelloController } from "./hello-controller.model.js";
+import { MAIN_TS_KEY, MainTsModel } from "./main-ts.model.js";
+import { apiPackageJson, CONFIG_DEV_YAML, configYaml, GITIGNORE, rootPackageJson, SAMPLE_CONFIG_TS, SAMPLE_SERVICE_TS, TSCONFIG, VSCODE_LAUNCH_JSON, vscodeSettingsJson } from "./scaffold-files.template.js";
+async function resolve(ctx) {
+    if (ctx.opts.yes) return ctx;
+    let { database, idp, postman } = ctx.opts;
+    if (database == null) {
+        console.log("\n  Select database:");
+        const db = await pick("  Choice (enter for none): ", [
+            "postgresql/typeorm"
+        ], (id)=>id);
+        database = db === "postgresql/typeorm" ? "typeorm" : undefined;
+    }
+    if (idp == null) {
+        console.log("\n  Select identity provider:");
+        const provider = await pick("  Choice (enter for none): ", [
+            "Auth0"
+        ], (id)=>id);
+        idp = provider === "Auth0" ? "auth0" : undefined;
+    }
+    if (!postman) {
+        const answer = await ask("\n  Configure Postman workspace? [yes/no] (no): ");
+        postman = answer === "yes" || undefined;
+    }
+    return {
+        ...ctx,
+        opts: {
+            ...ctx.opts,
+            database,
+            idp,
+            postman
+        }
+    };
+}
+async function configure(ctx) {
+    const helloController = createHelloController();
+    const devcontainer = new DevcontainerModel(`${ctx.projectName}.api`).addExtension("biomejs.biome", "vitest.explorer").forwardPort(3000).addPostStartCommand("npm whoami 2>/dev/null || npm login");
+    return {
+        ...ctx,
+        models: ctx.models.set(MAIN_TS_KEY, new MainTsModel(`${ctx.projectName}.api`)).set(DEVCONTAINER_KEY, devcontainer),
+        controllers: [
+            ...ctx.controllers,
+            helloController
+        ]
+    };
+}
+async function render(ctx) {
+    const { targetDir, projectName } = ctx;
+    await Promise.all([
+        mkdir(join(targetDir, ".vscode"), {
+            recursive: true
+        }),
+        mkdir(join(targetDir, "projects", "api", "src", "controllers"), {
+            recursive: true
+        }),
+        mkdir(join(targetDir, "config"), {
+            recursive: true
+        })
+    ]);
+    const { controllers } = ctx;
+    const mainTsModel = ctx.models.get(MAIN_TS_KEY);
+    const writes = [
+        writeFile(join(targetDir, "package.json"), rootPackageJson(projectName)),
+        writeFile(join(targetDir, "tsconfig.json"), TSCONFIG),
+        writeFile(join(targetDir, "projects", "api", "package.json"), apiPackageJson(projectName)),
+        writeFile(join(targetDir, "projects", "api", "src", "sample.config.ts"), SAMPLE_CONFIG_TS),
+        writeFile(join(targetDir, "projects", "api", "src", "sample.service.ts"), SAMPLE_SERVICE_TS),
+        writeFile(join(targetDir, "config", "config.yaml"), configYaml()),
+        writeFile(join(targetDir, "config", "config.dev.yaml"), CONFIG_DEV_YAML),
+        writeFile(join(targetDir, ".vscode", "launch.json"), VSCODE_LAUNCH_JSON),
+        writeFile(join(targetDir, ".vscode", "settings.json"), vscodeSettingsJson(projectName)),
+        writeFile(join(targetDir, ".gitignore"), GITIGNORE),
+        ...controllers.map((c)=>writeFile(join(targetDir, "projects", "api", "src", "controllers", c.fileName), c.render()))
+    ];
+    if (mainTsModel) {
+        for (const c of controllers)mainTsModel.addController(c);
+        writes.push(writeFile(join(targetDir, "projects", "api", "src", "main.ts"), mainTsModel.render()));
+    }
+    await Promise.all(writes);
+    return ctx;
+}
+export const apiCoreFeature = {
+    name: "api-core",
+    resolve,
+    configure,
+    render
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/create/v1/features/api-core/feature.ts"],"sourcesContent":["import { mkdir, writeFile } from \"node:fs/promises\";\nimport { join } from \"node:path\";\nimport { DEVCONTAINER_KEY, DevcontainerModel } from \"../../domain/devcontainer.model.js\";\nimport { ask, type Feature, pick, type ScaffoldContext } from \"../../domain/index.js\";\nimport { createHelloController } from \"./hello-controller.model.js\";\nimport { MAIN_TS_KEY, MainTsModel } from \"./main-ts.model.js\";\nimport {\n\tapiPackageJson,\n\tCONFIG_DEV_YAML,\n\tconfigYaml,\n\tGITIGNORE,\n\trootPackageJson,\n\tSAMPLE_CONFIG_TS,\n\tSAMPLE_SERVICE_TS,\n\tTSCONFIG,\n\tVSCODE_LAUNCH_JSON,\n\tvscodeSettingsJson,\n} from \"./scaffold-files.template.js\";\n\nasync function resolve(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tif (ctx.opts.yes) return ctx;\n\n\tlet { database, idp, postman } = ctx.opts;\n\n\tif (database == null) {\n\t\tconsole.log(\"\\n  Select database:\");\n\t\tconst db = await pick(\"  Choice (enter for none): \", [\"postgresql/typeorm\"], (id) => id);\n\t\tdatabase = db === \"postgresql/typeorm\" ? \"typeorm\" : undefined;\n\t}\n\n\tif (idp == null) {\n\t\tconsole.log(\"\\n  Select identity provider:\");\n\t\tconst provider = await pick(\"  Choice (enter for none): \", [\"Auth0\"], (id) => id);\n\t\tidp = provider === \"Auth0\" ? \"auth0\" : undefined;\n\t}\n\n\tif (!postman) {\n\t\tconst answer = await ask(\"\\n  Configure Postman workspace? [yes/no] (no): \");\n\t\tpostman = answer === \"yes\" || undefined;\n\t}\n\n\treturn { ...ctx, opts: { ...ctx.opts, database, idp, postman } };\n}\n\nasync function configure(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tconst helloController = createHelloController();\n\tconst devcontainer = new DevcontainerModel(`${ctx.projectName}.api`)\n\t\t.addExtension(\"biomejs.biome\", \"vitest.explorer\")\n\t\t.forwardPort(3000)\n\t\t.addPostStartCommand(\"npm whoami 2>/dev/null || npm login\");\n\treturn {\n\t\t...ctx,\n\t\tmodels: ctx.models\n\t\t\t.set(MAIN_TS_KEY, new MainTsModel(`${ctx.projectName}.api`))\n\t\t\t.set(DEVCONTAINER_KEY, devcontainer),\n\t\tcontrollers: [...ctx.controllers, helloController],\n\t};\n}\n\nasync function render(ctx: ScaffoldContext): Promise<ScaffoldContext> {\n\tconst { targetDir, projectName } = ctx;\n\n\tawait Promise.all([\n\t\tmkdir(join(targetDir, \".vscode\"), { recursive: true }),\n\t\tmkdir(join(targetDir, \"projects\", \"api\", \"src\", \"controllers\"), { recursive: true }),\n\t\tmkdir(join(targetDir, \"config\"), { recursive: true }),\n\t]);\n\n\tconst { controllers } = ctx;\n\tconst mainTsModel = ctx.models.get(MAIN_TS_KEY);\n\n\tconst writes: Array<Promise<unknown>> = [\n\t\twriteFile(join(targetDir, \"package.json\"), rootPackageJson(projectName)),\n\t\twriteFile(join(targetDir, \"tsconfig.json\"), TSCONFIG),\n\t\twriteFile(join(targetDir, \"projects\", \"api\", \"package.json\"), apiPackageJson(projectName)),\n\t\twriteFile(join(targetDir, \"projects\", \"api\", \"src\", \"sample.config.ts\"), SAMPLE_CONFIG_TS),\n\t\twriteFile(\n\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"sample.service.ts\"),\n\t\t\tSAMPLE_SERVICE_TS,\n\t\t),\n\t\twriteFile(join(targetDir, \"config\", \"config.yaml\"), configYaml()),\n\t\twriteFile(join(targetDir, \"config\", \"config.dev.yaml\"), CONFIG_DEV_YAML),\n\t\twriteFile(join(targetDir, \".vscode\", \"launch.json\"), VSCODE_LAUNCH_JSON),\n\t\twriteFile(join(targetDir, \".vscode\", \"settings.json\"), vscodeSettingsJson(projectName)),\n\t\twriteFile(join(targetDir, \".gitignore\"), GITIGNORE),\n\t\t...controllers.map((c) =>\n\t\t\twriteFile(\n\t\t\t\tjoin(targetDir, \"projects\", \"api\", \"src\", \"controllers\", c.fileName),\n\t\t\t\tc.render(),\n\t\t\t),\n\t\t),\n\t];\n\n\tif (mainTsModel) {\n\t\tfor (const c of controllers) mainTsModel.addController(c);\n\t\twrites.push(\n\t\t\twriteFile(join(targetDir, \"projects\", \"api\", \"src\", \"main.ts\"), mainTsModel.render()),\n\t\t);\n\t}\n\n\tawait Promise.all(writes);\n\treturn ctx;\n}\n\nexport const apiCoreFeature: Feature = {\n\tname: \"api-core\",\n\tresolve,\n\tconfigure,\n\trender,\n};\n"],"names":["mkdir","writeFile","join","DEVCONTAINER_KEY","DevcontainerModel","ask","pick","createHelloController","MAIN_TS_KEY","MainTsModel","apiPackageJson","CONFIG_DEV_YAML","configYaml","GITIGNORE","rootPackageJson","SAMPLE_CONFIG_TS","SAMPLE_SERVICE_TS","TSCONFIG","VSCODE_LAUNCH_JSON","vscodeSettingsJson","resolve","ctx","opts","yes","database","idp","postman","console","log","db","id","undefined","provider","answer","configure","helloController","devcontainer","projectName","addExtension","forwardPort","addPostStartCommand","models","set","controllers","render","targetDir","Promise","all","recursive","mainTsModel","get","writes","map","c","fileName","addController","push","apiCoreFeature","name"],"mappings":"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"}

package/es6/v1/features/api-core/hello-controller.model.js

@@ -0,0 +1,96 @@
+import { ClassModel } from "../../domain/class-model.js";
+/**
+ * Create the seed controller scaffolded into every new api project.
+ *
+ * Defines only the base CRUD structure.  Auth decorators, IPrincipalProvider
+ * injection, and other cross-cutting concerns are added by the relevant
+ * feature during its configure phase.
+ */ export function createHelloController() {
+    return new ClassModel("HelloController", "hello.controller.ts").addImport("@decohere/cortex", "Controller", "Delete", "Field", "Get", "Param", "Post", "Put", "Query").addImport("../sample.service.js", "SampleService").decorateClass(`@Controller({ prefix: "/hello" })`).addBodyClass({
+        name: "HelloBody",
+        fields: [
+            {
+                decorator: `@Field("body", "message")`,
+                name: "message",
+                typeName: "string"
+            }
+        ]
+    }).addConstructorParam({
+        paramDecorators: [],
+        name: "sample",
+        typeName: "SampleService",
+        isPrivate: true,
+        isReadonly: true
+    }).defineMethod({
+        decorators: [
+            "@Get()"
+        ],
+        name: "getAll",
+        isAsync: true,
+        params: [
+            {
+                decorator: `@Query("filter")`,
+                name: "filter",
+                typeName: "string"
+            }
+        ],
+        body: `const greeting = await this.sample.getGreeting();\n\t\treturn { filter, message: greeting };`
+    }).defineMethod({
+        decorators: [
+            `@Get("/:id")`
+        ],
+        name: "getOne",
+        params: [
+            {
+                decorator: `@Param("id")`,
+                name: "id",
+                typeName: "string"
+            }
+        ],
+        body: `return { id, message: \`Hello \${id}!\` };`
+    }).defineMethod({
+        decorators: [
+            `@Post("/")`
+        ],
+        name: "create",
+        params: [
+            {
+                name: "body",
+                typeName: "HelloBody"
+            }
+        ],
+        body: `return { message: body.message };`
+    }).defineMethod({
+        decorators: [
+            `@Put("/:id")`
+        ],
+        name: "update",
+        params: [
+            {
+                decorator: `@Param("id")`,
+                name: "id",
+                typeName: "string"
+            },
+            {
+                name: "body",
+                typeName: "HelloBody"
+            }
+        ],
+        body: `return { id, message: body.message };`
+    }).defineMethod({
+        decorators: [
+            `@Delete("/:id")`
+        ],
+        name: "remove",
+        params: [
+            {
+                decorator: `@Param("id")`,
+                name: "id",
+                typeName: "string"
+            }
+        ],
+        body: `return { id, deleted: true };`
+    });
+}
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS9mZWF0dXJlcy9hcGktY29yZS9oZWxsby1jb250cm9sbGVyLm1vZGVsLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENsYXNzTW9kZWwgfSBmcm9tIFwiLi4vLi4vZG9tYWluL2NsYXNzLW1vZGVsLmpzXCI7XG5cbi8qKlxuICogQ3JlYXRlIHRoZSBzZWVkIGNvbnRyb2xsZXIgc2NhZmZvbGRlZCBpbnRvIGV2ZXJ5IG5ldyBhcGkgcHJvamVjdC5cbiAqXG4gKiBEZWZpbmVzIG9ubHkgdGhlIGJhc2UgQ1JVRCBzdHJ1Y3R1cmUuICBBdXRoIGRlY29yYXRvcnMsIElQcmluY2lwYWxQcm92aWRlclxuICogaW5qZWN0aW9uLCBhbmQgb3RoZXIgY3Jvc3MtY3V0dGluZyBjb25jZXJucyBhcmUgYWRkZWQgYnkgdGhlIHJlbGV2YW50XG4gKiBmZWF0dXJlIGR1cmluZyBpdHMgY29uZmlndXJlIHBoYXNlLlxuICovXG5leHBvcnQgZnVuY3Rpb24gY3JlYXRlSGVsbG9Db250cm9sbGVyKCk6IENsYXNzTW9kZWwge1xuXHRyZXR1cm4gbmV3IENsYXNzTW9kZWwoXCJIZWxsb0NvbnRyb2xsZXJcIiwgXCJoZWxsby5jb250cm9sbGVyLnRzXCIpXG5cdFx0LmFkZEltcG9ydChcblx0XHRcdFwiQGRlY29oZXJlL2NvcnRleFwiLFxuXHRcdFx0XCJDb250cm9sbGVyXCIsXG5cdFx0XHRcIkRlbGV0ZVwiLFxuXHRcdFx0XCJGaWVsZFwiLFxuXHRcdFx0XCJHZXRcIixcblx0XHRcdFwiUGFyYW1cIixcblx0XHRcdFwiUG9zdFwiLFxuXHRcdFx0XCJQdXRcIixcblx0XHRcdFwiUXVlcnlcIixcblx0XHQpXG5cdFx0LmFkZEltcG9ydChcIi4uL3NhbXBsZS5zZXJ2aWNlLmpzXCIsIFwiU2FtcGxlU2VydmljZVwiKVxuXHRcdC5kZWNvcmF0ZUNsYXNzKGBAQ29udHJvbGxlcih7IHByZWZpeDogXCIvaGVsbG9cIiB9KWApXG5cdFx0LmFkZEJvZHlDbGFzcyh7XG5cdFx0XHRuYW1lOiBcIkhlbGxvQm9keVwiLFxuXHRcdFx0ZmllbGRzOiBbXG5cdFx0XHRcdHsgZGVjb3JhdG9yOiBgQEZpZWxkKFwiYm9keVwiLCBcIm1lc3NhZ2VcIilgLCBuYW1lOiBcIm1lc3NhZ2VcIiwgdHlwZU5hbWU6IFwic3RyaW5nXCIgfSxcblx0XHRcdF0sXG5cdFx0fSlcblx0XHQuYWRkQ29uc3RydWN0b3JQYXJhbSh7XG5cdFx0XHRwYXJhbURlY29yYXRvcnM6IFtdLFxuXHRcdFx0bmFtZTogXCJzYW1wbGVcIixcblx0XHRcdHR5cGVOYW1lOiBcIlNhbXBsZVNlcnZpY2VcIixcblx0XHRcdGlzUHJpdmF0ZTogdHJ1ZSxcblx0XHRcdGlzUmVhZG9ubHk6IHRydWUsXG5cdFx0fSlcblx0XHQuZGVmaW5lTWV0aG9kKHtcblx0XHRcdGRlY29yYXRvcnM6IFtcIkBHZXQoKVwiXSxcblx0XHRcdG5hbWU6IFwiZ2V0QWxsXCIsXG5cdFx0XHRpc0FzeW5jOiB0cnVlLFxuXHRcdFx0cGFyYW1zOiBbeyBkZWNvcmF0b3I6IGBAUXVlcnkoXCJmaWx0ZXJcIilgLCBuYW1lOiBcImZpbHRlclwiLCB0eXBlTmFtZTogXCJzdHJpbmdcIiB9XSxcblx0XHRcdGJvZHk6IGBjb25zdCBncmVldGluZyA9IGF3YWl0IHRoaXMuc2FtcGxlLmdldEdyZWV0aW5nKCk7XFxuXFx0XFx0cmV0dXJuIHsgZmlsdGVyLCBtZXNzYWdlOiBncmVldGluZyB9O2AsXG5cdFx0fSlcblx0XHQuZGVmaW5lTWV0aG9kKHtcblx0XHRcdGRlY29yYXRvcnM6IFtgQEdldChcIi86aWRcIilgXSxcblx0XHRcdG5hbWU6IFwiZ2V0T25lXCIsXG5cdFx0XHRwYXJhbXM6IFt7IGRlY29yYXRvcjogYEBQYXJhbShcImlkXCIpYCwgbmFtZTogXCJpZFwiLCB0eXBlTmFtZTogXCJzdHJpbmdcIiB9XSxcblx0XHRcdGJvZHk6IGByZXR1cm4geyBpZCwgbWVzc2FnZTogXFxgSGVsbG8gXFwke2lkfSFcXGAgfTtgLFxuXHRcdH0pXG5cdFx0LmRlZmluZU1ldGhvZCh7XG5cdFx0XHRkZWNvcmF0b3JzOiBbYEBQb3N0KFwiL1wiKWBdLFxuXHRcdFx0bmFtZTogXCJjcmVhdGVcIixcblx0XHRcdHBhcmFtczogW3sgbmFtZTogXCJib2R5XCIsIHR5cGVOYW1lOiBcIkhlbGxvQm9keVwiIH1dLFxuXHRcdFx0Ym9keTogYHJldHVybiB7IG1lc3NhZ2U6IGJvZHkubWVzc2FnZSB9O2AsXG5cdFx0fSlcblx0XHQuZGVmaW5lTWV0aG9kKHtcblx0XHRcdGRlY29yYXRvcnM6IFtgQFB1dChcIi86aWRcIilgXSxcblx0XHRcdG5hbWU6IFwidXBkYXRlXCIsXG5cdFx0XHRwYXJhbXM6IFtcblx0XHRcdFx0eyBkZWNvcmF0b3I6IGBAUGFyYW0oXCJpZFwiKWAsIG5hbWU6IFwiaWRcIiwgdHlwZU5hbWU6IFwic3RyaW5nXCIgfSxcblx0XHRcdFx0eyBuYW1lOiBcImJvZHlcIiwgdHlwZU5hbWU6IFwiSGVsbG9Cb2R5XCIgfSxcblx0XHRcdF0sXG5cdFx0XHRib2R5OiBgcmV0dXJuIHsgaWQsIG1lc3NhZ2U6IGJvZHkubWVzc2FnZSB9O2AsXG5cdFx0fSlcblx0XHQuZGVmaW5lTWV0aG9kKHtcblx0XHRcdGRlY29yYXRvcnM6IFtgQERlbGV0ZShcIi86aWRcIilgXSxcblx0XHRcdG5hbWU6IFwicmVtb3ZlXCIsXG5cdFx0XHRwYXJhbXM6IFt7IGRlY29yYXRvcjogYEBQYXJhbShcImlkXCIpYCwgbmFtZTogXCJpZFwiLCB0eXBlTmFtZTogXCJzdHJpbmdcIiB9XSxcblx0XHRcdGJvZHk6IGByZXR1cm4geyBpZCwgZGVsZXRlZDogdHJ1ZSB9O2AsXG5cdFx0fSk7XG59XG4iXSwibmFtZXMiOlsiQ2xhc3NNb2RlbCIsImNyZWF0ZUhlbGxvQ29udHJvbGxlciIsImFkZEltcG9ydCIsImRlY29yYXRlQ2xhc3MiLCJhZGRCb2R5Q2xhc3MiLCJuYW1lIiwiZmllbGRzIiwiZGVjb3JhdG9yIiwidHlwZU5hbWUiLCJhZGRDb25zdHJ1Y3RvclBhcmFtIiwicGFyYW1EZWNvcmF0b3JzIiwiaXNQcml2YXRlIiwiaXNSZWFkb25seSIsImRlZmluZU1ldGhvZCIsImRlY29yYXRvcnMiLCJpc0FzeW5jIiwicGFyYW1zIiwiYm9keSJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxRQUFRLDhCQUE4QjtBQUV6RDs7Ozs7O0NBTUMsR0FDRCxPQUFPLFNBQVNDO0lBQ2YsT0FBTyxJQUFJRCxXQUFXLG1CQUFtQix1QkFDdkNFLFNBQVMsQ0FDVCxvQkFDQSxjQUNBLFVBQ0EsU0FDQSxPQUNBLFNBQ0EsUUFDQSxPQUNBLFNBRUFBLFNBQVMsQ0FBQyx3QkFBd0IsaUJBQ2xDQyxhQUFhLENBQUMsQ0FBQyxpQ0FBaUMsQ0FBQyxFQUNqREMsWUFBWSxDQUFDO1FBQ2JDLE1BQU07UUFDTkMsUUFBUTtZQUNQO2dCQUFFQyxXQUFXLENBQUMseUJBQXlCLENBQUM7Z0JBQUVGLE1BQU07Z0JBQVdHLFVBQVU7WUFBUztTQUM5RTtJQUNGLEdBQ0NDLG1CQUFtQixDQUFDO1FBQ3BCQyxpQkFBaUIsRUFBRTtRQUNuQkwsTUFBTTtRQUNORyxVQUFVO1FBQ1ZHLFdBQVc7UUFDWEMsWUFBWTtJQUNiLEdBQ0NDLFlBQVksQ0FBQztRQUNiQyxZQUFZO1lBQUM7U0FBUztRQUN0QlQsTUFBTTtRQUNOVSxTQUFTO1FBQ1RDLFFBQVE7WUFBQztnQkFBRVQsV0FBVyxDQUFDLGdCQUFnQixDQUFDO2dCQUFFRixNQUFNO2dCQUFVRyxVQUFVO1lBQVM7U0FBRTtRQUMvRVMsTUFBTSxDQUFDLDRGQUE0RixDQUFDO0lBQ3JHLEdBQ0NKLFlBQVksQ0FBQztRQUNiQyxZQUFZO1lBQUMsQ0FBQyxZQUFZLENBQUM7U0FBQztRQUM1QlQsTUFBTTtRQUNOVyxRQUFRO1lBQUM7Z0JBQUVULFdBQVcsQ0FBQyxZQUFZLENBQUM7Z0JBQUVGLE1BQU07Z0JBQU1HLFVBQVU7WUFBUztTQUFFO1FBQ3ZFUyxNQUFNLENBQUMsMENBQTBDLENBQUM7SUFDbkQsR0FDQ0osWUFBWSxDQUFDO1FBQ2JDLFlBQVk7WUFBQyxDQUFDLFVBQVUsQ0FBQztTQUFDO1FBQzFCVCxNQUFNO1FBQ05XLFFBQVE7WUFBQztnQkFBRVgsTUFBTTtnQkFBUUcsVUFBVTtZQUFZO1NBQUU7UUFDakRTLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQztJQUMxQyxHQUNDSixZQUFZLENBQUM7UUFDYkMsWUFBWTtZQUFDLENBQUMsWUFBWSxDQUFDO1NBQUM7UUFDNUJULE1BQU07UUFDTlcsUUFBUTtZQUNQO2dCQUFFVCxXQUFXLENBQUMsWUFBWSxDQUFDO2dCQUFFRixNQUFNO2dCQUFNRyxVQUFVO1lBQVM7WUFDNUQ7Z0JBQUVILE1BQU07Z0JBQVFHLFVBQVU7WUFBWTtTQUN0QztRQUNEUyxNQUFNLENBQUMscUNBQXFDLENBQUM7SUFDOUMsR0FDQ0osWUFBWSxDQUFDO1FBQ2JDLFlBQVk7WUFBQyxDQUFDLGVBQWUsQ0FBQztTQUFDO1FBQy9CVCxNQUFNO1FBQ05XLFFBQVE7WUFBQztnQkFBRVQsV0FBVyxDQUFDLFlBQVksQ0FBQztnQkFBRUYsTUFBTTtnQkFBTUcsVUFBVTtZQUFTO1NBQUU7UUFDdkVTLE1BQU0sQ0FBQyw2QkFBNkIsQ0FBQztJQUN0QztBQUNGIn0=