@lunora/config 1.0.0-alpha.80 → 1.0.0-alpha.82

package/dist/packem_shared/reconcileWranglerBindings-2Cww5VLa.mjs

@@ -1,362 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { containerBuildTag } from '@lunora/container';
-import { a as applyModify } from './jsonc-edit-SbcD7MAe.mjs';
-import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
-
-const D1_PLACEHOLDER_ID = "<replace-with-d1-create-id>";
-const collectExportGaps = (inferred) => {
-  const gaps = [];
-  for (const container of inferred.containers) {
-    if (!container.exported) {
-      gaps.push({ className: container.className, exportName: container.exportName, kind: "container", module: "containers" });
-    }
-  }
-  for (const workflow of inferred.workflows) {
-    if (!workflow.exported) {
-      gaps.push({ className: workflow.className, exportName: workflow.exportName, kind: "workflow", module: "workflows" });
-    }
-  }
-  for (const agent of inferred.agents) {
-    if (!agent.exported) {
-      gaps.push({ className: agent.className, exportName: agent.exportName, kind: "agent", module: "agents" });
-    }
-  }
-  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/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,
-      "@lunora/hyperdrive is used but no hyperdrive binding exists; run 'wrangler hyperdrive create' and add a 'hyperdrive' binding ({ binding, id }) — the id can't be auto-provisioned."
-    ],
-    [
-      inferred.usesPipelines && (parsed?.pipelines?.length ?? 0) === 0,
-      "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);
-};
-const collectX402Warnings = (inferred) => {
-  const rules = [
-    [
-      inferred.usesX402Charge,
-      "@lunora/x402/charge is used; set the recipient wallet address as a [vars] entry (the var name is your choice) and pass it to the charge config — the x402 facilitator settles USDC to that address."
-    ],
-    [
-      inferred.usesX402Pay,
-      "@lunora/x402/pay is used (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding holding the agent wallet key (binding name == signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars."
-    ]
-  ];
-  return rules.filter(([active]) => active).map(([, warning]) => warning);
-};
-const unexportedDeclarationWarnings = (kind, module, declarations) => declarations.filter((declaration) => !declaration.exported).map(
-  (declaration) => `${kind} "${declaration.exportName}" is declared but ${declaration.className} is not exported by the worker entry; add \`export * from "./lunora/_generated/${module}"\` so its binding can be provisioned.`
-);
-const collectWarnings = (inferred, parsed) => {
-  const exported = new Set(inferred.durableObjects.map((object) => object.className));
-  const warnings = [];
-  const hasR2Bucket = (parsed?.r2_buckets?.length ?? 0) > 0;
-  const hasSessionStore = (parsed?.d1_databases?.some((binding) => binding.binding === "DB") ?? false) || inferred.needsD1;
-  if (inferred.usesStorage && !hasR2Bucket) {
-    warnings.push(
-      "@lunora/storage is used but R2 bucket bindings have user-defined names; add an r2_buckets entry and pass env.<BINDING> to createStorage()."
-    );
-  }
-  if (inferred.usesAuth && !exported.has("SessionDO") && !hasSessionStore) {
-    warnings.push(
-      "@lunora/auth is used but the worker entry exports no SessionDO; sessions are D1-backed, or export SessionDO to enable DO-backed sessions."
-    );
-  }
-  if (inferred.usesScheduler && !exported.has("SchedulerDO")) {
-    warnings.push("@lunora/scheduler is used but the worker entry exports no SchedulerDO; export it so the SCHEDULER binding can be provisioned.");
-  }
-  warnings.push(
-    ...unexportedDeclarationWarnings("container", "containers", inferred.containers),
-    ...unexportedDeclarationWarnings("workflow", "workflows", inferred.workflows),
-    ...unexportedDeclarationWarnings("agent", "agents", inferred.agents)
-  );
-  if (inferred.containers.length > 0 && parsed?.observability?.enabled === false) {
-    warnings.push("containers are declared but observability is explicitly disabled in wrangler.jsonc — container logs will not be captured.");
-  }
-  if (inferred.usesPayment) {
-    warnings.push(
-      "@lunora/payment is used; set the provider secrets in .dev.vars — STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)."
-    );
-  }
-  warnings.push(...collectX402Warnings(inferred), ...collectHintBindingWarnings(inferred, parsed));
-  return warnings;
-};
-const nextMigrationTag = (migrations) => {
-  const used = new Set(migrations.map((migration) => migration.tag));
-  let index = 1;
-  while (used.has(`v${String(index)}`)) {
-    index += 1;
-  }
-  return `v${String(index)}`;
-};
-const reconcileDurableObjects = (text, parsed, required) => {
-  const existingBindings = parsed.durable_objects?.bindings ?? [];
-  const existingNames = new Set(existingBindings.map((binding) => binding.name));
-  const missing = required.filter((object) => !existingNames.has(object.binding));
-  let nextText = text;
-  const added = [];
-  if (missing.length > 0) {
-    const nextBindings = [
-      ...existingBindings,
-      ...missing.map((object) => {
-        return { class_name: object.className, name: object.binding };
-      })
-    ];
-    nextText = applyModify(nextText, ["durable_objects", "bindings"], nextBindings);
-    added.push(...missing.map((object) => `${object.binding}/${object.className}`));
-  }
-  const migrations = parsed.migrations ?? [];
-  const registered = new Set(migrations.flatMap((migration) => [...migration.new_sqlite_classes ?? [], ...migration.new_classes ?? []]));
-  const missingClasses = required.map((object) => object.className).filter((className) => !registered.has(className));
-  if (missingClasses.length > 0) {
-    const nextMigrations = [...migrations, { new_sqlite_classes: missingClasses, tag: nextMigrationTag(migrations) }];
-    nextText = applyModify(nextText, ["migrations"], nextMigrations);
-  }
-  return { added, text: nextText };
-};
-const reconcileD1 = (text, parsed) => {
-  const d1Bindings = parsed.d1_databases ?? [];
-  if (d1Bindings.some((binding) => binding.binding === "DB")) {
-    return { added: [], text };
-  }
-  const databaseName = typeof parsed.name === "string" && parsed.name.length > 0 ? parsed.name : "lunora";
-  const nextD1 = [...d1Bindings, { binding: "DB", database_id: D1_PLACEHOLDER_ID, database_name: databaseName }];
-  return { added: ["DB (D1)"], text: applyModify(text, ["d1_databases"], nextD1) };
-};
-const reconcileSelfDescribing = (text, parsed, key, binding, label) => {
-  const current = parsed[key]?.binding;
-  if (typeof current === "string" && current.length > 0) {
-    return { added: [], text };
-  }
-  return { added: [label], text: applyModify(text, [key], { binding }) };
-};
-const reconcileAnalytics = (text, parsed) => {
-  if ((parsed.analytics_engine_datasets?.length ?? 0) > 0) {
-    return { added: [], text };
-  }
-  const nextDatasets = [{ binding: "ANALYTICS", dataset: "ANALYTICS" }];
-  return { added: ["ANALYTICS (Analytics Engine)"], text: applyModify(text, ["analytics_engine_datasets"], nextDatasets) };
-};
-const wranglerInstanceType = (instanceType) => {
-  if (typeof instanceType === "string") {
-    return instanceType;
-  }
-  const custom = {};
-  if (instanceType.diskMb !== void 0) {
-    custom.disk_mb = instanceType.diskMb;
-  }
-  if (instanceType.memoryMib !== void 0) {
-    custom.memory_mib = instanceType.memoryMib;
-  }
-  if (instanceType.vcpu !== void 0) {
-    custom.vcpu = instanceType.vcpu;
-  }
-  return custom;
-};
-const imageRefFor = (container) => {
-  if (container.image.kind === "dockerfile") {
-    return container.image.dockerfilePath;
-  }
-  if (container.image.kind === "registry") {
-    return container.image.reference;
-  }
-  return containerBuildTag(container.exportName);
-};
-const containerEntryFor = (container) => {
-  const entry = {
-    class_name: container.className,
-    image: imageRefFor(container)
-  };
-  if (container.image.kind === "dockerfile") {
-    entry.image_build_context = container.image.buildContext;
-  }
-  if (container.buildArgs !== void 0 && container.image.kind !== "registry") {
-    entry.image_vars = container.buildArgs;
-  }
-  if (container.instanceType !== void 0) {
-    entry.instance_type = wranglerInstanceType(container.instanceType);
-  }
-  if (container.maxInstances !== void 0) {
-    entry.max_instances = container.maxInstances;
-  }
-  if (container.name !== void 0) {
-    entry.name = container.name;
-  }
-  if (container.rollout?.stepPercentage !== void 0) {
-    entry.rollout_step_percentage = container.rollout.stepPercentage;
-  }
-  if (container.rollout?.gracePeriodSeconds !== void 0) {
-    entry.rollout_active_grace_period = container.rollout.gracePeriodSeconds;
-  }
-  return entry;
-};
-const reconcileContainers = (text, parsed, containers) => {
-  const existing = parsed.containers ?? [];
-  const existingClasses = new Set(existing.map((entry) => entry.class_name));
-  const missing = containers.filter((container) => !existingClasses.has(container.className));
-  if (missing.length === 0) {
-    return { added: [], text };
-  }
-  const nextText = applyModify(text, ["containers"], [...existing, ...missing.map((container) => containerEntryFor(container))]);
-  return { added: missing.map((container) => `containers/${container.className}`), text: nextText };
-};
-const reconcileObservability = (text, parsed) => {
-  if (parsed.observability !== void 0) {
-    return { added: [], text };
-  }
-  const nextText = applyModify(text, ["observability"], { enabled: true, head_sampling_rate: 1 });
-  return { added: ["observability"], text: nextText };
-};
-const workflowEntryFor = (workflow) => {
-  return { binding: workflow.bindingName, class_name: workflow.className, name: workflow.name };
-};
-const agentEntryFor = (agent) => {
-  return { binding: agent.bindingName, class_name: agent.className, name: agent.name };
-};
-const reconcileWorkflows = (text, parsed, workflows, agents = []) => {
-  const existing = parsed.workflows ?? [];
-  const existingClasses = new Set(existing.map((entry) => entry.class_name));
-  const missingWorkflows = workflows.filter((workflow) => !existingClasses.has(workflow.className));
-  const missingAgents = agents.filter((agent) => !existingClasses.has(agent.className));
-  if (missingWorkflows.length === 0 && missingAgents.length === 0) {
-    return { added: [], text };
-  }
-  const nextText = applyModify(
-    text,
-    ["workflows"],
-    [...existing, ...missingWorkflows.map((workflow) => workflowEntryFor(workflow)), ...missingAgents.map((agent) => agentEntryFor(agent))]
-  );
-  return {
-    added: [...missingWorkflows.map((workflow) => `workflows/${workflow.className}`), ...missingAgents.map((agent) => `workflows/${agent.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);
-  if (!wranglerPath) {
-    return { added: [], changed: false, exportGaps, reason: "wrangler.jsonc not found", warnings: collectWarnings(inferred) };
-  }
-  const { parsed, text: original } = readWranglerJsonc(wranglerPath);
-  if (parsed === void 0) {
-    return { added: [], changed: false, exportGaps, reason: `failed to parse ${wranglerPath} as JSONC`, warnings: collectWarnings(inferred), wranglerPath };
-  }
-  const warnings = collectWarnings(inferred, parsed);
-  const exportedContainers = inferred.containers.filter((container) => container.exported);
-  const voiceAgents = inferred.agents.filter(
-    (agent) => agent.exported && agent.voice === true && agent.voiceBindingName !== void 0 && agent.voiceClassName !== void 0
-  );
-  const requiredDurableObjects = [
-    ...inferred.durableObjects,
-    ...exportedContainers.map((container) => {
-      return { binding: container.bindingName, className: container.className };
-    }),
-    ...voiceAgents.map((agent) => {
-      return { binding: agent.voiceBindingName, className: agent.voiceClassName };
-    })
-  ];
-  const exportedWorkflows = inferred.workflows.filter((workflow) => workflow.exported);
-  const exportedAgents = inferred.agents.filter((agent) => agent.exported);
-  const pipeline = [
-    { enabled: true, run: (text2) => reconcileDurableObjects(text2, parsed, requiredDurableObjects) },
-    { enabled: inferred.needsD1, run: (text2) => reconcileD1(text2, parsed) },
-    { enabled: inferred.usesAi, run: (text2) => reconcileSelfDescribing(text2, parsed, "ai", "AI", "AI (Workers AI)") },
-    { enabled: inferred.usesBrowser, run: (text2) => reconcileSelfDescribing(text2, parsed, "browser", "BROWSER", "BROWSER (Browser Rendering)") },
-    { enabled: inferred.usesImages, run: (text2) => reconcileSelfDescribing(text2, parsed, "images", "IMAGES", "IMAGES (Cloudflare Images)") },
-    { 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 || exportedAgents.length > 0,
-      run: (text2) => reconcileWorkflows(text2, parsed, exportedWorkflows, exportedAgents)
-    },
-    { enabled: inferred.queues.length > 0, run: (text2) => reconcileQueues(text2, parsed, inferred.queues) }
-  ];
-  let text = original;
-  const added = [];
-  for (const step of pipeline) {
-    if (!step.enabled) {
-      continue;
-    }
-    const result = step.run(text);
-    text = result.text;
-    added.push(...result.added);
-  }
-  if (added.includes("DB (D1)")) {
-    warnings.push(
-      `wrote a DB binding with a placeholder database_id ("${D1_PLACEHOLDER_ID}") — run \`wrangler d1 create <name>\` and replace it before deploying.`
-    );
-  }
-  if (text === original) {
-    return { added: [], changed: false, exportGaps, reason: "bindings already in sync", warnings, wranglerPath };
-  }
-  writeFileSync(wranglerPath, text, "utf8");
-  return { added, changed: true, exportGaps, warnings, wranglerPath };
-};
-
-export { reconcileWranglerBindings };

package/dist/packem_shared/reconcileWranglerCompatibilityDate-C8c497ag.mjs

@@ -1,31 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { modify, applyEdits } from 'jsonc-parser';
-import { F as FORMATTING } from './jsonc-edit-SbcD7MAe.mjs';
-import { isCacheEnabled, WORKERS_CACHE_MIN_DATE } from './WORKERS_CACHE_MIN_DATE-CaXbS7CX.mjs';
-import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
-
-const reconcileWranglerCompatibilityDate = (projectRoot) => {
-  const wranglerPath = findWranglerFile(projectRoot);
-  if (!wranglerPath) {
-    return { changed: false, date: void 0, reason: "wrangler.jsonc not found" };
-  }
-  const { parsed, text } = readWranglerJsonc(wranglerPath);
-  if (parsed === void 0) {
-    return { changed: false, date: void 0, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
-  }
-  const currentDate = parsed.compatibility_date ?? "";
-  if (!isCacheEnabled(parsed)) {
-    return { changed: false, date: currentDate || void 0, reason: "cache not enabled", wranglerPath };
-  }
-  if (currentDate >= WORKERS_CACHE_MIN_DATE) {
-    return { changed: false, date: currentDate, reason: `compatibility_date already >= ${WORKERS_CACHE_MIN_DATE}`, wranglerPath };
-  }
-  const edits = modify(text, ["compatibility_date"], WORKERS_CACHE_MIN_DATE, FORMATTING);
-  if (edits.length === 0) {
-    return { changed: false, date: currentDate || void 0, reason: "no structural edit produced", wranglerPath };
-  }
-  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
-  return { changed: true, date: WORKERS_CACHE_MIN_DATE, wranglerPath };
-};
-
-export { reconcileWranglerCompatibilityDate };

package/dist/packem_shared/reconcileWranglerCrons-DvsceVFz.mjs

@@ -1,29 +0,0 @@
-import { writeFileSync } from 'node:fs';
-import { modify, applyEdits } from 'jsonc-parser';
-import { findWranglerFile, readWranglerJsonc } from './WRANGLER_FILES-DwSuC-Kn.mjs';
-
-const sameTriggers = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
-const reconcileWranglerCrons = (projectRoot, cronTriggers) => {
-  const wranglerPath = findWranglerFile(projectRoot);
-  if (!wranglerPath) {
-    return { changed: false, reason: "wrangler.jsonc not found" };
-  }
-  const { parsed, text } = readWranglerJsonc(wranglerPath);
-  if (parsed === void 0) {
-    return { changed: false, reason: `failed to parse ${wranglerPath} as JSONC`, wranglerPath };
-  }
-  const existing = Array.isArray(parsed.triggers?.crons) ? parsed.triggers.crons.filter((value) => typeof value === "string") : [];
-  if (sameTriggers(existing, cronTriggers)) {
-    return { changed: false, reason: "triggers.crons already in sync", wranglerPath };
-  }
-  const edits = modify(text, ["triggers", "crons"], [...cronTriggers], {
-    formattingOptions: { insertSpaces: true, tabSize: 4 }
-  });
-  if (edits.length === 0) {
-    return { changed: false, reason: "no structural edit produced", wranglerPath };
-  }
-  writeFileSync(wranglerPath, applyEdits(text, edits), "utf8");
-  return { changed: true, wranglerPath };
-};
-
-export { reconcileWranglerCrons };

package/dist/packem_shared/renderStudioHtml-449Ysn75.mjs

@@ -1,37 +0,0 @@
-const forInlineScript = (value) => JSON.stringify(value).replaceAll("<", String.raw`\u003c`);
-const forAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
-const renderStudioHtml = (config) => {
-  const settings = [`window.__LUNORA_BASE_PATH__=${forInlineScript(config.basePath)};`];
-  if (config.adminToken !== void 0 && config.adminToken !== "") {
-    settings.push(`window.__LUNORA_ADMIN_TOKEN__=${forInlineScript(config.adminToken)};`);
-  }
-  if (config.dataEditable === true) {
-    settings.push("window.__LUNORA_DATA_EDITABLE__=true;");
-  }
-  if (config.runAsIdentity === true) {
-    settings.push("window.__LUNORA_RUN_AS_IDENTITY__=true;");
-  }
-  if (config.schemaEditable === true) {
-    settings.push("window.__LUNORA_SCHEMA_EDITABLE__=true;");
-  }
-  if (config.rulesInstalled === false) {
-    settings.push("window.__LUNORA_RULES_INSTALLED__=false;");
-  }
-  return `<!doctype html>
-<html lang="en">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>Lunora Studio</title>
-        <script>${settings.join("")}<\/script>
-        <link rel="stylesheet" href="${forAttribute(config.styleHref)}" />
-    </head>
-    <body>
-        <div id="root"></div>
-        <script type="module" src="${forAttribute(config.scriptSrc)}"><\/script>
-    </body>
-</html>
-`;
-};
-
-export { renderStudioHtml as default };

package/dist/packem_shared/serveJsonHandler-Cl2Wqkv8.mjs

@@ -1,86 +0,0 @@
-const MAX_BODY_BYTES = 1e6;
-const readBody = async (request) => await new Promise((resolve, reject) => {
-  const chunks = [];
-  let size = 0;
-  request.on("data", (chunk) => {
-    size += chunk.length;
-    if (size > MAX_BODY_BYTES) {
-      reject(new Error("request body too large"));
-      return;
-    }
-    chunks.push(chunk);
-  });
-  request.on("end", () => {
-    resolve(Buffer.concat(chunks).toString("utf8"));
-  });
-  request.on("error", reject);
-});
-const respondJson = (response, status, body) => {
-  response.statusCode = status;
-  response.setHeader("Content-Type", "application/json; charset=utf-8");
-  response.end(JSON.stringify(body));
-};
-const headerValue = (raw) => {
-  const value = Array.isArray(raw) ? raw[0] : raw;
-  return typeof value === "string" ? value.trim().toLowerCase() : void 0;
-};
-const SAME_SITE_FETCH_VALUES = /* @__PURE__ */ new Set(["none", "same-origin", "same-site"]);
-const originRejectionReason = (request) => {
-  const secFetchSite = headerValue(request.headers["sec-fetch-site"]);
-  if (secFetchSite !== void 0) {
-    return SAME_SITE_FETCH_VALUES.has(secFetchSite) ? void 0 : "cross-origin request rejected";
-  }
-  const origin = headerValue(request.headers.origin);
-  if (origin === void 0 || origin === "null") {
-    return void 0;
-  }
-  let originHost;
-  try {
-    originHost = new URL(origin).host.toLowerCase();
-  } catch {
-    return "invalid origin header";
-  }
-  return originHost === headerValue(request.headers.host) ? void 0 : "cross-origin request rejected";
-};
-const csrfRejectionReason = (request) => {
-  const method = (request.method ?? "GET").toUpperCase();
-  const isStateChanging = method !== "GET" && method !== "HEAD";
-  const originReason = originRejectionReason(request);
-  if (originReason !== void 0) {
-    return originReason;
-  }
-  if (isStateChanging) {
-    const contentType = headerValue(request.headers["content-type"]);
-    if (!contentType?.startsWith("application/json")) {
-      return "content-type must be application/json";
-    }
-  }
-  return void 0;
-};
-const serveJsonHandler = (request, response, handle, projectRoot, schemaDirectory) => {
-  const run = async () => {
-    try {
-      const rejection = csrfRejectionReason(request);
-      if (rejection !== void 0) {
-        respondJson(response, 403, { error: rejection, ok: false });
-        return;
-      }
-      const raw = request.method === "GET" ? "" : await readBody(request);
-      let parsed;
-      try {
-        parsed = raw === "" ? void 0 : JSON.parse(raw);
-      } catch {
-        respondJson(response, 400, { error: "invalid-json", ok: false });
-        return;
-      }
-      const result = handle({ body: parsed, method: request.method ?? "POST", projectRoot, schemaDirectory });
-      respondJson(response, result.status, result.body);
-    } catch (error) {
-      respondJson(response, 500, { error: error instanceof Error ? error.message : String(error), ok: false });
-    }
-  };
-  run().catch(() => {
-  });
-};
-
-export { serveJsonHandler };