@holo-js/cli 0.1.2 → 0.1.4

package/dist/chunk-S7P7EBM3.mjs

@@ -0,0 +1,787 @@
+import {
+  loadGeneratedProjectRegistry,
+  writeGeneratedProjectRegistry
+} from "./chunk-H7TJ4FB3.mjs";
+import {
+  COMMAND_FILE_PATTERN,
+  MIGRATION_NAME_PATTERN,
+  hasEventDefinitionMarker,
+  hasListenerDefinitionMarker,
+  importProjectModule,
+  isRecord,
+  loadAuthorizationDiscoveryModule,
+  loadBroadcastDiscoveryModule,
+  loadEventsDiscoveryModule,
+  loadQueueDiscoveryModule,
+  makeProjectRelativePath,
+  pathExists,
+  readTextFile,
+  toPosixPath
+} from "./chunk-G5ADO27Q.mjs";
+
+// src/project/discovery.ts
+import { readdir } from "fs/promises";
+import { basename, dirname, extname, join, relative, resolve } from "path";
+import { loadConfigDirectory } from "@holo-js/config";
+import {
+  normalizeHoloProjectConfig
+} from "@holo-js/db";
+async function collectFiles(root) {
+  if (!await pathExists(root)) {
+    return [];
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const target = join(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await collectFiles(target));
+      continue;
+    }
+    if (entry.isFile() && COMMAND_FILE_PATTERN.test(entry.name)) {
+      files.push(target);
+    }
+  }
+  return files;
+}
+function deriveCommandNameFromPath(commandsRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(commandsRoot, sourcePath));
+  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(":");
+}
+function deriveJobNameFromPath(jobsRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(jobsRoot, sourcePath));
+  return relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").filter(Boolean).join(".");
+}
+function deriveEventNameFromPath(eventsRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(eventsRoot, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
+  if (!derived) {
+    throw new Error("[Holo Events] Derived event names require a non-empty source path.");
+  }
+  return derived;
+}
+function deriveListenerIdFromPath(listenersRoot, sourcePath) {
+  const relativePath = toPosixPath(relative(listenersRoot, sourcePath));
+  const derived = relativePath.replace(COMMAND_FILE_PATTERN, "").split("/").map((part) => part.trim()).filter(Boolean).join(".");
+  if (!derived) {
+    throw new Error("[Holo Events] Derived listener identifiers require a non-empty source path.");
+  }
+  return derived;
+}
+function deriveBroadcastNameFromPath(root, sourcePath) {
+  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
+  if (!derived) {
+    throw new Error("[Holo Broadcast] Derived broadcast names require a non-empty source path.");
+  }
+  return derived;
+}
+function deriveChannelPatternFromPath(root, sourcePath) {
+  const relativePath = toPosixPath(relative(root, sourcePath)).replace(COMMAND_FILE_PATTERN, "");
+  const derived = relativePath.split("/").map((part) => part.trim()).filter(Boolean).join(".");
+  if (!derived) {
+    throw new Error("[Holo Broadcast] Derived channel patterns require a non-empty source path.");
+  }
+  return derived;
+}
+function resolveDiscoveredJobMetadata(job, sourcePath, derivedName, queueConfig) {
+  const connection = job.connection ?? queueConfig.default;
+  let queue = job.queue;
+  if (!queue) {
+    const configuredConnection = queueConfig.connections[connection];
+    queue = configuredConnection ? configuredConnection.queue : "default";
+  }
+  return {
+    sourcePath,
+    name: derivedName,
+    connection,
+    queue,
+    ...typeof job.tries === "number" ? { tries: job.tries } : {},
+    ...typeof job.backoff !== "undefined" ? { backoff: job.backoff } : {},
+    ...typeof job.timeout === "number" ? { timeout: job.timeout } : {}
+  };
+}
+function isAppCommand(value) {
+  return isRecord(value) && typeof value.description === "string" && typeof value.run === "function";
+}
+function resolveCommandExport(moduleValue) {
+  if (isRecord(moduleValue) && isAppCommand(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isRecord(moduleValue)) {
+    for (const value of Object.values(moduleValue)) {
+      if (isAppCommand(value)) {
+        return value;
+      }
+    }
+  }
+  return void 0;
+}
+function normalizeCommandAliases(value) {
+  if (!value) {
+    return void 0;
+  }
+  const normalized = [...new Set(value.map((alias) => alias.trim()).filter(Boolean))];
+  return normalized.length > 0 ? normalized : void 0;
+}
+function assertUniqueEntries(kind, entries) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const existing = seen.get(entry.name);
+    if (existing) {
+      throw new Error(`Discovered duplicate ${kind} "${entry.name}" in "${existing}" and "${entry.sourcePath}".`);
+    }
+    seen.set(entry.name, entry.sourcePath);
+  }
+}
+function assertUniqueCommandTokens(entries) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    for (const token of [entry.name, ...entry.aliases]) {
+      const existing = seen.get(token);
+      if (existing) {
+        throw new Error(`Discovered duplicate command token "${token}" in "${existing}" and "${entry.sourcePath}".`);
+      }
+      seen.set(token, entry.sourcePath);
+    }
+  }
+}
+function resolveRegisteredPath(projectRoot, entry) {
+  return resolve(projectRoot, entry);
+}
+function resolveNamedExport(moduleValue, matcher) {
+  if (!isRecord(moduleValue)) return void 0;
+  if (matcher(moduleValue.default)) return moduleValue.default;
+  for (const value of Object.values(moduleValue)) {
+    if (matcher(value)) return value;
+  }
+  return void 0;
+}
+function resolveNamedExportEntry(moduleValue, matcher) {
+  if (!isRecord(moduleValue)) return void 0;
+  if (matcher(moduleValue.default)) {
+    return { exportName: "default", value: moduleValue.default };
+  }
+  for (const [exportName, value] of Object.entries(moduleValue)) {
+    if (matcher(value)) return { exportName, value };
+  }
+  return void 0;
+}
+function isCliModelReference(value) {
+  return isRecord(value) && isRecord(value.definition) && value.definition.kind === "model" && typeof value.definition.name === "string" && typeof value.prune === "function";
+}
+function isMissingGeneratedSchemaModelError(error) {
+  return error instanceof Error && error.message.includes("is not present in the generated schema registry");
+}
+function isInactiveGeneratedModelModule(value) {
+  return isRecord(value) && value.holoModelPendingSchema === true;
+}
+function isMigrationDefinition(value) {
+  return isRecord(value) && typeof value.up === "function";
+}
+function isSeederDefinition(value) {
+  return isRecord(value) && typeof value.name === "string" && typeof value.run === "function";
+}
+function resolveListenerEventNamesForDiscovery(listener, eventNamesByReference = /* @__PURE__ */ new Map()) {
+  return Object.freeze([...new Set(listener.listensTo.map((reference) => {
+    if (typeof reference === "string") {
+      return reference.trim();
+    }
+    if (typeof reference.name === "string" && reference.name.trim()) {
+      return reference.name.trim();
+    }
+    if (eventNamesByReference.has(reference)) {
+      return eventNamesByReference.get(reference);
+    }
+    throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+  }))]);
+}
+function resolveAuthorizationTargetName(target) {
+  const modelFacadeTarget = target;
+  if (typeof modelFacadeTarget.definition?.name === "string" && modelFacadeTarget.definition.name.trim()) {
+    return modelFacadeTarget.definition.name.trim();
+  }
+  const namedTarget = target;
+  return typeof namedTarget.name === "string" && namedTarget.name.trim() ? namedTarget.name.trim() : void 0;
+}
+function captureAuthorizationDefinitionNames(definitions) {
+  return new Set(definitions.keys());
+}
+function findAddedAuthorizationDefinitionNames(definitions, existingNames) {
+  return [...definitions.keys()].filter((name) => !existingNames.has(name));
+}
+function unregisterAuthorizationDefinitionNames(authorizationDiscovery, policyNames, abilityNames) {
+  if (typeof authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition !== "function" || typeof authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition !== "function") {
+    authorizationDiscovery.authorizationInternals.resetAuthorizationRuntimeState?.();
+    return;
+  }
+  for (const policyName of policyNames) {
+    authorizationDiscovery.authorizationInternals.unregisterPolicyDefinition(policyName);
+  }
+  for (const abilityName of abilityNames) {
+    authorizationDiscovery.authorizationInternals.unregisterAbilityDefinition(abilityName);
+  }
+}
+function collectImportedBindingsBySource(sourceText) {
+  const bindings = /* @__PURE__ */ new Map();
+  const importPattern = /import\s+([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
+  for (const match of sourceText.matchAll(importPattern)) {
+    const clause = match[1]?.trim();
+    const source = match[2]?.trim();
+    if (!clause || !source) {
+      continue;
+    }
+    const namedMatch = clause.match(/\{([\s\S]+)\}/);
+    const defaultClause = clause.replace(/\{[\s\S]+\}/, "").replace(/,$/, "").trim();
+    if (defaultClause && defaultClause !== "*") {
+      bindings.set(defaultClause, source);
+    }
+    if (namedMatch?.[1]) {
+      for (const specifier of namedMatch[1].split(",")) {
+        const trimmed = specifier.trim();
+        if (!trimmed) {
+          continue;
+        }
+        const [imported, local] = trimmed.split(/\s+as\s+/);
+        const bindingName = (local ?? imported)?.trim();
+        if (bindingName) {
+          bindings.set(bindingName, source);
+        }
+      }
+    }
+  }
+  return bindings;
+}
+function extractListensToItems(sourceText) {
+  const markerIndex = sourceText.indexOf("listensTo");
+  if (markerIndex < 0) {
+    return [];
+  }
+  const colonIndex = sourceText.indexOf(":", markerIndex);
+  if (colonIndex < 0) {
+    return [];
+  }
+  let cursor = colonIndex + 1;
+  while (cursor < sourceText.length && /\s/.test(sourceText[cursor])) {
+    cursor += 1;
+  }
+  const startChar = sourceText[cursor];
+  let depth = 0;
+  let inString;
+  let expression = "";
+  for (; cursor < sourceText.length; cursor += 1) {
+    const char = sourceText[cursor];
+    expression += char;
+    if (inString) {
+      if (char === inString && sourceText[cursor - 1] !== "\\") {
+        inString = void 0;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      inString = char;
+      continue;
+    }
+    if (char === "[" || char === "{" || char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === "]" || char === "}" || char === ")") {
+      depth -= 1;
+      if (depth === 0 && startChar === "[") {
+        break;
+      }
+      continue;
+    }
+    if (depth === 0 && startChar !== "[" && (char === "," || char === "\n" || char === "\r")) {
+      expression = expression.slice(0, -1);
+      break;
+    }
+  }
+  if (startChar !== "[") {
+    const item = expression.trim().replace(/\s+as\s+const$/, "");
+    return item ? [item] : [];
+  }
+  return expression.slice(1, -1).split(",").map((item) => item.trim().replace(/\s+as\s+const$/, "")).filter(Boolean);
+}
+async function resolveListenerEventNamesFromSource(projectRoot, listenerPath, discoveredEventNamesBySourcePath) {
+  const sourceText = await readTextFile(listenerPath) ?? "";
+  const bindingsByName = collectImportedBindingsBySource(sourceText);
+  const discoveredEventNamesByExtensionlessSourcePath = new Map(
+    [...discoveredEventNamesBySourcePath.entries()].map(([sourcePath, eventName]) => {
+      return [sourcePath.replace(/\.[^.]+$/, ""), eventName];
+    })
+  );
+  const resolvedEventNames = [];
+  for (const item of extractListensToItems(sourceText)) {
+    const quoted = item.match(/^['"](.+)['"]$/);
+    if (quoted) {
+      resolvedEventNames.push(quoted[1].trim());
+      continue;
+    }
+    const importSource = bindingsByName.get(item);
+    if (!importSource) {
+      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+    }
+    const importedPath = makeProjectRelativePath(projectRoot, resolve(dirname(listenerPath), importSource));
+    const eventName = discoveredEventNamesBySourcePath.get(importedPath) ?? discoveredEventNamesByExtensionlessSourcePath.get(importedPath.replace(/\.[^.]+$/, ""));
+    if (!eventName) {
+      throw new Error("[Holo Events] Listener event references must resolve to explicit event names before discovery registration.");
+    }
+    resolvedEventNames.push(eventName);
+  }
+  return Object.freeze([...new Set(resolvedEventNames)]);
+}
+function resolveBroadcastArtifactsPath(config, key) {
+  const configuredPaths = config.paths;
+  return configuredPaths[key] ?? `server/${key}`;
+}
+async function prepareProjectDiscovery(projectRoot, config = normalizeHoloProjectConfig()) {
+  const loadedConfig = await loadConfigDirectory(projectRoot, {
+    processEnv: process.env
+  });
+  const modelsRoot = resolve(projectRoot, config.paths.models);
+  const migrationsRoot = resolve(projectRoot, config.paths.migrations);
+  const seedersRoot = resolve(projectRoot, config.paths.seeders);
+  const commandsRoot = resolve(projectRoot, config.paths.commands);
+  const jobsRoot = resolve(projectRoot, config.paths.jobs);
+  const eventsRoot = resolve(projectRoot, config.paths.events);
+  const listenersRoot = resolve(projectRoot, config.paths.listeners);
+  const broadcastPath = resolveBroadcastArtifactsPath(config, "broadcast");
+  const channelsPath = resolveBroadcastArtifactsPath(config, "channels");
+  const broadcastRoot = resolve(projectRoot, broadcastPath);
+  const channelsRoot = resolve(projectRoot, channelsPath);
+  const policiesRoot = resolve(projectRoot, config.paths.authorizationPolicies ?? "server/policies");
+  const abilitiesRoot = resolve(projectRoot, config.paths.authorizationAbilities ?? "server/abilities");
+  const [modelFiles, migrationFiles, seederFiles, commandFiles, jobFiles, eventFiles, listenerFiles, broadcastFiles, channelFiles] = await Promise.all([
+    collectFiles(modelsRoot),
+    collectFiles(migrationsRoot),
+    collectFiles(seedersRoot),
+    collectFiles(commandsRoot),
+    collectFiles(jobsRoot),
+    collectFiles(eventsRoot),
+    collectFiles(listenersRoot),
+    collectFiles(broadcastRoot),
+    collectFiles(channelsRoot)
+  ]);
+  const [policyFiles, abilityFiles] = await Promise.all([
+    collectFiles(policiesRoot),
+    collectFiles(abilitiesRoot)
+  ]);
+  const models = [];
+  for (const filePath of modelFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    try {
+      const moduleValue = await importProjectModule(projectRoot, filePath);
+      const model = resolveNamedExport(moduleValue, isCliModelReference);
+      if (!model) {
+        if (isInactiveGeneratedModelModule(moduleValue)) {
+          continue;
+        }
+        throw new Error(`Discovered model "${relativePath}" does not export a Holo model.`);
+      }
+      models.push({
+        sourcePath: relativePath,
+        name: model.definition.name,
+        prunable: Boolean(model.definition.prunable)
+      });
+    } catch (error) {
+      if (!isMissingGeneratedSchemaModelError(error)) {
+        throw error;
+      }
+    }
+  }
+  assertUniqueEntries("model", models);
+  const migrations = [];
+  for (const filePath of migrationFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const moduleValue = await importProjectModule(projectRoot, filePath);
+    const migration = resolveNamedExport(moduleValue, isMigrationDefinition);
+    if (!migration) {
+      throw new Error(`Discovered migration "${relativePath}" does not export a Holo migration.`);
+    }
+    migrations.push({
+      sourcePath: relativePath,
+      name: migration.name ? validateMigrationName(migration.name) : inferMigrationNameFromEntry(relativePath)
+    });
+  }
+  assertUniqueEntries("migration", migrations);
+  const seeders = [];
+  for (const filePath of seederFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const moduleValue = await importProjectModule(projectRoot, filePath);
+    const seeder = resolveNamedExport(moduleValue, isSeederDefinition);
+    if (!seeder) {
+      throw new Error(`Discovered seeder "${relativePath}" does not export a Holo seeder.`);
+    }
+    seeders.push({
+      sourcePath: relativePath,
+      name: seeder.name
+    });
+  }
+  assertUniqueEntries("seeder", seeders);
+  const commands = [];
+  for (const filePath of commandFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const moduleValue = await importProjectModule(projectRoot, filePath);
+    const command = resolveCommandExport(moduleValue);
+    if (!command) {
+      throw new Error(`Discovered command "${relativePath}" does not export a Holo command.`);
+    }
+    const aliases = normalizeCommandAliases(command.aliases) ?? [];
+    commands.push({
+      sourcePath: relativePath,
+      name: command.name?.trim() || deriveCommandNameFromPath(commandsRoot, filePath),
+      aliases,
+      description: command.description,
+      ...command.usage ? { usage: command.usage } : {}
+    });
+  }
+  assertUniqueEntries("command", commands);
+  assertUniqueCommandTokens(commands);
+  const jobs = [];
+  const queueDiscovery = jobFiles.length > 0 ? await loadQueueDiscoveryModule(projectRoot) : void 0;
+  for (const filePath of jobFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const moduleValue = await importProjectModule(projectRoot, filePath);
+    const exportedJob = resolveNamedExportEntry(
+      moduleValue,
+      (value) => queueDiscovery.isQueueJobDefinition(value)
+    );
+    if (!exportedJob) {
+      throw new Error(`Discovered job "${relativePath}" does not export a Holo job.`);
+    }
+    const normalizedJob = queueDiscovery.normalizeQueueJobDefinition(exportedJob.value);
+    jobs.push({
+      ...resolveDiscoveredJobMetadata(
+        normalizedJob,
+        relativePath,
+        deriveJobNameFromPath(jobsRoot, filePath),
+        loadedConfig.queue
+      ),
+      exportName: exportedJob.exportName
+    });
+  }
+  assertUniqueEntries("job", jobs);
+  const events = [];
+  const eventsDiscovery = eventFiles.length > 0 || listenerFiles.length > 0 ? await loadEventsDiscoveryModule(projectRoot) : void 0;
+  const eventNamesByReference = /* @__PURE__ */ new Map();
+  const discoveredEventNamesBySourcePath = /* @__PURE__ */ new Map();
+  for (const filePath of eventFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const exportedEvent = resolveNamedExportEntry(
+      await importProjectModule(projectRoot, filePath),
+      (value) => hasEventDefinitionMarker(value)
+    );
+    if (!exportedEvent || !eventsDiscovery.isEventDefinition(exportedEvent.value)) {
+      throw new Error(`Discovered event "${relativePath}" does not export a Holo event.`);
+    }
+    const normalizedEvent = eventsDiscovery.normalizeEventDefinition(exportedEvent.value);
+    const name = normalizedEvent.name?.trim() || deriveEventNameFromPath(eventsRoot, filePath);
+    eventNamesByReference.set(exportedEvent.value, name);
+    discoveredEventNamesBySourcePath.set(relativePath, name);
+    events.push({
+      sourcePath: relativePath,
+      name,
+      exportName: exportedEvent.exportName
+    });
+  }
+  assertUniqueEntries("event", events);
+  const discoveredEventNames = new Set(events.map((entry) => entry.name));
+  const listeners = [];
+  for (const filePath of listenerFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const exportedListener = resolveNamedExportEntry(
+      await importProjectModule(projectRoot, filePath),
+      (value) => hasListenerDefinitionMarker(value)
+    );
+    if (!exportedListener || !eventsDiscovery.isListenerDefinition(exportedListener.value)) {
+      throw new Error(`Discovered listener "${relativePath}" does not export a Holo listener.`);
+    }
+    let eventNames;
+    try {
+      eventNames = resolveListenerEventNamesForDiscovery(
+        exportedListener.value,
+        eventNamesByReference
+      );
+    } catch (error) {
+      if (!(error instanceof Error) || error.message !== "[Holo Events] Listener event references must resolve to explicit event names before discovery registration.") {
+        throw error;
+      }
+      eventNames = await resolveListenerEventNamesFromSource(projectRoot, filePath, discoveredEventNamesBySourcePath);
+    }
+    const normalizedListener = eventsDiscovery.normalizeListenerDefinition(exportedListener.value);
+    const listenerId = normalizedListener.name?.trim() || deriveListenerIdFromPath(listenersRoot, filePath);
+    for (const eventName of eventNames) {
+      if (!discoveredEventNames.has(eventName)) {
+        throw new Error(`Listener "${listenerId}" references unknown event "${eventName}".`);
+      }
+    }
+    listeners.push({
+      sourcePath: relativePath,
+      id: listenerId,
+      eventNames,
+      exportName: exportedListener.exportName
+    });
+  }
+  assertUniqueEntries("listener", listeners.map((entry) => ({
+    name: entry.id,
+    sourcePath: entry.sourcePath
+  })));
+  listeners.sort((left, right) => left.id.localeCompare(right.id));
+  const broadcastDiscovery = broadcastFiles.length > 0 || channelFiles.length > 0 ? await loadBroadcastDiscoveryModule(projectRoot) : void 0;
+  const broadcast = [];
+  for (const filePath of broadcastFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const exportedBroadcast = resolveNamedExportEntry(
+      await importProjectModule(projectRoot, filePath),
+      (value) => broadcastDiscovery.isBroadcastDefinition(value)
+    );
+    if (!exportedBroadcast) {
+      throw new Error(`Discovered broadcast "${relativePath}" does not export a Holo broadcast definition.`);
+    }
+    const normalizedBroadcast = exportedBroadcast.value;
+    broadcast.push({
+      sourcePath: relativePath,
+      name: normalizedBroadcast.name?.trim() || deriveBroadcastNameFromPath(broadcastRoot, filePath),
+      exportName: exportedBroadcast.exportName,
+      channels: normalizedBroadcast.channels.map((channel) => ({
+        type: channel.type,
+        pattern: channel.pattern
+      }))
+    });
+  }
+  assertUniqueEntries("broadcast", broadcast);
+  broadcast.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+  const channels = [];
+  for (const filePath of channelFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const exportedChannel = resolveNamedExportEntry(
+      await importProjectModule(projectRoot, filePath),
+      (value) => broadcastDiscovery.isChannelDefinition(value)
+    );
+    if (!exportedChannel) {
+      throw new Error(`Discovered channel "${relativePath}" does not export a Holo channel definition.`);
+    }
+    const normalizedChannel = exportedChannel.value;
+    const pattern = normalizedChannel.pattern || deriveChannelPatternFromPath(channelsRoot, filePath);
+    channels.push({
+      sourcePath: relativePath,
+      pattern,
+      exportName: exportedChannel.exportName,
+      type: normalizedChannel.type,
+      params: broadcastDiscovery.broadcastInternals.extractChannelPatternParamNames(pattern),
+      whispers: Object.freeze(Object.keys(normalizedChannel.whispers))
+    });
+  }
+  assertUniqueEntries("channel", channels.map((entry) => ({
+    name: entry.pattern,
+    sourcePath: entry.sourcePath
+  })));
+  channels.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+  const authorizationDiscovery = policyFiles.length > 0 || abilityFiles.length > 0 ? await loadAuthorizationDiscoveryModule(projectRoot) : void 0;
+  const authorizationPolicies = [];
+  for (const filePath of policyFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const authorizationStateBeforeImport = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+    const existingPolicyNames = captureAuthorizationDefinitionNames(authorizationStateBeforeImport.policiesByName);
+    const existingAbilityNames = captureAuthorizationDefinitionNames(authorizationStateBeforeImport.abilitiesByName);
+    try {
+      const exportedPolicy = resolveNamedExportEntry(
+        await importProjectModule(projectRoot, filePath),
+        (value) => authorizationDiscovery.isAuthorizationPolicyDefinition(value)
+      );
+      if (!exportedPolicy) {
+        throw new Error(`Discovered policy "${relativePath}" does not export a Holo policy.`);
+      }
+      const authorizationStateAfterImport = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+      const addedPolicyNames = findAddedAuthorizationDefinitionNames(authorizationStateAfterImport.policiesByName, existingPolicyNames);
+      const addedAbilityNames = findAddedAuthorizationDefinitionNames(authorizationStateAfterImport.abilitiesByName, existingAbilityNames);
+      if (addedPolicyNames.length !== 1 || addedAbilityNames.length !== 0) {
+        throw new Error(
+          `Discovered policy "${relativePath}" must register exactly one Holo policy and zero Holo abilities (found ${addedPolicyNames.length} policies and ${addedAbilityNames.length} abilities).`
+        );
+      }
+      const normalizedPolicy = exportedPolicy.value;
+      authorizationPolicies.push({
+        sourcePath: relativePath,
+        name: normalizedPolicy.name.trim(),
+        exportName: exportedPolicy.exportName,
+        target: resolveAuthorizationTargetName(normalizedPolicy.target) ?? "Object",
+        classActions: Object.freeze(Object.keys(normalizedPolicy.class ?? {})),
+        recordActions: Object.freeze(Object.keys(normalizedPolicy.record ?? {}))
+      });
+    } finally {
+      const authorizationStateAfterDiscovery = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+      unregisterAuthorizationDefinitionNames(
+        authorizationDiscovery,
+        findAddedAuthorizationDefinitionNames(authorizationStateAfterDiscovery.policiesByName, existingPolicyNames),
+        findAddedAuthorizationDefinitionNames(authorizationStateAfterDiscovery.abilitiesByName, existingAbilityNames)
+      );
+    }
+  }
+  assertUniqueEntries("policy", authorizationPolicies.map((entry) => ({
+    name: entry.name,
+    sourcePath: entry.sourcePath
+  })));
+  authorizationPolicies.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+  const authorizationAbilities = [];
+  for (const filePath of abilityFiles) {
+    const relativePath = makeProjectRelativePath(projectRoot, filePath);
+    const authorizationStateBeforeImport = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+    const existingPolicyNames = captureAuthorizationDefinitionNames(authorizationStateBeforeImport.policiesByName);
+    const existingAbilityNames = captureAuthorizationDefinitionNames(authorizationStateBeforeImport.abilitiesByName);
+    try {
+      const exportedAbility = resolveNamedExportEntry(
+        await importProjectModule(projectRoot, filePath),
+        (value) => authorizationDiscovery.isAuthorizationAbilityDefinition(value)
+      );
+      if (!exportedAbility) {
+        throw new Error(`Discovered ability "${relativePath}" does not export a Holo ability.`);
+      }
+      const authorizationStateAfterImport = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+      const addedPolicyNames = findAddedAuthorizationDefinitionNames(authorizationStateAfterImport.policiesByName, existingPolicyNames);
+      const addedAbilityNames = findAddedAuthorizationDefinitionNames(authorizationStateAfterImport.abilitiesByName, existingAbilityNames);
+      if (addedPolicyNames.length !== 0 || addedAbilityNames.length !== 1) {
+        throw new Error(
+          `Discovered ability "${relativePath}" must register exactly one Holo ability and zero Holo policies (found ${addedPolicyNames.length} policies and ${addedAbilityNames.length} abilities).`
+        );
+      }
+      const normalizedAbility = exportedAbility.value;
+      authorizationAbilities.push({
+        sourcePath: relativePath,
+        name: normalizedAbility.name.trim(),
+        exportName: exportedAbility.exportName
+      });
+    } finally {
+      const authorizationStateAfterDiscovery = authorizationDiscovery.authorizationInternals.getAuthorizationRuntimeState();
+      unregisterAuthorizationDefinitionNames(
+        authorizationDiscovery,
+        findAddedAuthorizationDefinitionNames(authorizationStateAfterDiscovery.policiesByName, existingPolicyNames),
+        findAddedAuthorizationDefinitionNames(authorizationStateAfterDiscovery.abilitiesByName, existingAbilityNames)
+      );
+    }
+  }
+  assertUniqueEntries("ability", authorizationAbilities.map((entry) => ({
+    name: entry.name,
+    sourcePath: entry.sourcePath
+  })));
+  authorizationAbilities.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+  const registry = {
+    version: 1,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    paths: {
+      models: config.paths.models,
+      migrations: config.paths.migrations,
+      seeders: config.paths.seeders,
+      commands: config.paths.commands,
+      jobs: config.paths.jobs,
+      events: config.paths.events,
+      listeners: config.paths.listeners,
+      broadcast: broadcastPath,
+      channels: channelsPath,
+      authorizationPolicies: config.paths.authorizationPolicies ?? "server/policies",
+      authorizationAbilities: config.paths.authorizationAbilities ?? "server/abilities",
+      generatedSchema: config.paths.generatedSchema
+    },
+    models,
+    migrations,
+    seeders,
+    commands,
+    jobs,
+    events,
+    listeners,
+    broadcast,
+    channels,
+    authorizationPolicies,
+    authorizationAbilities
+  };
+  await writeGeneratedProjectRegistry(projectRoot, registry);
+  return registry;
+}
+async function discoverAppCommands(projectRoot, config = normalizeHoloProjectConfig()) {
+  const registry = await loadGeneratedProjectRegistry(projectRoot) ?? await prepareProjectDiscovery(projectRoot, config);
+  return [...registry.commands].map((entry) => ({
+    sourcePath: entry.sourcePath,
+    name: entry.name,
+    aliases: entry.aliases,
+    description: entry.description,
+    ...entry.usage ? { usage: entry.usage } : {},
+    async load() {
+      const moduleValue = await importProjectModule(projectRoot, resolve(projectRoot, entry.sourcePath));
+      const command = resolveCommandExport(moduleValue);
+      if (!command) {
+        throw new Error(`Discovered command "${entry.sourcePath}" does not export a Holo command.`);
+      }
+      return command;
+    }
+  })).sort((left, right) => left.name.localeCompare(right.name));
+}
+async function loadRegisteredModels(projectRoot, config) {
+  const models = [];
+  for (const entry of config.models) {
+    const moduleValue = await importProjectModule(projectRoot, resolveRegisteredPath(projectRoot, entry));
+    const model = resolveNamedExport(moduleValue, isCliModelReference);
+    if (!model) {
+      throw new Error(`Registered model "${entry}" does not export a Holo model.`);
+    }
+    models.push(model);
+  }
+  return models;
+}
+async function loadRegisteredMigrations(projectRoot, config) {
+  const migrations = [];
+  for (const entry of config.migrations) {
+    const moduleValue = await importProjectModule(projectRoot, resolveRegisteredPath(projectRoot, entry));
+    const migration = resolveNamedExport(moduleValue, isMigrationDefinition);
+    if (!migration) {
+      throw new Error(`Registered migration "${entry}" does not export a Holo migration.`);
+    }
+    migrations.push({
+      ...migration,
+      name: migration.name ? validateMigrationName(migration.name) : inferMigrationNameFromEntry(entry)
+    });
+  }
+  return migrations;
+}
+function inferMigrationNameFromEntry(entry) {
+  const fileName = basename(entry, extname(entry));
+  return validateMigrationName(
+    fileName,
+    `Registered migration "${entry}" must use a timestamped file name matching YYYY_MM_DD_HHMMSS_description.`
+  );
+}
+function validateMigrationName(name, message) {
+  if (!MIGRATION_NAME_PATTERN.test(name)) {
+    throw new Error(
+      message ?? `Migration name "${name}" must match YYYY_MM_DD_HHMMSS_description.`
+    );
+  }
+  return name;
+}
+async function loadRegisteredSeeders(projectRoot, config) {
+  const seeders = [];
+  for (const entry of config.seeders) {
+    const moduleValue = await importProjectModule(projectRoot, resolveRegisteredPath(projectRoot, entry));
+    const seeder = resolveNamedExport(moduleValue, isSeederDefinition);
+    if (!seeder) {
+      throw new Error(`Registered seeder "${entry}" does not export a Holo seeder.`);
+    }
+    seeders.push(seeder);
+  }
+  return seeders;
+}
+
+export {
+  resolveNamedExport,
+  resolveNamedExportEntry,
+  resolveListenerEventNamesForDiscovery,
+  collectImportedBindingsBySource,
+  extractListensToItems,
+  resolveListenerEventNamesFromSource,
+  prepareProjectDiscovery,
+  discoverAppCommands,
+  loadRegisteredModels,
+  loadRegisteredMigrations,
+  loadRegisteredSeeders
+};