@lunora/cli 1.0.0-alpha.1 → 1.0.0-alpha.100

package/dist/packem_shared/{DEFAULT_IMPORT_BATCH_SIZE-Ck-2bU08.mjs → DEFAULT_IMPORT_BATCH_SIZE-D0VOTerB.mjs}

@@ -1,5 +1,6 @@
 import { createWriteStream, createReadStream } from 'node:fs';
 import { unlink, stat } from 'node:fs/promises';
+import { LunoraError } from '@lunora/errors';
 import { r as resolveAdminBaseUrl } from './admin-url-4UzT-CI4.mjs';
 
 const EXPORT_ENDPOINT_PATH = "/_lunora/admin/export";
@@ -129,6 +130,10 @@ const resolveImportRequest = async (options) => {
     options.logger.error("--prod requires an explicit --url (refusing to import to the implicit localhost worker)");
     return void 0;
   }
+  if (options.prod && options.yes !== true) {
+    options.logger.error("import --prod bulk-writes production. Re-run with --yes to confirm.");
+    return void 0;
+  }
   const token = options.token ?? process.env["LUNORA_ADMIN_TOKEN"];
   if (!token) {
     options.logger.error("admin token required — pass --token or set LUNORA_ADMIN_TOKEN");
@@ -183,7 +188,7 @@ const runImportCommand = async (options) => {
     });
     if (!response.ok) {
       const text = await response.text().catch(() => "<no body>");
-      throw new Error(`import batch failed (HTTP ${String(response.status)}): ${text}`);
+      throw new LunoraError("INTERNAL", `import batch failed (HTTP ${String(response.status)}): ${text}`);
     }
     const json = await response.json();
     if (json.inserted) {
@@ -213,7 +218,7 @@ const runImportCommand = async (options) => {
       parsedDocument = JSON.parse(trimmed);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`invalid JSON on line ${String(lineNumber)}: ${message}`, { cause: error });
+      throw new LunoraError("INTERNAL", `invalid JSON on line ${String(lineNumber)}: ${message}`, { cause: error });
     }
     batch.push(JSON.stringify({ doc: parsedDocument, table: options.table }));
   };

package/dist/packem_shared/{api-spec-CtA6ilu4.mjs → api-spec-Bx0iKbxA.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const API_SPEC_VALUES = ["both", "none", "openapi", "openrpc"];
 const API_SPEC_HELP = API_SPEC_VALUES.join(" | ");
 const parseApiSpec = (value) => {
@@ -7,7 +9,7 @@ const parseApiSpec = (value) => {
   if (API_SPEC_VALUES.includes(value)) {
     return value;
   }
-  throw new Error(`invalid --api-spec "${value}" — expected one of: ${API_SPEC_HELP}`);
+  throw new LunoraError("INTERNAL", `invalid --api-spec "${value}" — expected one of: ${API_SPEC_HELP}`);
 };
 
 export { API_SPEC_HELP as A, parseApiSpec as p };

package/dist/packem_shared/{buildRegistryIndex-BcYe607_.mjs → buildRegistryIndex-BS5ig822.mjs}

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from '@visulima/path';
-import parseManifest from './parseManifest--vZf2FY1.mjs';
+import parseManifest from './parseManifest-Dbp-Q2q3.mjs';
 
 const CONTROL_CHARS = /[\u0000-\u001F\u007F-\u009F]/gu;
 const stripControlChars = (value) => value === void 0 ? void 0 : value.replaceAll(CONTROL_CHARS, "");

package/dist/packem_shared/codegen-error-DJG-ghs_.mjs

@@ -0,0 +1,31 @@
+import { findLunoraSolution } from '@lunora/codegen';
+import { VisulimaError, renderError } from '@visulima/error';
+
+const flattenSolutionBody = (solution) => solution.body.split("\n").filter((line) => !line.startsWith("```")).join("\n").replaceAll(/\*\*(.+?)\*\*/gu, "$1").replaceAll(/`([^`]+)`/gu, "$1");
+const NO_STACK = { filterStacktrace: () => false, hideErrorCodeView: true };
+const renderCodegenFailure = (error, reason) => {
+  const message = error instanceof Error ? error.message : String(error);
+  const solution = findLunoraSolution(message);
+  const rendered = new VisulimaError({
+    hint: solution ? [solution.header, "", flattenSolutionBody(solution)] : void 0,
+    message: reason === void 0 ? `codegen failed: ${message}` : `codegen failed (${reason}): ${message}`,
+    name: "CodegenError"
+  });
+  rendered.stack = "";
+  return renderError(rendered, NO_STACK);
+};
+const renderCodegenHint = (message) => {
+  const solution = findLunoraSolution(message);
+  if (solution === void 0) {
+    return void 0;
+  }
+  const rendered = new VisulimaError({
+    hint: [flattenSolutionBody(solution)],
+    message: solution.header,
+    name: "Hint"
+  });
+  rendered.stack = "";
+  return renderError(rendered, NO_STACK);
+};
+
+export { renderCodegenHint as a, renderCodegenFailure as r };

package/dist/packem_shared/{command-BDXcJCCJ.mjs → command-lYnl4QyF.mjs}

@@ -1,4 +1,5 @@
-import { createLogger } from './createLogger-CHPNjFw2.mjs';
+import { createLogger } from './createLogger-CIWSHrTL.mjs';
+import { P as PromptCancelledError, a as PROMPT_CANCEL_EXIT_CODE } from './prompt-cancelled-APzX1Im-.mjs';
 
 const defineHandler = (body) => async (toolbox) => {
   const logger = createLogger();
@@ -6,6 +7,10 @@ const defineHandler = (body) => async (toolbox) => {
     const { code } = await body({ argument: toolbox.argument, cwd: toolbox.process.cwd, logger, options: toolbox.options });
     toolbox.process.exit(code);
   } catch (error) {
+    if (error instanceof PromptCancelledError) {
+      toolbox.process.exit(PROMPT_CANCEL_EXIT_CODE);
+      return;
+    }
     logger.error(error instanceof Error ? error.message : String(error));
     toolbox.process.exit(1);
   }

package/dist/packem_shared/{runAddCommand-BZGkRnBs.mjs → commands-D5Yxt9VY.mjs}

@@ -1,15 +1,169 @@
 import { existsSync, readFileSync, writeFileSync, mkdirSync, mkdtempSync, rmSync } from 'node:fs';
-import { join, dirname } from '@visulima/path';
-import { DEV_VARS_FILE, parseDevVariableEntries, promptYesNo } from '@lunora/config';
+import { dirname, join, relative } from '@visulima/path';
+import { DEV_VARS_FILE, parseDevVariableEntries, findWranglerFile, readWranglerJsonc } from '@lunora/config';
 import { modify, applyEdits, parse } from 'jsonc-parser';
-import { collectCatalog, buildRegistryIndex } from './buildRegistryIndex-BcYe607_.mjs';
-import { insertSchemaExtension } from './insertSchemaExtension-BuzF6-t2.mjs';
+import { fileURLToPath } from 'node:url';
+import { LunoraError } from '@lunora/errors';
+import { b as tuiConfirm } from './tui-prompts-BjEN8XgP.mjs';
+import { collectCatalog, buildRegistryIndex } from './buildRegistryIndex-BS5ig822.mjs';
+import { insertSchemaExtension } from './insertSchemaExtension-DAqbfr9Z.mjs';
 import { createHash } from 'node:crypto';
 import { tmpdir } from 'node:os';
 import { downloadTemplate } from 'giget';
-import parseManifest from './parseManifest--vZf2FY1.mjs';
+import parseManifest from './parseManifest-Dbp-Q2q3.mjs';
 
-const applyDeps = (deps, projectRoot, logger, section = "dependencies") => {
+const DEFAULT_SOURCE_REF_FALLBACK = "alpha";
+const STABLE_BRANCH = "main";
+const PRERELEASE_CHANNEL_BRANCHES = /* @__PURE__ */ new Set(["alpha", "beta", "next"]);
+const SAFE_REF = /^[\w./@-]+$/;
+const isSafeRef = (ref) => !ref.includes("..") && SAFE_REF.test(ref);
+const resolveCliVersion = () => {
+  try {
+    let directory = dirname(fileURLToPath(import.meta.url));
+    for (let index = 0; index < 6; index += 1) {
+      const candidate = join(directory, "package.json");
+      if (existsSync(candidate)) {
+        const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+        if (parsed.name === "@lunora/cli" && typeof parsed.version === "string") {
+          return parsed.version;
+        }
+      }
+      const parent = dirname(directory);
+      if (parent === directory) {
+        break;
+      }
+      directory = parent;
+    }
+  } catch {
+  }
+  return "0.0.0";
+};
+const resolveVersionRef = (version) => {
+  if (version === "0.0.0") {
+    return DEFAULT_SOURCE_REF_FALLBACK;
+  }
+  const core = version.split("+")[0] ?? version;
+  const dashIndex = core.indexOf("-");
+  if (dashIndex !== -1) {
+    const [channel] = core.slice(dashIndex + 1).split(".");
+    if (channel !== void 0 && PRERELEASE_CHANNEL_BRANCHES.has(channel)) {
+      return channel;
+    }
+  }
+  return STABLE_BRANCH;
+};
+const resolveSourceRef = (ref) => {
+  if (ref !== void 0 && ref.length > 0) {
+    if (!isSafeRef(ref)) {
+      throw new LunoraError("INTERNAL", `invalid --ref "${ref}" — a ref may contain letters, digits, ".", "_", "-", "/", "@" and must not contain "..".`);
+    }
+    return ref;
+  }
+  return resolveVersionRef(resolveCliVersion());
+};
+const SOURCE_REPO = "anolilab/lunora";
+const COMMIT_SHA = /^[0-9a-f]{40}$/iu;
+const SEMVER_BODY = String.raw`\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)+)?(?:\+[0-9A-Za-z.-]+)?`;
+const LEADING_VERSION_TAG = new RegExp(String.raw`^v?${SEMVER_BODY}$`, "u");
+const PACKAGE_VERSION_TAG = new RegExp(String.raw`^(?:@[\w.-]+\/)?[\w.-]+@${SEMVER_BODY}$`, "u");
+const isImmutableRef = (ref) => COMMIT_SHA.test(ref) || LEADING_VERSION_TAG.test(ref) || PACKAGE_VERSION_TAG.test(ref);
+const githubAuthHeaders = () => {
+  const token = process.env["GITHUB_TOKEN"] ?? process.env["GH_TOKEN"];
+  return token !== void 0 && token.length > 0 ? { authorization: `Bearer ${token}` } : {};
+};
+const fetchBranchSha = async (branch) => {
+  try {
+    const response = await fetch(`https://api.github.com/repos/${SOURCE_REPO}/commits/${encodeURIComponent(branch)}`, {
+      headers: { accept: "application/vnd.github+json", "user-agent": "lunora-cli", ...githubAuthHeaders() },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const body = await response.json();
+    return typeof body.sha === "string" && COMMIT_SHA.test(body.sha) ? body.sha : void 0;
+  } catch {
+    return void 0;
+  }
+};
+const resolvePinnedSourceRef = async (ref, logger) => {
+  const resolved = resolveSourceRef(ref);
+  if (isImmutableRef(resolved)) {
+    return resolved;
+  }
+  const sha = await fetchBranchSha(resolved);
+  if (sha === void 0) {
+    logger.warn(`could not pin ${SOURCE_REPO}#${resolved} to a commit — fetching the UNPINNED branch (set GITHUB_TOKEN if rate-limited).`);
+    return resolved;
+  }
+  logger.info(`pinned ${SOURCE_REPO}#${resolved} → ${sha}`);
+  return sha;
+};
+const STABLE_DIST_TAG = "latest";
+const resolveDistTag = (version = resolveCliVersion()) => {
+  const ref = resolveVersionRef(version);
+  return ref === STABLE_BRANCH ? STABLE_DIST_TAG : ref;
+};
+const DEFAULT_REGISTRY = "https://registry.npmjs.org";
+const registryBase = () => {
+  const configured = process.env["npm_config_registry"];
+  const base = configured !== void 0 && configured.length > 0 ? configured : DEFAULT_REGISTRY;
+  return base.endsWith("/") ? base.slice(0, -1) : base;
+};
+const resolveTagVersion = async (packageName, tag) => {
+  try {
+    const response = await fetch(`${registryBase()}/${packageName.replaceAll("/", "%2F")}`, {
+      headers: { accept: "application/vnd.npm.install-v1+json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      return void 0;
+    }
+    const packument = await response.json();
+    return packument["dist-tags"]?.[tag];
+  } catch {
+    return void 0;
+  }
+};
+const resolveTagVersions = async (names, tag) => {
+  const resolved = /* @__PURE__ */ new Map();
+  await Promise.all(
+    [...new Set(names)].map(async (name) => {
+      const version = await resolveTagVersion(name, tag);
+      if (version !== void 0) {
+        resolved.set(name, version);
+      }
+    })
+  );
+  return resolved;
+};
+
+const resolveDepRange = (range) => {
+  if (!range.startsWith("workspace:")) {
+    return range;
+  }
+  const rest = range.slice("workspace:".length);
+  if (rest === "" || rest === "*" || rest === "^" || rest === "~") {
+    return resolveDistTag();
+  }
+  return rest;
+};
+const UMBRELLA_REEXPORTED_DEPS = /* @__PURE__ */ new Set(["@lunora/client", "@lunora/do", "@lunora/ratelimit", "@lunora/runtime", "@lunora/server", "@lunora/values"]);
+const UMBRELLA_IMPORT_RE = /(['"])@lunora\/(client|do|ratelimit|runtime|server|values)(\/[^'"]*)?\1/gu;
+const projectUsesUmbrella = (projectRoot) => {
+  const packageJsonPath = join(projectRoot, "package.json");
+  if (!existsSync(packageJsonPath)) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    return parsed.dependencies?.lunorash !== void 0 || parsed.devDependencies?.lunorash !== void 0;
+  } catch {
+    return false;
+  }
+};
+const rewriteUmbrellaImports = (source) => source.replaceAll(UMBRELLA_IMPORT_RE, (_match, quote, base, subpath) => `${quote}lunorash/${base}${subpath ?? ""}${quote}`);
+const applyDeps = (deps, projectRoot, logger, section = "dependencies", useUmbrella = false) => {
   const entries = Object.entries(deps);
   if (entries.length === 0) {
     return [];
@@ -23,11 +177,15 @@ const applyDeps = (deps, projectRoot, logger, section = "dependencies") => {
   const parsed = JSON.parse(text);
   const added = [];
   for (const [name, range] of entries) {
+    if (useUmbrella && UMBRELLA_REEXPORTED_DEPS.has(name)) {
+      logger.info(`dep provided by the lunorash umbrella, skipping: ${name}`);
+      continue;
+    }
     if (parsed.dependencies?.[name] !== void 0 || parsed.devDependencies?.[name] !== void 0) {
       logger.info(`dep already present: ${name}`);
       continue;
     }
-    const edits = modify(text, [section, name], range, {
+    const edits = modify(text, [section, name], resolveDepRange(range), {
       formattingOptions: { insertSpaces: true, tabSize: 4 }
     });
     text = applyEdits(text, edits);
@@ -148,14 +306,14 @@ const applyBindings = (bindings, projectRoot, logger) => {
   }
   return applied;
 };
-const applyItemResources = (manifest, cwd, logger) => {
+const applyItemResources = (manifest, cwd, logger, useUmbrella = false) => {
   const deps = [];
   const bindings = [];
   if (manifest.deps) {
-    deps.push(...applyDeps(manifest.deps, cwd, logger));
+    deps.push(...applyDeps(manifest.deps, cwd, logger, "dependencies", useUmbrella));
   }
   if (manifest.devDependencies) {
-    deps.push(...applyDeps(manifest.devDependencies, cwd, logger, "devDependencies"));
+    deps.push(...applyDeps(manifest.devDependencies, cwd, logger, "devDependencies", useUmbrella));
   }
   if (manifest.bindings) {
     bindings.push(...applyBindings(manifest.bindings, cwd, logger));
@@ -187,8 +345,8 @@ const confirmDepMutation = async (items, options) => {
     options.logger.error(`add: stdin is not a TTY and the requested items ${reasonText} — re-run with --yes to confirm`);
     return false;
   }
-  const confirmer = options.confirm ?? promptYesNo;
-  const confirmed = await confirmer(`The requested items ${reasonText}. Continue? [y/N] `);
+  const confirmer = options.confirm ?? tuiConfirm;
+  const confirmed = await confirmer(`The requested items ${reasonText}. Continue?`);
   if (!confirmed) {
     options.logger.info("add: aborted");
   }
@@ -267,7 +425,12 @@ const renderDiff = (oldText, newText) => {
   return out;
 };
 
-const reconcileSchemaExtension = (file, itemKey, itemDirectory, projectRoot, logger, diff) => {
+const CODE_FILE_RE = /\.[cm]?[jt]sx?$/u;
+const readItemFile = (itemDirectory, file, useUmbrella) => {
+  const source = readFileSync(join(itemDirectory, file.from), "utf8");
+  return useUmbrella && CODE_FILE_RE.test(file.to) ? rewriteUmbrellaImports(source) : source;
+};
+const reconcileSchemaExtension = (file, itemKey, itemDirectory, projectRoot, logger, diff, useUmbrella) => {
   const schemaPath = join(projectRoot, "lunora", "schema.ts");
   if (diff) {
     logger.info(`~ would merge .extend(${itemKey}.extension) into lunora/schema.ts (and create ${file.to} if absent)`);
@@ -276,9 +439,13 @@ const reconcileSchemaExtension = (file, itemKey, itemDirectory, projectRoot, log
   const destinationPath = join(projectRoot, file.to);
   if (!existsSync(destinationPath)) {
     mkdirSync(dirname(destinationPath), { recursive: true });
-    writeFileSync(destinationPath, readFileSync(join(itemDirectory, file.from), "utf8"), "utf8");
+    writeFileSync(destinationPath, readItemFile(itemDirectory, file, useUmbrella), "utf8");
   }
-  const existingSchema = existsSync(schemaPath) ? readFileSync(schemaPath, "utf8") : 'import { defineSchema } from "@lunora/server";\n\nexport const schema = defineSchema({});\n';
+  const baseModule = useUmbrella ? "lunorash/server" : "@lunora/server";
+  const existingSchema = existsSync(schemaPath) ? readFileSync(schemaPath, "utf8") : `import { defineSchema } from "${baseModule}";
+
+export const schema = defineSchema({});
+`;
   const result = insertSchemaExtension(existingSchema, itemKey);
   if (result.ok) {
     mkdirSync(dirname(schemaPath), { recursive: true });
@@ -291,11 +458,12 @@ const reconcileSchemaExtension = (file, itemKey, itemDirectory, projectRoot, log
     return { kind: "skipped", path: schemaPath };
   }
   if (result.reason === "invalid-identifier") {
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `schema-extension item "${itemKey}" is not a valid JS identifier — it is spliced into lunora/schema.ts as \`import { ${itemKey} }\` / \`.extend(${itemKey}.extension)\`. Rename the item to a valid identifier (no leading digit, no "-").`
     );
   }
-  throw new Error(`schema-extension merge failed for "${itemKey}": ${result.reason}`);
+  throw new LunoraError("INTERNAL", `schema-extension merge failed for "${itemKey}": ${result.reason}`);
 };
 const previewWholeFile = (file, current, incoming, exists, logger) => {
   const lines = renderDiff(current, incoming);
@@ -308,9 +476,9 @@ const previewWholeFile = (file, current, incoming, exists, logger) => {
     logger.info(`    ${line}`);
   }
 };
-const reconcileWholeFile = (file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions) => {
+const reconcileWholeFile = (file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions, useUmbrella) => {
   const destinationPath = join(projectRoot, file.to);
-  const incoming = readFileSync(join(itemDirectory, file.from), "utf8");
+  const incoming = readItemFile(itemDirectory, file, useUmbrella);
   const exists = existsSync(destinationPath);
   const current = exists ? readFileSync(destinationPath, "utf8") : "";
   const write = (message) => {
@@ -348,11 +516,95 @@ const reconcileWholeFile = (file, itemKey, itemDirectory, projectRoot, logger, l
   logger.warn(`conflict: ${file.to} has local edits and an upstream update — wrote ${file.to}.new (use --overwrite to take theirs)`);
   return { kind: "skipped", path: destinationPath };
 };
-const reconcileFile = (file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions = {}) => {
+const reconcileFile = (file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions = {}, useUmbrella = false) => {
   if (file.merge === "schema-extension") {
-    return reconcileSchemaExtension(file, itemKey, itemDirectory, projectRoot, logger, reconcileOptions.diff === true);
+    return reconcileSchemaExtension(file, itemKey, itemDirectory, projectRoot, logger, reconcileOptions.diff === true, useUmbrella);
   }
-  return reconcileWholeFile(file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions);
+  return reconcileWholeFile(file, itemKey, itemDirectory, projectRoot, logger, lock, reconcileOptions, useUmbrella);
+};
+const WORKER_ENTRY_FALLBACKS = ["src/server.ts", "src/server/index.ts", "src/server/index.tsx", "src/index.ts", "src/worker.ts"];
+const readWranglerMain = (projectRoot) => {
+  const wranglerPath = findWranglerFile(projectRoot);
+  if (wranglerPath === void 0) {
+    return void 0;
+  }
+  const { parsed } = readWranglerJsonc(wranglerPath);
+  return typeof parsed?.main === "string" ? parsed.main : void 0;
+};
+const findWorkerEntry = (projectRoot) => {
+  const main = readWranglerMain(projectRoot);
+  const candidates = main === void 0 ? WORKER_ENTRY_FALLBACKS : [main, ...WORKER_ENTRY_FALLBACKS];
+  for (const candidate of candidates) {
+    const absolute = join(projectRoot, candidate);
+    if (!existsSync(absolute)) {
+      continue;
+    }
+    const content = readFileSync(absolute, "utf8");
+    if (!content.includes("createShardDO(")) {
+      if (candidate === main) {
+        break;
+      }
+      continue;
+    }
+    return { entryPath: absolute, main: candidate, source: content };
+  }
+  return void 0;
+};
+const computeRelativeSpecifier = (entryPath, projectRoot, moduleName) => {
+  const importPath = relative(dirname(entryPath), join(projectRoot, "lunora", moduleName)).replaceAll("\\", "/");
+  return importPath.startsWith(".") ? importPath : `./${importPath}`;
+};
+const logClassAFallback = (entrypointReexports, logger) => {
+  for (const reexport of entrypointReexports) {
+    const specifier = `./lunora/${reexport.module}.js`;
+    const instruction = `Add \`export * from "${specifier}"\` to your worker entry`;
+    const suffix = reexport.comment ? ` (${reexport.comment})` : "";
+    logger.warn(`${instruction}${suffix}`);
+  }
+  return 0;
+};
+const buildReexportLines = (entrypointReexports, entryPath, projectRoot, source) => {
+  const lines = [];
+  for (const reexport of entrypointReexports) {
+    const specifier = computeRelativeSpecifier(entryPath, projectRoot, reexport.module);
+    const escapedSpecifier = specifier.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+    const existingRe = new RegExp(String.raw`export\s+\*\s+from\s+["']${escapedSpecifier}\.js["']`, "u");
+    if (existingRe.test(source)) {
+      continue;
+    }
+    if (reexport.comment) {
+      lines.push(`
+// ${reexport.comment}`);
+    }
+    lines.push(`export * from "${specifier}.js";`);
+  }
+  return lines;
+};
+const applyEntrypointReexports = (entrypointReexports, projectRoot, logger, diff) => {
+  if (entrypointReexports.length === 0) {
+    return 0;
+  }
+  const entry = findWorkerEntry(projectRoot);
+  if (entry === void 0) {
+    return logClassAFallback(entrypointReexports, logger);
+  }
+  const linesToAppend = buildReexportLines(entrypointReexports, entry.entryPath, projectRoot, entry.source);
+  if (linesToAppend.length === 0) {
+    return 0;
+  }
+  if (diff) {
+    for (const line of linesToAppend) {
+      if (line !== "") {
+        logger.info(`~ entrypoint: ${line}`);
+      }
+    }
+    return linesToAppend.length;
+  }
+  const separator = entry.source.endsWith("\n") ? "" : "\n";
+  writeFileSync(entry.entryPath, `${entry.source}${separator}${linesToAppend.join("\n")}
+`, "utf8");
+  logger.success(`wrote ${String(linesToAppend.length)} entrypoint re-export(s) to ${relative(projectRoot, entry.entryPath)}`);
+  return linesToAppend.length;
 };
 const reconcileItems = (items, cwd, logger, reconcileOptions = {}) => {
   const written = [];
@@ -360,15 +612,19 @@ const reconcileItems = (items, cwd, logger, reconcileOptions = {}) => {
   const depsAdded = [];
   const bindingsApplied = [];
   const lock = readLock(cwd);
+  const useUmbrella = projectUsesUmbrella(cwd);
   for (const { directory, manifest } of items) {
     for (const file of manifest.files) {
-      const outcome = reconcileFile(file, manifest.name, directory, cwd, logger, lock, reconcileOptions);
+      const outcome = reconcileFile(file, manifest.name, directory, cwd, logger, lock, reconcileOptions, useUmbrella);
       (outcome.kind === "written" ? written : skipped).push(outcome.path);
     }
+    if (manifest.entrypointReexports !== void 0) {
+      applyEntrypointReexports(manifest.entrypointReexports, cwd, logger, reconcileOptions.diff === true);
+    }
     if (reconcileOptions.diff) {
       continue;
     }
-    const applied = applyItemResources(manifest, cwd, logger);
+    const applied = applyItemResources(manifest, cwd, logger, useUmbrella);
     depsAdded.push(...applied.deps);
     bindingsApplied.push(...applied.bindings);
   }
@@ -379,11 +635,11 @@ const reconcileItems = (items, cwd, logger, reconcileOptions = {}) => {
 };
 
 const DEFAULT_SOURCE_BASE = "gh:anolilab/lunora/registry";
-const DEFAULT_SOURCE_REF = "alpha";
 const VALID_ITEM_NAME = /^[A-Za-z0-9][\w-]*$/u;
 const assertSafeItemName = (name) => {
   if (!VALID_ITEM_NAME.test(name)) {
-    throw new Error(
+    throw new LunoraError(
+      "INTERNAL",
       `invalid registry item name "${name}" — names must match ${VALID_ITEM_NAME.source} (letters, digits, "-", "_"; no path separators or "..")`
     );
   }
@@ -420,29 +676,39 @@ const fetchToStaging = async (remote, label, logger) => {
     throw error;
   }
 };
+const remoteRefCache = /* @__PURE__ */ new WeakMap();
+const resolveRemoteRef = async (options) => {
+  const cached = remoteRefCache.get(options);
+  if (cached !== void 0) {
+    return cached;
+  }
+  const pending = options.source !== void 0 && options.source.length > 0 ? Promise.resolve(resolveSourceRef(options.ref)) : resolvePinnedSourceRef(options.ref, options.logger);
+  remoteRefCache.set(options, pending);
+  return pending;
+};
 const resolveItemDirectory = async (name, options) => {
   assertSafeItemName(name);
   if (options.from !== void 0) {
     const directory = join(options.from, name);
     if (!existsSync(directory)) {
-      throw new Error(`registry item not found in local source: ${directory}`);
+      throw new LunoraError("INTERNAL", `registry item not found in local source: ${directory}`);
     }
     return { cleanup: () => {
     }, directory };
   }
   const base = options.source ?? DEFAULT_SOURCE_BASE;
-  return fetchToStaging(`${base}/${name}#${DEFAULT_SOURCE_REF}`, "item", options.logger);
+  return fetchToStaging(`${base}/${name}#${await resolveRemoteRef(options)}`, "item", options.logger);
 };
 const resolveRegistryRoot = async (options) => {
   if (options.from !== void 0) {
     if (!existsSync(options.from)) {
-      throw new Error(`registry root not found: ${options.from}`);
+      throw new LunoraError("INTERNAL", `registry root not found: ${options.from}`);
     }
     return { cleanup: () => {
     }, root: options.from };
   }
   const base = options.source ?? DEFAULT_SOURCE_BASE;
-  const { cleanup, directory } = await fetchToStaging(`${base}#${DEFAULT_SOURCE_REF}`, "registry", options.logger);
+  const { cleanup, directory } = await fetchToStaging(`${base}#${await resolveRemoteRef(options)}`, "registry", options.logger);
   return { cleanup, root: directory };
 };
 const readManifest = (itemDirectory, name) => {
@@ -459,7 +725,7 @@ const resolvePlan = async (names, options) => {
       return;
     }
     if (inProgress.has(name)) {
-      throw new Error(`cyclic registry dependency detected at "${name}"`);
+      throw new LunoraError("INTERNAL", `cyclic registry dependency detected at "${name}"`);
     }
     inProgress.add(name);
     const { cleanup, directory } = await resolveItemDirectory(name, options);
@@ -488,6 +754,26 @@ const resolvePlan = async (names, options) => {
 const emptyResult = () => {
   return { bindings: [], code: 0, deps: [], skipped: [], written: [] };
 };
+const setBindingField = (manifest, section, match, field, fieldValue) => {
+  if (!manifest.bindings) {
+    return manifest;
+  }
+  return {
+    ...manifest,
+    bindings: manifest.bindings.map((binding) => {
+      if (binding.path[0] !== section || !Array.isArray(binding.value)) {
+        return binding;
+      }
+      const entries = binding.value;
+      return {
+        ...binding,
+        value: entries.map(
+          (entry) => typeof entry === "object" && entry !== null && entry[match.key] === match.value ? { ...entry, [field]: fieldValue } : entry
+        )
+      };
+    })
+  };
+};
 
 const printPlan = (logger, manifest) => {
   const label = manifest.title ?? manifest.description;
@@ -508,6 +794,11 @@ const printPlan = (logger, manifest) => {
     const valueSuffix = variable.secret ? " (secret)" : ` = ${JSON.stringify(variable.value ?? "")}`;
     logger.info(`  env   ${variable.name}${valueSuffix}`);
   }
+  for (const reexport of manifest.entrypointReexports ?? []) {
+    const specifier = `./lunora/${reexport.module}`;
+    const suffix = reexport.comment ? `  // ${reexport.comment}` : "";
+    logger.info(`  entry ${specifier}${suffix}`);
+  }
 };
 const printJsonPlan = (items) => {
   const planSnapshot = items.map(({ manifest }) => {
@@ -519,6 +810,9 @@ const printJsonPlan = (items) => {
       }),
       deps: Object.keys(manifest.deps ?? {}),
       devDependencies: Object.keys(manifest.devDependencies ?? {}),
+      entrypointReexports: (manifest.entrypointReexports ?? []).map((reexport) => {
+        return { module: reexport.module, ...reexport.comment ? { comment: reexport.comment } : {} };
+      }),
       envVars: (manifest.envVars ?? []).map((variable) => {
         return { name: variable.name, ...variable.secret ? { secret: true } : { value: variable.value ?? "" } };
       }),
@@ -593,8 +887,12 @@ const runAddCommand = async (options) => {
   }
   let cleanups = [];
   try {
-    const { cleanups: planCleanups, items } = await resolvePlan(options.names, options);
+    const { cleanups: planCleanups, items: resolvedItems } = await resolvePlan(options.names, options);
     cleanups = planCleanups;
+    const { transformManifest } = options;
+    const items = transformManifest ? resolvedItems.map((item) => {
+      return { ...item, manifest: transformManifest(item.manifest) };
+    }) : resolvedItems;
     for (const { manifest } of items) {
       printPlan(options.logger, manifest);
     }
@@ -690,4 +988,4 @@ const runBuildIndexCommand = async (options) => {
   return empty;
 };
 
-export { runAddCommand, runBuildIndexCommand, runListCommand, runRegistryViewCommand };
+export { runBuildIndexCommand as a, runRegistryViewCommand as b, resolveTagVersions as c, resolveSourceRef as d, resolvePinnedSourceRef as e, resolveDistTag as f, runListCommand as g, runAddCommand as r, setBindingField as s };