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

package/es6/v1/workflows/api.js

@@ -0,0 +1,25 @@
+import { defineWorkflow } from "../domain/index.js";
+import { apiCoreFeature } from "../features/api-core/feature.js";
+import { auth0Feature } from "../features/auth0/feature.js";
+import { devcontainerFeature } from "../features/devcontainer/feature.js";
+import { finalizeFeature } from "../features/finalize/feature.js";
+import { postgresqlFeature } from "../features/postgresql/feature.js";
+import { postmanFeature } from "../features/postman/feature.js";
+import { typeormFeature } from "../features/typeorm/feature.js";
+/**
+ * Order matters within each phase:
+ *   - apiCore must render before typeorm (typeorm reads the config.yaml that
+ *     apiCore writes).
+ *   - typeorm must render before auth0 (both append to config.prod.yaml; the
+ *     existing behaviour writes the database section first, then auth).
+ */ export const apiWorkflow = defineWorkflow("api", [
+    apiCoreFeature,
+    typeormFeature,
+    postgresqlFeature,
+    auth0Feature,
+    postmanFeature,
+    devcontainerFeature,
+    finalizeFeature
+]);
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/v1/workflows/cli.js

@@ -0,0 +1,9 @@
+import { defineWorkflow } from "../domain/index.js";
+import { cliCoreFeature } from "../features/cli-core/feature.js";
+import { finalizeFeature } from "../features/finalize/feature.js";
+export const cliWorkflow = defineWorkflow("cli", [
+    cliCoreFeature,
+    finalizeFeature
+]);
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2NyZWF0ZS92MS93b3JrZmxvd3MvY2xpLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGRlZmluZVdvcmtmbG93IH0gZnJvbSBcIi4uL2RvbWFpbi9pbmRleC5qc1wiO1xuaW1wb3J0IHsgY2xpQ29yZUZlYXR1cmUgfSBmcm9tIFwiLi4vZmVhdHVyZXMvY2xpLWNvcmUvZmVhdHVyZS5qc1wiO1xuaW1wb3J0IHsgZmluYWxpemVGZWF0dXJlIH0gZnJvbSBcIi4uL2ZlYXR1cmVzL2ZpbmFsaXplL2ZlYXR1cmUuanNcIjtcblxuZXhwb3J0IGNvbnN0IGNsaVdvcmtmbG93ID0gZGVmaW5lV29ya2Zsb3coXCJjbGlcIiwgW2NsaUNvcmVGZWF0dXJlLCBmaW5hbGl6ZUZlYXR1cmVdKTtcbiJdLCJuYW1lcyI6WyJkZWZpbmVXb3JrZmxvdyIsImNsaUNvcmVGZWF0dXJlIiwiZmluYWxpemVGZWF0dXJlIiwiY2xpV29ya2Zsb3ciXSwibWFwcGluZ3MiOiJBQUFBLFNBQVNBLGNBQWMsUUFBUSxxQkFBcUI7QUFDcEQsU0FBU0MsY0FBYyxRQUFRLGtDQUFrQztBQUNqRSxTQUFTQyxlQUFlLFFBQVEsa0NBQWtDO0FBRWxFLE9BQU8sTUFBTUMsY0FBY0gsZUFBZSxPQUFPO0lBQUNDO0lBQWdCQztDQUFnQixFQUFFIn0=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/create",
-  "version": "0.0.1-dev.17",
+  "version": "0.0.1-dev.18",
   "description": "Scaffold a new Decohere project — build with Forge, serve with Flux",
   "keywords": [
     "decohere",
@@ -21,7 +21,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.17",
+    "@decohere/nexus": "0.0.1-dev.18",
     "commander": "^13.1.0"
   },
   "devDependencies": {}

package/types/src/models/compose.model.d.ts

@@ -0,0 +1,32 @@
+import type { KeyedModel } from "./source-file.js";
+export interface ComposeService {
+    build?: string;
+    image?: string;
+    env_file?: string[];
+    environment?: Record<string, string>;
+    ports?: string[];
+    volumes?: string[];
+    command?: string;
+    restart?: string;
+    depends_on?: string[];
+}
+/**
+ * Live builder for `docker-compose.yml`.
+ *
+ * Features call `addService` / `addVolume` in their `configure` phases.
+ * The devcontainer `render` phase calls `render()` and writes the file.
+ */
+export declare class DockerCompose implements KeyedModel {
+    readonly key: string;
+    private readonly _services;
+    private readonly _volumes;
+    addService(name: string, config: ComposeService): this;
+    files(): {
+        filePath: string;
+        content: string;
+    }[];
+    addVolume(name: string): this;
+    /** Append an env_file path to an existing service. */
+    addEnvFile(serviceName: string, filePath: string): this;
+    getContent(): string;
+}

package/types/src/models/config-yaml.model.d.ts

@@ -0,0 +1,16 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * 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 declare class ConfigYaml implements KeyedModel {
+    readonly key: string;
+    private readonly filePath;
+    private readonly _sections;
+    constructor(key: string, filePath: string, baseContent: string);
+    addSection(yaml: string): this;
+    files(): SourceFile[];
+}

package/types/src/models/const.d.ts

@@ -0,0 +1,17 @@
+export declare const WELL_KNOWN_FILES: {
+    VSCODE_SETTINGS: string;
+    LAUNCH_JSON: string;
+    DOCKER_COMPOSE: string;
+    DEVCONTAINER_JSON: string;
+    DOCKERFILE: string;
+    PACKAGE_JSON: string;
+    API_PACKAGE_JSON: string;
+    TSCONFIG: string;
+    MAIN_TS: string;
+    CONTROLLER_TS: string;
+    CONFIG_YAML: string;
+    CONFIG_DEV_YAML: string;
+    GITIGNORE: string;
+    AUTH_CONFIG: string;
+    ENV_FILE: string;
+};

package/types/src/models/container-image.model.d.ts

@@ -0,0 +1,15 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * 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 declare class DockerfileModel implements KeyedModel {
+    readonly key: string;
+    private readonly _runSteps;
+    /** Append a RUN instruction (pass the command, not the RUN keyword). */
+    addRunStep(cmd: string): this;
+    files(): SourceFile[];
+}

package/types/src/models/dev-container.model.d.ts

@@ -0,0 +1,21 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+/**
+ * Model for `.devcontainer/devcontainer.json`.
+ *
+ * Features call builder methods (`addExtension`, `forwardPort`, etc.) during
+ * their configure phase. `MonoRepoScaffold` calls `files()` at render time.
+ */
+export declare class DevContainer implements KeyedModel {
+    readonly key: string;
+    private readonly _extensions;
+    private readonly _ports;
+    private readonly _mounts;
+    private _postStartCommand?;
+    private _useCompose;
+    constructor();
+    addExtension(...ids: string[]): this;
+    forwardPort(...ports: number[]): this;
+    setPostStartCommand(cmd: string): this;
+    useCompose(): this;
+    files(): SourceFile[];
+}

package/types/src/models/env-file.model.d.ts

@@ -0,0 +1,14 @@
+import type { KeyedModel, SourceFile } from "./source-file.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 declare class EnvFile implements KeyedModel {
+    readonly key: string;
+    private readonly _entries;
+    addEntry(key: string, value: string): this;
+    files(): SourceFile[];
+}

package/types/src/models/gitignore.model.d.ts

@@ -0,0 +1,6 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class Gitignore implements KeyedModel {
+    readonly key: string;
+    private ignoreList;
+    files(): SourceFile[];
+}

package/types/src/models/launch-json.model.d.ts

@@ -0,0 +1,5 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class LaunchJson implements KeyedModel {
+    readonly key: string;
+    files(): SourceFile[];
+}

package/types/src/models/package-json.model.d.ts

@@ -0,0 +1,18 @@
+import type { KeyedModel, SourceFile } from "./source-file.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 declare class PackageJson implements KeyedModel {
+    private readonly name;
+    readonly key: string;
+    private readonly _dependencies;
+    private readonly _devDependencies;
+    constructor(name: string);
+    addDependency(name: string, version: string): this;
+    addDevDependency(name: string, version: string): this;
+    files(): SourceFile[];
+}

package/types/src/models/project.model.d.ts

@@ -0,0 +1,55 @@
+import type { KeyedModel, SourceFile, SourceFileProvider } from "./source-file.js";
+/**
+ * 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 declare class ProjectScaffold {
+    readonly dir: string;
+    private readonly _models;
+    private readonly _files;
+    constructor(dir: string);
+    addModel<T extends KeyedModel>(model: T): T;
+    addFile(provider: SourceFileProvider): this;
+    getModel<T extends SourceFileProvider>(key: string): T | undefined;
+    getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[];
+    /** Returns all files with `dir/` prepended to each path. */
+    files(): SourceFile[];
+}
+export declare abstract class WorkspaceScaffold {
+    readonly files: SourceFile[];
+    targetDir: string;
+    /** Derived from the basename of targetDir. */
+    get name(): string;
+    /** Add an ad-hoc file provider whose output is included at render time. */
+    addFile(provider: SourceFileProvider): this;
+    abstract addModel<T extends KeyedModel>(model: T): T;
+    abstract getModel<T extends SourceFileProvider>(key: string): T | undefined;
+    abstract getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[];
+    abstract getProject(dir: string): ProjectScaffold | undefined;
+    abstract scaffold(): Promise<void> | void;
+}
+export declare class MonoRepoScaffold extends WorkspaceScaffold {
+    private readonly _models;
+    private readonly _projects;
+    /** Register a named project. */
+    addProject(project: ProjectScaffold): ProjectScaffold;
+    /** Retrieve a previously-registered project by its directory path. */
+    getProject(dir: string): ProjectScaffold | undefined;
+    /** Register a named model at workspace level. */
+    addModel<T extends KeyedModel>(model: T): T;
+    /**
+     * Retrieve a model by key. Searches workspace models first, then all
+     * registered projects in order.
+     */
+    getModel<T extends SourceFileProvider>(key: string): T | undefined;
+    /**
+     * Retrieve all models of a given type. Searches workspace models and all
+     * projects, so features can discover controllers across multiple projects.
+     */
+    getModels<T extends SourceFileProvider>(ctor: new (...args: never[]) => T): T[];
+    /** Render all models and projects into files, then write everything to disk. */
+    scaffold(): Promise<void>;
+}

package/types/src/models/source-file.d.ts

@@ -0,0 +1,11 @@
+export interface SourceFileProvider {
+    files(): SourceFile[];
+}
+/** A SourceFileProvider that knows its own registration key. */
+export interface KeyedModel extends SourceFileProvider {
+    readonly key: string;
+}
+export type SourceFile = {
+    filePath: string;
+    content: string;
+};

package/types/src/models/tsconfig.model.d.ts

@@ -0,0 +1,5 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class TsConfig implements KeyedModel {
+    readonly key: string;
+    files(): SourceFile[];
+}

package/types/src/models/vscode-settings.model.d.ts

@@ -0,0 +1,7 @@
+import type { KeyedModel, SourceFile } from "./source-file.js";
+export declare class VSCodeSettings implements KeyedModel {
+    private readonly title;
+    readonly key: string;
+    constructor(title: string);
+    files(): SourceFile[];
+}

package/types/src/services/scaffold.service.d.ts

@@ -0,0 +1,22 @@
+import type { WorkspaceScaffold } from "../models/project.model.js";
+/**
+ * A feature has three responsibilities:
+ *  1. `getOptions` — resolve provider selection and any follow-up questions.
+ *     Receives the options collected so far; returns only the keys it owns.
+ *     Short-circuits if the caller already supplied those keys via CLI flags.
+ *  2. `scaffold` — mutate the workspace models and/or write files using the
+ *     fully-resolved options. Called after ALL features have gathered options
+ *     but BEFORE files are written to disk.
+ *  3. `finalize` (optional) — run post-write actions (e.g. install dependencies).
+ *     Called after workspace.scaffold() has flushed all files to disk.
+ */
+export interface Feature<TOptions extends object = object> {
+    getOptions(workspace: WorkspaceScaffold, cliOptions: Partial<TOptions>): Promise<Partial<TOptions>>;
+    scaffold(workspace: WorkspaceScaffold, options: TOptions): Promise<void> | void;
+    finalize?(workspace: WorkspaceScaffold, options: TOptions): Promise<void> | void;
+}
+declare function scaffold(workspace: WorkspaceScaffold, cliOptions: object, features: Feature[]): Promise<void>;
+export declare const ScaffoldService: {
+    scaffold: typeof scaffold;
+};
+export {};

package/types/src/webapi/create-api.d.ts

@@ -0,0 +1,7 @@
+export declare const WEBAPI_PROJECT_DIR = "projects/api";
+export type ApiOptions = {
+    d?: string;
+    authProvider?: string;
+    databaseProvider?: "none" | "postgres/typeorm";
+};
+export declare function scaffoldApi(cliOptions: ApiOptions): Promise<void>;

package/types/src/webapi/features/auth.feature.d.ts

@@ -0,0 +1,7 @@
+import type { Feature } from "../../services/scaffold.service.js";
+export type AuthOptions = {
+    authProvider?: "auth0" | "none";
+    issuerBaseUrl?: string;
+    audience?: string;
+};
+export declare const AuthFeature: Feature<AuthOptions>;

package/types/src/webapi/features/auth0-cli.d.ts

@@ -0,0 +1,22 @@
+declare const REQUIRED_SCOPES = "create:clients";
+export declare class Auth0AuthError extends Error {
+    constructor(message: string);
+}
+export interface Auth0Tenant {
+    name: string;
+    active?: boolean;
+}
+export declare function isInstalled(): boolean;
+export declare function listTenants(): Auth0Tenant[];
+export declare function login(): boolean;
+export declare function listApis(): Array<{
+    identifier: string;
+    name: string;
+}>;
+export declare function createApi(name: string, identifier: string): {
+    identifier: string;
+};
+export declare function createSpaApp(name: string, callbackUrl: string): {
+    client_id: string;
+};
+export { REQUIRED_SCOPES };

package/types/src/webapi/features/database.feature.d.ts

@@ -0,0 +1,5 @@
+import type { Feature } from "../../services/scaffold.service.js";
+export type DatabaseOptions = {
+    databaseProvider?: "none" | "postgres/typeorm";
+};
+export declare const DatabaseFeature: Feature<DatabaseOptions>;

package/types/src/webapi/features/finalize.feature.d.ts

@@ -0,0 +1,2 @@
+import type { Feature } from "../../services/scaffold.service.js";
+export declare const FinalizeFeature: Feature;

package/types/src/webapi/features/postman.feature.d.ts

@@ -0,0 +1,7 @@
+import type { Feature } from "../../services/scaffold.service.js";
+export type PostmanOptions = {
+    postmanProvider?: "api" | "local" | "none";
+    apiKey?: string;
+    workspaceId?: string;
+};
+export declare const PostmanFeature: Feature<PostmanOptions>;

package/types/src/webapi/models/api-package-json.model.d.ts

@@ -0,0 +1,17 @@
+import type { KeyedModel, SourceFile } from "../../models/source-file.js";
+/**
+ * Builder for `projects/api/package.json`.
+ *
+ * Starts with the core cortex + crucible deps. Features can call
+ * `addDependency` / `addDevDependency` to extend.
+ */
+export declare class ApiPackageJson implements KeyedModel {
+    private readonly projectName;
+    readonly key: string;
+    private readonly _dependencies;
+    private readonly _devDependencies;
+    constructor(projectName: string);
+    addDependency(name: string, version: string): this;
+    addDevDependency(name: string, version: string): this;
+    files(): SourceFile[];
+}

package/types/src/webapi/models/auth-config.model.d.ts

@@ -0,0 +1,18 @@
+import type { KeyedModel, SourceFile } from "../../models/source-file.js";
+export type AuthConfig = {
+    issuerBaseUrl: string;
+    audience: string;
+};
+/**
+ * Data-carrier model for auth configuration.
+ *
+ * Registered by AuthFeature when auth0 is configured. Other features (e.g.
+ * PostmanFeature) retrieve it via workspace.getModel(WELL_KNOWN_FILES.AUTH_CONFIG).
+ * Produces no files — exists solely so features can communicate auth details.
+ */
+export declare class AuthConfigModel implements KeyedModel {
+    readonly config: AuthConfig;
+    readonly key: string;
+    constructor(config: AuthConfig);
+    files(): SourceFile[];
+}

package/types/src/webapi/models/controller-source-file.model.d.ts

@@ -0,0 +1,42 @@
+import type { KeyedModel, SourceFile } from "../../models/source-file.js";
+/**
+ * A controller method. Features call `addDecorator()` to prepend decorators
+ * before the HTTP verb decorator (e.g. `@AllowAnonymous` before `@Get()`).
+ */
+export declare class ControllerMethod {
+    readonly name: string;
+    private readonly _httpDecorator;
+    private readonly _params;
+    private readonly _isAsync;
+    private readonly _body;
+    private readonly _extraDecorators;
+    constructor(name: string, _httpDecorator: string, _params: string, _isAsync: boolean, _body: string[]);
+    addDecorator(decorator: string): this;
+    render(): string[];
+}
+/**
+ * Model for `projects/api/src/controllers/hello.controller.ts`.
+ *
+ * Pre-initialised with all routes and their HTTP decorators. Features mutate
+ * the model via `getMethod(name).addDecorator(...)`, `addDecorator(...)` (class
+ * level), `addCortexImport(...)`, `addImport(...)`, and `addConstructorParam(...)`.
+ */
+export declare class ControllerSourceFile implements KeyedModel {
+    readonly key: string;
+    private readonly _cortexImports;
+    private readonly _extraImportGroups;
+    private readonly _classDecorators;
+    private readonly _ctorParams;
+    private readonly _methods;
+    /** Retrieve a method by name to mutate its decorators. */
+    getMethod(name: string): ControllerMethod;
+    /** Add a class-level decorator (e.g. `@Authorize`). */
+    addDecorator(decorator: string): this;
+    /** Add a named import from `@decohere/cortex`. */
+    addCortexImport(name: string, typeOnly?: boolean): this;
+    /** Add a named import from any other module. */
+    addImport(name: string, from: string, typeOnly?: boolean): this;
+    /** Add a constructor parameter (e.g. an injected dependency). */
+    addConstructorParam(param: string): this;
+    files(): SourceFile[];
+}

package/types/src/webapi/models/main-source-file.model.d.ts

@@ -0,0 +1,36 @@
+import type { KeyedModel, SourceFile } from "../../models/source-file.js";
+export type TypeOrmImport = {
+    className: string;
+    importPath: string;
+};
+/**
+ * Model for `projects/api/src/main.ts`.
+ *
+ * Starts with the minimal HTTP + YAML config setup. Features mutate the model
+ * by calling addSideEffectImport / addImport / addBuilderCall / addEntity /
+ * addRepository. files() renders whatever has been accumulated.
+ */
+export declare class MainSourceFile implements KeyedModel {
+    private readonly appName;
+    readonly key: string;
+    private readonly _sideEffectImports;
+    private readonly _extraImports;
+    private readonly _builderCalls;
+    private readonly _entities;
+    private readonly _repositories;
+    constructor(appName: string);
+    /** Adds a bare side-effect import, e.g. `@decohere/cortex/auth`. */
+    addSideEffectImport(path: string): this;
+    /** Adds a named import, e.g. `import { Foo } from "bar"`. */
+    addImport(name: string, from: string, typeOnly?: boolean): this;
+    /**
+     * Adds a builder call inserted after `.withConfiguration()` and before
+     * `.withServices()`. Pass the call without leading dot, e.g. `.withAuth()`.
+     */
+    addBuilderCall(call: string): this;
+    /** Adds a TypeORM entity — import and entry in `withTypeOrm({ entities })`. */
+    addEntity(entity: TypeOrmImport): this;
+    /** Adds a TypeORM repository — import and entry in `withTypeOrm({ repositories })`. */
+    addRepository(repo: TypeOrmImport): this;
+    files(): SourceFile[];
+}

package/types/src/webapi/models/sample-files.model.d.ts

@@ -0,0 +1,7 @@
+import type { SourceFile, SourceFileProvider } from "../../models/source-file.js";
+export declare class SampleConfigModel implements SourceFileProvider {
+    files(): SourceFile[];
+}
+export declare class SampleServiceModel implements SourceFileProvider {
+    files(): SourceFile[];
+}

package/types/v1/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/types/v1/domain/class-model.d.ts

@@ -0,0 +1,70 @@
+import { ImportMap } from "./import-map.js";
+export interface ConstructorParam {
+    /** e.g. ["@inject(IPrincipalProviderToken)"] */
+    paramDecorators: string[];
+    name: string;
+    typeName: string;
+    isPrivate: boolean;
+    isReadonly: boolean;
+}
+export interface MethodParam {
+    /** e.g. `@Query("filter")` */
+    decorator?: string;
+    name: string;
+    typeName: string;
+}
+export interface MethodDef {
+    /** Base HTTP decorator(s), e.g. ["@Get()"]. Rendered bottom-most. */
+    decorators: string[];
+    name: string;
+    isAsync?: boolean;
+    params?: MethodParam[];
+    body: string;
+}
+export interface BodyClassField {
+    decorator: string;
+    name: string;
+    typeName: string;
+}
+export interface BodyClassDef {
+    name: string;
+    fields: BodyClassField[];
+}
+/**
+ * A live, mutable model of a generated TypeScript class.
+ *
+ * Features call the fluent API to contribute imports, decorators, constructor
+ * params, and method decorators.  When all configure phases are done, `render()`
+ * produces the final TypeScript source.
+ *
+ * Subclass to model controllers, services, repositories, etc.
+ */
+export declare class ClassModel {
+    readonly className: string;
+    readonly fileName: string;
+    protected readonly _imports: ImportMap;
+    private readonly _classDecorators;
+    private readonly _constructorParams;
+    private readonly _bodyClasses;
+    private readonly _methods;
+    constructor(className: string, fileName: string);
+    /**
+     * Add named value imports from `pkg`.
+     * Called with no names, registers a side-effect `import "pkg"`.
+     */
+    addImport(pkg: string, ...names: string[]): this;
+    /** Add named type-only imports from `pkg`. */
+    addTypeImport(pkg: string, ...names: string[]): this;
+    /** Prepend a class-level decorator (goes above any already-registered ones). */
+    decorateClass(decorator: string): this;
+    addBodyClass(def: BodyClassDef): this;
+    addConstructorParam(param: ConstructorParam): this;
+    defineMethod(def: MethodDef): this;
+    /**
+     * Prepend a decorator onto an existing method.
+     * Silently ignored if `methodName` is not found, so features are
+     * resilient to controllers that don't expose a particular method.
+     */
+    decorateMethod(methodName: string, ...decorators: string[]): this;
+    render(): string;
+}

package/types/v1/domain/compose.model.d.ts

@@ -0,0 +1,25 @@
+export declare const COMPOSE_KEY: import("./context.js").FeatureModelKey<ComposeModel>;
+export interface ComposeService {
+    build?: string;
+    image?: string;
+    env_file?: string[];
+    environment?: Record<string, string>;
+    ports?: string[];
+    volumes?: string[];
+    command?: string;
+    restart?: string;
+    depends_on?: string[];
+}
+/**
+ * Live builder for `docker-compose.yml`.
+ *
+ * Features call `addService` / `addVolume` in their `configure` phases.
+ * The devcontainer `render` phase calls `render()` and writes the file.
+ */
+export declare class ComposeModel {
+    private readonly _services;
+    private readonly _volumes;
+    addService(name: string, config: ComposeService): this;
+    addVolume(name: string): this;
+    render(): string;
+}

package/types/v1/domain/context.d.ts

@@ -0,0 +1,36 @@
+import type { ClassModel } from "./class-model.js";
+/** Type-safe key for a value in the FeatureModelStore. */
+export interface FeatureModelKey<T> {
+    readonly _sym: symbol;
+    readonly _type?: T;
+}
+export declare function modelKey<T>(name?: string): FeatureModelKey<T>;
+/**
+ * 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 declare class FeatureModelStore {
+    private readonly _store;
+    constructor(store?: ReadonlyMap<symbol, unknown>);
+    get<T>(key: FeatureModelKey<T>): T | undefined;
+    set<T>(key: FeatureModelKey<T>, value: T): FeatureModelStore;
+}
+export interface ScaffoldOptions {
+    yes?: boolean;
+    template?: "api" | "cli";
+    database?: "typeorm";
+    idp?: "auth0";
+    postman?: boolean;
+}
+export interface ScaffoldContext {
+    projectName: string;
+    targetDir: string;
+    opts: ScaffoldOptions;
+    template: "api" | "cli";
+    models: FeatureModelStore;
+    /** Live controller models that features contribute to during configure. */
+    controllers: ClassModel[];
+}
+export declare function createContext(targetDir: string, opts: ScaffoldOptions, template?: "api" | "cli"): ScaffoldContext;