@lunora/cli 0.0.0 → 1.0.0-alpha.2

package/dist/packem_shared/DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs

@@ -0,0 +1,244 @@
+import { createWriteStream, createReadStream } from 'node:fs';
+import { unlink, stat } from 'node:fs/promises';
+import { r as resolveAdminBaseUrl } from './admin-url-4UzT-CI4.mjs';
+
+const EXPORT_ENDPOINT_PATH = "/_lunora/admin/export";
+const IMPORT_ENDPOINT_PATH = "/_lunora/admin/import";
+const DEFAULT_IMPORT_BATCH_SIZE = 500;
+const resolveTables = (raw) => {
+  if (raw === void 0) {
+    return void 0;
+  }
+  const tables = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return tables.length > 0 ? tables : void 0;
+};
+const writeWithBackpressure = async (sink, line) => {
+  if (!sink.write(line)) {
+    await new Promise((resolve) => {
+      sink.once("drain", resolve);
+    });
+  }
+};
+const streamNdjsonToSink = async (body, sink) => {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let bytes = 0;
+  let rows = 0;
+  let leftover = "";
+  let done = false;
+  try {
+    while (!done) {
+      const read = await reader.read();
+      done = read.done;
+      if (read.value === void 0) {
+        continue;
+      }
+      bytes += read.value.length;
+      leftover += decoder.decode(read.value, { stream: true });
+      let newlineIndex = leftover.indexOf("\n");
+      while (newlineIndex !== -1) {
+        rows += 1;
+        const line = `${leftover.slice(0, newlineIndex)}
+`;
+        await writeWithBackpressure(sink, line);
+        leftover = leftover.slice(newlineIndex + 1);
+        newlineIndex = leftover.indexOf("\n");
+      }
+    }
+    if (leftover.length > 0) {
+      rows += 1;
+      await writeWithBackpressure(sink, `${leftover}
+`);
+    }
+    return { bytes, rows };
+  } finally {
+    reader.releaseLock();
+  }
+};
+const discardPartialExport = async (sink, outPath) => {
+  if (outPath === void 0) {
+    return;
+  }
+  sink.destroy();
+  try {
+    await unlink(outPath);
+  } catch {
+  }
+};
+const runExportCommand = async (options) => {
+  if (options.prod && options.url === void 0) {
+    options.logger.error("--prod requires an explicit --url (refusing to export from the implicit localhost worker)");
+    return { bytes: 0, code: 1, rows: 0 };
+  }
+  const token = options.token ?? process.env["LUNORA_ADMIN_TOKEN"];
+  if (!token) {
+    options.logger.error("admin token required — pass --token or set LUNORA_ADMIN_TOKEN");
+    return { bytes: 0, code: 1, rows: 0 };
+  }
+  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
+  if (baseUrl === void 0) {
+    return { bytes: 0, code: 1, rows: 0 };
+  }
+  const requestUrl = `${baseUrl}${EXPORT_ENDPOINT_PATH}`;
+  const tables = resolveTables(options.tables);
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("no fetch implementation available — pass fetchImpl or run on Node >= 18");
+  }
+  options.logger.info(`POST ${requestUrl} -> export${tables ? ` (tables: ${tables.join(",")})` : ""}`);
+  const response = await fetchImpl(requestUrl, {
+    body: JSON.stringify(tables ? { tables } : {}),
+    headers: { authorization: `Bearer ${token}`, "content-type": "application/json" },
+    method: "POST"
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    options.logger.error(`export failed: HTTP ${String(response.status)}: ${errorText}`);
+    return { bytes: 0, code: 1, rows: 0 };
+  }
+  if (!response.body) {
+    options.logger.error("export response carried no body");
+    return { bytes: 0, code: 1, rows: 0 };
+  }
+  const outPath = options.out === void 0 || options.out === "-" ? void 0 : options.out;
+  const sink = outPath === void 0 ? process.stdout : createWriteStream(outPath, { encoding: "utf8" });
+  let bytes;
+  let rows;
+  try {
+    ({ bytes, rows } = await streamNdjsonToSink(response.body, sink));
+  } catch (error) {
+    await discardPartialExport(sink, outPath);
+    throw error;
+  }
+  if (outPath !== void 0) {
+    await new Promise((resolve, reject) => {
+      sink.end((error) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      });
+    });
+    options.logger.success(`wrote ${String(rows)} rows to ${outPath} (${String(bytes)} bytes)`);
+  }
+  return { bytes, code: 0, rows };
+};
+const resolveImportRequest = async (options) => {
+  if (options.prod && options.url === void 0) {
+    options.logger.error("--prod requires an explicit --url (refusing to import to the implicit localhost worker)");
+    return void 0;
+  }
+  const token = options.token ?? process.env["LUNORA_ADMIN_TOKEN"];
+  if (!token) {
+    options.logger.error("admin token required — pass --token or set LUNORA_ADMIN_TOKEN");
+    return void 0;
+  }
+  try {
+    const stats = await stat(options.file);
+    if (!stats.isFile()) {
+      options.logger.error(`not a file: ${options.file}`);
+      return void 0;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    options.logger.error(`failed to stat ${options.file}: ${message}`);
+    return void 0;
+  }
+  const baseUrl = resolveAdminBaseUrl(options.url, options.logger);
+  if (baseUrl === void 0) {
+    return void 0;
+  }
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new TypeError("no fetch implementation available — pass fetchImpl or run on Node >= 18");
+  }
+  return { fetchImpl, requestUrl: `${baseUrl}${IMPORT_ENDPOINT_PATH}`, token };
+};
+const runImportCommand = async (options) => {
+  const request = await resolveImportRequest(options);
+  if (request === void 0) {
+    return { body: void 0, code: 1, inserted: 0 };
+  }
+  const { fetchImpl, requestUrl, token } = request;
+  const batchSize = options.batchSize ?? DEFAULT_IMPORT_BATCH_SIZE;
+  options.logger.info(`POST ${requestUrl} -> import ${options.file}`);
+  const stream = createReadStream(options.file, { encoding: "utf8" });
+  const inserted = {};
+  const errors = [];
+  let conflicts = 0;
+  let buffer = "";
+  let batch = [];
+  let lineNumber = 0;
+  const flush = async () => {
+    if (batch.length === 0) {
+      return;
+    }
+    const body2 = batch.join("\n");
+    batch = [];
+    const response = await fetchImpl(requestUrl, {
+      body: body2,
+      headers: { authorization: `Bearer ${token}`, "content-type": "application/x-ndjson" },
+      method: "POST"
+    });
+    if (!response.ok) {
+      const text = await response.text().catch(() => "<no body>");
+      throw new Error(`import batch failed (HTTP ${String(response.status)}): ${text}`);
+    }
+    const json = await response.json();
+    if (json.inserted) {
+      for (const [table, count] of Object.entries(json.inserted)) {
+        inserted[table] = (inserted[table] ?? 0) + count;
+      }
+    }
+    if (Array.isArray(json.errors)) {
+      errors.push(...json.errors);
+    }
+    if (typeof json.conflicts === "number") {
+      conflicts += json.conflicts;
+    }
+  };
+  const processLine = (line) => {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      return;
+    }
+    lineNumber += 1;
+    if (options.table === void 0) {
+      batch.push(trimmed);
+      return;
+    }
+    let parsedDocument;
+    try {
+      parsedDocument = JSON.parse(trimmed);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`invalid JSON on line ${String(lineNumber)}: ${message}`, { cause: error });
+    }
+    batch.push(JSON.stringify({ doc: parsedDocument, table: options.table }));
+  };
+  for await (const chunk of stream) {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    buffer += text;
+    let newlineIndex = buffer.indexOf("\n");
+    while (newlineIndex !== -1) {
+      processLine(buffer.slice(0, newlineIndex));
+      buffer = buffer.slice(newlineIndex + 1);
+      newlineIndex = buffer.indexOf("\n");
+      if (batch.length >= batchSize) {
+        await flush();
+      }
+    }
+  }
+  if (buffer.length > 0) {
+    processLine(buffer);
+  }
+  await flush();
+  const insertedTotal = Object.values(inserted).reduce((a, b) => a + b, 0);
+  const body = { conflicts, errors, inserted };
+  options.logger.info(JSON.stringify(body, void 0, 2));
+  options.logger.success(`imported ${String(insertedTotal)} rows (${String(conflicts)} conflicts, ${String(errors.length)} errors)`);
+  return { body, code: errors.length > 0 ? 1 : 0, inserted: insertedTotal };
+};
+
+export { DEFAULT_IMPORT_BATCH_SIZE, runExportCommand, runImportCommand };

package/dist/packem_shared/admin-url-4UzT-CI4.mjs

@@ -0,0 +1,19 @@
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "[::1]", "localhost"]);
+const TRAILING_SLASH = /\/$/u;
+const resolveAdminBaseUrl = (rawUrl, logger) => {
+  const candidate = rawUrl ?? "http://localhost:8787";
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    logger.error(`invalid --url: ${candidate}`);
+    return void 0;
+  }
+  if (!LOOPBACK_HOSTS.has(parsed.hostname) && parsed.protocol !== "https:") {
+    logger.error(`refusing to send the admin bearer over ${parsed.protocol}// to ${parsed.hostname} — use https for non-localhost targets`);
+    return void 0;
+  }
+  return candidate.replace(TRAILING_SLASH, "");
+};
+
+export { resolveAdminBaseUrl as r };

package/dist/packem_shared/api-spec-CtA6ilu4.mjs

@@ -0,0 +1,13 @@
+const API_SPEC_VALUES = ["both", "none", "openapi", "openrpc"];
+const API_SPEC_HELP = API_SPEC_VALUES.join(" | ");
+const parseApiSpec = (value) => {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  if (API_SPEC_VALUES.includes(value)) {
+    return value;
+  }
+  throw new Error(`invalid --api-spec "${value}" — expected one of: ${API_SPEC_HELP}`);
+};
+
+export { API_SPEC_HELP as A, parseApiSpec as p };

package/dist/packem_shared/buildRegistryIndex-BcYe607_.mjs

@@ -0,0 +1,38 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from '@visulima/path';
+import parseManifest from './parseManifest--vZf2FY1.mjs';
+
+const CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/gu;
+const stripControlChars = (value) => value === void 0 ? void 0 : value.replaceAll(CONTROL_CHARS, "");
+const listItemDirectories = (root) => readdirSync(root).filter((entry) => {
+  const full = join(root, entry);
+  return statSync(full).isDirectory() && existsSync(join(full, "registry.json"));
+});
+const collectCatalog = (root) => {
+  const indexPath = join(root, "index.json");
+  if (existsSync(indexPath)) {
+    const parsed = JSON.parse(readFileSync(indexPath, "utf8"));
+    if (Array.isArray(parsed.items)) {
+      return parsed.items.filter((entry) => typeof entry === "object" && entry !== null && typeof entry.name === "string").map((entry) => {
+        return { description: stripControlChars(entry.description), name: stripControlChars(entry.name) ?? entry.name };
+      });
+    }
+  }
+  return listItemDirectories(root).map((name) => {
+    const raw = JSON.parse(readFileSync(join(root, name, "registry.json"), "utf8"));
+    return { description: stripControlChars(raw.description), name };
+  });
+};
+const buildRegistryIndex = (root) => {
+  const items = listItemDirectories(root).map((name) => {
+    const manifest = parseManifest(JSON.parse(readFileSync(join(root, name, "registry.json"), "utf8")), name);
+    return {
+      ...manifest.description === void 0 ? {} : { description: manifest.description },
+      name: manifest.name,
+      ...manifest.title === void 0 ? {} : { title: manifest.title }
+    };
+  }).toSorted((a, b) => a.name.localeCompare(b.name));
+  return { items };
+};
+
+export { buildRegistryIndex, collectCatalog, listItemDirectories };

package/dist/packem_shared/command-BDXcJCCJ.mjs

@@ -0,0 +1,14 @@
+import { createLogger } from './createLogger-CHPNjFw2.mjs';
+
+const defineHandler = (body) => async (toolbox) => {
+  const logger = createLogger();
+  try {
+    const { code } = await body({ argument: toolbox.argument, cwd: toolbox.process.cwd, logger, options: toolbox.options });
+    toolbox.process.exit(code);
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    toolbox.process.exit(1);
+  }
+};
+
+export { defineHandler as d };

package/dist/packem_shared/createLogger-CHPNjFw2.mjs

@@ -0,0 +1,73 @@
+import { JsonReporter } from '@visulima/pail/reporter/json';
+import { PrettyReporter } from '@visulima/pail/reporter/pretty';
+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 : PrettyReporter;
+  return new Reporter();
+};
+let sharedPail;
+const getPail = () => {
+  sharedPail ??= createPail({
+    reporters: [buildReporter()],
+    scope: ["lunora"],
+    stderr: process.stderr,
+    stdout: process.stdout
+  });
+  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;
+  }
+});
+
+export { createLogger, createStderrLogger, getPail, pail };

package/dist/packem_shared/defaultSpawner-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/diffSnapshots-RR2ZE8Ya.mjs

@@ -0,0 +1,161 @@
+import { quoteIdentifier, columnRef, physicalIndexName, frameworkColumnDdl, sqlAffinityForKind } 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/features-ocSSpZtS.mjs

@@ -0,0 +1,24 @@
+const AUTH_PROVIDER_OPTIONS = [
+  { description: "Email + password on better-auth (default)", label: "Email & password", value: "auth" },
+  { description: "Clerk-hosted auth", label: "Clerk", value: "auth-clerk" },
+  { description: "Auth0 (OIDC)", label: "Auth0", value: "auth-auth0" }
+];
+const DEFAULT_AUTH_ITEM = "auth";
+const promptAuthProvider = async (select) => await select("Which auth provider?", AUTH_PROVIDER_OPTIONS, { default: DEFAULT_AUTH_ITEM }) ?? DEFAULT_AUTH_ITEM;
+const EMAIL_ITEM = "mail";
+const normalizeFeature = (raw) => {
+  const value = raw.trim();
+  if (value === "") {
+    return void 0;
+  }
+  const lower = value.toLowerCase();
+  if (lower === "auth") {
+    return { kind: "auth" };
+  }
+  if (lower === "email" || lower === "mail") {
+    return { kind: "email" };
+  }
+  return { item: lower, kind: "item" };
+};
+
+export { AUTH_PROVIDER_OPTIONS as A, DEFAULT_AUTH_ITEM as D, EMAIL_ITEM as E, normalizeFeature as n, promptAuthProvider as p };