@decohere/forge 0.0.1-dev.12 → 0.0.1-dev.121

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

@@ -1,6 +1,6 @@
-import { Workspace } from "@decohere/mesh";
-import type { Action } from "@decohere/nexus/cli";
-import { ActionResponse } from "@decohere/nexus/cli";
+import { Workspace } from "@decohere/workspace";
+import type { Action } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
 export type WatchOptions = {
     watch: boolean;
     configuration: string;

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

@@ -1,5 +1,5 @@
-import type { MergeOptions } from "@decohere/nexus/cli";
-import { CommandResponse, DecohereCommand } from "@decohere/nexus/cli";
+import type { MergeOptions } from "@decohere/devkit/cli";
+import { CommandResponse, DecohereCommand } from "@decohere/devkit/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";
@@ -12,5 +12,6 @@ export type BuildActions = {
 };
 export declare class BuildCommand extends DecohereCommand<BuildActions> {
     constructor(name?: string);
+    runsUntilStopped(options: Record<string, unknown>): boolean;
     run: (actions: BuildActions, options: MergeOptions<BuildActions>) => Promise<CommandResponse<BuildActions>>;
 }

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

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

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

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

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

@@ -1,5 +1,5 @@
-import type { Actions } from "@decohere/nexus/cli";
-import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/nexus/cli";
+import type { Actions } from "@decohere/devkit/cli";
+import { type CommandHandler, type CommandResponse, type CommandType, DecohereCommand } from "@decohere/devkit/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

@@ -1,6 +1,11 @@
 export * from "./build.command.js";
 export * from "./dependency.command.js";
+export * from "./docker.command.js";
 export * from "./forge.command.js";
+export * from "./link.command.js";
+export * from "./package.command.js";
+export * from "./paths.command.js";
 export * from "./publish.command.js";
 export * from "./tag.command.js";
+export * from "./typecheck.command.js";
 export * from "./version.command.js";

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

@@ -0,0 +1,29 @@
+import type { CommandHandler, MergeOptions } from "@decohere/devkit/cli";
+import { CommandResponse, DecohereCommand } from "@decohere/devkit/cli";
+import { Build } from "../actions/build.action.js";
+import { Clean } from "../actions/clean.action.js";
+import { Copy } from "../actions/copy.action.js";
+import { Link } from "../actions/link.action.js";
+import { Unlink } from "../actions/unlink.action.js";
+import { Watch } from "../actions/watch.action.js";
+export type LinkActions = {
+    clean: Clean;
+    build: Build;
+    copy: Copy;
+    link: Link;
+    watch: Watch;
+};
+type UnlinkActions = {
+    unlink: Unlink;
+};
+export declare class LinkCommand extends DecohereCommand<LinkActions> {
+    get actions(): (typeof Build | typeof Clean | typeof Copy | typeof Link | typeof Watch)[];
+    constructor(name?: string);
+    runsUntilStopped(options: Record<string, unknown>): boolean;
+    run: (actions: LinkActions, options: MergeOptions<LinkActions>) => Promise<CommandResponse<LinkActions>>;
+}
+export declare class UnlinkCommand extends DecohereCommand<UnlinkActions> {
+    get actions(): (typeof Unlink)[];
+    constructor(name?: string, handler?: CommandHandler);
+}
+export {};

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

@@ -0,0 +1,11 @@
+import { DecohereCommand } from "@decohere/devkit/cli";
+import { PackageDeployable } from "../actions/package.action.js";
+export declare class PackageCommand extends DecohereCommand {
+    get actions(): (typeof PackageDeployable)[];
+    constructor(name: string);
+    /**
+     * Commander passes the positional before the options; the CLI host reads only options,
+     * so the project name is stashed on them.
+     */
+    action(fn: (...args: any[]) => void | Promise<void>): this;
+}

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { DecohereCommand } from "@decohere/nexus/cli";
+import { DecohereCommand } from "@decohere/devkit/cli";
 import { SyncLockFile } from "../actions/sync-lock-file.action.js";
 import { Version } from "../actions/version.action.js";
 type VersionActions = {

package/types/src/create-workspace.d.ts

@@ -0,0 +1,7 @@
+import { type Workspace } from "@decohere/workspace";
+import type { WorkspaceFactoryOptions } from "@decohere/devkit/cli";
+/**
+ * The workspace every Decohere tool sees (forge, the flux CLI and `flux.run`): forge's
+ * defaults, the user's `.decohere.js`, and a root found by searching upward from cwd.
+ */
+export declare function createWorkspace(options?: WorkspaceFactoryOptions): Promise<Workspace>;

package/types/src/errors.d.ts

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

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

@@ -1,7 +1,7 @@
-import { Project } from "@decohere/mesh";
+import { Project } from "@decohere/workspace";
 import type { ForgeConfiguration } from "../types/configuration.type.js";
 import { SwcConfig } from "../types/swc-config.type.js";
-declare module "@decohere/mesh" {
+declare module "@decohere/workspace" {
     interface Project {
         getForgeConfiguration(): ForgeConfiguration;
         getSwcConfig(): Promise<SwcConfig>;

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

@@ -1,4 +1,4 @@
-import type { FileEx } from "@decohere/nexus/io";
+import type { FileEx } from "@decohere/core/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";
@@ -8,8 +8,9 @@ export declare class SwcConfigFactory {
      * 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. */
+    /** Stamps a per-file filename onto a pre-built base config; `.tsx` also turns on JSX (#518). */
     createFileConfig(file: FileEx, baseConfig: Options): Options;
+    private static nonemptyPaths;
     /**
      * Validates SWC options against known causes of Rust/NAPI process crashes.
      * Throws a ForgeError with a descriptive message instead of letting the

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

@@ -1,6 +1,6 @@
-import type { WorkspaceFactoryOptions } from "@decohere/nexus/cli";
-import { ModuleManifest } from "@decohere/nexus/cli";
-import type { ContainerBuilder } from "@decohere/nexus/composition";
+import type { WorkspaceFactoryOptions } from "@decohere/devkit/cli";
+import { ModuleManifest } from "@decohere/devkit/cli";
+import type { ContainerBuilder } from "@decohere/core/composition";
 import * as Actions from "./actions/index.js";
 import * as Commands from "./commands/index.js";
 export declare class ForgeModule extends ModuleManifest {
@@ -9,6 +9,8 @@ export declare class ForgeModule extends ModuleManifest {
     readonly actions: {
         clean: typeof Actions.Clean;
         copy: typeof Actions.Copy;
+        docker: typeof Actions.Docker;
+        package: typeof Actions.PackageDeployable;
         build: typeof Actions.Build;
         watch: typeof Actions.Watch;
         publish: typeof Actions.Publish;
@@ -17,15 +19,25 @@ export declare class ForgeModule extends ModuleManifest {
         reportDependencies: typeof Actions.ReportDependencies;
         version: typeof Actions.Version;
         tag: typeof Actions.Tag;
+        paths: typeof Actions.Paths;
+        typecheck: typeof Actions.TypeCheck;
         commitFiles: typeof Actions.CommitFiles;
+        link: typeof Actions.Link;
+        unlink: typeof Actions.Unlink;
     };
     readonly commands: {
         build: typeof Commands.BuildCommand;
         publish: typeof Commands.PublishCommand;
         dependencies: typeof Commands.DependencyCommand;
+        docker: typeof Commands.DockerCommand;
+        package: typeof Commands.PackageCommand;
         version: typeof Commands.VersionCommand;
         tag: typeof Commands.TagCommand;
+        paths: typeof Commands.PathsCommand;
+        typecheck: typeof Commands.TypeCheckCommand;
+        link: typeof Commands.LinkCommand;
+        unlink: typeof Commands.UnlinkCommand;
     };
     registerServices(builder: ContainerBuilder): void;
-    createWorkspace(options: WorkspaceFactoryOptions): Promise<import("@decohere/mesh").Workspace>;
+    createWorkspace(options: WorkspaceFactoryOptions): Promise<import("@decohere/workspace").Workspace>;
 }

package/types/src/index.d.ts

@@ -1,9 +1,11 @@
+export { createWorkspace } from "./create-workspace.js";
 export { ForgeError } from "./errors.js";
 export { ForgeModule } from "./forge.module.js";
 export type { TranspileOptions } from "./services/swc-transpiler.js";
 export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { transpileCache } from "./services/transpile-cache.js";
 export type { BuildTarget, TranspileTarget } from "./types/build-target.type.js";
 export { BuildTargets } from "./types/build-target.type.js";
 export type { ForgeConfiguration } from "./types/configuration.type.js";
 export type { WorkspaceOptions } from "./types/workspace-config.type.js";
-export { Debug as DebugConfiguration, DefaultConfigurations, Release as ReleaseConfiguration, WorkspaceDefaults, } from "./workspace.config.js";
+export { Debug as DebugConfiguration, DefaultConfigurations, Link as LinkConfiguration, Release as ReleaseConfiguration, WorkspaceDefaults, } from "./workspace.config.js";

package/types/src/packaging/dependency-pinner.service.d.ts

@@ -0,0 +1,20 @@
+import type { PackageJson } from "@decohere/workspace";
+import type { ReachedPackages, ReleaseProject } from "./import-graph.service.js";
+/**
+ * Chooses the third-party `dependencies` for the packaged `package.json`: the union of
+ * `dependencies` (never devDependencies) of the deployable, every library copied in, and the
+ * workspace root. Declared is shipped, whether or not code imports it (a runtime-loaded pino
+ * transport, say), so removing an unused dependency is the author's job. Each is pinned to the
+ * exact version installed in the workspace, so the image runs what the tests ran.
+ *
+ * Code that imports a third-party package nothing ships is a crash waiting to happen, so that
+ * is an error: the package is only a devDependency, or declared nowhere.
+ */
+export declare class DependencyPinner {
+    pin(imported: ReachedPackages["thirdParty"], shipped: readonly ReleaseProject[], projects: ReadonlyMap<string, ReleaseProject>, workspaceRoot: {
+        dir: string;
+        pkg: PackageJson;
+    }): Promise<Record<string, string>>;
+    private assertImportsAreShipped;
+    private installedVersion;
+}

package/types/src/packaging/deployable.d.ts

@@ -0,0 +1,17 @@
+import type { Project } from "@decohere/workspace";
+/** Where `forge package` writes a deployable's output: inside the project, the Docker build context. */
+export declare const PACKAGE_DIR = ".package";
+/**
+ * A deployable is a project with a Dockerfile: `docker.dockerfile` from `.decohere.js`,
+ * or `Dockerfile` in the project folder. `forge docker` and `forge package` share this
+ * rule so they always agree on which projects are deployables.
+ */
+declare function dockerfileName(project: Project): string;
+declare function dockerfilePath(project: Project): string;
+declare function isDeployable(project: Project): Promise<boolean>;
+export declare const deployable: {
+    dockerfileName: typeof dockerfileName;
+    dockerfilePath: typeof dockerfilePath;
+    isDeployable: typeof isDeployable;
+};
+export {};

package/types/src/packaging/import-graph.service.d.ts

@@ -0,0 +1,33 @@
+import type { PackageJson } from "@decohere/workspace";
+/** A workspace project as the packager sees it: its manifest and its release build. */
+export type ReleaseProject = {
+    /** The package name, e.g. `@app/kernel`. */
+    name: string;
+    pkg: PackageJson;
+    /** Absolute path of the project folder (source). */
+    projectRoot: string;
+    /** Absolute path of the project's release output (holds `es6/`). */
+    releaseDir: string;
+};
+export type ReachedPackages = {
+    /** Workspace packages the entry reaches, including the entry's own project. */
+    workspace: Set<string>;
+    /**
+     * Third-party package name to the workspace packages whose code imports it. Not what
+     * ships (declared dependencies do); only used to fail on an import nothing ships.
+     */
+    thirdParty: Map<string, Set<string>>;
+};
+/**
+ * Walks the compiled (release) import graph from a deployable's entry point and reports which
+ * workspace and third-party packages the code actually reaches. Code that nothing imports (a
+ * library's `testing/` folder, say) is never opened, so its dependencies are not collected.
+ */
+export declare class ImportGraph {
+    #private;
+    walk(entry: ReleaseProject, projects: ReadonlyMap<string, ReleaseProject>): Promise<ReachedPackages>;
+    private follow;
+    private importsOf;
+    /** Compiled output keeps explicit `.js` paths; tolerate extensionless and folder imports. */
+    private resolveRelative;
+}

package/types/src/packaging/release-exports.d.ts

@@ -0,0 +1,18 @@
+import { type PackageJson } from "@decohere/workspace";
+/** Release `exports`: subpath (`.`, `./testing`) to a file path inside the release output. */
+export type ReleaseExports = Record<string, string>;
+/** `src/main.ts` becomes `src/main.js` (`.mts` `.mjs`, `.cts` `.cjs`), with any leading `./` dropped. */
+declare function toJs(filePath: string): string;
+/**
+ * The `exports` a library needs once only its `es6/` output is shipped: the library's own
+ * map (or its `main`) with every path pointed at `./es6/...js`.
+ */
+declare function build(pkg: PackageJson): ReleaseExports;
+/** The file one subpath (`""` for the package root, `/testing`) points at, or undefined. */
+declare function resolve(exports: ReleaseExports, subpath: string): string | undefined;
+export declare const releaseExports: {
+    build: typeof build;
+    resolve: typeof resolve;
+    toJs: typeof toJs;
+};
+export {};

package/types/src/packaging/ui-assets.d.ts

@@ -0,0 +1,21 @@
+import type { Project } from "@decohere/workspace";
+export declare const DEFAULT_UI_OUTPUT = "dist";
+export declare const DEFAULT_UI_TARGET = "ui";
+export type UiAssets = {
+    /** The UI project's name. */
+    project: string;
+    /** Absolute path of the built UI. */
+    from: string;
+    /** Folder name inside `.package/`. */
+    to: string;
+};
+/**
+ * What the deployable's `ui` declaration (`.decohere.js`) asks for, checked before anything
+ * is written: the UI project exists and has been built. Forge does not build it (see ADR 0007).
+ * Returns `undefined` when the deployable declares no UI.
+ */
+declare function resolve(deployable: Project, projects: readonly Project[]): Promise<UiAssets | undefined>;
+export declare const uiAssets: {
+    resolve: typeof resolve;
+};
+export {};

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

@@ -0,0 +1 @@
+export * from "./semver.js";

package/types/src/semver/semver.d.ts

@@ -0,0 +1,18 @@
+export type VersionType = "major" | "minor" | "patch" | "prerelease";
+export declare const VersionTypes: {
+    major: "major";
+    minor: "minor";
+    patch: "patch";
+    prerelease: "prerelease";
+};
+export declare class SemverError extends Error {
+    constructor(message: string);
+}
+export declare class Semver {
+    private version;
+    constructor(version: string);
+    increment(versionType: VersionType, preid?: string): Semver;
+    toString(): string;
+    private ensureValid;
+    private parse;
+}

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

@@ -1,4 +1,4 @@
-import type { PackageJson, Project, Workspace } from "@decohere/mesh";
+import type { PackageJson, Project, Workspace } from "@decohere/workspace";
 import type { DependencyWarning, DriftEntry, Package } from "../types/dependency.types.js";
 export type ProjectDependencies = {
     project: Project;

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

@@ -1,9 +1,8 @@
-import type { Project } from "@decohere/mesh";
+import type { Project } from "@decohere/workspace";
 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;

package/types/src/services/incremental-watch.d.ts

@@ -0,0 +1,13 @@
+import type { ProjectFileEvent, Workspace } from "@decohere/workspace";
+import type { Observable } from "rxjs";
+import type { TransformResponse } from "../types/transform-response.model.js";
+/**
+ * Runs a transformer's handler for every workspace file change and emits what it built. The
+ * handler invalidates the transformer's own caches, rebuilds, and returns the responses (empty
+ * for a deletion or when nothing was built).
+ */
+export declare class IncrementalWatch {
+    #private;
+    get results$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace, handler: (evt: ProjectFileEvent) => Promise<TransformResponse[]>): void;
+}

package/types/src/services/output-cache.d.ts

@@ -0,0 +1,10 @@
+import type { TransformResponse } from "../types/transform-response.model.js";
+/** The outputs each source file last built to, so watch mode can delete them when it goes. */
+export declare class OutputCache {
+    #private;
+    get(sourcePath: string): TransformResponse[] | undefined;
+    /** Records the successful outputs, replacing what each of their source files had before. */
+    record(responses: TransformResponse[]): void;
+    /** Deletes the files a source built to and forgets them. */
+    delete(sourcePath: string): void;
+}

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

@@ -1,34 +1,47 @@
-import type { Project } from "@decohere/mesh";
-import type { FileEx } from "@decohere/nexus/io";
+import { type Project, type Tsconfig, type Workspace } from "@decohere/workspace";
+import type { FileEx } from "@decohere/core/io";
+import { type Options } from "@swc/core";
+import type { Observable } from "rxjs";
 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;
+    sourceMaps?: boolean;
     tsConfig?: Tsconfig;
     userConfig?: SwcConfig;
+    workspace?: Workspace;
+    projects?: readonly Project[];
 };
-declare const SwcTranspiler_base: abstract new (...args: unknown[]) => CachesOutputs & IncrementalTransform;
-export declare class SwcTranspiler extends SwcTranspiler_base implements Transformer {
+export declare class SwcTranspiler implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace): void;
+    private withAliasContext;
     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[]>;
     /**
-     * Synchronous, single-file variant of `transformFile`.
-     * Reads the file with `fs.readFileSync` and transpiles via `swc.transformSync`.
-     * Intended for callers that cannot await (e.g. Node.js `registerHooks` load hook).
+     * The SWC options for one project and target, without a filename. Building them reads the
+     * workspace's aliases and merges configs, so a caller that transpiles many files builds them
+     * once and passes them to {@link transformCode}.
      */
-    transformFileSync(file: FileEx, buildTarget: TranspileTarget, options?: TranspileOptions): TransformResponse;
+    createBaseConfig(buildTarget: TranspileTarget, options?: TranspileOptions): Options;
+    /** Sync variant of {@link transformCode}, for the load hook, which cannot await (#514). */
+    transformCodeSync(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options): TransformResponse;
+    /**
+     * Compiles `content` as the source of `file`, without reading the file: for callers that
+     * already hold the code, such as the Vitest plugin, which must compile what Vite passes it
+     * rather than an earlier read of the disk (#517). Async SWC, on the thread pool, so many
+     * calls in flight compile in parallel (#661). With a `project`, the response carries where
+     * the build writes the output.
+     */
+    transformCode(content: string, file: FileEx, buildTarget: TranspileTarget, baseConfig: Options, project?: Project): Promise<TransformResponse>;
+    private static skippedEmpty;
+    private static succeeded;
     private transformTarget;
-    private runTransform;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     invalidateContentCache(_file: FileEx): void;
     private getFileContent;
 }
-export {};

package/types/src/services/transpile-cache.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Where compiled code is cached on disk (#514), or null when caching is off:
+ *
+ * - `DECOHERE_CACHE=0` turns it off.
+ * - `DECOHERE_CACHE_DIR` puts it in that directory.
+ * - Otherwise `<root>/node_modules/.cache/decohere`, where tools keep caches, or when the
+ *   workspace has no `node_modules`, `$XDG_CACHE_HOME/decohere`, then the OS temp directory.
+ *
+ * Flux keeps its entries in the `flux` folder inside it; `forge clean` removes the folder.
+ */
+declare function directory(rootDir: string, env?: NodeJS.ProcessEnv): string | null;
+/** The SWC version compiling: part of every cache key, so upgrading SWC misses. */
+export declare const transpileCache: {
+    directory: typeof directory;
+    swcVersion: string;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import type { FileEx } from "@decohere/nexus/io";
+import type { FileEx } from "@decohere/core/io";
 import type ts from "typescript";
 /**
  * Wraps a TypeScript CompilerHost with cached file-system calls so that
@@ -14,7 +14,7 @@ export declare class TsProgramHost {
     /** 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;
+    createProgram(files: FileEx[], compilerOptions: ts.CompilerOptions, host: ts.CompilerHost, oldProgram?: ts.Program, requiredOptions?: ts.CompilerOptions): ts.Program;
     readFileFromDisk(fileName: string): string | undefined;
     fileExistsOnDisk(fileName: string): boolean;
     directoryExists(directoryName: string): boolean;

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

@@ -1,5 +1,6 @@
-import type { Project, Tsconfig } from "@decohere/mesh";
-import type { FileEx } from "@decohere/nexus/io";
+import type { Project, Tsconfig } from "@decohere/workspace";
+import type { FileEx } from "@decohere/core/io";
+import ts from "typescript";
 import type { TsProgramHost } from "../services/ts-program-host.js";
 import { TransformResponse } from "../types/transform-response.model.js";
 export type TypeProgramProject = {
@@ -9,12 +10,16 @@ export type TypeProgramProject = {
 };
 export declare class TypeEmissionProgram {
     #private;
-    constructor(group: TypeProgramProject[], hostFactory: TsProgramHost);
+    constructor(group: TypeProgramProject[], hostFactory: TsProgramHost, requiredOptions: ts.CompilerOptions);
+    check(): readonly ts.Diagnostic[];
+    formatDiagnostics(diagnostics: readonly ts.Diagnostic[]): string;
     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 createProgram;
+    private refreshProgramIfNeeded;
     private emitAll;
     private emitFiltered;
     private toTransformResponse;

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

@@ -1,9 +1,8 @@
-import type { Project, ProjectFileEvent } from "@decohere/mesh";
-import type { FileEx } from "@decohere/nexus/io";
+import type { Project, Workspace } from "@decohere/workspace";
+import type { FileEx } from "@decohere/core/io";
+import type { Observable } from "rxjs";
 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";
@@ -25,10 +24,17 @@ export declare const DEFAULT_TYPE_EMITTER_OPTIONS: Readonly<ts.CompilerOptions>;
  * 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 {
+/** Compiler options enforced for `forge typecheck` — never emit JS or declarations. */
+export declare const REQUIRED_TYPE_CHECK_OPTIONS: Readonly<ts.CompilerOptions>;
+export type PrepareProgramsOptions = {
+    includeAllProjects?: boolean;
+    requiredCompilerOptions?: ts.CompilerOptions;
+};
+export declare class TypeEmitter implements Transformer {
     #private;
     buildTargets: BuildTarget[];
+    get incrementalTransform$(): Observable<TransformResponse[]>;
+    watch(workspace: Workspace): void;
     /**
      * Phase 1: fetch files, create TypeScript programs sequentially.
      * Called before transformProject() so that the heavy createProgram work
@@ -36,8 +42,15 @@ export declare class TypeEmitter extends TypeEmitter_base implements Transformer
      */
     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[]>;
+    /**
+     * Type-check projects without emitting files. Includes every workspace project, not
+     * only those with a `types` build target (debug is es6-only).
+     */
+    checkProject(projectArrayLike: Project[] | Project): Promise<{
+        diagnostics: ts.Diagnostic[];
+        formatted: string;
+    }>;
     private preparePrograms;
-    protected onIncrementalFileEvent(evt: ProjectFileEvent): Promise<TransformResponse[]>;
+    private onIncrementalFileEvent;
     private invalidateReadFileCache;
 }
-export {};

package/types/src/types/configuration.type.d.ts

@@ -1,6 +1,11 @@
-import type { Configuration } from "@decohere/mesh";
+import type { Configuration } from "@decohere/workspace";
 import type { BuildTarget } from "./build-target.type.js";
 export type ForgeConfiguration = Configuration & {
     targets: BuildTarget[];
     aliasPaths?: boolean;
+    /**
+     * Inline source maps in emitted JavaScript (default true). They embed the full TypeScript
+     * source and absolute build paths, so published (release) output turns them off.
+     */
+    sourceMaps?: boolean;
 };