@velajs/vela 1.18.0 → 1.19.1

package/dist/i18n/message-loader.service.js

@@ -1,90 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-import IntlMessageFormat from "intl-messageformat";
-import { Inject, Injectable } from "../container/decorators.js";
-import { I18N_OPTIONS } from "./i18n.tokens.js";
-import { MessageRegistry } from "./message-registry.js";
-export class MessageLoaderService {
-    cache = new Map();
-    compiledCache = new Map();
-    defaultLocale;
-    fallbackLocale;
-    constructor(registry, options){
-        this.defaultLocale = options?.defaultLocale ?? 'en';
-        this.fallbackLocale = options?.fallbackLocale ?? this.defaultLocale;
-        const merged = registry.getMergedMessages();
-        for (const locale of Object.keys(merged)){
-            this.cache.set(locale, merged[locale]);
-        }
-    }
-    translate(locale, key, params) {
-        const primary = this.getCompiledMessages(locale)[key];
-        if (primary) return primary(params);
-        // Per-key fallback: a supported locale missing an individual key falls back
-        // to fallbackLocale before giving up (returning the raw key).
-        if (this.fallbackLocale !== locale) {
-            const fallback = this.getCompiledMessages(this.fallbackLocale)[key];
-            if (fallback) return fallback(params);
-        }
-        return key; // missing everywhere → return the key (dev-friendly)
-    }
-    getAvailableLocales() {
-        return [
-            ...this.cache.keys()
-        ];
-    }
-    isLocaleSupported(locale) {
-        return this.cache.has(locale);
-    }
-    getDefaultLocale() {
-        return this.defaultLocale;
-    }
-    getCompiledMessages(locale) {
-        const effectiveLocale = this.cache.has(locale) ? locale : this.defaultLocale;
-        const cached = this.compiledCache.get(effectiveLocale);
-        if (cached) return cached;
-        const flattened = this.flattenMessages(this.cache.get(effectiveLocale) ?? {});
-        const compiled = {};
-        for (const [key, value] of Object.entries(flattened)){
-            const msg = new IntlMessageFormat(value, effectiveLocale);
-            compiled[key] = (params)=>String(msg.format(params));
-        }
-        this.compiledCache.set(effectiveLocale, compiled);
-        return compiled;
-    }
-    flattenMessages(messages, prefix = '') {
-        const result = {};
-        for (const key of Object.keys(messages)){
-            const value = messages[key];
-            const newKey = prefix ? `${prefix}.${key}` : key;
-            if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                Object.assign(result, this.flattenMessages(value, newKey));
-            } else {
-                result[newKey] = String(value);
-            }
-        }
-        return result;
-    }
-}
-MessageLoaderService = _ts_decorate([
-    Injectable(),
-    _ts_param(0, Inject(MessageRegistry)),
-    _ts_param(1, Inject(I18N_OPTIONS)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof MessageRegistry === "undefined" ? Object : MessageRegistry,
-        typeof I18nModuleOptions === "undefined" ? Object : I18nModuleOptions
-    ])
-], MessageLoaderService);

package/dist/i18n/message-registry.d.ts

@@ -1,16 +0,0 @@
-type Contribution = Record<string, Record<string, unknown>>;
-/**
- * Accumulates i18n messages from multiple `I18nModule.registerMessages()` calls
- * (statically, at module import time), deep-merged on read by
- * {@link MessageLoaderService}. Later registrations override earlier ones at the
- * leaf level.
- */
-export declare class MessageRegistry {
-    /** Called by `I18nModule.registerMessages()`. */
-    static addMessages(messages: Contribution): void;
-    /** All contributions deep-merged, per locale, in registration order. */
-    getMergedMessages(): Record<string, Record<string, unknown>>;
-    /** @internal — testing */
-    static reset(): void;
-}
-export {};

package/dist/i18n/message-registry.js

@@ -1,49 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Injectable } from "../container/decorators.js";
-import { deepMerge } from "./deep-merge.js";
-// Shared contributions store anchored on globalThis so bundler-inlined copies
-// (portal/symlink) and Vite HMR re-eval share ONE store. Content-keyed so
-// re-registering identical messages (HMR) dedups instead of accumulating.
-const CONTRIBUTIONS_KEY = Symbol.for('vela:i18n:message-registry:contributions');
-function getContributions() {
-    const g = globalThis;
-    return g[CONTRIBUTIONS_KEY] ??= new Map();
-}
-function contentKey(value) {
-    if (Array.isArray(value)) return `[${value.map(contentKey).join(',')}]`;
-    if (typeof value === 'object' && value !== null) {
-        const entries = Object.keys(value).sort().map((key)=>`${JSON.stringify(key)}:${contentKey(value[key])}`);
-        return `{${entries.join(',')}}`;
-    }
-    return JSON.stringify(value) ?? 'undefined';
-}
-export class MessageRegistry {
-    /** Called by `I18nModule.registerMessages()`. */ static addMessages(messages) {
-        if (messages && typeof messages === 'object' && Object.keys(messages).length > 0) {
-            // set() dedups by content-key AND preserves insertion order for an existing
-            // key. (A prior delete+set moved re-registered content to the end, flipping
-            // deep-merge precedence under HMR re-eval.)
-            getContributions().set(contentKey(messages), messages);
-        }
-    }
-    /** All contributions deep-merged, per locale, in registration order. */ getMergedMessages() {
-        const merged = {};
-        for (const contribution of getContributions().values()){
-            for (const locale of Object.keys(contribution)){
-                merged[locale] = deepMerge(merged[locale] ?? {}, contribution[locale]);
-            }
-        }
-        return merged;
-    }
-    /** @internal — testing */ static reset() {
-        globalThis[CONTRIBUTIONS_KEY] = new Map();
-    }
-}
-MessageRegistry = _ts_decorate([
-    Injectable()
-], MessageRegistry);

package/dist/lifecycle/index.d.ts

@@ -1,20 +0,0 @@
-export interface OnModuleInit {
-    onModuleInit(): void | Promise<void>;
-}
-export interface OnApplicationBootstrap {
-    onApplicationBootstrap(): void | Promise<void>;
-}
-export interface OnModuleDestroy {
-    onModuleDestroy(): void | Promise<void>;
-}
-export interface OnApplicationShutdown {
-    onApplicationShutdown(signal?: string): void | Promise<void>;
-}
-export interface BeforeApplicationShutdown {
-    beforeApplicationShutdown(signal?: string): void | Promise<void>;
-}
-export declare function hasOnModuleInit(instance: unknown): instance is OnModuleInit;
-export declare function hasOnApplicationBootstrap(instance: unknown): instance is OnApplicationBootstrap;
-export declare function hasOnModuleDestroy(instance: unknown): instance is OnModuleDestroy;
-export declare function hasBeforeApplicationShutdown(instance: unknown): instance is BeforeApplicationShutdown;
-export declare function hasOnApplicationShutdown(instance: unknown): instance is OnApplicationShutdown;

package/dist/lifecycle/index.js

@@ -1,15 +0,0 @@
-export function hasOnModuleInit(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.onModuleInit === 'function';
-}
-export function hasOnApplicationBootstrap(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.onApplicationBootstrap === 'function';
-}
-export function hasOnModuleDestroy(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.onModuleDestroy === 'function';
-}
-export function hasBeforeApplicationShutdown(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.beforeApplicationShutdown === 'function';
-}
-export function hasOnApplicationShutdown(instance) {
-    return instance !== null && typeof instance === 'object' && typeof instance.onApplicationShutdown === 'function';
-}

package/dist/live/live.cursor.d.ts

@@ -1,22 +0,0 @@
-import type { CommitStamp, CursorLog, ResumeVerdict } from './live.types';
-/**
- * The in-core `CursorLog`: a bounded in-memory ring, epoch minted per process
- * (Web Crypto). A restart rolls the epoch, so every reconnecting client falls
- * back to snapshot — exactly the documented node/dev semantics. Within one
- * process lifetime resume works for gaps the ring still covers; a trimmed gap
- * degrades to snapshot (mirrors lunora's CDC retention rule,
- * `ctx-db-cdc.ts` — retention gap → snapshot).
- *
- * The Cloudflare transport replaces this with a Durable-Object SQLite log so
- * resume survives hibernation and eviction.
- */
-export declare class InMemoryCursorLog implements CursorLog {
-    private readonly maxEntries;
-    private readonly epoch;
-    private readonly entries;
-    private seq;
-    constructor(maxEntries?: number);
-    append(tags: string[]): CommitStamp;
-    current(): CommitStamp;
-    evaluateResume(sinceCursor: number, sinceEpoch: string, subscriptionTags: string[]): ResumeVerdict;
-}

package/dist/live/live.cursor.js

@@ -1,56 +0,0 @@
-const intersects = (a, b)=>a.some((tag)=>b.has(tag));
-/**
- * The in-core `CursorLog`: a bounded in-memory ring, epoch minted per process
- * (Web Crypto). A restart rolls the epoch, so every reconnecting client falls
- * back to snapshot — exactly the documented node/dev semantics. Within one
- * process lifetime resume works for gaps the ring still covers; a trimmed gap
- * degrades to snapshot (mirrors lunora's CDC retention rule,
- * `ctx-db-cdc.ts` — retention gap → snapshot).
- *
- * The Cloudflare transport replaces this with a Durable-Object SQLite log so
- * resume survives hibernation and eviction.
- */ export class InMemoryCursorLog {
-    maxEntries;
-    epoch = crypto.randomUUID();
-    entries = [];
-    seq = 0;
-    constructor(maxEntries = 1024){
-        this.maxEntries = maxEntries;
-    }
-    append(tags) {
-        this.seq += 1;
-        this.entries.push({
-            seq: this.seq,
-            tags
-        });
-        if (this.entries.length > this.maxEntries) {
-            this.entries.splice(0, this.entries.length - this.maxEntries);
-        }
-        return {
-            cursor: this.seq,
-            epoch: this.epoch
-        };
-    }
-    current() {
-        return {
-            cursor: this.seq,
-            epoch: this.epoch
-        };
-    }
-    evaluateResume(sinceCursor, sinceEpoch, subscriptionTags) {
-        // Forked timeline (restart/reset) — the client's cursor means nothing here.
-        if (sinceEpoch !== this.epoch) return 'snapshot';
-        // Rollback guard: a cursor from the future is unexplainable.
-        if (sinceCursor > this.seq) return 'snapshot';
-        if (sinceCursor === this.seq) return 'resume';
-        // Retention: the ring must still cover (sinceCursor, seq].
-        const oldest = this.entries[0];
-        if (oldest === undefined || oldest.seq > sinceCursor + 1) return 'snapshot';
-        const subTags = new Set(subscriptionTags);
-        for (const entry of this.entries){
-            if (entry.seq <= sinceCursor) continue;
-            if (intersects(entry.tags, subTags)) return 'rerun';
-        }
-        return 'resume';
-    }
-}

package/dist/live/live.decorators.d.ts

@@ -1,32 +0,0 @@
-import type { LiveQueryMetadata, LiveQueryOptions } from './live.types';
-/**
- * Marks a provider class as a live-query resolver:
- *
- * ```ts
- * @LiveResolver()
- * @Injectable()
- * class TodoLive {
- *   constructor(private readonly todos: TodoService) {}
- *
- *   @LiveQuery('todos.list', { tags: (a: { listId: string }) => [`todos:${a.listId}`] })
- *   list(args: { listId: string }, ctx: LiveQueryContext) {
- *     return this.todos.byList(args.listId, ctx.identity?.userId);
- *   }
- * }
- * ```
- *
- * Clients subscribe by query name over the `$live` reserved event; the engine
- * re-runs a handler whenever one of its tags is invalidated and pushes the
- * result (as a keyed delta when possible). Stack with `@Injectable()`, exactly
- * like `@Processor`.
- */
-export declare function LiveResolver(): ClassDecorator;
-/**
- * Declares a live query on a resolver method. The handler receives
- * `(args, ctx: LiveQueryContext)` positionally — args are validated once at
- * subscribe (via `options.parse`), then replayed verbatim into every re-run
- * under the subscriber's captured identity.
- */
-export declare function LiveQuery<A = unknown>(name: string, options: LiveQueryOptions<A>): MethodDecorator;
-/** `@LiveQuery` entries declared on a resolver class (declaration order). */
-export declare function getLiveQueries(resolverClass: object): LiveQueryMetadata[];

package/dist/live/live.decorators.js

@@ -1,46 +0,0 @@
-import { createDiscoverableDecorator, defineMetadata, getMetadata } from "../index.js";
-import { LIVE_QUERY_METADATA, LIVE_RESOLVER_METADATA } from "./live.tokens.js";
-const LiveResolverMeta = createDiscoverableDecorator(LIVE_RESOLVER_METADATA);
-/**
- * Marks a provider class as a live-query resolver:
- *
- * ```ts
- * @LiveResolver()
- * @Injectable()
- * class TodoLive {
- *   constructor(private readonly todos: TodoService) {}
- *
- *   @LiveQuery('todos.list', { tags: (a: { listId: string }) => [`todos:${a.listId}`] })
- *   list(args: { listId: string }, ctx: LiveQueryContext) {
- *     return this.todos.byList(args.listId, ctx.identity?.userId);
- *   }
- * }
- * ```
- *
- * Clients subscribe by query name over the `$live` reserved event; the engine
- * re-runs a handler whenever one of its tags is invalidated and pushes the
- * result (as a keyed delta when possible). Stack with `@Injectable()`, exactly
- * like `@Processor`.
- */ export function LiveResolver() {
-    return LiveResolverMeta({});
-}
-/**
- * Declares a live query on a resolver method. The handler receives
- * `(args, ctx: LiveQueryContext)` positionally — args are validated once at
- * subscribe (via `options.parse`), then replayed verbatim into every re-run
- * under the subscriber's captured identity.
- */ export function LiveQuery(name, options) {
-    return (target, propertyKey)=>{
-        const ctor = target.constructor;
-        const existing = getMetadata(LIVE_QUERY_METADATA, ctor) ?? [];
-        existing.push({
-            name,
-            methodName: propertyKey,
-            options: options
-        });
-        defineMetadata(LIVE_QUERY_METADATA, existing, ctor);
-    };
-}
-/** `@LiveQuery` entries declared on a resolver class (declaration order). */ export function getLiveQueries(resolverClass) {
-    return getMetadata(LIVE_QUERY_METADATA, resolverClass) ?? [];
-}

package/dist/live/live.delta.d.ts

@@ -1,15 +0,0 @@
-import type { ServerLiveFrame } from '@velajs/live-protocol';
-import type { CommitStamp, SubscriptionRecord } from './live.types';
-/**
- * Decide what one re-run puts on the wire — pure, so the contract is
- * unit-testable without sockets:
- *
- * - byte-identical to the baseline → `settled` (cursor still advances; this
- *   is what drops client optimistic layers for writes that didn't change the
- *   result);
- * - baseline exists and the shared codec can diff → `delta` (batched keyed
- *   row ops);
- * - otherwise (first send after subscribe/resume, codec bailed, unparseable
- *   baseline) → full `data` snapshot.
- */
-export declare function encodeSubscriptionUpdate(record: SubscriptionRecord, json: string, result: unknown, stamp: CommitStamp, initial: boolean): ServerLiveFrame;

package/dist/live/live.delta.js

@@ -1,51 +0,0 @@
-import { DEFAULT_KEY_FIELD, encodeListDelta } from "@velajs/live-protocol";
-/**
- * Decide what one re-run puts on the wire — pure, so the contract is
- * unit-testable without sockets:
- *
- * - byte-identical to the baseline → `settled` (cursor still advances; this
- *   is what drops client optimistic layers for writes that didn't change the
- *   result);
- * - baseline exists and the shared codec can diff → `delta` (batched keyed
- *   row ops);
- * - otherwise (first send after subscribe/resume, codec bailed, unparseable
- *   baseline) → full `data` snapshot.
- */ export function encodeSubscriptionUpdate(record, json, result, stamp, initial) {
-    const settled = {
-        t: 'settled',
-        sub: record.sub,
-        cursor: stamp.cursor,
-        epoch: stamp.epoch
-    };
-    if (!initial && record.lastJson !== undefined) {
-        if (record.lastJson === json) return settled;
-        let previous;
-        let parsed = false;
-        try {
-            previous = JSON.parse(record.lastJson);
-            parsed = true;
-        } catch  {
-        // Unparseable baseline — fall through to a snapshot.
-        }
-        if (parsed) {
-            const ops = encodeListDelta(previous, result, record.key ?? DEFAULT_KEY_FIELD);
-            if (ops !== undefined && ops.length > 0) {
-                return {
-                    t: 'delta',
-                    sub: record.sub,
-                    ops,
-                    cursor: stamp.cursor,
-                    epoch: stamp.epoch
-                };
-            }
-            if (ops !== undefined) return settled;
-        }
-    }
-    return {
-        t: 'data',
-        sub: record.sub,
-        snapshot: result,
-        cursor: stamp.cursor,
-        epoch: stamp.epoch
-    };
-}

package/dist/live/live.engine.d.ts

@@ -1,81 +0,0 @@
-import { Container, DiscoveryService } from '../index';
-import type { ContributesEntrypoints, Entrypoint, OnApplicationBootstrap, ReservedWsEventHandler, WsClient, WsMessage } from '../index';
-import type { CommitStamp, CursorLog, InvalidationCommand, LiveDriver, LiveEntrypointMeta, LiveInvalidationSink, LiveModuleOptions, SubscriptionRecord } from './live.types';
-import { PresenceService } from './presence';
-/**
- * Where the engine persists a connection's subscription records inside
- * `client.data` (committed through `WsClient.commit()`). On Cloudflare that
- * lands in the hibernation attachment, so subscriptions survive DO eviction;
- * the transport replays them via `restoreSubscription` on wake. On node,
- * `commit()` is a no-op and this is just in-memory bookkeeping.
- */
-export declare const LIVE_SUBS_DATA_KEY = "__velaLiveSubs";
-/** Read the subscription records a transport persisted for a connection (wake/restore path). */
-export declare function readPersistedLiveSubscriptions(client: WsClient): SubscriptionRecord[];
-/**
- * The live-query engine of ONE log scope: routes `$live` frames (subscribe /
- * unsubscribe / presence), owns the subscription registry, and turns tag
- * invalidations into re-run → diff → push cycles.
- *
- * Delivery semantics (ported from lunora's `shard-do.ts` refresh loop):
- * - **Coalescing**: a burst of invalidations collapses into one flush; every
- *   committed invalidation is observed by a flush that STARTS after it
- *   committed (`applyInvalidation` appends to the log before arming the
- *   drain, and the drain re-loops while tags are pending).
- * - **At-least-once**: a subscription's diff baseline (`lastJson`) advances
- *   only when the frame left the socket; keyed deltas are idempotent on
- *   replay.
- * - **Frame suppression**: a byte-identical re-run sends `settled` — no
- *   payload, but the cursor still advances so client optimistic layers drop.
- * - **Outbound expiry**: a subscription whose captured identity lapsed is
- *   dropped (socket closed) before it receives another scoped push.
- * - **Cursor-before-run**: the stamp a frame carries is read BEFORE the
- *   re-run, so a result can only be NEWER than its cursor claims — an
- *   invalidation racing the run is re-observed by the next flush, never lost.
- *
- * Transports reach the engine via `app.entrypoints.ofKind('live')` (it
- * contributes itself) — the same contract the WebSocket triad uses.
- */
-export declare class LiveEngine implements OnApplicationBootstrap, ContributesEntrypoints, ReservedWsEventHandler, LiveInvalidationSink {
-    private readonly container;
-    private readonly discovery;
-    private readonly log;
-    private readonly options;
-    private readonly presence?;
-    private readonly queries;
-    private readonly connections;
-    private readonly pendingTags;
-    private drainChain;
-    private draining;
-    constructor(container: Container, discovery: DiscoveryService, log: CursorLog, driver: LiveDriver, options: LiveModuleOptions, presence?: PresenceService | undefined);
-    onApplicationBootstrap(): Promise<void>;
-    /** The `'live'` entrypoint — how transports (node registrar, CF DO bootstrap) find the engine. */
-    collectEntrypoints(): Entrypoint<LiveEntrypointMeta>[];
-    handleReservedEvent(path: string, client: WsClient, message: WsMessage): Promise<void>;
-    handleSocketClose(_path: string, client: WsClient): Promise<void>;
-    applyInvalidation(cmd: InvalidationCommand): Promise<CommitStamp>;
-    /** Settles when every pending invalidation has been flushed (tests, graceful transports). */
-    whenIdle(): Promise<void>;
-    /**
-     * Re-attach a persisted subscription without the subscribe handshake — the
-     * Cloudflare transport replays hibernation-attachment records through this
-     * on wake. No frames are sent; the next relevant invalidation pushes.
-     */
-    restoreSubscription(path: string, client: WsClient, record: SubscriptionRecord): void;
-    private onSubscribe;
-    private runSubscribeGuards;
-    private scheduleDrain;
-    private drainLoop;
-    private push;
-    private runQuery;
-    /**
-     * Mirror the connection's records into `client.data` + `commit()` so
-     * hibernating transports can replay them on wake. The volatile diff
-     * baseline (`lastJson`/`lastCursor`) is deliberately stripped: it can be
-     * large (the whole last result vs the 16 KiB attachment cap) and a lost
-     * baseline just means the next relevant change sends a full snapshot.
-     */
-    private persistSubscriptions;
-    private ensureConnection;
-    private sendFrame;
-}