@lunora/config 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -1,7 +1,7 @@
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { discoverSchemaInfo } from './discoverSchemaInfo-DWtypqpP.mjs';
-import { findWranglerFile, readWranglerJsonc } from './findWranglerFile-DwSuC-Kn.mjs';
+import { discoverSchemaInfo } from './discoverSchemaInfo-BB-CKlTK.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
 
 const REQUIRED_COMPATIBILITY_DATE = "2026-04-07";
 const REQUIRED_FLAG = "web_socket_auto_reply_to_close";
@@ -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/{buildPackageSecretsBlock-S74dgmwy.mjs → buildPackageSecretsBlock-DWDKHViT.mjs}

@@ -2,8 +2,9 @@ import { randomBytes } from 'node:crypto';
 import { existsSync, readFileSync, writeFileSync, renameSync, rmSync } 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 { 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 +46,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" };
@@ -155,7 +161,7 @@ const secretEntryBlock = (entry) => {
   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 +187,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/{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"),

package/dist/packem_shared/{inferLunoraBindings-0W3eRdIP.mjs → inferLunoraBindings-ByMwG-gH.mjs}

@@ -1,10 +1,38 @@
 import { existsSync, statSync, readFileSync, readdirSync } from 'node:fs';
 import { init, parse } from 'es-module-lexer';
 import { discoverContainerInfo } from './discoverContainerInfo-BXFs6Wav.mjs';
-import { discoverSchemaInfo } from './discoverSchemaInfo-DWtypqpP.mjs';
-import { discoverWorkflowInfo } from './discoverWorkflowInfo-CedvR0mn.mjs';
-import { WRANGLER_FILES, readWranglerJsonc } from './findWranglerFile-DwSuC-Kn.mjs';
+import { FLAGS_FILENAME, discoverFlags, QUEUES_FILENAME, discoverQueues } from '@lunora/codegen';
+import { Project } from 'ts-morph';
 import { join } from 'node:path';
+import { discoverSchemaInfo } from './discoverSchemaInfo-BB-CKlTK.mjs';
+import { discoverWorkflowInfo } from './discoverWorkflowInfo-CedvR0mn.mjs';
+import { WRANGLER_FILES, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+
+const discoverFlagsInfo = (projectRoot, schemaDirectory) => {
+  const flagsPath = join(projectRoot, schemaDirectory, FLAGS_FILENAME);
+  if (!existsSync(flagsPath)) {
+    return {};
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { flags: discoverFlags(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error) };
+  }
+};
+
+const discoverQueueInfo = (projectRoot, schemaDirectory) => {
+  const queuesPath = join(projectRoot, schemaDirectory, QUEUES_FILENAME);
+  if (!existsSync(queuesPath)) {
+    return { queues: [] };
+  }
+  try {
+    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
+    return { queues: discoverQueues(project, join(projectRoot, schemaDirectory)) };
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : String(error), queues: [] };
+  }
+};
 
 const SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([".cjs", ".cts", ".js", ".jsx", ".mjs", ".mts", ".ts", ".tsx"]);
 const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([".git", ".lunora-cache", ".wrangler", "_generated", "dist", "node_modules"]);
@@ -23,18 +51,23 @@ const TYPE_ONLY_EXPORT_PATTERNS = {
 };
 const ENV_DB_PATTERN = /\benv\s*\.\s*DB\b/;
 const ENV_AI_PATTERN = /\benv\s*\.\s*AI\b/;
+const CTX_PIPELINES_PATTERN = /\bctx\s*\.\s*pipelines\b/;
 const TYPE_ONLY_IMPORT_PATTERN = /^\s*import\s+type\b/;
 const CAPABILITY_SOURCES = {
   usesAi: { pattern: /\bfrom\s+["']@lunora\/ai["']/, source: "@lunora/ai" },
-  usesAnalytics: { pattern: /\bfrom\s+["']@lunora\/analytics["']/, source: "@lunora/analytics" },
+  usesAnalytics: { pattern: /\bfrom\s+["']@lunora\/bindings\/analytics["']/, source: "@lunora/bindings/analytics" },
   usesAuth: { pattern: /\bfrom\s+["']@lunora\/auth["']/, source: "@lunora/auth" },
   usesBrowser: { pattern: /\bfrom\s+["']@lunora\/browser["']/, source: "@lunora/browser" },
   usesHyperdrive: { pattern: /\bfrom\s+["']@lunora\/hyperdrive["']/, source: "@lunora/hyperdrive" },
-  usesImages: { pattern: /\bfrom\s+["']@lunora\/images["']/, source: "@lunora/images" },
-  usesKv: { pattern: /\bfrom\s+["']@lunora\/kv["']/, source: "@lunora/kv" },
+  usesImages: { pattern: /\bfrom\s+["']@lunora\/bindings\/images["']/, source: "@lunora/bindings/images" },
+  usesKv: { pattern: /\bfrom\s+["']@lunora\/bindings\/kv["']/, source: "@lunora/bindings/kv" },
   usesMail: { pattern: /\bfrom\s+["']@lunora\/mail["']/, source: "@lunora/mail" },
   usesPayment: { pattern: /\bfrom\s+["']@lunora\/payment["']/, source: "@lunora/payment" },
-  usesPipelines: { pattern: /\bfrom\s+["']@lunora\/pipelines["']/, source: "@lunora/pipelines" },
+  // Keyed off the `ctx.pipelines` access (not an import) — see CTX_PIPELINES_PATTERN.
+  // Pipelines is codegen-wired onto ActionCtx, so apps reach it via `ctx.pipelines`
+  // rather than importing `@lunora/bindings/pipelines`; `source` names that subpath
+  // for the hint message.
+  usesPipelines: { pattern: CTX_PIPELINES_PATTERN, source: "@lunora/bindings/pipelines" },
   usesScheduler: { pattern: /\bfrom\s+["']@lunora\/scheduler["']/, source: "@lunora/scheduler" },
   usesStorage: { pattern: /\bfrom\s+["']@lunora\/storage["']/, source: "@lunora/storage" }
 };
@@ -90,7 +123,12 @@ const capabilitiesFromSource = (code) => {
   } catch {
     capabilities = regexCapabilities(code);
   }
-  return mergeCapabilities(capabilities, { ...NO_CAPABILITIES, needsD1: ENV_DB_PATTERN.test(code), usesAi: ENV_AI_PATTERN.test(code) });
+  return mergeCapabilities(capabilities, {
+    ...NO_CAPABILITIES,
+    needsD1: ENV_DB_PATTERN.test(code),
+    usesAi: ENV_AI_PATTERN.test(code),
+    usesPipelines: CTX_PIPELINES_PATTERN.test(code)
+  });
 };
 const collectSourceFiles = (directory, accumulator) => {
   let entries;
@@ -137,8 +175,8 @@ const detectExportedDurableObjects = (entryPath) => {
   const code = readFileSync(entryPath, "utf8");
   let exportedNames;
   try {
-    const [, exports$1] = parse(code);
-    exportedNames = new Set(exports$1.map((entry) => entry.n));
+    const [, exports] = parse(code);
+    exportedNames = new Set(exports.map((entry) => entry.n));
   } catch {
     exportedNames = new Set(DURABLE_OBJECT_CLASSES.filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code)));
   }
@@ -163,8 +201,8 @@ const detectContainerExports = (entryPath, containers) => {
   const starReexport = CONTAINERS_STAR_REEXPORT_PATTERN.test(code);
   let exportedNames;
   try {
-    const [, exports$1] = parse(code);
-    exportedNames = new Set(exports$1.map((entry) => entry.n));
+    const [, exports] = parse(code);
+    exportedNames = new Set(exports.map((entry) => entry.n));
   } catch {
     exportedNames = new Set(
       containers.map((container) => container.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
@@ -188,8 +226,8 @@ const detectWorkflowExports = (entryPath, workflows) => {
   const starReexport = WORKFLOWS_STAR_REEXPORT_PATTERN.test(code);
   let exportedNames;
   try {
-    const [, exports$1] = parse(code);
-    exportedNames = new Set(exports$1.map((entry) => entry.n));
+    const [, exports] = parse(code);
+    exportedNames = new Set(exports.map((entry) => entry.n));
   } catch {
     exportedNames = new Set(
       workflows.map((workflow) => workflow.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
@@ -237,14 +275,14 @@ const describeCapabilitySignals = (capabilities, exported) => {
     // Self-describing bindings: the binding name is the whole config (no remote
     // id to mint), so reconcile auto-writes them like the DO/D1 bindings.
     [capabilities.usesBrowser, "browser (@lunora/browser imported) — self-describing { binding: BROWSER }"],
-    [capabilities.usesImages, "images (@lunora/images imported) — self-describing { binding: IMAGES }"],
-    [capabilities.usesAnalytics, "analytics_engine_datasets (@lunora/analytics imported) — self-describing { binding: ANALYTICS, dataset }"],
+    [capabilities.usesImages, "images (@lunora/bindings/images imported) — self-describing { binding: IMAGES }"],
+    [capabilities.usesAnalytics, "analytics_engine_datasets (@lunora/bindings/analytics imported) — self-describing { binding: ANALYTICS, dataset }"],
     // Hint bindings: each needs a remote resource Lunora can't fabricate (a KV
     // namespace id, a Hyperdrive id, a Pipelines pipeline name), so they surface
     // as hints — never an auto-write — exactly like R2's user-defined bucket name.
     [
       capabilities.usesKv,
-      "hint: @lunora/kv is imported; add a kv_namespaces binding ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned"
+      "hint: @lunora/bindings/kv is imported; add a kv_namespaces binding ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned"
     ],
     [
       capabilities.usesHyperdrive,
@@ -252,7 +290,7 @@ const describeCapabilitySignals = (capabilities, exported) => {
     ],
     [
       capabilities.usesPipelines,
-      "hint: @lunora/pipelines is imported; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned"
+      "hint: ctx.pipelines is used; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned"
     ]
   ];
   return rules.filter(([active]) => active).map(([, signal]) => signal);
@@ -276,15 +314,27 @@ const inferLunoraBindings = async (options) => {
   const needsD1 = capabilities.needsD1 || schemaNeedsD1(options.projectRoot, schemaDirectory);
   const containers = detectContainerExports(entryPath, discoverContainerInfo(options.projectRoot, schemaDirectory).containers);
   const workflows = detectWorkflowExports(entryPath, discoverWorkflowInfo(options.projectRoot, schemaDirectory).workflows);
+  const queues = [...discoverQueueInfo(options.projectRoot, schemaDirectory).queues];
+  const { flags } = discoverFlagsInfo(options.projectRoot, schemaDirectory);
+  const flagshipBinding = flags?.provider === "flagship" && flags.mode === "binding" ? flags.bindingName : void 0;
   const capabilityFlags = {};
   for (const flag of CAPABILITY_FLAGS) {
     capabilityFlags[flag] = capabilities[flag];
   }
+  const signals = describeSignals(durableObjects, needsD1, capabilities, containers, workflows);
+  if (flagshipBinding !== void 0) {
+    signals.push(
+      `hint: lunora/flags.ts uses Flagship in binding mode; add a flagship binding ({ binding: "${flagshipBinding}", app_id }) — the app_id can't be auto-provisioned`
+    );
+  }
   return {
     containers,
     durableObjects,
+    flagshipBinding,
     needsD1,
-    signals: describeSignals(durableObjects, needsD1, capabilities, containers, workflows),
+    queues,
+    signals,
+    usesFlags: flags !== void 0,
     workflows,
     ...capabilityFlags
   };

package/dist/packem_shared/{reconcileWranglerBindings-ByJk3yLU.mjs → reconcileWranglerBindings-Cruwwx1M.mjs}

@@ -1,7 +1,7 @@
 import { writeFileSync } from 'node:fs';
 import { containerBuildTag } from '@lunora/container';
 import { modify, applyEdits } from 'jsonc-parser';
-import { findWranglerFile, readWranglerJsonc } from './findWranglerFile-DwSuC-Kn.mjs';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
 
 const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
 const D1_PLACEHOLDER_ID = "<replace-with-d1-create-id>";
@@ -20,10 +20,11 @@ const collectExportGaps = (inferred) => {
   return gaps;
 };
 const collectHintBindingWarnings = (inferred, parsed) => {
+  const flagshipBindingMissing = inferred.flagshipBinding !== void 0 && !(parsed?.flagship ?? []).some((entry) => entry.binding === inferred.flagshipBinding);
   const rules = [
     [
       inferred.usesKv && (parsed?.kv_namespaces?.length ?? 0) === 0,
-      "@lunora/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
+      "@lunora/bindings/kv is used but no kv_namespaces binding exists; add a kv_namespaces entry ({ binding, id }) and pass env.<BINDING> to createKv() — the namespace id can't be auto-provisioned."
     ],
     [
       inferred.usesHyperdrive && (parsed?.hyperdrive?.length ?? 0) === 0,
@@ -31,7 +32,11 @@ const collectHintBindingWarnings = (inferred, parsed) => {
     ],
     [
       inferred.usesPipelines && (parsed?.pipelines?.length ?? 0) === 0,
-      "@lunora/pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+      "ctx.pipelines is used but no pipelines binding exists; run 'wrangler pipelines create <name>' and add a 'pipelines' binding ({ binding, pipeline }) — the pipeline resource can't be auto-provisioned."
+    ],
+    [
+      flagshipBindingMissing,
+      `lunora/flags.ts uses Flagship in binding mode but no flagship binding "${inferred.flagshipBinding ?? ""}" exists; add a flagship entry ({ binding: "${inferred.flagshipBinding ?? ""}", app_id }) — the app_id can't be auto-provisioned.`
     ]
   ];
   return rules.filter(([active]) => active).map(([, warning]) => warning);
@@ -222,6 +227,57 @@ const reconcileWorkflows = (text, parsed, workflows) => {
   const nextText = applyModify(text, ["workflows"], [...existing, ...missing.map((workflow) => workflowEntryFor(workflow))]);
   return { added: missing.map((workflow) => `workflows/${workflow.className}`), text: nextText };
 };
+const reconcileQueues = (text, parsed, queues) => {
+  const existing = parsed.queues ?? {};
+  const existingProducers = existing.producers ?? [];
+  const existingConsumers = existing.consumers ?? [];
+  const haveProducer = new Set(existingProducers.map((entry) => entry.binding));
+  const haveConsumer = new Set(existingConsumers.map((entry) => entry.queue));
+  const missingProducers = queues.filter((queue) => !haveProducer.has(queue.bindingName));
+  const missingConsumers = queues.filter((queue) => !haveConsumer.has(queue.name));
+  if (missingProducers.length === 0 && missingConsumers.length === 0) {
+    return { added: [], text };
+  }
+  const nextProducers = [
+    ...existingProducers,
+    ...missingProducers.map((queue) => {
+      return { binding: queue.bindingName, queue: queue.name };
+    })
+  ];
+  const nextConsumers = [
+    ...existingConsumers,
+    ...missingConsumers.map((queue) => {
+      const consumer = { queue: queue.name };
+      if (queue.mode === "pull") {
+        consumer.type = "http_pull";
+      }
+      if (queue.tuning.maxBatchSize !== void 0) {
+        consumer.max_batch_size = queue.tuning.maxBatchSize;
+      }
+      if (queue.tuning.maxBatchTimeout !== void 0) {
+        consumer.max_batch_timeout = queue.tuning.maxBatchTimeout;
+      }
+      if (queue.tuning.maxRetries !== void 0) {
+        consumer.max_retries = queue.tuning.maxRetries;
+      }
+      if (queue.tuning.deadLetterQueue !== void 0) {
+        consumer.dead_letter_queue = queue.tuning.deadLetterQueue;
+      }
+      if (queue.tuning.retryDelay !== void 0) {
+        consumer.retry_delay = queue.tuning.retryDelay;
+      }
+      return consumer;
+    })
+  ];
+  const nextText = applyModify(text, ["queues"], { consumers: nextConsumers, producers: nextProducers });
+  return {
+    added: [
+      ...missingProducers.map((queue) => `queues.producers/${queue.bindingName}`),
+      ...missingConsumers.map((queue) => `queues.consumers/${queue.name}`)
+    ],
+    text: nextText
+  };
+};
 const reconcileWranglerBindings = (projectRoot, inferred) => {
   const wranglerPath = findWranglerFile(projectRoot);
   const exportGaps = collectExportGaps(inferred);
@@ -250,7 +306,8 @@ const reconcileWranglerBindings = (projectRoot, inferred) => {
     { enabled: inferred.usesAnalytics, run: (text2) => reconcileAnalytics(text2, parsed) },
     { enabled: true, run: (text2) => reconcileObservability(text2, parsed) },
     { enabled: exportedContainers.length > 0, run: (text2) => reconcileContainers(text2, parsed, exportedContainers) },
-    { enabled: exportedWorkflows.length > 0, run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows) }
+    { enabled: exportedWorkflows.length > 0, run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows) },
+    { enabled: inferred.queues.length > 0, run: (text2) => reconcileQueues(text2, parsed, inferred.queues) }
   ];
   let text = original;
   const added = [];

package/dist/packem_shared/streamContainerLogs-BZ4cOZwH.mjs

@@ -0,0 +1,157 @@
+import { Writable } from 'node:stream';
+import { StringDecoder } from 'node:string_decoder';
+
+const DEV_CONTAINER_IMAGE_PREFIX = "cloudflare-dev/";
+const DEFAULT_POLL_INTERVAL_MS = 1500;
+const createDefaultDocker = async () => {
+  const { default: Dockerode } = await import('dockerode');
+  return new Dockerode();
+};
+const classFromImage = (image) => {
+  if (!image.startsWith(DEV_CONTAINER_IMAGE_PREFIX)) {
+    return void 0;
+  }
+  const [segment] = image.slice(DEV_CONTAINER_IMAGE_PREFIX.length).split(":");
+  return segment !== void 0 && segment.length > 0 ? segment : void 0;
+};
+const lineBufferWritable = (emit) => {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  const flushLine = (line) => {
+    emit(line.endsWith("\r") ? line.slice(0, -1) : line);
+  };
+  return new Writable({
+    final(callback) {
+      buffer += decoder.end();
+      if (buffer.length > 0) {
+        flushLine(buffer);
+        buffer = "";
+      }
+      callback();
+    },
+    write(chunk, _encoding, callback) {
+      buffer += decoder.write(chunk);
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        flushLine(line);
+      }
+      callback();
+    }
+  });
+};
+const streamContainerLogs = (options) => {
+  const classToExport = new Map(options.containers.map((source) => [source.className.toLowerCase(), source.exportName]));
+  if (classToExport.size === 0) {
+    return { close: () => {
+    } };
+  }
+  const interval = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const attached = /* @__PURE__ */ new Map();
+  let closed = false;
+  let unavailableNotified = false;
+  let timer;
+  let dockerPromise;
+  const getDocker = async () => {
+    dockerPromise ??= options.docker ? Promise.resolve(options.docker) : createDefaultDocker();
+    return dockerPromise;
+  };
+  const attach = async (docker, id, exportName) => {
+    try {
+      const stream = await docker.getContainer(id).logs({ follow: true, stderr: true, stdout: true, tail: "all", timestamps: false });
+      if (closed) {
+        stream.destroy();
+        return;
+      }
+      const stdout = lineBufferWritable((text) => {
+        options.onLine({ level: "info", name: exportName, text });
+      });
+      const stderr = lineBufferWritable((text) => {
+        options.onLine({ level: "error", name: exportName, text });
+      });
+      docker.modem.demuxStream(stream, stdout, stderr);
+      stream.on("end", () => {
+        stdout.end();
+        stderr.end();
+        attached.delete(id);
+      });
+      stream.on("error", () => {
+        attached.delete(id);
+      });
+      attached.set(id, stream);
+    } catch {
+    }
+  };
+  const listRunning = async () => {
+    try {
+      const docker = await getDocker();
+      const running = await docker.listContainers({ filters: { status: ["running"] } });
+      unavailableNotified = false;
+      return running;
+    } catch (error) {
+      if (!unavailableNotified) {
+        unavailableNotified = true;
+        options.onUnavailable?.(error instanceof Error ? error.message : String(error));
+      }
+      return void 0;
+    }
+  };
+  const reconcile = async (docker, running) => {
+    const live = /* @__PURE__ */ new Set();
+    for (const summary of running) {
+      const className = classFromImage(summary.Image);
+      const exportName = className === void 0 ? void 0 : classToExport.get(className);
+      if (exportName === void 0) {
+        continue;
+      }
+      live.add(summary.Id);
+      if (!attached.has(summary.Id)) {
+        await attach(docker, summary.Id, exportName);
+      }
+    }
+    for (const [id, stream] of attached) {
+      if (!live.has(id)) {
+        stream.destroy();
+        attached.delete(id);
+      }
+    }
+  };
+  const poll = async () => {
+    if (closed) {
+      return;
+    }
+    const running = await listRunning();
+    if (running === void 0) {
+      return;
+    }
+    await reconcile(await getDocker(), running);
+  };
+  let polling = false;
+  const onTick = () => {
+    if (polling || closed) {
+      return;
+    }
+    polling = true;
+    poll().finally(() => {
+      polling = false;
+    }).catch(() => void 0);
+  };
+  timer = setInterval(onTick, interval);
+  timer.unref();
+  onTick();
+  return {
+    close: () => {
+      closed = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = void 0;
+      }
+      for (const [id, stream] of attached) {
+        stream.destroy();
+        attached.delete(id);
+      }
+    }
+  };
+};
+
+export { streamContainerLogs };

package/dist/studio-host/index.mjs

@@ -1,7 +1,7 @@
 export { parseDevVariable, resolveAdminToken } from '../packem_shared/parseDevVariable-CJiq2IwE.mjs';
-export { default as loadStudioAssets, studioAssetsStamp } from '../packem_shared/studioAssetsStamp-Csk5RS4E.mjs';
-export { POLICY_SCAFFOLD_ENDPOINT, handlePolicyScaffoldRequest } from '../packem_shared/handlePolicyScaffoldRequest-CiC2IGKx.mjs';
+export { default as loadStudioAssets, studioAssetsStamp } from '../packem_shared/loadStudioAssets-Csk5RS4E.mjs';
+export { POLICY_SCAFFOLD_ENDPOINT, handlePolicyScaffoldRequest } from '../packem_shared/POLICY_SCAFFOLD_ENDPOINT-CiC2IGKx.mjs';
 export { default as renderStudioHtml } from '../packem_shared/renderStudioHtml-449Ysn75.mjs';
-export { SCHEMA_EDIT_ENDPOINT, handleSchemaEditRequest } from '../packem_shared/handleSchemaEditRequest-Df-Wrix-.mjs';
-export { SEED_ENDPOINT, handleSeedRequest } from '../packem_shared/handleSeedRequest-DVCjaGO-.mjs';
+export { SCHEMA_EDIT_ENDPOINT, handleSchemaEditRequest } from '../packem_shared/SCHEMA_EDIT_ENDPOINT-Df-Wrix-.mjs';
+export { SEED_ENDPOINT, handleSeedRequest } from '../packem_shared/SEED_ENDPOINT-DVCjaGO-.mjs';
 export { serveJsonHandler } from '../packem_shared/serveJsonHandler-B4OLTGLS.mjs';