@williamthorsen/preflight 0.2.0

package/bin/preflight.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+try {
+  await import('../dist/esm/bin/preflight.js');
+} catch (error) {
+  process.stderr.write(`preflight: failed to load: ${error.message}\n`);
+  process.exit(1);
+}

package/dist/esm/.cache

@@ -0,0 +1 @@
+fa0798ecd9314d7615561bcc9e5f533bf154ce5280b52c4e8bfc6faf00ae5380

package/dist/esm/bin/preflight.d.ts

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

package/dist/esm/bin/preflight.js

@@ -0,0 +1,12 @@
+import process from "node:process";
+import { routeCommand } from "./route.js";
+let exitCode;
+try {
+  exitCode = await routeCommand(process.argv.slice(2));
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`preflight: unexpected error: ${message}
+`);
+  exitCode = 1;
+}
+process.exit(exitCode);

package/dist/esm/bin/route.d.ts

@@ -0,0 +1 @@
+export declare function routeCommand(args: string[]): Promise<number>;

package/dist/esm/bin/route.js

@@ -0,0 +1,85 @@
+import process from "node:process";
+import { parseRunArgs, runCommand } from "../cli.js";
+import { initCommand } from "../init/initCommand.js";
+function showHelp() {
+  console.info(`
+Usage: preflight <command> [options]
+
+Commands:
+  run [names...]   Run preflight checklists
+  init             Scaffold a starter config file
+
+Options:
+  --help, -h       Show this help message
+`);
+}
+function showRunHelp() {
+  console.info(`
+Usage: preflight run [names...] [options]
+
+Run preflight checklists. If no names are given, all checklists are run.
+
+Options:
+  --config, -c <path>   Path to the config file
+  --help, -h            Show this help message
+`);
+}
+function showInitHelp() {
+  console.info(`
+Usage: preflight init [options]
+
+Scaffold a starter .config/preflight.config.ts file.
+
+Options:
+  --dry-run     Preview changes without writing files
+  --force       Overwrite an existing config file
+  --help, -h    Show this help message
+`);
+}
+async function routeCommand(args) {
+  const command = args[0];
+  const flags = args.slice(1);
+  if (command === "--help" || command === "-h" || command === void 0) {
+    showHelp();
+    return 0;
+  }
+  if (command === "run") {
+    if (flags.some((f) => f === "--help" || f === "-h")) {
+      showRunHelp();
+      return 0;
+    }
+    let parsed;
+    try {
+      parsed = parseRunArgs(flags);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Error: ${message}
+`);
+      return 1;
+    }
+    return runCommand(parsed);
+  }
+  if (command === "init") {
+    if (flags.some((f) => f === "--help" || f === "-h")) {
+      showInitHelp();
+      return 0;
+    }
+    const knownInitFlags = /* @__PURE__ */ new Set(["--dry-run", "--force", "--help", "-h"]);
+    const unknownFlags = flags.filter((f) => !knownInitFlags.has(f));
+    if (unknownFlags.length > 0) {
+      process.stderr.write(`Error: Unknown option: ${unknownFlags[0]}
+`);
+      return 1;
+    }
+    const dryRun = flags.includes("--dry-run");
+    const force = flags.includes("--force");
+    return initCommand({ dryRun, force });
+  }
+  process.stderr.write(`Error: Unknown command: ${command}
+`);
+  showHelp();
+  return 1;
+}
+export {
+  routeCommand
+};

package/dist/esm/cli.d.ts

@@ -0,0 +1,11 @@
+interface ParsedRunArgs {
+    configPath?: string;
+    names: string[];
+}
+export declare function parseRunArgs(flags: string[]): ParsedRunArgs;
+interface RunCommandOptions {
+    names: string[];
+    configPath?: string;
+}
+export declare function runCommand({ names, configPath }: RunCommandOptions): Promise<number>;
+export {};

package/dist/esm/cli.js

@@ -0,0 +1,79 @@
+import process from "node:process";
+import { loadPreflightConfig } from "./config.js";
+import { reportPreflight } from "./reportPreflight.js";
+import { runPreflight } from "./runPreflight.js";
+function parseRunArgs(flags) {
+  const result = { names: [] };
+  for (let i = 0; i < flags.length; i++) {
+    const arg = flags[i];
+    if (arg === void 0) break;
+    if (arg === "--config" || arg === "-c") {
+      i++;
+      const configValue = flags[i];
+      if (configValue === void 0) {
+        throw new Error("--config requires a path argument");
+      }
+      result.configPath = configValue;
+    } else if (arg.startsWith("--config=")) {
+      const configValue = arg.slice("--config=".length);
+      if (configValue === "") {
+        throw new Error("--config requires a path argument");
+      }
+      result.configPath = configValue;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`unknown flag '${arg}'`);
+    } else {
+      result.names.push(arg);
+    }
+  }
+  return result;
+}
+function resolveFixLocation(checklist, configDefault) {
+  return checklist.fixLocation ?? configDefault ?? "END";
+}
+async function runCommand({ names, configPath }) {
+  let config;
+  try {
+    config = await loadPreflightConfig(configPath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`Error: ${message}
+`);
+    return 1;
+  }
+  let checklists = config.checklists;
+  if (names.length > 0) {
+    const availableNames = new Set(config.checklists.map((c) => c.name));
+    const unknownNames = names.filter((n) => !availableNames.has(n));
+    if (unknownNames.length > 0) {
+      const available = [...availableNames].join(", ");
+      process.stderr.write(`Error: unknown checklist(s): ${unknownNames.join(", ")}. Available: ${available}
+`);
+      return 1;
+    }
+    const requestedNames = new Set(names);
+    checklists = config.checklists.filter((c) => requestedNames.has(c.name));
+  }
+  const showHeader = checklists.length > 1;
+  let allPassed = true;
+  for (const checklist of checklists) {
+    if (showHeader) {
+      process.stdout.write(`
+--- ${checklist.name} ---
+
+`);
+    }
+    const report = await runPreflight(checklist);
+    const fixLocation = resolveFixLocation(checklist, config.fixLocation);
+    const output = reportPreflight(report, { fixLocation });
+    process.stdout.write(output + "\n");
+    if (!report.passed) {
+      allPassed = false;
+    }
+  }
+  return allPassed ? 0 : 1;
+}
+export {
+  parseRunArgs,
+  runCommand
+};

package/dist/esm/config.d.ts

@@ -0,0 +1,6 @@
+import type { PreflightCheckList, PreflightConfig, StagedPreflightCheckList } from './types.ts';
+export declare const CONFIG_FILE_PATH = ".config/preflight.config.ts";
+export declare function definePreflightConfig(config: PreflightConfig): PreflightConfig;
+export declare function definePreflightCheckList(checklist: PreflightCheckList): PreflightCheckList;
+export declare function defineStagedPreflightCheckList(checklist: StagedPreflightCheckList): StagedPreflightCheckList;
+export declare function loadPreflightConfig(configPath?: string): Promise<PreflightConfig>;

package/dist/esm/config.js

@@ -0,0 +1,66 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+const CONFIG_FILE_PATH = ".config/preflight.config.ts";
+function definePreflightConfig(config) {
+  return config;
+}
+function definePreflightCheckList(checklist) {
+  return checklist;
+}
+function defineStagedPreflightCheckList(checklist) {
+  return checklist;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assertIsPreflightConfig(raw) {
+  if (!isRecord(raw)) {
+    throw new TypeError(`Preflight config must be an object, got ${Array.isArray(raw) ? "array" : typeof raw}`);
+  }
+  if (!Array.isArray(raw.checklists)) {
+    throw new TypeError("Preflight config must have a 'checklists' array");
+  }
+  for (const [i, entry] of raw.checklists.entries()) {
+    if (!isRecord(entry)) {
+      throw new Error(`checklists[${i}]: must be an object`);
+    }
+    if (typeof entry.name !== "string" || entry.name === "") {
+      throw new Error(`checklists[${i}]: 'name' is required and must be a non-empty string`);
+    }
+    const hasChecks = "checks" in entry;
+    const hasGroups = "groups" in entry;
+    if (!hasChecks && !hasGroups) {
+      throw new Error(`checklists[${i}]: must have either 'checks' or 'groups'`);
+    }
+    if (hasChecks && hasGroups) {
+      throw new Error(`checklists[${i}]: cannot have both 'checks' and 'groups'`);
+    }
+  }
+}
+async function loadPreflightConfig(configPath) {
+  const resolvedPath = path.resolve(process.cwd(), configPath ?? CONFIG_FILE_PATH);
+  if (!existsSync(resolvedPath)) {
+    throw new Error(`Preflight config not found: ${resolvedPath}`);
+  }
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url);
+  const imported = await jiti.import(resolvedPath);
+  if (!isRecord(imported)) {
+    throw new Error(`Config file must export an object, got ${Array.isArray(imported) ? "array" : typeof imported}`);
+  }
+  const resolved = imported.default ?? imported.config;
+  if (resolved === void 0) {
+    throw new Error(
+      "Config file must have a default export or a named `config` export (e.g., `export default definePreflightConfig({ ... })`)"
+    );
+  }
+  assertIsPreflightConfig(resolved);
+  return resolved;
+}
+export {
+  CONFIG_FILE_PATH,
+  definePreflightCheckList,
+  definePreflightConfig,
+  defineStagedPreflightCheckList,
+  loadPreflightConfig
+};

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+export type { FixLocation, PreflightCheck, PreflightCheckList, PreflightConfig, PreflightReport, PreflightResult, ReportOptions, StagedPreflightCheckList, } from './types.ts';
+export { isFlatCheckList } from './types.ts';
+export { definePreflightCheckList, definePreflightConfig, defineStagedPreflightCheckList } from './config.ts';
+export { runPreflight } from './runPreflight.ts';
+export { reportPreflight } from './reportPreflight.ts';

package/dist/esm/index.js

@@ -0,0 +1,12 @@
+import { isFlatCheckList } from "./types.js";
+import { definePreflightCheckList, definePreflightConfig, defineStagedPreflightCheckList } from "./config.js";
+import { runPreflight } from "./runPreflight.js";
+import { reportPreflight } from "./reportPreflight.js";
+export {
+  definePreflightCheckList,
+  definePreflightConfig,
+  defineStagedPreflightCheckList,
+  isFlatCheckList,
+  reportPreflight,
+  runPreflight
+};

package/dist/esm/init/initCommand.d.ts

@@ -0,0 +1,6 @@
+interface InitOptions {
+    dryRun: boolean;
+    force: boolean;
+}
+export declare function initCommand({ dryRun, force }: InitOptions): number;
+export {};

package/dist/esm/init/initCommand.js

@@ -0,0 +1,29 @@
+import { printError, printStep } from "../lib/terminal.js";
+import { scaffoldConfig } from "./scaffold.js";
+function initCommand({ dryRun, force }) {
+  if (dryRun) {
+    console.info("[dry-run mode]");
+  }
+  printStep("Scaffolding config");
+  try {
+    const ok = scaffoldConfig({ dryRun, force });
+    if (!ok) {
+      return 1;
+    }
+  } catch (error) {
+    printError(`Failed to scaffold config: ${error instanceof Error ? error.message : String(error)}`);
+    return 1;
+  }
+  if (!dryRun) {
+    printStep("Next steps");
+    console.info(`
+  1. Customize .config/preflight.config.ts with your checklists and checks.
+  2. Test by running: npx @williamthorsen/preflight run
+  3. Commit the generated file.
+`);
+  }
+  return 0;
+}
+export {
+  initCommand
+};

package/dist/esm/init/scaffold.d.ts

@@ -0,0 +1,6 @@
+interface ScaffoldOptions {
+    dryRun: boolean;
+    force: boolean;
+}
+export declare function scaffoldConfig({ dryRun, force }: ScaffoldOptions): boolean;
+export {};

package/dist/esm/init/scaffold.js

@@ -0,0 +1,63 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { printError, printSkip, printSuccess } from "../lib/terminal.js";
+import { preflightConfigTemplate } from "./templates.js";
+const CONFIG_PATH = ".config/preflight.config.ts";
+function normalizeTrailingWhitespace(content) {
+  return content.split("\n").map((line) => line.trimEnd()).join("\n").trimEnd();
+}
+function tryWriteFile(filePath, content) {
+  try {
+    writeFileSync(filePath, content, "utf8");
+    return true;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Failed to write ${filePath}: ${message}`);
+    return false;
+  }
+}
+function writeIfAbsent(filePath, content, dryRun, overwrite) {
+  const fileAlreadyExists = existsSync(filePath);
+  if (fileAlreadyExists && !overwrite) {
+    try {
+      const existing = readFileSync(filePath, "utf8");
+      if (normalizeTrailingWhitespace(existing) === normalizeTrailingWhitespace(content)) {
+        printSuccess(`${filePath} (up to date)`);
+        return true;
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      printError(`Could not read ${filePath}: ${message}`);
+    }
+    if (dryRun) {
+      printSkip(`[dry-run] Would skip ${filePath} (already exists)`);
+    } else {
+      printSkip(`${filePath} (already exists)`);
+    }
+    return true;
+  }
+  if (dryRun) {
+    const verb = fileAlreadyExists ? "overwrite" : "create";
+    printSuccess(`[dry-run] Would ${verb} ${filePath}`);
+    return true;
+  }
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    printError(`Failed to create directory for ${filePath}: ${message}`);
+    return false;
+  }
+  if (tryWriteFile(filePath, content)) {
+    const verb = fileAlreadyExists ? "Overwrote" : "Created";
+    printSuccess(`${verb} ${filePath}`);
+    return true;
+  }
+  return false;
+}
+function scaffoldConfig({ dryRun, force }) {
+  return writeIfAbsent(CONFIG_PATH, preflightConfigTemplate, dryRun, force);
+}
+export {
+  scaffoldConfig
+};

package/dist/esm/init/templates.d.ts

@@ -0,0 +1 @@
+export declare const preflightConfigTemplate = "import { definePreflightConfig } from '@williamthorsen/preflight';\n\n/**\n * Preflight configuration.\n *\n * Each checklist contains checks that run before a deployment or other operation.\n * Checks run concurrently within a checklist. Use `fix` to provide remediation hints.\n */\nexport default definePreflightConfig({\n  checklists: [\n    {\n      name: 'deploy',\n      checks: [\n        {\n          name: 'environment variables set',\n          check: () => Boolean(process.env['NODE_ENV']),\n          fix: 'Set NODE_ENV before deploying',\n        },\n      ],\n    },\n  ],\n});\n";

package/dist/esm/init/templates.js

@@ -0,0 +1,26 @@
+const preflightConfigTemplate = `import { definePreflightConfig } from '@williamthorsen/preflight';
+
+/**
+ * Preflight configuration.
+ *
+ * Each checklist contains checks that run before a deployment or other operation.
+ * Checks run concurrently within a checklist. Use \`fix\` to provide remediation hints.
+ */
+export default definePreflightConfig({
+  checklists: [
+    {
+      name: 'deploy',
+      checks: [
+        {
+          name: 'environment variables set',
+          check: () => Boolean(process.env['NODE_ENV']),
+          fix: 'Set NODE_ENV before deploying',
+        },
+      ],
+    },
+  ],
+});
+`;
+export {
+  preflightConfigTemplate
+};

package/dist/esm/lib/terminal.d.ts

@@ -0,0 +1,4 @@
+export declare function printStep(message: string): void;
+export declare function printSuccess(message: string): void;
+export declare function printSkip(message: string): void;
+export declare function printError(message: string): void;

package/dist/esm/lib/terminal.js

@@ -0,0 +1,19 @@
+function printStep(message) {
+  console.info(`
+> ${message}`);
+}
+function printSuccess(message) {
+  console.info(`  \u2705 ${message}`);
+}
+function printSkip(message) {
+  console.info(`  \u26A0\uFE0F ${message}`);
+}
+function printError(message) {
+  console.error(`  \u274C ${message}`);
+}
+export {
+  printError,
+  printSkip,
+  printStep,
+  printSuccess
+};

package/dist/esm/reportPreflight.d.ts

@@ -0,0 +1,2 @@
+import type { PreflightReport, ReportOptions } from './types.ts';
+export declare function reportPreflight(report: PreflightReport, options?: ReportOptions): string;

package/dist/esm/reportPreflight.js

@@ -0,0 +1,53 @@
+const ICON_PASSED = "\u2705";
+const ICON_FAILED = "\u274C";
+const ICON_SKIPPED = "\u26AA";
+function formatDuration(ms) {
+  return `${Math.round(ms)}ms`;
+}
+function getIcon(status) {
+  if (status === "passed") return ICON_PASSED;
+  if (status === "failed") return ICON_FAILED;
+  return ICON_SKIPPED;
+}
+function collectInlineDetails(result, includeFix) {
+  const details = [];
+  if (result.error !== void 0) {
+    details.push(`  Error: ${result.error.message}`);
+  }
+  if (includeFix && result.fix !== void 0) {
+    details.push(`  Fix: ${result.fix}`);
+  }
+  return details;
+}
+function reportPreflight(report, options) {
+  const fixLocation = options?.fixLocation ?? "END";
+  const lines = [];
+  const collectedFixes = [];
+  for (const result of report.results) {
+    const icon = getIcon(result.status);
+    lines.push(`${icon} ${result.name} (${formatDuration(result.durationMs)})`);
+    if (result.status === "failed") {
+      const includeFix = fixLocation === "INLINE";
+      lines.push(...collectInlineDetails(result, includeFix));
+      if (!includeFix && result.fix !== void 0) {
+        collectedFixes.push(result.fix);
+      }
+    }
+  }
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+  for (const r of report.results) {
+    if (r.status === "passed") passed++;
+    else if (r.status === "failed") failed++;
+    else skipped++;
+  }
+  lines.push("", `${passed} passed, ${failed} failed, ${skipped} skipped (${formatDuration(report.durationMs)})`);
+  if (fixLocation === "END" && collectedFixes.length > 0) {
+    lines.push("", "Fixes:", ...collectedFixes.map((fix) => `  ${fix}`));
+  }
+  return lines.join("\n");
+}
+export {
+  reportPreflight
+};

package/dist/esm/runPreflight.d.ts

@@ -0,0 +1,2 @@
+import type { PreflightCheckList, PreflightReport, StagedPreflightCheckList } from './types.ts';
+export declare function runPreflight(checklist: PreflightCheckList | StagedPreflightCheckList): Promise<PreflightReport>;

package/dist/esm/runPreflight.js

@@ -0,0 +1,73 @@
+import { performance } from "node:perf_hooks";
+import { isFlatCheckList } from "./types.js";
+function buildResult(name, status, durationMs, fix, error) {
+  const result = { name, status, durationMs };
+  if (fix !== void 0) {
+    result.fix = fix;
+  }
+  if (error !== void 0) {
+    result.error = error;
+  }
+  return result;
+}
+async function executeCheck(check) {
+  const start = performance.now();
+  try {
+    const passed = await check.check();
+    const durationMs = performance.now() - start;
+    return buildResult(check.name, passed ? "passed" : "failed", durationMs, check.fix);
+  } catch (error_) {
+    const durationMs = performance.now() - start;
+    const error = error_ instanceof Error ? error_ : new Error(String(error_));
+    return buildResult(check.name, "failed", durationMs, check.fix, error);
+  }
+}
+function skipCheck(check) {
+  return buildResult(check.name, "skipped", 0, check.fix);
+}
+async function runPreconditions(preconditions, results) {
+  if (preconditions.length === 0) return true;
+  const preconditionResults = await Promise.all(preconditions.map(executeCheck));
+  results.push(...preconditionResults);
+  return preconditionResults.every((r) => r.status === "passed");
+}
+async function runFlatChecks(checklist, results, preconditionsPassed) {
+  if (!preconditionsPassed) {
+    results.push(...checklist.checks.map(skipCheck));
+    return;
+  }
+  const checkResults = await Promise.all(checklist.checks.map(executeCheck));
+  results.push(...checkResults);
+}
+async function runStagedChecks(checklist, results, preconditionsPassed) {
+  if (!preconditionsPassed) {
+    for (const group of checklist.groups) {
+      results.push(...group.map(skipCheck));
+    }
+    return;
+  }
+  let shouldSkipRemaining = false;
+  for (const group of checklist.groups) {
+    if (shouldSkipRemaining) {
+      results.push(...group.map(skipCheck));
+      continue;
+    }
+    const groupResults = await Promise.all(group.map(executeCheck));
+    results.push(...groupResults);
+    if (groupResults.some((r) => r.status === "failed")) {
+      shouldSkipRemaining = true;
+    }
+  }
+}
+async function runPreflight(checklist) {
+  const start = performance.now();
+  const results = [];
+  const preconditionsPassed = await runPreconditions(checklist.preconditions ?? [], results);
+  await (isFlatCheckList(checklist) ? runFlatChecks(checklist, results, preconditionsPassed) : runStagedChecks(checklist, results, preconditionsPassed));
+  const durationMs = performance.now() - start;
+  const passed = results.every((r) => r.status !== "failed");
+  return { results, passed, durationMs };
+}
+export {
+  runPreflight
+};

package/dist/esm/types.d.ts

@@ -0,0 +1,38 @@
+export type FixLocation = 'INLINE' | 'END';
+export interface PreflightCheck {
+    name: string;
+    check: () => boolean | Promise<boolean>;
+    fix?: string;
+}
+export interface PreflightResult {
+    name: string;
+    status: 'passed' | 'failed' | 'skipped';
+    fix?: string;
+    error?: Error;
+    durationMs: number;
+}
+export interface PreflightReport {
+    results: PreflightResult[];
+    passed: boolean;
+    durationMs: number;
+}
+export interface PreflightCheckList {
+    name: string;
+    preconditions?: PreflightCheck[];
+    checks: PreflightCheck[];
+    fixLocation?: FixLocation;
+}
+export interface StagedPreflightCheckList {
+    name: string;
+    preconditions?: PreflightCheck[];
+    groups: PreflightCheck[][];
+    fixLocation?: FixLocation;
+}
+export interface ReportOptions {
+    fixLocation?: FixLocation;
+}
+export interface PreflightConfig {
+    fixLocation?: FixLocation;
+    checklists: Array<PreflightCheckList | StagedPreflightCheckList>;
+}
+export declare function isFlatCheckList(checklist: PreflightCheckList | StagedPreflightCheckList): checklist is PreflightCheckList;

package/dist/esm/types.js

@@ -0,0 +1,6 @@
+function isFlatCheckList(checklist) {
+  return "checks" in checklist;
+}
+export {
+  isFlatCheckList
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@williamthorsen/preflight",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Run pre-deployment checks to verify environment and configuration",
+  "keywords": [
+    "checks",
+    "deploy",
+    "preflight",
+    "verification"
+  ],
+  "homepage": "https://github.com/williamthorsen/node-monorepo-tools/tree/main/packages/preflight#readme",
+  "bugs": {
+    "url": "https://github.com/williamthorsen/node-monorepo-tools/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/williamthorsen/node-monorepo-tools.git",
+    "directory": "packages/preflight"
+  },
+  "license": "MIT",
+  "author": "William Thorsen <william@thorsen.dev> (https://github.com/williamthorsen)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js"
+    }
+  },
+  "bin": {
+    "preflight": "bin/preflight.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "jiti": "2.6.1"
+  },
+  "engines": {
+    "node": ">=18.17.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {}
+}