@lunora/cli 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/createLogger-B40gPzQo.mjs

@@ -0,0 +1,78 @@
+import { STEP_BADGE_NAMES, LunoraReporter } from '@lunora/config';
+import { JsonReporter } from '@visulima/pail/reporter/json';
+import { createPail } from '@visulima/pail/server';
+
+const wantJson = () => {
+  const flag = process.env.LUNORA_LOG_JSON;
+  return flag === "1" || flag === "true";
+};
+const buildReporter = () => {
+  const Reporter = wantJson() ? JsonReporter : LunoraReporter;
+  return new Reporter();
+};
+const STEP_LOG_TYPES = Object.fromEntries(STEP_BADGE_NAMES.map((name) => [name, { label: name, logLevel: "informational" }]));
+let sharedPail;
+const getPail = () => {
+  sharedPail ??= createPail({
+    reporters: [buildReporter()],
+    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 { createLogger, createStderrLogger, getPail, logStep, pail };

package/dist/packem_shared/createRecordingSpawner-DxI3mebw.mjs

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+
+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 child = spawn(descriptor.command, [...descriptor.args], {
+    cwd: descriptor.cwd ?? process.cwd(),
+    env: descriptor.env ? { ...process.env, ...descriptor.env } : process.env,
+    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 };

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

@@ -0,0 +1,61 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from '@visulima/path';
+
+const FALLBACK = "pnpm";
+const KNOWN_MANAGERS = ["pnpm", "yarn", "npm", "bun"];
+const INSTALL_PREFERENCE = ["pnpm", "bun", "yarn", "npm"];
+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 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;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+    return parseDeclaredManager(parsed.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 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" };
+};
+
+export { detectInstalledManagers as a, detectPackageManager as d, execArgsFor as e, installArgsFor as i };

package/dist/packem_shared/diffSnapshots-BeDvvNiF.mjs

@@ -0,0 +1,161 @@
+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

@@ -0,0 +1,21 @@
+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-BuzF6-t2.mjs

@@ -0,0 +1,59 @@
+import { Project, SyntaxKind } 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 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 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 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-Dfq6fAyT.mjs

@@ -0,0 +1,41 @@
+import { spawn } from 'node:child_process';
+import { platform } from 'node:os';
+
+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 Error(`Invalid URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(`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-wUvAN6AL.mjs

@@ -0,0 +1,17 @@
+import { createStderrLogger } from './createLogger-B40gPzQo.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/parseArgs-YXFuKdEk.mjs

@@ -0,0 +1,56 @@
+const consumeLongOption = (body, next, booleanFlags, accumulator) => {
+  const eqIndex = body.indexOf("=");
+  if (eqIndex !== -1) {
+    accumulator.options[body.slice(0, eqIndex)] = body.slice(eqIndex + 1);
+    return 1;
+  }
+  if (booleanFlags.has(body)) {
+    accumulator.flags[body] = true;
+    return 1;
+  }
+  if (next !== void 0 && !next.startsWith("-")) {
+    accumulator.options[body] = next;
+    return 2;
+  }
+  accumulator.flags[body] = true;
+  return 1;
+};
+const consumeShortOption = (body, next, accumulator) => {
+  if (body.length > 1) {
+    accumulator.options[body[0]] = body.slice(1);
+    return 1;
+  }
+  if (next !== void 0 && !next.startsWith("-")) {
+    accumulator.options[body] = next;
+    return 2;
+  }
+  accumulator.flags[body] = true;
+  return 1;
+};
+const parseArgs = (argv, booleanFlags = /* @__PURE__ */ new Set()) => {
+  const accumulator = { flags: {}, options: {}, positional: [] };
+  let index = 0;
+  let terminated = false;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === void 0) {
+      index += 1;
+      continue;
+    }
+    if (terminated || !token.startsWith("-") || token.length === 1) {
+      accumulator.positional.push(token);
+      index += 1;
+      continue;
+    }
+    if (token === "--") {
+      terminated = true;
+      index += 1;
+      continue;
+    }
+    const next = argv[index + 1];
+    index += token.startsWith("--") ? consumeLongOption(token.slice(2), next, booleanFlags, accumulator) : consumeShortOption(token.slice(1), next, accumulator);
+  }
+  return { flags: accumulator.flags, options: accumulator.options, positional: accumulator.positional };
+};
+
+export { parseArgs as default };

package/dist/packem_shared/parseManifest--vZf2FY1.mjs

@@ -0,0 +1,94 @@
+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 parseManifest = (raw, itemName) => {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`registry.json for "${itemName}" is not an object`);
+  }
+  const record = raw;
+  const { name } = record;
+  if (typeof name !== "string" || name.length === 0) {
+    throw new Error(`registry.json for "${itemName}" is missing a string "name"`);
+  }
+  if (!VALID_ITEM_NAME.test(name)) {
+    throw new Error(
+      `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 Error(`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 Error(`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 Error(`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 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 Error(
+        `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 Error(`registry.json "${itemName}": envVars["${entry.name}"].value must not contain a newline`);
+    }
+    if (typeof entry.description === "string" && NEWLINE_PRESENT.test(entry.description)) {
+      throw new Error(`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,
+    envVars: envVariables,
+    files,
+    name,
+    requires,
+    title: typeof record.title === "string" ? record.title : void 0
+  };
+};
+
+export { parseManifest as default };

package/dist/packem_shared/resolve-target-qbsJ_5sF.mjs

@@ -0,0 +1,16 @@
+import { readLinkedProject } from '@lunora/config';
+
+const resolveWorkerUrl = ({ cwd, url }) => {
+  if (url !== void 0 && url !== "") {
+    return url;
+  }
+  return readLinkedProject(cwd)?.workerUrl;
+};
+const resolveProductionWorkerUrl = ({ cwd, prod, url }) => {
+  if (url !== void 0 && url !== "") {
+    return url;
+  }
+  return prod ? readLinkedProject(cwd)?.workerUrl : void 0;
+};
+
+export { resolveProductionWorkerUrl as a, resolveWorkerUrl as r };

package/dist/packem_shared/runAddCommand-CTRA_JlL.mjs

@@ -0,0 +1,4 @@
+import 'node:fs';
+import '@visulima/path';
+export { r as runAddCommand, a as runBuildIndexCommand, e as runListCommand, b as runRegistryViewCommand } from './commands-DPKWlqqX.mjs';
+import './buildRegistryIndex-BcYe607_.mjs';