@decohere/forge 0.0.1-dev.20 → 0.0.1-dev.20261105.110

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

@@ -1,6 +1,6 @@
-import { Workspace } from "@decohere/mesh";
-import type { Action, ResultStatus } from "@decohere/nexus/cli";
-import { ActionResponse } from "@decohere/nexus/cli";
+import { Workspace } from "@decohere/workspace";
+import type { Action, ResultStatus } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
 export type DockerOptions = {
     configuration: string;
     dryRun?: boolean;
@@ -19,9 +19,20 @@ export declare class Docker implements Action<DockerOptions> {
     constructor(workspace: Workspace);
     run(options: DockerOptions): Promise<ActionResponse<DockerResponse>>;
     private getDockerProjects;
+    /**
+     * A Dockerfile that copies `.package/` needs `forge package` to have run. Fail before the
+     * build with that instruction rather than with Docker's "not found" from deep in a layer.
+     */
+    private assertPackaged;
     private buildProject;
     private interpolateBuildArgs;
+    /**
+     * Keep FORGE_DOCKER_EXTRA_TAGS_JSON scoped to this image so multi-image
+     * publishes do not stamp create:latest onto the app Dev Container (and vice versa).
+     */
+    private extraTagsForImage;
     private defaultImageName;
     private normalizeDockerRepository;
+    private normalizeProjectSlug;
     private parseJsonEnv;
 }

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

@@ -6,9 +6,12 @@ export * from "./dependency-report.action.js";
 export * from "./dependency-sync.action.js";
 export * from "./docker.action.js";
 export * from "./link.action.js";
+export * from "./package.action.js";
+export * from "./paths.action.js";
 export * from "./publish.action.js";
 export * from "./sync-lock-file.action.js";
 export * from "./tag.action.js";
+export * from "./typecheck.action.js";
 export * from "./unlink.action.js";
 export * from "./version.action.js";
 export * from "./watch.action.js";

package/types/src/actions/link.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";
 import "../extensions/project.extensions.js";
 export declare const LINK_MANIFEST = ".forge-link.json";
 export type LinkOptions = {

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

@@ -0,0 +1,38 @@
+import { Workspace } from "@decohere/workspace";
+import type { Action, ResultStatus } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { DependencyPinner } from "../packaging/dependency-pinner.service.js";
+import { ImportGraph } from "../packaging/import-graph.service.js";
+export type PackageOptions = {
+    /** Package name of one deployable. Omit to package every project that has a Dockerfile. */
+    project?: string;
+};
+export type PackageResponse = ResultStatus & {
+    projectName: string;
+    outDir: string;
+    workspacePackages: string[];
+    dependencies: Record<string, string>;
+    message: string;
+};
+/**
+ * Turns a deployable's release build into one self-contained folder that plain `node` runs:
+ * no symlinks, no workspace tooling. See ADR 0006.
+ */
+export declare class PackageDeployable implements Action<PackageOptions> {
+    #private;
+    private readonly workspace;
+    private readonly importGraph;
+    private readonly pinner;
+    private readonly npm;
+    constructor(workspace: Workspace, importGraph: ImportGraph, pinner: DependencyPinner);
+    run(options: PackageOptions): Promise<ActionResponse<PackageResponse>>;
+    /** The deployables to package, or the reason a named project cannot be one. */
+    private select;
+    private releaseProjects;
+    private packageProject;
+    private write;
+    /** Copies file contents, never links: a symlink in the output would break outside the image. */
+    private copyTree;
+    private writeJson;
+    private assertNoSymlinks;
+}

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

@@ -0,0 +1,28 @@
+import { Workspace } from "@decohere/workspace";
+import type { Action } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
+export declare const PATHS_FILE = "tsconfig.paths.json";
+export type PathsOptions = {
+    /** Fail if the file is missing or out of date, instead of writing it. */
+    check?: boolean;
+};
+export type PathsResponse = {
+    file: string;
+    changed: boolean;
+    succeeded: boolean;
+    error?: string;
+};
+/**
+ * Writes `tsconfig.paths.json`: tsconfig `paths` for every workspace package and the subpaths it
+ * exports, from the workspace aliases. Without `node_modules` links, `tsc` finds workspace
+ * packages only through `paths`; generating them keeps them in step with what Flux, the Vitest
+ * plugin and builds resolve. The root tsconfig extends the file.
+ */
+export declare class Paths implements Action<PathsOptions> {
+    #private;
+    private readonly workspace;
+    constructor(workspace: Workspace);
+    run(options: PathsOptions): Promise<ActionResponse<PathsResponse>>;
+    /** The file's content: convention and exported subpaths only, never the tsconfig's own paths. */
+    static render(workspace: Workspace): string;
+}

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

@@ -1,7 +1,7 @@
-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";
+import type { Project } from "@decohere/workspace";
+import { Workspace } from "@decohere/workspace";
+import type { Action, ResultStatus } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
 export type PublishOptions = {
     configuration: string;
     channel?: string;

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

@@ -1,5 +1,5 @@
-import type { Action } from "@decohere/nexus/cli";
-import { ActionResponse } from "@decohere/nexus/cli";
+import type { Action } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
 export type SyncLockFileOptions = {
     sync?: boolean;
     dryRun?: boolean;

package/types/src/actions/tag.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 TagOptions = {
     prefix?: string;
     dryRun?: boolean;

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

@@ -0,0 +1,14 @@
+import { Workspace } from "@decohere/workspace";
+import type { Action } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { TypeEmitter } from "../services/type-emitter.js";
+export type TypeCheckOptions = {
+    configuration: string;
+};
+export declare class TypeCheck implements Action<TypeCheckOptions> {
+    #private;
+    private readonly workspace;
+    private readonly typeEmitter;
+    constructor(workspace: Workspace, typeEmitter: TypeEmitter);
+    run: (options: TypeCheckOptions) => Promise<ActionResponse>;
+}

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

@@ -1,5 +1,5 @@
-import type { Action } from "@decohere/nexus/cli";
-import { ActionResponse } from "@decohere/nexus/cli";
+import type { Action } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
 export type UnlinkOptions = {
     targetDir: string;
 };

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

@@ -1,7 +1,7 @@
-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";
+import { Workspace } from "@decohere/workspace";
+import type { Action, ResultStatus } from "@decohere/devkit/cli";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { type VersionType } from "../semver/index.js";
 export type VersionResponse = ResultStatus & {
     name: string;
 };
@@ -11,6 +11,12 @@ export type VersionOptions = {
     releaseType?: VersionType;
     channel?: string;
     version?: string;
+    /** A CI run number: the version becomes `<base>-<channel>.<commit's UTC date>.<number>`. */
+    buildNumber?: string;
+    /** Copy the version from the built packages, failing if they don't all match. */
+    fromBuild?: boolean;
+    /** The build `fromBuild` reads. */
+    configuration?: string;
     dryRun?: boolean;
     commit?: boolean;
     message?: string;
@@ -23,6 +29,10 @@ export declare class Version implements Action<VersionOptions> {
     constructor(workspace: Workspace);
     run(options: VersionOptions): Promise<ActionResponse>;
     version(workspace: Workspace, options?: VersionOptions): Promise<ActionResponse<VersionResponse>>;
+    private resolveNextVersion;
+    private versionFromBuildNumber;
+    private versionFromBuild;
+    private readBuiltVersion;
     private resolveBaseVersion;
     private resolveVersionFromGitTag;
     /**

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

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

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

@@ -3,6 +3,9 @@ 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

@@ -1,5 +1,5 @@
-import type { CommandHandler, MergeOptions } from "@decohere/nexus/cli";
-import { CommandResponse, DecohereCommand } from "@decohere/nexus/cli";
+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";
@@ -19,6 +19,7 @@ type UnlinkActions = {
 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> {

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 the root: `--root-dir`, else the current folder.
+ */
+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. */
     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 {
@@ -10,6 +10,7 @@ export declare class ForgeModule extends ModuleManifest {
         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;
@@ -18,6 +19,8 @@ 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;
@@ -27,11 +30,14 @@ export declare class ForgeModule extends ModuleManifest {
         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,7 +1,9 @@
+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";

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,20 @@
+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;
+    /** This version's major.minor.patch with `prerelease` in place of any it has now. */
+    withPrerelease(prerelease: 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;
@@ -9,6 +9,13 @@ 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>;
+    /**
+     * A package declares its peers by name in its own `peerDependencies` (and marks optional ones in
+     * `peerDependenciesMeta`, which sync leaves as written). The root owns every version, so each
+     * peer gets the root's range; a peer the root doesn't list is an error. A declared peer stays
+     * even when no code imports it: a pino transport, say, is loaded by name.
+     */
+    private getPeerDependencies;
     private getDependencies;
     private getDependencyFrom;
     private getFileImports;

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;