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

package/es6/src/factories/swc-config.factory.js

@@ -5,8 +5,9 @@ function _ts_decorate(decorators, target, key, desc) {
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 import path from "node:path";
-import { Trace } from "@decohere/nexus/diagnostics";
-import { merge } from "@decohere/nexus/objects";
+import { packageAliases } from "@decohere/workspace";
+import { Trace } from "@decohere/devkit/diagnostics";
+import { merge } from "@decohere/core/objects";
 import { ForgeError } from "../errors.js";
 const defaultOptions = {
     jsc: {
@@ -32,10 +33,15 @@ export 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, configOptions) {
-        const { userConfig, tsConfig, aliasPaths } = configOptions;
+        const { userConfig, tsConfig, aliasPaths, sourceMaps, workspace, projects } = configOptions;
         const { compilerOptions } = tsConfig ?? {};
-        const paths = aliasPaths ? compilerOptions?.paths : undefined;
-        const baseUrl = SwcConfigFactory.getBaseUrl(tsConfig) ?? (paths != null ? path.resolve(".") : undefined);
+        const aliases = aliasPaths ? workspace != null ? workspace.getPackageAliases(projects?.[0]?.configuration.name ?? "debug") : projects != null && projects.length > 0 ? packageAliases.build(projects, {
+            baseUrl: SwcConfigFactory.getBaseUrl(tsConfig) ?? path.resolve(projects[0].rootDir),
+            tsconfigPaths: compilerOptions?.paths
+        }) : undefined : undefined;
+        const tsconfigOnlyPaths = aliasPaths && aliases == null ? compilerOptions?.paths : undefined;
+        const paths = SwcConfigFactory.nonemptyPaths(aliases?.paths ?? tsconfigOnlyPaths);
+        const baseUrl = aliases?.baseUrl ?? SwcConfigFactory.getBaseUrl(tsConfig) ?? (workspace != null ? path.resolve(workspace.rootDir) : undefined) ?? (paths != null ? path.resolve(".") : undefined);
         const options = {
             jsc: {
                 baseUrl,
@@ -43,20 +49,36 @@ export class SwcConfigFactory {
             },
             module: {
                 type: buildTarget
-            }
+            },
+            ...sourceMaps === false ? {
+                sourceMaps: false
+            } : {}
         };
         return merge.withOptions({
             mergeArrays: false
         }, defaultOptions, options, userConfig ?? {});
     }
-    /** Stamps a per-file filename onto a pre-built base config. */ createFileConfig(file, baseConfig) {
+    /** Stamps a per-file filename onto a pre-built base config; `.tsx` also turns on JSX. */ createFileConfig(file, baseConfig) {
+        const tsx = file.fullPath.endsWith(".tsx");
+        const jsc = tsx && baseConfig.jsc?.parser?.syntax === "typescript" ? {
+            ...baseConfig.jsc,
+            parser: {
+                ...baseConfig.jsc.parser,
+                tsx: true
+            }
+        } : baseConfig.jsc;
         const config = {
             ...baseConfig,
+            jsc,
             filename: file.fullPath
         };
         this.validate(config);
         return config;
     }
+    static nonemptyPaths(paths) {
+        if (paths == null || Object.keys(paths).length === 0) return undefined;
+        return paths;
+    }
     /**
 	 * Validates SWC options against known causes of Rust/NAPI process crashes.
 	 * Throws a ForgeError with a descriptive message instead of letting the
@@ -79,5 +101,3 @@ export class SwcConfigFactory {
 SwcConfigFactory = _ts_decorate([
     Trace
 ], SwcConfigFactory);
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/forge.module.js

@@ -1,13 +1,14 @@
-import { UserConfigFactory, WorkspaceFactory } from "@decohere/mesh";
-import { ModuleManifest } from "@decohere/nexus/cli";
+import { ModuleManifest } from "@decohere/devkit/cli";
 import * as Actions from "./actions/index.js";
 import * as Commands from "./commands/index.js";
+import { createWorkspace } from "./create-workspace.js";
+import { DependencyPinner } from "./packaging/dependency-pinner.service.js";
+import { ImportGraph } from "./packaging/import-graph.service.js";
 import { DependencyResolver } from "./services/dependency-resolver.service.js";
 import { FileWriterService } from "./services/file-writer.service.js";
 import { SwcTranspiler } from "./services/swc-transpiler.js";
 import { TypeEmitter } from "./services/type-emitter.js";
 import { TransformerKey } from "./types/transformer.type.js";
-import { DefaultConfigurations, WorkspaceDefaults } from "./workspace.config.js";
 export class ForgeModule extends ModuleManifest {
     id = "forge";
     command = Commands.ForgeCommand;
@@ -15,6 +16,7 @@ export class ForgeModule extends ModuleManifest {
         clean: Actions.Clean,
         copy: Actions.Copy,
         docker: Actions.Docker,
+        package: Actions.PackageDeployable,
         build: Actions.Build,
         watch: Actions.Watch,
         publish: Actions.Publish,
@@ -23,6 +25,8 @@ export class ForgeModule extends ModuleManifest {
         reportDependencies: Actions.ReportDependencies,
         version: Actions.Version,
         tag: Actions.Tag,
+        paths: Actions.Paths,
+        typecheck: Actions.TypeCheck,
         commitFiles: Actions.CommitFiles,
         link: Actions.Link,
         unlink: Actions.Unlink
@@ -32,33 +36,24 @@ export class ForgeModule extends ModuleManifest {
         publish: Commands.PublishCommand,
         dependencies: Commands.DependencyCommand,
         docker: Commands.DockerCommand,
+        package: Commands.PackageCommand,
         version: Commands.VersionCommand,
         tag: Commands.TagCommand,
+        paths: Commands.PathsCommand,
+        typecheck: Commands.TypeCheckCommand,
         link: Commands.LinkCommand,
         unlink: Commands.UnlinkCommand
     };
     registerServices(builder) {
+        builder.registerSingleton(TypeEmitter);
         builder.registerSingleton(TransformerKey, SwcTranspiler);
         builder.registerSingleton(TransformerKey, TypeEmitter);
         builder.registerSingleton(DependencyResolver);
+        builder.registerSingleton(ImportGraph);
+        builder.registerSingleton(DependencyPinner);
         builder.registerSingleton(FileWriterService);
     }
-    async createWorkspace(options) {
-        const { configurations: _, ...forgeDefaults } = WorkspaceDefaults;
-        const userConfig = await UserConfigFactory.getUserConfig(options.configFile);
-        // Only apply forge default configurations when user config doesn't provide any.
-        // This ensures user-defined configurations take priority while still providing
-        // sensible defaults (debug + release) when no config file is present.
-        const configurations = userConfig.configurations?.length ? undefined : DefaultConfigurations;
-        return WorkspaceFactory.create({
-            ...forgeDefaults,
-            ...configurations ? {
-                configurations
-            } : {},
-            configFile: options.configFile,
-            rootDir: options.rootDir ?? WorkspaceDefaults.rootDir
-        });
+    createWorkspace(options) {
+        return createWorkspace(options);
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/index.js

@@ -1,7 +1,7 @@
+export { createWorkspace } from "./create-workspace.js";
 export { ForgeError } from "./errors.js";
 export { ForgeModule } from "./forge.module.js";
 export { SwcTranspiler } from "./services/swc-transpiler.js";
+export { transpileCache } from "./services/transpile-cache.js";
 export { BuildTargets } from "./types/build-target.type.js";
 export { Debug as DebugConfiguration, DefaultConfigurations, Link as LinkConfiguration, Release as ReleaseConfiguration, WorkspaceDefaults } from "./workspace.config.js";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL2ZvcmdlL3NyYy9pbmRleC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBGb3JnZUVycm9yIH0gZnJvbSBcIi4vZXJyb3JzLmpzXCI7XG5leHBvcnQgeyBGb3JnZU1vZHVsZSB9IGZyb20gXCIuL2ZvcmdlLm1vZHVsZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBUcmFuc3BpbGVPcHRpb25zIH0gZnJvbSBcIi4vc2VydmljZXMvc3djLXRyYW5zcGlsZXIuanNcIjtcbmV4cG9ydCB7IFN3Y1RyYW5zcGlsZXIgfSBmcm9tIFwiLi9zZXJ2aWNlcy9zd2MtdHJhbnNwaWxlci5qc1wiO1xuZXhwb3J0IHR5cGUgeyBCdWlsZFRhcmdldCwgVHJhbnNwaWxlVGFyZ2V0IH0gZnJvbSBcIi4vdHlwZXMvYnVpbGQtdGFyZ2V0LnR5cGUuanNcIjtcbmV4cG9ydCB7IEJ1aWxkVGFyZ2V0cyB9IGZyb20gXCIuL3R5cGVzL2J1aWxkLXRhcmdldC50eXBlLmpzXCI7XG5leHBvcnQgdHlwZSB7IEZvcmdlQ29uZmlndXJhdGlvbiB9IGZyb20gXCIuL3R5cGVzL2NvbmZpZ3VyYXRpb24udHlwZS5qc1wiO1xuZXhwb3J0IHR5cGUgeyBXb3Jrc3BhY2VPcHRpb25zIH0gZnJvbSBcIi4vdHlwZXMvd29ya3NwYWNlLWNvbmZpZy50eXBlLmpzXCI7XG5leHBvcnQge1xuXHREZWJ1ZyBhcyBEZWJ1Z0NvbmZpZ3VyYXRpb24sXG5cdERlZmF1bHRDb25maWd1cmF0aW9ucyxcblx0TGluayBhcyBMaW5rQ29uZmlndXJhdGlvbixcblx0UmVsZWFzZSBhcyBSZWxlYXNlQ29uZmlndXJhdGlvbixcblx0V29ya3NwYWNlRGVmYXVsdHMsXG59IGZyb20gXCIuL3dvcmtzcGFjZS5jb25maWcuanNcIjtcbiJdLCJuYW1lcyI6WyJGb3JnZUVycm9yIiwiRm9yZ2VNb2R1bGUiLCJTd2NUcmFuc3BpbGVyIiwiQnVpbGRUYXJnZXRzIiwiRGVidWciLCJEZWJ1Z0NvbmZpZ3VyYXRpb24iLCJEZWZhdWx0Q29uZmlndXJhdGlvbnMiLCJMaW5rIiwiTGlua0NvbmZpZ3VyYXRpb24iLCJSZWxlYXNlIiwiUmVsZWFzZUNvbmZpZ3VyYXRpb24iLCJXb3Jrc3BhY2VEZWZhdWx0cyJdLCJtYXBwaW5ncyI6IkFBQUEsU0FBU0EsVUFBVSxRQUFRLGNBQWM7QUFDekMsU0FBU0MsV0FBVyxRQUFRLG9CQUFvQjtBQUVoRCxTQUFTQyxhQUFhLFFBQVEsK0JBQStCO0FBRTdELFNBQVNDLFlBQVksUUFBUSwrQkFBK0I7QUFHNUQsU0FDQ0MsU0FBU0Msa0JBQWtCLEVBQzNCQyxxQkFBcUIsRUFDckJDLFFBQVFDLGlCQUFpQixFQUN6QkMsV0FBV0Msb0JBQW9CLEVBQy9CQyxpQkFBaUIsUUFDWCx3QkFBd0IifQ==

package/es6/src/packaging/dependency-pinner.service.js

@@ -0,0 +1,103 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { io } from "@decohere/core/io";
+import { ForgeError } from "../errors.js";
+export class DependencyPinner {
+    async pin(imported, shipped, projects, workspaceRoot) {
+        const scopes = [
+            ...shipped.map((project)=>({
+                    name: project.name,
+                    dir: project.projectRoot,
+                    pkg: project.pkg
+                })),
+            {
+                name: "the workspace root",
+                dir: workspaceRoot.dir,
+                pkg: workspaceRoot.pkg
+            }
+        ];
+        const declaredBy = new Map();
+        for (const scope of scopes){
+            for (const name of Object.keys(scope.pkg.dependencies ?? {})){
+                if (projects.has(name)) {
+                    continue; // a workspace library, copied from its build, never installed
+                }
+                declaredBy.set(name, [
+                    ...declaredBy.get(name) ?? [],
+                    scope
+                ]);
+            }
+        }
+        this.assertImportsAreShipped(imported, declaredBy, scopes);
+        const pinned = {};
+        for (const name of [
+            ...declaredBy.keys()
+        ].sort()){
+            pinned[name] = await this.installedVersion(name, declaredBy.get(name) ?? [], workspaceRoot.dir);
+        }
+        return pinned;
+    }
+    assertImportsAreShipped(imported, declaredBy, scopes) {
+        for (const name of [
+            ...imported.keys()
+        ].sort()){
+            if (declaredBy.has(name)) {
+                continue;
+            }
+            const importers = [
+                ...imported.get(name) ?? []
+            ].sort().join(", ");
+            const devOnly = scopes.find((scope)=>scope.pkg.devDependencies?.[name] != null);
+            if (devOnly != null) {
+                throw new ForgeError(`${name} is imported at run time by ${importers}, but it is only a devDependency ` + `(of ${devOnly.name}). Move it to "dependencies".`);
+            }
+            throw new ForgeError(`${name} is imported at run time by ${importers}, but is not in "dependencies" of the ` + "deployable, any library it uses, or the workspace root package.json. Add it there.");
+        }
+    }
+    async installedVersion(name, declarers, workspaceRootDir) {
+        const versions = new Map();
+        for (const scope of declarers){
+            const version = await findInstalledVersion(name, scope.dir) ?? await findInstalledVersion(name, workspaceRootDir);
+            if (version == null) {
+                throw new ForgeError(`${name} is declared by ${scope.name} but is not installed. ` + "Run the package manager install first.");
+            }
+            versions.set(scope.name, version);
+        }
+        const distinct = new Set(versions.values());
+        if (distinct.size > 1) {
+            const detail = [
+                ...versions
+            ].map(([owner, version])=>`${owner}: ${version}`).join(", ");
+            throw new ForgeError(`${name} is installed at different versions for the packages that declare it (${detail}). ` + "One packaged app can only ship one version; align them.");
+        }
+        const [version] = distinct;
+        if (version == null) {
+            throw new ForgeError(`${name} is not installed. Run the package manager install first.`);
+        }
+        return version;
+    }
+}
+DependencyPinner = _ts_decorate([
+    injectable()
+], DependencyPinner);
+/** Looks for `node_modules/<name>` in `fromDir` and each folder above it, as Node does. */ async function findInstalledVersion(name, fromDir) {
+    let dir = path.resolve(fromDir);
+    for(;;){
+        const manifest = path.join(dir, "node_modules", name, "package.json");
+        if (await io.fileExists(manifest)) {
+            const { version } = await io.readJsonFile(manifest);
+            return version;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return undefined;
+        }
+        dir = parent;
+    }
+}

package/es6/src/packaging/deployable.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { io } from "@decohere/core/io";
+/** Where `forge package` writes a deployable's output: inside the project, the Docker build context. */ export 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.
+ */ function dockerfileName(project) {
+    return project.dockerConfig?.dockerfile ?? "Dockerfile";
+}
+function dockerfilePath(project) {
+    return path.join(project.projectRoot, dockerfileName(project));
+}
+async function isDeployable(project) {
+    return await io.fileExists(dockerfilePath(project));
+}
+export const deployable = {
+    dockerfileName,
+    dockerfilePath,
+    isDeployable
+};

package/es6/src/packaging/import-graph.service.js

@@ -0,0 +1,122 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import path from "node:path";
+import { injectable } from "@decohere/crucible/decorators";
+import { io } from "@decohere/core/io";
+import { scribe } from "@decohere/scribe";
+import { parseImports } from "parse-imports";
+import { BUILT_IN_MODULES } from "../const.js";
+import { ForgeError } from "../errors.js";
+import { releaseExports } from "./release-exports.js";
+const CODE_FILE = /\.(?:js|mjs|cjs)$/;
+export class ImportGraph {
+    #logger = scribe.logger(ImportGraph.name);
+    async walk(entry, projects) {
+        const reached = {
+            workspace: new Set([
+                entry.name
+            ]),
+            thirdParty: new Map()
+        };
+        const exportsByProject = new Map();
+        const seen = new Set();
+        const queue = [
+            {
+                file: path.join(entry.releaseDir, "es6", releaseExports.toJs(entry.pkg.main ?? "src/index.ts")),
+                owner: entry
+            }
+        ];
+        while(queue.length > 0){
+            const { file, owner } = queue.pop();
+            if (seen.has(file)) {
+                continue;
+            }
+            seen.add(file);
+            for (const specifier of (await this.importsOf(file, owner))){
+                if (specifier.startsWith(".")) {
+                    queue.push({
+                        file: await this.resolveRelative(file, specifier, owner),
+                        owner
+                    });
+                } else if (!isBuiltin(specifier)) {
+                    this.follow(specifier, owner, projects, exportsByProject, reached, queue);
+                }
+            }
+        }
+        return reached;
+    }
+    follow(specifier, importer, projects, exportsByProject, reached, queue) {
+        const name = packageName(specifier);
+        const project = projects.get(name);
+        if (project == null) {
+            const owners = reached.thirdParty.get(name) ?? new Set();
+            owners.add(importer.name);
+            reached.thirdParty.set(name, owners);
+            return;
+        }
+        reached.workspace.add(name);
+        let exports = exportsByProject.get(name);
+        if (exports == null) {
+            exports = releaseExports.build(project.pkg);
+            exportsByProject.set(name, exports);
+        }
+        const subpath = specifier.slice(name.length);
+        const target = releaseExports.resolve(exports, subpath);
+        if (target == null) {
+            throw new ForgeError(`${importer.name} imports "${specifier}", but ${name} does not export "${subpath === "" ? "." : `.${subpath}`}".`);
+        }
+        queue.push({
+            file: path.join(project.releaseDir, target),
+            owner: project
+        });
+    }
+    async importsOf(file, owner) {
+        if (!await io.fileExists(file)) {
+            throw new ForgeError(`${file} is imported by ${owner.name} but was not built. ` + "Run `forge build --configuration release` first.");
+        }
+        if (!CODE_FILE.test(file)) {
+            return [];
+        }
+        const code = await io.readFile(file);
+        const specifiers = [];
+        try {
+            for (const entry of (await parseImports(code))){
+                if (entry.moduleSpecifier.value != null) {
+                    specifiers.push(entry.moduleSpecifier.value);
+                } else if (entry.isDynamicImport) {
+                    this.#logger.warn(`${file}: dynamic import of ${entry.moduleSpecifier.code} cannot be followed; ` + "whatever it loads is not packaged");
+                }
+            }
+        } catch (reason) {
+            throw new ForgeError(`Could not read the imports of ${file}: ${reason instanceof Error ? reason.message : String(reason)}`);
+        }
+        return specifiers;
+    }
+    /** Compiled output keeps explicit `.js` paths; tolerate extensionless and folder imports. */ async resolveRelative(importer, specifier, owner) {
+        const base = path.resolve(path.dirname(importer), specifier);
+        for (const candidate of [
+            base,
+            `${base}.js`,
+            path.join(base, "index.js")
+        ]){
+            if (await io.fileExists(candidate)) {
+                return candidate;
+            }
+        }
+        throw new ForgeError(`${importer} (${owner.name}) imports "${specifier}", which was not built. ` + "Run `forge build --configuration release` first.");
+    }
+}
+ImportGraph = _ts_decorate([
+    injectable()
+], ImportGraph);
+/** `@scope/pkg/deep/path` becomes `@scope/pkg`; `pkg/deep` becomes `pkg`. */ function packageName(specifier) {
+    const parts = specifier.split("/");
+    return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0] ?? specifier;
+}
+function isBuiltin(specifier) {
+    return specifier.startsWith("node:") || BUILT_IN_MODULES.includes(specifier) || BUILT_IN_MODULES.includes(packageName(specifier));
+}

package/es6/src/packaging/release-exports.js

@@ -0,0 +1,80 @@
+import { sourceExtensions } from "@decohere/workspace";
+const ES6_PREFIX = "./es6/";
+/** Condition names that can point at runnable ESM, most specific first. `types` never does. */ const RUNTIME_CONDITIONS = [
+    "import",
+    "node",
+    "default"
+];
+/** `src/main.ts` becomes `src/main.js` (`.mts` `.mjs`, `.cts` `.cjs`), with any leading `./` dropped. */ function toJs(filePath) {
+    const file = filePath.replace(/^\.\//, "");
+    return sourceExtensions.isSource(file) ? sourceExtensions.outputPath(file) : file;
+}
+/**
+ * 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`.
+ */ function build(pkg) {
+    const result = {};
+    for (const [subpath, target] of Object.entries(subpathMap(pkg.exports))){
+        const file = runtimeFile(target);
+        if (file != null) {
+            result[subpath] = file.startsWith(ES6_PREFIX) ? file : `${ES6_PREFIX}${toJs(file)}`;
+        }
+    }
+    if (Object.keys(result).length === 0) {
+        result["."] = `${ES6_PREFIX}${toJs(pkg.main ?? "src/index.ts")}`;
+    }
+    return result;
+}
+/** The file one subpath (`""` for the package root, `/testing`) points at, or undefined. */ function resolve(exports, subpath) {
+    const key = subpath === "" ? "." : `.${subpath}`;
+    const exact = exports[key];
+    if (exact != null) {
+        return exact;
+    }
+    for (const [pattern, target] of Object.entries(exports)){
+        const star = pattern.indexOf("*");
+        if (star < 0) {
+            continue;
+        }
+        const prefix = pattern.slice(0, star);
+        const suffix = pattern.slice(star + 1);
+        if (key.startsWith(prefix) && key.endsWith(suffix) && key.length >= pattern.length - 1) {
+            return target.replaceAll("*", key.slice(prefix.length, key.length - suffix.length));
+        }
+    }
+    return undefined;
+}
+/** A bare path or a conditions object means "the root"; otherwise keys are subpaths. */ function subpathMap(exports) {
+    if (exports == null) {
+        return {};
+    }
+    if (typeof exports === "string") {
+        return {
+            ".": exports
+        };
+    }
+    const keys = Object.keys(exports);
+    return keys.length > 0 && keys.every((key)=>key.startsWith(".")) ? exports : {
+        ".": exports
+    };
+}
+function runtimeFile(target) {
+    if (typeof target === "string") {
+        return target;
+    }
+    if (target == null) {
+        return undefined;
+    }
+    for (const condition of RUNTIME_CONDITIONS){
+        const file = runtimeFile(target[condition]);
+        if (file != null) {
+            return file;
+        }
+    }
+    return undefined;
+}
+export const releaseExports = {
+    build,
+    resolve,
+    toJs
+};

package/es6/src/packaging/ui-assets.js

@@ -0,0 +1,49 @@
+import path from "node:path";
+import { io } from "@decohere/core/io";
+import { ForgeError } from "../errors.js";
+export const DEFAULT_UI_OUTPUT = "dist";
+export const DEFAULT_UI_TARGET = "ui";
+/** Folders `forge package` writes itself; a UI cannot land on top of them. */ const RESERVED_TARGETS = new Set([
+    "es6",
+    "node_modules",
+    "config",
+    "package.json"
+]);
+/**
+ * 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.
+ */ async function resolve(deployable, projects) {
+    const ui = deployable.uiConfig;
+    if (ui == null) {
+        return undefined;
+    }
+    const to = path.normalize(ui.to ?? DEFAULT_UI_TARGET);
+    const output = ui.output ?? DEFAULT_UI_OUTPUT;
+    if (path.isAbsolute(to) || to.split(path.sep).includes("..") || to === ".") {
+        throw new ForgeError(`ui.to of ${deployable.name} must be a folder inside .package/, but is "${ui.to}".`);
+    }
+    if (RESERVED_TARGETS.has(to.split(path.sep)[0])) {
+        throw new ForgeError(`ui.to of ${deployable.name} is "${ui.to}", which forge package uses for something else.`);
+    }
+    const uiProject = projects.find((candidate)=>candidate.name === ui.project);
+    if (uiProject == null) {
+        throw new ForgeError(`${deployable.name} declares the UI project ${ui.project}, which is not a workspace project. ` + `Known projects: ${projects.map((p)=>p.name).join(", ")}`);
+    }
+    const root = path.resolve(uiProject.projectRoot);
+    const from = path.resolve(root, output);
+    if (!from.startsWith(root + path.sep)) {
+        throw new ForgeError(`ui.output of ${deployable.name} must stay inside ${ui.project}.`);
+    }
+    if (!await io.directoryExists(from)) {
+        throw new ForgeError(`${deployable.name} declares the UI project ${ui.project}, but it has no build output at ${from}. ` + "Build the UI first (forge does not build it), or set ui.output if it builds somewhere else.");
+    }
+    return {
+        project: ui.project,
+        from,
+        to
+    };
+}
+export const uiAssets = {
+    resolve
+};

package/es6/src/semver/index.js

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

package/es6/src/semver/semver.js

@@ -0,0 +1,75 @@
+export const VersionTypes = {
+    major: "major",
+    minor: "minor",
+    patch: "patch",
+    prerelease: "prerelease"
+};
+export class SemverError extends Error {
+    constructor(message){
+        super(message);
+        this.name = SemverError.name;
+    }
+}
+const SEMVER_REGEX = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?$/;
+export class Semver {
+    version;
+    constructor(version){
+        this.ensureValid(version);
+        this.version = version;
+    }
+    increment(versionType, preid = "pre") {
+        const { major, minor, patch, prerelease } = this.parse(this.version);
+        if (versionType === "major") {
+            this.version = `${major + 1}.0.0`;
+            return this;
+        }
+        if (versionType === "minor") {
+            this.version = `${major}.${minor + 1}.0`;
+            return this;
+        }
+        if (versionType === "patch") {
+            this.version = `${major}.${minor}.${patch + 1}`;
+            return this;
+        }
+        if (prerelease == null) {
+            this.version = `${major}.${minor}.${patch + 1}-${preid}.0`;
+            return this;
+        }
+        const [identifier, ...rest] = prerelease.split(".");
+        const maybeCounter = rest.at(-1);
+        const counter = maybeCounter != null ? Number.parseInt(maybeCounter, 10) : Number.NaN;
+        if (identifier === preid && Number.isFinite(counter)) {
+            const nextCounter = counter + 1;
+            const prefix = rest.length > 1 ? `${rest.slice(0, -1).join(".")}.` : "";
+            this.version = `${major}.${minor}.${patch}-${preid}.${prefix}${nextCounter}`;
+            return this;
+        }
+        this.version = `${major}.${minor}.${patch}-${preid}.0`;
+        return this;
+    }
+    /** This version's major.minor.patch with `prerelease` in place of any it has now. */ withPrerelease(prerelease) {
+        const { major, minor, patch } = this.parse(this.version);
+        return new Semver(`${major}.${minor}.${patch}-${prerelease}`);
+    }
+    toString() {
+        return this.version;
+    }
+    ensureValid(version) {
+        if (SEMVER_REGEX.test(version)) {
+            return;
+        }
+        throw new SemverError(`Invalid semantic version: ${version}`);
+    }
+    parse(version) {
+        const match = version.match(SEMVER_REGEX);
+        if (match == null) {
+            throw new SemverError(`Invalid semantic version: ${version}`);
+        }
+        return {
+            major: Number.parseInt(match[1], 10),
+            minor: Number.parseInt(match[2], 10),
+            patch: Number.parseInt(match[3], 10),
+            prerelease: match[4]
+        };
+    }
+}