@vyriy/dist 0.5.2

package/AGENTS.md

@@ -0,0 +1,102 @@
+# Project Agent Guide
+
+This repository follows a calm engineering style: changes should be explicit, reusable, typed, documented, tested, and easy to reason about.
+
+Use this guide as the default behavior for AI agents and contributors working in this repository. Prefer local package conventions when they are more specific than this document.
+
+## Core Principles
+
+- Prefer simple modules over clever frameworks or hidden conventions.
+- Keep package and project boundaries explicit.
+- Avoid project-specific coupling in reusable code.
+- Extract only proven reusable behavior.
+- Keep public APIs small, typed, documented, and stable.
+- Prefer SSR-friendly and SSG-friendly code paths when working with frontend or shared code.
+- Keep integrations replaceable and avoid hard coupling to a CMS, framework, vendor, or runtime host.
+- Prefer infrastructure assumptions that are easy to deploy, observe, and replace.
+- Prefer the option that is simpler to explain, easier to evolve, and calmer to maintain.
+
+## File Shape
+
+- Prefer one exported runtime method, component, helper, or class per production file when it stays readable.
+- Prefer one matching test file per production file, for example `feature.ts` and `feature.test.ts`.
+- Use focused folders when behavior naturally splits into several related files.
+- Keep `index.ts` as a public re-export surface only. Do not place implementation logic in it.
+- Use relative import and export specifiers that match the package module style.
+- Use `.js` relative specifiers in TypeScript source for ESM/NodeNext packages.
+- Add `types.ts` when public shared types are part of the package contract.
+- Keep constants near the code that owns them unless they are shared or clarify repeated behavior.
+
+## Public Surface
+
+- Every new public export must be re-exported from the package or module public entry point.
+- Add or update public-surface tests when exports change.
+- Add JSDoc for public exports when behavior, parameters, return values, or usage expectations need explanation.
+- Avoid exporting internal helpers only to make tests easier.
+- Do not hand-maintain package `exports` maps unless the project has a real custom publishing need.
+
+## Tests
+
+- Cover public behavior and meaningful edge cases.
+- Prefer behavior-focused tests over private implementation lock-in.
+- Keep tests deterministic.
+- Avoid real network, filesystem, timers, browser, or cloud dependencies unless the behavior specifically requires them.
+- When mocking modules, install mocks before loading the module under test.
+- Use focused validation when changing behavior.
+
+Example validation commands:
+
+```bash
+yarn test
+```
+
+For workspaces, prefer the project convention, for example:
+
+```bash
+yarn workspace <package-name> test
+```
+
+For Jest-based packages, focused validation may look like:
+
+```bash
+yarn jest packages/<package> --runInBand --coverage=false
+```
+
+## Documentation
+
+- Keep `README.md` concise and usage-oriented.
+- Start package READMEs with `# <package>`.
+- Document real public exports, supported options, and examples that actually work.
+- Update docs when public behavior changes.
+- Keep generated docs wrappers, such as `doc.mdx`, aligned with the README when the project uses them.
+- For component packages, include visual documentation or stories for supported states and common usage.
+
+## Components
+
+- Prefer lightweight React components with TypeScript when working in React packages.
+- Keep components SSR-friendly and avoid browser globals during render.
+- Prefer composable props and predictable ergonomics.
+- Put each public component in its own file with a matching test.
+- Add stories or examples when a component has visual states, variants, or interaction states.
+- Keep styling explicit and reusable. Avoid hidden theme assumptions unless they are part of the package contract.
+
+## Change Discipline
+
+- Keep changes scoped to the requested behavior.
+- Avoid unrelated refactors and metadata churn.
+- Sync implementation, tests, docs, examples, and public re-exports together.
+- Do not introduce new dependencies unless they clearly reduce complexity or are already part of the project direction.
+- Prefer small, reviewable changes over broad rewrites.
+- Preserve existing conventions unless there is a clear reason to change them.
+
+## Before Finishing
+
+Check that the change is complete:
+
+- Public exports are updated.
+- Public-surface tests are updated when exports change.
+- Matching unit tests exist for new behavior.
+- README examples still match the real API.
+- Visual docs, stories, or examples are updated for visible component behavior.
+- TypeScript imports follow the package module style.
+- No unrelated files, formatting churn, or generated artifacts were changed.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vyriy contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @vyriy/dist
+
+Vyriy distribution build CLI and package metadata preparation API.
+
+## CLI
+
+Install globally:
+
+```bash
+npm install --global @vyriy/dist
+```
+
+Prepare compiled workspace packages for distribution:
+
+```bash
+vyriy-dist
+```
+
+## API
+
+Install as a project dependency:
+
+```bash
+npm install @vyriy/dist
+```
+
+Run distribution preparation from code:
+
+```ts
+import { dist } from '@vyriy/dist';
+
+const code = await dist();
+```
+
+`dist()` copies root package metadata, prepares each `dist/<package>/package.json`, creates export maps, removes empty generated JavaScript files, and returns a process-style exit code.

package/assets.d.ts

@@ -0,0 +1,5 @@
+import type { PackageJson } from './types.js';
+export declare const copyReadme: (packageDirectory: string) => Promise<void>;
+export declare const resolveSourceAgentsPath: (packageAgentsPath: string, sharedAgentsPath: string, rootAgentsPath: string) => Promise<string>;
+export declare const copyAgents: (packageDirectory: string, rootPackageJson: PackageJson) => Promise<boolean>;
+export declare const copyLicense: (packageDirectory: string) => Promise<void>;

package/assets.js

@@ -0,0 +1,37 @@
+import { copyFile } from 'node:fs/promises';
+import path from 'node:path';
+import { AGENTS_FILE, LICENSE_FILE, PACKAGES_DIR, README_FILE } from './constants.js';
+import { hasFile } from './file.js';
+export const copyReadme = async (packageDirectory) => {
+    const packageName = path.basename(packageDirectory);
+    const sourceReadmePath = path.join(PACKAGES_DIR, packageName, README_FILE);
+    if (await hasFile(sourceReadmePath)) {
+        await copyFile(sourceReadmePath, path.join(packageDirectory, README_FILE));
+    }
+};
+export const resolveSourceAgentsPath = async (packageAgentsPath, sharedAgentsPath, rootAgentsPath) => {
+    if (await hasFile(packageAgentsPath)) {
+        return packageAgentsPath;
+    }
+    if (await hasFile(sharedAgentsPath)) {
+        return sharedAgentsPath;
+    }
+    return rootAgentsPath;
+};
+export const copyAgents = async (packageDirectory, rootPackageJson) => {
+    const packageName = path.basename(packageDirectory);
+    const packageAgentsPath = path.join(PACKAGES_DIR, packageName, AGENTS_FILE);
+    const sharedAgentsPath = path.join(PACKAGES_DIR, AGENTS_FILE);
+    const rootAgentsPath = typeof rootPackageJson.agents === 'string' ? rootPackageJson.agents.replace(/^\.\//, '') : '';
+    const sourceAgentsPath = await resolveSourceAgentsPath(packageAgentsPath, sharedAgentsPath, rootAgentsPath);
+    if (await hasFile(sourceAgentsPath)) {
+        await copyFile(sourceAgentsPath, path.join(packageDirectory, AGENTS_FILE));
+        return true;
+    }
+    return false;
+};
+export const copyLicense = async (packageDirectory) => {
+    if (await hasFile(LICENSE_FILE)) {
+        await copyFile(LICENSE_FILE, path.join(packageDirectory, LICENSE_FILE));
+    }
+};

package/bin/vyriy-dist.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { dist } from '../index.js';
+process.exitCode = await dist();

package/bin.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson } from './types.js';
+export declare const getPackageBinFiles: (packageJson: PackageJson) => string[];
+export declare const removePackageBinDeclarationFiles: (packageDirectory: string, packageJson: PackageJson) => Promise<void>;
+export declare const makePackageBinsExecutable: (packageDirectory: string, packageJson: PackageJson) => Promise<void>;

package/bin.js

@@ -0,0 +1,29 @@
+import { chmod, unlink } from 'node:fs/promises';
+import path from 'node:path';
+import { hasFile } from './file.js';
+import { toPackageLocalPath } from './path.js';
+export const getPackageBinFiles = (packageJson) => {
+    if (typeof packageJson.bin === 'string') {
+        return [packageJson.bin];
+    }
+    if (packageJson.bin && typeof packageJson.bin === 'object') {
+        return Object.values(packageJson.bin);
+    }
+    return [];
+};
+export const removePackageBinDeclarationFiles = async (packageDirectory, packageJson) => {
+    for (const binFile of getPackageBinFiles(packageJson)) {
+        const declarationFilePath = path.join(packageDirectory, toPackageLocalPath(binFile).replace(/\.js$/, '.d.ts'));
+        if (await hasFile(declarationFilePath)) {
+            await unlink(declarationFilePath);
+        }
+    }
+};
+export const makePackageBinsExecutable = async (packageDirectory, packageJson) => {
+    for (const binFile of getPackageBinFiles(packageJson)) {
+        const binFilePath = path.join(packageDirectory, toPackageLocalPath(binFile));
+        if (await hasFile(binFilePath)) {
+            await chmod(binFilePath, 0o755);
+        }
+    }
+};

package/cleanup.d.ts

@@ -0,0 +1,2 @@
+export declare const isEmptyJavaScriptContent: (content: string) => boolean;
+export declare const removeEmptyJavaScriptFiles: (packageDirectory: string) => Promise<void>;

package/cleanup.js

@@ -0,0 +1,14 @@
+import { readFile, unlink } from 'node:fs/promises';
+import { readFiles } from './file.js';
+export const isEmptyJavaScriptContent = (content) => {
+    const normalizedContent = content.trim();
+    return normalizedContent.length === 0 || normalizedContent === 'export {};';
+};
+export const removeEmptyJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (file.endsWith('.js') && isEmptyJavaScriptContent(await readFile(file, 'utf8'))) {
+            await unlink(file);
+        }
+    }
+};

package/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const DIST_DIR = "dist";
+export declare const AGENTS_FILE = "AGENTS.md";
+export declare const LICENSE_FILE = "LICENSE";
+export declare const PACKAGE_JSON_FILE = "package.json";
+export declare const PACKAGES_DIR = "packages";
+export declare const README_FILE = "README.md";

package/constants.js

@@ -0,0 +1,6 @@
+export const DIST_DIR = 'dist';
+export const AGENTS_FILE = 'AGENTS.md';
+export const LICENSE_FILE = 'LICENSE';
+export const PACKAGE_JSON_FILE = 'package.json';
+export const PACKAGES_DIR = 'packages';
+export const README_FILE = 'README.md';

package/dist.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const dist: Command;

package/dist.js

@@ -0,0 +1,28 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { DIST_DIR, PACKAGE_JSON_FILE } from './constants.js';
+import { hasFile, readJson } from './file.js';
+import { distPackage } from './package.js';
+import { distRoot } from './root.js';
+export const dist = async () => {
+    const previousCwd = process.cwd();
+    try {
+        process.chdir(process.cwd());
+        const rootPackageJson = await readJson(PACKAGE_JSON_FILE);
+        await distRoot();
+        const entries = await readdir(DIST_DIR, { withFileTypes: true });
+        const packageJsonPaths = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(DIST_DIR, entry.name, PACKAGE_JSON_FILE))
+            .sort((left, right) => left.localeCompare(right));
+        for (const packageJsonPath of packageJsonPaths) {
+            if (await hasFile(packageJsonPath)) {
+                await distPackage(packageJsonPath, rootPackageJson);
+            }
+        }
+        return 0;
+    }
+    finally {
+        process.chdir(previousCwd);
+    }
+};

package/exports.d.ts

@@ -0,0 +1,7 @@
+import type { ExportTarget, PackageJson } from './types.js';
+export declare const getMissingExportTarget: (file: string, line: string) => Promise<string | undefined>;
+export declare const removeMissingJavaScriptExports: (packageDirectory: string) => Promise<void>;
+export declare const getJavaScriptFiles: (packageDirectory: string) => Promise<string[]>;
+export declare const getPackageMain: (packageDirectory: string, packageJson: PackageJson, javaScriptFiles: string[]) => Promise<string | undefined>;
+export declare const createExportTarget: (javaScriptFile: string) => ExportTarget;
+export declare const createExports: (mainFile: string, javaScriptFiles: string[]) => Record<string, ExportTarget>;

package/exports.js

@@ -0,0 +1,81 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { getPackageBinFiles } from './bin.js';
+import { hasFile, readFiles } from './file.js';
+import { toPackagePath, toPosixPath } from './path.js';
+const exportTargetPattern = /^\s*export(?:\s+\*|\s+\{[^}]*\})\s+from\s+['"](\..+\.js)['"];?\s*$/;
+export const getMissingExportTarget = async (file, line) => {
+    const exportTarget = exportTargetPattern.exec(line)?.[1];
+    if (!exportTarget) {
+        return undefined;
+    }
+    const exportTargetPath = path.resolve(path.dirname(file), exportTarget);
+    return (await hasFile(exportTargetPath)) ? undefined : exportTargetPath;
+};
+export const removeMissingJavaScriptExports = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    for (const file of files) {
+        if (!file.endsWith('.js')) {
+            continue;
+        }
+        const content = await readFile(file, 'utf8');
+        const lines = content.split('\n');
+        const retainedLines = [];
+        for (const line of lines) {
+            if (!(await getMissingExportTarget(file, line))) {
+                retainedLines.push(line);
+            }
+        }
+        if (retainedLines.length !== lines.length) {
+            await writeFile(file, retainedLines.join('\n'));
+        }
+    }
+};
+export const getJavaScriptFiles = async (packageDirectory) => {
+    const files = await readFiles(packageDirectory);
+    const javaScriptFiles = [];
+    for (const file of files) {
+        const relativeFile = toPosixPath(path.relative(packageDirectory, file));
+        const declarationFile = path.join(packageDirectory, relativeFile.replace(/\.js$/, '.d.ts'));
+        if (relativeFile.endsWith('.js') && !relativeFile.endsWith('.test.js') && (await hasFile(declarationFile))) {
+            javaScriptFiles.push(relativeFile);
+        }
+    }
+    return javaScriptFiles.sort((left, right) => left.localeCompare(right));
+};
+export const getPackageMain = async (packageDirectory, packageJson, javaScriptFiles) => {
+    if (packageJson.main?.endsWith('.js')) {
+        const mainPath = packageJson.main.replace(/^\.\//, '');
+        if (await hasFile(path.join(packageDirectory, mainPath))) {
+            return toPosixPath(mainPath);
+        }
+    }
+    if (javaScriptFiles.includes('index.js')) {
+        return 'index.js';
+    }
+    if (getPackageBinFiles(packageJson).length > 0) {
+        return undefined;
+    }
+    return javaScriptFiles[0];
+};
+export const createExportTarget = (javaScriptFile) => {
+    const packagePath = toPackagePath(javaScriptFile);
+    return {
+        types: packagePath.replace(/\.js$/, '.d.ts'),
+        import: packagePath,
+        default: packagePath,
+    };
+};
+export const createExports = (mainFile, javaScriptFiles) => {
+    const exports = {
+        '.': createExportTarget(mainFile),
+    };
+    for (const javaScriptFile of javaScriptFiles) {
+        const packagePath = toPackagePath(javaScriptFile);
+        const extensionlessPackagePath = packagePath.replace(/\.js$/, '');
+        const target = createExportTarget(javaScriptFile);
+        exports[extensionlessPackagePath] = target;
+        exports[packagePath] = target;
+    }
+    return exports;
+};

package/file.d.ts

@@ -0,0 +1,4 @@
+export declare const hasFile: (filePath: string) => Promise<boolean>;
+export declare const readJson: <Value>(filePath: string) => Promise<Value>;
+export declare const writeJson: (filePath: string, value: unknown) => Promise<void>;
+export declare const readFiles: (directory: string) => Promise<string[]>;

package/file.js

@@ -0,0 +1,28 @@
+import { readdir, readFile, stat, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+export const hasFile = async (filePath) => {
+    try {
+        return (await stat(filePath)).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+export const readJson = async (filePath) => {
+    const content = await readFile(filePath, 'utf8');
+    return JSON.parse(content);
+};
+export const writeJson = async (filePath, value) => {
+    await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`);
+};
+export const readFiles = async (directory) => {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+        const entryPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return readFiles(entryPath);
+        }
+        return entry.isFile() ? [entryPath] : [];
+    }));
+    return files.flat();
+};

package/index.d.ts

@@ -0,0 +1,2 @@
+export * from './dist.js';
+export type * from './types.js';

package/index.js

@@ -0,0 +1 @@
+export * from './dist.js';

package/package.d.ts

@@ -0,0 +1,4 @@
+import type { PackageJson, Repository } from './types.js';
+export declare const createPackageRepository: (rootPackageJson: PackageJson, packageDirectory: string) => Repository | undefined;
+export declare const syncPackageRuntimeMetadata: (packageJson: PackageJson, rootPackageJson: PackageJson) => void;
+export declare const distPackage: (packageJsonPath: string, rootPackageJson: PackageJson) => Promise<void>;

package/package.js

@@ -0,0 +1,68 @@
+import path from 'node:path';
+import { copyAgents, copyLicense, copyReadme } from './assets.js';
+import { makePackageBinsExecutable, removePackageBinDeclarationFiles } from './bin.js';
+import { AGENTS_FILE, PACKAGES_DIR } from './constants.js';
+import { removeEmptyJavaScriptFiles } from './cleanup.js';
+import { createExports, getJavaScriptFiles, getPackageMain, removeMissingJavaScriptExports } from './exports.js';
+import { readJson, writeJson } from './file.js';
+import { toPackagePath, toPosixPath } from './path.js';
+export const createPackageRepository = (rootPackageJson, packageDirectory) => {
+    const rootRepository = rootPackageJson.repository;
+    if (!rootRepository) {
+        return undefined;
+    }
+    return {
+        ...rootRepository,
+        directory: toPosixPath(path.join(PACKAGES_DIR, path.basename(packageDirectory))),
+    };
+};
+export const syncPackageRuntimeMetadata = (packageJson, rootPackageJson) => {
+    if (packageJson.name !== 'vyriy') {
+        return;
+    }
+    packageJson.packageManager = rootPackageJson.packageManager;
+    packageJson.engines = rootPackageJson.engines;
+};
+export const distPackage = async (packageJsonPath, rootPackageJson) => {
+    const packageDirectory = path.dirname(packageJsonPath);
+    const packageJson = await readJson(packageJsonPath);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    await removeMissingJavaScriptExports(packageDirectory);
+    await removeEmptyJavaScriptFiles(packageDirectory);
+    await removePackageBinDeclarationFiles(packageDirectory, packageJson);
+    const javaScriptFiles = await getJavaScriptFiles(packageDirectory);
+    await copyLicense(packageDirectory);
+    await copyReadme(packageDirectory);
+    const hasAgents = await copyAgents(packageDirectory, rootPackageJson);
+    delete packageJson.private;
+    if (hasAgents && rootPackageJson.agents) {
+        packageJson.agents = toPackagePath(AGENTS_FILE);
+    }
+    else {
+        delete packageJson.agents;
+    }
+    if (rootPackageJson.license) {
+        packageJson.license = rootPackageJson.license;
+    }
+    else {
+        delete packageJson.license;
+    }
+    const repository = createPackageRepository(rootPackageJson, packageDirectory);
+    if (repository) {
+        packageJson.repository = repository;
+    }
+    else {
+        delete packageJson.repository;
+    }
+    syncPackageRuntimeMetadata(packageJson, rootPackageJson);
+    if (javaScriptFiles.length > 0) {
+        const mainFile = await getPackageMain(packageDirectory, packageJson, javaScriptFiles);
+        if (mainFile) {
+            packageJson.main = toPackagePath(mainFile);
+            packageJson.types = toPackagePath(mainFile).replace(/\.js$/, '.d.ts');
+            packageJson.exports = createExports(mainFile, javaScriptFiles);
+        }
+    }
+    await makePackageBinsExecutable(packageDirectory, packageJson);
+    await writeJson(packageJsonPath, packageJson);
+};

package/package.json

@@ -0,0 +1,136 @@
+{
+  "name": "@vyriy/dist",
+  "version": "0.5.2",
+  "description": "Vyriy distribution build CLI.",
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "bin": "./bin/vyriy-dist.js",
+  "agents": "./AGENTS.md",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/evheniy/vyriy",
+    "directory": "packages/dist"
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./assets": {
+      "types": "./assets.d.ts",
+      "import": "./assets.js",
+      "default": "./assets.js"
+    },
+    "./assets.js": {
+      "types": "./assets.d.ts",
+      "import": "./assets.js",
+      "default": "./assets.js"
+    },
+    "./bin": {
+      "types": "./bin.d.ts",
+      "import": "./bin.js",
+      "default": "./bin.js"
+    },
+    "./bin.js": {
+      "types": "./bin.d.ts",
+      "import": "./bin.js",
+      "default": "./bin.js"
+    },
+    "./cleanup": {
+      "types": "./cleanup.d.ts",
+      "import": "./cleanup.js",
+      "default": "./cleanup.js"
+    },
+    "./cleanup.js": {
+      "types": "./cleanup.d.ts",
+      "import": "./cleanup.js",
+      "default": "./cleanup.js"
+    },
+    "./constants": {
+      "types": "./constants.d.ts",
+      "import": "./constants.js",
+      "default": "./constants.js"
+    },
+    "./constants.js": {
+      "types": "./constants.d.ts",
+      "import": "./constants.js",
+      "default": "./constants.js"
+    },
+    "./dist": {
+      "types": "./dist.d.ts",
+      "import": "./dist.js",
+      "default": "./dist.js"
+    },
+    "./dist.js": {
+      "types": "./dist.d.ts",
+      "import": "./dist.js",
+      "default": "./dist.js"
+    },
+    "./exports": {
+      "types": "./exports.d.ts",
+      "import": "./exports.js",
+      "default": "./exports.js"
+    },
+    "./exports.js": {
+      "types": "./exports.d.ts",
+      "import": "./exports.js",
+      "default": "./exports.js"
+    },
+    "./file": {
+      "types": "./file.d.ts",
+      "import": "./file.js",
+      "default": "./file.js"
+    },
+    "./file.js": {
+      "types": "./file.d.ts",
+      "import": "./file.js",
+      "default": "./file.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./index.js": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./package": {
+      "types": "./package.d.ts",
+      "import": "./package.js",
+      "default": "./package.js"
+    },
+    "./package.js": {
+      "types": "./package.d.ts",
+      "import": "./package.js",
+      "default": "./package.js"
+    },
+    "./path": {
+      "types": "./path.d.ts",
+      "import": "./path.js",
+      "default": "./path.js"
+    },
+    "./path.js": {
+      "types": "./path.d.ts",
+      "import": "./path.js",
+      "default": "./path.js"
+    },
+    "./root": {
+      "types": "./root.d.ts",
+      "import": "./root.js",
+      "default": "./root.js"
+    },
+    "./root.js": {
+      "types": "./root.d.ts",
+      "import": "./root.js",
+      "default": "./root.js"
+    }
+  }
+}

package/path.d.ts

@@ -0,0 +1,3 @@
+export declare const toPosixPath: (value: string) => string;
+export declare const toPackagePath: (value: string) => string;
+export declare const toPackageLocalPath: (filePath: string) => string;

package/path.js

@@ -0,0 +1,7 @@
+import path from 'node:path';
+export const toPosixPath = (value) => value.split(path.sep).join('/');
+export const toPackagePath = (value) => {
+    const normalizedValue = toPosixPath(value);
+    return `./${normalizedValue.replace(/^\.\//, '')}`;
+};
+export const toPackageLocalPath = (filePath) => filePath.replace(/^\.\//, '');

package/root.d.ts

@@ -0,0 +1,3 @@
+export declare const copyRootFile: (fileName: string) => Promise<void>;
+export declare const distRootPackageJson: () => Promise<void>;
+export declare const distRoot: () => Promise<void>;

package/root.js

@@ -0,0 +1,23 @@
+import { copyFile } from 'node:fs/promises';
+import path from 'node:path';
+import { DIST_DIR, LICENSE_FILE, PACKAGE_JSON_FILE, README_FILE } from './constants.js';
+import { hasFile, readJson, writeJson } from './file.js';
+export const copyRootFile = async (fileName) => {
+    if (await hasFile(fileName)) {
+        await copyFile(fileName, path.join(DIST_DIR, fileName));
+    }
+};
+export const distRootPackageJson = async () => {
+    const packageJson = await readJson(PACKAGE_JSON_FILE);
+    delete packageJson.agents;
+    delete packageJson.dependencies;
+    delete packageJson.packageManager;
+    delete packageJson.scripts;
+    delete packageJson.devDependencies;
+    await writeJson(path.join(DIST_DIR, PACKAGE_JSON_FILE), packageJson);
+};
+export const distRoot = async () => {
+    await copyRootFile(README_FILE);
+    await copyRootFile(LICENSE_FILE);
+    await distRootPackageJson();
+};

package/types.d.ts

@@ -0,0 +1,29 @@
+export type Command = () => Promise<number>;
+export type ExportTarget = {
+    readonly default: string;
+    readonly import: string;
+    readonly types: string;
+};
+export type Repository = {
+    readonly directory?: string;
+    readonly type: string;
+    readonly url: string;
+};
+export type PackageJson = {
+    agents?: string;
+    bin?: string | Record<string, string>;
+    dependencies?: unknown;
+    devDependencies?: unknown;
+    engines?: unknown;
+    exports?: Record<string, ExportTarget>;
+    license?: string;
+    main?: string;
+    name?: string;
+    packageManager?: unknown;
+    private?: boolean;
+    repository?: Repository;
+    scripts?: unknown;
+    types?: string;
+    workspaces?: unknown;
+    [key: string]: unknown;
+};