@atls/raijin 0.2.0

package/bin/raijin.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+import '../dist/cli.js'

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,13 @@
+import { runRaijinInitializer } from './initializer/index.js';
+try {
+    await runRaijinInitializer({ argv: process.argv.slice(2) });
+}
+catch (error) {
+    if (error instanceof Error) {
+        process.stderr.write(`${error.message}\n`);
+    }
+    else {
+        process.stderr.write(`${String(error)}\n`);
+    }
+    process.exitCode = 1;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export type { RunRaijinInitializerOptions } from './initializer/interface.js';
+export { runRaijinInitializer } from './initializer/index.js';

package/dist/index.js

@@ -0,0 +1 @@
+export { runRaijinInitializer } from "./initializer/index.js";

package/dist/initializer/exceptions/usage.d.ts

@@ -0,0 +1,3 @@
+export declare class RaijinInitializerUsageException extends Error {
+    constructor();
+}

package/dist/initializer/exceptions/usage.js

@@ -0,0 +1,7 @@
+const RAIJIN_INITIALIZER_USAGE_MESSAGE = 'Usage: yarn init @atls/raijin or yarn dlx @atls/raijin init';
+export class RaijinInitializerUsageException extends Error {
+    constructor() {
+        super(RAIJIN_INITIALIZER_USAGE_MESSAGE);
+        this.name = 'RaijinInitializerUsageException';
+    }
+}

package/dist/initializer/index.d.ts

@@ -0,0 +1,2 @@
+import type { RunRaijinInitializerOptions } from './interface.js';
+export declare const runRaijinInitializer: ({ argv, cwd, fetchImpl, runYarnCommand: runCommand, }?: RunRaijinInitializerOptions) => Promise<void>;

package/dist/initializer/index.js

@@ -0,0 +1,18 @@
+import { RaijinInitializerUsageException } from './exceptions/usage.js';
+import { installRaijinRuntime } from '../runtime/installer.js';
+import { runYarnCommand } from '../yarn/command.js';
+import { ensurePackageJson } from './project.js';
+import { ensureYarnLock } from './project.js';
+const CODE_RUNTIME_PACKAGE = '@atls/code-runtime@latest';
+export const runRaijinInitializer = async ({ argv = [], cwd = process.cwd(), fetchImpl = fetch, runYarnCommand: runCommand = runYarnCommand, } = {}) => {
+    const command = argv[0];
+    if (argv.length > 1 || (command && command !== 'init')) {
+        throw new RaijinInitializerUsageException();
+    }
+    await ensurePackageJson(cwd);
+    await ensureYarnLock(cwd);
+    await installRaijinRuntime({ cwd, fetchImpl });
+    await runCommand(['add', '-D', CODE_RUNTIME_PACKAGE], cwd);
+    await runCommand(['generate', 'project'], cwd);
+    await runCommand(['tools', 'sync'], cwd);
+};

package/dist/initializer/interface.d.ts

@@ -0,0 +1,8 @@
+import type { FetchLike } from '../runtime/download.js';
+import type { YarnCommandRunner } from '../yarn/runner.js';
+export interface RunRaijinInitializerOptions {
+    argv?: Array<string>;
+    cwd?: string;
+    fetchImpl?: FetchLike;
+    runYarnCommand?: YarnCommandRunner;
+}

package/dist/initializer/interface.js

@@ -0,0 +1 @@
+export {};

package/dist/initializer/project.d.ts

@@ -0,0 +1,5 @@
+export declare const getPackageName: (cwd: string) => string;
+export declare const hasPackageJson: (cwd: string) => Promise<boolean>;
+export declare const hasYarnLock: (cwd: string) => Promise<boolean>;
+export declare const ensurePackageJson: (cwd: string) => Promise<void>;
+export declare const ensureYarnLock: (cwd: string) => Promise<void>;

package/dist/initializer/project.js

@@ -0,0 +1,42 @@
+import { access } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+import { join } from 'node:path';
+const PACKAGE_JSON = 'package.json';
+const YARN_LOCK = 'yarn.lock';
+const FALLBACK_PACKAGE_NAME = 'raijin-project';
+const INVALID_PACKAGE_NAME_CHARS_PATTERN = /[^a-z0-9._~-]+/g;
+const PACKAGE_NAME_EDGE_DASHES_PATTERN = /^-+|-+$/g;
+export const getPackageName = (cwd) => {
+    const packageName = basename(cwd)
+        .toLowerCase()
+        .replace(INVALID_PACKAGE_NAME_CHARS_PATTERN, '-')
+        .replace(PACKAGE_NAME_EDGE_DASHES_PATTERN, '');
+    return packageName || FALLBACK_PACKAGE_NAME;
+};
+const hasProjectFile = async (cwd, fileName) => {
+    try {
+        await access(join(cwd, fileName));
+        return true;
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+};
+export const hasPackageJson = async (cwd) => hasProjectFile(cwd, PACKAGE_JSON);
+export const hasYarnLock = async (cwd) => hasProjectFile(cwd, YARN_LOCK);
+export const ensurePackageJson = async (cwd) => {
+    if (await hasPackageJson(cwd)) {
+        return;
+    }
+    await writeFile(join(cwd, PACKAGE_JSON), `${JSON.stringify({ name: getPackageName(cwd) }, null, 2)}\n`);
+};
+export const ensureYarnLock = async (cwd) => {
+    if (await hasYarnLock(cwd)) {
+        return;
+    }
+    await writeFile(join(cwd, YARN_LOCK), '');
+};

package/dist/runtime/bootstrap.d.ts

@@ -0,0 +1,2 @@
+export declare const updateBootstrapConfiguration: (content: string, yarnPath: string) => string;
+export declare const writeBootstrapConfiguration: (cwd: string, yarnPath: string) => Promise<void>;

package/dist/runtime/bootstrap.js

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const YARNRC_PATH = '.yarnrc.yml';
+const RAIJIN_NODE_LINKER = 'pnp';
+const TOP_LEVEL_NODE_LINKER_PATTERN = /^nodeLinker:.*$/gm;
+const TOP_LEVEL_YARN_PATH_PATTERN = /^yarnPath:.*$/gm;
+const readTextOrEmpty = async (path) => {
+    try {
+        return await readFile(path, 'utf-8');
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
+            return '';
+        }
+        throw error;
+    }
+};
+const removeTopLevelLine = (content, pattern) => content.replace(pattern, '').trim();
+export const updateBootstrapConfiguration = (content, yarnPath) => {
+    const normalizedContent = content.trimEnd();
+    const preservedContent = removeTopLevelLine(removeTopLevelLine(normalizedContent, TOP_LEVEL_NODE_LINKER_PATTERN), TOP_LEVEL_YARN_PATH_PATTERN);
+    const configuration = [`nodeLinker: ${RAIJIN_NODE_LINKER}`, `yarnPath: ${yarnPath}`];
+    if (preservedContent.length === 0) {
+        return `${configuration.join('\n')}\n`;
+    }
+    return `${preservedContent}\n${configuration.join('\n')}\n`;
+};
+export const writeBootstrapConfiguration = async (cwd, yarnPath) => {
+    const yarnrcPath = join(cwd, YARNRC_PATH);
+    const yarnrc = await readTextOrEmpty(yarnrcPath);
+    await writeFile(yarnrcPath, updateBootstrapConfiguration(yarnrc, yarnPath));
+};

package/dist/runtime/download.d.ts

@@ -0,0 +1,4 @@
+import type { RaijinRuntimeManifest } from './manifest.js';
+export type FetchLike = typeof fetch;
+export declare const fetchRaijinRuntimeManifest: (fetchImpl: FetchLike) => Promise<RaijinRuntimeManifest>;
+export declare const downloadRaijinRuntime: (fetchImpl: FetchLike, manifest: RaijinRuntimeManifest) => Promise<Buffer>;

package/dist/runtime/download.js

@@ -0,0 +1,30 @@
+import { RaijinRuntimeAssetDownloadException } from './exceptions/asset-download.js';
+import { RaijinRuntimeManifestDownloadException } from './exceptions/manifest-download.js';
+import { RAIJIN_RUNTIME_MANIFEST_URL } from './manifest.js';
+import { parseRaijinRuntimeManifest } from './manifest.js';
+const fetchJson = async (fetchImpl, url) => {
+    const response = await fetchImpl(url, {
+        headers: {
+            accept: 'application/json',
+            'user-agent': 'raijin-initializer',
+        },
+    });
+    if (!response.ok) {
+        throw new RaijinRuntimeManifestDownloadException(response.status);
+    }
+    return response.json();
+};
+const fetchBuffer = async (fetchImpl, url) => {
+    const response = await fetchImpl(url, {
+        headers: {
+            accept: 'application/octet-stream',
+            'user-agent': 'raijin-initializer',
+        },
+    });
+    if (!response.ok) {
+        throw new RaijinRuntimeAssetDownloadException(response.status);
+    }
+    return Buffer.from(await response.arrayBuffer());
+};
+export const fetchRaijinRuntimeManifest = async (fetchImpl) => parseRaijinRuntimeManifest(await fetchJson(fetchImpl, RAIJIN_RUNTIME_MANIFEST_URL));
+export const downloadRaijinRuntime = async (fetchImpl, manifest) => fetchBuffer(fetchImpl, manifest.assetUrl);

package/dist/runtime/exceptions/asset-download.d.ts

@@ -0,0 +1,3 @@
+export declare class RaijinRuntimeAssetDownloadException extends Error {
+    constructor(status: number);
+}

package/dist/runtime/exceptions/asset-download.js

@@ -0,0 +1,7 @@
+const createRuntimeAssetDownloadFailureMessage = (status) => `Failed to download Raijin runtime asset: ${status}`;
+export class RaijinRuntimeAssetDownloadException extends Error {
+    constructor(status) {
+        super(createRuntimeAssetDownloadFailureMessage(status));
+        this.name = 'RaijinRuntimeAssetDownloadException';
+    }
+}

package/dist/runtime/exceptions/digest-mismatch.d.ts

@@ -0,0 +1,3 @@
+export declare class RaijinRuntimeDigestMismatchException extends Error {
+    constructor(expected: string, actual: string);
+}

package/dist/runtime/exceptions/digest-mismatch.js

@@ -0,0 +1,7 @@
+const createRuntimeDigestMismatchMessage = (expected, actual) => `Downloaded Raijin runtime digest mismatch: expected ${expected}, got ${actual}`;
+export class RaijinRuntimeDigestMismatchException extends Error {
+    constructor(expected, actual) {
+        super(createRuntimeDigestMismatchMessage(expected, actual));
+        this.name = 'RaijinRuntimeDigestMismatchException';
+    }
+}

package/dist/runtime/exceptions/invalid-manifest.d.ts

@@ -0,0 +1,10 @@
+import type { RaijinRuntimeManifest } from '../manifest.js';
+export declare class InvalidRaijinRuntimeManifestException extends Error {
+    private constructor();
+    static expectedObject(): InvalidRaijinRuntimeManifestException;
+    static unsupportedSchemaVersion(): InvalidRaijinRuntimeManifestException;
+    static missingField(key: keyof RaijinRuntimeManifest): InvalidRaijinRuntimeManifestException;
+    static unexpectedPackage(packageName: string): InvalidRaijinRuntimeManifestException;
+    static unexpectedAsset(assetName: string): InvalidRaijinRuntimeManifestException;
+    static invalidSha256(): InvalidRaijinRuntimeManifestException;
+}

package/dist/runtime/exceptions/invalid-manifest.js

@@ -0,0 +1,30 @@
+const INVALID_RUNTIME_MANIFEST_OBJECT_MESSAGE = 'Invalid Raijin runtime manifest: expected object';
+const INVALID_RUNTIME_MANIFEST_SCHEMA_VERSION_MESSAGE = 'Invalid Raijin runtime manifest: unsupported schemaVersion';
+const INVALID_RUNTIME_MANIFEST_SHA256_MESSAGE = 'Invalid Raijin runtime manifest: invalid sha256';
+const createInvalidRuntimeManifestFieldMessage = (key) => `Invalid Raijin runtime manifest: missing ${key}`;
+const createInvalidRuntimeManifestPackageMessage = (packageName) => `Invalid Raijin runtime manifest: expected ${packageName}`;
+const createInvalidRuntimeManifestAssetMessage = (assetName) => `Invalid Raijin runtime manifest: expected ${assetName}`;
+export class InvalidRaijinRuntimeManifestException extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidRaijinRuntimeManifestException';
+    }
+    static expectedObject() {
+        return new InvalidRaijinRuntimeManifestException(INVALID_RUNTIME_MANIFEST_OBJECT_MESSAGE);
+    }
+    static unsupportedSchemaVersion() {
+        return new InvalidRaijinRuntimeManifestException(INVALID_RUNTIME_MANIFEST_SCHEMA_VERSION_MESSAGE);
+    }
+    static missingField(key) {
+        return new InvalidRaijinRuntimeManifestException(createInvalidRuntimeManifestFieldMessage(key));
+    }
+    static unexpectedPackage(packageName) {
+        return new InvalidRaijinRuntimeManifestException(createInvalidRuntimeManifestPackageMessage(packageName));
+    }
+    static unexpectedAsset(assetName) {
+        return new InvalidRaijinRuntimeManifestException(createInvalidRuntimeManifestAssetMessage(assetName));
+    }
+    static invalidSha256() {
+        return new InvalidRaijinRuntimeManifestException(INVALID_RUNTIME_MANIFEST_SHA256_MESSAGE);
+    }
+}

package/dist/runtime/exceptions/manifest-download.d.ts

@@ -0,0 +1,3 @@
+export declare class RaijinRuntimeManifestDownloadException extends Error {
+    constructor(status: number);
+}

package/dist/runtime/exceptions/manifest-download.js

@@ -0,0 +1,7 @@
+const createRuntimeManifestDownloadFailureMessage = (status) => `Failed to download Raijin runtime manifest: ${status}`;
+export class RaijinRuntimeManifestDownloadException extends Error {
+    constructor(status) {
+        super(createRuntimeManifestDownloadFailureMessage(status));
+        this.name = 'RaijinRuntimeManifestDownloadException';
+    }
+}

package/dist/runtime/index.d.ts

@@ -0,0 +1,13 @@
+export type { FetchLike } from './download.js';
+export type { InstallRaijinRuntimeOptions } from './installer.js';
+export type { RaijinRuntimeManifest } from './manifest.js';
+export { createSha256Digest } from './manifest.js';
+export { downloadRaijinRuntime } from './download.js';
+export { fetchRaijinRuntimeManifest } from './download.js';
+export { getRaijinRuntimeYarnPath } from './manifest.js';
+export { installRaijinRuntime } from './installer.js';
+export { parseRaijinRuntimeManifest } from './manifest.js';
+export { RAIJIN_RUNTIME_ASSET_NAME } from './manifest.js';
+export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from './manifest.js';
+export { RAIJIN_RUNTIME_MANIFEST_URL } from './manifest.js';
+export { RAIJIN_RUNTIME_PACKAGE_NAME } from './manifest.js';

package/dist/runtime/index.js

@@ -0,0 +1,10 @@
+export { createSha256Digest } from "./manifest.js";
+export { downloadRaijinRuntime } from "./download.js";
+export { fetchRaijinRuntimeManifest } from "./download.js";
+export { getRaijinRuntimeYarnPath } from "./manifest.js";
+export { installRaijinRuntime } from "./installer.js";
+export { parseRaijinRuntimeManifest } from "./manifest.js";
+export { RAIJIN_RUNTIME_ASSET_NAME } from "./manifest.js";
+export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from "./manifest.js";
+export { RAIJIN_RUNTIME_MANIFEST_URL } from "./manifest.js";
+export { RAIJIN_RUNTIME_PACKAGE_NAME } from "./manifest.js";

package/dist/runtime/installer.d.ts

@@ -0,0 +1,7 @@
+import type { FetchLike } from './download.js';
+import type { RaijinRuntimeManifest } from './manifest.js';
+export interface InstallRaijinRuntimeOptions {
+    cwd: string;
+    fetchImpl: FetchLike;
+}
+export declare const installRaijinRuntime: ({ cwd, fetchImpl, }: InstallRaijinRuntimeOptions) => Promise<RaijinRuntimeManifest>;

package/dist/runtime/installer.js

@@ -0,0 +1,24 @@
+import { mkdir } from 'node:fs/promises';
+import { writeFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { join } from 'node:path';
+import { RaijinRuntimeDigestMismatchException } from './exceptions/digest-mismatch.js';
+import { writeBootstrapConfiguration } from './bootstrap.js';
+import { downloadRaijinRuntime } from './download.js';
+import { fetchRaijinRuntimeManifest } from './download.js';
+import { createSha256Digest } from './manifest.js';
+import { getRaijinRuntimeYarnPath } from './manifest.js';
+export const installRaijinRuntime = async ({ cwd, fetchImpl, }) => {
+    const manifest = await fetchRaijinRuntimeManifest(fetchImpl);
+    const runtime = await downloadRaijinRuntime(fetchImpl, manifest);
+    const digest = createSha256Digest(runtime);
+    if (digest !== manifest.sha256) {
+        throw new RaijinRuntimeDigestMismatchException(manifest.sha256, digest);
+    }
+    const yarnPath = getRaijinRuntimeYarnPath(manifest);
+    const runtimePath = join(cwd, yarnPath);
+    await mkdir(dirname(runtimePath), { recursive: true });
+    await writeFile(runtimePath, runtime);
+    await writeBootstrapConfiguration(cwd, yarnPath);
+    return manifest;
+};

package/dist/runtime/manifest.d.ts

@@ -0,0 +1,16 @@
+export interface RaijinRuntimeManifest {
+    assetName: string;
+    assetUrl: string;
+    packageName: string;
+    schemaVersion: number;
+    sha256: string;
+    tagName: string;
+    version: string;
+}
+export declare const RAIJIN_RUNTIME_MANIFEST_URL = "https://raw.githubusercontent.com/atls/raijin/master/.yarn/releases/raijin-runtime.json";
+export declare const RAIJIN_RUNTIME_PACKAGE_NAME = "@atls/yarn-cli";
+export declare const RAIJIN_RUNTIME_ASSET_NAME = "yarn.mjs";
+export declare const RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION = 1;
+export declare const parseRaijinRuntimeManifest: (value: unknown) => RaijinRuntimeManifest;
+export declare const createSha256Digest: (data: Buffer) => string;
+export declare const getRaijinRuntimeYarnPath: (manifest: RaijinRuntimeManifest) => string;

package/dist/runtime/manifest.js

@@ -0,0 +1,46 @@
+import { createHash } from 'node:crypto';
+import { InvalidRaijinRuntimeManifestException } from './exceptions/invalid-manifest.js';
+export const RAIJIN_RUNTIME_MANIFEST_URL = 'https://raw.githubusercontent.com/atls/raijin/master/.yarn/releases/raijin-runtime.json';
+export const RAIJIN_RUNTIME_PACKAGE_NAME = '@atls/yarn-cli';
+export const RAIJIN_RUNTIME_ASSET_NAME = 'yarn.mjs';
+export const RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION = 1;
+const SHA256_PATTERN = /^[a-f0-9]{64}$/;
+const isRecord = (value) => typeof value === 'object' && value !== null;
+const assertManifestString = (manifest, key) => {
+    const value = manifest[key];
+    if (typeof value !== 'string' || value.length === 0) {
+        throw InvalidRaijinRuntimeManifestException.missingField(key);
+    }
+    return value;
+};
+export const parseRaijinRuntimeManifest = (value) => {
+    if (!isRecord(value)) {
+        throw InvalidRaijinRuntimeManifestException.expectedObject();
+    }
+    if (value.schemaVersion !== RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION) {
+        throw InvalidRaijinRuntimeManifestException.unsupportedSchemaVersion();
+    }
+    const packageName = assertManifestString(value, 'packageName');
+    const assetName = assertManifestString(value, 'assetName');
+    const sha256 = assertManifestString(value, 'sha256');
+    if (packageName !== RAIJIN_RUNTIME_PACKAGE_NAME) {
+        throw InvalidRaijinRuntimeManifestException.unexpectedPackage(RAIJIN_RUNTIME_PACKAGE_NAME);
+    }
+    if (assetName !== RAIJIN_RUNTIME_ASSET_NAME) {
+        throw InvalidRaijinRuntimeManifestException.unexpectedAsset(RAIJIN_RUNTIME_ASSET_NAME);
+    }
+    if (!SHA256_PATTERN.test(sha256)) {
+        throw InvalidRaijinRuntimeManifestException.invalidSha256();
+    }
+    return {
+        assetName,
+        assetUrl: assertManifestString(value, 'assetUrl'),
+        packageName,
+        schemaVersion: RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION,
+        sha256,
+        tagName: assertManifestString(value, 'tagName'),
+        version: assertManifestString(value, 'version'),
+    };
+};
+export const createSha256Digest = (data) => createHash('sha256').update(data).digest('hex');
+export const getRaijinRuntimeYarnPath = (manifest) => `.yarn/releases/raijin-yarn-${manifest.version}.mjs`;

package/dist/runtime.d.ts

@@ -0,0 +1,8 @@
+export type { RaijinRuntimeManifest } from './runtime/manifest.js';
+export { createSha256Digest } from './runtime/manifest.js';
+export { getRaijinRuntimeYarnPath } from './runtime/manifest.js';
+export { parseRaijinRuntimeManifest } from './runtime/manifest.js';
+export { RAIJIN_RUNTIME_ASSET_NAME } from './runtime/manifest.js';
+export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from './runtime/manifest.js';
+export { RAIJIN_RUNTIME_MANIFEST_URL } from './runtime/manifest.js';
+export { RAIJIN_RUNTIME_PACKAGE_NAME } from './runtime/manifest.js';

package/dist/runtime.js

@@ -0,0 +1,7 @@
+export { createSha256Digest } from "./runtime/manifest.js";
+export { getRaijinRuntimeYarnPath } from "./runtime/manifest.js";
+export { parseRaijinRuntimeManifest } from "./runtime/manifest.js";
+export { RAIJIN_RUNTIME_ASSET_NAME } from "./runtime/manifest.js";
+export { RAIJIN_RUNTIME_MANIFEST_SCHEMA_VERSION } from "./runtime/manifest.js";
+export { RAIJIN_RUNTIME_MANIFEST_URL } from "./runtime/manifest.js";
+export { RAIJIN_RUNTIME_PACKAGE_NAME } from "./runtime/manifest.js";

package/dist/yarn/command.d.ts

@@ -0,0 +1,3 @@
+import type { YarnCommandRunner } from './runner.js';
+export declare const createYarnCommandEnvironment: (environment?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const runYarnCommand: YarnCommandRunner;

package/dist/yarn/command.js

@@ -0,0 +1,22 @@
+import { spawn } from 'node:child_process';
+import { RaijinYarnCommandException } from './exceptions/command.js';
+export const createYarnCommandEnvironment = (environment = process.env) => {
+    const yarnEnvironment = { ...environment };
+    delete yarnEnvironment.YARN_IGNORE_PATH;
+    return yarnEnvironment;
+};
+export const runYarnCommand = async (args, cwd) => {
+    const child = spawn('yarn', args, {
+        cwd,
+        env: createYarnCommandEnvironment(),
+        shell: process.platform === 'win32',
+        stdio: 'inherit',
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.once('error', reject);
+        child.once('exit', resolve);
+    });
+    if (exitCode !== 0) {
+        throw new RaijinYarnCommandException(args);
+    }
+};

package/dist/yarn/exceptions/command.d.ts

@@ -0,0 +1,3 @@
+export declare class RaijinYarnCommandException extends Error {
+    constructor(args: Array<string>);
+}

package/dist/yarn/exceptions/command.js

@@ -0,0 +1,7 @@
+const createYarnCommandFailureMessage = (args) => `Command failed: yarn ${args.join(' ')}`;
+export class RaijinYarnCommandException extends Error {
+    constructor(args) {
+        super(createYarnCommandFailureMessage(args));
+        this.name = 'RaijinYarnCommandException';
+    }
+}

package/dist/yarn/index.d.ts

@@ -0,0 +1,3 @@
+export type { YarnCommandRunner } from './runner.js';
+export { createYarnCommandEnvironment } from './command.js';
+export { runYarnCommand } from './command.js';

package/dist/yarn/index.js

@@ -0,0 +1,2 @@
+export { createYarnCommandEnvironment } from "./command.js";
+export { runYarnCommand } from "./command.js";

package/dist/yarn/runner.d.ts

@@ -0,0 +1 @@
+export type YarnCommandRunner = (args: Array<string>, cwd: string) => Promise<void>;

package/dist/yarn/runner.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@atls/raijin",
+  "version": "0.2.0",
+  "license": "BSD-3-Clause",
+  "type": "module",
+  "exports": {
+    "./package.json": "./package.json",
+    "./runtime": {
+      "import": "./dist/runtime.js",
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    },
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "main": "dist/index.js",
+  "bin": {
+    "raijin": "./bin/raijin.mjs"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build": "yarn library build",
+    "prepack": "yarn run build",
+    "postpack": "rm -rf dist"
+  },
+  "devDependencies": {
+    "@types/node": "24.12.2"
+  },
+  "publishConfig": {
+    "access": "public",
+    "bin": {
+      "raijin": "./bin/raijin.mjs"
+    },
+    "exports": {
+      "./package.json": "./package.json",
+      "./runtime": {
+        "import": "./dist/runtime.js",
+        "types": "./dist/runtime.d.ts",
+        "default": "./dist/runtime.js"
+      },
+      ".": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts"
+  },
+  "types": "dist/index.d.ts"
+}