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

package/dist/packem_shared/discoverWorkflowInfo-CedvR0mn.mjs

@@ -1,19 +0,0 @@
-import { existsSync } from 'node:fs';
-import { WORKFLOWS_FILENAME, discoverWorkflows } from '@lunora/codegen';
-import { Project } from 'ts-morph';
-import { join } from 'node:path';
-
-const discoverWorkflowInfo = (projectRoot, schemaDirectory) => {
-  const workflowsPath = join(projectRoot, schemaDirectory, WORKFLOWS_FILENAME);
-  if (!existsSync(workflowsPath)) {
-    return { workflows: [] };
-  }
-  try {
-    const project = new Project({ skipAddingFilesFromTsConfig: true, useInMemoryFileSystem: false });
-    return { workflows: discoverWorkflows(project, join(projectRoot, schemaDirectory)) };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : String(error), workflows: [] };
-  }
-};
-
-export { discoverWorkflowInfo };

package/dist/packem_shared/inferLunoraBindings-BcvvtpSG.mjs

@@ -1,397 +0,0 @@
-import { existsSync, statSync, readFileSync, readdirSync } from 'node:fs';
-import { init, parse } from 'es-module-lexer';
-import { discoverAgentInfo } from './discoverAgentInfo-eXA3hF4v.mjs';
-import { discoverContainerInfo } from './discoverContainerInfo-BXFs6Wav.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"]);
-const DEFAULT_SCAN_DIRECTORIES = ["lunora", "src"];
-const WORKER_ENTRY_FALLBACKS = ["src/server/index.ts", "src/server/index.tsx", "src/index.ts", "src/worker.ts"];
-const DURABLE_OBJECT_BINDINGS = {
-  SchedulerDO: "SCHEDULER",
-  SessionDO: "SESSION",
-  ShardDO: "SHARD"
-};
-const DURABLE_OBJECT_CLASSES = Object.keys(DURABLE_OBJECT_BINDINGS);
-const TYPE_ONLY_EXPORT_PATTERNS = {
-  SchedulerDO: /\btype\s+SchedulerDO\b/,
-  SessionDO: /\btype\s+SessionDO\b/,
-  ShardDO: /\btype\s+ShardDO\b/
-};
-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 SANDBOX_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["@lunora/agent", "@lunora/agent/sandbox"]);
-const extractImportSpecifierList = (statementText) => {
-  const openBraceIndex = statementText.indexOf("{");
-  if (openBraceIndex === -1) {
-    return "";
-  }
-  const closeBraceIndex = statementText.indexOf("}", openBraceIndex + 1);
-  return closeBraceIndex === -1 ? statementText.slice(openBraceIndex + 1) : statementText.slice(openBraceIndex + 1, closeBraceIndex);
-};
-const TYPE_BROWSER_TOOL_SPECIFIER_PATTERN = /\btype\s+browserTool\b/;
-const BROWSER_TOOL_NAME_PATTERN = /\bbrowserTool\b/;
-const SANDBOX_BROWSER_TOOL_FALLBACK_PATTERN = /import\s+\{[^}]*\bbrowserTool\b[^}]*\}\s+from\s+["']@lunora\/agent(?:\/sandbox)?["']/;
-const isValueBrowserToolImport = (statementText) => {
-  if (TYPE_ONLY_IMPORT_PATTERN.test(statementText)) {
-    return false;
-  }
-  const specifierList = extractImportSpecifierList(statementText);
-  return BROWSER_TOOL_NAME_PATTERN.test(specifierList) && !TYPE_BROWSER_TOOL_SPECIFIER_PATTERN.test(specifierList);
-};
-const hasSandboxBrowserToolImport = (code) => {
-  try {
-    const [imports] = parse(code);
-    return imports.some(
-      (entry) => entry.n !== void 0 && SANDBOX_MODULE_SPECIFIERS.has(entry.n) && isValueBrowserToolImport(code.slice(entry.ss, entry.se))
-    );
-  } catch {
-    return SANDBOX_BROWSER_TOOL_FALLBACK_PATTERN.test(code);
-  }
-};
-const CAPABILITY_SOURCES = {
-  usesAi: { pattern: /\bfrom\s+["']@lunora\/ai["']/, source: "@lunora/ai" },
-  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\/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" },
-  // 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" },
-  // x402 rails are opt-in add-on subpaths (not part of the `lunorash` umbrella),
-  // so they key off the exact `@lunora/x402/{charge,pay}` specifiers. Neither
-  // implies a `.dev.vars` secret: the charge recipient is a user-named `[vars]`
-  // entry and the pay wallet key is a Secrets Store binding — both hint-only.
-  usesX402Charge: { pattern: /\bfrom\s+["']@lunora\/x402\/charge["']/, source: "@lunora/x402/charge" },
-  usesX402Pay: { pattern: /\bfrom\s+["']@lunora\/x402\/pay["']/, source: "@lunora/x402/pay" }
-};
-const CAPABILITY_FLAGS = Object.keys(CAPABILITY_SOURCES);
-const PAYMENT_PROVIDER_SECRETS = "STRIPE_SECRET_KEY + STRIPE_WEBHOOK_SECRET (Stripe) or POLAR_ACCESS_TOKEN + POLAR_WEBHOOK_SECRET (Polar)";
-const ALL_CAPABILITY_KEYS = [...CAPABILITY_FLAGS, "needsD1"];
-const emptyCapabilities = () => {
-  const base = {};
-  for (const key of ALL_CAPABILITY_KEYS) {
-    base[key] = false;
-  }
-  return base;
-};
-const NO_CAPABILITIES = Object.freeze(emptyCapabilities());
-const mergeCapabilities = (a, b) => {
-  const merged = {};
-  for (const key of ALL_CAPABILITY_KEYS) {
-    merged[key] = a[key] || b[key];
-  }
-  return merged;
-};
-const capabilityForImportSource = (source) => {
-  for (const flag of CAPABILITY_FLAGS) {
-    if (CAPABILITY_SOURCES[flag].source === source) {
-      return { ...NO_CAPABILITIES, [flag]: true };
-    }
-  }
-  return NO_CAPABILITIES;
-};
-const lexCapabilities = (code) => {
-  const [imports] = parse(code);
-  let capabilities = NO_CAPABILITIES;
-  for (const entry of imports) {
-    const source = entry.n;
-    if (!source || TYPE_ONLY_IMPORT_PATTERN.test(code.slice(entry.ss, entry.se))) {
-      continue;
-    }
-    capabilities = mergeCapabilities(capabilities, capabilityForImportSource(source));
-  }
-  return capabilities;
-};
-const regexCapabilities = (code) => {
-  const capabilities = { ...NO_CAPABILITIES };
-  for (const flag of CAPABILITY_FLAGS) {
-    capabilities[flag] = CAPABILITY_SOURCES[flag].pattern.test(code);
-  }
-  return capabilities;
-};
-const capabilitiesFromSource = (code) => {
-  let capabilities;
-  try {
-    capabilities = lexCapabilities(code);
-  } catch {
-    capabilities = regexCapabilities(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;
-  try {
-    entries = readdirSync(directory, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (!IGNORED_DIRECTORIES.has(entry.name)) {
-        collectSourceFiles(join(directory, entry.name), accumulator);
-      }
-      continue;
-    }
-    const dotIndex = entry.name.lastIndexOf(".");
-    if (dotIndex !== -1 && SOURCE_EXTENSIONS.has(entry.name.slice(dotIndex))) {
-      accumulator.push(join(directory, entry.name));
-    }
-  }
-};
-const resolveWorkerEntry = (projectRoot) => {
-  for (const candidate of WRANGLER_FILES) {
-    const wranglerPath = join(projectRoot, candidate);
-    if (!existsSync(wranglerPath)) {
-      continue;
-    }
-    const { parsed } = readWranglerJsonc(wranglerPath);
-    const main = parsed?.main;
-    if (typeof main === "string" && existsSync(join(projectRoot, main))) {
-      return join(projectRoot, main);
-    }
-    break;
-  }
-  for (const fallback of WORKER_ENTRY_FALLBACKS) {
-    const fullPath = join(projectRoot, fallback);
-    if (existsSync(fullPath)) {
-      return fullPath;
-    }
-  }
-  return void 0;
-};
-const detectExportedDurableObjects = (entryPath) => {
-  const code = readFileSync(entryPath, "utf8");
-  let exportedNames;
-  try {
-    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)));
-  }
-  return DURABLE_OBJECT_CLASSES.filter((className) => exportedNames.has(className) && !TYPE_ONLY_EXPORT_PATTERNS[className].test(code)).map((className) => {
-    return {
-      binding: DURABLE_OBJECT_BINDINGS[className],
-      className
-    };
-  });
-};
-const isTypeOnlyClassExport = (code, className) => (
-  // `export type Foo` / `export type { … Foo … }` / `export { type Foo }` — all
-  // three type-only forms list the name via the lexer but compile away.
-  new RegExp(String.raw`\bexport\s+type\s+${className}\b`).test(code) || new RegExp(String.raw`\bexport\s+type\s*\{[^}]*\b${className}\b`).test(code) || new RegExp(String.raw`\bexport\s+\{[^}]*\btype\s+${className}\b`).test(code)
-);
-const detectClassExports = (entryPath, definitions, generatedModule) => {
-  if (definitions.length === 0) {
-    return [];
-  }
-  if (entryPath === void 0) {
-    return definitions.map((definition) => {
-      return { ...definition, exported: false };
-    });
-  }
-  const code = readFileSync(entryPath, "utf8");
-  const starReexport = new RegExp(String.raw`\bexport\s*\*\s*from\s*["'][^"']*_generated\/${generatedModule}(?:\.js)?["']`).test(code);
-  let exportedNames;
-  try {
-    const [, exports] = parse(code);
-    exportedNames = new Set(exports.map((entry) => entry.n));
-  } catch {
-    exportedNames = new Set(
-      definitions.map((definition) => definition.className).filter((className) => new RegExp(String.raw`\bexport\b[^\n;]*\b${className}\b`).test(code))
-    );
-  }
-  return definitions.map((definition) => {
-    const exported = starReexport || exportedNames.has(definition.className) && !isTypeOnlyClassExport(code, definition.className);
-    return { ...definition, exported };
-  });
-};
-const detectContainerExports = (entryPath, containers) => detectClassExports(entryPath, containers, "containers");
-const detectWorkflowExports = (entryPath, workflows) => detectClassExports(entryPath, workflows, "workflows");
-const detectAgentExports = (entryPath, agents) => detectClassExports(entryPath, agents, "agents");
-const schemaNeedsD1 = (projectRoot, schemaDirectory) => discoverSchemaInfo(projectRoot, schemaDirectory).info?.hasGlobalTable ?? false;
-const scanCapabilities = (projectRoot, scanDirectories) => {
-  let merged = NO_CAPABILITIES;
-  for (const relativeDirectory of scanDirectories) {
-    const absolute = join(projectRoot, relativeDirectory);
-    if (!existsSync(absolute) || !statSync(absolute).isDirectory()) {
-      continue;
-    }
-    const files = [];
-    collectSourceFiles(absolute, files);
-    for (const file of files) {
-      merged = mergeCapabilities(merged, capabilitiesFromSource(readFileSync(file, "utf8")));
-    }
-  }
-  return merged;
-};
-const scanSandboxBrowserToolUsage = (projectRoot, lunoraDirectory) => {
-  const absolute = join(projectRoot, lunoraDirectory);
-  if (!existsSync(absolute) || !statSync(absolute).isDirectory()) {
-    return false;
-  }
-  const files = [];
-  collectSourceFiles(absolute, files);
-  return files.some((file) => hasSandboxBrowserToolImport(readFileSync(file, "utf8")));
-};
-const describeDeclaredExports = (containers, workflows, agents) => [
-  ...containers.map(
-    (container) => container.exported ? `${container.bindingName}/${container.className} (container "${container.exportName}" declared and exported)` : `hint: container "${container.exportName}" is declared but ${container.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/containers"\``
-  ),
-  ...workflows.map(
-    (workflow) => workflow.exported ? `${workflow.bindingName}/${workflow.className} (workflow "${workflow.exportName}" declared and exported)` : `hint: workflow "${workflow.exportName}" is declared but ${workflow.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/workflows"\``
-  ),
-  ...agents.map(
-    (agent) => agent.exported ? `${agent.bindingName}/${agent.className} (agent "${agent.exportName}" declared and exported)` : `hint: agent "${agent.exportName}" is declared but ${agent.className} is not exported by the worker entry — add \`export * from "./lunora/_generated/agents"\``
-  )
-];
-const describeCapabilitySignals = (capabilities, exported) => {
-  const rules = [
-    [capabilities.usesAi, "AI (@lunora/ai imported or env.AI used)"],
-    [
-      capabilities.usesAuth && !exported.has("SessionDO"),
-      "hint: @lunora/auth is imported but no SessionDO is exported (sessions are D1-backed, or export SessionDO for DO-backed sessions)"
-    ],
-    [capabilities.usesScheduler && !exported.has("SchedulerDO"), "hint: @lunora/scheduler is imported but no SchedulerDO is exported by the worker entry"],
-    [capabilities.usesStorage, "hint: @lunora/storage is imported; add an r2_buckets binding (bucket binding names are user-defined)"],
-    [capabilities.usesMail, "hint: @lunora/mail is imported; set RESEND_API_KEY in .dev.vars (obtain at https://resend.com/api-keys)"],
-    [capabilities.usesPayment, `hint: @lunora/payment is imported; set the provider secrets in .dev.vars — ${PAYMENT_PROVIDER_SECRETS}`],
-    // 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/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/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,
-      "hint: @lunora/hyperdrive is imported; run 'wrangler hyperdrive create' and add a 'hyperdrive' binding ({ binding, id }) — the id can't be auto-provisioned"
-    ],
-    [
-      capabilities.usesPipelines,
-      "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"
-    ],
-    [
-      capabilities.usesX402Charge,
-      "hint: @lunora/x402/charge is imported; set the recipient wallet address as a [vars] entry (the var name is yours to choose) and pass it to the charge config — the x402 facilitator settles USDC to that address"
-    ],
-    [
-      capabilities.usesX402Pay,
-      "hint: @lunora/x402/pay is imported (ActionCtx-only, spends real funds); add a secrets_store_secrets[] binding for the agent wallet key (name it to match signer.secretName) and pair the pay rail with a spend policy — ctx.secrets reads a Secrets Store binding, not .dev.vars, so the key can't be auto-provisioned"
-    ]
-  ];
-  return rules.filter(([active]) => active).map(([, signal]) => signal);
-};
-const describeSignals = (durableObjects, needsD1, capabilities, containers = [], workflows = [], agents = []) => {
-  const exported = new Set(durableObjects.map((object) => object.className));
-  const signals = durableObjects.map((object) => `${object.binding}/${object.className} (exported by worker entry)`);
-  if (needsD1) {
-    signals.push("DB (.global() table declared)");
-  }
-  signals.push(...describeDeclaredExports(containers, workflows, agents), ...describeCapabilitySignals(capabilities, exported));
-  return signals;
-};
-const inferLunoraBindings = async (options) => {
-  await init;
-  const schemaDirectory = options.schemaDir ?? "lunora";
-  const scanDirectories = options.scanDirs ?? DEFAULT_SCAN_DIRECTORIES;
-  const scannedCapabilities = scanCapabilities(options.projectRoot, scanDirectories);
-  const capabilities = {
-    ...scannedCapabilities,
-    usesBrowser: scannedCapabilities.usesBrowser || scanSandboxBrowserToolUsage(options.projectRoot, schemaDirectory)
-  };
-  const entryPath = resolveWorkerEntry(options.projectRoot);
-  const durableObjects = entryPath ? detectExportedDurableObjects(entryPath) : [];
-  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 agents = detectAgentExports(entryPath, discoverAgentInfo(options.projectRoot, schemaDirectory).agents);
-  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, agents);
-  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 {
-    agents,
-    containers,
-    durableObjects,
-    flagshipBinding,
-    needsD1,
-    queues,
-    signals,
-    usesFlags: flags !== void 0,
-    workflows,
-    ...capabilityFlags
-  };
-};
-const packageNamesFromBindings = (bindings) => {
-  const names = [];
-  for (const flag of CAPABILITY_FLAGS) {
-    if (bindings[flag]) {
-      names.push(CAPABILITY_SOURCES[flag].source);
-    }
-  }
-  return names;
-};
-
-export { inferLunoraBindings, packageNamesFromBindings };

package/dist/packem_shared/jsonc-edit-SbcD7MAe.mjs

@@ -1,9 +0,0 @@
-import { modify, applyEdits } from 'jsonc-parser';
-
-const FORMATTING = { formattingOptions: { insertSpaces: true, tabSize: 4 } };
-const applyModify = (text, path, value) => {
-  const edits = modify(text, [...path], value, FORMATTING);
-  return edits.length > 0 ? applyEdits(text, edits) : text;
-};
-
-export { FORMATTING as F, applyModify as a };

package/dist/packem_shared/parseDevVariable-B0FEvfHC.mjs

@@ -1,21 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { parseDevVariableEntries } from './DEV_VARS_EXAMPLE_FILE-dJPNTEnK.mjs';
-
-const parseDevVariable = (contents, key) => {
-  const entry = parseDevVariableEntries(contents).find((candidate) => candidate.key === key);
-  return entry === void 0 || entry.value === "" ? void 0 : entry.value;
-};
-const resolveAdminToken = (root) => {
-  const fromEnv = process.env["LUNORA_ADMIN_TOKEN"];
-  if (typeof fromEnv === "string" && fromEnv !== "") {
-    return fromEnv;
-  }
-  try {
-    return parseDevVariable(readFileSync(join(root, ".dev.vars"), "utf8"), "LUNORA_ADMIN_TOKEN");
-  } catch {
-    return void 0;
-  }
-};
-
-export { parseDevVariable, resolveAdminToken };

package/dist/packem_shared/parseSchema-DSeyktvG.mjs

@@ -1,107 +0,0 @@
-import { Project, SyntaxKind } from 'ts-morph';
-
-const OPTIONAL_VALIDATOR_PATTERN = /^v\s*\.\s*optional\s*\(/u;
-const SHARD_BY_PATTERN = /\.shardBy\(\s*["']([^"']+)["']\s*\)/u;
-const GLOBAL_PATTERN = /\.global\(\s*\)/u;
-const QUOTE_PATTERN = /["']/gu;
-const collectCalls = (node) => {
-  const calls = node.getDescendantsOfKind(SyntaxKind.CallExpression);
-  if (node.getKind() === SyntaxKind.CallExpression) {
-    calls.push(node.asKindOrThrow(SyntaxKind.CallExpression));
-  }
-  return calls;
-};
-const isOptionalValidator = (validatorText) => OPTIONAL_VALIDATOR_PATTERN.test(validatorText.trim());
-const readStringArray = (node) => {
-  if (node?.getKind() !== SyntaxKind.ArrayLiteralExpression) {
-    return [];
-  }
-  return node.asKindOrThrow(SyntaxKind.ArrayLiteralExpression).getElements().filter((element) => element.getKind() === SyntaxKind.StringLiteral).map((element) => element.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText());
-};
-const readUnique = (node) => {
-  if (node?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-    return false;
-  }
-  const property = node.asKindOrThrow(SyntaxKind.ObjectLiteralExpression).getProperty("unique");
-  return property?.getKind() === SyntaxKind.PropertyAssignment && property.getInitializer()?.getText() === "true";
-};
-const parseIndexCall = (call) => {
-  const expression = call.getExpression();
-  if (expression.getKind() !== SyntaxKind.PropertyAccessExpression || expression.asKindOrThrow(SyntaxKind.PropertyAccessExpression).getName() !== "index") {
-    return void 0;
-  }
-  const [nameArgument, fieldsArgument, optionsArgument] = call.getArguments();
-  if (nameArgument?.getKind() !== SyntaxKind.StringLiteral) {
-    return void 0;
-  }
-  return {
-    fields: readStringArray(fieldsArgument),
-    name: nameArgument.asKindOrThrow(SyntaxKind.StringLiteral).getLiteralText(),
-    unique: readUnique(optionsArgument)
-  };
-};
-const parseIndexes = (initializer) => {
-  const initializerNode = initializer.getInitializer();
-  if (initializerNode === void 0) {
-    return [];
-  }
-  const indexes = [];
-  for (const call of collectCalls(initializerNode)) {
-    const index = parseIndexCall(call);
-    if (index !== void 0) {
-      indexes.push(index);
-    }
-  }
-  return indexes;
-};
-const parseColumns = (initializer) => {
-  const columns = [];
-  const defineTableCall = initializer.getInitializer()?.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "defineTable");
-  const tableShape = defineTableCall?.getArguments()[0];
-  if (tableShape?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-    return columns;
-  }
-  for (const property of tableShape.getProperties()) {
-    if (property.getKind() !== SyntaxKind.PropertyAssignment) {
-      continue;
-    }
-    const assignment = property;
-    const name = assignment.getName().replaceAll(QUOTE_PATTERN, "");
-    const validator = assignment.getInitializer()?.getText() ?? "";
-    columns.push({ name, optional: isOptionalValidator(validator), validator });
-  }
-  return columns;
-};
-const parseSchema = (source) => {
-  const project = new Project({ compilerOptions: { allowJs: true }, useInMemoryFileSystem: true });
-  const sourceFile = project.createSourceFile("schema.ts", source, { overwrite: true });
-  const defineSchemaCall = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).find((call) => call.getExpression().getText() === "defineSchema");
-  if (defineSchemaCall === void 0) {
-    const aliased = sourceFile.getImportDeclarations().some((declaration) => declaration.getNamedImports().some((named) => named.getName() === "defineSchema" && named.getAliasNode() !== void 0));
-    return { ok: false, reason: aliased ? "aliased-define-schema" : "no-define-schema" };
-  }
-  const tablesArgument = defineSchemaCall.getArguments()[0];
-  if (tablesArgument?.getKind() !== SyntaxKind.ObjectLiteralExpression) {
-    return { ok: false, reason: "non-object-argument" };
-  }
-  const tables = [];
-  for (const property of tablesArgument.getProperties()) {
-    if (property.getKind() !== SyntaxKind.PropertyAssignment) {
-      continue;
-    }
-    const assignment = property;
-    const name = assignment.getName().replaceAll(QUOTE_PATTERN, "");
-    const initializerText = assignment.getInitializer()?.getText() ?? "";
-    const shardMatch = SHARD_BY_PATTERN.exec(initializerText);
-    tables.push({
-      columns: parseColumns(assignment),
-      global: GLOBAL_PATTERN.test(initializerText),
-      indexes: parseIndexes(assignment),
-      name,
-      ...shardMatch?.[1] === void 0 ? {} : { shardBy: shardMatch[1] }
-    });
-  }
-  return { ok: true, tables };
-};
-
-export { collectCalls, parseSchema };