@aphexcms/cms-core 0.1.8 → 0.1.10

package/dist/engine.js

@@ -0,0 +1,66 @@
+export class CMSEngine {
+    db;
+    config;
+    constructor(config, dbAdapter) {
+        this.config = config;
+        this.db = dbAdapter;
+    }
+    // Update config dynamically (for schema hot-reloading)
+    updateConfig(newConfig) {
+        this.config = newConfig;
+        console.log('🔄 CMS config updated:', {
+            schemaTypes: newConfig.schemaTypes.length,
+            documents: newConfig.schemaTypes.filter((t) => t.type === 'document').length,
+            objects: newConfig.schemaTypes.filter((t) => t.type === 'object').length
+        });
+    }
+    // Initialize CMS - register schema types in database
+    async initialize() {
+        console.log('🚀 Initializing CMS...');
+        // Get existing schemas from database
+        const existingSchemas = await this.db.listSchemas();
+        const existingNames = new Set(existingSchemas.map((s) => s.name));
+        const currentNames = new Set(this.config.schemaTypes.map((s) => s.name));
+        // Delete schemas that are no longer in config
+        for (const existingName of existingNames) {
+            if (!currentNames.has(existingName)) {
+                await this.db.deleteSchemaType(existingName);
+            }
+        }
+        // Register all schema types (updates if exists, creates if new)
+        for (const schemaType of this.config.schemaTypes) {
+            await this.db.registerSchemaType(schemaType);
+        }
+        console.log('✅ CMS initialized successfully');
+    }
+    // Schema Type utility methods
+    async getSchemaType(name) {
+        return this.db.getSchemaType(name);
+    }
+    async listSchemas() {
+        return this.db.listSchemas();
+    }
+    getSchemaTypeByName(name) {
+        return this.config.schemaTypes.find((s) => s.name === name) || null;
+    }
+    async listDocumentTypes() {
+        return this.db.listDocumentTypes();
+    }
+    async listObjectTypes() {
+        return this.db.listObjectTypes();
+    }
+}
+// Global CMS instance
+let cmsInstance = null;
+export function createCMS(config, dbAdapter) {
+    if (!cmsInstance) {
+        cmsInstance = new CMSEngine(config, dbAdapter);
+    }
+    return cmsInstance;
+}
+export function getCMS() {
+    if (!cmsInstance) {
+        throw new Error('CMS not initialized. Call createCMS() first.');
+    }
+    return cmsInstance;
+}

package/dist/field-validation/rule.d.ts

@@ -0,0 +1,51 @@
+export interface ValidationMarker {
+    level: 'error' | 'warning' | 'info';
+    message: string;
+    path?: string[];
+}
+export interface ValidationContext {
+    document?: any;
+    parent?: any;
+    path?: string[];
+}
+export interface CustomValidator<T = unknown> {
+    (value: T, context: ValidationContext): ValidationMarker[] | string | boolean | Promise<ValidationMarker[] | string | boolean>;
+}
+export interface FieldReference {
+    __fieldReference: true;
+    path: string | string[];
+}
+export declare class Rule {
+    private _required;
+    private _rules;
+    private _level;
+    private _message?;
+    static FIELD_REF: symbol;
+    static valueOfField(path: string | string[]): FieldReference;
+    valueOfField(path: string | string[]): FieldReference;
+    required(): Rule;
+    optional(): Rule;
+    min(len: number | string | FieldReference): Rule;
+    max(len: number | string | FieldReference): Rule;
+    length(len: number | FieldReference): Rule;
+    email(): Rule;
+    uri(options?: {
+        scheme?: RegExp[];
+        allowRelative?: boolean;
+    }): Rule;
+    regex(pattern: RegExp, name?: string): Rule;
+    positive(): Rule;
+    negative(): Rule;
+    integer(): Rule;
+    greaterThan(num: number | FieldReference): Rule;
+    lessThan(num: number | FieldReference): Rule;
+    custom<T = unknown>(fn: CustomValidator<T>): Rule;
+    error(message?: string): Rule;
+    warning(message?: string): Rule;
+    info(message?: string): Rule;
+    clone(): Rule;
+    validate(value: unknown, context?: ValidationContext): Promise<ValidationMarker[]>;
+    private validateRule;
+    isRequired(): boolean;
+}
+//# sourceMappingURL=rule.d.ts.map

package/dist/field-validation/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../src/lib/field-validation/rule.ts"],"names":[],"mappings":"AACA,MAAM,WAAW,gBAAgB;IAChC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,iBAAiB;IAEjC,QAAQ,CAAC,EAAE,GAAG,CAAC;IAEf,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,MAAM,WAAW,eAAe,CAAC,CAAC,GAAG,OAAO;IAC3C,CACC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,iBAAiB,GACxB,gBAAgB,EAAE,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,gBAAgB,EAAE,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC;CAC1F;AAED,MAAM,WAAW,cAAc;IAC9B,gBAAgB,EAAE,IAAI,CAAC;IACvB,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACxB;AAED,qBAAa,IAAI;IAChB,OAAO,CAAC,SAAS,CAAkB;IAEnC,OAAO,CAAC,MAAM,CAAmE;IACjF,OAAO,CAAC,MAAM,CAAyC;IACvD,OAAO,CAAC,QAAQ,CAAC,CAAS;IAE1B,MAAM,CAAC,SAAS,SAA4B;IAE5C,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,cAAc;IAO5D,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,cAAc;IAIrD,QAAQ,IAAI,IAAI;IAMhB,QAAQ,IAAI,IAAI;IAMhB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,IAAI;IAMhD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,cAAc,GAAG,IAAI;IAMhD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAM1C,KAAK,IAAI,IAAI;IAMb,GAAG,CAAC,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,IAAI;IAMnE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,IAAI;IAM3C,QAAQ,IAAI,IAAI;IAMhB,QAAQ,IAAI,IAAI;IAMhB,OAAO,IAAI,IAAI;IAMf,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAM/C,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI;IAM5C,MAAM,CAAC,CAAC,GAAG,OAAO,EAAE,EAAE,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IAMjD,KAAK,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAO7B,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAO/B,IAAI,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAO5B,KAAK,IAAI,IAAI;IASP,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;YAwC9E,YAAY;IAkF1B,UAAU,IAAI,OAAO;CAGrB"}

package/dist/field-validation/rule.js

@@ -0,0 +1,221 @@
+export class Rule {
+    _required = false;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _rules = [];
+    _level = 'error';
+    _message;
+    static FIELD_REF = Symbol('fieldReference');
+    static valueOfField(path) {
+        return {
+            __fieldReference: true,
+            path
+        };
+    }
+    valueOfField(path) {
+        return Rule.valueOfField(path);
+    }
+    required() {
+        const newRule = this.clone();
+        newRule._required = true;
+        return newRule;
+    }
+    optional() {
+        const newRule = this.clone();
+        newRule._required = false;
+        return newRule;
+    }
+    min(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'min', constraint: len });
+        return newRule;
+    }
+    max(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'max', constraint: len });
+        return newRule;
+    }
+    length(len) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'length', constraint: len });
+        return newRule;
+    }
+    email() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'email' });
+        return newRule;
+    }
+    uri(options) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'uri', constraint: options });
+        return newRule;
+    }
+    regex(pattern, name) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'regex', constraint: { pattern, name } });
+        return newRule;
+    }
+    positive() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'positive' });
+        return newRule;
+    }
+    negative() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'negative' });
+        return newRule;
+    }
+    integer() {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'integer' });
+        return newRule;
+    }
+    greaterThan(num) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'greaterThan', constraint: num });
+        return newRule;
+    }
+    lessThan(num) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'lessThan', constraint: num });
+        return newRule;
+    }
+    custom(fn) {
+        const newRule = this.clone();
+        newRule._rules.push({ type: 'custom', constraint: fn });
+        return newRule;
+    }
+    error(message) {
+        const newRule = this.clone();
+        newRule._level = 'error';
+        newRule._message = message;
+        return newRule;
+    }
+    warning(message) {
+        const newRule = this.clone();
+        newRule._level = 'warning';
+        newRule._message = message;
+        return newRule;
+    }
+    info(message) {
+        const newRule = this.clone();
+        newRule._level = 'info';
+        newRule._message = message;
+        return newRule;
+    }
+    clone() {
+        const newRule = new Rule();
+        newRule._required = this._required;
+        newRule._rules = [...this._rules];
+        newRule._level = this._level;
+        newRule._message = this._message;
+        return newRule;
+    }
+    async validate(value, context = {}) {
+        const markers = [];
+        // Check required
+        if (this._required && (value === undefined || value === null || value === '')) {
+            markers.push({
+                level: this._level,
+                message: this._message || 'Required',
+                path: context.path
+            });
+        }
+        // If value is empty and not required, skip other validations
+        if (!this._required && (value === undefined || value === null || value === '')) {
+            return markers;
+        }
+        // Run other validations
+        for (const rule of this._rules) {
+            try {
+                const result = await this.validateRule(rule, value, context);
+                if (result) {
+                    markers.push({
+                        level: this._level,
+                        message: this._message || result,
+                        path: context.path
+                    });
+                }
+            }
+            catch (error) {
+                markers.push({
+                    level: 'error',
+                    message: `Validation error: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    path: context.path
+                });
+            }
+        }
+        return markers;
+    }
+    async validateRule(rule, value, context) {
+        switch (rule.type) {
+            case 'min':
+                if (typeof value === 'string' && value.length < rule.constraint) {
+                    return `Must be at least ${rule.constraint} characters`;
+                }
+                if (typeof value === 'number' && value < rule.constraint) {
+                    return `Must be at least ${rule.constraint}`;
+                }
+                break;
+            case 'max':
+                if (typeof value === 'string' && value.length > rule.constraint) {
+                    return `Must be at most ${rule.constraint} characters`;
+                }
+                if (typeof value === 'number' && value > rule.constraint) {
+                    return `Must be at most ${rule.constraint}`;
+                }
+                break;
+            case 'email':
+                if (typeof value === 'string' && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)) {
+                    return 'Must be a valid email address';
+                }
+                break;
+            case 'uri':
+                if (typeof value === 'string') {
+                    try {
+                        new URL(value);
+                    }
+                    catch {
+                        return 'Must be a valid URL';
+                    }
+                }
+                break;
+            case 'regex':
+                if (typeof value === 'string' && !rule.constraint.pattern.test(value)) {
+                    return `Must match pattern${rule.constraint.name ? ` (${rule.constraint.name})` : ''}`;
+                }
+                break;
+            case 'positive':
+                if (typeof value === 'number' && value <= 0) {
+                    return 'Must be positive';
+                }
+                break;
+            case 'negative':
+                if (typeof value === 'number' && value >= 0) {
+                    return 'Must be negative';
+                }
+                break;
+            case 'integer':
+                if (typeof value === 'number' && !Number.isInteger(value)) {
+                    return 'Must be an integer';
+                }
+                break;
+            case 'custom': {
+                const customResult = await rule.constraint(value, context);
+                if (customResult === false) {
+                    return 'Validation failed';
+                }
+                if (typeof customResult === 'string') {
+                    return customResult;
+                }
+                if (Array.isArray(customResult) && customResult.length > 0) {
+                    return customResult[0].message;
+                }
+                break;
+            }
+        }
+        return null;
+    }
+    isRequired() {
+        return this._required;
+    }
+}

package/dist/field-validation/utils.d.ts

@@ -0,0 +1,21 @@
+import type { Field } from '../types/index.js';
+export interface ValidationError {
+    level: 'error' | 'warning' | 'info';
+    message: string;
+}
+/**
+ * Check if a field is required based on its validation rules
+ */
+export declare function isFieldRequired(field: Field): boolean;
+/**
+ * Validate a field value against its validation rules
+ */
+export declare function validateField(field: Field, value: any, context?: any): Promise<{
+    isValid: boolean;
+    errors: ValidationError[];
+}>;
+/**
+ * Get validation CSS classes for input styling
+ */
+export declare function getValidationClasses(hasErrors: boolean): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/field-validation/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/lib/field-validation/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAG5C,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACpC,OAAO,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAUrD;AAED;;GAEG;AACH,wBAAsB,aAAa,CAClC,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,GAAG,EACV,OAAO,GAAE,GAAQ,GACf,OAAO,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,eAAe,EAAE,CAAC;CAC1B,CAAC,CA6CD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAO/D"}

package/dist/field-validation/utils.js

@@ -0,0 +1,66 @@
+import { Rule } from './rule.js';
+/**
+ * Check if a field is required based on its validation rules
+ */
+export function isFieldRequired(field) {
+    if (!field.validation)
+        return false;
+    try {
+        const validationFn = Array.isArray(field.validation) ? field.validation[0] : field.validation;
+        if (!validationFn)
+            return false;
+        const rule = validationFn(new Rule());
+        return rule.isRequired();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate a field value against its validation rules
+ */
+export async function validateField(field, value, context = {}) {
+    if (!field.validation) {
+        return { isValid: true, errors: [] };
+    }
+    try {
+        const validationFunctions = Array.isArray(field.validation)
+            ? field.validation
+            : [field.validation];
+        const allErrors = [];
+        for (const validationFn of validationFunctions) {
+            const rule = validationFn(new Rule());
+            if (!(rule instanceof Rule)) {
+                console.error(`Validation function for field "${field.name}" did not return a Rule object. Make sure you are chaining validation methods and returning the result.`);
+                continue;
+            }
+            const markers = await rule.validate(value, {
+                path: [field.name],
+                ...context
+            });
+            allErrors.push(...markers.map((marker) => ({
+                level: marker.level,
+                message: marker.message
+            })));
+        }
+        const isValid = allErrors.filter((e) => e.level === 'error').length === 0;
+        return { isValid, errors: allErrors };
+    }
+    catch (error) {
+        console.error('Validation error:', error);
+        return {
+            isValid: false,
+            errors: [{ level: 'error', message: 'Validation failed' }]
+        };
+    }
+}
+/**
+ * Get validation CSS classes for input styling
+ */
+export function getValidationClasses(hasErrors) {
+    if (hasErrors) {
+        return 'border-destructive border-2';
+    }
+    // No green styling for success - only show red for errors
+    return '';
+}

package/dist/hooks.d.ts

@@ -0,0 +1,23 @@
+import type { Handle } from '@sveltejs/kit';
+import type { CMSConfig } from './types/index.js';
+import type { DatabaseAdapter } from './db/index.js';
+import type { AssetService } from './services/asset-service.js';
+import type { StorageAdapter } from './storage/interfaces/storage.js';
+import type { EmailAdapter } from './email/index.js';
+import type { AuthProvider } from './auth/provider.js';
+import { CMSEngine } from './engine.js';
+export interface CMSInstances {
+    config: CMSConfig;
+    assetService: AssetService;
+    storageAdapter: StorageAdapter;
+    databaseAdapter: DatabaseAdapter;
+    emailAdapter?: EmailAdapter | null;
+    cmsEngine: CMSEngine;
+    auth?: AuthProvider;
+    pluginRoutes?: Map<string, {
+        handler: (event: any) => Promise<Response> | Response;
+        pluginName: string;
+    }>;
+}
+export declare function createCMSHook(config: CMSConfig): Handle;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/lib/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,OAAO,EAAa,SAAS,EAAE,MAAM,UAAU,CAAC;AAGhD,MAAM,WAAW,YAAY;IAC5B,MAAM,EAAE,SAAS,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;IAC3B,cAAc,EAAE,cAAc,CAAC;IAC/B,eAAe,EAAE,eAAe,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,SAAS,EAAE,SAAS,CAAC;IACrB,IAAI,CAAC,EAAE,YAAY,CAAC;IACpB,YAAY,CAAC,EAAE,GAAG,CACjB,MAAM,EACN;QAAE,OAAO,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,GAAG,QAAQ,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC7E,CAAC;CACF;AAqBD,wBAAgB,aAAa,CAAC,MAAM,EAAE,SAAS,GAAG,MAAM,CA+FvD"}

package/dist/hooks.js

@@ -0,0 +1,96 @@
+import { handleAuthHook } from './auth/auth-hooks.js';
+import { createStorageAdapter as createStorageAdapterProvider } from './storage/providers/storage.js';
+import { AssetService as AssetServiceClass } from './services/asset-service.js';
+import { createCMS } from './engine.js';
+let cmsInstances = null;
+let lastConfigHash = null;
+// Helper to generate a simple hash of schema types for change detection
+function getConfigHash(config) {
+    const schemaNames = config.schemaTypes
+        .map((s) => `${s.name}:${s.fields.length}:${JSON.stringify(s.fields)}`)
+        .join(',');
+    return schemaNames;
+}
+// Factory function to create the default local storage adapter
+function createDefaultStorageAdapter() {
+    return createStorageAdapterProvider('local', {
+        basePath: './storage/assets', // Private storage - not in static/, not served in production
+        baseUrl: '' // No direct URL - all access through /assets/{id}/{filename}
+    });
+}
+export function createCMSHook(config) {
+    return async ({ event, resolve }) => {
+        // Note: In dev mode, /storage/ might be accessible via Vite dev server
+        // In production, only /static/ folder is served - /storage/ is private
+        const currentConfigHash = getConfigHash(config);
+        const configChanged = lastConfigHash !== null && currentConfigHash !== lastConfigHash;
+        // Initialize CMS instances once at application startup
+        if (!cmsInstances) {
+            console.log('🚀 Initializing CMS...');
+            const databaseAdapter = config.database;
+            // Use the storage adapter from config, or create the default local one.
+            const storageAdapter = config.storage ?? createDefaultStorageAdapter();
+            const emailAdapter = config.email ?? null;
+            const assetService = new AssetServiceClass(storageAdapter, databaseAdapter);
+            const cmsEngine = createCMS(config, databaseAdapter);
+            await cmsEngine.initialize();
+            // Build plugin route map (do this ONCE at startup)
+            const pluginRoutes = new Map();
+            if (config.plugins && config.plugins.length > 0) {
+                for (const plugin of config.plugins) {
+                    if (plugin.routes) {
+                        for (const [path, handler] of Object.entries(plugin.routes)) {
+                            pluginRoutes.set(path, { handler, pluginName: plugin.name });
+                        }
+                    }
+                }
+            }
+            cmsInstances = {
+                config,
+                databaseAdapter: databaseAdapter,
+                assetService: assetService,
+                storageAdapter: storageAdapter,
+                emailAdapter: emailAdapter,
+                cmsEngine: cmsEngine,
+                auth: config.auth?.provider,
+                pluginRoutes
+            };
+            // Install plugins
+            if (config.plugins && config.plugins.length > 0) {
+                for (const plugin of config.plugins) {
+                    console.log(`🔌 Installing plugin: ${plugin.name}`);
+                    await plugin.install(cmsInstances);
+                }
+            }
+            lastConfigHash = currentConfigHash;
+        }
+        else if (configChanged) {
+            // HMR: Config changed, re-sync schemas
+            console.log('🔄 Schema types changed, re-syncing...');
+            console.log('Old hash:', lastConfigHash?.substring(0, 100) + '...');
+            console.log('New hash:', currentConfigHash.substring(0, 100) + '...');
+            console.log('Schema types being updated:', config.schemaTypes.map((s) => s.name));
+            cmsInstances.cmsEngine.updateConfig(config);
+            await cmsInstances.cmsEngine.initialize();
+            lastConfigHash = currentConfigHash;
+            console.log('✅ Schema sync complete');
+        }
+        // Inject shared CMS services into locals (reuse singleton instances)
+        event.locals.aphexCMS = cmsInstances;
+        // Auth protection if configured
+        if (cmsInstances.auth) {
+            const authResponse = await handleAuthHook(event, config, cmsInstances.auth, cmsInstances.databaseAdapter);
+            if (authResponse)
+                return authResponse;
+        }
+        // Check if a plugin handles this route (O(1) lookup)
+        if (cmsInstances.pluginRoutes && cmsInstances.pluginRoutes.size > 0) {
+            const pluginRoute = cmsInstances.pluginRoutes.get(event.url.pathname);
+            if (pluginRoute) {
+                console.log(`🔌 Plugin ${pluginRoute.pluginName} handling route: ${event.url.pathname}`);
+                return pluginRoute.handler(event);
+            }
+        }
+        return resolve(event);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './client/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAIA,cAAc,gBAAgB,CAAC"}

package/{src/lib/index.ts → dist/index.js}

@@ -1,5 +1,4 @@
 // Aphex CMS Core - Main exports (client-safe only)
 // For server-side functionality, import from '@aphexcms/cms-core/server'
-
 // Re-export all client-safe functionality
-export * from './client/index';
+export * from './client/index.js';

package/dist/is-mobile.svelte.d.ts

@@ -0,0 +1,5 @@
+import { MediaQuery } from 'svelte/reactivity';
+export declare class IsMobile extends MediaQuery {
+    constructor(breakpoint?: number);
+}
+//# sourceMappingURL=is-mobile.svelte.d.ts.map

package/dist/is-mobile.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-mobile.svelte.d.ts","sourceRoot":"","sources":["../src/lib/is-mobile.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAI/C,qBAAa,QAAS,SAAQ,UAAU;gBAC3B,UAAU,GAAE,MAAkC;CAG1D"}

package/{src/lib/is-mobile.svelte.ts → dist/is-mobile.svelte.js}

@@ -1,9 +1,7 @@
 import { MediaQuery } from 'svelte/reactivity';
-
 const DEFAULT_MOBILE_BREAKPOINT = 768;
-
 export class IsMobile extends MediaQuery {
-	constructor(breakpoint: number = DEFAULT_MOBILE_BREAKPOINT) {
-		super(`max-width: ${breakpoint - 1}px`);
-	}
+    constructor(breakpoint = DEFAULT_MOBILE_BREAKPOINT) {
+        super(`max-width: ${breakpoint - 1}px`);
+    }
 }

package/dist/routes/assets-by-id.d.ts

@@ -0,0 +1,5 @@
+import type { RequestHandler } from '@sveltejs/kit';
+export declare const GET: RequestHandler;
+export declare const DELETE: RequestHandler;
+export declare const PATCH: RequestHandler;
+//# sourceMappingURL=assets-by-id.d.ts.map

package/dist/routes/assets-by-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets-by-id.d.ts","sourceRoot":"","sources":["../../src/lib/routes/assets-by-id.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAGpD,eAAO,MAAM,GAAG,EAAE,cAoDjB,CAAC;AAEF,eAAO,MAAM,MAAM,EAAE,cA4BpB,CAAC;AAEF,eAAO,MAAM,KAAK,EAAE,cAwEnB,CAAC"}