@beeblock/svelar 0.4.0

package/dist/broadcasting/index.d.ts

@@ -0,0 +1,318 @@
+/**
+ * Svelar Broadcasting
+ *
+ * Real-time event broadcasting with multiple drivers and Laravel-style
+ * channel authorization. Supports SSE (zero-dependency), Pusher/Soketi
+ * (WebSocket via pusher protocol), and a log driver for development.
+ *
+ * Channel types:
+ *   - Public channels:   Anyone can subscribe
+ *   - Private channels:  Require authorization (prefixed with 'private-')
+ *   - Presence channels: Require authorization + track who's online (prefixed with 'presence-')
+ *
+ * @example
+ * ```ts
+ * import { Broadcast } from 'svelar/broadcasting';
+ *
+ * // Configure
+ * Broadcast.configure({
+ *   default: 'sse',
+ *   drivers: {
+ *     sse: { driver: 'sse' },
+ *     pusher: {
+ *       driver: 'pusher',
+ *       key: env('PUSHER_KEY'),
+ *       secret: env('PUSHER_SECRET'),
+ *       appId: env('PUSHER_APP_ID'),
+ *       cluster: env('PUSHER_CLUSTER', 'mt1'),
+ *       host: env('PUSHER_HOST'),           // For Soketi
+ *       port: env<number>('PUSHER_PORT'),   // For Soketi
+ *       useTLS: env<boolean>('PUSHER_TLS', true),
+ *     },
+ *   },
+ * });
+ *
+ * // Register channel authorization
+ * Broadcast.channel('private-orders.{orderId}', async (user, { orderId }) => {
+ *   return user.id === (await Order.findOrFail(orderId)).user_id;
+ * });
+ *
+ * Broadcast.channel('presence-chat.{roomId}', async (user, { roomId }) => {
+ *   const room = await ChatRoom.findOrFail(roomId);
+ *   if (!room.hasMember(user.id)) return false;
+ *   return { id: user.id, name: user.name, avatar: user.avatar };
+ * });
+ *
+ * // Broadcast events from anywhere
+ * Broadcast.event('OrderShipped', { orderId: 123 })
+ *   .on('private-orders.123')
+ *   .send();
+ *
+ * // Or the shorthand
+ * Broadcast.to('private-orders.123').send('OrderShipped', { orderId: 123 });
+ * ```
+ */
+export interface BroadcastConfig {
+    default: string;
+    drivers: Record<string, BroadcastDriverConfig>;
+}
+export type BroadcastDriverConfig = {
+    driver: 'sse';
+} | {
+    driver: 'log';
+} | {
+    driver: 'pusher';
+    key: string;
+    secret: string;
+    appId: string;
+    cluster?: string;
+    host?: string;
+    port?: number;
+    useTLS?: boolean;
+};
+export interface BroadcastEvent {
+    event: string;
+    data: any;
+    id?: string;
+}
+/** Channel authorization callback */
+export type ChannelAuthCallback = (user: any, params: Record<string, string>) => Promise<boolean | Record<string, any>> | boolean | Record<string, any>;
+/** Presence channel member info */
+export interface PresenceMember {
+    id: string | number;
+    [key: string]: any;
+}
+export type ChannelType = 'public' | 'private' | 'presence';
+/**
+ * Determine channel type from its name.
+ * - 'private-xxx' → private
+ * - 'presence-xxx' → presence
+ * - anything else → public
+ */
+export declare function channelType(name: string): ChannelType;
+declare class SSEChannel {
+    private subscribers;
+    readonly name: string;
+    readonly type: ChannelType;
+    constructor(name: string);
+    /**
+     * Create an SSE streaming response for this channel.
+     * For private/presence channels, authorization must be checked BEFORE calling this.
+     */
+    stream(userId?: string | number, userInfo?: Record<string, any>): Response;
+    /**
+     * Send an event to all subscribers
+     */
+    send(event: string, data: any, targetUserId?: string | number): void;
+    /** Internal send that excludes a specific subscriber (for join/leave events) */
+    private sendInternal;
+    /**
+     * Send to a specific user in this channel
+     */
+    toUser(userId: string | number): {
+        send: (event: string, data: any) => void;
+    };
+    /**
+     * Get the number of active subscribers
+     */
+    subscriberCount(): number;
+    /**
+     * Get presence members (for presence channels)
+     */
+    getMembers(): PresenceMember[];
+    /**
+     * Check if a user is present in this channel
+     */
+    hasMember(userId: string | number): boolean;
+    /**
+     * Whisper — send a client event to other users (not from server).
+     * Useful for typing indicators, cursor positions, etc.
+     */
+    whisper(event: string, data: any, fromUserId: string | number): void;
+}
+/**
+ * Pusher/Soketi broadcast driver.
+ * Sends events via HTTP API (compatible with Pusher and Soketi).
+ * Clients connect using pusher-js.
+ */
+declare class PusherDriver {
+    private config;
+    constructor(config: Extract<BroadcastDriverConfig, {
+        driver: 'pusher';
+    }>);
+    /**
+     * Send an event via the Pusher HTTP API
+     */
+    send(channels: string | string[], event: string, data: any): Promise<void>;
+    /**
+     * Generate auth signature for private/presence channel subscriptions.
+     * Used in the channel authorization endpoint.
+     */
+    authenticate(socketId: string, channelName: string, presenceData?: {
+        user_id: string | number;
+        user_info?: Record<string, any>;
+    }): Promise<{
+        auth: string;
+        channel_data?: string;
+    }>;
+    /** Get the Pusher app key (needed by clients) */
+    get key(): string;
+    /** Get connection config for the client */
+    clientConfig(): Record<string, any>;
+    private md5;
+    private hmacSha256;
+}
+declare class BroadcastEventBuilder {
+    private manager;
+    private eventName;
+    private eventData;
+    private channels;
+    constructor(manager: BroadcastManager, eventName: string, eventData: any);
+    /** Specify which channel(s) to broadcast on */
+    on(...channels: string[]): BroadcastEventBuilder;
+    /** Send the event to all specified channels */
+    send(): Promise<void>;
+}
+declare class BroadcastManager {
+    private config;
+    private sseChannels;
+    private channelAuth;
+    private pusherDriver;
+    /**
+     * Configure broadcasting drivers.
+     */
+    configure(config: BroadcastConfig): void;
+    /**
+     * Register an authorization callback for a private or presence channel.
+     * Pattern supports `{param}` placeholders that are extracted from the channel name.
+     *
+     * Return `true` for private channels to allow access.
+     * Return an object with user info for presence channels (or `false` to deny).
+     *
+     * @example
+     * // Private channel
+     * Broadcast.channel('private-orders.{orderId}', async (user, { orderId }) => {
+     *   const order = await Order.findOrFail(orderId);
+     *   return order.user_id === user.id;
+     * });
+     *
+     * // Presence channel — return user info to share with other members
+     * Broadcast.channel('presence-chat.{roomId}', async (user, { roomId }) => {
+     *   const room = await ChatRoom.findOrFail(roomId);
+     *   if (!room.hasMember(user.id)) return false;
+     *   return { id: user.id, name: user.name, avatar: user.avatar };
+     * });
+     */
+    channel(pattern: string, callback: ChannelAuthCallback): void;
+    /**
+     * Get or create an SSE channel for subscribing.
+     */
+    channel(name: string): SSEChannel;
+    /**
+     * Authorize a user to subscribe to a private or presence channel.
+     * Called from your channel authorization endpoint.
+     *
+     * Returns `false` if denied, `true` for private channels,
+     * or a presence member object for presence channels.
+     */
+    authorize(channelName: string, user: any): Promise<false | true | Record<string, any>>;
+    /**
+     * Authenticate a Pusher channel subscription.
+     * Use this in your channel auth endpoint for Pusher/Soketi.
+     *
+     * @example
+     * // src/routes/api/broadcasting/auth/+server.ts
+     * export const POST: RequestHandler = async ({ request, locals }) => {
+     *   if (!locals.user) return new Response('Unauthorized', { status: 401 });
+     *
+     *   const form = await request.formData();
+     *   const socketId = form.get('socket_id') as string;
+     *   const channelName = form.get('channel_name') as string;
+     *
+     *   const auth = await Broadcast.authenticatePusher(channelName, socketId, locals.user);
+     *   if (!auth) return new Response('Forbidden', { status: 403 });
+     *
+     *   return new Response(JSON.stringify(auth), {
+     *     headers: { 'Content-Type': 'application/json' },
+     *   });
+     * };
+     */
+    authenticatePusher(channelName: string, socketId: string, user: any): Promise<{
+        auth: string;
+        channel_data?: string;
+    } | false>;
+    /**
+     * Create an event builder for fluent broadcasting.
+     *
+     * @example
+     * Broadcast.event('OrderShipped', { orderId: 123 })
+     *   .on('private-orders.123')
+     *   .send();
+     */
+    event(name: string, data: any): BroadcastEventBuilder;
+    /**
+     * Shorthand — get a sender for a channel.
+     *
+     * @example
+     * Broadcast.to('private-orders.123').send('OrderShipped', { orderId: 123 });
+     * Broadcast.to('notifications', userId).send('new-message', { text: 'Hello!' });
+     */
+    to(channelName: string, userId?: string | number): {
+        send: (event: string, data: any) => Promise<void>;
+    };
+    /**
+     * Send an event to a channel. Used internally and by the event builder.
+     * Routes to the appropriate driver.
+     */
+    sendToChannel(channelName: string, event: string, data: any, targetUserId?: string | number): Promise<void>;
+    /**
+     * Subscribe to an SSE channel. For private/presence channels,
+     * call `authorize()` first and check the result before calling `subscribe()`.
+     *
+     * @example
+     * // Public channel
+     * return Broadcast.subscribe('updates');
+     *
+     * // Private channel (check auth first)
+     * const allowed = await Broadcast.authorize('private-orders.123', locals.user);
+     * if (!allowed) return new Response('Forbidden', { status: 403 });
+     * return Broadcast.subscribe('private-orders.123', locals.user.id);
+     *
+     * // Presence channel (pass user info for member tracking)
+     * const presenceInfo = await Broadcast.authorize('presence-chat.1', locals.user);
+     * if (!presenceInfo) return new Response('Forbidden', { status: 403 });
+     * return Broadcast.subscribe('presence-chat.1', locals.user.id, presenceInfo);
+     */
+    subscribe(channelName: string, userId?: string | number, userInfo?: Record<string, any>): Response;
+    /**
+     * Get members of a presence channel (SSE driver only)
+     */
+    members(channelName: string): PresenceMember[];
+    /**
+     * Get the Pusher driver instance (for advanced usage)
+     */
+    pusher(): PusherDriver;
+    /**
+     * Get all active channel names
+     */
+    activeChannels(): string[];
+    /**
+     * Get total subscriber count across all SSE channels
+     */
+    totalSubscribers(): number;
+    /**
+     * Remove empty SSE channels (cleanup)
+     */
+    prune(): void;
+    /**
+     * Match a channel pattern like 'private-orders.{orderId}'
+     * against a channel name like 'private-orders.123'.
+     * Returns extracted params or null if no match.
+     */
+    private matchPattern;
+}
+/**
+ * Global Broadcast singleton
+ */
+export declare const Broadcast: BroadcastManager;
+export {};

package/dist/broadcasting/index.js

@@ -0,0 +1,20 @@
+function b(c,e){let n=Symbol.for(c),t=globalThis;return t[n]||(t[n]=e()),t[n]}function d(c){return c.startsWith("private-")?"private":c.startsWith("presence-")?"presence":"public"}var l=class{subscribers=[];name;type;constructor(e){this.name=e,this.type=d(e)}stream(e,n){let t=this,i=new ReadableStream({start(r){let s={channel:t.name};t.type==="presence"&&(s.members=t.getMembers());let o=`event: connected
+data: ${JSON.stringify(s)}
+id: ${Date.now()}
+
+`;r.enqueue(new TextEncoder().encode(o));let a={controller:r,userId:e,userInfo:n};t.subscribers.push(a),t.type==="presence"&&e!==void 0&&t.sendInternal("member:joined",{id:e,...n},a)},cancel(){let r=t.subscribers.findIndex(o=>o.controller===this._controller),s=t.subscribers.length;t.subscribers=t.subscribers.filter(o=>{try{return o.controller.enqueue(new TextEncoder().encode(`:
+
+`)),!0}catch{return!1}}),t.type==="presence"&&e!==void 0&&t.subscribers.length<s&&t.sendInternal("member:left",{id:e,...n})}});return new Response(i,{headers:{"Content-Type":"text/event-stream","Cache-Control":"no-cache",Connection:"keep-alive","X-Accel-Buffering":"no"}})}send(e,n,t){let i=`event: ${e}
+data: ${JSON.stringify(n)}
+id: ${Date.now()}
+
+`,r=new TextEncoder().encode(i);for(let s of this.subscribers)if(!(t!==void 0&&s.userId!==t))try{s.controller.enqueue(r)}catch{}}sendInternal(e,n,t){let i=`event: ${e}
+data: ${JSON.stringify(n)}
+id: ${Date.now()}
+
+`,r=new TextEncoder().encode(i);for(let s of this.subscribers)if(s!==t)try{s.controller.enqueue(r)}catch{}}toUser(e){return{send:(n,t)=>this.send(n,t,e)}}subscriberCount(){return this.subscribers.length}getMembers(){return this.type!=="presence"?[]:this.subscribers.filter(e=>e.userId!==void 0).map(e=>({id:e.userId,...e.userInfo??{}}))}hasMember(e){return this.subscribers.some(n=>n.userId===e)}whisper(e,n,t){let i=`event: client-${e}
+data: ${JSON.stringify(n)}
+id: ${Date.now()}
+
+`,r=new TextEncoder().encode(i);for(let s of this.subscribers)if(s.userId!==t)try{s.controller.enqueue(r)}catch{}}},h=class{config;constructor(e){this.config=e}async send(e,n,t){let i=Array.isArray(e)?e:[e],r=JSON.stringify({name:n,channels:i,data:JSON.stringify(t)}),s=Math.floor(Date.now()/1e3).toString(),o=await this.md5(r),a=["POST",`/apps/${this.config.appId}/events`,[`auth_key=${this.config.key}`,`auth_timestamp=${s}`,"auth_version=1.0",`body_md5=${o}`].join("&")].join(`
+`),u=await this.hmacSha256(this.config.secret,a),y=this.config.useTLS!==!1?"https":"http",v=this.config.host??`api-${this.config.cluster??"mt1"}.pusher.com`,m=this.config.port??(this.config.useTLS!==!1?443:80),w=`${y}://${v}:${m}/apps/${this.config.appId}/events?auth_key=${this.config.key}&auth_timestamp=${s}&auth_version=1.0&body_md5=${o}&auth_signature=${u}`,g=await fetch(w,{method:"POST",headers:{"Content-Type":"application/json"},body:r});if(!g.ok){let C=await g.text();throw new Error(`Pusher API error (${g.status}): ${C}`)}}async authenticate(e,n,t){let i=`${e}:${n}`,r;t&&(r=JSON.stringify(t),i+=`:${r}`);let s=await this.hmacSha256(this.config.secret,i),o=`${this.config.key}:${s}`;return r?{auth:o,channel_data:r}:{auth:o}}get key(){return this.config.key}clientConfig(){let e={key:this.config.key,cluster:this.config.cluster??"mt1"};return this.config.host&&(e.wsHost=this.config.host,e.wsPort=this.config.port??6001,e.wssPort=this.config.port??6001,e.forceTLS=this.config.useTLS??!1,e.enabledTransports=["ws","wss"],e.disableStats=!0),e}async md5(e){let{createHash:n}=await import("crypto");return n("md5").update(e).digest("hex")}async hmacSha256(e,n){let{createHmac:t}=await import("crypto");return t("sha256",e).update(n).digest("hex")}},f=class{constructor(e,n,t){this.manager=e;this.eventName=n;this.eventData=t}channels=[];on(...e){return this.channels.push(...e),this}async send(){for(let e of this.channels)await this.manager.sendToChannel(e,this.eventName,this.eventData)}},p=class{config={default:"sse",drivers:{sse:{driver:"sse"}}};sseChannels=new Map;channelAuth=new Map;pusherDriver=null;configure(e){this.config=e;let n=Object.values(e.drivers).find(t=>t.driver==="pusher");n&&n.driver==="pusher"&&(this.pusherDriver=new h(n))}channel(e,n){if(n){this.channelAuth.set(e,n);return}return this.sseChannels.has(e)||this.sseChannels.set(e,new l(e)),this.sseChannels.get(e)}async authorize(e,n){if(d(e)==="public")return!0;for(let[i,r]of this.channelAuth){let s=this.matchPattern(i,e);if(s!==null)return await r(n,s)}return!1}async authenticatePusher(e,n,t){if(!this.pusherDriver)throw new Error("Pusher driver is not configured. Call Broadcast.configure() first.");let i=d(e);if(i==="public")return!1;let r=await this.authorize(e,t);if(r===!1)return!1;if(i==="presence"){let s=typeof r=="object"?{user_id:r.id??t.id,user_info:r}:{user_id:t.id,user_info:{id:t.id}};return this.pusherDriver.authenticate(n,e,s)}return this.pusherDriver.authenticate(n,e)}event(e,n){return new f(this,e,n)}to(e,n){return{send:async(t,i)=>{await this.sendToChannel(e,t,i,n)}}}async sendToChannel(e,n,t,i){let r=this.config.drivers[this.config.default];switch(r?.driver){case"pusher":this.pusherDriver||(this.pusherDriver=new h(r)),await this.pusherDriver.send(e,n,t);break;case"log":console.log(`[Broadcast] ${e} \u2192 ${n}:`,JSON.stringify(t));break;default:for(let[,s]of this.sseChannels)s.name===e&&s.send(n,t,i);break}}subscribe(e,n,t){return this.channel(e).stream(n,t)}members(e){let n=this.sseChannels.get(e);return n?n.getMembers():[]}pusher(){if(!this.pusherDriver)throw new Error("Pusher driver is not configured.");return this.pusherDriver}activeChannels(){return[...new Set([...this.sseChannels.values()].map(e=>e.name))]}totalSubscribers(){let e=0;for(let n of this.sseChannels.values())e+=n.subscriberCount();return e}prune(){for(let[e,n]of this.sseChannels)n.subscriberCount()===0&&this.sseChannels.delete(e)}matchPattern(e,n){let t=[],i=e.replace(/[.*+?^${}()|[\]\\]/g,a=>a==="{"||a==="}"?a:`\\${a}`).replace(/\\\{(\w+)\\\}/g,(a,u)=>(t.push(u),"([^.]+)")).replace(/\{(\w+)\}/g,(a,u)=>(t.push(u),"([^.]+)")),r=new RegExp(`^${i}$`),s=n.match(r);if(!s)return null;let o={};for(let a=0;a<t.length;a++)o[t[a]]=s[a+1];return o}},T=b("svelar.broadcast",()=>new p);export{T as Broadcast,d as channelType};

package/dist/cache/index.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Svelar Cache
+ *
+ * Laravel-inspired cache with memory, file, and Redis drivers.
+ *
+ * @example
+ * ```ts
+ * import { Cache } from 'svelar/cache';
+ *
+ * Cache.configure({ default: 'memory', stores: { memory: { driver: 'memory' } } });
+ *
+ * await Cache.put('key', 'value', 3600); // 1 hour TTL
+ * const value = await Cache.get('key', 'default');
+ * await Cache.forget('key');
+ *
+ * // Remember pattern (fetch or compute)
+ * const users = await Cache.remember('all-users', 600, async () => {
+ *   return await User.all();
+ * });
+ * ```
+ */
+export type CacheDriver = 'memory' | 'file' | 'redis' | 'null';
+export interface CacheStoreConfig {
+    driver: CacheDriver;
+    /** Default TTL in seconds */
+    ttl?: number;
+    /** File cache: directory path */
+    path?: string;
+    /** Redis cache: connection URL or config */
+    url?: string;
+    /** Key prefix */
+    prefix?: string;
+}
+export interface CacheConfig {
+    default: string;
+    stores: Record<string, CacheStoreConfig>;
+}
+interface CacheStore {
+    get<T = any>(key: string): Promise<T | null>;
+    put(key: string, value: any, ttl?: number): Promise<void>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    increment(key: string, amount?: number): Promise<number>;
+    decrement(key: string, amount?: number): Promise<number>;
+}
+declare class CacheManager {
+    private config;
+    private stores;
+    configure(config: CacheConfig): void;
+    store(name?: string): CacheStore;
+    get<T = any>(key: string, defaultValue?: T): Promise<T | null>;
+    put(key: string, value: any, ttl?: number): Promise<void>;
+    forget(key: string): Promise<boolean>;
+    flush(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    increment(key: string, amount?: number): Promise<number>;
+    decrement(key: string, amount?: number): Promise<number>;
+    /**
+     * Get or compute a cached value
+     */
+    remember<T>(key: string, ttl: number, callback: () => T | Promise<T>): Promise<T>;
+    /**
+     * Get or compute, caching forever
+     */
+    rememberForever<T>(key: string, callback: () => T | Promise<T>): Promise<T>;
+    /**
+     * Get and delete
+     */
+    pull<T = any>(key: string, defaultValue?: T): Promise<T | null>;
+    private createStore;
+}
+/**
+ * Global Cache singleton
+ */
+export declare const Cache: CacheManager;
+export type { CacheStore };

package/dist/cache/index.js

@@ -0,0 +1 @@
+import{readFile as g,writeFile as f,unlink as h,mkdir as l}from"fs/promises";import{join as y,dirname as p}from"path";import{createHash as d}from"crypto";function m(i,e){let r=Symbol.for(i),t=globalThis;return t[r]||(t[r]=e()),t[r]}var a=class{store=new Map;async get(e){let r=this.store.get(e);return r?r.expiresAt&&Date.now()>r.expiresAt?(this.store.delete(e),null):r.value:null}async put(e,r,t){this.store.set(e,{value:r,expiresAt:t?Date.now()+t*1e3:null})}async forget(e){return this.store.delete(e)}async flush(){this.store.clear()}async has(e){let r=this.store.get(e);return r?r.expiresAt&&Date.now()>r.expiresAt?(this.store.delete(e),!1):!0:!1}async increment(e,r=1){let s=(await this.get(e)??0)+r,n=this.store.get(e);return await this.put(e,s,n?.expiresAt?Math.ceil((n.expiresAt-Date.now())/1e3):void 0),s}async decrement(e,r=1){return this.increment(e,-r)}},o=class{basePath;constructor(e){this.basePath=e.path??"storage/cache"}filePath(e){let r=d("md5").update(e).digest("hex");return y(this.basePath,r.slice(0,2),r)}async get(e){let r=this.filePath(e);try{let t=await g(r,"utf-8"),s=JSON.parse(t);return s.expiresAt&&Date.now()>s.expiresAt?(await h(r).catch(()=>{}),null):s.value}catch{return null}}async put(e,r,t){let s=this.filePath(e),n={value:r,expiresAt:t?Date.now()+t*1e3:null};await l(p(s),{recursive:!0}),await f(s,JSON.stringify(n))}async forget(e){try{return await h(this.filePath(e)),!0}catch{return!1}}async flush(){let{rm:e}=await import("fs/promises");await e(this.basePath,{recursive:!0,force:!0}),await l(this.basePath,{recursive:!0})}async has(e){return await this.get(e)!==null}async increment(e,r=1){let s=(await this.get(e)??0)+r;return await this.put(e,s),s}async decrement(e,r=1){return this.increment(e,-r)}},c=class{async get(){return null}async put(){}async forget(){return!0}async flush(){}async has(){return!1}async increment(){return 0}async decrement(){return 0}},u=class{config={default:"memory",stores:{memory:{driver:"memory"}}};stores=new Map;configure(e){this.config=e,this.stores.clear()}store(e){let r=e??this.config.default;if(this.stores.has(r))return this.stores.get(r);let t=this.config.stores[r];if(!t)throw new Error(`Cache store "${r}" is not defined.`);let s=this.createStore(t);return this.stores.set(r,s),s}async get(e,r){let t=this.store();return await t.has(e)?t.get(e):r??null}async put(e,r,t){return this.store().put(e,r,t??this.config.stores[this.config.default]?.ttl)}async forget(e){return this.store().forget(e)}async flush(){return this.store().flush()}async has(e){return this.store().has(e)}async increment(e,r){return this.store().increment(e,r)}async decrement(e,r){return this.store().decrement(e,r)}async remember(e,r,t){let s=await this.store().get(e);if(s!==null)return s;let n=await t();return await this.store().put(e,n,r),n}async rememberForever(e,r){let t=await this.store().get(e);if(t!==null)return t;let s=await r();return await this.store().put(e,s),s}async pull(e,r){let t=await this.get(e,r);return await this.forget(e),t}createStore(e){switch(e.driver){case"memory":return new a;case"file":return new o(e);case"null":return new c;case"redis":throw new Error("Redis cache requires ioredis. Install: npm install ioredis");default:throw new Error(`Unknown cache driver: ${e.driver}`)}}},x=m("svelar.cache",()=>new u);export{x as Cache};

package/dist/cli/Cli.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Svelar CLI Runner
+ */
+import { Command } from './Command.js';
+export declare class Cli {
+    private commands;
+    private version;
+    constructor(version?: string);
+    /**
+     * Register a command
+     */
+    register(CommandClass: new () => Command): this;
+    /**
+     * Register a command instance
+     */
+    add(command: Command): this;
+    /**
+     * Execute CLI with process arguments
+     */
+    run(argv?: string[]): Promise<void>;
+    private parseArgs;
+    private showHelp;
+}

package/dist/cli/Command.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Svelar CLI Command Base
+ */
+export interface CommandFlag {
+    name: string;
+    alias?: string;
+    description: string;
+    type: 'boolean' | 'string';
+    default?: any;
+}
+export declare abstract class Command {
+    /** Command name (e.g. 'make:model') */
+    abstract name: string;
+    /** Description shown in help */
+    abstract description: string;
+    /** Positional arguments description */
+    arguments: string[];
+    /** Available flags */
+    flags: CommandFlag[];
+    /** Execute the command */
+    abstract handle(args: string[], flags: Record<string, any>): Promise<void>;
+    /**
+     * Bootstrap database configuration for CLI commands.
+     *
+     * Reads a `svelar.database.json` file if present, or uses env vars
+     * and sensible defaults (SQLite with `database.db`).
+     */
+    protected bootstrap(): Promise<void>;
+    protected log(message: string): void;
+    protected info(message: string): void;
+    protected success(message: string): void;
+    protected warn(message: string): void;
+    protected error(message: string): void;
+    protected table(headers: string[], rows: string[][]): void;
+    protected newLine(): void;
+}

package/dist/cli/bin.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Svelar CLI — Laravel-like Artisan for SvelteKit
+ *
+ * Re-launches with --import ts-resolver.mjs so that dynamic imports of
+ * user .ts files (tasks, commands, seeders) resolve .js → .ts correctly.
+ */
+export {};