@theholocron/astromech 3.65.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Newton Koumantzelis
+
+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,102 @@
+# `@theholocron/astromech`
+
+The Holocron task runner. One **task manifest** per repo, and every
+derived surface comes from it: `holocron run` (local), `holocron ci` (the
+CI suite run locally), the generated GitHub Actions workflows, the
+`package.json` scripts, the linter set, and the branch-protection
+required-checks list.
+
+> An astromech droid runs a starfighter's maintenance, diagnostics and
+> system wiring while the pilot flies. This does that for a repo.
+
+A plain library — **not** a capability plugin. `@theholocron/cli` depends
+on it and instantiates it once.
+
+## Installation
+
+```sh
+pnpm add @theholocron/astromech
+```
+
+## Usage
+
+```ts
+import { createAstromech } from "@theholocron/astromech";
+
+const astromech = createAstromech({ cwd });
+
+const report = astromech.run("test", { passthrough: ["--watch"] });
+// → { status: "ok" | "fail" | "skip" | "dry-run" | "unknown", command?, message? }
+```
+
+### `holocron run <task>` resolution
+
+`holocron run test` runs your tests — you don't tell it turbo vs pnpm vs
+npm, or which runner:
+
+```
+1. turbo.json defines the task            → turbo run <task>
+2. package.json has a <task> script       → <detected pm> run <task>
+   (a "holocron run …" thin caller is skipped — no recursion)
+3. the registry has a local runner        → <tool> <args> <org-flags>   (e.g. --coverage)
+4. known task, nothing to run             → "no <task> task", exit 0  (exit 1 with --required)
+5. unknown task                           → error, exit 1
+```
+
+The registry (`TASKS`) covers `test` / `typecheck` / `lint` / `build` /
+`sync` / `wiki`; `codeql` / `deploy` have no local equivalent. Adding a
+task here gives every repo that task.
+
+## Config — `@theholocron/astromech/config`
+
+The config surface lives in a zero-runtime-dep subpath so
+`astromech.config.ts` and `@theholocron/cli` import it without pulling
+the runner.
+
+```ts
+// astromech.config.ts
+import { defineConfig } from "@theholocron/astromech/config";
+
+export default defineConfig({
+  tasks: [
+    "typecheck",
+    { name: "test", required: true, with: { "run-coverage": true } },
+    { name: "audit", ci: true, local: false }, // CI-only
+  ],
+});
+```
+
+`loadTasksConfig(cwd)` resolves the manifest: the `tasks` key of
+`holocron.config.*` (a bare item array), then a dedicated
+`astromech.config.*` merged on top (dedicated wins; arrays concatenate).
+
+| `TaskEntry` field        | Effect                                                      |
+| ------------------------ | ----------------------------------------------------------- |
+| `ci` (default `true`)    | emit the CI workflow; include in `holocron ci`              |
+| `local` (default `true`) | write the `package.json` script; `holocron run` resolves it |
+| `local: false`           | `holocron run <name>` → "CI-only task", exit 0              |
+| `required`               | the task's check context is a required status check         |
+| `with`                   | per-repo overrides on the reusable-workflow channel         |
+| `linters` (`lint` only)  | explicit linter list; omitted → auto-detect                 |
+
+Nothing in `holocron run` reads the config yet — the manifest drives
+`holocron ci`, workflow generation, and script sync in later phases
+(epic #581).
+
+## Development
+
+| Script               | Description             |
+| -------------------- | ----------------------- |
+| `pnpm build`         | Bundle with tsdown      |
+| `pnpm test`          | Run the vitest suite    |
+| `pnpm test:coverage` | Run tests with coverage |
+| `pnpm typecheck`     | `tsc --noEmit`          |
+| `pnpm lint`          | ESLint                  |
+
+## Releases
+
+Automated via semantic-release. See [CHANGELOG.md](../../CHANGELOG.md).
+
+## Documentation
+
+<https://theholocron.github.io/holocron/>

package/dist/config/index.d.mts

@@ -0,0 +1,25 @@
+import { i as normalizeTaskEntry, n as TaskEntry, r as TasksConfig, t as TaskConfigItem } from "../schema-4kyr9ILV.mjs";
+//#region src/config/define.d.ts
+/**
+ * Typed identity helper for `astromech.config.ts`:
+ *
+ * ```ts
+ * import { defineConfig } from "@theholocron/astromech/config";
+ *
+ * export default defineConfig({
+ *   tasks: ["typecheck", { name: "test", required: true }],
+ * });
+ * ```
+ */
+declare const defineConfig: <C extends TasksConfig>(config: C) => C;
+//#endregion
+//#region src/config/load.d.ts
+/**
+ * Resolve the task manifest for a repo: the `tasks` key of
+ * `holocron.config.*`, then a dedicated `astromech.config.*` merged on
+ * top (dedicated wins; item arrays concatenate). Returns `{}` when
+ * neither source is present.
+ */
+declare function loadTasksConfig(cwd: string): Promise<TasksConfig>;
+//#endregion
+export { type TaskConfigItem, type TaskEntry, type TasksConfig, defineConfig, loadTasksConfig, normalizeTaskEntry };

package/dist/config/index.mjs

@@ -0,0 +1,48 @@
+import { createDefineConfig, loadConfigFile, mergeConfig } from "@theholocron/datapad";
+//#region src/config/define.ts
+/**
+* Typed identity helper for `astromech.config.ts`:
+*
+* ```ts
+* import { defineConfig } from "@theholocron/astromech/config";
+*
+* export default defineConfig({
+*   tasks: ["typecheck", { name: "test", required: true }],
+* });
+* ```
+*/
+const defineConfig = createDefineConfig();
+//#endregion
+//#region src/config/load.ts
+/**
+* Resolve the task manifest for a repo: the `tasks` key of
+* `holocron.config.*`, then a dedicated `astromech.config.*` merged on
+* top (dedicated wins; item arrays concatenate). Returns `{}` when
+* neither source is present.
+*/
+async function loadTasksConfig(cwd) {
+	const dedicated = await loadConfigFile({
+		cwd,
+		name: "astromech"
+	});
+	return [coerce((await loadConfigFile({
+		cwd,
+		name: "holocron"
+	}))?.config.tasks), coerce(dedicated?.config)].filter((layer) => layer !== void 0).reduce((acc, layer) => mergeConfig(acc, layer), {});
+}
+function coerce(value) {
+	if (value == null) return void 0;
+	return Array.isArray(value) ? { tasks: value } : value;
+}
+//#endregion
+//#region src/config/schema.ts
+/** Normalise a `TaskConfigItem` to a full {@link TaskEntry} with defaults applied. */
+function normalizeTaskEntry(item) {
+	return {
+		ci: true,
+		local: true,
+		...typeof item === "string" ? { name: item } : item
+	};
+}
+//#endregion
+export { defineConfig, loadTasksConfig, normalizeTaskEntry };

package/dist/index.d.mts

@@ -0,0 +1,136 @@
+import { r as TasksConfig } from "./schema-4kyr9ILV.mjs";
+//#region src/run.d.ts
+/**
+ * `holocron run <task> [-- <passthrough>]` — run a registry task locally.
+ *
+ * Resolution:
+ *
+ *   1. turbo.json defines the task            → `turbo run <task>`
+ *   2. package.json has a `<task>` script     → `<pm> run <task>`
+ *      (unless it's the `holocron run …` thin caller — that recurses)
+ *   3. TASKS[task].local resolves             → `<tool> <args> <org-flags> <passthrough>`
+ *   4. known task, nothing to run             → "no <task> task" (exit 0, or 1 with --required)
+ *   5. unknown task                           → "unknown task" (exit 1)
+ */
+/** Minimal structural logger — `@theholocron/logger`'s `Logger` satisfies it. */
+interface RunLogger {
+  debug(obj: Record<string, unknown>, msg?: string): void;
+  warn(obj: Record<string, unknown>, msg?: string): void;
+}
+type ExecFn = (cmd: string, args: string[], opts: {
+  cwd: string;
+}) => {
+  exitCode: number;
+};
+/**
+ * Everything `runTask` needs from the outside world. `createAstromech`
+ * fills these with real implementations (or the caller's injected ones);
+ * `runTask` never reaches for a global itself, so it has no default
+ * branches to leave untested.
+ */
+interface RunDeps {
+  print: (line: string) => void;
+  logger: RunLogger;
+  exec: ExecFn;
+  readFile: (path: string) => string;
+  fileExists: (path: string) => boolean;
+  listDir: (path: string) => string[];
+}
+interface RunTaskInput extends RunDeps {
+  /** Registry task name, e.g. `"test"`. */
+  task: string;
+  /** Directory to run in. */
+  cwd: string;
+  /** Args after `--` on the command line, forwarded to the tool / turbo / script. */
+  passthrough?: string[];
+  /** Print the resolved command without running it. */
+  dryRun?: boolean;
+  /** Turn "no such task for this repo" (normally exit 0) into a failure. */
+  required?: boolean;
+}
+interface RunTaskReport {
+  status: "ok" | "fail" | "skip" | "dry-run" | "unknown";
+  /** Resolved command, for the caller / tests. */
+  command?: string;
+  message?: string;
+}
+declare function runTask(input: RunTaskInput): RunTaskReport;
+//#endregion
+//#region src/astromech.d.ts
+interface AstromechOptions {
+  /** Repo root. */
+  cwd: string;
+  /**
+   * The resolved task manifest. Optional for `run` (which is
+   * filesystem-driven); later methods (`ci`, workflow generation) need it.
+   * Load it with `loadTasksConfig` from `@theholocron/astromech/config`.
+   */
+  config?: TasksConfig;
+  /** Structured-logging sink. Defaults to a no-op. */
+  logger?: RunLogger;
+  /** User-facing line printer. Defaults to `console.log`. */
+  print?: (line: string) => void;
+  /** Injectable subprocess runner (tests). Defaults to `spawnSync` (stdio inherit). */
+  exec?: ExecFn;
+  /** Injectable fs (tests). Default to `node:fs`. */
+  readFile?: (path: string) => string;
+  fileExists?: (path: string) => boolean;
+  listDir?: (path: string) => string[];
+}
+interface RunOptions {
+  /** Args after `--`, forwarded to the tool / turbo / script. */
+  passthrough?: string[];
+  /** Print the resolved command without running it. */
+  dryRun?: boolean;
+  /** Fail (exit 1) instead of skipping when the repo has no such task. */
+  required?: boolean;
+}
+interface Astromech {
+  /** Run one task locally. */
+  run(task: string, opts?: RunOptions): RunTaskReport;
+}
+declare function createAstromech(options: AstromechOptions): Astromech;
+//#endregion
+//#region src/registry.d.ts
+/**
+ * The task registry — how each task runs *locally*, without GitHub
+ * Actions. `holocron run <task>` and `holocron ci` resolve against this;
+ * adding a task here gives every repo that task.
+ *
+ * Keyed identically to the workflow templates — a task IS a workflow.
+ *
+ * Spec: `.notes/tech-astromech-task-runner.spec.md` (epic #581).
+ */
+/** How to run one task (or job) locally. */
+interface LocalRunner {
+  /** Binary to invoke — resolved from `node_modules/.bin` then PATH. */
+  tool?: string;
+  /** Args appended after the tool. */
+  args?: string[];
+  /** First entry whose `when` filename matches a repo-root file wins. */
+  detect?: Array<{
+    when: RegExp;
+    tool: string;
+    args?: string[];
+  }>;
+  /** The task is already a holocron subcommand (`sync`, `sync-wiki`). */
+  command?: string;
+}
+interface TaskDef {
+  /**
+   * `null` — no local equivalent (CodeQL, deploys). `holocron ci` reports
+   * it as skipped; `holocron run` treats it as "nothing to do".
+   */
+  local: LocalRunner | null;
+  /** Sub-jobs, keyed by slug — `holocron run audit performance`. */
+  jobs?: Record<string, {
+    local: LocalRunner | null;
+  }>;
+  /** Org-default flags injected by tool name. Removed by a repo override. */
+  flags?: Record<string, string[]>;
+}
+declare const TASKS: Record<string, TaskDef>;
+/** Every task name the registry knows. */
+declare const KNOWN_TASKS: Set<string>;
+//#endregion
+export { type Astromech, type AstromechOptions, type ExecFn, KNOWN_TASKS, type LocalRunner, type RunLogger, type RunOptions, type RunTaskInput, type RunTaskReport, TASKS, type TaskDef, createAstromech, runTask };

package/dist/index.mjs

@@ -0,0 +1,237 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+//#region src/registry.ts
+const TASKS = {
+	test: {
+		local: {
+			tool: "vitest",
+			args: ["run"]
+		},
+		flags: { vitest: ["--coverage"] }
+	},
+	typecheck: { local: {
+		tool: "tsc",
+		args: ["--noEmit"]
+	} },
+	lint: { local: {
+		tool: "eslint",
+		args: ["."]
+	} },
+	build: { local: { detect: [
+		{
+			when: /^tsdown\.config\.(ts|js|mjs|cjs)$/,
+			tool: "tsdown"
+		},
+		{
+			when: /^vite\.config\.(ts|js|mjs|cjs)$/,
+			tool: "vite",
+			args: ["build"]
+		},
+		{
+			when: /^rollup\.config\.(ts|js|mjs|cjs)$/,
+			tool: "rollup",
+			args: ["-c"]
+		},
+		{
+			when: /^tsconfig\.json$/,
+			tool: "tsc",
+			args: ["-b"]
+		}
+	] } },
+	sync: { local: { command: "sync" } },
+	wiki: { local: { command: "sync-wiki" } },
+	codeql: { local: null },
+	deploy: { local: null }
+};
+/** Every task name the registry knows. */
+const KNOWN_TASKS = new Set(Object.keys(TASKS));
+//#endregion
+//#region src/run.ts
+/**
+* `holocron run <task> [-- <passthrough>]` — run a registry task locally.
+*
+* Resolution:
+*
+*   1. turbo.json defines the task            → `turbo run <task>`
+*   2. package.json has a `<task>` script     → `<pm> run <task>`
+*      (unless it's the `holocron run …` thin caller — that recurses)
+*   3. TASKS[task].local resolves             → `<tool> <args> <org-flags> <passthrough>`
+*   4. known task, nothing to run             → "no <task> task" (exit 0, or 1 with --required)
+*   5. unknown task                           → "unknown task" (exit 1)
+*/
+function runTask(input) {
+	const { print, logger, exec, readFile, fileExists, listDir, task, cwd } = input;
+	const passthrough = input.passthrough ?? [];
+	const dryRun = input.dryRun ?? false;
+	const run = (cmd, args) => {
+		const command = [cmd, ...args].join(" ");
+		if (dryRun) {
+			print(`would run: ${command}`);
+			logger.debug({
+				task,
+				command,
+				status: "dry-run"
+			}, `run: ${task}`);
+			return {
+				status: "dry-run",
+				command
+			};
+		}
+		print(`→ ${command}`);
+		const { exitCode } = exec(cmd, args, { cwd });
+		const status = exitCode === 0 ? "ok" : "fail";
+		logger[status === "fail" ? "warn" : "debug"]({
+			task,
+			command,
+			exitCode,
+			status
+		}, `run: ${task}`);
+		return {
+			status,
+			command,
+			...status === "fail" ? { message: `\`${command}\` exited ${exitCode}` } : {}
+		};
+	};
+	if (turboDefinesTask(cwd, task, readFile, fileExists)) {
+		const args = [
+			"run",
+			task,
+			...passthrough.length ? ["--", ...passthrough] : []
+		];
+		return run(resolveBin(cwd, "turbo", fileExists), args);
+	}
+	const def = TASKS[task];
+	const script = packageJsonScript(cwd, task, readFile, fileExists);
+	if (script && !/^holocron run\b/.test(script.trim())) return run(packageManager(cwd, readFile, fileExists), [
+		"run",
+		task,
+		...passthrough.length ? ["--", ...passthrough] : []
+	]);
+	if (def?.local) {
+		if (def.local.command) return run(process.execPath, [
+			process.argv[1],
+			def.local.command,
+			...passthrough
+		]);
+		const runner = resolveRunner(def.local, cwd, listDir);
+		if (runner) {
+			const flags = def.flags?.[runner.tool] ?? [];
+			return run(resolveBin(cwd, runner.tool, fileExists), [
+				...runner.args,
+				...flags,
+				...passthrough
+			]);
+		}
+	}
+	if (KNOWN_TASKS.has(task) || def?.local === null) {
+		const msg = `no ${task} task for this repo`;
+		print(input.required ? `✗ ${msg} (required)` : `· ${msg}`);
+		logger[input.required ? "warn" : "debug"]({
+			task,
+			status: input.required ? "fail" : "skip"
+		}, `run: ${task}`);
+		return {
+			status: input.required ? "fail" : "skip",
+			message: msg
+		};
+	}
+	print(`✗ unknown task "${task}"`);
+	logger.warn({
+		task,
+		status: "unknown"
+	}, `run: ${task}`);
+	return {
+		status: "unknown",
+		message: `unknown task "${task}"`
+	};
+}
+const mkRunner = (tool, args = []) => ({
+	tool,
+	args
+});
+/**
+* Resolve `{ tool, args }` for a runner, applying `detect[]` against repo
+* files. Only called for `tool` / `detect` runners — the caller handles
+* `command` runners itself, so `local.detect` is present whenever
+* `local.tool` is not.
+*/
+function resolveRunner(local, cwd, listDir) {
+	if (local.tool) return mkRunner(local.tool, local.args);
+	let files;
+	try {
+		files = listDir(cwd);
+	} catch {
+		return;
+	}
+	for (const candidate of local.detect) if (files.some((f) => candidate.when.test(f))) return mkRunner(candidate.tool, candidate.args);
+}
+function resolveBin(cwd, tool, fileExists) {
+	const local = join(cwd, "node_modules", ".bin", tool);
+	return fileExists(local) ? local : tool;
+}
+function packageManager(cwd, readFile, fileExists) {
+	try {
+		const pkg = JSON.parse(readFile(join(cwd, "package.json")));
+		if (typeof pkg.packageManager === "string") return pkg.packageManager.split("@")[0];
+	} catch {}
+	if (fileExists(join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+	if (fileExists(join(cwd, "bun.lockb"))) return "bun";
+	if (fileExists(join(cwd, "yarn.lock"))) return "yarn";
+	if (fileExists(join(cwd, "package-lock.json"))) return "npm";
+	return "pnpm";
+}
+function turboDefinesTask(cwd, task, readFile, fileExists) {
+	if (!fileExists(join(cwd, "turbo.json"))) return false;
+	try {
+		const turbo = JSON.parse(readFile(join(cwd, "turbo.json")));
+		return Boolean(turbo.tasks?.[task] ?? turbo.pipeline?.[task]);
+	} catch {
+		return false;
+	}
+}
+function packageJsonScript(cwd, task, readFile, fileExists) {
+	if (!fileExists(join(cwd, "package.json"))) return void 0;
+	try {
+		return JSON.parse(readFile(join(cwd, "package.json"))).scripts?.[task];
+	} catch {
+		return;
+	}
+}
+//#endregion
+//#region src/astromech.ts
+/**
+* `createAstromech(options)` — the self-contained task runner.
+* `@theholocron/cli` instantiates it once and delegates the `run` /
+* `ci` / workflow-generation commands to it (like `@theholocron/logger`).
+*/
+const noopLogger = {
+	debug() {},
+	warn() {}
+};
+const realExec = (cmd, args, opts) => {
+	return { exitCode: spawnSync(cmd, args, {
+		cwd: opts.cwd,
+		stdio: "inherit"
+	}).status ?? -1 };
+};
+function createAstromech(options) {
+	const deps = {
+		print: options.print ?? ((line) => console.log(line)),
+		logger: options.logger ?? noopLogger,
+		exec: options.exec ?? realExec,
+		readFile: options.readFile ?? ((path) => readFileSync(path, "utf8")),
+		fileExists: options.fileExists ?? ((path) => existsSync(path)),
+		listDir: options.listDir ?? ((path) => readdirSync(path))
+	};
+	return { run: (task, opts = {}) => runTask({
+		...deps,
+		task,
+		cwd: options.cwd,
+		passthrough: opts.passthrough ?? [],
+		dryRun: opts.dryRun ?? false,
+		required: opts.required ?? false
+	}) };
+}
+//#endregion
+export { KNOWN_TASKS, TASKS, createAstromech, runTask };

package/dist/schema-4kyr9ILV.d.mts

@@ -0,0 +1,54 @@
+//#region src/config/schema.d.ts
+/**
+ * The `tasks` config shape — the single manifest of what a repo runs.
+ * Read from a dedicated `astromech.config.*` file or the `tasks` key of
+ * `holocron.config.*` (see {@link loadTasksConfig}).
+ *
+ * Runtime validation is the loader's job, not this type's — the type only
+ * describes what an author writes.
+ */
+interface TaskEntry {
+  /** Registry task name — `test`, `lint`, `build`, `audit`, … */
+  name: string;
+  /**
+   * Emit a `.github/workflows/<name>.yml` thin caller and include the task
+   * in `holocron ci`. Default `true`.
+   */
+  ci?: boolean;
+  /**
+   * Write a `"<name>": "holocron run <name>"` script to `package.json` and
+   * let `holocron run <name>` resolve the task. Default `true`.
+   * `false` → `holocron run <name>` prints "CI-only task" and exits 0.
+   */
+  local?: boolean;
+  /**
+   * The task's CI check context is a required status check (branch
+   * protection) and part of `holocron ci`'s default run.
+   */
+  required?: boolean;
+  /** Per-repo overrides on the same channel the reusable workflow reads. */
+  with?: Record<string, unknown>;
+  /**
+   * `lint` only — the explicit linter list driving both super-linter's
+   * `VALIDATE_*` env (CI) and the native local run. Omitted → auto-detect
+   * from the config files present.
+   */
+  linters?: string[];
+}
+/** A task is either its bare name (all defaults) or an entry object. */
+type TaskConfigItem = string | TaskEntry;
+interface TasksConfig {
+  /** The manifest. */
+  tasks?: TaskConfigItem[];
+  /** Opt out of the `package.json` script writes. Default `true`. */
+  syncScripts?: boolean;
+  /**
+   * Required status-check contexts not backed by a task — DCO, semantic
+   * PR title, …
+   */
+  extraRequiredChecks?: string[];
+}
+/** Normalise a `TaskConfigItem` to a full {@link TaskEntry} with defaults applied. */
+declare function normalizeTaskEntry(item: TaskConfigItem): Required<Pick<TaskEntry, "name" | "ci" | "local">> & TaskEntry;
+//#endregion
+export { normalizeTaskEntry as i, TaskEntry as n, TasksConfig as r, TaskConfigItem as t };

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@theholocron/astromech",
+  "version": "3.65.0",
+  "description": "The Holocron task runner — one task manifest drives `holocron run`, `holocron ci`, the CI workflows, package.json scripts, linters, and required checks.",
+  "keywords": [
+    "ci",
+    "holocron",
+    "monorepo",
+    "task-runner",
+    "theholocron",
+    "turbo"
+  ],
+  "homepage": "https://github.com/theholocron/holocron/tree/main/packages/astromech#readme",
+  "bugs": "https://github.com/theholocron/holocron/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/theholocron/holocron.git",
+    "directory": "packages/astromech"
+  },
+  "license": "MIT",
+  "author": "Newton Koumantzelis",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.mts",
+      "import": "./dist/config/index.mjs",
+      "default": "./dist/config/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@theholocron/datapad": "3.65.0"
+  },
+  "devDependencies": {
+    "@theholocron/eslint-config": "^7.32.1",
+    "@theholocron/tsconfig": "^7.32.1",
+    "@theholocron/tsdown-config": "^7.32.1",
+    "@theholocron/vitest-config": "^7.32.1",
+    "@types/node": "^26",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/eslint-plugin": "^1.6.27",
+    "eslint": "^10.8.1",
+    "eslint-plugin-n": "^18.3.0",
+    "globals": "^17.11.0",
+    "tsdown": "^0.22.14",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.11"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "lint": "eslint .",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  }
+}