@lunora/cli 1.0.0-alpha.8 → 1.0.0-alpha.80

package/dist/packem_shared/{commands-DqsEzojt.mjs → commands-ClEvcz3V.mjs}

@@ -1,15 +1,16 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { dirname, join } from '@visulima/path';
+import { dirname, join, relative } from '@visulima/path';
 import { DEV_VARS_FILE, parseDevVariableEntries } from '@lunora/config';
 import { modify, applyEdits, parse } from 'jsonc-parser';
 import { fileURLToPath } from 'node:url';
-import { a as tuiConfirm } from './tui-prompts-XHFxlOg5.mjs';
-import { collectCatalog, buildRegistryIndex } from './buildRegistryIndex-BcYe607_.mjs';
-import { insertSchemaExtension } from './insertSchemaExtension-BuzF6-t2.mjs';
+import { LunoraError } from '@lunora/errors';
+import { b as tuiConfirm } from './tui-prompts-BjEN8XgP.mjs';
+import { collectCatalog, buildRegistryIndex } from './buildRegistryIndex-BS5ig822.mjs';
+import { insertSchemaExtension } from './insertSchemaExtension-DAqbfr9Z.mjs';
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { downloadTemplate } from 'giget';
-import parseManifest from './parseManifest--vZf2FY1.mjs';
+import parseManifest from './parseManifest-Dbp-Q2q3.mjs';
 
 const DEFAULT_SOURCE_REF_FALLBACK = "alpha";
 const STABLE_BRANCH = "main";
@@ -54,17 +55,88 @@ const resolveVersionRef = (version) => {
 const resolveSourceRef = (ref) => {
   if (ref !== void 0 && ref.length > 0) {
     if (!isSafeRef(ref)) {
-      throw new Error(`invalid --ref "${ref}" — a ref may contain letters, digits, ".", "_", "-", "/", "@" and must not contain "..".`);
+      throw new LunoraError("INTERNAL", `invalid --ref "${ref}" — a ref may contain letters, digits, ".", "_", "-", "/", "@" and must not contain "..".`);
     }
     return ref;
   }
   return resolveVersionRef(resolveCliVersion());
 };
+const SOURCE_REPO = "anolilab/lunora";
+const COMMIT_SHA = /^[0-9a-f]{40}$/iu;
+const SEMVER_BODY = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)+)?(?:\+[0-9A-Za-z.-]+)?`;
+const LEADING_VERSION_TAG = new RegExp(String.raw`^v?${SEMVER_BODY}$`, "u");
+const PACKAGE_VERSION_TAG = new RegExp(String.raw`^(?:@[\w.-]+\/)?[\w.-]+@${SEMVER_BODY}$`, "u");
+const isImmutableRef = (ref) => COMMIT_SHA.test(ref) || LEADING_VERSION_TAG.test(ref) || PACKAGE_VERSION_TAG.test(ref);
+const githubAuthHeaders = () => {
+  const token = process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"];
+  return token !== void 0 && token.length > 0 ? { authorization: `Bearer ${token}` } : {};
+};
+const fetchBranchSha = async (branch) => {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${SOURCE_REPO}/commits/${encodeURIComponent(branch)}`, {
+      headers: { accept: "application/vnd.github+json", "user-agent": "lunora-cli", ...githubAuthHeaders() },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const body = await response.json();
+    return typeof body.sha === "string" && COMMIT_SHA.test(body.sha) ? body.sha : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const resolvePinnedSourceRef = async (ref, logger) => {
+  const resolved = resolveSourceRef(ref);
+  if (isImmutableRef(resolved)) {
+    return resolved;
+  }
+  const sha = await fetchBranchSha(resolved);
+  if (sha === void 0) {
+    logger.warn(`could not pin ${SOURCE_REPO}#${resolved} to a commit — fetching the UNPINNED branch (set GITHUB_TOKEN if rate-limited).`);
+    return resolved;
+  }
+  logger.info(`pinned ${SOURCE_REPO}#${resolved} → ${sha}`);
+  return sha;
+};
 const STABLE_DIST_TAG = "latest";
 const resolveDistTag = () => {
   const ref = resolveVersionRef(resolveCliVersion());
   return ref === STABLE_BRANCH ? STABLE_DIST_TAG : ref;
 };
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const registryBase = () => {
+  const configured = process.env["npm_config_registry"];
+  const base = configured !== void 0 && configured.length > 0 ? configured : DEFAULT_REGISTRY;
+  return base.endsWith("/") ? base.slice(0, -1) : base;
+};
+const resolveTagVersion = async (packageName, tag) => {
+  try {
+    const response = await fetch(`${registryBase()}/${packageName.replace("/", "%2F")}`, {
+      headers: { accept: "application/vnd.npm.install-v1+json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const packument = await response.json();
+    return packument["dist-tags"]?.[tag];
+  } catch {
+    return void 0;
+  }
+};
+const resolveTagVersions = async (names, tag) => {
+  const resolved = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...new Set(names)].map(async (name) => {
+      const version = await resolveTagVersion(name, tag);
+      if (version !== void 0) {
+        resolved.set(name, version);
+      }
+    })
+  );
+  return resolved;
+};
 
 const resolveDepRange = (range) => {
   if (!range.startsWith("workspace:")) {
@@ -76,8 +148,8 @@ const resolveDepRange = (range) => {
   }
   return rest;
 };
-const UMBRELLA_REEXPORTED_DEPS = /* @__PURE__ */ new Set(["@lunora/client", "@lunora/do", "@lunora/runtime", "@lunora/server", "@lunora/values"]);
-const UMBRELLA_IMPORT_RE = /(['"])@lunora\/(client|do|runtime|server|values)(\/[^'"]*)?\1/gu;
+const UMBRELLA_REEXPORTED_DEPS = /* @__PURE__ */ new Set(["@lunora/client", "@lunora/do", "@lunora/ratelimit", "@lunora/runtime", "@lunora/server", "@lunora/values"]);
+const UMBRELLA_IMPORT_RE = /(['"])@lunora\/(client|do|ratelimit|runtime|server|values)(\/[^'"]*)?\1/gu;
 const projectUsesUmbrella = (projectRoot) => {
   const packageJsonPath = join(projectRoot, "package.json");
   if (!existsSync(packageJsonPath)) {
@@ -386,11 +458,12 @@ export const schema = defineSchema({});
     return { kind: "skipped", path: schemaPath };
   }
   if (result.reason === "invalid-identifier") {
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `schema-extension item "${itemKey}" is not a valid JS identifier — it is spliced into lunora/schema.ts as \`import { ${itemKey} }\` / \`.extend(${itemKey}.extension)\`. Rename the item to a valid identifier (no leading digit, no "-").`
     );
   }
-  throw new Error(`schema-extension merge failed for "${itemKey}": ${result.reason}`);
+  throw new LunoraError("INTERNAL", `schema-extension merge failed for "${itemKey}": ${result.reason}`);
 };
 const previewWholeFile = (file, current, incoming, exists, logger) => {
   const lines = renderDiff(current, incoming);
@@ -449,6 +522,93 @@ const reconcileFile = (file, itemKey, itemDirectory, projectRoot, logger, lock,
   }
   return reconcileWholeFile(file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions, useUmbrella);
 };
+const WORKER_ENTRY_FALLBACKS = ["src/server.ts", "src/server/index.ts", "src/index.ts", "src/worker.ts"];
+const WRANGLER_MAIN_RE = /"main"\s*:\s*"([^"]+)"/u;
+const readWranglerMain = (projectRoot) => {
+  for (const file of ["wrangler.jsonc", "wrangler.json"]) {
+    const path = join(projectRoot, file);
+    if (!existsSync(path)) {
+      continue;
+    }
+    const match = WRANGLER_MAIN_RE.exec(readFileSync(path, "utf8"));
+    if (match?.[1]) {
+      return match[1];
+    }
+  }
+  return void 0;
+};
+const findWorkerEntry = (projectRoot) => {
+  const main = readWranglerMain(projectRoot);
+  const candidates = main === void 0 ? WORKER_ENTRY_FALLBACKS : [main, ...WORKER_ENTRY_FALLBACKS];
+  for (const candidate of candidates) {
+    const absolute = join(projectRoot, candidate);
+    if (!existsSync(absolute)) {
+      continue;
+    }
+    const content = readFileSync(absolute, "utf8");
+    if (!content.includes("createShardDO(")) {
+      break;
+    }
+    return { entryPath: absolute, main: candidate, source: content };
+  }
+  return void 0;
+};
+const computeRelativeSpecifier = (entryPath, projectRoot, moduleName) => {
+  const importPath = relative(dirname(entryPath), join(projectRoot, "lunora", moduleName)).replaceAll("\\", "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+};
+const logClassAFallback = (entrypointReexports, logger) => {
+  for (const reexport of entrypointReexports) {
+    const specifier = `./lunora/${reexport.module}.js`;
+    const instruction = `Add \`export * from "${specifier}"\` to your worker entry`;
+    const suffix = reexport.comment ? ` (${reexport.comment})` : "";
+    logger.warn(`${instruction}${suffix}`);
+  }
+  return 0;
+};
+const buildReexportLines = (entrypointReexports, entryPath, projectRoot, source) => {
+  const lines = [];
+  for (const reexport of entrypointReexports) {
+    const specifier = computeRelativeSpecifier(entryPath, projectRoot, reexport.module);
+    const escapedSpecifier = specifier.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    const existingRe = new RegExp(String.raw`export\s+\*\s+from\s+["']${escapedSpecifier}\.js["']`, "u");
+    if (existingRe.test(source)) {
+      continue;
+    }
+    if (reexport.comment) {
+      lines.push(`
+// ${reexport.comment}`);
+    }
+    lines.push(`export * from "${specifier}.js";`);
+  }
+  return lines;
+};
+const applyEntrypointReexports = (entrypointReexports, projectRoot, logger, diff) => {
+  if (entrypointReexports.length === 0) {
+    return 0;
+  }
+  const entry = findWorkerEntry(projectRoot);
+  if (entry === void 0) {
+    return logClassAFallback(entrypointReexports, logger);
+  }
+  const linesToAppend = buildReexportLines(entrypointReexports, entry.entryPath, projectRoot, entry.source);
+  if (linesToAppend.length === 0) {
+    return 0;
+  }
+  if (diff) {
+    for (const line of linesToAppend) {
+      if (line !== "") {
+        logger.info(`~ entrypoint: ${line}`);
+      }
+    }
+    return linesToAppend.length;
+  }
+  const separator = entry.source.endsWith("\n") ? "" : "\n";
+  writeFileSync(entry.entryPath, `${entry.source}${separator}${linesToAppend.join("\n")}
+`, "utf8");
+  logger.success(`wrote ${String(linesToAppend.length)} entrypoint re-export(s) to ${relative(projectRoot, entry.entryPath)}`);
+  return linesToAppend.length;
+};
 const reconcileItems = (items, cwd, logger, reconcileOptions = {}) => {
   const written = [];
   const skipped = [];
@@ -461,6 +621,9 @@ const reconcileItems = (items, cwd, logger, reconcileOptions = {}) => {
       const outcome = reconcileFile(file, manifest.name, directory, cwd, logger, lock, reconcileOptions, useUmbrella);
       (outcome.kind === "written" ? written : skipped).push(outcome.path);
     }
+    if (manifest.entrypointReexports !== void 0) {
+      applyEntrypointReexports(manifest.entrypointReexports, cwd, logger, reconcileOptions.diff === true);
+    }
     if (reconcileOptions.diff) {
       continue;
     }
@@ -478,7 +641,8 @@ const DEFAULT_SOURCE_BASE = "gh:anolilab/lunora/registry";
 const VALID_ITEM_NAME = /^[A-Za-z0-9][\w-]*$/u;
 const assertSafeItemName = (name) => {
   if (!VALID_ITEM_NAME.test(name)) {
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `invalid registry item name "${name}" — names must match ${VALID_ITEM_NAME.source} (letters, digits, "-", "_"; no path separators or "..")`
     );
   }
@@ -515,29 +679,39 @@ const fetchToStaging = async (remote, label, logger) => {
     throw error;
   }
 };
+const remoteRefCache = /* @__PURE__ */ new WeakMap();
+const resolveRemoteRef = async (options) => {
+  const cached = remoteRefCache.get(options);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const pending = options.source !== void 0 && options.source.length > 0 ? Promise.resolve(resolveSourceRef(options.ref)) : resolvePinnedSourceRef(options.ref, options.logger);
+  remoteRefCache.set(options, pending);
+  return pending;
+};
 const resolveItemDirectory = async (name, options) => {
   assertSafeItemName(name);
   if (options.from !== void 0) {
     const directory = join(options.from, name);
     if (!existsSync(directory)) {
-      throw new Error(`registry item not found in local source: ${directory}`);
+      throw new LunoraError("INTERNAL", `registry item not found in local source: ${directory}`);
     }
     return { cleanup: () => {
     }, directory };
   }
   const base = options.source ?? DEFAULT_SOURCE_BASE;
-  return fetchToStaging(`${base}/${name}#${resolveSourceRef(options.ref)}`, "item", options.logger);
+  return fetchToStaging(`${base}/${name}#${await resolveRemoteRef(options)}`, "item", options.logger);
 };
 const resolveRegistryRoot = async (options) => {
   if (options.from !== void 0) {
     if (!existsSync(options.from)) {
-      throw new Error(`registry root not found: ${options.from}`);
+      throw new LunoraError("INTERNAL", `registry root not found: ${options.from}`);
     }
     return { cleanup: () => {
     }, root: options.from };
   }
   const base = options.source ?? DEFAULT_SOURCE_BASE;
-  const { cleanup, directory } = await fetchToStaging(`${base}#${resolveSourceRef(options.ref)}`, "registry", options.logger);
+  const { cleanup, directory } = await fetchToStaging(`${base}#${await resolveRemoteRef(options)}`, "registry", options.logger);
   return { cleanup, root: directory };
 };
 const readManifest = (itemDirectory, name) => {
@@ -554,7 +728,7 @@ const resolvePlan = async (names, options) => {
       return;
     }
     if (inProgress.has(name)) {
-      throw new Error(`cyclic registry dependency detected at "${name}"`);
+      throw new LunoraError("INTERNAL", `cyclic registry dependency detected at "${name}"`);
     }
     inProgress.add(name);
     const { cleanup, directory } = await resolveItemDirectory(name, options);
@@ -583,6 +757,26 @@ const resolvePlan = async (names, options) => {
 const emptyResult = () => {
   return { bindings: [], code: 0, deps: [], skipped: [], written: [] };
 };
+const setBindingField = (manifest, section, match, field, fieldValue) => {
+  if (!manifest.bindings) {
+    return manifest;
+  }
+  return {
+    ...manifest,
+    bindings: manifest.bindings.map((binding) => {
+      if (binding.path[0] !== section || !Array.isArray(binding.value)) {
+        return binding;
+      }
+      const entries = binding.value;
+      return {
+        ...binding,
+        value: entries.map(
+          (entry) => typeof entry === "object" && entry !== null && entry[match.key] === match.value ? { ...entry, [field]: fieldValue } : entry
+        )
+      };
+    })
+  };
+};
 
 const printPlan = (logger, manifest) => {
   const label = manifest.title ?? manifest.description;
@@ -603,6 +797,11 @@ const printPlan = (logger, manifest) => {
     const valueSuffix = variable.secret ? " (secret)" : ` = ${JSON.stringify(variable.value ?? "")}`;
     logger.info(`  env   ${variable.name}${valueSuffix}`);
   }
+  for (const reexport of manifest.entrypointReexports ?? []) {
+    const specifier = `./lunora/${reexport.module}`;
+    const suffix = reexport.comment ? `  // ${reexport.comment}` : "";
+    logger.info(`  entry ${specifier}${suffix}`);
+  }
 };
 const printJsonPlan = (items) => {
   const planSnapshot = items.map(({ manifest }) => {
@@ -614,6 +813,9 @@ const printJsonPlan = (items) => {
       }),
       deps: Object.keys(manifest.deps ?? {}),
       devDependencies: Object.keys(manifest.devDependencies ?? {}),
+      entrypointReexports: (manifest.entrypointReexports ?? []).map((reexport) => {
+        return { module: reexport.module, ...reexport.comment ? { comment: reexport.comment } : {} };
+      }),
       envVars: (manifest.envVars ?? []).map((variable) => {
         return { name: variable.name, ...variable.secret ? { secret: true } : { value: variable.value ?? "" } };
       }),
@@ -688,8 +890,12 @@ const runAddCommand = async (options) => {
   }
   let cleanups = [];
   try {
-    const { cleanups: planCleanups, items } = await resolvePlan(options.names, options);
+    const { cleanups: planCleanups, items: resolvedItems } = await resolvePlan(options.names, options);
     cleanups = planCleanups;
+    const { transformManifest } = options;
+    const items = transformManifest ? resolvedItems.map((item) => {
+      return { ...item, manifest: transformManifest(item.manifest) };
+    }) : resolvedItems;
     for (const { manifest } of items) {
       printPlan(options.logger, manifest);
     }
@@ -785,4 +991,4 @@ const runBuildIndexCommand = async (options) => {
   return empty;
 };
 
-export { runBuildIndexCommand as a, runRegistryViewCommand as b, resolveDistTag as c, resolveSourceRef as d, runListCommand as e, runAddCommand as r };
+export { runBuildIndexCommand as a, runRegistryViewCommand as b, resolveTagVersions as c, resolveSourceRef as d, resolvePinnedSourceRef as e, resolveDistTag as f, runListCommand as g, runAddCommand as r, setBindingField as s };

package/dist/packem_shared/{createLogger-CHPNjFw2.mjs → createLogger-CIWSHrTL.mjs}

@@ -1,22 +1,51 @@
+import { STEP_BADGE_NAMES, LunoraReporter } from '@lunora/config';
 import { JsonReporter } from '@visulima/pail/reporter/json';
-import { PrettyReporter } from '@visulima/pail/reporter/pretty';
 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 buildReporter = () => {
-  const Reporter = wantJson() ? JsonReporter : PrettyReporter;
-  return new Reporter();
+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)];
 };
-let sharedPail;
+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: [buildReporter()],
+    reporters: buildReporters(),
     scope: ["lunora"],
     stderr: process.stderr,
-    stdout: process.stdout
+    stdout: process.stdout,
+    types: STEP_LOG_TYPES
   });
   return sharedPail;
 };
@@ -69,5 +98,8 @@ const pail = /* @__PURE__ */ new Proxy({}, {
     return typeof value === "function" ? value.bind(instance) : value;
   }
 });
+const logStep = (type, message) => {
+  getPail()[type](message);
+};
 
-export { createLogger, createStderrLogger, getPail, pail };
+export { configureLogHandlers, createLogger, createStderrLogger, forceJsonLogging, getPail, logHandlers, logStep, pail };

package/dist/packem_shared/{createRecordingSpawner-DxI3mebw.mjs → createRecordingSpawner-Cw5Iu73G.mjs}

@@ -1,5 +1,13 @@
 import { spawn } from 'node:child_process';
 
+const NEEDS_CMD_QUOTING = /\s/;
+const spawnShellCompat = (command, args, platform = process.platform) => {
+  if (platform !== "win32" || command === process.execPath) {
+    return { args: [...args], command, shell: false };
+  }
+  const quote = (value) => NEEDS_CMD_QUOTING.test(value) ? `"${value}"` : value;
+  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;
@@ -9,9 +17,11 @@ const defaultSpawner = (descriptor) => new Promise((resolve, reject) => {
   } else if (descriptor.stdoutToStderr) {
     stdout = 2;
   }
-  const child = spawn(descriptor.command, [...descriptor.args], {
+  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 = "";
@@ -40,4 +50,4 @@ const createRecordingSpawner = (exitCode = 0) => {
   return { calls, spawner };
 };
 
-export { createRecordingSpawner, defaultSpawner };
+export { createRecordingSpawner, defaultSpawner, spawnShellCompat };

package/dist/packem_shared/{detect-package-manager-DYp7n3mJ.mjs → detect-package-manager-DvEthdCw.mjs}

@@ -1,9 +1,7 @@
 import { spawnSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from '@visulima/path';
+import { LunoraError } from '@lunora/errors';
+import { findPackageManagerSync, identifyInitiatingPackageManager } from '@visulima/package/package-manager';
 
-const FALLBACK = "pnpm";
-const KNOWN_MANAGERS = ["pnpm", "yarn", "npm", "bun"];
 const INSTALL_PREFERENCE = ["pnpm", "bun", "yarn", "npm"];
 const isManagerInstalled = (manager) => {
   try {
@@ -16,34 +14,23 @@ const detectInstalledManagers = (probe = isManagerInstalled) => INSTALL_PREFEREN
 const installArgsFor = (manager) => {
   return { args: ["install"], command: manager };
 };
-const parseDeclaredManager = (declared) => {
-  if (typeof declared !== "string") {
-    return void 0;
-  }
-  return KNOWN_MANAGERS.find((manager) => declared.startsWith(`${manager}@`));
-};
-const readDeclaredManager = (directory) => {
-  const candidate = join(directory, "package.json");
-  if (!existsSync(candidate)) {
-    return void 0;
-  }
+const detectPackageManager = (startDirectory) => {
   try {
-    const parsed = JSON.parse(readFileSync(candidate, "utf8"));
-    return parseDeclaredManager(parsed.packageManager);
+    return findPackageManagerSync(startDirectory).packageManager;
   } catch {
-    return void 0;
   }
-};
-const detectPackageManager = (startDirectory) => {
-  let directory = startDirectory;
-  while (directory && directory !== dirname(directory)) {
-    const declared = readDeclaredManager(directory);
-    if (declared !== void 0) {
-      return declared;
-    }
-    directory = dirname(directory);
-  }
-  return FALLBACK;
+  const initiating = identifyInitiatingPackageManager();
+  if (initiating !== void 0) {
+    return initiating.name === "cnpm" ? "npm" : initiating.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") {
@@ -57,5 +44,14 @@ const execArgsFor = (manager, command, args) => {
   }
   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 };
+export { detectInstalledManagers as a, detectPackageManager as d, execArgsFor as e, installArgsFor as i, runScriptCommand as r };

package/dist/packem_shared/{insertSchemaExtension-BuzF6-t2.mjs → insertSchemaExtension-DAqbfr9Z.mjs}

@@ -1,4 +1,4 @@
-import { Project, SyntaxKind } from 'ts-morph';
+import { Project, SyntaxKind, Node } from 'ts-morph';
 
 const VALID_JS_IDENTIFIER = /^[A-Za-z_$][\w$]*$/u;
 const startMarker = (key) => `// lunora:add:${key}:start`;
@@ -12,6 +12,19 @@ const findDefineSchemaCall = (callExpressions) => {
   }
   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" };
@@ -33,15 +46,7 @@ const insertSchemaExtension = (source, key) => {
   if (tablesArgument?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
     return { ok: false, reason: "non-object-argument" };
   }
-  const variableDeclaration = defineSchemaCall.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
-  if (!variableDeclaration) {
-    return { ok: false, reason: "no-define-schema" };
-  }
-  const initializer = variableDeclaration.getInitializer();
-  if (!initializer) {
-    return { ok: false, reason: "no-define-schema" };
-  }
-  const insertAt = initializer.getEnd();
+  const insertAt = outermostChainExpression(defineSchemaCall).getEnd();
   const chainText = `
     ${startMarker(key)}
     .extend(${key}.extension)

package/dist/packem_shared/{open-url-Dfq6fAyT.mjs → open-url-4PBLY9X0.mjs}

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { platform } from 'node:os';
+import { LunoraError } from '@lunora/errors';
 
 const platformCommand = () => {
   const os = platform();
@@ -29,10 +30,10 @@ const openUrl = async (url, options = {}) => {
   try {
     parsed = new URL(url);
   } catch {
-    throw new Error(`Invalid URL: ${url}`);
+    throw new LunoraError("INTERNAL", `Invalid URL: ${url}`);
   }
   if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error(`Refusing to open non-http(s) URL: ${url}`);
+    throw new LunoraError("INTERNAL", `Refusing to open non-http(s) URL: ${url}`);
   }
   const opener = options.opener ?? platformOpener;
   await opener(url);

package/dist/packem_shared/{output-format-7gyGR3h8.mjs → output-format-B4642rjE.mjs}

@@ -1,4 +1,4 @@
-import { createStderrLogger } from './createLogger-CHPNjFw2.mjs';
+import { createStderrLogger } from './createLogger-CIWSHrTL.mjs';
 
 const OUTPUT_FORMATS = /* @__PURE__ */ new Set(["json", "pretty"]);
 const validateOutputFormat = (command, format) => {