@holo-js/cli 0.1.1 → 0.1.3

package/dist/chunk-3OTCSFDG.mjs

@@ -0,0 +1,849 @@
+#!/usr/bin/env node
+import {
+  CONFIG_EXTENSION_PRIORITY,
+  GENERATED_AUTHORIZATION_REGISTRY_PATH,
+  GENERATED_AUTHORIZATION_TYPES_PATH,
+  GENERATED_BROADCAST_MANIFEST_PATH,
+  GENERATED_BROADCAST_PATH,
+  GENERATED_BROADCAST_TYPES_PATH,
+  GENERATED_CHANNELS_PATH,
+  GENERATED_COMMANDS_PATH,
+  GENERATED_CONFIG_TYPES_PATH,
+  GENERATED_EVENTS_PATH,
+  GENERATED_EVENT_TYPES_PATH,
+  GENERATED_GITIGNORE_PATH,
+  GENERATED_INDEX_PATH,
+  GENERATED_JOBS_PATH,
+  GENERATED_LISTENERS_PATH,
+  GENERATED_METADATA_PATH,
+  GENERATED_MIGRATIONS_PATH,
+  GENERATED_MODELS_PATH,
+  GENERATED_QUEUE_TYPES_PATH,
+  GENERATED_REGISTRY_JSON_PATH,
+  GENERATED_ROOT,
+  GENERATED_SEEDERS_PATH,
+  GENERATED_TSCONFIG_PATH,
+  SUPPORTED_CONFIG_EXTENSIONS,
+  importProjectModule,
+  isRecord,
+  makeProjectRelativePath,
+  pathExists
+} from "./chunk-66FHW725.mjs";
+
+// src/templates.ts
+import { dirname, relative, resolve } from "path";
+function toPosixPath(value) {
+  return value.replace(/\\/g, "/");
+}
+function splitRequestedName(value) {
+  const normalized = value.trim().replace(/\\/g, "/").replace(/^\/+|\/+$/g, "");
+  if (!normalized) {
+    throw new Error("A name is required.");
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  if (segments.some((segment) => segment === "." || segment === "..")) {
+    throw new Error("Names must stay within the project root.");
+  }
+  const rawBaseName = segments.pop();
+  if (!rawBaseName) {
+    throw new Error("A name is required.");
+  }
+  return {
+    directory: segments.join("/"),
+    rawBaseName
+  };
+}
+function toPascalCase(value) {
+  return value.replace(/[^a-z0-9]+/gi, " ").split(" ").filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function toSnakeCase(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-z0-9]+/gi, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+}
+function toKebabCase(value) {
+  return toSnakeCase(value).replaceAll("_", "-");
+}
+function pluralize(word) {
+  if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) {
+    return `${word.slice(0, -1)}ies`;
+  }
+  if (/(?:[sxz]|ch|sh)$/i.test(word)) {
+    return `${word}es`;
+  }
+  return `${word}s`;
+}
+function ensureSuffix(name, suffix) {
+  return name.endsWith(suffix) ? name : `${name}${suffix}`;
+}
+function relativeImportPath(fromFile, toFile) {
+  const fromDir = dirname(fromFile);
+  const target = toPosixPath(relative(fromDir, toFile)).replace(/\.[^.]+$/, "");
+  return target.startsWith(".") ? target : `./${target}`;
+}
+function renderModelTemplate(options) {
+  const imports = [
+    `import { tables as holoGeneratedTables } from '${options.generatedSchemaImportPath}'`,
+    "import { defineModel, type TableDefinition } from '@holo-js/db'"
+  ];
+  if (options.observerImportPath && options.observerClassName) {
+    imports.push(`import { ${options.observerClassName} } from '${options.observerImportPath}'`);
+  }
+  return [
+    ...imports,
+    "",
+    `const holoModelTable = (holoGeneratedTables as Partial<Record<string, TableDefinition>>)[${JSON.stringify(options.tableName)}]`,
+    "export const holoModelPendingSchema = typeof holoModelTable === 'undefined'",
+    "",
+    "export default holoModelPendingSchema",
+    "  ? undefined",
+    "  : defineModel(",
+    "      holoModelTable,",
+    "      {",
+    "        fillable: [],",
+    ...options.observerClassName ? [`        observers: [${options.observerClassName}],`] : [],
+    "      },",
+    "    )",
+    ""
+  ].join("\n");
+}
+function renderSeederTemplate(seederName) {
+  return [
+    "import { defineSeeder } from '@holo-js/db'",
+    "",
+    "export default defineSeeder({",
+    `  name: '${seederName}',`,
+    "  async run({ db, schema }) {",
+    "    void db",
+    "    void schema",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderObserverTemplate(className) {
+  return [
+    `export class ${className} {`,
+    "  created() {}",
+    "",
+    "  updated() {}",
+    "",
+    "  deleted() {}",
+    "}",
+    "",
+    `export default ${className}`,
+    ""
+  ].join("\n");
+}
+function renderFactoryTemplate(modelImportPath, modelName) {
+  return [
+    "import { defineFactory } from '@holo-js/db'",
+    `import ${modelName} from '${modelImportPath}'`,
+    "",
+    `export default defineFactory(${modelName}, () => ({`,
+    "}))",
+    ""
+  ].join("\n");
+}
+function renderJobTemplate() {
+  return [
+    "import { defineJob } from '@holo-js/queue'",
+    "",
+    "export default defineJob({",
+    "  async handle(payload, context) {",
+    "    void payload",
+    "    void context",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderEventTemplate(eventName) {
+  return [
+    "import { defineEvent } from '@holo-js/events'",
+    "",
+    "export default defineEvent<Record<string, unknown>>({",
+    `  name: '${eventName}',`,
+    "})",
+    ""
+  ].join("\n");
+}
+function renderBroadcastTemplate(eventName) {
+  return [
+    "import { channel, defineBroadcast } from '@holo-js/broadcast'",
+    "",
+    "export default defineBroadcast({",
+    `  name: '${eventName}',`,
+    "  channels: [",
+    `    channel('${eventName}'),`,
+    "  ],",
+    "  payload: {},",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderChannelTemplate(pattern) {
+  return [
+    "import { defineChannel } from '@holo-js/broadcast'",
+    "",
+    `export default defineChannel('${pattern}', {`,
+    "  type: 'private',",
+    "  authorize() {",
+    "    return false",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderListenerTemplate(eventImportStatement, eventName) {
+  return [
+    "import { defineListener } from '@holo-js/events'",
+    eventImportStatement,
+    "",
+    "export default defineListener({",
+    `  listensTo: [${eventName}],`,
+    "  async handle(event) {",
+    "    void event",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderMultiListenerTemplate(events) {
+  return [
+    "import { defineListener } from '@holo-js/events'",
+    ...events.map((event) => event.importStatement),
+    "",
+    "export default defineListener({",
+    `  listensTo: [${events.map((event) => event.importName).join(", ")}],`,
+    "  async handle(event) {",
+    "    void event",
+    "  },",
+    "})",
+    ""
+  ].join("\n");
+}
+function renderMarkdownMailTemplate(mailName, inputTypeName) {
+  return [
+    "import { defineMail } from '@holo-js/mail'",
+    "",
+    `export type ${inputTypeName} = {`,
+    "  readonly to: string",
+    "  readonly name: string",
+    "}",
+    "",
+    `function ${mailName}(input: ${inputTypeName}) {`,
+    "  return defineMail({",
+    "    to: input.to,",
+    "    subject: `Welcome, ${input.name}`,",
+    "    markdown: [",
+    "      '# Welcome',",
+    "      '',",
+    "      `Hello ${input.name},`,",
+    "      '',",
+    "      'Your mail definition is ready.',",
+    "    ].join('\\n'),",
+    "  })",
+    "}",
+    "",
+    `export default ${mailName}`,
+    ""
+  ].join("\n");
+}
+function resolveNameInfo(requestedName, options = {}) {
+  const parts = splitRequestedName(requestedName);
+  const baseName = ensureSuffix(toPascalCase(parts.rawBaseName), options.suffix ?? "");
+  const baseStem = options.suffix && baseName.endsWith(options.suffix) ? baseName.slice(0, -options.suffix.length) : baseName;
+  const snakeStem = toSnakeCase(baseStem);
+  const tableName = pluralize(snakeStem);
+  return {
+    directory: parts.directory,
+    baseName,
+    baseStem,
+    snakeStem,
+    tableName
+  };
+}
+function resolveArtifactPath(root, subdir, directory, fileName) {
+  return resolve(root, subdir, directory, fileName);
+}
+
+// src/project/registry.ts
+import { mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { dirname as dirname2, extname, join, resolve as resolve2 } from "path";
+import { loadConfigDirectory } from "@holo-js/config";
+import { DEFAULT_HOLO_PROJECT_PATHS } from "@holo-js/db";
+function renderGeneratedModule(exportName, value) {
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    `export const ${exportName} = ${JSON.stringify(value, null, 2)}`,
+    "",
+    `export default ${exportName}`,
+    ""
+  ].join("\n");
+}
+function renderGeneratedIndexModule() {
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "/* eslint-disable @typescript-eslint/triple-slash-reference */",
+    "",
+    '/// <reference path="./broadcast.d.ts" />',
+    '/// <reference path="./authorization/types.d.ts" />',
+    '/// <reference path="./config.d.ts" />',
+    '/// <reference path="./events.d.ts" />',
+    '/// <reference path="./queue.d.ts" />',
+    "",
+    "import metadata from './metadata'",
+    "import models from './models'",
+    "import migrations from './migrations'",
+    "import seeders from './seeders'",
+    "import commands from './commands'",
+    "import jobs from './jobs'",
+    "import events from './events'",
+    "import listeners from './listeners'",
+    "import broadcast from './broadcast'",
+    "import channels from './channels'",
+    "import authorization from './authorization/registry'",
+    "import broadcastManifest from './broadcast-manifest'",
+    "",
+    "export { metadata, models, migrations, seeders, commands, jobs, events, listeners, broadcast, channels, authorization, broadcastManifest }",
+    "",
+    "export const registry = {",
+    "  ...metadata,",
+    "  models,",
+    "  migrations,",
+    "  seeders,",
+    "  commands,",
+    "  jobs,",
+    "  events,",
+    "  listeners,",
+    "  broadcast,",
+    "  channels,",
+    "  authorizationPolicies: authorization.policies,",
+    "  authorizationAbilities: authorization.abilities,",
+    "  broadcastManifest,",
+    "}",
+    "",
+    "export default registry",
+    ""
+  ].join("\n");
+}
+function renderAugmentationInterface(name, members) {
+  if (members.length === 0) {
+    return [
+      "  // eslint-disable-next-line @typescript-eslint/no-empty-object-type",
+      `  interface ${name} {}`
+    ];
+  }
+  return [
+    `  interface ${name} {`,
+    ...members,
+    "  }"
+  ];
+}
+function renderGeneratedBroadcastTypes(broadcast, channels) {
+  const typedBroadcastEntries = broadcast.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const typedChannelEntries = channels.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const broadcastImportNameByName = new Map(typedBroadcastEntries.map((entry, index) => [entry.name, `holoBroadcastModule${index}`]));
+  const channelImportNameByPattern = new Map(typedChannelEntries.map((entry, index) => [entry.pattern, `holoChannelModule${index}`]));
+  const broadcastNeedsDefinitionType = broadcast.some((entry) => !broadcastImportNameByName.get(entry.name) || !entry.exportName);
+  const broadcastNeedsExportedType = broadcast.some((entry) => Boolean(broadcastImportNameByName.get(entry.name) && entry.exportName));
+  const channelNeedsDefinitionType = channels.some((entry) => !channelImportNameByPattern.get(entry.pattern) || !entry.exportName);
+  const channelNeedsExportedType = channels.some((entry) => Boolean(channelImportNameByPattern.get(entry.pattern) && entry.exportName));
+  const typeImports = [];
+  if (broadcastNeedsDefinitionType) typeImports.push("BroadcastDefinition");
+  if (channelNeedsDefinitionType) typeImports.push("ChannelDefinition");
+  if (broadcastNeedsExportedType) typeImports.push("ExportedBroadcastDefinition");
+  if (channelNeedsExportedType) typeImports.push("ExportedChannelDefinition");
+  const imports = [];
+  if (typeImports.length > 0) {
+    imports.push("import type {", ...typeImports.map((typeName) => `  ${typeName},`), "} from '@holo-js/broadcast'");
+  }
+  imports.push(
+    ...typedBroadcastEntries.map((entry, index) => {
+      return `import type * as holoBroadcastModule${index} from '${relativeImportPath(GENERATED_BROADCAST_TYPES_PATH, entry.sourcePath)}'`;
+    }),
+    ...typedChannelEntries.map((entry, index) => {
+      return `import type * as holoChannelModule${index} from '${relativeImportPath(GENERATED_BROADCAST_TYPES_PATH, entry.sourcePath)}'`;
+    })
+  );
+  const broadcastMembers = broadcast.map((entry) => {
+    const importName = broadcastImportNameByName.get(entry.name);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.name)}: BroadcastDefinition`;
+    }
+    return `    ${JSON.stringify(entry.name)}: ExportedBroadcastDefinition<typeof ${importName}[${JSON.stringify(entry.exportName)}]>`;
+  });
+  const channelMembers = channels.map((entry) => {
+    const importName = channelImportNameByPattern.get(entry.pattern);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.pattern)}: ChannelDefinition`;
+    }
+    return `    ${JSON.stringify(entry.pattern)}: ExportedChannelDefinition<typeof ${importName}[${JSON.stringify(entry.exportName)}]>`;
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...imports,
+    ...imports.length > 0 ? [""] : [],
+    "declare module '@holo-js/broadcast' {",
+    ...renderAugmentationInterface("HoloBroadcastRegistry", broadcastMembers),
+    "",
+    ...renderAugmentationInterface("HoloChannelRegistry", channelMembers),
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderGeneratedBroadcastManifest(registry) {
+  const hasPresenceChannels = registry.channels.some((entry) => entry.type === "presence");
+  const manifestImports = hasPresenceChannels ? ["import type { ChannelPresenceMemberFor, GeneratedBroadcastManifest } from '@holo-js/broadcast'"] : ["import type { GeneratedBroadcastManifest } from '@holo-js/broadcast'"];
+  const eventLines = registry.broadcast.flatMap((entry, index) => {
+    const lines = [
+      "    {",
+      `      name: ${JSON.stringify(entry.name)},`,
+      "      channels: [",
+      ...entry.channels.flatMap((channel, channelIndex) => {
+        return [
+          "        {",
+          `          type: ${JSON.stringify(channel.type)},`,
+          `          pattern: ${JSON.stringify(channel.pattern)},`,
+          `        }${channelIndex < entry.channels.length - 1 ? "," : ""}`
+        ];
+      }),
+      "      ],",
+      `    }${index < registry.broadcast.length - 1 ? "," : ""}`
+    ];
+    return lines;
+  });
+  const channelLines = registry.channels.flatMap((entry, index) => {
+    const lines = [
+      "    {",
+      `      name: ${JSON.stringify(entry.pattern)},`,
+      `      pattern: ${JSON.stringify(entry.pattern)},`,
+      `      type: ${JSON.stringify(entry.type)},`,
+      `      params: ${JSON.stringify(entry.params)},`,
+      `      whispers: ${JSON.stringify(entry.whispers)},`
+    ];
+    if (entry.type === "presence") {
+      lines.push(`      member: undefined as unknown as ChannelPresenceMemberFor<${JSON.stringify(entry.pattern)}>,`);
+    }
+    lines.push(`    }${index < registry.channels.length - 1 ? "," : ""}`);
+    return lines;
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...manifestImports,
+    "",
+    "export const broadcastManifest = {",
+    "  version: 1,",
+    `  generatedAt: ${JSON.stringify(registry.generatedAt)},`,
+    "  events: [",
+    ...eventLines,
+    "  ],",
+    "  channels: [",
+    ...channelLines,
+    "  ],",
+    "} as const satisfies GeneratedBroadcastManifest",
+    "",
+    "export default broadcastManifest",
+    ""
+  ].join("\n");
+}
+function renderGeneratedEventTypes(events, listeners) {
+  const typedEventEntries = events.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const typedListenerEntries = listeners.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const eventImportNameByName = new Map(typedEventEntries.map((entry, index) => [entry.name, `holoEventModule${index}`]));
+  const listenerImportNameById = new Map(typedListenerEntries.map((entry, index) => [entry.id, `holoListenerModule${index}`]));
+  const needsEventDefinitionType = events.some((entry) => !eventImportNameByName.get(entry.name) || !entry.exportName);
+  const needsExportedEventType = events.some((entry) => Boolean(eventImportNameByName.get(entry.name) && entry.exportName));
+  const needsListenerDefinitionType = listeners.some((entry) => !listenerImportNameById.get(entry.id) || !entry.exportName);
+  const needsTypedListenerDefinitionType = listeners.some((entry) => Boolean(listenerImportNameById.get(entry.id) && entry.exportName));
+  const typeImports = [];
+  if (needsEventDefinitionType) typeImports.push("EventDefinition");
+  if (needsExportedEventType) typeImports.push("ExportedEventDefinition");
+  if (needsListenerDefinitionType || needsTypedListenerDefinitionType) typeImports.push("ListenerDefinition");
+  const imports = [];
+  if (typeImports.length > 0) {
+    imports.push("import type {", ...typeImports.map((typeName) => `  ${typeName},`), "} from '@holo-js/events'");
+  }
+  imports.push(
+    ...typedEventEntries.map((entry, index) => {
+      return `import type * as holoEventModule${index} from '${relativeImportPath(GENERATED_EVENT_TYPES_PATH, entry.sourcePath)}'`;
+    }),
+    ...typedListenerEntries.map((entry, index) => {
+      return `import type * as holoListenerModule${index} from '${relativeImportPath(GENERATED_EVENT_TYPES_PATH, entry.sourcePath)}'`;
+    })
+  );
+  const eventMembers = events.map((entry) => {
+    const importName = eventImportNameByName.get(entry.name);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.name)}: EventDefinition`;
+    }
+    return `    ${JSON.stringify(entry.name)}: ExportedEventDefinition<typeof ${importName}[${JSON.stringify(entry.exportName)}]>`;
+  });
+  const listenerMembers = listeners.map((entry) => {
+    const importName = listenerImportNameById.get(entry.id);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.id)}: ListenerDefinition`;
+    }
+    return `    ${JSON.stringify(entry.id)}: Extract<typeof ${importName}[${JSON.stringify(entry.exportName)}], ListenerDefinition>`;
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...imports,
+    ...imports.length > 0 ? [""] : [],
+    "declare module '@holo-js/events' {",
+    ...renderAugmentationInterface("HoloEventRegistry", eventMembers),
+    "",
+    ...renderAugmentationInterface("HoloListenerRegistry", listenerMembers),
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderGeneratedQueueTypes(jobs) {
+  const typedJobs = jobs.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const typeImportNameByJob = new Map(
+    typedJobs.map((entry, index) => {
+      return [entry.name, `holoQueueJobModule${index}`];
+    })
+  );
+  const needsQueueJobDefinitionType = jobs.some((entry) => !typeImportNameByJob.get(entry.name) || !entry.exportName);
+  const needsExportedQueueJobDefinitionType = jobs.some((entry) => Boolean(typeImportNameByJob.get(entry.name) && entry.exportName));
+  const imports = typedJobs.map((entry, index) => {
+    return `import type * as holoQueueJobModule${index} from '${relativeImportPath(GENERATED_QUEUE_TYPES_PATH, entry.sourcePath)}'`;
+  });
+  const queueTypeImports = [];
+  if (needsQueueJobDefinitionType) queueTypeImports.push("QueueJobDefinition");
+  if (needsExportedQueueJobDefinitionType) queueTypeImports.push("ExportedQueueJobDefinition");
+  const members = jobs.map((entry) => {
+    const importName = typeImportNameByJob.get(entry.name);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.name)}: QueueJobDefinition`;
+    }
+    return `    ${JSON.stringify(entry.name)}: ExportedQueueJobDefinition<typeof ${importName}[${JSON.stringify(entry.exportName)}]>`;
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...queueTypeImports.length > 0 ? ["import type {", ...queueTypeImports.map((typeName) => `  ${typeName},`), "} from '@holo-js/queue'"] : [],
+    ...queueTypeImports.length > 0 ? [""] : [],
+    ...imports,
+    ...imports.length > 0 ? [""] : [],
+    "declare module '@holo-js/queue' {",
+    ...renderAugmentationInterface("HoloQueueJobRegistry", members),
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderGeneratedAuthorizationRegistry(registry) {
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "export const authorization = {",
+    `  generatedAt: ${JSON.stringify(registry.generatedAt)},`,
+    "  policies: [",
+    ...registry.authorizationPolicies.flatMap((entry, index) => {
+      return [
+        "    {",
+        `      sourcePath: ${JSON.stringify(entry.sourcePath)},`,
+        `      name: ${JSON.stringify(entry.name)},`,
+        ...entry.exportName ? [`      exportName: ${JSON.stringify(entry.exportName)},`] : [],
+        `      target: ${JSON.stringify(entry.target)},`,
+        `      classActions: ${JSON.stringify(entry.classActions)},`,
+        `      recordActions: ${JSON.stringify(entry.recordActions)},`,
+        `    }${index < registry.authorizationPolicies.length - 1 ? "," : ""}`
+      ];
+    }),
+    "  ],",
+    "  abilities: [",
+    ...registry.authorizationAbilities.flatMap((entry, index) => {
+      return [
+        "    {",
+        `      sourcePath: ${JSON.stringify(entry.sourcePath)},`,
+        `      name: ${JSON.stringify(entry.name)},`,
+        ...entry.exportName ? [`      exportName: ${JSON.stringify(entry.exportName)},`] : [],
+        `    }${index < registry.authorizationAbilities.length - 1 ? "," : ""}`
+      ];
+    }),
+    "  ],",
+    "} as const",
+    "",
+    "export default authorization",
+    ""
+  ].join("\n");
+}
+function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationAbilities, guardNames) {
+  const typedPolicyEntries = authorizationPolicies.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const typedAbilityEntries = authorizationAbilities.filter((entry) => [".ts", ".mts", ".cts"].includes(extname(entry.sourcePath)));
+  const policyImportNameByName = new Map(typedPolicyEntries.map((entry, index) => [entry.name, `holoAuthorizationPolicyModule${index}`]));
+  const abilityImportNameByName = new Map(typedAbilityEntries.map((entry, index) => [entry.name, `holoAuthorizationAbilityModule${index}`]));
+  const imports = [
+    ...typedPolicyEntries.map((entry, index) => {
+      return `import type * as holoAuthorizationPolicyModule${index} from '${relativeImportPath(GENERATED_AUTHORIZATION_TYPES_PATH, entry.sourcePath)}'`;
+    }),
+    ...typedAbilityEntries.map((entry, index) => {
+      return `import type * as holoAuthorizationAbilityModule${index} from '${relativeImportPath(GENERATED_AUTHORIZATION_TYPES_PATH, entry.sourcePath)}'`;
+    })
+  ];
+  const policyMembers = authorizationPolicies.map((entry) => {
+    const importName = policyImportNameByName.get(entry.name);
+    const classActionEntries = entry.classActions.length > 0 ? entry.classActions.map((action) => `      ${JSON.stringify(action)}: true`) : [];
+    const recordActionEntries = entry.recordActions.length > 0 ? entry.recordActions.map((action) => `      ${JSON.stringify(action)}: true`) : [];
+    if (!importName || !entry.exportName) {
+      return [
+        `    ${JSON.stringify(entry.name)}: {`,
+        "      actor: object",
+        `      target: object`,
+        "      classActions: {",
+        ...classActionEntries,
+        "      }",
+        "      recordActions: {",
+        ...recordActionEntries,
+        "      }",
+        "    }"
+      ].join("\n");
+    }
+    return [
+      `    ${JSON.stringify(entry.name)}: {`,
+      "      actor: object",
+      `      target: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends import('@holo-js/authorization/contracts').AuthorizationPolicyDefinition<infer _TName, infer TTarget, infer _TClassActions, infer _TRecordActions, infer _TActor> ? TTarget : object`,
+      `      classActions: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends import('@holo-js/authorization/contracts').AuthorizationPolicyDefinition<infer _TName, infer _TTarget, infer TClassActions, infer _TRecordActions, infer _TActor> ? {`,
+      ...classActionEntries,
+      "      } : {",
+      ...classActionEntries,
+      "      }",
+      `      recordActions: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends import('@holo-js/authorization/contracts').AuthorizationPolicyDefinition<infer _TName, infer _TTarget, infer _TClassActions, infer TRecordActions, infer _TActor> ? {`,
+      ...recordActionEntries,
+      "      } : {",
+      ...recordActionEntries,
+      "      }",
+      "    }"
+    ].join("\n");
+  });
+  const abilityMembers = authorizationAbilities.map((entry) => {
+    const importName = abilityImportNameByName.get(entry.name);
+    if (!importName || !entry.exportName) {
+      return `    ${JSON.stringify(entry.name)}: { actor: object, input: object }`;
+    }
+    return [
+      `    ${JSON.stringify(entry.name)}: {`,
+      "      actor: object",
+      `      input: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends import('@holo-js/authorization/contracts').AuthorizationAbilityDefinition<infer _TName, infer TInput, infer _TActor> ? TInput : object`,
+      "    }"
+    ].join("\n");
+  });
+  const guardMembers = guardNames.map((name) => {
+    return [
+      `    ${JSON.stringify(name)}: {`,
+      `      user: import('@holo-js/auth').AuthUser`,
+      "    }"
+    ].join("\n");
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...imports.length > 0 ? [...imports, ""] : [],
+    "declare module '@holo-js/authorization/contracts' {",
+    ...renderAugmentationInterface("AuthorizationPolicyRegistry", policyMembers),
+    "",
+    ...renderAugmentationInterface("AuthorizationAbilityRegistry", abilityMembers),
+    "",
+    ...renderAugmentationInterface("AuthorizationGuardRegistry", guardMembers),
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderGeneratedTsconfig() {
+  return `${JSON.stringify({
+    extends: "../../tsconfig.json",
+    include: ["./**/*.ts", "./**/*.d.ts"]
+  }, null, 2)}
+`;
+}
+function getConfigExtensionPriority(fileName) {
+  const extension = extname(fileName);
+  const index = CONFIG_EXTENSION_PRIORITY.indexOf(extension);
+  return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+async function collectProjectConfigEntries(projectRoot) {
+  const configDir = resolve2(projectRoot, "config");
+  const entries = await readdir(configDir, { withFileTypes: true }).catch(() => []);
+  const selectedByName = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const extension = extname(entry.name);
+    if (!SUPPORTED_CONFIG_EXTENSIONS.has(extension)) {
+      continue;
+    }
+    const configName = entry.name.slice(0, entry.name.length - extension.length);
+    const filePath = join(configDir, entry.name);
+    const priority = getConfigExtensionPriority(entry.name);
+    const current = selectedByName.get(configName);
+    if (!current || priority < current.priority) {
+      selectedByName.set(configName, { filePath, priority });
+    }
+  }
+  return [...selectedByName.entries()].sort((left, right) => left[0].localeCompare(right[0])).map(([configName, entry]) => ({
+    configName,
+    filePath: entry.filePath
+  }));
+}
+function renderGeneratedConfigTypes(projectRoot, entries) {
+  const customEntries = entries.filter((entry) => !["app", "database", "redis", "cache", "storage", "queue", "broadcast", "notifications", "mail", "media", "session", "security", "auth"].includes(entry.configName));
+  if (customEntries.length === 0) {
+    return [
+      "// Generated by holo prepare. Do not edit.",
+      "",
+      "declare module '@holo-js/config' {",
+      ...renderAugmentationInterface("HoloConfigRegistry", []),
+      "}",
+      "",
+      "export {}",
+      ""
+    ].join("\n");
+  }
+  const imports = customEntries.map((entry, index) => {
+    return `import type holoConfig${index} from '${relativeImportPath(GENERATED_CONFIG_TYPES_PATH, makeProjectRelativePath(projectRoot, entry.filePath))}'`;
+  });
+  const members = customEntries.map((entry, index) => {
+    return `    ${JSON.stringify(entry.configName)}: typeof holoConfig${index}`;
+  });
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    ...imports,
+    "",
+    "declare module '@holo-js/config' {",
+    ...renderAugmentationInterface("HoloConfigRegistry", members),
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
+async function writeFileIfChanged(path, contents) {
+  try {
+    if (await readFile(path, "utf8") === contents) {
+      return;
+    }
+  } catch {
+  }
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, contents, "utf8");
+}
+function stripGeneratedAt(registry) {
+  const { generatedAt: _generatedAt, ...stableRegistry } = registry;
+  return stableRegistry;
+}
+async function ensureGeneratedRegistryOwnership(projectRoot) {
+  await mkdir(resolve2(projectRoot, GENERATED_ROOT), { recursive: true });
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_GITIGNORE_PATH), "*\n!.gitignore\n");
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_TSCONFIG_PATH), renderGeneratedTsconfig());
+}
+async function writeGeneratedProjectRegistry(projectRoot, registry) {
+  await ensureGeneratedRegistryOwnership(projectRoot);
+  const loadedConfig = await loadConfigDirectory(projectRoot);
+  const configEntries = await collectProjectConfigEntries(projectRoot);
+  const existingRegistry = await loadGeneratedProjectRegistry(projectRoot);
+  const nextRegistry = existingRegistry && JSON.stringify(stripGeneratedAt(existingRegistry)) === JSON.stringify(stripGeneratedAt(registry)) ? {
+    ...registry,
+    generatedAt: existingRegistry.generatedAt
+  } : registry;
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_METADATA_PATH), renderGeneratedModule("metadata", {
+    version: nextRegistry.version,
+    generatedAt: nextRegistry.generatedAt,
+    paths: nextRegistry.paths
+  }));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_MODELS_PATH), renderGeneratedModule("models", nextRegistry.models));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_MIGRATIONS_PATH), renderGeneratedModule("migrations", nextRegistry.migrations));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_SEEDERS_PATH), renderGeneratedModule("seeders", nextRegistry.seeders));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_COMMANDS_PATH), renderGeneratedModule("commands", nextRegistry.commands));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_JOBS_PATH), renderGeneratedModule("jobs", nextRegistry.jobs));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_EVENTS_PATH), renderGeneratedModule("events", nextRegistry.events));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_LISTENERS_PATH), renderGeneratedModule("listeners", nextRegistry.listeners));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_BROADCAST_PATH), renderGeneratedModule("broadcast", nextRegistry.broadcast));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_CHANNELS_PATH), renderGeneratedModule("channels", nextRegistry.channels));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_BROADCAST_MANIFEST_PATH), renderGeneratedBroadcastManifest(nextRegistry));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_BROADCAST_TYPES_PATH), renderGeneratedBroadcastTypes(nextRegistry.broadcast, nextRegistry.channels));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_CONFIG_TYPES_PATH), renderGeneratedConfigTypes(projectRoot, configEntries));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_EVENT_TYPES_PATH), renderGeneratedEventTypes(nextRegistry.events, nextRegistry.listeners));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_QUEUE_TYPES_PATH), renderGeneratedQueueTypes(nextRegistry.jobs));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_AUTHORIZATION_REGISTRY_PATH), renderGeneratedAuthorizationRegistry(nextRegistry));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_AUTHORIZATION_TYPES_PATH), renderGeneratedAuthorizationTypes(
+    nextRegistry.authorizationPolicies,
+    nextRegistry.authorizationAbilities,
+    Object.keys(loadedConfig?.auth?.guards ?? {}).sort((left, right) => left.localeCompare(right))
+  ));
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_INDEX_PATH), renderGeneratedIndexModule());
+  await writeFileIfChanged(resolve2(projectRoot, GENERATED_REGISTRY_JSON_PATH), `${JSON.stringify(nextRegistry, null, 2)}
+`);
+}
+function isGeneratedProjectRegistry(value) {
+  if (isRecord(value) && isRecord(value.paths)) {
+    value.paths.events ??= DEFAULT_HOLO_PROJECT_PATHS.events;
+    value.paths.listeners ??= DEFAULT_HOLO_PROJECT_PATHS.listeners;
+    value.paths.broadcast ??= "server/broadcast";
+    value.paths.channels ??= "server/channels";
+    value.paths.authorizationPolicies ??= "server/policies";
+    value.paths.authorizationAbilities ??= "server/abilities";
+  }
+  if (isRecord(value)) {
+    value.events ??= [];
+    value.listeners ??= [];
+    value.broadcast ??= [];
+    value.channels ??= [];
+    value.authorizationPolicies ??= [];
+    value.authorizationAbilities ??= [];
+  }
+  return isRecord(value) && value.version === 1 && isRecord(value.paths) && Array.isArray(value.models) && Array.isArray(value.migrations) && Array.isArray(value.seeders) && Array.isArray(value.commands) && Array.isArray(value.jobs) && Array.isArray(value.events) && Array.isArray(value.listeners) && Array.isArray(value.broadcast) && Array.isArray(value.channels) && Array.isArray(value.authorizationPolicies) && Array.isArray(value.authorizationAbilities);
+}
+async function loadGeneratedProjectRegistry(projectRoot) {
+  const filePath = resolve2(projectRoot, GENERATED_INDEX_PATH);
+  if (!await pathExists(filePath)) {
+    return void 0;
+  }
+  const moduleValue = await importProjectModule(projectRoot, filePath);
+  if (isRecord(moduleValue) && isGeneratedProjectRegistry(moduleValue.default)) {
+    return moduleValue.default;
+  }
+  if (isRecord(moduleValue) && isGeneratedProjectRegistry(moduleValue.registry)) {
+    return moduleValue.registry;
+  }
+  return void 0;
+}
+
+export {
+  splitRequestedName,
+  toPascalCase,
+  toSnakeCase,
+  toKebabCase,
+  ensureSuffix,
+  relativeImportPath,
+  renderModelTemplate,
+  renderSeederTemplate,
+  renderObserverTemplate,
+  renderFactoryTemplate,
+  renderJobTemplate,
+  renderEventTemplate,
+  renderBroadcastTemplate,
+  renderChannelTemplate,
+  renderListenerTemplate,
+  renderMultiListenerTemplate,
+  renderMarkdownMailTemplate,
+  resolveNameInfo,
+  resolveArtifactPath,
+  writeGeneratedProjectRegistry,
+  loadGeneratedProjectRegistry
+};