@decohere/forge 0.0.1-dev.5

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@decohere/forge",
+  "version": "0.0.1-dev.5",
+  "description": "TypeScript monorepo build system — zero config, fast compilation, streamlined developer workflow",
+  "keywords": [
+    "typescript",
+    "build",
+    "monorepo",
+    "bundler",
+    "swc",
+    "decohere"
+  ],
+  "license": "ISC",
+  "author": "Typesmiths",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/src/index.d.ts",
+      "import": "./es6/src/index.js",
+      "require": "./commonjs/src/index.js"
+    },
+    "./vitest": {
+      "types": "./types/src/vitest/index.d.ts",
+      "import": "./es6/src/vitest/index.js",
+      "require": "./commonjs/src/vitest/index.js"
+    }
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "@decohere/crucible": "0.0.1-dev.5",
+    "@decohere/mesh": "0.0.1-dev.5",
+    "@decohere/nexus": "0.0.1-dev.5",
+    "@decohere/scribe": "0.0.1-dev.5",
+    "@swc/core": "^1.11.11",
+    "async": "^3.2.6",
+    "parse-imports": "^2.2.1",
+    "rxjs": "^7.8.2",
+    "typescript": "^6.0.3"
+  },
+  "devDependencies": {}
+}

package/types/src/actions/build.action.d.ts

@@ -0,0 +1,22 @@
+import type { Project } from "@decohere/mesh";
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { FileWriterService } from "../services/file-writer.service.js";
+import type { TransformResponse } from "../types/transform-response.model.js";
+import { type Transformer } from "../types/transformer.type.js";
+export type BuildOptions = {
+    configuration: string;
+    file: string;
+};
+export declare class Build implements Action<BuildOptions> {
+    #private;
+    private readonly workspace;
+    private readonly transformers;
+    private readonly fileWriter;
+    constructor(workspace: Workspace, transformers: Transformer[], fileWriter: FileWriterService);
+    run: (options: BuildOptions) => Promise<ActionResponse<TransformResponse>>;
+    build(projectArrayLike: readonly Project[] | Project): Promise<TransformResponse[]>;
+    private runTransformers;
+    private writeOutput;
+}

package/types/src/actions/clean.action.d.ts

@@ -0,0 +1,13 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type CleanOptions = {
+    clean: boolean;
+    configuration: string;
+};
+export declare class Clean implements Action<CleanOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run: (options: CleanOptions) => Promise<ActionResponse>;
+}

package/types/src/actions/commit.action.d.ts

@@ -0,0 +1,17 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type CommitFilesOptions = {
+    configuration?: string;
+    commit?: boolean;
+    message?: string;
+    files?: string[];
+    dryRun?: boolean;
+};
+export declare class CommitFiles implements Action<CommitFilesOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run(options: CommitFilesOptions): Promise<ActionResponse>;
+    private getDefaultFiles;
+}

package/types/src/actions/copy.action.d.ts

@@ -0,0 +1,14 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type CopyOptions = {
+    copy: boolean;
+    configuration: string;
+};
+export declare class Copy implements Action<CopyOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run: (options: CopyOptions) => Promise<ActionResponse>;
+    private copyFileToOut;
+}

package/types/src/actions/dependency-report.action.d.ts

@@ -0,0 +1,36 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { DependencyResolver } from "../services/dependency-resolver.service.js";
+import type { DependencyWarning, DriftEntry } from "../types/dependency.types.js";
+type ReportOptions = {
+    configuration: string;
+    file?: string;
+    failOnDrift?: boolean;
+};
+type ReportEntry = {
+    projectName: string;
+    dependencies: string[];
+    devDependencies: string[];
+};
+type ProjectReport = {
+    projectName: string;
+    entry: ReportEntry;
+    drift: DriftEntry | null;
+    warnings: DependencyWarning[];
+};
+export declare class ReportDependencies implements Action<ReportOptions> {
+    #private;
+    private readonly workspace;
+    private readonly resolver;
+    constructor(workspace: Workspace, resolver: DependencyResolver);
+    run(options: ReportOptions): Promise<ActionResponse<ProjectReport>>;
+    private analyzeWorkspace;
+    private analyzeProject;
+    private getDependencies;
+    private buildDriftReport;
+    private throwOnDrift;
+    private logReport;
+    private writeReportFile;
+}
+export {};

package/types/src/actions/dependency-sync.action.d.ts

@@ -0,0 +1,17 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { DependencyResolver } from "../services/dependency-resolver.service.js";
+import type { SyncprojectResult } from "../types/dependency.types.js";
+export type DependenciesOptions = {
+    configuration: string;
+    logDiff?: boolean;
+};
+export declare class SyncDependencies implements Action<DependenciesOptions> {
+    #private;
+    private readonly workspace;
+    private readonly resolver;
+    constructor(workspace: Workspace, resolver: DependencyResolver);
+    run(options: DependenciesOptions): Promise<ActionResponse<SyncprojectResult>>;
+    private computeDependenciesFor;
+}

package/types/src/actions/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./build.action.js";
+export * from "./clean.action.js";
+export * from "./commit.action.js";
+export * from "./copy.action.js";
+export * from "./dependency-report.action.js";
+export * from "./dependency-sync.action.js";
+export * from "./publish.action.js";
+export * from "./sync-lock-file.action.js";
+export * from "./tag.action.js";
+export * from "./version.action.js";
+export * from "./watch.action.js";

package/types/src/actions/publish.action.d.ts

@@ -0,0 +1,34 @@
+import type { Project } from "@decohere/mesh";
+import { Workspace } from "@decohere/mesh";
+import type { Action, ResultStatus } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type PublishOptions = {
+    configuration: string;
+    channel?: string;
+    dryRun?: boolean;
+    token?: string;
+    otp?: string;
+    promptAuth?: boolean;
+    promptOtp?: boolean;
+};
+export type PublishResponse = ResultStatus & {
+    projectName: string;
+    message: string;
+    packageName?: string;
+};
+export declare class Publish implements Action<PublishOptions> {
+    #private;
+    private readonly workspace;
+    private readonly npm;
+    constructor(workspace: Workspace);
+    run(options: PublishOptions): Promise<ActionResponse<PublishResponse>>;
+    publishProjects(projects: readonly Project[], options: PublishOptions): Promise<(ResultStatus & {
+        projectName: string;
+        message: string;
+        packageName?: string;
+    })[]>;
+    private publishProject;
+    private resolveToken;
+    private resolveOtp;
+    private promptSecret;
+}

package/types/src/actions/sync-lock-file.action.d.ts

@@ -0,0 +1,10 @@
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type SyncLockFileOptions = {
+    sync?: boolean;
+    dryRun?: boolean;
+};
+export declare class SyncLockFile implements Action<SyncLockFileOptions> {
+    #private;
+    run(options: SyncLockFileOptions): Promise<ActionResponse>;
+}

package/types/src/actions/tag.action.d.ts

@@ -0,0 +1,19 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type TagOptions = {
+    prefix?: string;
+    dryRun?: boolean;
+    push?: boolean;
+};
+export type TagResponse = {
+    tag: string;
+    succeeded: boolean;
+    error?: string;
+};
+export declare class Tag implements Action<TagOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run(options: TagOptions): Promise<ActionResponse<TagResponse>>;
+}

package/types/src/actions/version.action.d.ts

@@ -0,0 +1,35 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action, ResultStatus } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+import { type VersionType } from "@decohere/nexus/semver";
+export type VersionResponse = ResultStatus & {
+    name: string;
+};
+export declare const DefaultChannel = "beta";
+export declare const DefaultReleaseType: "prerelease";
+export type VersionOptions = {
+    releaseType?: VersionType;
+    channel?: string;
+    version?: string;
+    dryRun?: boolean;
+    commit?: boolean;
+    message?: string;
+    /** Read pending .changeset entries to determine the highest bump type */
+    fromChangesets?: boolean;
+};
+export declare class Version implements Action<VersionOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run(options: VersionOptions): Promise<ActionResponse>;
+    version(workspace: Workspace, options?: VersionOptions): Promise<ActionResponse<VersionResponse>>;
+    private resolveBaseVersion;
+    private resolveVersionFromGitTag;
+    /**
+     * Reads all pending .changeset/*.md entries and returns the highest bump type
+     * found across all of them. Precedence: major > minor > patch.
+     */
+    private resolveReleaseTypeFromChangesets;
+    private getNextVersion;
+    private updatePackageJson;
+}

package/types/src/actions/watch.action.d.ts

@@ -0,0 +1,14 @@
+import { Workspace } from "@decohere/mesh";
+import type { Action } from "@decohere/nexus/cli";
+import { ActionResponse } from "@decohere/nexus/cli";
+export type WatchOptions = {
+    watch: boolean;
+    configuration: string;
+};
+export declare class Watch implements Action<WatchOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run: (options: WatchOptions) => Promise<ActionResponse>;
+    [Symbol.dispose](): void;
+}

package/types/src/commands/build.command.d.ts

@@ -0,0 +1,16 @@
+import type { MergeOptions } from "@decohere/nexus/cli";
+import { CommandResponse, DecohereCommand } from "@decohere/nexus/cli";
+import type { Build } from "../actions/build.action.js";
+import type { Clean } from "../actions/clean.action.js";
+import type { Copy } from "../actions/copy.action.js";
+import type { Watch } from "../actions/watch.action.js";
+export type BuildActions = {
+    clean: Clean;
+    build: Build;
+    watch: Watch;
+    copy: Copy;
+};
+export declare class BuildCommand extends DecohereCommand<BuildActions> {
+    constructor(name?: string);
+    run: (actions: BuildActions, options: MergeOptions<BuildActions>) => Promise<CommandResponse<BuildActions>>;
+}

package/types/src/commands/dependency.command.d.ts

@@ -0,0 +1,5 @@
+import type { CommandHandler } from "@decohere/nexus/cli";
+import { DecohereCommand } from "@decohere/nexus/cli";
+export declare class DependencyCommand extends DecohereCommand {
+    constructor(name?: string, handler?: CommandHandler);
+}

package/types/src/commands/forge.command.d.ts

@@ -0,0 +1,6 @@
+import type { Actions } from "@decohere/nexus/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
+export declare class ForgeCommand extends DecohereCommand {
+    constructor(commands: Record<string, CommandType>, handler: CommandHandler);
+    run(_actions: Actions, _options: never): Promise<CommandResponse>;
+}

package/types/src/commands/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./build.command.js";
+export * from "./dependency.command.js";
+export * from "./forge.command.js";
+export * from "./publish.command.js";
+export * from "./tag.command.js";
+export * from "./version.command.js";

package/types/src/commands/publish.command.d.ts

@@ -0,0 +1,6 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { Publish } from "../actions/publish.action.js";
+export declare class PublishCommand extends DecohereCommand {
+    get actions(): (typeof Publish)[];
+    constructor(name: string);
+}

package/types/src/commands/tag.command.d.ts

@@ -0,0 +1,6 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { Tag } from "../actions/tag.action.js";
+export declare class TagCommand extends DecohereCommand {
+    get actions(): (typeof Tag)[];
+    constructor(name: string);
+}

package/types/src/commands/version.command.d.ts

@@ -0,0 +1,12 @@
+import { DecohereCommand } from "@decohere/nexus/cli";
+import { SyncLockFile } from "../actions/sync-lock-file.action.js";
+import { Version } from "../actions/version.action.js";
+type VersionActions = {
+    version: Version;
+    syncLockFile: SyncLockFile;
+};
+export declare class VersionCommand extends DecohereCommand<VersionActions> {
+    get actions(): (typeof SyncLockFile | typeof Version)[];
+    constructor(name: string);
+}
+export {};

package/types/src/const.d.ts

@@ -0,0 +1,3 @@
+export declare const SWC_CONFIG = ".swcrc";
+export declare const NODE_MODULES = "node_modules";
+export declare const BUILT_IN_MODULES: string[];

package/types/src/errors.d.ts

@@ -0,0 +1,4 @@
+export { WorkspaceConfigurationError } from "@decohere/mesh";
+export declare class ForgeError extends Error {
+}
+export declare function formatUnknownError(reason: unknown): string;

package/types/src/extensions/project.extensions.d.ts

@@ -0,0 +1,13 @@
+import { Project } from "@decohere/mesh";
+import type { ForgeConfiguration } from "../types/configuration.type.js";
+import { SwcConfig } from "../types/swc-config.type.js";
+declare module "@decohere/mesh" {
+    interface Project {
+        getForgeConfiguration(): ForgeConfiguration;
+        getSwcConfig(): Promise<SwcConfig>;
+    }
+}
+export declare class ProjectExtensions {
+    static getForgeConfiguration(project: Project): ForgeConfiguration;
+    static getSwcConfig(project: Project): Promise<SwcConfig>;
+}

package/types/src/factories/swc-config.factory.d.ts

@@ -0,0 +1,24 @@
+import type { FileEx } from "@decohere/nexus/io";
+import type { Options } from "@swc/core";
+import type { TranspileTarget } from "../types/build-target.type.js";
+import type { SwcConfigOptions } from "../types/swc-config.type.js";
+export declare class SwcConfigFactory {
+    /**
+     * Creates a base config for a project+target combination, without a filename.
+     * Call once per (project, target) and then use createFileConfig() per file.
+     */
+    createBaseConfig(buildTarget: TranspileTarget, configOptions: SwcConfigOptions): Options;
+    /** Stamps a per-file filename onto a pre-built base config. */
+    createFileConfig(file: FileEx, baseConfig: Options): Options;
+    /**
+     * Validates SWC options against known causes of Rust/NAPI process crashes.
+     * Throws a ForgeError with a descriptive message instead of letting the
+     * NAPI layer abort the process.
+     *
+     * Known crash causes:
+     * - `jsc.baseUrl` set to a relative path (SWC requires an absolute path)
+     */
+    validate(options: Options): void;
+    /** Resolves tsconfig baseUrl to an absolute path. Returns undefined if not set. */
+    private static getBaseUrl;
+}

package/types/src/forge.module.d.ts

@@ -0,0 +1,31 @@
+import type { WorkspaceFactoryOptions } from "@decohere/nexus/cli";
+import { ModuleManifest } from "@decohere/nexus/cli";
+import type { ContainerBuilder } from "@decohere/nexus/composition";
+import * as Actions from "./actions/index.js";
+import * as Commands from "./commands/index.js";
+export declare class ForgeModule extends ModuleManifest {
+    readonly id = "forge";
+    readonly command: typeof Commands.ForgeCommand;
+    readonly actions: {
+        clean: typeof Actions.Clean;
+        copy: typeof Actions.Copy;
+        build: typeof Actions.Build;
+        watch: typeof Actions.Watch;
+        publish: typeof Actions.Publish;
+        syncDependencies: typeof Actions.SyncDependencies;
+        syncLockFile: typeof Actions.SyncLockFile;
+        reportDependencies: typeof Actions.ReportDependencies;
+        version: typeof Actions.Version;
+        tag: typeof Actions.Tag;
+        commitFiles: typeof Actions.CommitFiles;
+    };
+    readonly commands: {
+        build: typeof Commands.BuildCommand;
+        publish: typeof Commands.PublishCommand;
+        dependencies: typeof Commands.DependencyCommand;
+        version: typeof Commands.VersionCommand;
+        tag: typeof Commands.TagCommand;
+    };
+    registerServices(builder: ContainerBuilder): void;
+    createWorkspace(options: WorkspaceFactoryOptions): Promise<import("@decohere/mesh").Workspace>;
+}

package/types/src/index.d.ts

@@ -0,0 +1,4 @@
+export { ForgeError } from "./errors.js";
+export { ForgeModule } from "./forge.module.js";
+export type { ForgeConfiguration } from "./types/configuration.type.js";
+export type { WorkspaceOptions } from "./types/workspace-config.type.js";

package/types/src/mixins/caches-outputs.mixin.d.ts

@@ -0,0 +1,7 @@
+import type { TransformResponse } from "../types/transform-response.model.js";
+export declare abstract class CachesOutputs {
+    /** Maps source file fullPath -> output TransformResponses for cleanup in watch mode. */
+    protected get outputCache(): Map<string, TransformResponse[]>;
+    protected cacheOutputs(responses: TransformResponse[]): void;
+    protected deleteCachedOutputs(filePath: string): void;
+}

package/types/src/mixins/incremental-transform.mixin.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectFileEvent, Workspace } from "@decohere/mesh";
+import type { Observable } from "rxjs";
+import type { TransformResponse } from "../types/transform-response.model.js";
+export declare abstract class IncrementalTransform {
+    get incrementalTransform$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace): void;
+    /**
+     * Called for every workspace file change. Implementations should invalidate
+     * any internal caches, perform the incremental transform, and return the results.
+     * Return an empty array for deletions or when no output is produced.
+     */
+    protected abstract onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+}

package/types/src/services/dependency-resolver.service.d.ts

@@ -0,0 +1,15 @@
+import type { PackageJson, Project, Workspace } from "@decohere/mesh";
+import type { DependencyWarning, DriftEntry, Package } from "../types/dependency.types.js";
+export type ProjectDependencies = {
+    project: Project;
+    updatedPackage: PackageJson;
+    warnings: DependencyWarning[];
+};
+export declare class DependencyResolver {
+    computeDrift(current: PackageJson, computed: PackageJson): DriftEntry | null;
+    getWorkspacePackages(workspace: Workspace, projects: readonly Project[]): Promise<Map<string, Package>>;
+    computeProjectDependencies(project: Project, workspacePackages: Map<string, Package>): Promise<ProjectDependencies>;
+    private getDependencies;
+    private getDependencyFrom;
+    private getFileImports;
+}

package/types/src/services/file-writer.service.d.ts

@@ -0,0 +1,20 @@
+import type { Project } from "@decohere/mesh";
+import "../extensions/project.extensions.js";
+import type { TransformResponse } from "../types/transform-response.model.js";
+export declare class FileWriterService {
+    #private;
+    initialize(): Promise<void>;
+    warmup(projects: Project[]): Promise<void>;
+    enqueueOutput(response: TransformResponse): void;
+    enqueueOutputs(responses: TransformResponse[]): void;
+    flush(): Promise<void>;
+    private getOutputDirs;
+    private loadExistingArtifacts;
+    private collectFiles;
+    private getWriteConcurrency;
+    private startWorkers;
+    private runWorker;
+    private ensureDirectory;
+    private resolveDrain;
+    private withConcurrency;
+}

package/types/src/services/swc-transpiler.d.ts

@@ -0,0 +1,28 @@
+import type { Project } from "@decohere/mesh";
+import type { FileEx } from "@decohere/nexus/io";
+import { type BuildTarget, type TranspileTarget } from "../types/build-target.type.js";
+import "../extensions/project.extensions.js";
+import type { ProjectFileEvent, Tsconfig } from "@decohere/mesh";
+import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
+import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
+import type { SwcConfig } from "../types/swc-config.type.js";
+import { TransformResponse } from "../types/transform-response.model.js";
+import type { Transformer } from "../types/transformer.type.js";
+export type TranspileOptions = {
+    aliasPaths?: boolean;
+    tsConfig?: Tsconfig;
+    userConfig?: SwcConfig;
+};
+declare const SwcTranspiler_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
+export declare class SwcTranspiler extends SwcTranspiler_base implements Transformer {
+    #private;
+    buildTargets: BuildTarget[];
+    transformProject(projectArrayLike: Project | Project[], fileFilter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
+    transformFile(fileArrayLike: FileEx[] | FileEx, buildTarget: TranspileTarget, options?: TranspileOptions): Promise<TransformResponse[]>;
+    private transformTarget;
+    private runTransform;
+    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    invalidateContentCache(_file: FileEx): void;
+    private getFileContent;
+}
+export {};

package/types/src/services/ts-program-host.d.ts

@@ -0,0 +1,22 @@
+import type { FileEx } from "@decohere/nexus/io";
+import type ts from "typescript";
+/**
+ * Wraps a TypeScript CompilerHost with cached file-system calls so that
+ * repeated reads during a single build do not hit the disk multiple times.
+ *
+ * Separating this from TypeEmitter keeps the transformer logic readable and
+ * lets the caching/program-creation concerns live in one focused place.
+ */
+export declare class TsProgramHost {
+    #private;
+    invalidateSourceFile(fileName: string): void;
+    hasInvalidated(): boolean;
+    /** Returns a stable string key for a set of compiler options that affect host behaviour. */
+    hostKey(opts: ts.CompilerOptions): string;
+    createHost(compilerOptions: ts.CompilerOptions): ts.CompilerHost;
+    createProgram(files: FileEx[], compilerOptions: ts.CompilerOptions, host: ts.CompilerHost, oldProgram?: ts.Program): ts.Program;
+    readFileFromDisk(fileName: string): string | undefined;
+    fileExistsOnDisk(fileName: string): boolean;
+    directoryExists(directoryName: string): boolean;
+    getDirectories(directoryName: string): string[];
+}

package/types/src/services/type-emission-program.d.ts

@@ -0,0 +1,22 @@
+import type { Project, Tsconfig } from "@decohere/mesh";
+import type { FileEx } from "@decohere/nexus/io";
+import type { TsProgramHost } from "../services/ts-program-host.js";
+import { TransformResponse } from "../types/transform-response.model.js";
+export type TypeProgramProject = {
+    project: Project;
+    files: FileEx[];
+    tsconfig: Tsconfig;
+};
+export declare class TypeEmissionProgram {
+    #private;
+    constructor(group: TypeProgramProject[], hostFactory: TsProgramHost);
+    private toEmissionTarget;
+    private emittedKey;
+    private buildTargetMaps;
+    addFile(file: FileEx, project: Project): void;
+    emit(fileFilter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
+    private emitAll;
+    private emitFiltered;
+    private toTransformResponse;
+    private toTransformResponseFromTarget;
+}

package/types/src/services/type-emitter.d.ts

@@ -0,0 +1,43 @@
+import type { Project, ProjectFileEvent } from "@decohere/mesh";
+import type { FileEx } from "@decohere/nexus/io";
+import type ts from "typescript";
+import "../extensions/project.extensions.js";
+import { CachesOutputs } from "../mixins/caches-outputs.mixin.js";
+import { IncrementalTransform } from "../mixins/incremental-transform.mixin.js";
+import { type BuildTarget } from "../types/build-target.type.js";
+import type { TransformResponse } from "../types/transform-response.model.js";
+import type { Transformer } from "../types/transformer.type.js";
+/**
+ * Compiler option defaults applied before the user's tsconfig — the user's values override these.
+ *
+ * lib: ES2022 — avoids loading lib.dom.d.ts (1.8 MB) which TS includes by default
+ * when no `lib` is set. Backend packages have no use for browser APIs.
+ *
+ * types: [] — disables ambient @types auto-discovery. Without this, TS scans
+ * every @types/* package in the node_modules hierarchy; in a monorepo that can
+ * pull in dozens of unrelated packages. Explicitly imported types still resolve
+ * normally; only ambient globals (e.g. Buffer, process) are suppressed — add
+ * `types: ["node"]` to a project's tsconfig to restore them.
+ */
+export declare const DEFAULT_TYPE_EMITTER_OPTIONS: Readonly<ts.CompilerOptions>;
+/**
+ * Compiler options that TypeEmitter always enforces regardless of what the user's
+ * tsconfig specifies. Applied after the user spread so they cannot be overridden.
+ */
+export declare const REQUIRED_TYPE_EMITTER_OPTIONS: Readonly<ts.CompilerOptions>;
+declare const TypeEmitter_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
+export declare class TypeEmitter extends TypeEmitter_base implements Transformer {
+    #private;
+    buildTargets: BuildTarget[];
+    /**
+     * Phase 1: fetch files, create TypeScript programs sequentially.
+     * Called before transformProject() so that the heavy createProgram work
+     * completes before other transformers (SWC/Rayon) start running in parallel.
+     */
+    init(projectArrayLike: Project[] | Project, _filter?: (project: Project) => Promise<FileEx[]>): Promise<void>;
+    transformProject(projectArrayLike: Project[] | Project, filter?: (project: Project) => Promise<FileEx[]>, onOutput?: (response: TransformResponse) => void): Promise<TransformResponse[]>;
+    private preparePrograms;
+    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private invalidateReadFileCache;
+}
+export {};