@carno.js/live 1.8.0

package/dist/LivePlugin.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivePlugin = void 0;
+const core_1 = require("@carno.js/core");
+const orm_1 = require("@carno.js/orm");
+const websocket_1 = require("@carno.js/websocket");
+const authorizer_1 = require("./auth/authorizer");
+const InProcessBus_1 = require("./bus/InProcessBus");
+const PgNotifyBus_1 = require("./bus/PgNotifyBus");
+const pg_notify_emitter_1 = require("./emitters/pg-notify-emitter");
+const config_1 = require("./config");
+const AppEmitter_1 = require("./emitters/AppEmitter");
+const DependencyGraph_1 = require("./graph/DependencyGraph");
+const SubscriptionRegistry_1 = require("./graph/SubscriptionRegistry");
+const LiveEngine_1 = require("./LiveEngine");
+const observability_1 = require("./observability");
+const LiveService_1 = require("./LiveService");
+const ResourceRegistry_1 = require("./resource/ResourceRegistry");
+const route_executor_1 = require("./resource/route-executor");
+const runtime_1 = require("./runtime");
+const etag_1 = require("./http/etag");
+const FanTransport_1 = require("./transport/FanTransport");
+const LiveGateway_1 = require("./transport/LiveGateway");
+const scope_resolver_1 = require("./transport/scope-resolver");
+const SocketTransport_1 = require("./transport/SocketTransport");
+const SseTransport_1 = require("./transport/SseTransport");
+const sse_routes_1 = require("./transport/sse-routes");
+const protocol_1 = require("./shared/protocol");
+class LivePlugin {
+    static create(options) {
+        const config = (0, config_1.resolveLiveConfig)(options.config);
+        const resources = new ResourceRegistry_1.ResourceRegistry();
+        const graph = new DependencyGraph_1.DependencyGraph();
+        const subs = new SubscriptionRegistry_1.SubscriptionRegistry();
+        const distributedBus = options.distributed
+            ? new PgNotifyBus_1.PgNotifyBus({
+                url: options.distributed.url ?? '',
+                channel: options.distributed.channel,
+                nodeId: options.distributed.nodeId
+            })
+            : null;
+        const bus = distributedBus ?? new InProcessBus_1.InProcessBus();
+        const sockets = new SocketTransport_1.SocketTransport();
+        const fan = new FanTransport_1.FanTransport();
+        fan.add(sockets);
+        let sink = null;
+        const metrics = new observability_1.LiveMetrics({
+            onMetric: (name, value, tags) => sink?.onMetric(name, value, tags)
+        });
+        const engine = new LiveEngine_1.LiveEngine(resources, graph, subs, bus, fan, config, options.authorizer ?? new authorizer_1.AllowAllAuthorizer(), metrics);
+        const emitter = new AppEmitter_1.AppEmitter(bus, config);
+        const scopeResolver = options.scopeResolver ?? new scope_resolver_1.ConnectionScopeResolver();
+        const dispose = [() => engine.stop()];
+        (0, runtime_1.setLiveRuntime)({
+            engine,
+            transport: sockets,
+            resolver: scopeResolver,
+            scopes: new Map(),
+            handshakes: new Set(),
+            resources,
+            dispose
+        });
+        const plugin = new core_1.Carno({ exports: [] });
+        plugin.controllers(options.controllers);
+        plugin.services([LiveService_1.LiveService]);
+        if (options.sse) {
+            const sse = new SseTransport_1.SseTransport({
+                heartbeatMs: config.sseHeartbeatMs,
+                maxConnections: config.sseMaxConnections,
+                onDisconnect: LiveGateway_1.dropLiveConnection
+            });
+            fan.add(sse);
+            dispose.push(() => sse.stop());
+            const routes = (0, sse_routes_1.createSseRoutes)({
+                transport: sse,
+                streamPath: config.ssePath,
+                controlPath: config.sseControlPath
+            });
+            plugin.route('GET', routes.streamPath, routes.stream);
+            plugin.route('POST', routes.controlPath, routes.control);
+        }
+        let teachEtag = null;
+        // Registered now, taught later: `plugin.middlewares()` runs before
+        // bootstrap, and the resources are only known inside the builder.
+        // The middleware also gates polling, even when ETags are disabled.
+        const etag = new etag_1.LiveETagMiddleware([], { enabled: options.etag !== false });
+        etag.setPollingGuard(async ({ resourceId, inputs, request }) => {
+            const connectionId = request.headers.get(protocol_1.LIVE_CONNECTION_HEADER);
+            if (!connectionId) {
+                return null;
+            }
+            let scope;
+            try {
+                scope = await scopeResolver.resolve({
+                    connectionId,
+                    token: request.headers.get(protocol_1.LIVE_TOKEN_HEADER) ?? undefined
+                });
+            }
+            catch {
+                return null;
+            }
+            return await engine.authorizePolling(connectionId, resourceId, inputs, scope)
+                ? scope
+                : null;
+        });
+        plugin.middlewares([etag]);
+        teachEtag = paths => etag.setPaths(paths);
+        const websocket = websocket_1.WebSocketPlugin.create([LiveGateway_1.LiveGateway, ...(options.gateways ?? [])], options.websocket);
+        const innerBuilder = websocket._wsHandlerBuilder;
+        const upgradePaths = [...websocket._wsUpgradePaths];
+        plugin.use(websocket);
+        // The builder runs after bootstrap, when the container holds the
+        // controller instances and the ORM holds its connection — which is why
+        // everything that needs a database URL is started here and not above.
+        plugin.wsHandler((container) => {
+            // Resolved here and not above: the container does not exist until
+            // bootstrap, and an app with no observability plugin never
+            // registers one.
+            sink = container.has(core_1.ObservabilityService) ? container.get(core_1.ObservabilityService) : null;
+            const routeExecutor = (0, route_executor_1.createLiveRouteExecutor)(container.get(core_1.Carno));
+            for (const ControllerClass of options.controllers) {
+                resources.register(ControllerClass, container.get(ControllerClass), routeExecutor);
+            }
+            teachEtag?.(resources.livePaths());
+            if (options.pgNotify) {
+                const driver = orm_1.Orm.getInstance().driverInstance;
+                const deliver = (events) => {
+                    // A trigger already notified every node. Publishing it on
+                    // the bus would send it around a second time.
+                    if (distributedBus) {
+                        distributedBus.publishLocal(events);
+                        return;
+                    }
+                    bus.publish(events);
+                };
+                const pgEmitter = new pg_notify_emitter_1.PgNotifyEmitter(deliver, {
+                    tables: options.pgNotify.tables,
+                    url: options.pgNotify.url ?? driver.connectionString,
+                    channel: options.pgNotify.channel,
+                    execute: sql => driver.executeSql(sql)
+                });
+                // Two emitters on one table would wake the same instance twice.
+                emitter.setCoveredTables(pgEmitter.coveredTables());
+                dispose.push(() => pgEmitter.detach());
+                void pgEmitter.attach().catch(error => {
+                    console.error('[carno:live] the Postgres emitter failed to attach', error);
+                });
+            }
+            if (distributedBus) {
+                if (!options.distributed?.url) {
+                    distributedBus.setUrl(orm_1.Orm.getInstance().driverInstance.connectionString);
+                }
+                void distributedBus.start().catch(error => {
+                    console.error('[carno:live] the distributed bus failed to start', error);
+                });
+                dispose.push(() => distributedBus.stop());
+            }
+            emitter.attach();
+            engine.start();
+            return innerBuilder(container);
+        }, upgradePaths);
+        return plugin;
+    }
+}
+exports.LivePlugin = LivePlugin;

package/dist/LiveService.d.ts

@@ -0,0 +1,32 @@
+import { type LivePayload } from './resource/prefetch';
+import { type LiveDescriptor } from './shared/descriptor';
+import type { LiveExecutionContext, LiveInputs } from './resource/types';
+/**
+ * Manual invalidation — the third emitter of §4.4, for data the ORM cannot
+ * see: a rebuilt report, a webhook, an external cache.
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * export class ReportJob {
+ *     constructor(private readonly live: LiveService) {}
+ *
+ *     @Cron('0 * * * *')
+ *     async run() {
+ *         await this.rebuild();
+ *         this.live.invalidate('app:report:current');
+ *     }
+ * }
+ * ```
+ */
+export declare class LiveService {
+    invalidate(key: string): void;
+    /**
+     * Compute a live resource for a server-rendered first paint.
+     *
+     * Hand the payload to the template; the client starts full and its
+     * subscription carries only the hash, so the first screen costs one
+     * request instead of two and the data is never sent twice.
+     */
+    prefetch(resource: string | LiveDescriptor<any>, inputs?: Partial<LiveInputs>, context?: LiveExecutionContext): Promise<LivePayload>;
+}

package/dist/LiveService.js

@@ -0,0 +1,51 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveService = void 0;
+const core_1 = require("@carno.js/core");
+const runtime_1 = require("./runtime");
+const prefetch_1 = require("./resource/prefetch");
+const descriptor_1 = require("./shared/descriptor");
+/**
+ * Manual invalidation — the third emitter of §4.4, for data the ORM cannot
+ * see: a rebuilt report, a webhook, an external cache.
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * export class ReportJob {
+ *     constructor(private readonly live: LiveService) {}
+ *
+ *     @Cron('0 * * * *')
+ *     async run() {
+ *         await this.rebuild();
+ *         this.live.invalidate('app:report:current');
+ *     }
+ * }
+ * ```
+ */
+let LiveService = class LiveService {
+    invalidate(key) {
+        (0, runtime_1.getLiveRuntime)().engine.invalidate(key);
+    }
+    /**
+     * Compute a live resource for a server-rendered first paint.
+     *
+     * Hand the payload to the template; the client starts full and its
+     * subscription carries only the hash, so the first screen costs one
+     * request instead of two and the data is never sent twice.
+     */
+    prefetch(resource, inputs = {}, context = {}) {
+        const resourceId = typeof resource === 'string' ? resource : (0, descriptor_1.resourceIdOf)(resource);
+        return (0, prefetch_1.prefetchLive)((0, runtime_1.getLiveRuntime)().resources, resourceId, inputs, context);
+    }
+};
+exports.LiveService = LiveService;
+exports.LiveService = LiveService = __decorate([
+    (0, core_1.Service)()
+], LiveService);

package/dist/auth/authorizer.d.ts

@@ -0,0 +1,33 @@
+import type { LiveMeta } from '../metadata';
+import type { LiveInputs, LiveScope } from '../shared/inputs';
+export interface LiveAuthorizationRequest {
+    resourceId: string;
+    controllerName: string;
+    handlerName: string;
+    meta: LiveMeta;
+    inputs: LiveInputs;
+    scope: LiveScope;
+    connectionId: string;
+}
+/**
+ * Decides whether one connection may hold one subscription.
+ *
+ * Called when the subscription is created and again whenever the connection's
+ * `auth:` key is invalidated. Returning false ends that connection's
+ * subscription; it never affects the other subscribers of a shared instance.
+ */
+export interface LiveAuthorizer {
+    authorize(request: LiveAuthorizationRequest): boolean | Promise<boolean>;
+}
+/** Default. The scope already isolates instances, so nothing extra is refused. */
+export declare class AllowAllAuthorizer implements LiveAuthorizer {
+    authorize(): boolean;
+}
+export declare function isAuthKey(key: string): boolean;
+/**
+ * The authorization keys a connection with this scope answers to.
+ *
+ * Same two-level shape as the ORM keys: `auth:principal#42` is contained by
+ * `auth:principal`, so invalidating the parent re-checks everyone.
+ */
+export declare function authKeysOf(scope: LiveScope): string[];

package/dist/auth/authorizer.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AllowAllAuthorizer = void 0;
+exports.isAuthKey = isAuthKey;
+exports.authKeysOf = authKeysOf;
+/** Default. The scope already isolates instances, so nothing extra is refused. */
+class AllowAllAuthorizer {
+    authorize() {
+        return true;
+    }
+}
+exports.AllowAllAuthorizer = AllowAllAuthorizer;
+const AUTH_PREFIX = 'auth:';
+function isAuthKey(key) {
+    return key.startsWith(AUTH_PREFIX);
+}
+/**
+ * The authorization keys a connection with this scope answers to.
+ *
+ * Same two-level shape as the ORM keys: `auth:principal#42` is contained by
+ * `auth:principal`, so invalidating the parent re-checks everyone.
+ */
+function authKeysOf(scope) {
+    const keys = [];
+    if (scope.principal !== undefined && scope.principal !== null && scope.principal !== '') {
+        keys.push(`${AUTH_PREFIX}principal#${scope.principal}`);
+    }
+    if (scope.tenant !== undefined && scope.tenant !== null && scope.tenant !== '') {
+        keys.push(`${AUTH_PREFIX}tenant#${scope.tenant}`);
+    }
+    return keys;
+}

package/dist/bus/InProcessBus.d.ts

@@ -0,0 +1,8 @@
+import type { InvalidationBus, InvalidationHandler } from './InvalidationBus';
+import type { InvalidationEvent } from '../graph/types';
+/** Single-process bus. Correct for one node; phase 2 adds the distributed ones. */
+export declare class InProcessBus implements InvalidationBus {
+    private readonly handlers;
+    publish(events: InvalidationEvent[]): void;
+    subscribe(handler: InvalidationHandler): () => void;
+}

package/dist/bus/InProcessBus.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InProcessBus = void 0;
+/** Single-process bus. Correct for one node; phase 2 adds the distributed ones. */
+class InProcessBus {
+    constructor() {
+        this.handlers = new Set();
+    }
+    publish(events) {
+        if (events.length === 0) {
+            return;
+        }
+        for (const handler of this.handlers) {
+            try {
+                handler(events);
+            }
+            catch (error) {
+                // One broken subscriber must not swallow invalidations for the
+                // others: a dropped invalidation is a screen frozen on stale data.
+                console.error('[carno:live] invalidation handler failed', error);
+            }
+        }
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+}
+exports.InProcessBus = InProcessBus;

package/dist/bus/InvalidationBus.d.ts

@@ -0,0 +1,15 @@
+import type { InvalidationEvent } from '../graph/types';
+export type InvalidationHandler = (events: InvalidationEvent[]) => void;
+/**
+ * Carries invalidations from an emitter to the nodes holding subscriptions.
+ *
+ * The graph does not care where an invalidation came from, which is why the
+ * ORM emitter, the Postgres emitter and manual invalidation are three
+ * implementations feeding one interface. Phase 1 ships the in-process one;
+ * Redis and pg_notify buses arrive in phase 2 without touching the graph.
+ */
+export interface InvalidationBus {
+    publish(events: InvalidationEvent[]): void;
+    /** Returns an unsubscribe function. */
+    subscribe(handler: InvalidationHandler): () => void;
+}

package/dist/bus/InvalidationBus.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/bus/PgNotifyBus.d.ts

@@ -0,0 +1,55 @@
+import type { InvalidationEvent } from '../graph/types';
+import { PgListener } from '../emitters/pg-listener';
+import type { InvalidationBus, InvalidationHandler } from './InvalidationBus';
+export declare const DEFAULT_PG_BUS_CHANNEL = "carno_live_bus";
+export declare const DEFAULT_PG_BUS_MAX_PAYLOAD_BYTES = 7000;
+export interface PgNotifyBusOptions {
+    /** May be empty at construction; `setUrl` fills it before `start()`. */
+    url: string;
+    channel?: string;
+    /** Identifies this process so its own echo can be dropped. */
+    nodeId?: string;
+    maxPayloadBytes?: number;
+    heartbeatMs?: number;
+    retryMs?: number;
+    /** Injected in tests. */
+    listener?: PgListener;
+}
+/**
+ * Split events into `pg_notify` frames under the payload ceiling.
+ *
+ * A single event that does not fit on its own degrades to its table key: a
+ * coarse invalidation costs CPU, a dropped one costs a screen frozen on stale
+ * data.
+ */
+export declare function chunkEvents(events: InvalidationEvent[], nodeId: string, maxPayloadBytes: number): string[];
+/**
+ * Invalidation bus across nodes, over `LISTEN/NOTIFY`.
+ *
+ * Two entry points, on purpose. `publish` is for a source local to this node —
+ * the ORM emitter, `LiveService.invalidate()` — and has to reach the others.
+ * `publishLocal` is for a source that already reached every node, which is what
+ * a Postgres trigger is; re-publishing that would multiply one write by the
+ * size of the cluster.
+ */
+export declare class PgNotifyBus implements InvalidationBus {
+    private readonly options;
+    readonly nodeId: string;
+    private readonly handlers;
+    private readonly channel;
+    private readonly maxPayloadBytes;
+    private listener;
+    private url;
+    constructor(options: PgNotifyBusOptions);
+    /** Called by the plugin once the ORM knows where the database is. */
+    setUrl(url: string): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    publish(events: InvalidationEvent[]): void;
+    /** Deliver here only: the source already reached every node. */
+    publishLocal(events: InvalidationEvent[]): void;
+    subscribe(handler: InvalidationHandler): () => void;
+    private broadcast;
+    private onFrame;
+    private deliver;
+}

package/dist/bus/PgNotifyBus.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PgNotifyBus = exports.DEFAULT_PG_BUS_MAX_PAYLOAD_BYTES = exports.DEFAULT_PG_BUS_CHANNEL = void 0;
+exports.chunkEvents = chunkEvents;
+const dep_key_1 = require("../graph/dep-key");
+const pg_listener_1 = require("../emitters/pg-listener");
+exports.DEFAULT_PG_BUS_CHANNEL = 'carno_live_bus';
+exports.DEFAULT_PG_BUS_MAX_PAYLOAD_BYTES = 7000;
+/**
+ * Split events into `pg_notify` frames under the payload ceiling.
+ *
+ * A single event that does not fit on its own degrades to its table key: a
+ * coarse invalidation costs CPU, a dropped one costs a screen frozen on stale
+ * data.
+ */
+function chunkEvents(events, nodeId, maxPayloadBytes) {
+    const encode = (items) => JSON.stringify({ n: nodeId, e: items });
+    const frames = [];
+    let batch = [];
+    for (const event of events) {
+        let item = event;
+        if (Buffer.byteLength(encode([item]), 'utf8') > maxPayloadBytes) {
+            const table = (0, dep_key_1.tableOfKey)(item.key);
+            item = { key: table ? (0, dep_key_1.tableKey)(table) : item.key, columns: null };
+        }
+        if (batch.length > 0 && Buffer.byteLength(encode([...batch, item]), 'utf8') > maxPayloadBytes) {
+            frames.push(encode(batch));
+            batch = [item];
+            continue;
+        }
+        batch.push(item);
+    }
+    if (batch.length > 0) {
+        frames.push(encode(batch));
+    }
+    return frames;
+}
+/**
+ * Invalidation bus across nodes, over `LISTEN/NOTIFY`.
+ *
+ * Two entry points, on purpose. `publish` is for a source local to this node —
+ * the ORM emitter, `LiveService.invalidate()` — and has to reach the others.
+ * `publishLocal` is for a source that already reached every node, which is what
+ * a Postgres trigger is; re-publishing that would multiply one write by the
+ * size of the cluster.
+ */
+class PgNotifyBus {
+    constructor(options) {
+        this.options = options;
+        this.handlers = new Set();
+        this.nodeId = options.nodeId ?? crypto.randomUUID();
+        this.channel = options.channel ?? exports.DEFAULT_PG_BUS_CHANNEL;
+        this.maxPayloadBytes = options.maxPayloadBytes ?? exports.DEFAULT_PG_BUS_MAX_PAYLOAD_BYTES;
+        this.listener = options.listener ?? null;
+        this.url = options.url;
+    }
+    /** Called by the plugin once the ORM knows where the database is. */
+    setUrl(url) {
+        this.url = url;
+    }
+    async start() {
+        if (!this.listener) {
+            this.listener = new pg_listener_1.PgListener({
+                url: this.url,
+                heartbeatMs: this.options.heartbeatMs,
+                retryMs: this.options.retryMs
+            });
+        }
+        await this.listener.listen(this.channel, raw => this.onFrame(raw));
+    }
+    async stop() {
+        await this.listener?.close();
+    }
+    publish(events) {
+        if (events.length === 0) {
+            return;
+        }
+        this.deliver(events);
+        void this.broadcast(events);
+    }
+    /** Deliver here only: the source already reached every node. */
+    publishLocal(events) {
+        if (events.length === 0) {
+            return;
+        }
+        this.deliver(events);
+    }
+    subscribe(handler) {
+        this.handlers.add(handler);
+        return () => this.handlers.delete(handler);
+    }
+    // ------------------------------------------------------------ internals
+    async broadcast(events) {
+        const listener = this.listener;
+        if (!listener) {
+            console.error('[carno:live] the distributed bus is not started; invalidation stayed local');
+            return;
+        }
+        for (const frame of chunkEvents(events, this.nodeId, this.maxPayloadBytes)) {
+            try {
+                await listener.notify(this.channel, frame);
+            }
+            catch (error) {
+                // The other nodes will miss this one. Loud, because the symptom
+                // over there is a screen that simply stops updating.
+                console.error('[carno:live] failed to broadcast an invalidation', error);
+            }
+        }
+    }
+    onFrame(raw) {
+        let frame;
+        try {
+            frame = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (!frame || typeof frame.n !== 'string' || !Array.isArray(frame.e)) {
+            return;
+        }
+        if (frame.n === this.nodeId) {
+            // Our own echo. These were delivered locally before being sent.
+            return;
+        }
+        this.deliver(frame.e);
+    }
+    deliver(events) {
+        for (const handler of this.handlers) {
+            try {
+                handler(events);
+            }
+            catch (error) {
+                console.error('[carno:live] invalidation handler failed', error);
+            }
+        }
+    }
+}
+exports.PgNotifyBus = PgNotifyBus;

package/dist/client/angular.d.ts

@@ -0,0 +1,19 @@
+import { InjectionToken, Injector, type Provider, type Signal } from '@angular/core';
+import type { LiveDataOf, LiveDescriptor, LiveInputsOf } from '../shared/descriptor';
+import type { LiveClient, LiveState } from './core';
+/** How a component finds the client without every call site passing it. */
+export declare const LIVE_CLIENT: InjectionToken<LiveClient>;
+export declare function provideLive(client: LiveClient): Provider;
+export interface LiveSignalOptions {
+    /** Overrides the injected client. Mostly for tests and for multi-backend apps. */
+    client?: LiveClient;
+    /** Required when calling outside an injection context. */
+    injector?: Injector;
+}
+/**
+ * The function production `effect()` calls. bun:test has no EffectScheduler,
+ * so tests invoke this in place of `TestBed.flushEffects()`.
+ */
+export declare function reconcileLiveSignal(state: object): void;
+export declare function liveSignal<R>(descriptor: LiveDescriptor<R>, inputs?: () => LiveInputsOf<R>, options?: LiveSignalOptions): Signal<LiveState<LiveDataOf<R>>>;
+export declare function liveSignal<T>(resourceId: string, inputs?: () => Record<string, any>, options?: LiveSignalOptions): Signal<LiveState<T>>;

package/dist/client/angular.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIVE_CLIENT = void 0;
+exports.provideLive = provideLive;
+exports.reconcileLiveSignal = reconcileLiveSignal;
+exports.liveSignal = liveSignal;
+const core_1 = require("@angular/core");
+const vanilla_1 = require("./vanilla");
+/** How a component finds the client without every call site passing it. */
+exports.LIVE_CLIENT = new core_1.InjectionToken('carno.live.client');
+function provideLive(client) {
+    return { provide: exports.LIVE_CLIENT, useValue: client };
+}
+const PENDING = { data: undefined, pending: true, error: null, stale: false };
+/** bun:test Injector.create has no APP_EFFECT_SCHEDULER (an unnamed InjectionToken). */
+function isMissingEffectScheduler(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.includes('NullInjectorError') && message.includes('No provider for InjectionToken');
+}
+const reconcilers = new WeakMap();
+/**
+ * The function production `effect()` calls. bun:test has no EffectScheduler,
+ * so tests invoke this in place of `TestBed.flushEffects()`.
+ */
+function reconcileLiveSignal(state) {
+    const reconcile = reconcilers.get(state);
+    if (!reconcile) {
+        throw new Error('reconcileLiveSignal() expected a liveSignal() state');
+    }
+    reconcile();
+}
+/**
+ * Subscribe a component to server-owned state, as a signal.
+ *
+ * `inputs` is read reactively, so changing a signal it touches re-points the
+ * subscription and cancels the previous one. Teardown is `DestroyRef`, so
+ * there is nothing to unsubscribe by hand, and nothing here touches zone.js.
+ */
+function liveSignal(resource, inputs = () => ({}), options = {}) {
+    const client = options.client ?? (0, core_1.inject)(exports.LIVE_CLIENT);
+    const destroyRef = options.injector
+        ? options.injector.get(core_1.DestroyRef)
+        : (0, core_1.inject)(core_1.DestroyRef);
+    const state = (0, core_1.signal)(PENDING);
+    const slot = new vanilla_1.LiveSlot(client, next => state.set(next));
+    // A computed, not a raw call: the effect below then re-runs only when the
+    // inputs actually recompute to something different, and LiveSlot ignores
+    // the ones that recompute to the same thing.
+    const target = (0, core_1.computed)(() => inputs());
+    function reconcile() {
+        slot.point(resource, target());
+    }
+    try {
+        // LiveSlot.point() writes the output signal synchronously. Angular 18
+        // forbids that inside an effect unless allowSignalWrites is set.
+        (0, core_1.effect)(() => reconcile(), {
+            allowSignalWrites: true,
+            injector: options.injector
+        });
+    }
+    catch (error) {
+        // bun:test has no EffectScheduler. Any other construction failure is real.
+        if (!isMissingEffectScheduler(error)) {
+            throw error;
+        }
+    }
+    destroyRef.onDestroy(() => slot.close());
+    const output = state.asReadonly();
+    reconcilers.set(output, reconcile);
+    return output;
+}