@lunora/config 0.0.0 → 1.0.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,22 @@
+export { AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, LUNORA_SKILL_NAMES, ROOT_SKILL_NAME, claimAgentRulesHint, detectAgentRules } from './packem_shared/AGENT_RULES_DIR-lcgC08aE.mjs';
+export { discoverContainerInfo } from './packem_shared/discoverContainerInfo-BXFs6Wav.mjs';
+export { detectFramework } from './packem_shared/detectFramework-Br-BcPBq.mjs';
+export { DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, parseDevVariableEntries } from './packem_shared/DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
+export { inferLunoraBindings, packageNamesFromBindings } from './packem_shared/inferLunoraBindings-DIku9mTN.mjs';
+export { LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, readLinkedProject, writeLinkedProject } from './packem_shared/LINKED_PROJECT_DIR-CXwXzV_C.mjs';
+export { LUNORA_EVENT_SOURCE, formatLunoraEvent } from './packem_shared/LUNORA_EVENT_SOURCE-D2fDeGB6.mjs';
+export { default as LunoraReporter } from './packem_shared/LunoraReporter-Ci-bDCK9.mjs';
+export { PACKAGE_SECRETS_REGISTRY, secretsForPackages } from './packem_shared/PACKAGE_SECRETS_REGISTRY-B8t_SdoZ.mjs';
+export { LUNORA_CONFIG_FILE, interpretRemote, readProjectRemotePreference } from './packem_shared/LUNORA_CONFIG_FILE-CtcIcB5-.mjs';
+export { createConfirm, isInteractive, promptMultiSelect, promptSelect, promptYesNo } from './packem_shared/createConfirm-fvpdgJ9s.mjs';
+export { reconcileWranglerBindings } from './packem_shared/reconcileWranglerBindings-DTHmqTbL.mjs';
+export { REMOTE_ELIGIBLE_KEYS, injectRemoteFlags, isRemoteEnvEnabled, materializeRemoteWranglerConfig, planRemoteBindings, resolveRemoteEnabled } from './packem_shared/REMOTE_ELIGIBLE_KEYS-BC7_e9Bz.mjs';
+export { buildPackageSecretsBlock, ensureDevVariables, ensureDevVarsExample, isPlaceholderValue, planDevVariablesAugment, planDevVariablesScaffold } from './packem_shared/buildPackageSecretsBlock-DNzNRu7T.mjs';
+export { applyAdditiveEdit, classifyEdit } from './packem_shared/applyAdditiveEdit-C-snTFEV.mjs';
+export { parseSchema } from './packem_shared/parseSchema-DSeyktvG.mjs';
+export { classifyPolicyEdit, scaffoldPolicyFile, wireRlsIntoProcedure } from './packem_shared/classifyPolicyEdit-BHeAqF8P.mjs';
+export { discoverSchemaInfo } from './packem_shared/discoverSchemaInfo-BB-CKlTK.mjs';
+export { ACCENT, BADGES, BADGE_COLUMN_WIDTH, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, STEP_BADGE_NAMES, badgeLead, badgeWidth, padBadge, paintAnswer, paintBadge } from './packem_shared/ACCENT-DW1XJn8i.mjs';
+export { discoverWorkflowInfo } from './packem_shared/discoverWorkflowInfo-CedvR0mn.mjs';
+export { WRANGLER_FILES, findWranglerFile, readWranglerJsonc } from './packem_shared/WRANGLER_FILES-DwSuC-Kn.mjs';
+export { REQUIRED_COMPATIBILITY_DATE, REQUIRED_FLAG, validateWrangler, validateWranglerConfig, validateWranglerProject, withTailConsumer } from './packem_shared/REQUIRED_COMPATIBILITY_DATE-DRSNSOOp.mjs';

package/dist/packem_shared/ACCENT-DW1XJn8i.mjs

@@ -0,0 +1,40 @@
+import colorize from '@visulima/colorize';
+
+const ACCENT = "#a855f7";
+const INK = "#0b0b0b";
+const STEP_BADGE_NAMES = ["lunora", "dir", "tmpl", "add", "deps", "git", "next"];
+const BADGES = {
+  add: { bg: ACCENT, fg: INK, text: "add" },
+  debug: { bg: "#6b7280", fg: "#f3f4f6", text: "debug" },
+  deps: { bg: ACCENT, fg: INK, text: "deps" },
+  dir: { bg: ACCENT, fg: INK, text: "dir" },
+  error: { bg: "#ef4444", fg: INK, text: "error" },
+  git: { bg: "#f59e0b", fg: INK, text: "git" },
+  info: { bg: "#3b82f6", fg: INK, text: "info" },
+  lunora: { bg: "#22c55e", fg: INK, text: "lunora" },
+  next: { bg: "#06b6d4", fg: INK, text: "next" },
+  success: { bg: "#22c55e", fg: INK, text: "ok" },
+  tmpl: { bg: ACCENT, fg: INK, text: "tmpl" },
+  warn: { bg: "#f59e0b", fg: INK, text: "warn" }
+};
+const LUNA_NAME = "Luna";
+const LUNA_SIGNOFF = "Safe travels, voyager.";
+const LUNA_BUNNY = String.raw`
+   .-"""""-.
+  /  (\(\   \
+ |   ( -.-)  |
+  \  o(")(") /
+   '-._____.-'`;
+const LUNA_ART = LUNA_BUNNY.startsWith("\n") ? LUNA_BUNNY.slice(1) : LUNA_BUNNY;
+const BADGE_GUTTER = 6;
+const padBadge = (text) => ` ${text} `;
+const badgeLead = (text) => " ".repeat(Math.max(0, BADGE_GUTTER - text.length));
+const BADGE_COLUMN_WIDTH = BADGE_GUTTER + 2;
+const badgeWidth = (_spec) => BADGE_COLUMN_WIDTH;
+const paintBadge = (spec) => (
+  // eslint-disable-next-line import/no-named-as-default-member -- see file header.
+  badgeLead(spec.text) + colorize.bgHex(spec.bg).hex(spec.fg).bold(padBadge(spec.text))
+);
+const paintAnswer = (text) => colorize.dim(text);
+
+export { ACCENT, BADGES, BADGE_COLUMN_WIDTH, LUNA_ART, LUNA_BUNNY, LUNA_NAME, LUNA_SIGNOFF, STEP_BADGE_NAMES, badgeLead, badgeWidth, padBadge, paintAnswer, paintBadge };

package/dist/packem_shared/AGENT_RULES_DIR-lcgC08aE.mjs

@@ -0,0 +1,40 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const AGENT_RULES_DIR = ".agents/skills";
+const AGENT_RULES_HINT_ENV = "LUNORA_RULES_HINT_SHOWN";
+const LUNORA_SKILL_NAMES = [
+  "lunora",
+  "lunora-quickstart",
+  "lunora-functions",
+  "lunora-realtime",
+  "lunora-setup-auth",
+  "lunora-create-package",
+  "lunora-migration-helper",
+  "lunora-deploy",
+  "lunora-performance-audit"
+];
+const ROOT_SKILL_NAME = "lunora";
+const AGENT_RULES_HINT = "Lunora AI rules not installed — run `lunora rules install` so your coding agent knows how to use Lunora.";
+const claimAgentRulesHint = () => {
+  if (process.env[AGENT_RULES_HINT_ENV] === "1") {
+    return false;
+  }
+  process.env[AGENT_RULES_HINT_ENV] = "1";
+  return true;
+};
+const skillFile = (projectRoot, name) => join(projectRoot, AGENT_RULES_DIR, name, "SKILL.md");
+const detectAgentRules = (projectRoot) => {
+  const present = [];
+  const missing = [];
+  for (const name of LUNORA_SKILL_NAMES) {
+    if (existsSync(skillFile(projectRoot, name))) {
+      present.push(name);
+    } else {
+      missing.push(name);
+    }
+  }
+  return { installed: existsSync(skillFile(projectRoot, ROOT_SKILL_NAME)), missing, present };
+};
+
+export { AGENT_RULES_DIR, AGENT_RULES_HINT, AGENT_RULES_HINT_ENV, LUNORA_SKILL_NAMES, ROOT_SKILL_NAME, claimAgentRulesHint, detectAgentRules };

package/dist/packem_shared/DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs

@@ -0,0 +1,37 @@
+const DEV_VARS_FILE = ".dev.vars";
+const DEV_VARS_EXAMPLE_FILE = ".dev.vars.example";
+const DEV_VARS_KEY_PATTERN = /^[A-Za-z_]\w*$/u;
+const DEV_VARS_NEWLINE = /\r?\n/u;
+const unquoteDevVariable = (value) => {
+  if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+};
+const splitDevVariableLine = (line) => {
+  const trimmed = line.trim();
+  if (trimmed === "" || trimmed.startsWith("#")) {
+    return void 0;
+  }
+  const equals = trimmed.indexOf("=");
+  if (equals <= 0) {
+    return void 0;
+  }
+  const key = trimmed.slice(0, equals).trim();
+  if (!DEV_VARS_KEY_PATTERN.test(key)) {
+    return void 0;
+  }
+  return { key, value: trimmed.slice(equals + 1).trim() };
+};
+const parseDevVariableEntries = (content) => {
+  const entries = [];
+  for (const line of content.split(DEV_VARS_NEWLINE)) {
+    const parsed = splitDevVariableLine(line);
+    if (parsed) {
+      entries.push({ key: parsed.key, value: unquoteDevVariable(parsed.value) });
+    }
+  }
+  return entries;
+};
+
+export { DEV_VARS_EXAMPLE_FILE, DEV_VARS_FILE, DEV_VARS_KEY_PATTERN, DEV_VARS_NEWLINE, parseDevVariableEntries, splitDevVariableLine, unquoteDevVariable };

package/dist/packem_shared/LINKED_PROJECT_DIR-CXwXzV_C.mjs

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { parse } from 'jsonc-parser';
+import { join } from 'node:path';
+
+const LINKED_PROJECT_DIR = ".lunora";
+const LINKED_PROJECT_FILE = join(LINKED_PROJECT_DIR, "project.json");
+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 readLinkedProject = (projectRoot) => {
+  const path = join(projectRoot, LINKED_PROJECT_FILE);
+  if (!existsSync(path)) {
+    return void 0;
+  }
+  let text;
+  try {
+    text = readFileSync(path, "utf8");
+  } catch {
+    return void 0;
+  }
+  const parseErrors = [];
+  const parsed = parse(text, parseErrors, { allowTrailingComma: true });
+  if (parseErrors.length > 0 || !isObject(parsed)) {
+    return void 0;
+  }
+  return {
+    account: stringField(parsed, "account"),
+    env: stringField(parsed, "env"),
+    linkedAt: stringField(parsed, "linkedAt"),
+    workerName: stringField(parsed, "workerName"),
+    workerUrl: stringField(parsed, "workerUrl")
+  };
+};
+const writeLinkedProject = (projectRoot, link) => {
+  const directory = join(projectRoot, LINKED_PROJECT_DIR);
+  mkdirSync(directory, { recursive: true });
+  const record = {};
+  for (const key of ["account", "env", "linkedAt", "workerName", "workerUrl"]) {
+    const value = link[key];
+    if (value !== void 0 && value !== "") {
+      record[key] = value;
+    }
+  }
+  const path = join(projectRoot, LINKED_PROJECT_FILE);
+  writeFileSync(path, `${JSON.stringify(record, void 0, 2)}
+`, "utf8");
+  return path;
+};
+
+export { LINKED_PROJECT_DIR, LINKED_PROJECT_FILE, readLinkedProject, writeLinkedProject };

package/dist/packem_shared/LUNORA_CONFIG_FILE-CtcIcB5-.mjs

@@ -0,0 +1,34 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parse } from 'jsonc-parser';
+import { join } from 'node:path';
+
+const LUNORA_CONFIG_FILE = "lunora.json";
+const interpretRemote = (value) => {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value !== null && typeof value === "object") {
+    return true;
+  }
+  return void 0;
+};
+const readProjectRemotePreference = (projectRoot) => {
+  const configPath = join(projectRoot, LUNORA_CONFIG_FILE);
+  if (!existsSync(configPath)) {
+    return void 0;
+  }
+  let text;
+  try {
+    text = readFileSync(configPath, "utf8");
+  } catch {
+    return void 0;
+  }
+  const parseErrors = [];
+  const parsed = parse(text, parseErrors, { allowTrailingComma: true });
+  if (parseErrors.length > 0 || parsed === null || typeof parsed !== "object") {
+    return void 0;
+  }
+  return interpretRemote(parsed.remote);
+};
+
+export { LUNORA_CONFIG_FILE, interpretRemote, readProjectRemotePreference };

package/dist/packem_shared/LUNORA_EVENT_SOURCE-D2fDeGB6.mjs

@@ -0,0 +1,86 @@
+const LUNORA_EVENT_SOURCE = "lunora";
+const ROOT_SHARD_NAME = "__root__";
+const asString = (value) => typeof value === "string" ? value : "";
+const asStringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+const formatDuration = (value) => typeof value === "number" && Number.isFinite(value) ? `${String(Math.round(value))}ms` : "?ms";
+const toLineLevel = (rawLevel) => {
+  if (rawLevel === "error") {
+    return "error";
+  }
+  if (rawLevel === "warn") {
+    return "warn";
+  }
+  return "info";
+};
+const parseLunoraEvent = (line) => {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const event = parsed;
+  return event.source === LUNORA_EVENT_SOURCE ? event : void 0;
+};
+const labelFor = (functionPath, event) => {
+  const shard = asString(event.shard);
+  return shard === "" || shard === ROOT_SHARD_NAME ? functionPath : `${functionPath}@${shard}`;
+};
+const formatRequest = (event, functionPath) => {
+  const failed = event.outcome === "error";
+  const parts = [labelFor(functionPath, event), failed ? "error" : "ok", formatDuration(event.durationMs)];
+  const read = asStringList(event.tablesRead);
+  const written = asStringList(event.tablesWritten);
+  if (read.length > 0) {
+    parts.push(`read[${read.join(",")}]`);
+  }
+  if (written.length > 0) {
+    parts.push(`write[${written.join(",")}]`);
+  }
+  if (event.cacheHit === true) {
+    parts.push("cached");
+  }
+  const errorMessage = asString(event.error);
+  if (failed && errorMessage !== "") {
+    parts.push(errorMessage);
+  }
+  return { kind: "rpc", level: failed ? "error" : "info", text: parts.join("  ") };
+};
+const formatContainer = (event) => {
+  const name = asString(event.container) || "<unknown>";
+  const instance = asString(event.instance);
+  const transition = asString(event.event) || "event";
+  const shortId = instance === "" || instance === "unknown" ? "" : `#${instance.slice(0, 8)}`;
+  const message = asString(event.message);
+  const parts = [`container:${name}${shortId}`, transition];
+  if (message !== "") {
+    parts.push(message);
+  }
+  return { kind: "log", level: event.event === "error" ? "error" : "info", text: parts.join("  ") };
+};
+const formatLunoraEvent = (line) => {
+  const event = parseLunoraEvent(line);
+  if (!event) {
+    return void 0;
+  }
+  const functionPath = asString(event.function) || "<unknown>";
+  if (event.type === "log") {
+    return { kind: "log", level: toLineLevel(asString(event.level)), text: `${labelFor(functionPath, event)}  ${asString(event.message)}`.trimEnd() };
+  }
+  if (event.type === "request") {
+    return formatRequest(event, functionPath);
+  }
+  if (event.type === "container") {
+    return formatContainer(event);
+  }
+  return void 0;
+};
+
+export { LUNORA_EVENT_SOURCE, formatLunoraEvent };

package/dist/packem_shared/LunoraReporter-Ci-bDCK9.mjs

@@ -0,0 +1,70 @@
+import { paintBadge, badgeWidth, BADGES } from './ACCENT-DW1XJn8i.mjs';
+
+const NAME_ALIASES = {
+  informational: "info",
+  warning: "warn"
+};
+const STDERR_LEVELS = /* @__PURE__ */ new Set(["alert", "critical", "emergency", "error", "warn", "warning"]);
+const resolveBadge = (name) => {
+  if (name in BADGES) {
+    return BADGES[name];
+  }
+  const alias = NAME_ALIASES[name];
+  return alias === void 0 ? void 0 : BADGES[alias];
+};
+const renderContextArgument = (value) => {
+  if (value instanceof Error) {
+    return `
+${value.stack ?? value.message}`;
+  }
+  if (typeof value === "object" && value !== null) {
+    try {
+      return ` ${JSON.stringify(value)}`;
+    } catch {
+      return " [unserializable]";
+    }
+  }
+  return ` ${String(value)}`;
+};
+const composeMessage = (meta) => {
+  const base = typeof meta.message === "string" ? meta.message : String(meta.message);
+  const context = meta.context ?? [];
+  return context.length === 0 ? base : base + context.map((value) => renderContextArgument(value)).join("");
+};
+class LunoraReporter {
+  #stdout = process.stdout;
+  #stderr = process.stderr;
+  setStdout(stdout) {
+    this.#stdout = stdout;
+  }
+  setStderr(stderr) {
+    this.#stderr = stderr;
+  }
+  // Note: pail's other reporter setters (setLoggerTypes / setInteractiveManager /
+  // setIsInteractive) are optional and intentionally omitted — this reporter keeps
+  // no type or interactive state; it only needs the two stream setters above.
+  log(meta) {
+    const data = meta;
+    const badge = resolveBadge(data.type.name);
+    const stream = STDERR_LEVELS.has(data.type.level ?? data.type.name) ? this.#stderr : this.#stdout;
+    stream.write(LunoraReporter.#render(badge, composeMessage(data)));
+  }
+  /**
+   * Frame `text` under `badge`: `<badge> <first line>`, with any further lines
+   * indented to align beneath the message. Without a badge (unknown type) the
+   * message is written plain.
+   */
+  static #render(badge, text) {
+    if (badge === void 0) {
+      return `${text}
+`;
+    }
+    const [first = "", ...rest] = text.split("\n");
+    const indent = " ".repeat(badgeWidth() + 1);
+    const lines = [`${paintBadge(badge)} ${first}`, ...rest.map((line) => `${indent}${line}`)];
+    return `${lines.join("\n")}
+`;
+  }
+}
+
+export { LunoraReporter as default };

package/dist/packem_shared/PACKAGE_SECRETS_REGISTRY-B8t_SdoZ.mjs

@@ -0,0 +1,70 @@
+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": [
+    {
+      description: "32-byte random secret used to sign sessions and tokens. Generate with: openssl rand -hex 32",
+      docsUrl: "https://lunora.sh/docs/packages/auth#secrets",
+      key: "AUTH_SECRET",
+      placeholderValue: "replace-with-openssl-rand-hex-32"
+    },
+    {
+      description: "Public base URL of your worker (used by better-auth for redirects and cookie domain). For local dev this is typically http://localhost:8787",
+      docsUrl: "https://lunora.sh/docs/packages/auth#secrets",
+      key: "AUTH_URL",
+      placeholderValue: "http://localhost:8787"
+    }
+  ],
+  "@lunora/mail": [
+    {
+      description: "Resend API key for sending transactional email via @lunora/mail. Obtain at https://resend.com/api-keys",
+      docsUrl: "https://lunora.sh/docs/packages/mail#secrets",
+      key: "RESEND_API_KEY",
+      placeholderValue: "<your-resend-api-key>"
+    }
+  ],
+  "@lunora/payment": [
+    {
+      description: "Stripe secret key (sk_test_…). Required when using the Stripe adapter. Obtain at https://dashboard.stripe.com/apikeys",
+      docsUrl: "https://lunora.sh/docs/packages/payment#stripe",
+      key: "STRIPE_SECRET_KEY",
+      placeholderValue: "<your-stripe-secret-key>"
+    },
+    {
+      description: "Stripe webhook signing secret (whsec_…) for verifying event payloads. Obtain at https://dashboard.stripe.com/webhooks",
+      docsUrl: "https://lunora.sh/docs/packages/payment#stripe",
+      key: "STRIPE_WEBHOOK_SECRET",
+      placeholderValue: "<your-stripe-webhook-secret>"
+    },
+    {
+      description: "Polar access token for the Polar payment adapter. Obtain at https://polar.sh/settings/tokens",
+      docsUrl: "https://lunora.sh/docs/packages/payment#polar",
+      key: "POLAR_ACCESS_TOKEN",
+      placeholderValue: "<your-polar-access-token>"
+    },
+    {
+      description: "Polar webhook secret for verifying event payloads from Polar. Obtain at https://polar.sh/settings/webhooks",
+      docsUrl: "https://lunora.sh/docs/packages/payment#polar",
+      key: "POLAR_WEBHOOK_SECRET",
+      placeholderValue: "<your-polar-webhook-secret>"
+    }
+  ]
+};
+const secretsForPackages = (packageNames) => {
+  const result = [];
+  for (const name of packageNames) {
+    const entries = PACKAGE_SECRETS_REGISTRY[name];
+    if (entries !== void 0) {
+      result.push(...entries);
+    }
+  }
+  return result;
+};
+
+export { CORE_SECRETS, PACKAGE_SECRETS_REGISTRY, secretsForPackages };

package/dist/packem_shared/POLICY_SCAFFOLD_ENDPOINT-CiC2IGKx.mjs

@@ -0,0 +1,103 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { join, isAbsolute, relative } from 'node:path';
+import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { classifyPolicyEdit, scaffoldPolicyFile, wireRlsIntoProcedure } from './classifyPolicyEdit-BHeAqF8P.mjs';
+
+const POLICY_SCAFFOLD_ENDPOINT = "/__lunora/policy-scaffold";
+const statusForFailure = (reason) => {
+  if (reason === "unknown-procedure") {
+    return 404;
+  }
+  if (reason === "already-wired") {
+    return 409;
+  }
+  return reason === "destructive" ? 409 : 422;
+};
+const writeAtomic = (path, text) => {
+  const temporaryPath = `${path}.lunora-tmp`;
+  writeFileSync(temporaryPath, text, "utf8");
+  renameSync(temporaryPath, path);
+};
+const runCodegenForResponse = (request, okBody) => {
+  let diagnostics = [];
+  try {
+    runCodegen({ lunoraDirectory: request.schemaDirectory ?? "lunora", projectRoot: request.projectRoot });
+  } catch (error) {
+    if (error instanceof CodegenDiagnosticError) {
+      diagnostics = [error.message];
+    } else {
+      return { body: { error: error instanceof Error ? error.message : String(error), ok: false }, status: 500 };
+    }
+  }
+  return { body: { ...okBody, diagnostics, ok: true }, status: 200 };
+};
+const refuseDestructive = (edit) => {
+  return {
+    body: {
+      edit,
+      message: "Rewriting an existing policy predicate changes evaluation semantics and must be done by hand. The scaffolder only adds new, deny-by-default rules.",
+      needsManualEdit: true,
+      ok: false
+    },
+    status: 409
+  };
+};
+const handleScaffoldPolicy = (request, edit) => {
+  const result = scaffoldPolicyFile(edit);
+  if (!result.ok) {
+    return { body: { error: result.reason, ok: false }, status: statusForFailure(result.reason) };
+  }
+  const lunoraDirectory = request.schemaDirectory ?? "lunora";
+  const targetPath = join(request.projectRoot, lunoraDirectory, result.fileName);
+  if (existsSync(targetPath)) {
+    return { body: { error: "file-exists", fileName: result.fileName, ok: false }, status: 409 };
+  }
+  writeAtomic(targetPath, result.source);
+  return runCodegenForResponse(request, { fileName: result.fileName });
+};
+const resolveProcedureFile = (projectRoot, lunoraDirectory, filePath) => {
+  if (typeof filePath !== "string" || filePath.length === 0 || isAbsolute(filePath) || filePath.includes("\\")) {
+    return void 0;
+  }
+  const lunoraRoot = join(projectRoot, lunoraDirectory);
+  const resolved = join(lunoraRoot, `${filePath}.ts`);
+  const relativePath = relative(lunoraRoot, resolved);
+  if (relativePath.startsWith("..") || isAbsolute(relativePath)) {
+    return void 0;
+  }
+  return resolved;
+};
+const handleWireRls = (request, edit) => {
+  const procedurePath = resolveProcedureFile(request.projectRoot, request.schemaDirectory ?? "lunora", edit.filePath);
+  if (procedurePath === void 0 || !existsSync(procedurePath)) {
+    return { body: { error: "unknown-procedure", ok: false }, status: 404 };
+  }
+  const wired = wireRlsIntoProcedure(readFileSync(procedurePath, "utf8"), edit);
+  if (!wired.ok) {
+    return { body: { error: wired.reason, ok: false }, status: statusForFailure(wired.reason) };
+  }
+  writeAtomic(procedurePath, wired.text);
+  return runCodegenForResponse(request, { exportName: edit.exportName });
+};
+const handlePolicyScaffoldRequest = (request) => {
+  if (request.method !== "POST") {
+    return { body: { error: "method-not-allowed", ok: false }, status: 405 };
+  }
+  const { body } = request;
+  if (body === void 0 || typeof body !== "object" || typeof body.kind !== "string") {
+    return { body: { error: "invalid-edit", ok: false }, status: 400 };
+  }
+  const edit = body;
+  if (classifyPolicyEdit(edit) === "destructive") {
+    return refuseDestructive(edit);
+  }
+  if (edit.kind === "scaffoldPolicy") {
+    return handleScaffoldPolicy(request, edit);
+  }
+  if (edit.kind === "wireRls") {
+    return handleWireRls(request, edit);
+  }
+  throw new Error(`unhandled additive policy edit kind: ${String(edit.kind)}`);
+};
+
+export { POLICY_SCAFFOLD_ENDPOINT, handlePolicyScaffoldRequest };

package/dist/packem_shared/REMOTE_ELIGIBLE_KEYS-BC7_e9Bz.mjs

@@ -0,0 +1,105 @@
+import { writeFileSync, rmSync } from 'node:fs';
+import { modify, applyEdits } from 'jsonc-parser';
+import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
+import { join } from 'node:path';
+
+const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
+const REMOTE_ELIGIBLE_KEYS = {
+  ai: { label: "AI", shape: "object" },
+  d1_databases: { label: "D1", shape: "array" },
+  kv_namespaces: { label: "KV", shape: "array" },
+  queues: { label: "Queue", shape: "producers" },
+  r2_buckets: { label: "R2", shape: "array" },
+  services: { label: "Service", shape: "array" },
+  vectorize: { label: "Vectorize", shape: "array" }
+};
+const REMOTE_ELIGIBLE_KEY_LIST = Object.keys(REMOTE_ELIGIBLE_KEYS);
+const entryName = (entry, fallback) => typeof entry.binding === "string" ? entry.binding : fallback;
+const planArrayEntries = (section, entries, kind, pathPrefix) => {
+  const plans = [];
+  for (const [index, entry] of entries.entries()) {
+    if (entry === null || entry === void 0) {
+      continue;
+    }
+    plans.push({ binding: entryName(entry, `#${String(index)}`), kind, path: [...pathPrefix, index], section });
+  }
+  return plans;
+};
+const planSection = (section, parsed) => {
+  const { label, shape } = REMOTE_ELIGIBLE_KEYS[section];
+  if (shape === "array") {
+    const entries = parsed[section] ?? [];
+    return planArrayEntries(section, entries, label, []);
+  }
+  if (shape === "producers") {
+    return planArrayEntries(section, parsed.queues?.producers ?? [], label, ["producers"]);
+  }
+  const entry = parsed.ai;
+  return entry === null || entry === void 0 ? [] : [{ binding: entryName(entry, section), kind: label, path: [], section }];
+};
+const planRemoteBindings = (parsed) => REMOTE_ELIGIBLE_KEY_LIST.flatMap((section) => planSection(section, parsed));
+const applyModify = (text, path, value) => {
+  const edits = modify(text, [...path], value, FORMATTING);
+  return edits.length > 0 ? applyEdits(text, edits) : text;
+};
+const injectRemoteFlags = (text, plans) => {
+  let next = text;
+  for (const plan of plans) {
+    next = applyModify(next, [plan.section, ...plan.path, "remote"], true);
+  }
+  return next;
+};
+const noopCleanup = () => {
+};
+const createCleanup = (path) => {
+  let done = false;
+  return () => {
+    if (done) {
+      return;
+    }
+    done = true;
+    try {
+      rmSync(path, { force: true, recursive: true });
+    } catch {
+    }
+  };
+};
+const remoteConfigBasename = () => `.wrangler.lunora-remote.${String(process.pid)}.jsonc`;
+const materializeRemoteWranglerConfig = (options) => {
+  if (!options.enabled) {
+    return { cleanup: noopCleanup, enabled: false, remoteBindings: [] };
+  }
+  const wranglerPath = findWranglerFile(options.projectRoot);
+  if (!wranglerPath) {
+    return { cleanup: noopCleanup, enabled: true, reason: "wrangler.jsonc not found", remoteBindings: [] };
+  }
+  const { parsed, text } = readWranglerJsonc(wranglerPath);
+  if (parsed === void 0) {
+    return { cleanup: noopCleanup, enabled: true, reason: `failed to parse ${wranglerPath} as JSONC`, remoteBindings: [] };
+  }
+  const plans = planRemoteBindings(parsed);
+  if (plans.length === 0) {
+    return { cleanup: noopCleanup, enabled: true, reason: "no remote-eligible bindings to proxy", remoteBindings: [] };
+  }
+  const configPath = join(options.projectRoot, remoteConfigBasename());
+  writeFileSync(configPath, injectRemoteFlags(text, plans), "utf8");
+  return { cleanup: createCleanup(configPath), configPath, enabled: true, remoteBindings: plans };
+};
+const isRemoteEnvEnabled = (value) => {
+  if (value === void 0) {
+    return false;
+  }
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true";
+};
+const resolveRemoteEnabled = (inputs) => {
+  if (inputs.flag === true) {
+    return true;
+  }
+  if (isRemoteEnvEnabled(inputs.envValue)) {
+    return true;
+  }
+  return inputs.configPreference ?? false;
+};
+
+export { REMOTE_ELIGIBLE_KEYS, injectRemoteFlags, isRemoteEnvEnabled, materializeRemoteWranglerConfig, planRemoteBindings, resolveRemoteEnabled };