@lunora/config 1.0.0-alpha.5 → 1.0.0-alpha.51

package/dist/packem_shared/DEV_DAEMON_ENV-FIEtW7Fz.mjs

@@ -0,0 +1,163 @@
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const DEV_STATE_DIR = ".lunora";
+const DEV_STATE_FILE = join(DEV_STATE_DIR, "dev.json");
+const DEV_LOG_FILE = join(DEV_STATE_DIR, "dev.log");
+const DEV_DAEMON_ENV = "LUNORA_DEV_DAEMON";
+const DEV_LOG_FILE_ENV = "LUNORA_DEV_LOG_FILE";
+const DEV_HANDOFF_ENV = "LUNORA_DEV_HANDOFF_PID";
+const isObject = (value) => value !== null && typeof value === "object";
+const stringField = (record, key) => {
+  const value = record[key];
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+};
+const isProcessAlive = (pid) => {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const START_TIME_SKEW_MS = 1e4;
+const LINUX_CLOCK_TICKS_PER_SECOND = 100;
+const processStartTimeMs = (pid) => {
+  if (process.platform !== "linux") {
+    return void 0;
+  }
+  try {
+    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+    const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+    const startTicks = Number(fields[19]);
+    const bootLine = readFileSync("/proc/stat", "utf8").split("\n").find((line) => line.startsWith("btime "));
+    const bootSeconds = Number(bootLine?.slice("btime ".length));
+    if (!Number.isFinite(startTicks) || !Number.isFinite(bootSeconds)) {
+      return void 0;
+    }
+    return bootSeconds * 1e3 + startTicks / LINUX_CLOCK_TICKS_PER_SECOND * 1e3;
+  } catch {
+    return void 0;
+  }
+};
+const isRecordedProcessCurrent = (state) => {
+  if (!isProcessAlive(state.pid)) {
+    return false;
+  }
+  const recordedAtMs = state.startedAt === void 0 ? Number.NaN : Date.parse(state.startedAt);
+  if (Number.isNaN(recordedAtMs)) {
+    return true;
+  }
+  const actualStartMs = processStartTimeMs(state.pid);
+  return actualStartMs === void 0 || actualStartMs <= recordedAtMs + START_TIME_SKEW_MS;
+};
+const readDevServerState = (projectRoot) => {
+  const path = join(projectRoot, DEV_STATE_FILE);
+  if (!existsSync(path)) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return void 0;
+  }
+  if (!isObject(parsed) || typeof parsed["pid"] !== "number") {
+    return void 0;
+  }
+  const url = stringField(parsed, "url");
+  if (url === void 0) {
+    return void 0;
+  }
+  return {
+    background: parsed["background"] === true,
+    logFile: stringField(parsed, "logFile"),
+    mode: parsed["mode"] === "vite" ? "vite" : "cli",
+    pid: parsed["pid"],
+    startedAt: stringField(parsed, "startedAt"),
+    studioUrl: stringField(parsed, "studioUrl"),
+    url
+  };
+};
+const writeDevServerState = (projectRoot, state) => {
+  try {
+    mkdirSync(join(projectRoot, DEV_STATE_DIR), { recursive: true });
+    const path = join(projectRoot, DEV_STATE_FILE);
+    writeFileSync(path, `${JSON.stringify(state, void 0, 2)}
+`, "utf8");
+    return path;
+  } catch {
+    return void 0;
+  }
+};
+const updateDevServerState = (projectRoot, patch) => {
+  const existing = readDevServerState(projectRoot);
+  if (existing === void 0) {
+    return void 0;
+  }
+  const merged = { ...existing, ...patch };
+  writeDevServerState(projectRoot, merged);
+  return merged;
+};
+const clearDevServerState = (projectRoot, expectedPid) => {
+  try {
+    if (expectedPid !== void 0) {
+      const current = readDevServerState(projectRoot);
+      if (current !== void 0 && current.pid !== expectedPid) {
+        return;
+      }
+    }
+    rmSync(join(projectRoot, DEV_STATE_FILE), { force: true });
+  } catch {
+  }
+};
+const readLiveDevServerState = (projectRoot) => {
+  const state = readDevServerState(projectRoot);
+  if (state === void 0) {
+    return void 0;
+  }
+  if (isRecordedProcessCurrent(state)) {
+    return state;
+  }
+  clearDevServerState(projectRoot, state.pid);
+  return void 0;
+};
+const resolveClaimConflict = (projectRoot, state, supersedePid) => {
+  const existing = readLiveDevServerState(projectRoot);
+  if (existing === void 0) {
+    return void 0;
+  }
+  if (supersedePid !== void 0 && existing.pid === supersedePid) {
+    return { ok: writeDevServerState(projectRoot, state) !== void 0 };
+  }
+  if (existing.pid !== state.pid) {
+    return { existing, ok: false };
+  }
+  return { ok: writeDevServerState(projectRoot, state) !== void 0 };
+};
+const claimDevServerState = (projectRoot, state, options) => {
+  const path = join(projectRoot, DEV_STATE_FILE);
+  const payload = `${JSON.stringify(state, void 0, 2)}
+`;
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    try {
+      mkdirSync(join(projectRoot, DEV_STATE_DIR), { recursive: true });
+      writeFileSync(path, payload, { encoding: "utf8", flag: "wx" });
+      return { ok: true };
+    } catch (error) {
+      if (error.code !== "EEXIST") {
+        return { ok: writeDevServerState(projectRoot, state) !== void 0 };
+      }
+      const resolved = resolveClaimConflict(projectRoot, state, options?.supersedePid);
+      if (resolved !== void 0) {
+        return resolved;
+      }
+    }
+  }
+  return { ok: writeDevServerState(projectRoot, state) !== void 0 };
+};
+
+export { DEV_DAEMON_ENV, DEV_HANDOFF_ENV, DEV_LOG_FILE, DEV_LOG_FILE_ENV, DEV_STATE_DIR, DEV_STATE_FILE, claimDevServerState, clearDevServerState, isProcessAlive, isRecordedProcessCurrent, readDevServerState, readLiveDevServerState, updateDevServerState, writeDevServerState };

package/dist/packem_shared/{LunoraReporter-DDGFirVv.mjs → LunoraReporter-Ci-bDCK9.mjs}

@@ -1,4 +1,4 @@
-import { paintBadge, badgeWidth, BADGES } from './ACCENT-DN2byyj1.mjs';
+import { paintBadge, badgeWidth, BADGES } from './ACCENT-DW1XJn8i.mjs';
 
 const NAME_ALIASES = {
   informational: "info",

package/dist/packem_shared/{PACKAGE_SECRETS_REGISTRY-CySy5vR_.mjs → PACKAGE_SECRETS_REGISTRY-B8t_SdoZ.mjs}

@@ -1,3 +1,11 @@
+const CORE_SECRETS = [
+  {
+    description: "Bearer token the local Lunora Studio uses to call the worker's admin endpoints (data browser, schema edits) in dev. Generate with: openssl rand -hex 32",
+    docsUrl: "https://lunora.sh/docs/packages/studio",
+    key: "LUNORA_ADMIN_TOKEN",
+    placeholderValue: "replace-with-openssl-rand-hex-32"
+  }
+];
 const PACKAGE_SECRETS_REGISTRY = {
   "@lunora/auth": [
     {
@@ -59,4 +67,4 @@ const secretsForPackages = (packageNames) => {
   return result;
 };
 
-export { PACKAGE_SECRETS_REGISTRY, secretsForPackages };
+export { CORE_SECRETS, PACKAGE_SECRETS_REGISTRY, secretsForPackages };

package/dist/packem_shared/{POLICY_SCAFFOLD_ENDPOINT-CiC2IGKx.mjs → POLICY_SCAFFOLD_ENDPOINT-8bNMHGiu.mjs}

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
 import { join, isAbsolute, relative } from 'node:path';
 import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { LunoraError } from '@lunora/errors';
 import { classifyPolicyEdit, scaffoldPolicyFile, wireRlsIntoProcedure } from './classifyPolicyEdit-BHeAqF8P.mjs';
 
 const POLICY_SCAFFOLD_ENDPOINT = "/__lunora/policy-scaffold";
@@ -97,7 +98,7 @@ const handlePolicyScaffoldRequest = (request) => {
   if (edit.kind === "wireRls") {
     return handleWireRls(request, edit);
   }
-  throw new Error(`unhandled additive policy edit kind: ${String(edit.kind)}`);
+  throw new LunoraError("INTERNAL", `unhandled additive policy edit kind: ${String(edit.kind)}`);
 };
 
 export { POLICY_SCAFFOLD_ENDPOINT, handlePolicyScaffoldRequest };

package/dist/packem_shared/{REQUIRED_COMPATIBILITY_DATE-ycqievRl.mjs → REQUIRED_COMPATIBILITY_DATE-2YYyWJUq.mjs}

@@ -1,6 +1,6 @@
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { discoverSchemaInfo } from './discoverSchemaInfo-DWtypqpP.mjs';
+import { discoverSchemaInfo } from './discoverSchemaInfo-BB-CKlTK.mjs';
 import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
 
 const REQUIRED_COMPATIBILITY_DATE = "2026-04-07";
@@ -127,6 +127,82 @@ const validateWorkflows = (wrangler, errors) => {
     }
   }
 };
+const validateQueueProducers = (producers, errors) => {
+  if (producers === void 0) {
+    return;
+  }
+  if (!Array.isArray(producers)) {
+    errors.push("queues.producers must be an array of { binding, queue } entries");
+    return;
+  }
+  const entries = producers;
+  for (const [index, entry] of entries.entries()) {
+    const label = `queues.producers[${String(index)}]`;
+    if (!entry || typeof entry !== "object") {
+      errors.push(`${label} must be a { binding, queue } object`);
+      continue;
+    }
+    if (typeof entry.binding !== "string" || entry.binding.length === 0) {
+      errors.push(`${label} must have a non-empty "binding" naming the Queue producer (e.g. QUEUE_EMAIL)`);
+    }
+    if (typeof entry.queue !== "string" || entry.queue.length === 0) {
+      errors.push(`${label} must have a non-empty "queue" naming the deployed queue`);
+    }
+  }
+};
+const validateQueueConsumers = (consumers, errors) => {
+  if (consumers === void 0) {
+    return;
+  }
+  if (!Array.isArray(consumers)) {
+    errors.push("queues.consumers must be an array of { queue } entries");
+    return;
+  }
+  const entries = consumers;
+  for (const [index, entry] of entries.entries()) {
+    const label = `queues.consumers[${String(index)}]`;
+    if (!entry || typeof entry !== "object") {
+      errors.push(`${label} must be a { queue } object`);
+      continue;
+    }
+    if (typeof entry.queue !== "string" || entry.queue.length === 0) {
+      errors.push(`${label} must have a non-empty "queue" naming the consumed queue`);
+    }
+  }
+};
+const validateQueues = (wrangler, errors) => {
+  if (wrangler.queues === void 0) {
+    return;
+  }
+  if (typeof wrangler.queues !== "object" || Array.isArray(wrangler.queues)) {
+    errors.push("queues must be a { producers, consumers } object");
+    return;
+  }
+  validateQueueProducers(wrangler.queues.producers, errors);
+  validateQueueConsumers(wrangler.queues.consumers, errors);
+};
+const validateSecretsStore = (wrangler, errors) => {
+  if (wrangler.secrets_store_secrets === void 0) {
+    return;
+  }
+  if (!Array.isArray(wrangler.secrets_store_secrets)) {
+    errors.push("secrets_store_secrets must be an array of { binding, store_id, secret_name } entries");
+    return;
+  }
+  const entries = wrangler.secrets_store_secrets;
+  for (const [index, entry] of entries.entries()) {
+    const label = `secrets_store_secrets[${String(index)}]`;
+    if (!entry || typeof entry !== "object") {
+      errors.push(`${label} must be a { binding, store_id, secret_name } object`);
+      continue;
+    }
+    for (const field of ["binding", "store_id", "secret_name"]) {
+      if (typeof entry[field] !== "string" || entry[field].length === 0) {
+        errors.push(`${label} must have a non-empty "${field}"`);
+      }
+    }
+  }
+};
 const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
 const asBindingEntries = (value) => value;
 const HINT_BINDING_RULES = [
@@ -137,6 +213,13 @@ const HINT_BINDING_RULES = [
     hintMessage: (label, binding) => `${label} ("${binding}") has no "id" — run \`wrangler kv namespace create\` and set the namespace id, or the binding can't resolve`,
     key: "kv_namespaces"
   },
+  {
+    arrayMessage: "flagship must be an array of { binding, app_id } entries",
+    bindingMessage: (label) => `${label} must have a non-empty "binding" naming the Flagship binding`,
+    hintField: "app_id",
+    hintMessage: (label, binding) => `${label} ("${binding}") has no "app_id" — create a Flagship app and set its id, or the binding can't resolve`,
+    key: "flagship"
+  },
   {
     arrayMessage: "hyperdrive must be an array of { binding, id } entries",
     bindingMessage: (label) => `${label} must have a non-empty "binding" naming the Hyperdrive binding`,
@@ -398,6 +481,8 @@ const validateWranglerConfig = (wrangler, schema) => {
   validateTailConsumers(wrangler, errors);
   validateContainers(wrangler, errors, warnings);
   validateWorkflows(wrangler, errors);
+  validateQueues(wrangler, errors);
+  validateSecretsStore(wrangler, errors);
   for (const rule of HINT_BINDING_RULES) {
     validateHintBinding(wrangler, rule, errors, warnings);
   }

package/dist/packem_shared/assetContentType-ByZjeV3D.mjs

@@ -0,0 +1,72 @@
+import { readFileSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { normalize, join, relative, isAbsolute, dirname } from 'node:path';
+
+const loadStudioAssets = (logger, resolveFrom = import.meta.url) => {
+  try {
+    const require = createRequire(resolveFrom);
+    return {
+      script: readFileSync(require.resolve("@lunora/studio/standalone/studio.js")),
+      styles: readFileSync(require.resolve("@lunora/studio/styles.css"))
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger?.warnOnce?.(`[lunora] studio assets unavailable (build @lunora/studio?): ${message}`);
+    return void 0;
+  }
+};
+const studioAssetsStamp = (resolveFrom = import.meta.url) => {
+  try {
+    const require = createRequire(resolveFrom);
+    const scriptMtime = statSync(require.resolve("@lunora/studio/standalone/studio.js")).mtimeMs;
+    const stylesMtime = statSync(require.resolve("@lunora/studio/styles.css")).mtimeMs;
+    return Math.max(scriptMtime, stylesMtime);
+  } catch {
+    return void 0;
+  }
+};
+const resolveStandaloneDirectory = (resolveFrom = import.meta.url) => {
+  try {
+    return dirname(createRequire(resolveFrom).resolve("@lunora/studio/standalone/studio.js"));
+  } catch {
+    return void 0;
+  }
+};
+const resolveContainedFile = (directory, fileName) => {
+  if (fileName === "" || fileName === "." || fileName === ".." || fileName.includes("/") || fileName.includes("\\") || fileName.includes("\0")) {
+    return void 0;
+  }
+  const resolved = normalize(join(directory, fileName));
+  const relativePath = relative(directory, resolved);
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath) || relativePath.includes("/") || relativePath.includes("\\")) {
+    return void 0;
+  }
+  return resolved;
+};
+const readStandaloneAsset = (fileName, resolveFrom = import.meta.url) => {
+  const directory = resolveStandaloneDirectory(resolveFrom);
+  if (directory === void 0) {
+    return void 0;
+  }
+  const resolved = resolveContainedFile(directory, fileName);
+  if (resolved === void 0) {
+    return void 0;
+  }
+  try {
+    return readFileSync(resolved);
+  } catch {
+    return void 0;
+  }
+};
+const isStandaloneModulePath = (pathname) => pathname.endsWith(".js") || pathname.endsWith(".js.map");
+const assetContentType = (fileName) => {
+  if (fileName.endsWith(".css")) {
+    return "text/css; charset=utf-8";
+  }
+  if (fileName.endsWith(".map")) {
+    return "application/json; charset=utf-8";
+  }
+  return "text/javascript; charset=utf-8";
+};
+
+export { assetContentType, isStandaloneModulePath, loadStudioAssets, readStandaloneAsset, resolveContainedFile, resolveStandaloneDirectory, studioAssetsStamp };

package/dist/packem_shared/{buildPackageSecretsBlock-S74dgmwy.mjs → buildPackageSecretsBlock-B8iSX1Zo.mjs}

@@ -1,9 +1,11 @@
 import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, renameSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
-import { DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, parseDevVariableEntries, DEV_VARS_NEWLINE, splitDevVariableLine, unquoteDevVariable } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
-import { secretsForPackages } from './PACKAGE_SECRETS_REGISTRY-CySy5vR_.mjs';
+import { LunoraError } from '@lunora/errors';
+import { DEV_VARS_FILE, DEV_VARS_EXAMPLE_FILE, splitDevVariableLine, parseDevVariableEntries, DEV_VARS_NEWLINE, unquoteDevVariable } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
+import { CORE_SECRETS, PACKAGE_SECRETS_REGISTRY, secretsForPackages } from './PACKAGE_SECRETS_REGISTRY-B8t_SdoZ.mjs';
 
+const requiredSecrets = (packageNames) => [...CORE_SECRETS, ...secretsForPackages(packageNames)];
 const SECRET_BYTES = 32;
 const SECRET_KEY = /(?:KEY|PASSWORD|SECRET|TOKEN)$/u;
 const PLACEHOLDER_MARKERS = [
@@ -45,6 +47,11 @@ const isPlaceholderValue = (value) => {
 const isPlaceholder = (rawValue) => isPlaceholderValue(unquoteDevVariable(rawValue.trim()));
 const defaultRandomHex = (bytes) => randomBytes(bytes).toString("hex");
 const generatedSecretFor = (key, rawValue, randomHex) => SECRET_KEY.test(key) && isPlaceholder(rawValue) ? randomHex(SECRET_BYTES) : void 0;
+const PROVIDER_SECRET_KEYS = new Set(
+  [...CORE_SECRETS, ...Object.values(PACKAGE_SECRETS_REGISTRY).flat()].filter((entry) => SECRET_KEY.test(entry.key) && entry.placeholderValue.startsWith("<")).map((entry) => entry.key)
+);
+const isMintableSecretKey = (key) => SECRET_KEY.test(key) && !PROVIDER_SECRET_KEYS.has(key);
+const generateSecretValue = (randomHex = defaultRandomHex) => randomHex(SECRET_BYTES);
 const planDevVariablesScaffold = (input) => {
   if (input.devVarsExists) {
     return { status: "exists" };
@@ -98,19 +105,48 @@ const atomicCreateDevVariables = (path, content) => {
     throw error;
   }
 };
-const appendDevVariables = (path, additions) => {
-  const existing = readFileSync(path, "utf8");
-  const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
-  const content = `${existing}${separator}${additions.join("\n")}
-`;
-  const temporaryPath = `${path}.tmp-${String(process.pid)}`;
+const APPEND_MAX_ATTEMPTS = 5;
+const fingerprintOf = (path) => {
   try {
-    writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
-    renameSync(temporaryPath, path);
-  } catch (error) {
-    rmSync(temporaryPath, { force: true });
-    throw error;
+    const stats = statSync(path);
+    return { mtimeMs: stats.mtimeMs, size: stats.size };
+  } catch {
+    return void 0;
+  }
+};
+const sameFingerprint = (a, b) => {
+  if (a === void 0 || b === void 0) {
+    return false;
+  }
+  return a.mtimeMs === b.mtimeMs && a.size === b.size;
+};
+const appendDevVariables = (path, buildAdditions) => {
+  for (let attempt = 0; attempt < APPEND_MAX_ATTEMPTS; attempt += 1) {
+    const beforeFingerprint = fingerprintOf(path);
+    const existing = readFileSync(path, "utf8");
+    const additions = buildAdditions(existing);
+    if (additions.length === 0) {
+      return [];
+    }
+    const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    const content = `${existing}${separator}${additions.join("\n")}
+`;
+    const temporaryPath = `${path}.tmp-${String(process.pid)}-${randomBytes(6).toString("hex")}`;
+    try {
+      writeFileSync(temporaryPath, content, { encoding: "utf8", mode: 384 });
+      const beforeRenameFingerprint = fingerprintOf(path);
+      if (!sameFingerprint(beforeFingerprint, beforeRenameFingerprint)) {
+        rmSync(temporaryPath, { force: true });
+        continue;
+      }
+      renameSync(temporaryPath, path);
+      return additions;
+    } catch (error) {
+      rmSync(temporaryPath, { force: true });
+      throw error;
+    }
   }
+  throw new LunoraError("INTERNAL", `Failed to append to ${path} after ${String(APPEND_MAX_ATTEMPTS)} attempts — a concurrent writer kept winning the race.`);
 };
 const ensureDevVariables = async (deps) => {
   const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
@@ -146,16 +182,24 @@ const ensureDevVariables = async (deps) => {
     deps.info(`Skipped — add ${list} to ${DEV_VARS_FILE} when you're ready.`);
     return { addedKeys: [], generatedKeys: [], status: "declined" };
   }
-  appendDevVariables(devVariablesPath, augment.additions);
-  deps.info(`Updated ${DEV_VARS_FILE} — added ${list}${generatedSuffix(augment.generatedKeys)}.`);
-  return { addedKeys: augment.missingKeys, generatedKeys: augment.generatedKeys, status: "augmented" };
+  const written = appendDevVariables(
+    devVariablesPath,
+    (currentContent) => planDevVariablesAugment({ existingContent: currentContent, exampleContent, randomHex: deps.randomHex }).additions
+  );
+  const writtenKeys = written.map((line) => splitDevVariableLine(line)?.key).filter((key) => key !== void 0);
+  if (writtenKeys.length === 0) {
+    return { addedKeys: [], generatedKeys: [], status: "exists" };
+  }
+  const writtenGeneratedKeys = augment.generatedKeys.filter((key) => writtenKeys.includes(key));
+  deps.info(`Updated ${DEV_VARS_FILE} — added ${writtenKeys.join(", ")}${generatedSuffix(writtenGeneratedKeys)}.`);
+  return { addedKeys: writtenKeys, generatedKeys: writtenGeneratedKeys, status: "augmented" };
 };
 const secretEntryBlock = (entry) => {
   const lines = [`# ${entry.description}`, `# Docs: ${entry.docsUrl}`, `${entry.key}="${entry.placeholderValue}"`];
   return lines.join("\n");
 };
 const buildPackageSecretsBlock = (packageNames, existingKeys) => {
-  const entries = secretsForPackages(packageNames).filter((entry) => !existingKeys.has(entry.key));
+  const entries = requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key));
   if (entries.length === 0) {
     return "";
   }
@@ -181,7 +225,57 @@ ${block}
     rmSync(temporaryPath, { force: true });
     throw error;
   }
-  return secretsForPackages(packageNames).filter((entry) => !existingKeys.has(entry.key)).map((entry) => entry.key);
+  return requiredSecrets(packageNames).filter((entry) => !existingKeys.has(entry.key)).map((entry) => entry.key);
+};
+const planDevSecretsFill = (input) => {
+  const randomHex = input.randomHex ?? defaultRandomHex;
+  const filledKeys = [];
+  const lines = input.existingContent.split(DEV_VARS_NEWLINE).map((line) => {
+    const parsed = splitDevVariableLine(line);
+    const secret = parsed ? generatedSecretFor(parsed.key, parsed.value, randomHex) : void 0;
+    if (!parsed || secret === void 0) {
+      return line;
+    }
+    filledKeys.push(parsed.key);
+    return `${parsed.key}="${secret}"`;
+  });
+  const present = new Set(parseDevVariableEntries(input.existingContent).map((entry) => entry.key));
+  const addedKeys = [];
+  const additions = [];
+  for (const entry of CORE_SECRETS) {
+    if (present.has(entry.key)) {
+      continue;
+    }
+    addedKeys.push(entry.key);
+    additions.push(`# ${entry.description}`, `${entry.key}="${randomHex(SECRET_BYTES)}"`);
+  }
+  const body = lines.join("\n");
+  if (additions.length === 0) {
+    return { addedKeys, content: body, filledKeys };
+  }
+  const separator = body === "" || body.endsWith("\n") ? "" : "\n";
+  return { addedKeys, content: `${body}${separator}${additions.join("\n")}
+`, filledKeys };
+};
+const fillDevSecrets = (deps) => {
+  const devVariablesPath = join(deps.cwd, DEV_VARS_FILE);
+  const exists = existsSync(devVariablesPath);
+  const existingContent = exists ? readFileSync(devVariablesPath, "utf8") : "";
+  const plan = planDevSecretsFill({ existingContent, randomHex: deps.randomHex });
+  if (plan.filledKeys.length === 0 && plan.addedKeys.length === 0) {
+    return { addedKeys: [], filledKeys: [], status: "unchanged" };
+  }
+  const temporaryPath = `${devVariablesPath}.tmp-${String(process.pid)}`;
+  try {
+    writeFileSync(temporaryPath, plan.content, { encoding: "utf8", mode: 384 });
+    renameSync(temporaryPath, devVariablesPath);
+  } catch (error) {
+    rmSync(temporaryPath, { force: true });
+    throw error;
+  }
+  const generated = [...plan.filledKeys, ...plan.addedKeys];
+  deps.info?.(`Generated ${String(generated.length)} dev secret(s) in ${DEV_VARS_FILE}: ${generated.join(", ")}`);
+  return { addedKeys: plan.addedKeys, filledKeys: plan.filledKeys, status: exists ? "filled" : "created" };
 };
 
-export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, isPlaceholderValue, planDevVariablesAugment, planDevVariablesScaffold };
+export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVariablesExample as ensureDevVarsExample, fillDevSecrets, generateSecretValue, isMintableSecretKey, isPlaceholderValue, planDevSecretsFill, planDevVariablesAugment, planDevVariablesScaffold, requiredSecrets };

package/dist/packem_shared/collectWranglerSecretVariables-CoSGg_7B.mjs

@@ -0,0 +1,56 @@
+import { relative } from 'node:path';
+import { secretKindOf, redact } from '@lunora/codegen';
+import { isPlaceholderValue } from './buildPackageSecretsBlock-B8iSX1Zo.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const MIN_SECRET_NAMED_VALUE_LENGTH = 8;
+const SECRET_WORD_TOKENS = /* @__PURE__ */ new Set(["CREDENTIAL", "CREDENTIALS", "DSN", "PASSPHRASE", "PASSWD", "PASSWORD", "SECRET", "TOKEN"]);
+const SECRET_KEY_SUFFIXES = ["ACCESS_KEY", "API_KEY", "ENCRYPTION_KEY", "PRIVATE_KEY", "SIGNING_KEY"];
+const PUBLIC_KEY_TOKENS = /* @__PURE__ */ new Set(["PUBLIC", "PUBLISHABLE"]);
+const KEY_SEPARATOR_RE = /[_-]/u;
+const keyTokens = (key) => key.toUpperCase().split(KEY_SEPARATOR_RE);
+const isSecretKeyName = (key) => {
+  const normalized = key.toUpperCase().replaceAll("-", "_");
+  if (keyTokens(key).some((token) => SECRET_WORD_TOKENS.has(token))) {
+    return true;
+  }
+  return SECRET_KEY_SUFFIXES.some((suffix) => normalized === suffix || normalized.endsWith(`_${suffix}`));
+};
+const isPublicKeyName = (key) => keyTokens(key).some((token) => PUBLIC_KEY_TOKENS.has(token));
+const scanWranglerVariablesForSecrets = (variables, file) => {
+  if (variables === void 0) {
+    return [];
+  }
+  const findings = [];
+  for (const [key, rawValue] of Object.entries(variables)) {
+    if (typeof rawValue !== "string") {
+      continue;
+    }
+    if (isPlaceholderValue(rawValue)) {
+      continue;
+    }
+    if (isPublicKeyName(key)) {
+      continue;
+    }
+    const shapeKind = secretKindOf(rawValue);
+    const kind = shapeKind ?? (isSecretKeyName(key) && rawValue.length >= MIN_SECRET_NAMED_VALUE_LENGTH ? "secret_named_var" : void 0);
+    if (kind === void 0) {
+      continue;
+    }
+    findings.push({ file, key, kind, preview: redact(rawValue) });
+  }
+  return findings;
+};
+const collectWranglerSecretVariables = (projectRoot) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (wranglerPath === void 0) {
+    return [];
+  }
+  const { parsed } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return [];
+  }
+  return scanWranglerVariablesForSecrets(parsed.vars, relative(projectRoot, wranglerPath));
+};
+
+export { collectWranglerSecretVariables, scanWranglerVariablesForSecrets };

package/dist/packem_shared/{detectFramework-Br-BcPBq.mjs → detectFramework-U08038Yp.mjs}

@@ -12,7 +12,7 @@ const FRAMEWORK_SIGNATURES = [
   { class: "B", dependency: "astro", framework: "astro" }
 ];
 const STANDALONE = { class: "C", framework: "none" };
-const readDependencyNames = (root) => {
+const readProjectDependencyNames = (root) => {
   const packageJsonPath = join(root, "package.json");
   if (!existsSync(packageJsonPath)) {
     return /* @__PURE__ */ new Set();
@@ -26,7 +26,7 @@ const readDependencyNames = (root) => {
   }
 };
 const detectFramework = (root) => {
-  const dependencies = readDependencyNames(root);
+  const dependencies = readProjectDependencyNames(root);
   if (dependencies.size === 0) {
     return STANDALONE;
   }
@@ -38,4 +38,4 @@ const detectFramework = (root) => {
   return STANDALONE;
 };
 
-export { detectFramework };
+export { detectFramework, readProjectDependencyNames };

package/dist/packem_shared/{discoverSchemaInfo-DWtypqpP.mjs → discoverSchemaInfo-BB-CKlTK.mjs}

@@ -10,7 +10,7 @@ const discoverSchemaInfo = (projectRoot, schemaDirectory) => {
   }
   try {
     const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-    const schema = discoverSchema(project, schemaPath);
+    const schema = discoverSchema(project, schemaPath, projectRoot);
     return {
       info: {
         hasGlobalTable: schema.tables.some((table) => table.shardMode === "global"),