@opys/runtime 0.1.2

package/README.md

@@ -0,0 +1,138 @@
+# @opys/installer
+
+Programmatic install and launch for Opys manifests. Downloads artifacts in parallel, verifies integrity, extracts natives, and spawns the JVM.
+
+## Install
+
+```sh
+npm install @opys/installer @opys/core
+```
+
+## Manifest sources
+
+Both `install` and `launch` accept a **manifest source** as their first argument:
+
+| Value             | Example                                    |
+| ----------------- | ------------------------------------------ |
+| File path string  | `'opys.json'`                              |
+| HTTPS URL object  | `new URL('https://example.com/pack.json')` |
+| Parsed `Manifest` | object returned by `resolveManifest`       |
+
+---
+
+## `install(source, options?)`
+
+Streams missing artifacts to `<finalPath>.partial` then renames them into place; extracts zips for artifacts with `extract` rules. Already-cached artifacts (path exists on disk) are skipped. A failed integrity check throws `IntegrityError` immediately.
+
+```ts
+import { install } from '@opys/installer';
+
+await install('opys.json', {
+  vars: {
+    root: '/opt/minecraft/1.20.1',
+    username: 'Player',
+    uuid: '...',
+    token: '...',
+  },
+  concurrency: 16,
+  onProgress(p) {
+    if (p.phase === 'download') {
+      process.stderr.write(`  ${p.fetched}/${p.total}\r`);
+    }
+  },
+});
+```
+
+**Options**
+
+| Option            | Type                           | Default | Description                        |
+| ----------------- | ------------------------------ | ------- | ---------------------------------- |
+| `platform`        | `OsOptions`                    | auto    | Override OS/arch detection         |
+| `vars`            | `Record<string, string>`       | `{}`    | Extra vars; override manifest vars |
+| `concurrency`     | `number`                       | `8`     | Max parallel downloads             |
+| `onProgress`      | `(p: InstallProgress) => void` | —       | Progress callback                  |
+| `verifyIntegrity` | `boolean`                      | `true`  | Skip hash checks if `false`        |
+
+**`InstallProgress`**
+
+```ts
+type InstallProgress =
+  | { phase: 'resolve' }
+  | { phase: 'download'; fetched: number; total: number; skipped: number }
+  | { phase: 'verify' }
+  | { phase: 'extract'; count: number };
+```
+
+---
+
+## `launch(source, options?)`
+
+Runs `install` then spawns the process described by the manifest's launch config. Returns a `ChildProcess` — the caller decides how to wait on it.
+
+Pass `install: false` to skip installation.
+
+```ts
+import { launch } from '@opys/installer';
+
+const child = await launch('opys.json', {
+  vars: {
+    root: '/opt/minecraft/1.20.1',
+    username: 'Player',
+    uuid: '...',
+    token: '...',
+  },
+  install: { onProgress: (p) => console.log(p) },
+});
+
+await new Promise<void>((resolve, reject) => {
+  child.on('exit', (code) =>
+    code === 0 || code === null ? resolve() : reject(new Error(`exit ${code}`)),
+  );
+  child.on('error', reject);
+});
+```
+
+**Options**
+
+| Option     | Type                      | Default | Description                            |
+| ---------- | ------------------------- | ------- | -------------------------------------- |
+| `platform` | `OsOptions`               | auto    | Override OS/arch detection             |
+| `vars`     | `Record<string, string>`  | `{}`    | Extra vars; typically auth credentials |
+| `install`  | `InstallOptions \| false` | `{}`    | Install options, or `false` to skip    |
+| `log`      | `(level, msg) => void`    | —       | Debug/warn logger for spawn details    |
+
+---
+
+## `resolveManifest(source)`
+
+Resolves any manifest source to a `Manifest` object.
+
+```ts
+import { resolveManifest } from '@opys/installer';
+
+const manifest = await resolveManifest('opys.json');
+console.log(manifest.artifacts.length);
+```
+
+---
+
+## `currentPlatform()`
+
+Returns the `OsOptions` for the current host.
+
+```ts
+import { currentPlatform } from '@opys/installer';
+
+const platform = currentPlatform();
+// { name: 'linux', arch: 'x64', version: '...' }
+```
+
+---
+
+## Error types
+
+| Class             | When                               |
+| ----------------- | ---------------------------------- |
+| `NetworkError`    | HTTP download failure              |
+| `IntegrityError`  | Hash mismatch on a downloaded file |
+| `ExtractionError` | ZIP extraction failure             |

package/dist/index.cjs

@@ -0,0 +1,129 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_child_process = require("node:child_process");
+let _opys_runtime_binding = require("@opys/runtime-binding");
+_opys_runtime_binding = __toESM(_opys_runtime_binding);
+
+//#region lib/index.ts
+/**
+* `@opys/runtime` — install + launch executor. Behaviors are backed by the
+* Rust `opys-runtime` crate (via napi-rs); the TS surface wraps the
+* binding with a Node `child_process.spawn` for `launch`, and translates
+* the napi-thrown messages back into the typed `NetworkError` /
+* `IntegrityError` / `ExtractionError` classes consumers still
+* `instanceof`-check.
+*/
+/**
+* Compat error classes. The Rust bridge currently throws
+* `napi::Error::from_reason(msg)` with the discriminant baked into the
+* message ("HTTP …", "Integrity check failed: …", "Failed to extract …");
+* `translateError` re-wraps those into these classes so consumers using
+* `instanceof` keep working. Q10's `code`-discriminant model is the
+* follow-up — when the Rust side emits structured errors, these classes
+* either gain a `code` field or get replaced wholesale.
+*/
+var NetworkError = class extends Error {
+	kind = "network";
+	constructor(url, status, message) {
+		super(message);
+		this.url = url;
+		this.status = status;
+		this.name = "NetworkError";
+	}
+};
+var IntegrityError = class extends Error {
+	kind = "integrity";
+	constructor(paths) {
+		super(`Integrity check failed: ${paths.join(", ")}`);
+		this.paths = paths;
+		this.name = "IntegrityError";
+	}
+};
+var ExtractionError = class extends Error {
+	kind = "extraction";
+	constructor(artifactPath, options) {
+		super(`Failed to extract ${artifactPath}`, options);
+		this.artifactPath = artifactPath;
+		this.name = "ExtractionError";
+	}
+};
+function translateError(err) {
+	if (!(err instanceof Error)) return err;
+	const msg = err.message;
+	let m = /^HTTP (\d+) downloading (\S+)/.exec(msg);
+	if (m) return new NetworkError(m[2], Number(m[1]), msg);
+	m = /^Integrity check failed:\s*(.+)$/.exec(msg);
+	if (m) return new IntegrityError(m[1].split(",").map((s) => s.trim()).filter(Boolean));
+	m = /^Failed to extract (\S+):/.exec(msg);
+	if (m) return new ExtractionError(m[1], { cause: err });
+	return err;
+}
+async function install(manifest, options = {}) {
+	const { onProgress, ...rest } = options;
+	const bridge = onProgress ? (event) => onProgress(event) : void 0;
+	try {
+		await _opys_runtime_binding.install(manifest, rest, bridge);
+	} catch (err) {
+		throw translateError(err);
+	}
+}
+async function buildLaunch(manifest, options = {}) {
+	try {
+		return await _opys_runtime_binding.buildLaunch(manifest, options);
+	} catch (err) {
+		throw translateError(err);
+	}
+}
+async function launch(manifest, options = {}) {
+	const { install: installOpts = {}, cwd, ...launchRest } = options;
+	if (installOpts !== false) await install(manifest, installOpts);
+	const spec = await buildLaunch(manifest, {
+		...launchRest,
+		cwd
+	});
+	return (0, node_child_process.spawn)(spec.command, spec.args, {
+		cwd: spec.workdir,
+		env: {
+			...process.env,
+			...spec.envs
+		},
+		stdio: "inherit"
+	});
+}
+const currentPlatform = _opys_runtime_binding.currentPlatform;
+
+//#endregion
+exports.ExtractionError = ExtractionError;
+exports.IntegrityError = IntegrityError;
+exports.NetworkError = NetworkError;
+exports.buildLaunch = buildLaunch;
+exports.currentPlatform = currentPlatform;
+exports.install = install;
+exports.launch = launch;
+exports.translateError = translateError;

package/dist/index.d.cts

@@ -0,0 +1,89 @@
+import { ChildProcess } from "node:child_process";
+import * as napi from "@opys/runtime-binding";
+
+//#region lib/index.d.ts
+/**
+ * Discriminated by `phase`. The Rust bridge populates only the fields
+ * relevant to each phase; the union encodes that contract so consumers can
+ * narrow on `phase` and access the populated fields without optional-chain
+ * dances.
+ */
+type InstallProgress = {
+  phase: 'resolve';
+  resolved: number;
+} | {
+  phase: 'download';
+  fetched: number;
+  total: number;
+  skipped: number;
+} | {
+  phase: 'download:start';
+  path: string;
+  total: number;
+} | {
+  phase: 'download:bytes';
+  path: string;
+  bytes: number;
+} | {
+  phase: 'download:done';
+  path: string;
+} | {
+  phase: 'verify';
+} | {
+  phase: 'extract';
+  count: number;
+} | {
+  phase: 'sweep';
+  removed: number;
+};
+interface InstallOptions {
+  platform?: napi.OsOptions;
+  vars?: Record<string, string>;
+  concurrency?: number;
+  verifyIntegrity?: boolean;
+  features?: string[];
+  onProgress?: (p: InstallProgress) => void;
+}
+interface LaunchOptions {
+  platform?: napi.OsOptions;
+  features?: string[];
+  vars?: Record<string, string>;
+  cwd?: string;
+  install?: InstallOptions | false;
+}
+/**
+ * Compat error classes. The Rust bridge currently throws
+ * `napi::Error::from_reason(msg)` with the discriminant baked into the
+ * message ("HTTP …", "Integrity check failed: …", "Failed to extract …");
+ * `translateError` re-wraps those into these classes so consumers using
+ * `instanceof` keep working. Q10's `code`-discriminant model is the
+ * follow-up — when the Rust side emits structured errors, these classes
+ * either gain a `code` field or get replaced wholesale.
+ */
+declare class NetworkError extends Error {
+  readonly url: string;
+  readonly status: number;
+  readonly kind: "network";
+  constructor(url: string, status: number, message: string);
+}
+declare class IntegrityError extends Error {
+  readonly paths: string[];
+  readonly kind: "integrity";
+  constructor(paths: string[]);
+}
+declare class ExtractionError extends Error {
+  readonly artifactPath: string;
+  readonly kind: "extraction";
+  constructor(artifactPath: string, options?: ErrorOptions);
+}
+type InstallError = NetworkError | IntegrityError | ExtractionError;
+declare function translateError(err: unknown): unknown;
+declare function install(manifest: unknown, options?: InstallOptions): Promise<void>;
+declare function buildLaunch(manifest: unknown, options?: Omit<LaunchOptions, 'install'>): Promise<napi.LaunchSpec>;
+declare function launch(manifest: unknown, options?: LaunchOptions): Promise<ChildProcess>;
+declare const currentPlatform: any;
+type OsOptions = napi.OsOptions;
+type LaunchSpec = napi.LaunchSpec;
+//#endregion
+export { ExtractionError, InstallError, InstallOptions, InstallProgress, IntegrityError, LaunchOptions, LaunchSpec, NetworkError, OsOptions, buildLaunch, currentPlatform, install, launch, translateError };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../lib/index.ts"],"mappings":";;;;;;;;;;KAkBY,eAAA;EACN,KAAA;EAAkB,QAAA;AAAA;EAClB,KAAA;EAAmB,OAAA;EAAiB,KAAA;EAAe,OAAA;AAAA;EACnD,KAAA;EAAyB,IAAA;EAAc,KAAA;AAAA;EACvC,KAAA;EAAyB,IAAA;EAAc,KAAA;AAAA;EACvC,KAAA;EAAwB,IAAA;AAAA;EACxB,KAAA;AAAA;EACA,KAAA;EAAkB,KAAA;AAAA;EAClB,KAAA;EAAgB,OAAA;AAAA;AAAA,UAEL,cAAA;EACf,QAAA,GAAW,IAAA,CAAK,SAAA;EAChB,IAAA,GAAO,MAAA;EACP,WAAA;EACA,eAAA;EACA,QAAA;EACA,UAAA,IAAc,CAAA,EAAG,eAAA;AAAA;AAAA,UAGF,aAAA;EACf,QAAA,GAAW,IAAA,CAAK,SAAA;EAChB,QAAA;EACA,IAAA,GAAO,MAAA;EACP,GAAA;EACA,OAAA,GAAU,cAAA;AAAA;;;;;;;;;;cAYC,YAAA,SAAqB,KAAA;EAAA,SAGrB,GAAA;EAAA,SACA,MAAA;EAAA,SAHF,IAAA;cAEE,GAAA,UACA,MAAA,UACT,OAAA;AAAA;AAAA,cAMS,cAAA,SAAuB,KAAA;EAAA,SAEb,KAAA;EAAA,SADZ,IAAA;cACY,KAAA;AAAA;AAAA,cAKV,eAAA,SAAwB,KAAA;EAAA,SAGxB,YAAA;EAAA,SAFF,IAAA;cAEE,YAAA,UACT,OAAA,GAAU,YAAA;AAAA;AAAA,KAMF,YAAA,GAAe,YAAA,GAAe,cAAA,GAAiB,eAAA;AAAA,iBAE3C,cAAA,CAAe,GAAA;AAAA,iBAkBT,OAAA,CACpB,QAAA,WACA,OAAA,GAAS,cAAA,GACR,OAAA;AAAA,iBAYmB,WAAA,CACpB,QAAA,WACA,OAAA,GAAS,IAAA,CAAK,aAAA,eACb,OAAA,CAAQ,IAAA,CAAK,UAAA;AAAA,iBAQM,MAAA,CACpB,QAAA,WACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,YAAA;AAAA,cAaE,eAAA;AAAA,KACD,SAAA,GAAY,IAAA,CAAK,SAAA;AAAA,KACjB,UAAA,GAAa,IAAA,CAAK,UAAA"}

package/dist/index.d.mts

@@ -0,0 +1,89 @@
+import { ChildProcess } from "node:child_process";
+import * as napi from "@opys/runtime-binding";
+
+//#region lib/index.d.ts
+/**
+ * Discriminated by `phase`. The Rust bridge populates only the fields
+ * relevant to each phase; the union encodes that contract so consumers can
+ * narrow on `phase` and access the populated fields without optional-chain
+ * dances.
+ */
+type InstallProgress = {
+  phase: 'resolve';
+  resolved: number;
+} | {
+  phase: 'download';
+  fetched: number;
+  total: number;
+  skipped: number;
+} | {
+  phase: 'download:start';
+  path: string;
+  total: number;
+} | {
+  phase: 'download:bytes';
+  path: string;
+  bytes: number;
+} | {
+  phase: 'download:done';
+  path: string;
+} | {
+  phase: 'verify';
+} | {
+  phase: 'extract';
+  count: number;
+} | {
+  phase: 'sweep';
+  removed: number;
+};
+interface InstallOptions {
+  platform?: napi.OsOptions;
+  vars?: Record<string, string>;
+  concurrency?: number;
+  verifyIntegrity?: boolean;
+  features?: string[];
+  onProgress?: (p: InstallProgress) => void;
+}
+interface LaunchOptions {
+  platform?: napi.OsOptions;
+  features?: string[];
+  vars?: Record<string, string>;
+  cwd?: string;
+  install?: InstallOptions | false;
+}
+/**
+ * Compat error classes. The Rust bridge currently throws
+ * `napi::Error::from_reason(msg)` with the discriminant baked into the
+ * message ("HTTP …", "Integrity check failed: …", "Failed to extract …");
+ * `translateError` re-wraps those into these classes so consumers using
+ * `instanceof` keep working. Q10's `code`-discriminant model is the
+ * follow-up — when the Rust side emits structured errors, these classes
+ * either gain a `code` field or get replaced wholesale.
+ */
+declare class NetworkError extends Error {
+  readonly url: string;
+  readonly status: number;
+  readonly kind: "network";
+  constructor(url: string, status: number, message: string);
+}
+declare class IntegrityError extends Error {
+  readonly paths: string[];
+  readonly kind: "integrity";
+  constructor(paths: string[]);
+}
+declare class ExtractionError extends Error {
+  readonly artifactPath: string;
+  readonly kind: "extraction";
+  constructor(artifactPath: string, options?: ErrorOptions);
+}
+type InstallError = NetworkError | IntegrityError | ExtractionError;
+declare function translateError(err: unknown): unknown;
+declare function install(manifest: unknown, options?: InstallOptions): Promise<void>;
+declare function buildLaunch(manifest: unknown, options?: Omit<LaunchOptions, 'install'>): Promise<napi.LaunchSpec>;
+declare function launch(manifest: unknown, options?: LaunchOptions): Promise<ChildProcess>;
+declare const currentPlatform: any;
+type OsOptions = napi.OsOptions;
+type LaunchSpec = napi.LaunchSpec;
+//#endregion
+export { ExtractionError, InstallError, InstallOptions, InstallProgress, IntegrityError, LaunchOptions, LaunchSpec, NetworkError, OsOptions, buildLaunch, currentPlatform, install, launch, translateError };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../lib/index.ts"],"mappings":";;;;;;;;;;KAkBY,eAAA;EACN,KAAA;EAAkB,QAAA;AAAA;EAClB,KAAA;EAAmB,OAAA;EAAiB,KAAA;EAAe,OAAA;AAAA;EACnD,KAAA;EAAyB,IAAA;EAAc,KAAA;AAAA;EACvC,KAAA;EAAyB,IAAA;EAAc,KAAA;AAAA;EACvC,KAAA;EAAwB,IAAA;AAAA;EACxB,KAAA;AAAA;EACA,KAAA;EAAkB,KAAA;AAAA;EAClB,KAAA;EAAgB,OAAA;AAAA;AAAA,UAEL,cAAA;EACf,QAAA,GAAW,IAAA,CAAK,SAAA;EAChB,IAAA,GAAO,MAAA;EACP,WAAA;EACA,eAAA;EACA,QAAA;EACA,UAAA,IAAc,CAAA,EAAG,eAAA;AAAA;AAAA,UAGF,aAAA;EACf,QAAA,GAAW,IAAA,CAAK,SAAA;EAChB,QAAA;EACA,IAAA,GAAO,MAAA;EACP,GAAA;EACA,OAAA,GAAU,cAAA;AAAA;;;;;;;;;;cAYC,YAAA,SAAqB,KAAA;EAAA,SAGrB,GAAA;EAAA,SACA,MAAA;EAAA,SAHF,IAAA;cAEE,GAAA,UACA,MAAA,UACT,OAAA;AAAA;AAAA,cAMS,cAAA,SAAuB,KAAA;EAAA,SAEb,KAAA;EAAA,SADZ,IAAA;cACY,KAAA;AAAA;AAAA,cAKV,eAAA,SAAwB,KAAA;EAAA,SAGxB,YAAA;EAAA,SAFF,IAAA;cAEE,YAAA,UACT,OAAA,GAAU,YAAA;AAAA;AAAA,KAMF,YAAA,GAAe,YAAA,GAAe,cAAA,GAAiB,eAAA;AAAA,iBAE3C,cAAA,CAAe,GAAA;AAAA,iBAkBT,OAAA,CACpB,QAAA,WACA,OAAA,GAAS,cAAA,GACR,OAAA;AAAA,iBAYmB,WAAA,CACpB,QAAA,WACA,OAAA,GAAS,IAAA,CAAK,aAAA,eACb,OAAA,CAAQ,IAAA,CAAK,UAAA;AAAA,iBAQM,MAAA,CACpB,QAAA,WACA,OAAA,GAAS,aAAA,GACR,OAAA,CAAQ,YAAA;AAAA,cAaE,eAAA;AAAA,KACD,SAAA,GAAY,IAAA,CAAK,SAAA;AAAA,KACjB,UAAA,GAAa,IAAA,CAAK,UAAA"}

package/dist/index.mjs

@@ -0,0 +1,94 @@
+import { spawn } from "node:child_process";
+import * as napi from "@opys/runtime-binding";
+
+//#region lib/index.ts
+/**
+* `@opys/runtime` — install + launch executor. Behaviors are backed by the
+* Rust `opys-runtime` crate (via napi-rs); the TS surface wraps the
+* binding with a Node `child_process.spawn` for `launch`, and translates
+* the napi-thrown messages back into the typed `NetworkError` /
+* `IntegrityError` / `ExtractionError` classes consumers still
+* `instanceof`-check.
+*/
+/**
+* Compat error classes. The Rust bridge currently throws
+* `napi::Error::from_reason(msg)` with the discriminant baked into the
+* message ("HTTP …", "Integrity check failed: …", "Failed to extract …");
+* `translateError` re-wraps those into these classes so consumers using
+* `instanceof` keep working. Q10's `code`-discriminant model is the
+* follow-up — when the Rust side emits structured errors, these classes
+* either gain a `code` field or get replaced wholesale.
+*/
+var NetworkError = class extends Error {
+	kind = "network";
+	constructor(url, status, message) {
+		super(message);
+		this.url = url;
+		this.status = status;
+		this.name = "NetworkError";
+	}
+};
+var IntegrityError = class extends Error {
+	kind = "integrity";
+	constructor(paths) {
+		super(`Integrity check failed: ${paths.join(", ")}`);
+		this.paths = paths;
+		this.name = "IntegrityError";
+	}
+};
+var ExtractionError = class extends Error {
+	kind = "extraction";
+	constructor(artifactPath, options) {
+		super(`Failed to extract ${artifactPath}`, options);
+		this.artifactPath = artifactPath;
+		this.name = "ExtractionError";
+	}
+};
+function translateError(err) {
+	if (!(err instanceof Error)) return err;
+	const msg = err.message;
+	let m = /^HTTP (\d+) downloading (\S+)/.exec(msg);
+	if (m) return new NetworkError(m[2], Number(m[1]), msg);
+	m = /^Integrity check failed:\s*(.+)$/.exec(msg);
+	if (m) return new IntegrityError(m[1].split(",").map((s) => s.trim()).filter(Boolean));
+	m = /^Failed to extract (\S+):/.exec(msg);
+	if (m) return new ExtractionError(m[1], { cause: err });
+	return err;
+}
+async function install(manifest, options = {}) {
+	const { onProgress, ...rest } = options;
+	const bridge = onProgress ? (event) => onProgress(event) : void 0;
+	try {
+		await napi.install(manifest, rest, bridge);
+	} catch (err) {
+		throw translateError(err);
+	}
+}
+async function buildLaunch(manifest, options = {}) {
+	try {
+		return await napi.buildLaunch(manifest, options);
+	} catch (err) {
+		throw translateError(err);
+	}
+}
+async function launch(manifest, options = {}) {
+	const { install: installOpts = {}, cwd, ...launchRest } = options;
+	if (installOpts !== false) await install(manifest, installOpts);
+	const spec = await buildLaunch(manifest, {
+		...launchRest,
+		cwd
+	});
+	return spawn(spec.command, spec.args, {
+		cwd: spec.workdir,
+		env: {
+			...process.env,
+			...spec.envs
+		},
+		stdio: "inherit"
+	});
+}
+const currentPlatform = napi.currentPlatform;
+
+//#endregion
+export { ExtractionError, IntegrityError, NetworkError, buildLaunch, currentPlatform, install, launch, translateError };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../lib/index.ts"],"sourcesContent":["/**\n * `@opys/runtime` — install + launch executor. Behaviors are backed by the\n * Rust `opys-runtime` crate (via napi-rs); the TS surface wraps the\n * binding with a Node `child_process.spawn` for `launch`, and translates\n * the napi-thrown messages back into the typed `NetworkError` /\n * `IntegrityError` / `ExtractionError` classes consumers still\n * `instanceof`-check.\n */\n\nimport { spawn, type ChildProcess } from 'node:child_process';\nimport * as napi from '@opys/runtime-binding';\n\n/**\n * Discriminated by `phase`. The Rust bridge populates only the fields\n * relevant to each phase; the union encodes that contract so consumers can\n * narrow on `phase` and access the populated fields without optional-chain\n * dances.\n */\nexport type InstallProgress =\n  | { phase: 'resolve'; resolved: number }\n  | { phase: 'download'; fetched: number; total: number; skipped: number }\n  | { phase: 'download:start'; path: string; total: number }\n  | { phase: 'download:bytes'; path: string; bytes: number }\n  | { phase: 'download:done'; path: string }\n  | { phase: 'verify' }\n  | { phase: 'extract'; count: number }\n  | { phase: 'sweep'; removed: number };\n\nexport interface InstallOptions {\n  platform?: napi.OsOptions;\n  vars?: Record<string, string>;\n  concurrency?: number;\n  verifyIntegrity?: boolean;\n  features?: string[];\n  onProgress?: (p: InstallProgress) => void;\n}\n\nexport interface LaunchOptions {\n  platform?: napi.OsOptions;\n  features?: string[];\n  vars?: Record<string, string>;\n  cwd?: string;\n  install?: InstallOptions | false;\n}\n\n/**\n * Compat error classes. The Rust bridge currently throws\n * `napi::Error::from_reason(msg)` with the discriminant baked into the\n * message (\"HTTP …\", \"Integrity check failed: …\", \"Failed to extract …\");\n * `translateError` re-wraps those into these classes so consumers using\n * `instanceof` keep working. Q10's `code`-discriminant model is the\n * follow-up — when the Rust side emits structured errors, these classes\n * either gain a `code` field or get replaced wholesale.\n */\nexport class NetworkError extends Error {\n  readonly kind = 'network' as const;\n  constructor(\n    readonly url: string,\n    readonly status: number,\n    message: string,\n  ) {\n    super(message);\n    this.name = 'NetworkError';\n  }\n}\nexport class IntegrityError extends Error {\n  readonly kind = 'integrity' as const;\n  constructor(readonly paths: string[]) {\n    super(`Integrity check failed: ${paths.join(', ')}`);\n    this.name = 'IntegrityError';\n  }\n}\nexport class ExtractionError extends Error {\n  readonly kind = 'extraction' as const;\n  constructor(\n    readonly artifactPath: string,\n    options?: ErrorOptions,\n  ) {\n    super(`Failed to extract ${artifactPath}`, options);\n    this.name = 'ExtractionError';\n  }\n}\nexport type InstallError = NetworkError | IntegrityError | ExtractionError;\n\nexport function translateError(err: unknown): unknown {\n  if (!(err instanceof Error)) return err;\n  const msg = err.message;\n  let m = /^HTTP (\\d+) downloading (\\S+)/.exec(msg);\n  if (m) return new NetworkError(m[2]!, Number(m[1]!), msg);\n  m = /^Integrity check failed:\\s*(.+)$/.exec(msg);\n  if (m) {\n    const paths = m[1]!\n      .split(',')\n      .map((s) => s.trim())\n      .filter(Boolean);\n    return new IntegrityError(paths);\n  }\n  m = /^Failed to extract (\\S+):/.exec(msg);\n  if (m) return new ExtractionError(m[1]!, { cause: err });\n  return err;\n}\n\nexport async function install(\n  manifest: unknown,\n  options: InstallOptions = {},\n): Promise<void> {\n  const { onProgress, ...rest } = options;\n  const bridge = onProgress\n    ? (event: unknown) => onProgress(event as InstallProgress)\n    : undefined;\n  try {\n    await napi.install(manifest, rest, bridge);\n  } catch (err) {\n    throw translateError(err);\n  }\n}\n\nexport async function buildLaunch(\n  manifest: unknown,\n  options: Omit<LaunchOptions, 'install'> = {},\n): Promise<napi.LaunchSpec> {\n  try {\n    return await napi.buildLaunch(manifest, options);\n  } catch (err) {\n    throw translateError(err);\n  }\n}\n\nexport async function launch(\n  manifest: unknown,\n  options: LaunchOptions = {},\n): Promise<ChildProcess> {\n  const { install: installOpts = {}, cwd, ...launchRest } = options;\n  if (installOpts !== false) {\n    await install(manifest, installOpts);\n  }\n  const spec = await buildLaunch(manifest, { ...launchRest, cwd });\n  return spawn(spec.command, spec.args, {\n    cwd: spec.workdir,\n    env: { ...process.env, ...spec.envs },\n    stdio: 'inherit',\n  });\n}\n\nexport const currentPlatform = napi.currentPlatform;\nexport type OsOptions = napi.OsOptions;\nexport type LaunchSpec = napi.LaunchSpec;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsDA,IAAa,eAAb,cAAkC,MAAM;CACtC,AAAS,OAAO;CAChB,YACE,AAAS,KACT,AAAS,QACT,SACA;AACA,QAAM,QAAQ;EAJL;EACA;AAIT,OAAK,OAAO;;;AAGhB,IAAa,iBAAb,cAAoC,MAAM;CACxC,AAAS,OAAO;CAChB,YAAY,AAAS,OAAiB;AACpC,QAAM,2BAA2B,MAAM,KAAK,KAAK,GAAG;EADjC;AAEnB,OAAK,OAAO;;;AAGhB,IAAa,kBAAb,cAAqC,MAAM;CACzC,AAAS,OAAO;CAChB,YACE,AAAS,cACT,SACA;AACA,QAAM,qBAAqB,gBAAgB,QAAQ;EAH1C;AAIT,OAAK,OAAO;;;AAKhB,SAAgB,eAAe,KAAuB;AACpD,KAAI,EAAE,eAAe,OAAQ,QAAO;CACpC,MAAM,MAAM,IAAI;CAChB,IAAI,IAAI,gCAAgC,KAAK,IAAI;AACjD,KAAI,EAAG,QAAO,IAAI,aAAa,EAAE,IAAK,OAAO,EAAE,GAAI,EAAE,IAAI;AACzD,KAAI,mCAAmC,KAAK,IAAI;AAChD,KAAI,EAKF,QAAO,IAAI,eAJG,EAAE,GACb,MAAM,IAAI,CACV,KAAK,MAAM,EAAE,MAAM,CAAC,CACpB,OAAO,QAAQ,CACc;AAElC,KAAI,4BAA4B,KAAK,IAAI;AACzC,KAAI,EAAG,QAAO,IAAI,gBAAgB,EAAE,IAAK,EAAE,OAAO,KAAK,CAAC;AACxD,QAAO;;AAGT,eAAsB,QACpB,UACA,UAA0B,EAAE,EACb;CACf,MAAM,EAAE,YAAY,GAAG,SAAS;CAChC,MAAM,SAAS,cACV,UAAmB,WAAW,MAAyB,GACxD;AACJ,KAAI;AACF,QAAM,KAAK,QAAQ,UAAU,MAAM,OAAO;UACnC,KAAK;AACZ,QAAM,eAAe,IAAI;;;AAI7B,eAAsB,YACpB,UACA,UAA0C,EAAE,EAClB;AAC1B,KAAI;AACF,SAAO,MAAM,KAAK,YAAY,UAAU,QAAQ;UACzC,KAAK;AACZ,QAAM,eAAe,IAAI;;;AAI7B,eAAsB,OACpB,UACA,UAAyB,EAAE,EACJ;CACvB,MAAM,EAAE,SAAS,cAAc,EAAE,EAAE,KAAK,GAAG,eAAe;AAC1D,KAAI,gBAAgB,MAClB,OAAM,QAAQ,UAAU,YAAY;CAEtC,MAAM,OAAO,MAAM,YAAY,UAAU;EAAE,GAAG;EAAY;EAAK,CAAC;AAChE,QAAO,MAAM,KAAK,SAAS,KAAK,MAAM;EACpC,KAAK,KAAK;EACV,KAAK;GAAE,GAAG,QAAQ;GAAK,GAAG,KAAK;GAAM;EACrC,OAAO;EACR,CAAC;;AAGJ,MAAa,kBAAkB,KAAK"}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@opys/runtime",
+  "version": "0.1.2",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown lib/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run tests/unit"
+  },
+  "type": "module",
+  "dependencies": {
+    "@opys/core": "^0.1.2",
+    "@opys/runtime-binding": "^0.1.2"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/harmoniya-net/opys.git",
+    "directory": "packages/runtime"
+  }
+}