@holo-js/cli 0.1.3 → 0.1.5

package/dist/{chunk-3OTCSFDG.mjs → chunk-MXKNQACM.mjs}

@@ -1,8 +1,8 @@
-#!/usr/bin/env node
 import {
   CONFIG_EXTENSION_PRIORITY,
   GENERATED_AUTHORIZATION_REGISTRY_PATH,
   GENERATED_AUTHORIZATION_TYPES_PATH,
+  GENERATED_AUTH_TYPES_PATH,
   GENERATED_BROADCAST_MANIFEST_PATH,
   GENERATED_BROADCAST_PATH,
   GENERATED_BROADCAST_TYPES_PATH,
@@ -18,20 +18,24 @@ import {
   GENERATED_METADATA_PATH,
   GENERATED_MIGRATIONS_PATH,
   GENERATED_MODELS_PATH,
+  GENERATED_MODEL_TYPES_PATH,
   GENERATED_QUEUE_TYPES_PATH,
   GENERATED_REGISTRY_JSON_PATH,
   GENERATED_ROOT,
+  GENERATED_SCHEMA_RUNTIME_PATH,
   GENERATED_SEEDERS_PATH,
+  GENERATED_SVELTE_HOOKS_PATH,
+  GENERATED_SVELTE_SERVER_HOOKS_PATH,
   GENERATED_TSCONFIG_PATH,
   SUPPORTED_CONFIG_EXTENSIONS,
   importProjectModule,
   isRecord,
-  makeProjectRelativePath,
-  pathExists
-} from "./chunk-66FHW725.mjs";
+  makeProjectRelativePath
+} from "./chunk-R6BWRY3E.mjs";
 
 // src/templates.ts
 import { dirname, relative, resolve } from "path";
+import inflection from "inflection";
 function toPosixPath(value) {
   return value.replace(/\\/g, "/");
 }
@@ -63,13 +67,7 @@ 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`;
+  return inflection.pluralize(word);
 }
 function ensureSuffix(name, suffix) {
   return name.endsWith(suffix) ? name : `${name}${suffix}`;
@@ -80,28 +78,17 @@ function relativeImportPath(fromFile, toFile) {
   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'"
-  ];
+  const imports = ["import { defineModel } 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}],`] : [],
-    "      },",
-    "    )",
+    `export default defineModel(${JSON.stringify(options.tableName)}, {`,
+    "  fillable: [],",
+    ...options.observerClassName ? [`  observers: [${options.observerClassName}],`] : [],
+    "})",
     ""
   ].join("\n");
 }
@@ -267,10 +254,336 @@ function resolveArtifactPath(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 { constants as fsConstants } from "fs";
+import { access, mkdir as mkdir2, readFile as readFile2, readdir, writeFile as writeFile2 } from "fs/promises";
+import { dirname as dirname3, extname, join, resolve as resolve3 } from "path";
 import { loadConfigDirectory } from "@holo-js/config";
-import { DEFAULT_HOLO_PROJECT_PATHS } from "@holo-js/db";
+import { DEFAULT_HOLO_PROJECT_PATHS, renderGeneratedSchemaRuntimeModule } from "@holo-js/db";
+
+// src/project/registry-svelte.ts
+import { mkdir, readFile, unlink, writeFile } from "fs/promises";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+function renderManagedSvelteHooksModule() {
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "import type { Reroute } from '@sveltejs/kit'",
+    "import { holoSvelteKitTransport } from '@holo-js/adapter-sveltekit/transport'",
+    "import * as userHooks from '../../src/hooks'",
+    "",
+    "const universalHooks = userHooks as {",
+    "  reroute?: Reroute",
+    "  transport?: Partial<typeof holoSvelteKitTransport>",
+    "}",
+    "",
+    "function normalizeStorageRoutePrefix(value: string | undefined): string {",
+    "  const raw = value?.trim() ?? '/storage'",
+    "  if (!raw || raw === '/') {",
+    "    return '/storage'",
+    "  }",
+    "",
+    "  return `/${raw.replace(/^\\/+|\\/+$/g, '')}`",
+    "}",
+    "",
+    "function resolveStorageRoutePrefix(): string {",
+    "  return normalizeStorageRoutePrefix(typeof process === 'undefined' ? undefined : process.env.STORAGE_ROUTE_PREFIX)",
+    "}",
+    "",
+    "export const reroute: Reroute = async (event) => {",
+    "  const userPath = await universalHooks.reroute?.(event)",
+    "  const pathname = typeof userPath === 'string' ? userPath : event.url.pathname",
+    "  const storageRoutePrefix = resolveStorageRoutePrefix()",
+    "",
+    "  if (storageRoutePrefix !== '/storage' && (pathname === storageRoutePrefix || pathname.startsWith(`${storageRoutePrefix}/`))) {",
+    "    const suffix = pathname.slice(storageRoutePrefix.length)",
+    "    return suffix ? `/storage${suffix}` : '/storage'",
+    "  }",
+    "",
+    "  return userPath",
+    "}",
+    "export const transport = {",
+    "  ...(universalHooks.transport ?? {}),",
+    "  ...holoSvelteKitTransport,",
+    "}",
+    ""
+  ].join("\n");
+}
+function renderManagedSvelteServerHooksModule() {
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "import { error as svelteKitError, type Handle, type HandleFetch, type HandleServerError } from '@sveltejs/kit'",
+    "import { adapterSvelteKitInternals, runWithSvelteKitRequestEvent } from '@holo-js/adapter-sveltekit'",
+    "import { sequence } from '@sveltejs/kit/hooks'",
+    "import { holo } from '$lib/server/holo'",
+    "import * as userHooks from '../../src/hooks.server'",
+    "",
+    "const serverHooks = userHooks as {",
+    "  handle?: Handle",
+    "  handleError?: HandleServerError",
+    "  handleFetch?: HandleFetch",
+    "}",
+    "",
+    "function isHoloAuthorizationHttpError(cause: unknown): cause is Error & { readonly decision: { readonly status: 403 | 404 } } {",
+    "  if (!(cause instanceof Error) || cause.name !== 'AuthorizationError') {",
+    "    return false",
+    "  }",
+    "",
+    "  const decision = (cause as { readonly decision?: { readonly status?: unknown } }).decision",
+    "  return decision?.status === 403 || decision?.status === 404",
+    "}",
+    "",
+    "function serializeHoloValidationException(cause: unknown) {",
+    "  return adapterSvelteKitInternals.serializeValidationException(cause) ?? null",
+    "}",
+    "",
+    "const holoHandle: Handle = ({ event, resolve }) => runWithSvelteKitRequestEvent(event, async () => {",
+    "  await holo.getApp()",
+    "",
+    "  try {",
+    "    const response = await resolve(event)",
+    "    return await adapterSvelteKitInternals.mapValidationActionResponse(event, response)",
+    "  } catch (cause) {",
+    "    if (isHoloAuthorizationHttpError(cause)) {",
+    "      svelteKitError(cause.decision.status, cause.message)",
+    "    }",
+    "",
+    "    const validationPayload = serializeHoloValidationException(cause)",
+    "    if (validationPayload) {",
+    "      if (adapterSvelteKitInternals.isApiEvent(event)) {",
+    "        return Response.json(validationPayload, { status: validationPayload.status })",
+    "      }",
+    "",
+    "      throw cause",
+    "    }",
+    "",
+    "    throw cause",
+    "  }",
+    "})",
+    "",
+    "const holoHandleError: HandleServerError = async (input) => {",
+    "  const validationPayload = serializeHoloValidationException(input.error)",
+    "  if (validationPayload) {",
+    "    adapterSvelteKitInternals.rememberValidationActionFailure(input.event, validationPayload)",
+    "    return validationPayload",
+    "  }",
+    "",
+    "  if (serverHooks.handleError) {",
+    "    return await serverHooks.handleError(input)",
+    "  }",
+    "",
+    "  return {",
+    "    message: input.error instanceof Error ? input.error.message : 'Internal server error',",
+    "  }",
+    "}",
+    "",
+    "export const handle = typeof serverHooks.handle === 'function'",
+    "  ? sequence(holoHandle, serverHooks.handle)",
+    "  : holoHandle",
+    "export const handleError = holoHandleError",
+    "export const handleFetch = serverHooks.handleFetch",
+    ""
+  ].join("\n");
+}
+function renderSvelteDefaultHooksModule() {
+  return [
+    "export {}",
+    ""
+  ].join("\n");
+}
+function renderSvelteDefaultServerHooksModule() {
+  return [
+    "export {}",
+    ""
+  ].join("\n");
+}
+function isManagedPrepareArtifact(contents) {
+  return contents.startsWith("// Generated by holo prepare. Do not edit.");
+}
+function isLegacySvelteTransportHook(contents) {
+  return contents.trim() === [
+    "import { holoSvelteKitTransport } from '@holo-js/adapter-sveltekit/transport'",
+    "",
+    "export const transport = holoSvelteKitTransport"
+  ].join("\n").trim();
+}
+function isLegacySvelteServerHook(contents) {
+  return contents.trim() === [
+    "import '@holo-js/adapter-sveltekit'",
+    "",
+    "import type { Handle } from '@sveltejs/kit'",
+    "import { holo } from '$lib/server/holo'",
+    "",
+    "function normalizeStorageRoutePrefix(value: string | undefined): string {",
+    "  const raw = value?.trim() ?? '/storage'",
+    "  if (!raw || raw === '/') {",
+    "    return '/storage'",
+    "  }",
+    "",
+    "  return `/${raw.replace(/^\\/+|\\/+$/g, '')}`",
+    "}",
+    "",
+    "export const handle: Handle = async ({ event, resolve }) => {",
+    "  await holo.getApp()",
+    "",
+    "  const storageRoutePrefix = normalizeStorageRoutePrefix(process.env.STORAGE_ROUTE_PREFIX)",
+    "",
+    "  if (storageRoutePrefix !== '/storage') {",
+    "    const pathname = event.url.pathname",
+    "    if (pathname === storageRoutePrefix || pathname.startsWith(`${storageRoutePrefix}/`)) {",
+    "      const suffix = pathname.slice(storageRoutePrefix.length)",
+    "      event.url.pathname = suffix ? `/storage${suffix}` : '/storage'",
+    "    }",
+    "  }",
+    "",
+    "  return resolve(event)",
+    "}"
+  ].join("\n").trim();
+}
+async function readFileIfPresent(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+async function unlinkIfPresent(path) {
+  try {
+    await unlink(path);
+  } catch {
+  }
+}
+var SVELTE_HOOKS_OVERRIDE_BLOCK = [
+  "    files: {",
+  "      hooks: {",
+  "        server: '.holo-js/generated/hooks.server',",
+  "        universal: '.holo-js/generated/hooks',",
+  "      },",
+  "    },"
+].join("\n");
+var SVELTE_CONFIG_WRAPPER_IMPORT = "import { withHoloSvelteKit } from '@holo-js/adapter-sveltekit/config'";
+var LEGACY_SVELTE_PREPROCESS_IMPORT = "import { holoSveltePreprocess } from '@holo-js/adapter-sveltekit'";
+var LEGACY_SVELTE_PREPROCESS_CALL = "holoSveltePreprocess()";
+var SVELTE_CONFIG_WRAPPER_CALL = "withHoloSvelteKit(";
+function getSvelteConfigHooksOverrideState(contents) {
+  if (contents.includes(".holo-js/generated/hooks")) {
+    return "managed";
+  }
+  if (/kit\s*:\s*\{[\s\S]*?files\s*:\s*\{[\s\S]*?hooks\s*:/.test(contents)) {
+    return "custom";
+  }
+  return "none";
+}
+function assertSvelteConfigHasNoCustomHookOverride(contents) {
+  const hooksOverrideState = getSvelteConfigHooksOverrideState(contents);
+  if (hooksOverrideState === "custom") {
+    throw new Error("Custom SvelteKit hook entrypoints are not supported. Remove kit.files.hooks from svelte.config.js and let holo prepare manage the generated hook bridge.");
+  }
+}
+function ensureSvelteConfigWrapperImport(contents) {
+  if (contents.includes(SVELTE_CONFIG_WRAPPER_IMPORT)) {
+    return contents;
+  }
+  const lastImport = [...contents.matchAll(/^import .+$/gm)].at(-1);
+  if (!lastImport || lastImport.index === void 0) {
+    return `${SVELTE_CONFIG_WRAPPER_IMPORT}
+${contents}`;
+  }
+  const insertAt = lastImport.index + lastImport[0].length;
+  return `${contents.slice(0, insertAt)}
+${SVELTE_CONFIG_WRAPPER_IMPORT}${contents.slice(insertAt)}`;
+}
+function removeLegacySvelteConfigWiring(contents) {
+  return contents.replace(`${LEGACY_SVELTE_PREPROCESS_IMPORT}
+`, "").replace(new RegExp(String.raw`,\s*${LEGACY_SVELTE_PREPROCESS_CALL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`, "g"), "").replace(new RegExp(String.raw`${LEGACY_SVELTE_PREPROCESS_CALL.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\s*,\s*`, "g"), "").replace(`${SVELTE_HOOKS_OVERRIDE_BLOCK}
+`, "");
+}
+function patchSvelteConfigWithHoloWrapper(contents) {
+  assertSvelteConfigHasNoCustomHookOverride(contents);
+  const cleaned = ensureSvelteConfigWrapperImport(removeLegacySvelteConfigWiring(contents));
+  if (cleaned.includes(SVELTE_CONFIG_WRAPPER_CALL)) {
+    return cleaned === contents ? void 0 : cleaned;
+  }
+  const constConfigPattern = /(const\s+config\s*=\s*)\{/;
+  if (!constConfigPattern.test(cleaned)) {
+    throw new Error("Could not patch svelte.config.js with withHoloSvelteKit(). Export a const config object so holo prepare can manage the SvelteKit integration.");
+  }
+  const wrappedOpening = cleaned.replace(constConfigPattern, `$1${SVELTE_CONFIG_WRAPPER_CALL}{`);
+  const wrapped = wrappedOpening.replace(/\}\s*export\s+default\s+config\s*$/u, "})\n\nexport default config");
+  if (wrapped === wrappedOpening) {
+    throw new Error("Could not patch svelte.config.js with withHoloSvelteKit(). Export a const config object so holo prepare can manage the SvelteKit integration.");
+  }
+  return wrapped;
+}
+async function ensureSvelteConfigHooksOverride(projectRoot) {
+  const configPath = resolve2(projectRoot, "svelte.config.js");
+  const contents = await readFileIfPresent(configPath);
+  if (!contents) {
+    return;
+  }
+  const patched = patchSvelteConfigWithHoloWrapper(contents) ?? contents;
+  if (patched !== contents) {
+    await writeFile(configPath, patched, "utf8");
+  }
+}
+async function writeFileIfChanged(path, contents) {
+  if (await readFileIfPresent(path) === contents) {
+    return;
+  }
+  await mkdir(dirname2(path), { recursive: true });
+  await writeFile(path, contents, "utf8");
+}
+async function ensureSvelteManagedHooks(projectRoot) {
+  const hooksPath = resolve2(projectRoot, "src/hooks.ts");
+  const hooksServerPath = resolve2(projectRoot, "src/hooks.server.ts");
+  const generatedHooksPath = resolve2(projectRoot, GENERATED_SVELTE_HOOKS_PATH);
+  const generatedServerHooksPath = resolve2(projectRoot, GENERATED_SVELTE_SERVER_HOOKS_PATH);
+  const legacyHooksUserPath = resolve2(projectRoot, "src/hooks.user.ts");
+  const legacyHooksServerUserPath = resolve2(projectRoot, "src/hooks.server.user.ts");
+  const [hooksContents, hooksServerContents, legacyUserContents, legacyServerUserContents] = await Promise.all([
+    readFileIfPresent(hooksPath),
+    readFileIfPresent(hooksServerPath),
+    readFileIfPresent(legacyHooksUserPath),
+    readFileIfPresent(legacyHooksServerUserPath)
+  ]);
+  if (legacyUserContents && (!hooksContents || isManagedPrepareArtifact(hooksContents))) {
+    await writeFileIfChanged(hooksPath, legacyUserContents);
+    await unlinkIfPresent(legacyHooksUserPath);
+  } else if (legacyUserContents && hooksContents === legacyUserContents) {
+    await unlinkIfPresent(legacyHooksUserPath);
+  }
+  if (legacyServerUserContents && (!hooksServerContents || isManagedPrepareArtifact(hooksServerContents))) {
+    await writeFileIfChanged(hooksServerPath, legacyServerUserContents);
+    await unlinkIfPresent(legacyHooksServerUserPath);
+  } else if (legacyServerUserContents && hooksServerContents === legacyServerUserContents) {
+    await unlinkIfPresent(legacyHooksServerUserPath);
+  }
+  const currentHooks = await readFileIfPresent(hooksPath);
+  if (!currentHooks || isManagedPrepareArtifact(currentHooks) || isLegacySvelteTransportHook(currentHooks)) {
+    await writeFileIfChanged(hooksPath, renderSvelteDefaultHooksModule());
+  }
+  const currentServerHooks = await readFileIfPresent(hooksServerPath);
+  if (!currentServerHooks || isManagedPrepareArtifact(currentServerHooks) || isLegacySvelteServerHook(currentServerHooks)) {
+    await writeFileIfChanged(hooksServerPath, renderSvelteDefaultServerHooksModule());
+  }
+  await writeFileIfChanged(generatedHooksPath, renderManagedSvelteHooksModule());
+  await writeFileIfChanged(generatedServerHooksPath, renderManagedSvelteServerHooksModule());
+  await ensureSvelteConfigHooksOverride(projectRoot);
+}
+async function syncManagedFrameworkArtifacts(projectRoot) {
+  let manifest;
+  try {
+    const content = await readFile(resolve2(projectRoot, ".holo-js/framework/project.json"), "utf8");
+    manifest = JSON.parse(content);
+  } catch {
+    return;
+  }
+  if (manifest.framework === "sveltekit") {
+    await ensureSvelteManagedHooks(projectRoot);
+  }
+}
+
+// src/project/registry.ts
 function renderGeneratedModule(exportName, value) {
   return [
     "// Generated by holo prepare. Do not edit.",
@@ -281,6 +594,39 @@ function renderGeneratedModule(exportName, value) {
     ""
   ].join("\n");
 }
+function isGeneratedSchemaTable(value) {
+  return isRecord(value) && value.kind === "table" && typeof value.tableName === "string" && isRecord(value.columns);
+}
+function extractGeneratedSchemaTables(moduleValue) {
+  if (isRecord(moduleValue) && isRecord(moduleValue.tables)) {
+    return Object.values(moduleValue.tables).filter(isGeneratedSchemaTable);
+  }
+  if (isRecord(moduleValue) && isGeneratedSchemaTable(moduleValue.default)) {
+    return [moduleValue.default];
+  }
+  if (isRecord(moduleValue)) {
+    return Object.values(moduleValue).filter(isGeneratedSchemaTable);
+  }
+  return [];
+}
+function getFilesystemErrorCode(error) {
+  return error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : void 0;
+}
+async function renderGeneratedSchemaRuntimeArtifact(projectRoot, schemaEntry) {
+  const schemaPath = resolve3(projectRoot, schemaEntry);
+  try {
+    await access(schemaPath, fsConstants.R_OK);
+  } catch (error) {
+    const code = getFilesystemErrorCode(error);
+    if (code === "ENOENT" || code === "ENOTDIR") {
+      return renderGeneratedSchemaRuntimeModule([]);
+    }
+    throw error;
+  }
+  const moduleValue = await importProjectModule(projectRoot, schemaPath);
+  const tables = extractGeneratedSchemaTables(moduleValue);
+  return renderGeneratedSchemaRuntimeModule(tables);
+}
 function renderGeneratedIndexModule() {
   return [
     "// Generated by holo prepare. Do not edit.",
@@ -288,9 +634,11 @@ function renderGeneratedIndexModule() {
     "/* eslint-disable @typescript-eslint/triple-slash-reference */",
     "",
     '/// <reference path="./broadcast.d.ts" />',
+    '/// <reference path="./auth.d.ts" />',
     '/// <reference path="./authorization/types.d.ts" />',
     '/// <reference path="./config.d.ts" />',
     '/// <reference path="./events.d.ts" />',
+    '/// <reference path="./model-registry.d.ts" />',
     '/// <reference path="./queue.d.ts" />',
     "",
     "import metadata from './metadata'",
@@ -328,6 +676,40 @@ function renderGeneratedIndexModule() {
     ""
   ].join("\n");
 }
+function renderGeneratedModelTypes(models) {
+  const aliases = models.map((entry, index) => {
+    return `type HoloModel${index} = ModelReference<GeneratedSchemaTable<${JSON.stringify(entry.tableName)}>, EmptyScopeMap>`;
+  });
+  const modelTypeImports = aliases.length > 0 ? [
+    "import type { EmptyScopeMap, GeneratedSchemaTable, ModelReference } from '@holo-js/db'",
+    ""
+  ] : [];
+  const registryEntries = models.map((entry, index) => {
+    return `    readonly ${JSON.stringify(entry.name)}: HoloModel${index}`;
+  });
+  const registeredModelsDeclaration = registryEntries.length > 0 ? [
+    "  interface RegisteredModels {",
+    ...registryEntries,
+    "  }"
+  ] : [
+    "  // eslint-disable-next-line @typescript-eslint/no-empty-object-type",
+    "  interface RegisteredModels {}"
+  ];
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "import './schema.generated'",
+    ...modelTypeImports,
+    ...aliases,
+    "",
+    "declare module '@holo-js/db' {",
+    ...registeredModelsDeclaration,
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
 function renderAugmentationInterface(name, members) {
   if (members.length === 0) {
     return [
@@ -398,7 +780,9 @@ function renderGeneratedBroadcastTypes(broadcast, channels) {
 }
 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 manifestImports = hasPresenceChannels ? [
+    "import type { ChannelPresenceMemberFor } from '@holo-js/broadcast'"
+  ] : [];
   const eventLines = registry.broadcast.flatMap((entry, index) => {
     const lines = [
       "    {",
@@ -436,6 +820,30 @@ function renderGeneratedBroadcastManifest(registry) {
     "// Generated by holo prepare. Do not edit.",
     "",
     ...manifestImports,
+    ...manifestImports.length > 0 ? [""] : [],
+    "type GeneratedBroadcastManifestEvent = {",
+    "  readonly name: string",
+    "  readonly channels: readonly {",
+    "    readonly type: 'public' | 'private' | 'presence'",
+    "    readonly pattern: string",
+    "  }[]",
+    "}",
+    "",
+    "type GeneratedBroadcastManifestChannel = {",
+    "  readonly name: string",
+    "  readonly pattern: string",
+    "  readonly type: 'private' | 'presence'",
+    "  readonly params: readonly string[]",
+    "  readonly whispers: readonly string[]",
+    "  readonly member?: Readonly<Record<string, unknown>>",
+    "}",
+    "",
+    "type GeneratedBroadcastManifest = {",
+    "  readonly version: 1",
+    "  readonly generatedAt: string",
+    "  readonly events: readonly GeneratedBroadcastManifestEvent[]",
+    "  readonly channels: readonly GeneratedBroadcastManifestChannel[]",
+    "}",
     "",
     "export const broadcastManifest = {",
     "  version: 1,",
@@ -543,6 +951,37 @@ function renderGeneratedQueueTypes(jobs) {
     ""
   ].join("\n");
 }
+function renderGeneratedAuthTypes(guards) {
+  const members = Object.entries(guards).sort(([left], [right]) => left.localeCompare(right)).filter((entry) => {
+    return entry[1].driver === "session" || entry[1].driver === "token";
+  }).map(([name, guard]) => {
+    return `        readonly ${JSON.stringify(name)}: ${JSON.stringify(guard.driver)}`;
+  });
+  const guardsMember = members.length > 0 ? [
+    "      guards: {",
+    ...members,
+    "      }"
+  ] : [
+    "      guards: Readonly<Record<string, 'session'>>"
+  ];
+  return [
+    "// Generated by holo prepare. Do not edit.",
+    "",
+    "import '@holo-js/auth'",
+    "",
+    "declare global {",
+    "  // eslint-disable-next-line @typescript-eslint/no-namespace",
+    "  namespace HoloAuth {",
+    "    interface TypeRegistry {",
+    ...guardsMember,
+    "    }",
+    "  }",
+    "}",
+    "",
+    "export {}",
+    ""
+  ].join("\n");
+}
 function renderGeneratedAuthorizationRegistry(registry) {
   return [
     "// Generated by holo prepare. Do not edit.",
@@ -585,7 +1024,11 @@ function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationA
   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 usesHoloAuthUser = authorizationPolicies.length > 0 || authorizationAbilities.length > 0 || guardNames.length > 0;
   const imports = [
+    ...typedPolicyEntries.length > 0 ? ["import type { AuthorizationPolicyDefinition as HoloAuthorizationPolicyDefinition } from '@holo-js/authorization/contracts'"] : [],
+    ...typedAbilityEntries.length > 0 ? ["import type { AuthorizationAbilityDefinition as HoloAuthorizationAbilityDefinition } from '@holo-js/authorization/contracts'"] : [],
+    ...usesHoloAuthUser ? ["import type { AuthUser as HoloAuthUser } from '@holo-js/auth'"] : [],
     ...typedPolicyEntries.map((entry, index) => {
       return `import type * as holoAuthorizationPolicyModule${index} from '${relativeImportPath(GENERATED_AUTHORIZATION_TYPES_PATH, entry.sourcePath)}'`;
     }),
@@ -600,7 +1043,7 @@ function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationA
     if (!importName || !entry.exportName) {
       return [
         `    ${JSON.stringify(entry.name)}: {`,
-        "      actor: object",
+        "      actor: HoloAuthUser",
         `      target: object`,
         "      classActions: {",
         ...classActionEntries,
@@ -613,16 +1056,12 @@ function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationA
     }
     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,
-      "      } : {",
+      "      actor: HoloAuthUser",
+      `      target: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends HoloAuthorizationPolicyDefinition<infer _TName, infer TTarget, infer _TClassActions, infer _TRecordActions, infer _TActor> ? TTarget : object`,
+      "      classActions: {",
       ...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,
-      "      } : {",
+      "      recordActions: {",
       ...recordActionEntries,
       "      }",
       "    }"
@@ -631,19 +1070,19 @@ function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationA
   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: HoloAuthUser, 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`,
+      "      actor: HoloAuthUser",
+      `      input: typeof ${importName}[${JSON.stringify(entry.exportName)}] extends HoloAuthorizationAbilityDefinition<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`,
+      "      user: HoloAuthUser",
       "    }"
     ].join("\n");
   });
@@ -663,20 +1102,23 @@ function renderGeneratedAuthorizationTypes(authorizationPolicies, authorizationA
     ""
   ].join("\n");
 }
-function renderGeneratedTsconfig() {
+function renderGeneratedTsconfigForBase(basePath) {
   return `${JSON.stringify({
-    extends: "../../tsconfig.json",
+    extends: basePath,
     include: ["./**/*.ts", "./**/*.d.ts"]
   }, null, 2)}
 `;
 }
+async function resolveGeneratedTsconfigBase(_projectRoot) {
+  return "../../tsconfig.json";
+}
 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 configDir = resolve3(projectRoot, "config");
   const entries = await readdir(configDir, { withFileTypes: true }).catch(() => []);
   const selectedByName = /* @__PURE__ */ new Map();
   for (const entry of entries) {
@@ -701,7 +1143,7 @@ async function collectProjectConfigEntries(projectRoot) {
   }));
 }
 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));
+  const customEntries = entries.filter((entry) => !["app", "database", "redis", "cache", "cors", "storage", "queue", "broadcast", "notifications", "mail", "media", "session", "security", "auth"].includes(entry.configName));
   if (customEntries.length === 0) {
     return [
       "// Generated by holo prepare. Do not edit.",
@@ -733,27 +1175,31 @@ function renderGeneratedConfigTypes(projectRoot, entries) {
     ""
   ].join("\n");
 }
-async function writeFileIfChanged(path, contents) {
+async function writeFileIfChanged2(path, contents) {
   try {
-    if (await readFile(path, "utf8") === contents) {
+    if (await readFile2(path, "utf8") === contents) {
       return;
     }
   } catch {
   }
-  await mkdir(dirname2(path), { recursive: true });
-  await writeFile(path, contents, "utf8");
+  await mkdir2(dirname3(path), { recursive: true });
+  await writeFile2(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());
+  await mkdir2(resolve3(projectRoot, GENERATED_ROOT), { recursive: true });
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_GITIGNORE_PATH), "*\n!.gitignore\n");
 }
 async function writeGeneratedProjectRegistry(projectRoot, registry) {
   await ensureGeneratedRegistryOwnership(projectRoot);
+  const tsconfigPath = resolve3(projectRoot, GENERATED_TSCONFIG_PATH);
+  await writeFileIfChanged2(
+    tsconfigPath,
+    renderGeneratedTsconfigForBase(await resolveGeneratedTsconfigBase(projectRoot))
+  );
   const loadedConfig = await loadConfigDirectory(projectRoot);
   const configEntries = await collectProjectConfigEntries(projectRoot);
   const existingRegistry = await loadGeneratedProjectRegistry(projectRoot);
@@ -761,34 +1207,41 @@ async function writeGeneratedProjectRegistry(projectRoot, registry) {
     ...registry,
     generatedAt: existingRegistry.generatedAt
   } : registry;
-  await writeFileIfChanged(resolve2(projectRoot, GENERATED_METADATA_PATH), renderGeneratedModule("metadata", {
+  await writeFileIfChanged2(resolve3(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(
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_MODELS_PATH), renderGeneratedModule("models", nextRegistry.models));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_MODEL_TYPES_PATH), renderGeneratedModelTypes(nextRegistry.models));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_MIGRATIONS_PATH), renderGeneratedModule("migrations", nextRegistry.migrations));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_SEEDERS_PATH), renderGeneratedModule("seeders", nextRegistry.seeders));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_COMMANDS_PATH), renderGeneratedModule("commands", nextRegistry.commands));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_JOBS_PATH), renderGeneratedModule("jobs", nextRegistry.jobs));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_EVENTS_PATH), renderGeneratedModule("events", nextRegistry.events));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_LISTENERS_PATH), renderGeneratedModule("listeners", nextRegistry.listeners));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_BROADCAST_PATH), renderGeneratedModule("broadcast", nextRegistry.broadcast));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_CHANNELS_PATH), renderGeneratedModule("channels", nextRegistry.channels));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_BROADCAST_MANIFEST_PATH), renderGeneratedBroadcastManifest(nextRegistry));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_BROADCAST_TYPES_PATH), renderGeneratedBroadcastTypes(nextRegistry.broadcast, nextRegistry.channels));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_AUTH_TYPES_PATH), renderGeneratedAuthTypes(loadedConfig?.auth?.guards ?? {}));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_CONFIG_TYPES_PATH), renderGeneratedConfigTypes(projectRoot, configEntries));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_EVENT_TYPES_PATH), renderGeneratedEventTypes(nextRegistry.events, nextRegistry.listeners));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_QUEUE_TYPES_PATH), renderGeneratedQueueTypes(nextRegistry.jobs));
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_AUTHORIZATION_REGISTRY_PATH), renderGeneratedAuthorizationRegistry(nextRegistry));
+  await writeFileIfChanged2(resolve3(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)}
+  await syncManagedFrameworkArtifacts(projectRoot);
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_INDEX_PATH), renderGeneratedIndexModule());
+  await writeFileIfChanged2(resolve3(projectRoot, GENERATED_REGISTRY_JSON_PATH), `${JSON.stringify(nextRegistry, null, 2)}
 `);
+  await writeFileIfChanged2(
+    resolve3(projectRoot, GENERATED_SCHEMA_RUNTIME_PATH),
+    await renderGeneratedSchemaRuntimeArtifact(projectRoot, nextRegistry.paths.generatedSchema)
+  );
 }
 function isGeneratedProjectRegistry(value) {
   if (isRecord(value) && isRecord(value.paths)) {
@@ -810,16 +1263,24 @@ function isGeneratedProjectRegistry(value) {
   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 filePath = resolve3(projectRoot, GENERATED_REGISTRY_JSON_PATH);
+  const contents = await readFile2(filePath, "utf8").catch(() => void 0);
+  if (contents) {
+    try {
+      const parsed = JSON.parse(contents);
+      if (isGeneratedProjectRegistry(parsed)) {
+        return parsed;
+      }
+    } catch {
+    }
   }
-  const moduleValue = await importProjectModule(projectRoot, filePath);
-  if (isRecord(moduleValue) && isGeneratedProjectRegistry(moduleValue.default)) {
-    return moduleValue.default;
+  const generatedIndexPath = resolve3(projectRoot, GENERATED_INDEX_PATH);
+  const generatedModule = await importProjectModule(projectRoot, generatedIndexPath).catch(() => void 0);
+  if (isRecord(generatedModule) && isGeneratedProjectRegistry(generatedModule.registry)) {
+    return generatedModule.registry;
   }
-  if (isRecord(moduleValue) && isGeneratedProjectRegistry(moduleValue.registry)) {
-    return moduleValue.registry;
+  if (isRecord(generatedModule) && isGeneratedProjectRegistry(generatedModule.default)) {
+    return generatedModule.default;
   }
   return void 0;
 }
@@ -844,6 +1305,7 @@ export {
   renderMarkdownMailTemplate,
   resolveNameInfo,
   resolveArtifactPath,
+  renderGeneratedModelTypes,
   writeGeneratedProjectRegistry,
   loadGeneratedProjectRegistry
 };