@lunora/config 0.0.0 → 1.0.0-alpha.10

package/dist/packem_shared/REQUIRED_COMPATIBILITY_DATE-DRSNSOOp.mjs

@@ -0,0 +1,476 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+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";
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+const validateVectorizeBindings = (wrangler, vectorIndexNames, errors) => {
+  if (vectorIndexNames.length === 0) {
+    return;
+  }
+  const vectorizeBindings = wrangler.vectorize ?? [];
+  const declaredIndexNames = new Set(vectorizeBindings.filter(Boolean).map((binding) => binding?.index_name));
+  for (const indexName of vectorIndexNames) {
+    if (!declaredIndexNames.has(indexName)) {
+      errors.push(`schema declares vector index "${indexName}"; wrangler "vectorize" must include a binding with index_name "${indexName}"`);
+    }
+  }
+};
+const NAMED_INSTANCE_TYPES = /* @__PURE__ */ new Set(["basic", "dev", "lite", "standard", "standard-1", "standard-2", "standard-3", "standard-4"]);
+const CUSTOM_INSTANCE_LIMITS = { disk_mb: 2e4, memory_mib: 12288, vcpu: 4 };
+const validateInstanceType = (entry, label, errors) => {
+  const instanceType = entry.instance_type;
+  if (instanceType === void 0) {
+    return;
+  }
+  if (typeof instanceType === "string") {
+    if (!NAMED_INSTANCE_TYPES.has(instanceType)) {
+      errors.push(
+        `${label} has unknown instance_type "${instanceType}" — expected lite, basic, standard-1..4, or a custom { vcpu, memory_mib, disk_mb } object`
+      );
+    }
+    return;
+  }
+  for (const [field, limit] of Object.entries(CUSTOM_INSTANCE_LIMITS)) {
+    const value = instanceType[field];
+    if (value !== void 0 && (typeof value !== "number" || value <= 0 || value > limit)) {
+      errors.push(`${label} custom instance_type ${field} must be a positive number ≤ ${String(limit)} (got ${String(value)})`);
+    }
+  }
+  const { disk_mb: diskMb, memory_mib: memoryMib, vcpu } = instanceType;
+  if (typeof vcpu === "number" && typeof memoryMib === "number" && memoryMib < vcpu * 3072) {
+    errors.push(`${label} custom instance_type needs ≥ 3 GiB (3072 MiB) memory per vCPU (got ${String(memoryMib)} MiB for ${String(vcpu)} vCPU)`);
+  }
+  if (typeof memoryMib === "number" && typeof diskMb === "number") {
+    const maxDiskMb = Math.floor(memoryMib / 1024 * 2e3);
+    if (diskMb > maxDiskMb) {
+      errors.push(
+        `${label} custom instance_type allows ≤ 2 GB disk per GiB memory (≤ ${String(maxDiskMb)} MB for ${String(memoryMib)} MiB memory; got ${String(diskMb)} MB)`
+      );
+    }
+  }
+};
+const validateContainerEntry = (entry, label, checks) => {
+  const { boundClasses, errors, nonSqliteClasses, sqliteClasses, warnings } = checks;
+  if (!entry || typeof entry !== "object" || typeof entry.class_name !== "string" || entry.class_name.length === 0) {
+    errors.push(`${label} must have a non-empty "class_name" naming its container-enabled Durable Object class`);
+    return;
+  }
+  if (typeof entry.image !== "string" || entry.image.length === 0) {
+    errors.push(`${label} ("${entry.class_name}") must have an "image" — a Dockerfile path or a registry reference`);
+  }
+  if (!boundClasses.has(entry.class_name)) {
+    errors.push(
+      `${label} class "${entry.class_name}" has no matching durable_objects binding — run \`lunora dev\` to auto-reconcile wrangler.jsonc, or add { "name": "...", "class_name": "${entry.class_name}" }`
+    );
+  }
+  if (!sqliteClasses.has(entry.class_name)) {
+    errors.push(
+      nonSqliteClasses.has(entry.class_name) ? `${label} class "${entry.class_name}" is registered via "new_classes" but containers require SQLite-backed DOs — move it to "new_sqlite_classes"` : `${label} class "${entry.class_name}" is missing from migrations — add a migration entry with "new_sqlite_classes": ["${entry.class_name}"]`
+    );
+  }
+  validateInstanceType(entry, `${label} ("${entry.class_name}")`, errors);
+  if (entry.max_instances === void 0) {
+    warnings.push(`${label} ("${entry.class_name}") declares no max_instances — set a cap so a traffic spike can't fan out unbounded container spend`);
+  }
+};
+const validateContainers = (wrangler, errors, warnings) => {
+  if (wrangler.containers === void 0) {
+    return;
+  }
+  if (!Array.isArray(wrangler.containers)) {
+    errors.push("containers must be an array of { class_name, image, ... } entries");
+    return;
+  }
+  const entries = wrangler.containers;
+  if (entries.length === 0) {
+    return;
+  }
+  const boundClasses = new Set((wrangler.durable_objects?.bindings ?? []).map((binding) => binding.class_name));
+  const migrations = wrangler.migrations ?? [];
+  const sqliteClasses = new Set(migrations.flatMap((migration) => [...migration?.new_sqlite_classes ?? []]));
+  const nonSqliteClasses = new Set(migrations.flatMap((migration) => [...migration?.new_classes ?? []]));
+  for (const [index, entry] of entries.entries()) {
+    validateContainerEntry(entry, `containers[${String(index)}]`, { boundClasses, errors, nonSqliteClasses, sqliteClasses, warnings });
+  }
+  if (wrangler.observability?.enabled !== true) {
+    warnings.push(
+      'containers are configured but observability is not enabled — container logs will not be captured (add { "observability": { "enabled": true } })'
+    );
+  }
+};
+const validateWorkflows = (wrangler, errors) => {
+  if (wrangler.workflows === void 0) {
+    return;
+  }
+  if (!Array.isArray(wrangler.workflows)) {
+    errors.push("workflows must be an array of { name, binding, class_name } entries");
+    return;
+  }
+  const entries = wrangler.workflows;
+  for (const [index, entry] of entries.entries()) {
+    const label = `workflows[${String(index)}]`;
+    if (!entry || typeof entry !== "object") {
+      errors.push(`${label} must be a { name, binding, class_name } object`);
+      continue;
+    }
+    if (typeof entry.binding !== "string" || entry.binding.length === 0) {
+      errors.push(`${label} must have a non-empty "binding" naming the Workflow binding (e.g. WORKFLOW_ORDER_PIPELINE)`);
+    }
+    if (typeof entry.class_name !== "string" || entry.class_name.length === 0) {
+      errors.push(`${label} must have a non-empty "class_name" naming the exported WorkflowEntrypoint class`);
+    }
+    if (typeof entry.name !== "string" || entry.name.length === 0) {
+      errors.push(`${label} must have a non-empty "name" naming the deployed workflow`);
+    }
+  }
+};
+const isNonEmptyString = (value) => typeof value === "string" && value.length > 0;
+const asBindingEntries = (value) => value;
+const HINT_BINDING_RULES = [
+  {
+    arrayMessage: "kv_namespaces must be an array of { binding, id } entries",
+    bindingMessage: (label) => `${label} must have a non-empty "binding" naming the KV namespace binding`,
+    hintField: "id",
+    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: "hyperdrive must be an array of { binding, id } entries",
+    bindingMessage: (label) => `${label} must have a non-empty "binding" naming the Hyperdrive binding`,
+    hintField: "id",
+    hintMessage: (label, binding) => `${label} ("${binding}") has no "id" — run \`wrangler hyperdrive create\` and set the id, or the binding can't connect`,
+    key: "hyperdrive"
+  },
+  {
+    arrayMessage: "pipelines must be an array of { binding, pipeline } entries",
+    bindingMessage: (label) => `${label} must have a non-empty "binding" naming the Pipelines binding`,
+    hintField: "pipeline",
+    hintMessage: (label, binding) => `${label} ("${binding}") has no "pipeline" — run \`wrangler pipelines create <name>\` and set the pipeline name, or the binding can't resolve`,
+    key: "pipelines"
+  },
+  {
+    arrayMessage: "analytics_engine_datasets must be an array of { binding, dataset } entries",
+    bindingMessage: (label) => `${label} must have a non-empty "binding" naming the Analytics Engine binding`,
+    hintField: "dataset",
+    hintMessage: (label, binding) => `${label} ("${binding}") has no "dataset" — it defaults to the binding name; set it explicitly to avoid drift`,
+    key: "analytics_engine_datasets"
+  }
+];
+const validateHintBinding = (wrangler, rule, errors, warnings) => {
+  const value = wrangler[rule.key];
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    errors.push(rule.arrayMessage);
+    return;
+  }
+  for (const [index, entry] of asBindingEntries(value).entries()) {
+    const label = `${rule.key}[${String(index)}]`;
+    if (!entry || typeof entry !== "object" || !isNonEmptyString(entry.binding)) {
+      errors.push(rule.bindingMessage(label));
+      continue;
+    }
+    if (!isNonEmptyString(entry[rule.hintField])) {
+      warnings.push(rule.hintMessage(label, entry.binding));
+    }
+  }
+};
+const SELF_DESCRIBING_BINDING_RULES = [
+  { key: "browser", message: 'browser must be an object with a non-empty "binding" (e.g. { "binding": "BROWSER" })' },
+  { key: "images", message: 'images must be an object with a non-empty "binding" (e.g. { "binding": "IMAGES" })' }
+];
+const validateSelfDescribingBinding = (wrangler, rule, errors) => {
+  const value = wrangler[rule.key];
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "object" || Array.isArray(value) || !isNonEmptyString(value.binding)) {
+    errors.push(rule.message);
+  }
+};
+const REQUIRED_FIELD_BINDING_RULES = [
+  {
+    arrayMessage: "services must be an array of { binding, service, entrypoint? } entries",
+    fields: [
+      { field: "binding", message: (label) => `${label} must have a non-empty "binding" naming the service binding` },
+      { field: "service", message: (label) => `${label} must have a non-empty "service" naming the target Worker` }
+    ],
+    key: "services",
+    objectMessage: (label) => `${label} must be a { binding, service, entrypoint? } object`
+  },
+  {
+    arrayMessage: "dispatch_namespaces must be an array of { binding, namespace } entries",
+    fields: [
+      { field: "binding", message: (label) => `${label} must have a non-empty "binding"` },
+      { field: "namespace", message: (label) => `${label} must have a non-empty "namespace" naming the dispatch namespace` }
+    ],
+    key: "dispatch_namespaces",
+    objectMessage: (label) => `${label} must be a { binding, namespace } object`
+  },
+  {
+    arrayMessage: "mtls_certificates must be an array of { binding, certificate_id } entries",
+    fields: [
+      { field: "binding", message: (label) => `${label} must have a non-empty "binding"` },
+      {
+        field: "certificate_id",
+        message: (label) => `${label} must have a non-empty "certificate_id" (upload via \`wrangler mtls-certificate upload\`)`
+      }
+    ],
+    key: "mtls_certificates",
+    objectMessage: (label) => `${label} must be a { binding, certificate_id } object`
+  }
+];
+const validateRequiredFieldsBinding = (wrangler, rule, errors) => {
+  const value = wrangler[rule.key];
+  if (value === void 0) {
+    return;
+  }
+  if (!Array.isArray(value)) {
+    errors.push(rule.arrayMessage);
+    return;
+  }
+  for (const [index, entry] of asBindingEntries(value).entries()) {
+    const label = `${rule.key}[${String(index)}]`;
+    if (!entry || typeof entry !== "object") {
+      errors.push(rule.objectMessage(label));
+      continue;
+    }
+    for (const field of rule.fields) {
+      if (!isNonEmptyString(entry[field.field])) {
+        errors.push(field.message(label));
+      }
+    }
+  }
+};
+const validateSendEmail = (wrangler, errors, warnings) => {
+  const sendEmail = wrangler.send_email;
+  if (sendEmail === void 0) {
+    return;
+  }
+  if (!Array.isArray(sendEmail)) {
+    errors.push("send_email must be an array of { name, destination_address? } entries");
+    return;
+  }
+  const entries = sendEmail;
+  for (const [index, entry] of entries.entries()) {
+    if (!entry || typeof entry !== "object" || typeof entry.name !== "string" || entry.name.length === 0) {
+      warnings.push(`send_email[${String(index)}] has no non-empty "name" naming the send-email binding — set one before deploying`);
+    }
+  }
+};
+const validateLogpush = (wrangler, errors) => {
+  if (wrangler.logpush !== void 0 && typeof wrangler.logpush !== "boolean") {
+    errors.push('logpush must be a boolean (set "logpush": true to enable Cloudflare Logpush)');
+  }
+};
+const validatePlacement = (wrangler, errors) => {
+  const { placement } = wrangler;
+  if (placement === void 0) {
+    return;
+  }
+  if (typeof placement !== "object" || Array.isArray(placement)) {
+    errors.push('placement must be an object (e.g. { "mode": "smart" })');
+    return;
+  }
+  if (placement.mode !== void 0 && placement.mode !== "smart") {
+    errors.push('placement.mode must be "smart" (the only supported Smart Placement mode)');
+  }
+};
+const validateObservability = (wrangler, errors) => {
+  const { observability } = wrangler;
+  if (observability === void 0) {
+    return;
+  }
+  if (typeof observability !== "object" || Array.isArray(observability)) {
+    errors.push('observability must be an object (e.g. { "enabled": true, "head_sampling_rate": 1 })');
+    return;
+  }
+  const checkSamplingRate = (rate, path) => {
+    if (rate !== void 0 && (typeof rate !== "number" || Number.isNaN(rate) || rate < 0 || rate > 1)) {
+      errors.push(`${path} must be a number in [0, 1] (the fraction of requests sampled)`);
+    }
+  };
+  checkSamplingRate(observability.head_sampling_rate, "observability.head_sampling_rate");
+  if (observability.logs !== void 0) {
+    if (typeof observability.logs !== "object" || Array.isArray(observability.logs)) {
+      errors.push("observability.logs must be an object");
+    } else {
+      checkSamplingRate(observability.logs.head_sampling_rate, "observability.logs.head_sampling_rate");
+    }
+  }
+};
+const validateAssets = (wrangler, errors) => {
+  const { assets } = wrangler;
+  if (assets === void 0) {
+    return;
+  }
+  if (typeof assets !== "object" || Array.isArray(assets)) {
+    errors.push('assets must be an object (e.g. { "directory": "./dist/client", "binding": "ASSETS" })');
+    return;
+  }
+  if (typeof assets.directory !== "string" || assets.directory.length === 0) {
+    errors.push('assets must declare a non-empty "directory" pointing at the built client output (e.g. "./dist/client")');
+  }
+  if (assets.binding !== void 0 && (typeof assets.binding !== "string" || assets.binding.length === 0)) {
+    errors.push('assets.binding must be a non-empty string (e.g. "ASSETS")');
+  }
+  if (assets.html_handling !== void 0 && typeof assets.html_handling !== "string") {
+    errors.push("assets.html_handling must be a string");
+  }
+  if (assets.not_found_handling !== void 0 && typeof assets.not_found_handling !== "string") {
+    errors.push("assets.not_found_handling must be a string");
+  }
+};
+const validateTailConsumers = (wrangler, errors) => {
+  const consumers = wrangler.tail_consumers;
+  if (consumers === void 0) {
+    return;
+  }
+  if (!Array.isArray(consumers)) {
+    errors.push("tail_consumers must be an array of { service, environment? } entries");
+    return;
+  }
+  const entries = consumers;
+  for (const [index, consumer] of entries.entries()) {
+    if (!consumer || typeof consumer !== "object" || typeof consumer.service !== "string" || consumer.service.length === 0) {
+      errors.push(`tail_consumers[${String(index)}] must have a non-empty "service" naming the consumer Worker`);
+    }
+  }
+};
+const withTailConsumer = (wrangler, consumer) => {
+  const existing = wrangler.tail_consumers ?? [];
+  const alreadyWired = existing.some((entry) => Boolean(entry) && entry?.service === consumer.service && entry?.environment === consumer.environment);
+  if (alreadyWired) {
+    return wrangler;
+  }
+  return { ...wrangler, tail_consumers: [...existing, consumer] };
+};
+const TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "enabled", "on", "true", "yes"]);
+const validateCorsVariables = (wrangler, errors) => {
+  const { vars } = wrangler;
+  if (!vars || typeof vars !== "object") {
+    return;
+  }
+  const allowedOrigins = vars["LUNORA_ALLOWED_ORIGINS"];
+  const allowCredentials = vars["LUNORA_CORS_ALLOW_CREDENTIALS"];
+  const hasWildcard = typeof allowedOrigins === "string" && allowedOrigins.split(",").some((entry) => entry.trim() === "*");
+  const credentialsOn = typeof allowCredentials === "string" && TRUTHY_ENV_VALUES.has(allowCredentials.trim().toLowerCase());
+  if (hasWildcard && credentialsOn) {
+    errors.push(
+      'vars.LUNORA_ALLOWED_ORIGINS includes a "*" wildcard while vars.LUNORA_CORS_ALLOW_CREDENTIALS is on — browsers reject this combination and it defeats the allowlist; name explicit origins or drop credentials'
+    );
+  }
+};
+const validateWranglerConfig = (wrangler, schema) => {
+  const errors = [];
+  const warnings = [];
+  if (!wrangler || typeof wrangler !== "object") {
+    errors.push("wrangler config is not a valid object");
+    return { errors, valid: false, warnings };
+  }
+  const durableObjectBindings = wrangler.durable_objects?.bindings ?? [];
+  const shardBinding = durableObjectBindings.find((binding) => binding.name === "SHARD" && binding.class_name === "ShardDO");
+  if (!shardBinding) {
+    errors.push(
+      'durable_objects.bindings must include { "name": "SHARD", "class_name": "ShardDO" } — run `lunora dev` to auto-reconcile wrangler.jsonc, or add the binding manually'
+    );
+  }
+  const compatibilityDate = wrangler.compatibility_date ?? "";
+  if (compatibilityDate && !ISO_DATE_PATTERN.test(compatibilityDate)) {
+    errors.push(`compatibility_date must be in YYYY-MM-DD format (got "${compatibilityDate}")`);
+  } else if (compatibilityDate < REQUIRED_COMPATIBILITY_DATE) {
+    errors.push(`compatibility_date must be >= "${REQUIRED_COMPATIBILITY_DATE}" (got "${compatibilityDate || "<missing>"}")`);
+  }
+  if (schema?.hasGlobalTable) {
+    const d1Bindings = wrangler.d1_databases ?? [];
+    const databaseBinding = d1Bindings.find((binding) => binding.binding === "DB");
+    if (!databaseBinding) {
+      errors.push(
+        'schema declares .global() tables; d1_databases must include a binding named "DB" — run `lunora dev` to auto-reconcile wrangler.jsonc, or add the binding manually'
+      );
+    }
+  }
+  validateVectorizeBindings(wrangler, schema?.vectorIndexNames ?? [], errors);
+  validateTailConsumers(wrangler, errors);
+  validateContainers(wrangler, errors, warnings);
+  validateWorkflows(wrangler, errors);
+  for (const rule of HINT_BINDING_RULES) {
+    validateHintBinding(wrangler, rule, errors, warnings);
+  }
+  for (const rule of REQUIRED_FIELD_BINDING_RULES) {
+    validateRequiredFieldsBinding(wrangler, rule, errors);
+  }
+  for (const rule of SELF_DESCRIBING_BINDING_RULES) {
+    validateSelfDescribingBinding(wrangler, rule, errors);
+  }
+  validateSendEmail(wrangler, errors, warnings);
+  validateLogpush(wrangler, errors);
+  validatePlacement(wrangler, errors);
+  validateObservability(wrangler, errors);
+  validateAssets(wrangler, errors);
+  validateCorsVariables(wrangler, errors);
+  return { errors, valid: errors.length === 0, warnings };
+};
+const validateWrangler = validateWranglerConfig;
+const collectContainerImageErrors = (containers, configDirectory, wranglerPath) => {
+  const errors = [];
+  for (const entry of containers) {
+    const image = entry?.image;
+    if (typeof image !== "string" || !(image.startsWith("./") || image.startsWith("../") || image.startsWith("/") || image.includes("Dockerfile"))) {
+      continue;
+    }
+    if (!existsSync(image.startsWith("/") ? image : join(configDirectory, image))) {
+      errors.push(
+        `containers image "${image}" does not exist (resolved relative to ${wranglerPath}); create the Dockerfile or point image at a registry reference`
+      );
+    }
+  }
+  return errors;
+};
+const validateWranglerProject = (options) => {
+  const schemaDirectory = options.schemaDir ?? "lunora";
+  const wranglerPath = findWranglerFile(options.projectRoot);
+  if (!wranglerPath) {
+    const message = `wrangler.jsonc not found in ${options.projectRoot}; create one declaring at least the SHARD durable object binding.`;
+    return {
+      problems: [message],
+      report: { errors: [message], valid: false, warnings: [] },
+      wranglerPath: void 0
+    };
+  }
+  const { parsed: wrangler } = readWranglerJsonc(wranglerPath);
+  if (wrangler === void 0) {
+    const message = `failed to parse ${wranglerPath} as JSONC.`;
+    return {
+      problems: [message],
+      report: { errors: [message], valid: false, warnings: [] },
+      wranglerPath
+    };
+  }
+  const { error: schemaError, info: schemaInfo } = discoverSchemaInfo(options.projectRoot, schemaDirectory);
+  const report = validateWranglerConfig(wrangler, schemaInfo);
+  if (schemaError !== void 0) {
+    report.warnings.push(`schema parse failed in ${schemaDirectory}/schema.ts: ${schemaError}`);
+  }
+  const configDirectory = dirname(wranglerPath);
+  report.errors.push(...collectContainerImageErrors(wrangler.containers ?? [], configDirectory, wranglerPath));
+  const assetsDirectory = wrangler.assets?.directory;
+  if (typeof assetsDirectory === "string" && assetsDirectory.length > 0) {
+    const resolved = assetsDirectory.startsWith("/") ? assetsDirectory : join(configDirectory, assetsDirectory);
+    if (!existsSync(resolved)) {
+      report.warnings.push(`assets.directory "${assetsDirectory}" does not exist yet — it is created by the client build; run the build before deploy`);
+    }
+  }
+  report.valid = report.errors.length === 0;
+  return {
+    problems: report.errors,
+    report,
+    wranglerPath
+  };
+};
+
+export { REQUIRED_COMPATIBILITY_DATE, REQUIRED_FLAG, validateWrangler, validateWranglerConfig, validateWranglerProject, withTailConsumer };

package/dist/packem_shared/SCHEMA_EDIT_ENDPOINT-Df-Wrix-.mjs

@@ -0,0 +1,99 @@
+import { existsSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { runCodegen, CodegenDiagnosticError } from '@lunora/codegen';
+import { classifyEdit, applyAdditiveEdit } from './applyAdditiveEdit-C-snTFEV.mjs';
+import { parseSchema } from './parseSchema-DSeyktvG.mjs';
+import { join } from 'node:path';
+
+const SCHEMA_EDIT_ENDPOINT = "/__lunora/schema-edit";
+const statusForFailure = (reason) => {
+  if (reason === "destructive") {
+    return 409;
+  }
+  if (reason === "duplicate-table" || reason === "duplicate-column" || reason === "duplicate-index") {
+    return 409;
+  }
+  if (reason === "unknown-table") {
+    return 404;
+  }
+  if (reason === "invalid-identifier" || reason === "invalid-validator") {
+    return 400;
+  }
+  return 422;
+};
+const parseFailureResponse = (result) => {
+  return {
+    body: { error: result.reason, ok: false },
+    status: 422
+  };
+};
+const readSchema = (schemaPath) => {
+  if (!existsSync(schemaPath)) {
+    return { response: { body: { error: "no-schema-file", ok: false }, status: 404 } };
+  }
+  const parsed = parseSchema(readFileSync(schemaPath, "utf8"));
+  if (!parsed.ok) {
+    return { response: parseFailureResponse(parsed) };
+  }
+  return { tables: parsed.tables };
+};
+const writeSchemaAtomic = (schemaPath, text) => {
+  const temporaryPath = `${schemaPath}.lunora-tmp`;
+  writeFileSync(temporaryPath, text, "utf8");
+  renameSync(temporaryPath, schemaPath);
+};
+const needsMigrationResponse = (edit) => {
+  return {
+    body: {
+      edit,
+      message: "This edit changes stored data and must go through a migration. Review the migration before applying.",
+      needsMigration: true,
+      ok: false
+    },
+    status: 409
+  };
+};
+const handlePost = (request, schemaPath) => {
+  const edit = request.body;
+  if (edit === void 0 || typeof edit !== "object" || typeof edit.kind !== "string") {
+    return { body: { error: "invalid-edit", ok: false }, status: 400 };
+  }
+  if (classifyEdit(edit) === "destructive") {
+    return needsMigrationResponse(edit);
+  }
+  if (!existsSync(schemaPath)) {
+    return { body: { error: "no-schema-file", ok: false }, status: 404 };
+  }
+  const applied = applyAdditiveEdit(readFileSync(schemaPath, "utf8"), edit);
+  if (!applied.ok) {
+    return { body: { error: applied.reason, ok: false }, status: statusForFailure(applied.reason) };
+  }
+  writeSchemaAtomic(schemaPath, applied.text);
+  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 };
+    }
+  }
+  const parsed = parseSchema(applied.text);
+  return {
+    body: { diagnostics, ok: true, tables: parsed.ok ? parsed.tables : [] },
+    status: 200
+  };
+};
+const handleSchemaEditRequest = (request) => {
+  const schemaPath = join(request.projectRoot, request.schemaDirectory ?? "lunora", "schema.ts");
+  if (request.method === "GET") {
+    const read = readSchema(schemaPath);
+    return "response" in read ? read.response : { body: { ok: true, tables: read.tables }, status: 200 };
+  }
+  if (request.method === "POST") {
+    return handlePost(request, schemaPath);
+  }
+  return { body: { error: "method-not-allowed", ok: false }, status: 405 };
+};
+
+export { SCHEMA_EDIT_ENDPOINT, handleSchemaEditRequest };

package/dist/packem_shared/SEED_ENDPOINT-DVCjaGO-.mjs

@@ -0,0 +1,61 @@
+import { existsSync } from 'node:fs';
+import { discoverSchema, schemaFromIr } from '@lunora/codegen';
+import { seedPlan } from '@lunora/seed';
+import { Project } from 'ts-morph';
+import { join } from 'node:path';
+
+const SEED_ENDPOINT = "/__lunora/seed";
+const MAX_SEED_ROWS = 1e3;
+const jsonReplacer = (_key, value) => {
+  if (typeof value === "bigint") {
+    return Number(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    return [...new Uint8Array(value)];
+  }
+  return value;
+};
+const clampCount = (count) => {
+  if (typeof count !== "number" || !Number.isFinite(count)) {
+    return 10;
+  }
+  return Math.min(Math.max(1, Math.floor(count)), MAX_SEED_ROWS);
+};
+const handleSeedRequest = (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") {
+    return { body: { error: "invalid-request", ok: false }, status: 400 };
+  }
+  const { count, existingIds, seed, table } = body;
+  if (typeof table !== "string" || table.length === 0) {
+    return { body: { error: "missing-table", ok: false }, status: 400 };
+  }
+  const lunoraDirectory = request.schemaDirectory ?? "lunora";
+  const schemaPath = join(request.projectRoot, lunoraDirectory, "schema.ts");
+  if (!existsSync(schemaPath)) {
+    return { body: { error: "schema-not-found", ok: false }, status: 404 };
+  }
+  const project = new Project({ skipAddingFilesFromTsConfig: true });
+  const ir = discoverSchema(project, schemaPath);
+  if (!ir.tables.some((candidate) => candidate.name === table)) {
+    return { body: { error: "unknown-table", ok: false, table }, status: 404 };
+  }
+  const schema = schemaFromIr(ir);
+  const plan = seedPlan(schema, {
+    // Pass every sampled parent table as `existingIds` so the generator links
+    // to live rows and never fabricates parents — matching the studio's
+    // "existing rows are not affected, FKs point at what's there" semantics.
+    existingIds: existingIds ?? {},
+    defaultCount: clampCount(count),
+    only: [table],
+    seed: seed ?? 0
+  });
+  const rows = plan.find((entry) => entry.table === table)?.rows ?? [];
+  const jsonSafeRows = JSON.parse(JSON.stringify(rows, jsonReplacer));
+  return { body: { ok: true, rows: jsonSafeRows }, status: 200 };
+};
+
+export { SEED_ENDPOINT, handleSeedRequest };

package/dist/packem_shared/WRANGLER_FILES-DwSuC-Kn.mjs

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { parse } from 'jsonc-parser';
+import { join } from 'node:path';
+
+const WRANGLER_FILES = ["wrangler.jsonc", "wrangler.json"];
+const findWranglerFile = (projectRoot) => {
+  for (const candidate of WRANGLER_FILES) {
+    const fullPath = join(projectRoot, candidate);
+    if (existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+  return void 0;
+};
+const readWranglerJsonc = (wranglerPath) => {
+  const text = readFileSync(wranglerPath, "utf8");
+  const parseErrors = [];
+  const value = parse(text, parseErrors, { allowTrailingComma: true });
+  if (parseErrors.length > 0 || value === null || typeof value !== "object") {
+    return { parsed: void 0, text };
+  }
+  return { parsed: value, text };
+};
+
+export { WRANGLER_FILES, findWranglerFile, readWranglerJsonc };