@vibesdotdev/kit 0.0.0-stage → 1.0.0-rc.3

package/dist/lib/icons/data.js

@@ -0,0 +1,31 @@
+/**
+ * Static icon data + lookup.
+ *
+ * Uses a generated subset of Iconify collections instead of bundling every icon
+ * from every supported collection into each app's client graph.
+ */
+import { generatedIconCollections } from "./data.generated.js";
+/** The generated collections by prefix; a prefix that is not generated is absent. */
+const collections = generatedIconCollections;
+/**
+ * Look up an icon by its "prefix:name" string (e.g. "lucide:home", "mdi:account").
+ * Returns the raw Iconify entry (body + dimensions) or null if not found.
+ */
+export function getIconData(icon) {
+    if (!icon)
+        return null;
+    const [prefix, name] = icon.split(':', 2);
+    if (!prefix || !name)
+        return null;
+    const collection = collections[prefix];
+    if (!collection)
+        return null;
+    const entry = collection.icons[name];
+    return entry ?? null;
+}
+/**
+ * Returns the list of registered collection prefixes (useful for debugging / tooling).
+ */
+export function getRegisteredPrefixes() {
+    return Object.keys(collections);
+}

package/dist/lib/icons/registry.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Static Iconify icon registry.
+ *
+ * Registers the generated icon subset used by the repo so any direct
+ * @iconify/svelte usage can resolve locally without loading full icon sets.
+ *
+ * This is the required pattern for strict CSP.
+ *
+ * ## Recommended usage
+ *
+ * **Use the kit's own SSR-friendly Icon component** (not the raw @iconify/svelte one):
+ *
+ *   import { Icon } from '../index.ts/components';
+ *   <Icon icon="lucide:home" class="h-5 w-5" />
+ *
+ * This component renders real inline <svg> during SSR and on the client.
+ *
+ * The registry import is available for advanced cases or legacy code that
+ * directly renders @iconify/svelte components:
+ *
+ *   import '../index.ts/icons/registry';
+ *
+ * You can still call `registerIcons()` or `addCollection(...)` to extend.
+ *
+ * Additional collections can be added by apps after importing:
+ *
+ *   import { registerIcons, addCollection } from '../index.ts/icons/registry';
+ *   import mySet from '@iconify-json/whatever/icons.json' with { type: 'json' };
+ *   registerIcons();
+ *   addCollection(mySet);
+ */
+import { addCollection } from '@iconify/svelte';
+import { getIconData, getRegisteredPrefixes } from './data.ts';
+export { getIconData, getRegisteredPrefixes };
+export declare function registerIcons(): void;
+export { addCollection };

package/dist/lib/icons/registry.js

@@ -0,0 +1,48 @@
+/**
+ * Static Iconify icon registry.
+ *
+ * Registers the generated icon subset used by the repo so any direct
+ * @iconify/svelte usage can resolve locally without loading full icon sets.
+ *
+ * This is the required pattern for strict CSP.
+ *
+ * ## Recommended usage
+ *
+ * **Use the kit's own SSR-friendly Icon component** (not the raw @iconify/svelte one):
+ *
+ *   import { Icon } from '../index.ts/components';
+ *   <Icon icon="lucide:home" class="h-5 w-5" />
+ *
+ * This component renders real inline <svg> during SSR and on the client.
+ *
+ * The registry import is available for advanced cases or legacy code that
+ * directly renders @iconify/svelte components:
+ *
+ *   import '../index.ts/icons/registry';
+ *
+ * You can still call `registerIcons()` or `addCollection(...)` to extend.
+ *
+ * Additional collections can be added by apps after importing:
+ *
+ *   import { registerIcons, addCollection } from '../index.ts/icons/registry';
+ *   import mySet from '@iconify-json/whatever/icons.json' with { type: 'json' };
+ *   registerIcons();
+ *   addCollection(mySet);
+ */
+import { addCollection } from '@iconify/svelte';
+import { generatedIconCollections } from "./data.generated.js";
+import { getIconData, getRegisteredPrefixes } from "./data.js";
+// Re-export the data lookup for the custom SSR Icon component and for advanced use.
+export { getIconData, getRegisteredPrefixes };
+let registered = false;
+export function registerIcons() {
+    if (registered)
+        return;
+    registered = true;
+    for (const collection of Object.values(generatedIconCollections)) {
+        addCollection(collection);
+    }
+}
+// Auto-register on import (the recommended usage from hooks files)
+registerIcons();
+export { addCollection }; // for apps that want to extend with more collections

package/dist/lib/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @vibesdotdev/kit — Main entry point
+ *
+ * Import boundaries:
+ *   Components: import from '@vibesdotdev/kit/components'
+ *   Server:     import from '@vibesdotdev/kit/server'
+ *   Client:     import from '@vibesdotdev/kit/client'
+ *
+ * This barrel exports only environment-neutral utilities. Its complete import
+ * closure must run in every supported runtime. Svelte, SvelteKit, Node, Bun,
+ * filesystem, and other surface/environment bindings belong in explicit
+ * subpath exports.
+ */
+export { cn, debounce, type WithElementRef, type WithoutChildren, type WithoutChildrenOrChild } from './utils.js';
+export * from './pagination/index.js';
+export * from './errors.ts';

package/dist/lib/index.js

@@ -0,0 +1,18 @@
+/**
+ * @vibesdotdev/kit — Main entry point
+ *
+ * Import boundaries:
+ *   Components: import from '@vibesdotdev/kit/components'
+ *   Server:     import from '@vibesdotdev/kit/server'
+ *   Client:     import from '@vibesdotdev/kit/client'
+ *
+ * This barrel exports only environment-neutral utilities. Its complete import
+ * closure must run in every supported runtime. Svelte, SvelteKit, Node, Bun,
+ * filesystem, and other surface/environment bindings belong in explicit
+ * subpath exports.
+ */
+// Shared utilities (client-safe)
+export { cn, debounce } from './utils.js';
+export * from './pagination/index.js';
+// Error classes use only standard JavaScript and Web APIs.
+export * from "./errors.js";

package/dist/lib/instance/creators.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Kit method creators
+ *
+ * Factory functions that create the kit API methods
+ * Separated from main instance file to keep it under 200 lines
+ */
+import type { VibesKitConfig } from '../types/kit';
+import type { VibesPlugin } from '../types/plugin';
+import type { Handle, HandleServerError } from '@sveltejs/kit';
+import { vibesLayoutLoad, vibesLayoutAuth, vibesLayoutFeature } from '../server/layout/load';
+import { vibesPageLoad, vibesAction } from '../server/page/load';
+import { vibesLayoutMount } from '../client/layout/mount';
+import { vibesPage } from '../client/page/enhance';
+import { vibesGuard, createVibesGateAction } from '../client/guard/gate';
+export declare function createHandleMethod(config: VibesKitConfig, plugins: Map<string, VibesPlugin>): (middleware?: Handle[], overrides?: Partial<VibesKitConfig>) => Handle;
+export declare function createErrorHandlerMethod(config: VibesKitConfig): () => HandleServerError;
+export declare function createEndpointMethods(): {
+    GET: <TConfig extends import("../server/endpoint/types").VibesConfig, T = unknown>(config: TConfig, handler: import("../server/endpoint/types").VibesHandler<T, TConfig["validation"]>) => import("@sveltejs/kit").RequestHandler;
+    POST: <TConfig extends import("../server/endpoint/types").VibesConfig, T = unknown>(config: TConfig, handler: import("../server/endpoint/types").VibesHandler<T, TConfig["validation"]>) => import("@sveltejs/kit").RequestHandler;
+    PUT: <TConfig extends import("../server/endpoint/types").VibesConfig, T = unknown>(config: TConfig, handler: import("../server/endpoint/types").VibesHandler<T, TConfig["validation"]>) => import("@sveltejs/kit").RequestHandler;
+    PATCH: <TConfig extends import("../server/endpoint/types").VibesConfig, T = unknown>(config: TConfig, handler: import("../server/endpoint/types").VibesHandler<T, TConfig["validation"]>) => import("@sveltejs/kit").RequestHandler;
+    DELETE: <TConfig extends import("../server/endpoint/types").VibesConfig, T = unknown>(config: TConfig, handler: import("../server/endpoint/types").VibesHandler<T, TConfig["validation"]>) => import("@sveltejs/kit").RequestHandler;
+    request: (method: string, path: string, config: import("../server/endpoint/types").VibesConfig, handler: import("../server/endpoint/types").VibesHandler) => import("@sveltejs/kit").RequestHandler;
+};
+export declare function createServerLayoutMethods(): {
+    load: typeof vibesLayoutLoad;
+    auth: typeof vibesLayoutAuth;
+    feature: typeof vibesLayoutFeature;
+};
+export declare function createServerPageMethods(): {
+    load: typeof vibesPageLoad;
+    action: typeof vibesAction;
+};
+export declare function createClientLayoutMethods(): {
+    mount: typeof vibesLayoutMount;
+    init: typeof vibesLayoutMount;
+};
+export declare function createClientPageMethods(): {
+    enhance: typeof vibesPage;
+};
+export declare function createGuardMethod(): typeof vibesGuard;
+export declare function createGateActionMethod(): typeof createVibesGateAction;

package/dist/lib/instance/creators.js

@@ -0,0 +1,120 @@
+/**
+ * Kit method creators
+ *
+ * Factory functions that create the kit API methods
+ * Separated from main instance file to keep it under 200 lines
+ */
+import { getVibesKit } from '../instance';
+import { createVibesHandle } from '../server/hooks/handle';
+import { createVibesErrorHandler } from '../server/hooks/errors';
+import { DEV } from 'esm-env';
+import { vibesGET, vibesPOST, vibesPUT, vibesPATCH, vibesDELETE, vibesEndpoint } from '../server/endpoint/wrapper';
+import { vibesLayoutLoad, vibesLayoutAuth, vibesLayoutFeature } from '../server/layout/load';
+import { vibesPageLoad, vibesAction } from '../server/page/load';
+import { vibesLayoutMount, vibesLayoutInit } from '../client/layout/mount';
+import { vibesPage } from '../client/page/enhance';
+import { vibesGuard, createVibesGateAction } from '../client/guard/gate';
+export function createHandleMethod(config, plugins) {
+    return (middleware, overrides) => {
+        const merged = { ...config, ...overrides };
+        const security = merged.security;
+        const headers = security?.headers ??
+            (security
+                ? {
+                    frameOptions: security.frameOptions,
+                    hsts: security.hsts,
+                    noSniff: security.noSniff,
+                    xssProtection: security.xssProtection,
+                    csp: security.csp
+                }
+                : undefined);
+        const handleConfig = {
+            auth: merged.auth,
+            security: {
+                patterns: security?.patterns ?? [],
+                headers
+            },
+            context: merged.context,
+            maintenance: merged.maintenance,
+            activity: merged.activity,
+            userStatus: merged.userStatus,
+            referral: merged.referral,
+            isDev: merged.isDev,
+            developmentMode: merged.developmentMode
+        };
+        return createVibesHandle(handleConfig, plugins, middleware);
+    };
+}
+export function createErrorHandlerMethod(config) {
+    const isDev = config.isDev ?? DEV;
+    const resolveDevelopmentModeEnabled = () => config.developmentMode?.resolveEnabled?.() ?? config.developmentMode?.enabled ?? true;
+    const resolveDevelopmentModeWarning = () => config.developmentMode?.resolveWarningEnabled?.() ?? true;
+    return () => {
+        const kit = getVibesKit();
+        const logger = kit.config.services?.logger;
+        const handler = async (input) => {
+            const developmentModeEnabled = resolveDevelopmentModeEnabled();
+            const baseHandler = createVibesErrorHandler({
+                environment: isDev ? 'development' : 'production',
+                showDetailedErrors: developmentModeEnabled,
+                showStackTraces: developmentModeEnabled,
+                logSystemError: async (error, context) => {
+                    const { serializedError, ...restContext } = context;
+                    logger?.error('Unhandled SvelteKit error', error, {
+                        ...restContext,
+                        context: 'sveltekit-error',
+                        error: serializedError
+                    });
+                }
+            });
+            const baseError = await baseHandler(input);
+            const showDevelopmentModeWarning = !isDev && developmentModeEnabled && resolveDevelopmentModeWarning();
+            return {
+                ...baseError,
+                developmentModeEnabled,
+                showDevelopmentModeWarning
+            };
+        };
+        return handler;
+    };
+}
+export function createEndpointMethods() {
+    return {
+        GET: vibesGET,
+        POST: vibesPOST,
+        PUT: vibesPUT,
+        PATCH: vibesPATCH,
+        DELETE: vibesDELETE,
+        request: vibesEndpoint
+    };
+}
+export function createServerLayoutMethods() {
+    return {
+        load: vibesLayoutLoad,
+        auth: vibesLayoutAuth,
+        feature: vibesLayoutFeature
+    };
+}
+export function createServerPageMethods() {
+    return {
+        load: vibesPageLoad,
+        action: vibesAction
+    };
+}
+export function createClientLayoutMethods() {
+    return {
+        mount: vibesLayoutMount,
+        init: vibesLayoutInit
+    };
+}
+export function createClientPageMethods() {
+    return {
+        enhance: vibesPage
+    };
+}
+export function createGuardMethod() {
+    return vibesGuard;
+}
+export function createGateActionMethod() {
+    return createVibesGateAction;
+}

package/dist/lib/instance.d.ts

@@ -0,0 +1,45 @@
+/**
+ * VibesKit singleton instance
+ *
+ * Creates and manages the global vibeskit instance.
+ * Only one kit instance should exist per application.
+ *
+ * D8 note: the process-wide slot holds ONLY static, app-declared kit config
+ * (handles, security patterns, plugin registry, injected logger) so every
+ * bundled entrypoint of one app shares it (`kit-slot.ts`). Every
+ * runtime-derived value (origins, credentials, bindings, caches) is resolved
+ * per request through `event.locals.runtime` (`VibesKitRuntimePort`) and any
+ * cache is keyed per runtime port; none is stored here.
+ */
+import type { VibesKit, VibesKitConfig } from './types/kit';
+/**
+ * Create and initialize the VibesKit singleton
+ *
+ * @param config - Kit configuration
+ * @returns Initialized kit instance
+ *
+ * @example
+ * ```typescript
+ * // src/lib/app/vibeskit.ts
+ * export const kit = createVibesKit({
+ *   auth: { ... },
+ *   security: { ... },
+ *   verification: {
+ *     acme: {
+ *       enabled: true,
+ *       getChallenge: async (token) => await getACMEChallenge(token)
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export declare function createVibesKit(config: VibesKitConfig): VibesKit;
+/**
+ * Get the global kit instance
+ * Throws if kit hasn't been initialized
+ */
+export declare function getVibesKit(): VibesKit;
+/**
+ * Check if kit is initialized
+ */
+export declare function hasVibesKit(): boolean;

package/dist/lib/instance.js

@@ -0,0 +1,159 @@
+/**
+ * VibesKit singleton instance
+ *
+ * Creates and manages the global vibeskit instance.
+ * Only one kit instance should exist per application.
+ *
+ * D8 note: the process-wide slot holds ONLY static, app-declared kit config
+ * (handles, security patterns, plugin registry, injected logger) so every
+ * bundled entrypoint of one app shares it (`kit-slot.ts`). Every
+ * runtime-derived value (origins, credentials, bindings, caches) is resolved
+ * per request through `event.locals.runtime` (`VibesKitRuntimePort`) and any
+ * cache is keyed per runtime port; none is stored here.
+ */
+import { PluginSettingsSchema } from './types/plugin';
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { createACMEPlugin } from './plugins/acme/index';
+import { createHostnamePlugin } from './plugins/hostname/index';
+import { createHandleMethod, createErrorHandlerMethod, createEndpointMethods, createServerLayoutMethods, createServerPageMethods, createClientLayoutMethods, createClientPageMethods, createGuardMethod, createGateActionMethod } from './instance/creators';
+import { planNormalizer } from './billing/plan-normalizer';
+import { kitLoggerFrom } from './kit-logger';
+import { kitSlot } from './kit-slot';
+import { DEV } from 'esm-env';
+/**
+ * Create and initialize the VibesKit singleton
+ *
+ * @param config - Kit configuration
+ * @returns Initialized kit instance
+ *
+ * @example
+ * ```typescript
+ * // src/lib/app/vibeskit.ts
+ * export const kit = createVibesKit({
+ *   auth: { ... },
+ *   security: { ... },
+ *   verification: {
+ *     acme: {
+ *       enabled: true,
+ *       getChallenge: async (token) => await getACMEChallenge(token)
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export function createVibesKit(config) {
+    // The singleton does not exist yet: log through the logger on the config being created.
+    const logger = kitLoggerFrom(() => config.services?.logger, 'vibeskit-instance');
+    const slot = kitSlot();
+    if (slot.kit) {
+        if (DEV) {
+            logger.warn('Kit already initialized. Returning existing instance.');
+        }
+        return slot.kit;
+    }
+    // Configure the planNormalizer singleton with the canonical tier slugs
+    // owned by @vibesdotdev/account. Apps that import normalizePlanSlug from
+    // `@vibesdotdev/kit/server` (e.g. `$lib/vibeskit`) otherwise hit
+    // "PlanNormalizer not configured" the first time a route gates on plan
+    // tier. Configure once per app at kit-creation time so individual
+    // app/vibeskit.ts files do not have to remember.
+    planNormalizer.configure({
+        canonicalTiers: config.billing?.canonicalTiers ?? [
+            'free',
+            'plus',
+            'pro',
+            'ultra',
+            'team-standard',
+            'team-plus',
+            'team-ultra',
+            'enterprise'
+        ]
+    });
+    const plugins = new Map();
+    const kit = {
+        config,
+        _plugins: plugins,
+        server: {
+            hooks: {
+                handle: createHandleMethod(config, plugins),
+                errorHandler: createErrorHandlerMethod(config)
+            },
+            endpoint: createEndpointMethods(),
+            layout: createServerLayoutMethods(),
+            page: createServerPageMethods()
+        },
+        client: {
+            layout: createClientLayoutMethods(),
+            page: createClientPageMethods(),
+            guard: createGuardMethod(),
+            gateAction: createGateActionMethod()
+        },
+        plugin: {
+            get: (name) => plugins.get(name)?.api,
+            has: (name) => plugins.has(name),
+            list: () => Array.from(plugins.values())
+        },
+        _registerPlugin: (plugin, pluginConfig) => {
+            if (plugins.has(plugin.name)) {
+                throw new Error(`[vibeskit] Plugin "${plugin.name}" is already registered`);
+            }
+            // A plugin's settings are parsed once, here: what onRegister receives is the parsed copy.
+            const settings = PluginSettingsSchema.safeParse(pluginConfig ?? {});
+            if (!settings.success) {
+                throw new CapabilityError(`[vibeskit] Plugin "${plugin.name}" settings must be an object`, 'INVALID_INPUT', {
+                    reason: 'kit-plugin-settings-invalid',
+                    cause: settings.error
+                });
+            }
+            plugins.set(plugin.name, plugin);
+            // Call onRegister lifecycle hook
+            if (plugin.onRegister) {
+                plugin.onRegister({
+                    config: settings.data,
+                    kitConfig: config,
+                    registerPlugin: (p) => kit._registerPlugin(p)
+                });
+            }
+            if (DEV) {
+                logger.info('Registered plugin', { name: plugin.name, version: plugin.version });
+            }
+        }
+    };
+    // Register built-in plugins from config
+    if (config.plugins) {
+        for (const pluginConfig of config.plugins) {
+            if (pluginConfig.enabled !== false) {
+                kit._registerPlugin(pluginConfig.plugin, pluginConfig.config);
+            }
+        }
+    }
+    // Register convenience plugins (ACME, hostname). Each plugin's registration
+    // settings are its own typed config, carried field for field.
+    if (config.verification?.acme) {
+        const acmePlugin = createACMEPlugin(config.verification.acme);
+        kit._registerPlugin(acmePlugin, { ...config.verification.acme });
+    }
+    if (config.hostname) {
+        const hostnamePlugin = createHostnamePlugin(config.hostname);
+        kit._registerPlugin(hostnamePlugin, { ...config.hostname });
+    }
+    slot.kit = kit;
+    return kit;
+}
+/**
+ * Get the global kit instance
+ * Throws if kit hasn't been initialized
+ */
+export function getVibesKit() {
+    const kit = kitSlot().kit;
+    if (!kit) {
+        throw new Error('[vibeskit] Kit not initialized. Call createVibesKit() in src/lib/app/vibeskit.ts first.');
+    }
+    return kit;
+}
+/**
+ * Check if kit is initialized
+ */
+export function hasVibesKit() {
+    return kitSlot().kit !== null;
+}

package/dist/lib/kit-logger.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Kit logger seam.
+ *
+ * Kit imports no logging package. The host injects a logger through
+ * `createVibesKit({ services: { logger } })`; apps pass a factory
+ * (`logger: (runtime) => getLogger('vibeskit', runtime)`) to `createAppVibesKit`,
+ * which binds it to the first runtime the kit is handed. `kitLogger(context)`
+ * resolves that injected logger on EVERY call, so a module-level
+ * `const logger = kitLogger('x')` is load-safe. It is a documented no-op when
+ * the kit is not yet initialized or no logger was injected: kit has no
+ * logging owner of its own to fall back to.
+ *
+ * Every entry carries `context` in its metadata (the role the framework
+ * `.child({ context })` used to play).
+ */
+import type { Logger, LoggerMeta } from './types/kit';
+/**
+ * Accepts the shapes kit call sites use: `(message, error, meta)` and
+ * `(message, { error, ...meta })`. A non-Error thrown value is normalized to an
+ * `Error` whose message is `String(value)`.
+ */
+export interface KitLogger {
+    debug(message: string, meta?: LoggerMeta): void;
+    info(message: string, meta?: LoggerMeta): void;
+    warn(message: string, meta?: LoggerMeta): void;
+    error<ErrorOrMeta>(message: string, errorOrMeta?: ErrorOrMeta, meta?: LoggerMeta): void;
+}
+/**
+ * Build a kit logger over an arbitrary logger source. `instance.ts` uses this
+ * with the config being created (the singleton does not exist yet).
+ */
+export declare function kitLoggerFrom(source: () => Logger | undefined, context: string): KitLogger;
+/** Logger bound to the initialized kit's injected `services.logger`. */
+export declare function kitLogger(context: string): KitLogger;

package/dist/lib/kit-logger.js

@@ -0,0 +1,55 @@
+/**
+ * Kit logger seam.
+ *
+ * Kit imports no logging package. The host injects a logger through
+ * `createVibesKit({ services: { logger } })`; apps pass a factory
+ * (`logger: (runtime) => getLogger('vibeskit', runtime)`) to `createAppVibesKit`,
+ * which binds it to the first runtime the kit is handed. `kitLogger(context)`
+ * resolves that injected logger on EVERY call, so a module-level
+ * `const logger = kitLogger('x')` is load-safe. It is a documented no-op when
+ * the kit is not yet initialized or no logger was injected: kit has no
+ * logging owner of its own to fall back to.
+ *
+ * Every entry carries `context` in its metadata (the role the framework
+ * `.child({ context })` used to play).
+ */
+import { kitSlot } from "./kit-slot.js";
+function isMetaRecord(value) {
+    return typeof value === 'object' && value !== null && !(value instanceof Error);
+}
+/**
+ * Build a kit logger over an arbitrary logger source. `instance.ts` uses this
+ * with the config being created (the singleton does not exist yet).
+ */
+export function kitLoggerFrom(source, context) {
+    return {
+        debug: (message, meta) => source()?.debug(message, { ...meta, context }),
+        info: (message, meta) => source()?.info(message, { ...meta, context }),
+        warn: (message, meta) => source()?.warn(message, { ...meta, context }),
+        error: (message, errorOrMeta, meta) => {
+            const target = source();
+            if (!target)
+                return;
+            if (isMetaRecord(errorOrMeta)) {
+                const { error, ...rest } = errorOrMeta;
+                const err = error instanceof Error
+                    ? error
+                    : error === undefined
+                        ? undefined
+                        : new Error(String(error));
+                target.error(message, err, { ...rest, ...meta, context });
+                return;
+            }
+            const err = errorOrMeta instanceof Error
+                ? errorOrMeta
+                : errorOrMeta === undefined
+                    ? undefined
+                    : new Error(String(errorOrMeta));
+            target.error(message, err, { ...meta, context });
+        }
+    };
+}
+/** Logger bound to the initialized kit's injected `services.logger`. */
+export function kitLogger(context) {
+    return kitLoggerFrom(() => kitSlot().kit?.config.services?.logger, context);
+}

package/dist/lib/kit-slot.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Process-global slot holding the initialized kit singleton. Split from
+ * `instance.ts` so leaf modules (the kit logger) can read the initialized kit
+ * without importing the instance module (which imports them).
+ *
+ * Several apps import both `@vibesdotdev/kit/server` and deeper server
+ * subpaths; bundlers may materialize those as distinct modules, so the
+ * instance lives on `globalThis` and every entrypoint shares one kit.
+ */
+import type { VibesKit } from './types/kit';
+declare global {
+    var __vibesdotdevKitInstance: {
+        kit: VibesKit | null;
+    } | undefined;
+}
+export declare function kitSlot(): {
+    kit: VibesKit | null;
+};

package/dist/lib/kit-slot.js

@@ -0,0 +1,13 @@
+/**
+ * Process-global slot holding the initialized kit singleton. Split from
+ * `instance.ts` so leaf modules (the kit logger) can read the initialized kit
+ * without importing the instance module (which imports them).
+ *
+ * Several apps import both `@vibesdotdev/kit/server` and deeper server
+ * subpaths; bundlers may materialize those as distinct modules, so the
+ * instance lives on `globalThis` and every entrypoint shares one kit.
+ */
+export function kitSlot() {
+    globalThis.__vibesdotdevKitInstance ??= { kit: null };
+    return globalThis.__vibesdotdevKitInstance;
+}

package/dist/lib/pagination/http.d.ts

@@ -0,0 +1,22 @@
+import type { PaginationHeaderFallback, PaginationMeta } from './schemas/common.ts';
+/**
+ * Pagination headers shared by endpoint helpers and typed HTTP clients.
+ *
+ * Collection bodies stay canonical (`{ results }`). Metadata travels in
+ * headers so storage/cloud-api consumers do not need a second wire envelope.
+ */
+export declare const PAGINATION_HEADERS: {
+    readonly page: "x-page";
+    readonly pageSize: "x-per-page";
+    readonly total: "x-total-count";
+    readonly totalPages: "x-total-pages";
+    readonly link: "link";
+};
+type HeaderReader = Pick<Headers, 'get'>;
+/**
+ * Read a paginated collection response without coupling the client to a custom
+ * JSON envelope. Missing headers degrade to the supplied page and result count,
+ * which keeps rolling deploys compatible.
+ */
+export declare function readPaginationHeaders(headers: HeaderReader, fallback: PaginationHeaderFallback): PaginationMeta;
+export {};