@lunora/cli 1.0.0-alpha.100 → 1.0.0-alpha.102

package/dist/packem_shared/createLogger-CIWSHrTL.mjs

@@ -1,105 +0,0 @@
-import { STEP_BADGE_NAMES, LunoraReporter } from '@lunora/config';
-import { JsonReporter } from '@visulima/pail/reporter/json';
-import { createPail } from '@visulima/pail/server';
-
-let sharedPail;
-let jsonForced = false;
-let configuredReporters;
-const wantJson = () => {
-  if (jsonForced) {
-    return true;
-  }
-  const flag = process.env.LUNORA_LOG_JSON;
-  return flag === "1" || flag === "true";
-};
-const constructReporter = (Reporter) => new Reporter();
-const buildReporters = () => {
-  if (jsonForced) {
-    return [constructReporter(JsonReporter)];
-  }
-  if (configuredReporters !== void 0 && configuredReporters.length > 0) {
-    return configuredReporters;
-  }
-  return [constructReporter(wantJson() ? JsonReporter : LunoraReporter)];
-};
-const forceJsonLogging = () => {
-  if (jsonForced) {
-    return;
-  }
-  jsonForced = true;
-  sharedPail = void 0;
-};
-const logHandlers = {
-  compose: (...reporters) => reporters,
-  console: () => constructReporter(LunoraReporter),
-  json: () => constructReporter(JsonReporter)
-};
-const configureLogHandlers = (reporters) => {
-  configuredReporters = Array.isArray(reporters) ? reporters : [reporters];
-  sharedPail = void 0;
-};
-const STEP_LOG_TYPES = Object.fromEntries(STEP_BADGE_NAMES.map((name) => [name, { label: name, logLevel: "informational" }]));
-const getPail = () => {
-  sharedPail ??= createPail({
-    reporters: buildReporters(),
-    scope: ["lunora"],
-    stderr: process.stderr,
-    stdout: process.stdout,
-    types: STEP_LOG_TYPES
-  });
-  return sharedPail;
-};
-const createLogger = () => {
-  return {
-    debug: (message) => {
-      getPail().debug(message);
-    },
-    error: (message) => {
-      getPail().error(message);
-    },
-    info: (message) => {
-      getPail().info(message);
-    },
-    success: (message) => {
-      getPail().success(message);
-    },
-    warn: (message) => {
-      getPail().warn(message);
-    }
-  };
-};
-const createStderrLogger = () => {
-  const write = (tag, message) => {
-    process.stderr.write(`${tag} ${message}
-`);
-  };
-  return {
-    debug: (message) => {
-      write("debug", message);
-    },
-    error: (message) => {
-      write("error", message);
-    },
-    info: (message) => {
-      write("info ", message);
-    },
-    success: (message) => {
-      write("ok   ", message);
-    },
-    warn: (message) => {
-      write("warn ", message);
-    }
-  };
-};
-const pail = /* @__PURE__ */ new Proxy({}, {
-  get(_target, property) {
-    const instance = getPail();
-    const value = instance[property];
-    return typeof value === "function" ? value.bind(instance) : value;
-  }
-});
-const logStep = (type, message) => {
-  getPail()[type](message);
-};
-
-export { configureLogHandlers, createLogger, createStderrLogger, forceJsonLogging, getPail, logHandlers, logStep, pail };

package/dist/packem_shared/createRecordingSpawner-WuSn20kb.mjs

@@ -1,64 +0,0 @@
-import { spawn } from 'node:child_process';
-
-const NEEDS_CMD_QUOTING = /[\s"%&<>^|]/u;
-const BACKSLASH_RUN_BEFORE_QUOTE = /(\\*)"/gu;
-const TRAILING_BACKSLASH_RUN = /(\\+)$/u;
-const spawnShellCompat = (command, args, platform = process.platform) => {
-  if (platform !== "win32" || command === process.execPath) {
-    return { args: [...args], command, shell: false };
-  }
-  const quote = (value) => {
-    if (value === "") {
-      return `""`;
-    }
-    if (!NEEDS_CMD_QUOTING.test(value)) {
-      return value;
-    }
-    const escaped = value.replaceAll(BACKSLASH_RUN_BEFORE_QUOTE, String.raw`$1$1\"`).replace(TRAILING_BACKSLASH_RUN, "$1$1");
-    return `"${escaped}"`;
-  };
-  return { args: args.map((argument) => quote(argument)), command: quote(command), shell: true };
-};
-const defaultSpawner = (descriptor) => new Promise((resolve, reject) => {
-  const hasInput = typeof descriptor.input === "string";
-  const wantCapture = descriptor.captureStdout === true;
-  let stdout = "inherit";
-  if (wantCapture) {
-    stdout = "pipe";
-  } else if (descriptor.stdoutToStderr) {
-    stdout = 2;
-  }
-  const exec = spawnShellCompat(descriptor.command, descriptor.args);
-  const child = spawn(exec.command, exec.args, {
-    cwd: descriptor.cwd ?? process.cwd(),
-    env: descriptor.env ? { ...process.env, ...descriptor.env } : process.env,
-    shell: exec.shell,
-    stdio: [hasInput ? "pipe" : "inherit", stdout, "inherit"]
-  });
-  let captured = "";
-  if (wantCapture && child.stdout) {
-    child.stdout.on("data", (chunk) => {
-      captured += chunk.toString("utf8");
-      process.stdout.write(chunk);
-    });
-  }
-  child.on("error", (error) => {
-    reject(error);
-  });
-  child.on("exit", (code, signal) => {
-    resolve({ code: code ?? (signal ? 1 : 0), stdout: wantCapture ? captured : void 0 });
-  });
-  if (hasInput && child.stdin) {
-    child.stdin.end(descriptor.input);
-  }
-});
-const createRecordingSpawner = (exitCode = 0) => {
-  const calls = [];
-  const spawner = (descriptor) => {
-    calls.push({ descriptor });
-    return Promise.resolve({ code: exitCode });
-  };
-  return { calls, spawner };
-};
-
-export { createRecordingSpawner, defaultSpawner, spawnShellCompat };

package/dist/packem_shared/detect-package-manager-v4hHpQd0.mjs

@@ -1,62 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { LunoraError } from '@lunora/errors';
-import { findPackageManagerSync, identifyInitiatingPackageManager } from '@visulima/package/package-manager';
-
-const INSTALL_PREFERENCE = ["pnpm", "bun", "yarn", "npm"];
-const KNOWN_PACKAGE_MANAGERS = /* @__PURE__ */ new Set(["bun", "npm", "pnpm", "yarn"]);
-const isKnownPackageManager = (name) => KNOWN_PACKAGE_MANAGERS.has(name);
-const isManagerInstalled = (manager) => {
-  try {
-    return spawnSync(manager, ["--version"], { stdio: "ignore", timeout: 5e3 }).status === 0;
-  } catch {
-    return false;
-  }
-};
-const detectInstalledManagers = (probe = isManagerInstalled) => INSTALL_PREFERENCE.filter((manager) => probe(manager));
-const installArgsFor = (manager) => {
-  return { args: ["install"], command: manager };
-};
-const detectPackageManager = (startDirectory) => {
-  try {
-    return findPackageManagerSync(startDirectory).packageManager;
-  } catch {
-  }
-  const initiating = identifyInitiatingPackageManager();
-  if (initiating !== void 0) {
-    const name = initiating.name === "cnpm" ? "npm" : initiating.name;
-    if (isKnownPackageManager(name)) {
-      return name;
-    }
-  }
-  const [installed] = detectInstalledManagers();
-  if (installed !== void 0) {
-    return installed;
-  }
-  throw new LunoraError(
-    "INTERNAL",
-    "Could not detect a package manager: no lock file or `packageManager` field was found, and none (pnpm, bun, yarn, npm) is installed on PATH."
-  );
-};
-const execArgsFor = (manager, command, args) => {
-  if (manager === "yarn") {
-    return { args: [command, ...args], command: "yarn" };
-  }
-  if (manager === "bun") {
-    return { args: ["x", command, ...args], command: "bun" };
-  }
-  if (manager === "npm") {
-    return { args: ["--", command, ...args], command: "npx" };
-  }
-  return { args: ["exec", command, ...args], command: "pnpm" };
-};
-const runScriptCommand = (manager, script) => {
-  if (manager === "npm") {
-    return `npm run ${script}`;
-  }
-  if (manager === "bun") {
-    return `bun run ${script}`;
-  }
-  return `${manager} ${script}`;
-};
-
-export { detectInstalledManagers as a, detectPackageManager as d, execArgsFor as e, installArgsFor as i, runScriptCommand as r };

package/dist/packem_shared/diffSnapshots-BeDvvNiF.mjs

@@ -1,161 +0,0 @@
-import { quoteIdentifier, sqlAffinityForKind, frameworkColumnDdl, columnRef, physicalIndexName } from '@lunora/d1/dialect';
-
-const validatorKindToSqlType = (kind) => sqlAffinityForKind(kind);
-const renderColumnDefinition = (name, column) => {
-  const parts = [quoteIdentifier(name), column.sqlType];
-  if (!column.nullable) {
-    parts.push("NOT NULL");
-  }
-  return parts.join(" ");
-};
-const renderCreateTable = (table) => {
-  const columns = Object.entries(table.columns).map(([columnName, column]) => `    ${renderColumnDefinition(columnName, column)}`);
-  const lines = [...frameworkColumnDdl().map((column) => `    ${column}`), ...columns].join(",\n");
-  return `CREATE TABLE IF NOT EXISTS ${quoteIdentifier(table.name)} (
-${lines}
-);`;
-};
-const renderDropTable = (tableName) => `DROP TABLE IF EXISTS ${quoteIdentifier(tableName)};`;
-const renderAddColumn = (tableName, columnName, column) => `ALTER TABLE ${quoteIdentifier(tableName)} ADD COLUMN ${renderColumnDefinition(columnName, column)};`;
-const renderCreateIndex = (tableName, index) => {
-  const fields = index.fields.map((field) => columnRef(field)).join(", ");
-  const uniqueClause = index.unique ? "UNIQUE " : "";
-  return `CREATE ${uniqueClause}INDEX IF NOT EXISTS ${physicalIndexName(tableName, index.name)} ON ${quoteIdentifier(tableName)} (${fields});`;
-};
-const renderDropIndex = (tableName, indexName) => `DROP INDEX IF EXISTS ${physicalIndexName(tableName, indexName)};`;
-const diffExistingColumn = (tableName, columnName, old, column, unsupported) => {
-  if (old.sqlType !== column.sqlType) {
-    unsupported.push({
-      kind: "columnTypeChange",
-      summary: `column type change on ${tableName}.${columnName}: ${old.sqlType} → ${column.sqlType} (write SQL manually)`
-    });
-  }
-  if (old.nullable !== column.nullable) {
-    unsupported.push({
-      kind: "columnTypeChange",
-      summary: `nullability change on ${tableName}.${columnName}: ${old.nullable ? "NULL" : "NOT NULL"} → ${column.nullable ? "NULL" : "NOT NULL"} (write SQL manually)`
-    });
-  }
-};
-const diffColumns = (tableName, previous, next, entries, unsupported) => {
-  for (const [columnName, column] of Object.entries(next)) {
-    const old = previous[columnName];
-    if (old === void 0) {
-      entries.push({
-        kind: "addColumn",
-        sql: renderAddColumn(tableName, columnName, column),
-        summary: `ADD COLUMN ${tableName}.${columnName}`
-      });
-      continue;
-    }
-    diffExistingColumn(tableName, columnName, old, column, unsupported);
-  }
-  for (const columnName of Object.keys(previous)) {
-    if (next[columnName] === void 0) {
-      unsupported.push({
-        kind: "dropColumn",
-        summary: `DROP COLUMN ${tableName}.${columnName} (SQLite drop-column requires careful migration — write SQL manually)`
-      });
-    }
-  }
-};
-const diffIndexes = (tableName, previous, next, entries, unsupported) => {
-  for (const [indexName, index] of Object.entries(next)) {
-    const old = previous[indexName];
-    if (old === void 0) {
-      entries.push({
-        kind: "createIndex",
-        sql: renderCreateIndex(tableName, index),
-        summary: `CREATE INDEX ${indexName} ON ${tableName}`
-      });
-      continue;
-    }
-    const fieldsEqual = old.fields.length === index.fields.length && old.fields.every((field, i) => field === index.fields[i]);
-    if (!fieldsEqual || old.unique !== index.unique) {
-      unsupported.push({
-        kind: "indexRename",
-        summary: `index ${indexName} changed on ${tableName} — drop+create manually if intentional`
-      });
-    }
-  }
-  for (const indexName of Object.keys(previous)) {
-    if (next[indexName] === void 0) {
-      entries.push({
-        kind: "dropIndex",
-        sql: renderDropIndex(tableName, indexName),
-        summary: `DROP INDEX ${indexName}`
-      });
-    }
-  }
-};
-const diffNewTable = (tableName, table, entries) => {
-  entries.push({
-    kind: "createTable",
-    sql: renderCreateTable(table),
-    summary: `CREATE TABLE ${tableName}`
-  });
-  for (const index of Object.values(table.indexes)) {
-    entries.push({
-      kind: "createIndex",
-      sql: renderCreateIndex(tableName, index),
-      summary: `CREATE INDEX ${index.name} ON ${tableName}`
-    });
-  }
-};
-const diffSnapshots = (previous, next) => {
-  const previousTables = previous?.tables ?? {};
-  const entries = [];
-  const unsupported = [];
-  for (const [tableName, table] of Object.entries(next.tables)) {
-    const old = previousTables[tableName];
-    if (old === void 0) {
-      diffNewTable(tableName, table, entries);
-      continue;
-    }
-    diffColumns(tableName, old.columns, table.columns, entries, unsupported);
-    diffIndexes(tableName, old.indexes, table.indexes, entries, unsupported);
-  }
-  for (const [tableName] of Object.entries(previousTables)) {
-    if (next.tables[tableName] === void 0) {
-      entries.push({
-        kind: "dropTable",
-        sql: renderDropTable(tableName),
-        summary: `DROP TABLE ${tableName}`
-      });
-    }
-  }
-  return {
-    empty: entries.length === 0 && unsupported.length === 0,
-    entries,
-    unsupported
-  };
-};
-const renderMigrationFile = (name, diff, generatedAt) => {
-  const lines = [
-    `-- Lunora migration: ${name}`,
-    `-- Generated at ${generatedAt}`,
-    "-- This file was produced by `lunora migrate generate`. Review carefully before applying.",
-    ""
-  ];
-  for (const entry of diff.entries) {
-    lines.push(`-- ${entry.summary}`, entry.sql, "");
-  }
-  if (diff.unsupported.length > 0) {
-    lines.push(
-      "-- ---------------------------------------------------------------",
-      "-- The following deltas are NOT auto-generated in v0.1.",
-      "-- Write the appropriate SQL below by hand:",
-      "--"
-    );
-    for (const entry of diff.unsupported) {
-      lines.push(`--   * ${entry.summary}`);
-    }
-    lines.push("-- ---------------------------------------------------------------", "");
-  }
-  if (diff.empty) {
-    lines.push("-- No changes detected. Re-running `lunora migrate generate` will overwrite this file.", "");
-  }
-  return lines.join("\n");
-};
-
-export { diffSnapshots, renderAddColumn, renderCreateIndex, renderCreateTable, renderDropIndex, renderDropTable, renderMigrationFile, validatorKindToSqlType };

package/dist/packem_shared/docker-hMQ97KSQ.mjs

@@ -1,21 +0,0 @@
-import { spawnSync } from 'node:child_process';
-
-const isDockerAvailable = () => {
-  try {
-    return spawnSync("docker", ["info"], { stdio: "ignore" }).status === 0;
-  } catch {
-    return false;
-  }
-};
-const isRailpackAvailable = () => {
-  if (typeof process.env.BUILDKIT_HOST !== "string" || process.env.BUILDKIT_HOST.length === 0) {
-    return false;
-  }
-  try {
-    return spawnSync("railpack", ["--version"], { stdio: "ignore" }).status === 0;
-  } catch {
-    return false;
-  }
-};
-
-export { isRailpackAvailable as a, isDockerAvailable as i };

package/dist/packem_shared/insertSchemaExtension-DAqbfr9Z.mjs

@@ -1,64 +0,0 @@
-import { Project, SyntaxKind, Node } from 'ts-morph';
-
-const VALID_JS_IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
-const startMarker = (key) => `// lunora:add:${key}:start`;
-const endMarker = (key) => `// lunora:add:${key}:end`;
-const extensionImportSpecifier = (key) => `./${key}/schema`;
-const findDefineSchemaCall = (callExpressions) => {
-  for (const call of callExpressions) {
-    if (call.getExpression().getText() === "defineSchema") {
-      return call;
-    }
-  }
-  return void 0;
-};
-const outermostChainExpression = (defineSchemaCall) => {
-  let node = defineSchemaCall;
-  for (let parent = node.getParent(); parent !== void 0; parent = node.getParent()) {
-    if (Node.isPropertyAccessExpression(parent) && parent.getExpression() === node) {
-      node = parent;
-    } else if (Node.isCallExpression(parent) && parent.getExpression() === node) {
-      node = parent;
-    } else {
-      break;
-    }
-  }
-  return node;
-};
-const insertSchemaExtension = (source, key) => {
-  if (!VALID_JS_IDENTIFIER.test(key)) {
-    return { ok: false, reason: "invalid-identifier" };
-  }
-  if (source.includes(startMarker(key))) {
-    return { ok: false, reason: "already-applied" };
-  }
-  const project = new Project({
-    compilerOptions: { allowJs: true },
-    useInMemoryFileSystem: true
-  });
-  const sourceFile = project.createSourceFile("schema.ts", source, { overwrite: true });
-  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
-  const defineSchemaCall = findDefineSchemaCall(callExpressions);
-  if (!defineSchemaCall) {
-    return { ok: false, reason: "no-define-schema" };
-  }
-  const tablesArgument = defineSchemaCall.getArguments()[0];
-  if (tablesArgument?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-    return { ok: false, reason: "non-object-argument" };
-  }
-  const insertAt = outermostChainExpression(defineSchemaCall).getEnd();
-  const chainText = `
-    ${startMarker(key)}
-    .extend(${key}.extension)
-    ${endMarker(key)}
-`;
-  sourceFile.insertText(insertAt, chainText);
-  const importText = `${startMarker(key)}
-import { ${key} } from "${extensionImportSpecifier(key)}";
-${endMarker(key)}
-`;
-  sourceFile.insertText(0, importText);
-  return { ok: true, text: sourceFile.getFullText() };
-};
-
-export { insertSchemaExtension };

package/dist/packem_shared/open-url-4PBLY9X0.mjs

@@ -1,42 +0,0 @@
-import { spawn } from 'node:child_process';
-import { platform } from 'node:os';
-import { LunoraError } from '@lunora/errors';
-
-const platformCommand = () => {
-  const os = platform();
-  if (os === "darwin") {
-    return { args: [], command: "open" };
-  }
-  if (os === "win32") {
-    return { args: ["/c", "start", ""], command: "cmd" };
-  }
-  return { args: [], command: "xdg-open" };
-};
-const escapeForCmd = (url) => url.replaceAll("%", "%25").replaceAll("&", "%26").replaceAll("|", "%7C").replaceAll("^", "%5E").replaceAll("<", "%3C").replaceAll(">", "%3E").replaceAll("(", "%28").replaceAll(")", "%29").replaceAll('"', "%22").replaceAll("!", "%21");
-const platformOpener = (url) => new Promise((resolve, reject) => {
-  const { args, command } = platformCommand();
-  const safeUrl = platform() === "win32" ? escapeForCmd(url) : url;
-  const child = spawn(command, [...args, safeUrl], { detached: true, stdio: "ignore" });
-  child.once("error", (error) => {
-    reject(error);
-  });
-  child.once("spawn", () => {
-    child.unref();
-    resolve();
-  });
-});
-const openUrl = async (url, options = {}) => {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new LunoraError("INTERNAL", `Invalid URL: ${url}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new LunoraError("INTERNAL", `Refusing to open non-http(s) URL: ${url}`);
-  }
-  const opener = options.opener ?? platformOpener;
-  await opener(url);
-};
-
-export { openUrl as o };

package/dist/packem_shared/output-format-B4642rjE.mjs

@@ -1,17 +0,0 @@
-import { createStderrLogger } from './createLogger-CIWSHrTL.mjs';
-
-const OUTPUT_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
-const validateOutputFormat = (command, format) => {
-  if (format !== void 0 && !OUTPUT_FORMATS.has(format)) {
-    return `${command}: unknown --format "${format}" — expected pretty | json`;
-  }
-  return void 0;
-};
-const isJsonFormat = (format) => format === "json";
-const loggerForFormat = (format, prettyLogger) => isJsonFormat(format) ? createStderrLogger() : prettyLogger;
-const printJson = (result) => {
-  process.stdout.write(`${JSON.stringify(result, void 0, 2)}
-`);
-};
-
-export { isJsonFormat as i, loggerForFormat as l, printJson as p, validateOutputFormat as v };

package/dist/packem_shared/parseManifest-Dbp-Q2q3.mjs

@@ -1,121 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const NEWLINE_PRESENT = /[\r\n]/u;
-const VALID_ENV_NAME = /^[A-Za-z_]\w*$/u;
-const VALID_ITEM_NAME = /^[A-Za-z0-9][\w-]*$/u;
-const VALID_MODULE_PATH = /^[\w.-]+(?:\/[\w.-]+)*$/u;
-const parseManifest = (raw, itemName) => {
-  if (typeof raw !== "object" || raw === null) {
-    throw new LunoraError("INTERNAL", `registry.json for "${itemName}" is not an object`);
-  }
-  const record = raw;
-  const { name } = record;
-  if (typeof name !== "string" || name.length === 0) {
-    throw new LunoraError("INTERNAL", `registry.json for "${itemName}" is missing a string "name"`);
-  }
-  if (!VALID_ITEM_NAME.test(name)) {
-    throw new LunoraError(
-      "INTERNAL",
-      `registry.json for "${itemName}": name "${name}" must match ${VALID_ITEM_NAME.source} (letters, digits, "-", "_"; no path separators, "..", or code)`
-    );
-  }
-  const filesRaw = record.files;
-  if (!Array.isArray(filesRaw)) {
-    throw new TypeError(`registry.json for "${itemName}" is missing a "files" array`);
-  }
-  const files = filesRaw.map((entry, index) => {
-    if (typeof entry !== "object" || entry === null) {
-      throw new LunoraError("INTERNAL", `registry.json "${itemName}": files[${String(index)}] is not an object`);
-    }
-    const fileRecord = entry;
-    const { from } = fileRecord;
-    const { to } = fileRecord;
-    const { merge } = fileRecord;
-    if (typeof from !== "string" || typeof to !== "string") {
-      throw new TypeError(`registry.json "${itemName}": files[${String(index)}] needs string "from" and "to"`);
-    }
-    if (merge !== "create-or-skip" && merge !== "schema-extension") {
-      throw new LunoraError("INTERNAL", `registry.json "${itemName}": files[${String(index)}].merge must be "create-or-skip" or "schema-extension"`);
-    }
-    for (const [field, value] of [
-      ["from", from],
-      ["to", to]
-    ]) {
-      if (value.includes("..") || value.startsWith("/")) {
-        throw new LunoraError(
-          "INTERNAL",
-          `registry.json "${itemName}": files[${String(index)}].${field} "${value}" must be a relative path without ".."`
-        );
-      }
-    }
-    return { from, merge, to };
-  });
-  const asStringMap = (value) => typeof value === "object" && value !== null ? value : void 0;
-  const deps = asStringMap(record.deps);
-  const devDependencies = asStringMap(record.devDependencies);
-  const requires = Array.isArray(record.requires) ? record.requires.filter((value) => typeof value === "string") : void 0;
-  const bindings = Array.isArray(record.bindings) ? record.bindings.filter((value) => {
-    if (typeof value !== "object" || value === null) {
-      return false;
-    }
-    const bindingRecord = value;
-    return Array.isArray(bindingRecord.path) && bindingRecord.path.every((segment) => typeof segment === "string");
-  }) : void 0;
-  const entrypointReexports = Array.isArray(record.entrypointReexports) ? record.entrypointReexports.filter(
-    (value) => typeof value === "object" && value !== null && typeof value.module === "string"
-  ).map((entry) => {
-    if (entry.module.includes("..") || entry.module.startsWith("/") || !VALID_MODULE_PATH.test(entry.module)) {
-      throw new LunoraError(
-        "INTERNAL",
-        `registry.json "${itemName}": entrypointReexports[].module "${entry.module}" must be a safe relative module path without path traversal or unsafe characters`
-      );
-    }
-    const reexport = { module: entry.module };
-    if (typeof entry.comment === "string") {
-      if (NEWLINE_PRESENT.test(entry.comment)) {
-        throw new LunoraError("INTERNAL", `registry.json "${itemName}": entrypointReexports[].comment must not contain a newline`);
-      }
-      reexport.comment = entry.comment;
-    }
-    return reexport;
-  }) : void 0;
-  const envVariables = Array.isArray(record.envVars) ? record.envVars.filter(
-    (value) => typeof value === "object" && value !== null && typeof value.name === "string"
-  ).map((entry) => {
-    const hasValue = typeof entry.value === "string";
-    if (!VALID_ENV_NAME.test(entry.name)) {
-      throw new LunoraError(
-        "INTERNAL",
-        `registry.json "${itemName}": envVars["${entry.name}"].name must match ${VALID_ENV_NAME.source} (letters, digits, underscore; no "=" or newline)`
-      );
-    }
-    if (hasValue && NEWLINE_PRESENT.test(entry.value)) {
-      throw new LunoraError("INTERNAL", `registry.json "${itemName}": envVars["${entry.name}"].value must not contain a newline`);
-    }
-    if (typeof entry.description === "string" && NEWLINE_PRESENT.test(entry.description)) {
-      throw new LunoraError("INTERNAL", `registry.json "${itemName}": envVars["${entry.name}"].description must not contain a newline`);
-    }
-    return {
-      ...typeof entry.description === "string" ? { description: entry.description } : {},
-      name: entry.name,
-      // Default to secret unless a concrete value is provided.
-      secret: typeof entry.secret === "boolean" ? entry.secret : !hasValue,
-      ...hasValue ? { value: entry.value } : {}
-    };
-  }) : void 0;
-  return {
-    bindings,
-    deps,
-    description: typeof record.description === "string" ? record.description : void 0,
-    devDependencies,
-    docs: typeof record.docs === "string" ? record.docs : void 0,
-    entrypointReexports,
-    envVars: envVariables,
-    files,
-    name,
-    requires,
-    title: typeof record.title === "string" ? record.title : void 0
-  };
-};
-
-export { parseManifest as default };

package/dist/packem_shared/prompt-cancelled-APzX1Im-.mjs

@@ -1,9 +0,0 @@
-class PromptCancelledError extends Error {
-  constructor() {
-    super("cancelled");
-    this.name = "PromptCancelledError";
-  }
-}
-const PROMPT_CANCEL_EXIT_CODE = 130;
-
-export { PromptCancelledError as P, PROMPT_CANCEL_EXIT_CODE as a };