@vibesdotdev/runnable 0.0.0-stage → 1.0.0-rc.0

package/dist/svelte/runs/data.svelte.js

@@ -0,0 +1,28 @@
+/** The one private state container for a RunsStore instance; operations live with their subscription phase. */
+export class RunsData {
+    source;
+    query;
+    projection;
+    /** Latest full watch delivery, or null before the first one. Owner object, not a rebuild. */
+    snapshot = $state.raw(null);
+    catalogSnapshot = $state.raw(null);
+    lastReceivedAt = $state(null);
+    detailLoading = $state(false);
+    connection = $state('idle');
+    /** True only while this attempt is waiting for its first delivery. */
+    loading = $state(false);
+    /**
+     * Watch `onError` stores `FailureFacts`. Setup and cleanup store the thrown
+     * cause. Null means this attempt has not failed.
+     */
+    error = $state.raw(null);
+    /** Selection intent. It may name a run the current delivery does not include. */
+    selectedId = $state(null);
+    detail = $state.raw(null);
+    lifetime = { detailStop: null, detailEpoch: 0, detailAttempts: new Set(), epoch: 0, seenEpoch: -1, attempt: null, stop: null, cleanup: null, closing: null, signal: null, onAbort: null };
+    constructor(source, query, projection) {
+        this.source = source;
+        this.query = query;
+        this.projection = projection;
+    }
+}

package/dist/svelte/runs/opening.d.ts

@@ -0,0 +1,8 @@
+import type { RunnableWatchSnapshot } from "../../schemas/runs.ts";
+import type { RunsData } from "./data.svelte.ts";
+import type { RunsOpenOptions, WatchStop } from "../../schemas/contracts/watch.ts";
+export declare function openRunsWatch(data: RunsData, options?: RunsOpenOptions): Promise<void>;
+export declare function startRunsWatch(data: RunsData, epoch: number, signal: AbortSignal | undefined): Promise<void>;
+export declare function subscribeRunsWatch(data: RunsData, epoch: number, signal: AbortSignal | undefined): Promise<WatchStop>;
+export declare function acceptRunsSnapshot(data: RunsData, epoch: number, delivered: RunnableWatchSnapshot): void;
+//# sourceMappingURL=opening.d.ts.map

package/dist/svelte/runs/opening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening.d.ts","sourceRoot":"","sources":["../../../src/svelte/runs/opening.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AACnE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAEnF,wBAAsB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAkC5F;AACD,wBAAsB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAmBlH;AACD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAqC3H;AACD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,qBAAqB,GAAG,IAAI,CAWxG"}

package/dist/svelte/runs/opening.js

@@ -0,0 +1,110 @@
+import { followSelectedRun } from "./selection.js";
+import { CapabilityError } from "@vibesdotdev/kernel";
+import { finishRunsWatch, listenRunsAbort, detachRunsAbort } from "./shutdown.js";
+export async function openRunsWatch(data, options) {
+    if (data.lifetime.closing)
+        await data.lifetime.closing;
+    if (data.connection === 'open')
+        return;
+    if (data.connection === 'connecting' && data.lifetime.attempt)
+        return data.lifetime.attempt;
+    if (data.lifetime.cleanup) {
+        await data.lifetime.cleanup;
+        data.lifetime.cleanup = null;
+    }
+    const epoch = data.lifetime.epoch;
+    const signal = options?.signal;
+    if (signal?.aborted) {
+        data.error = signal.reason;
+        data.connection = 'closed';
+        signal.throwIfAborted();
+    }
+    const started = Promise.withResolvers();
+    const attempt = started.promise.then(() => startRunsWatch(data, epoch, signal));
+    data.lifetime.attempt = attempt;
+    listenRunsAbort(data, signal);
+    data.error = null;
+    data.loading = true;
+    // State writes stop here so a synchronous close from a subscriber cannot be overwritten.
+    data.connection = 'connecting';
+    started.resolve();
+    try {
+        await attempt;
+    }
+    finally {
+        if (data.lifetime.attempt === attempt)
+            data.lifetime.attempt = null;
+    }
+}
+export async function startRunsWatch(data, epoch, signal) {
+    if (epoch !== data.lifetime.epoch) {
+        detachRunsAbort(data);
+        data.loading = false;
+        throw new CapabilityError('Runnable watch closed before the subscription was established.', 'CANCELLED', { reason: 'runnable-watch-closed' });
+    }
+    const stop = await subscribeRunsWatch(data, epoch, signal);
+    if (epoch !== data.lifetime.epoch) {
+        detachRunsAbort(data);
+        await finishRunsWatch(data, stop);
+        throw new CapabilityError('Runnable watch closed before the subscription was established.', 'CANCELLED', { reason: 'runnable-watch-closed' });
+    }
+    data.lifetime.stop = stop;
+    if (data.connection === 'connecting')
+        data.connection = 'open';
+    data.loading = false;
+    if (data.selectedId !== null && data.lifetime.detailStop === null && data.lifetime.detailAttempts.size === 0) {
+        await followSelectedRun(data, epoch);
+    }
+}
+export async function subscribeRunsWatch(data, epoch, signal) {
+    const listener = (delivered) => {
+        acceptRunsSnapshot(data, epoch, delivered);
+    };
+    const onError = (failure) => {
+        if (epoch !== data.lifetime.epoch)
+            return;
+        data.error = failure;
+    };
+    try {
+        if (data.projection === 'catalog') {
+            const options = signal === undefined ? { onError } : { onError, signal };
+            return await data.source.watchCatalog(data.query, delivered => {
+                if (epoch !== data.lifetime.epoch)
+                    return;
+                if (data.lifetime.seenEpoch === epoch && data.catalogSnapshot !== null && delivered.revision < data.catalogSnapshot.revision)
+                    return;
+                data.lifetime.seenEpoch = epoch;
+                data.catalogSnapshot = delivered;
+                data.lastReceivedAt = Date.now();
+                data.loading = false;
+                data.error = null;
+            }, options);
+        }
+        const options = signal === undefined
+            ? { onError, projection: data.projection }
+            : { onError, projection: data.projection, signal };
+        return await data.source.watch(data.query, listener, options);
+    }
+    catch (cause) {
+        if (epoch === data.lifetime.epoch) {
+            data.error = cause;
+            data.lifetime.epoch += 1;
+            data.connection = 'closed';
+            data.loading = false;
+            detachRunsAbort(data);
+        }
+        throw cause;
+    }
+}
+export function acceptRunsSnapshot(data, epoch, delivered) {
+    if (epoch !== data.lifetime.epoch)
+        return;
+    const held = data.lifetime.seenEpoch === epoch ? data.snapshot : null;
+    if (held !== null && delivered.revision < held.revision)
+        return;
+    data.lifetime.seenEpoch = epoch;
+    data.snapshot = delivered;
+    data.lastReceivedAt = Date.now();
+    data.loading = false;
+    data.error = null;
+}

package/dist/svelte/runs/query.d.ts

@@ -0,0 +1,3 @@
+import { type RunnableReadQuery } from "../../schemas/runs.ts";
+export declare function admitQuery(input: RunnableReadQuery): RunnableReadQuery;
+//# sourceMappingURL=query.d.ts.map

package/dist/svelte/runs/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../../src/svelte/runs/query.ts"],"names":[],"mappings":"AACA,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACxF,wBAAgB,UAAU,CAAC,KAAK,EAAE,iBAAiB,GAAG,iBAAiB,CAItE"}

package/dist/svelte/runs/query.js

@@ -0,0 +1,16 @@
+import { isJsonObject } from "@vibesdotdev/kernel/schemas/json";
+import { RunnableReadQuerySchema } from "../../schemas/runs.js";
+export function admitQuery(input) {
+    const admitted = structuredClone(RunnableReadQuerySchema.strict().parse(input));
+    freezeJson(admitted);
+    return admitted;
+}
+function freezeJson(value) {
+    if (value === undefined || (!Array.isArray(value) && !isJsonObject(value)))
+        return;
+    if (Object.isFrozen(value))
+        return;
+    for (const nested of Object.values(value))
+        freezeJson(nested);
+    Object.freeze(value);
+}

package/dist/svelte/runs/selection.d.ts

@@ -0,0 +1,3 @@
+import type { RunsData } from "./data.svelte.ts";
+export declare function followSelectedRun(data: RunsData, epoch: number): Promise<void>;
+//# sourceMappingURL=selection.d.ts.map

package/dist/svelte/runs/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../../src/svelte/runs/selection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAwCpF"}

package/dist/svelte/runs/selection.js

@@ -0,0 +1,42 @@
+export async function followSelectedRun(data, epoch) {
+    const generation = ++data.lifetime.detailEpoch;
+    const previous = data.lifetime.detailStop;
+    data.lifetime.detailStop = null;
+    if (previous) {
+        try {
+            await previous();
+        }
+        catch (cause) {
+            if (generation === data.lifetime.detailEpoch && epoch === data.lifetime.epoch)
+                data.error = cause;
+            throw cause;
+        }
+    }
+    if (generation !== data.lifetime.detailEpoch || epoch !== data.lifetime.epoch)
+        return;
+    if (data.lifetime.closing !== null) {
+        data.detailLoading = false;
+        return;
+    }
+    const id = data.selectedId;
+    if (id === null) {
+        data.detail = null;
+        return;
+    }
+    const stop = await data.source.watch({ id }, (delivered) => {
+        if (generation !== data.lifetime.detailEpoch || epoch !== data.lifetime.epoch || data.selectedId !== id)
+            return;
+        data.detail = delivered.runs.find((snapshot) => snapshot.run.id === id) ?? null;
+        data.detailLoading = false;
+    }, (failure) => {
+        if (generation !== data.lifetime.detailEpoch || epoch !== data.lifetime.epoch)
+            return;
+        data.error = failure;
+        data.detailLoading = false;
+    });
+    if (generation !== data.lifetime.detailEpoch || epoch !== data.lifetime.epoch) {
+        await stop();
+        return;
+    }
+    data.lifetime.detailStop = stop;
+}

package/dist/svelte/runs/shutdown.d.ts

@@ -0,0 +1,9 @@
+import type { RunsData } from "./data.svelte.ts";
+import type { WatchStop } from "../../schemas/contracts/watch.ts";
+export declare function closeRunsWatch(data: RunsData): Promise<void>;
+export declare function shutdownRunsWatch(data: RunsData): Promise<void>;
+export declare function retireRunsWatch(data: RunsData): Promise<void>;
+export declare function finishRunsWatch(data: RunsData, stop: WatchStop): Promise<void>;
+export declare function listenRunsAbort(data: RunsData, signal: AbortSignal | undefined): void;
+export declare function detachRunsAbort(data: RunsData): void;
+//# sourceMappingURL=shutdown.d.ts.map

package/dist/svelte/runs/shutdown.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shutdown.d.ts","sourceRoot":"","sources":["../../../src/svelte/runs/shutdown.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,wBAAsB,cAAc,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBlE;AACD,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAOrE;AACD,wBAAsB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAyCnE;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAa9E;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,GAAG,SAAS,GAAG,IAAI,CAYrF;AACD,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI,CAMpD"}

package/dist/svelte/runs/shutdown.js

@@ -0,0 +1,104 @@
+import { CaughtFailureSchema, isCapabilityError } from "@vibesdotdev/kernel";
+export async function closeRunsWatch(data) {
+    if (data.lifetime.closing)
+        return data.lifetime.closing;
+    if (data.connection === 'idle' && data.lifetime.detailStop === null && data.lifetime.detailAttempts.size === 0)
+        return;
+    const started = Promise.withResolvers();
+    const closing = started.promise.then(() => shutdownRunsWatch(data));
+    data.lifetime.closing = closing;
+    started.resolve();
+    try {
+        await closing;
+    }
+    finally {
+        if (data.lifetime.closing === closing)
+            data.lifetime.closing = null;
+    }
+}
+export async function shutdownRunsWatch(data) {
+    if (data.connection === 'closed' && data.lifetime.detailStop === null && data.lifetime.detailAttempts.size === 0) {
+        if (data.lifetime.cleanup)
+            await data.lifetime.cleanup;
+        return;
+    }
+    await retireRunsWatch(data);
+}
+export async function retireRunsWatch(data) {
+    data.lifetime.epoch += 1;
+    data.lifetime.detailEpoch += 1;
+    detachRunsAbort(data);
+    data.detail = null;
+    data.detailLoading = false;
+    const detail = data.lifetime.detailStop;
+    data.lifetime.detailStop = null;
+    const detailAttempts = [...data.lifetime.detailAttempts];
+    const stop = data.lifetime.stop;
+    data.lifetime.stop = null;
+    if (detail) {
+        try {
+            await detail();
+        }
+        catch (cause) {
+            data.error = cause;
+        }
+    }
+    const admitted = await Promise.allSettled(detailAttempts);
+    for (const result of admitted)
+        if (result.status === 'rejected')
+            data.error = result.reason;
+    if (data.connection !== 'idle') {
+        data.connection = 'closed';
+        data.loading = false;
+    }
+    if (stop) {
+        await finishRunsWatch(data, stop);
+        return;
+    }
+    const attempt = data.lifetime.attempt;
+    if (!attempt)
+        return;
+    try {
+        await attempt;
+    }
+    catch (cause) {
+        const failure = CaughtFailureSchema.parse(cause);
+        if (isCapabilityError(failure) && failure.reason === 'runnable-watch-closed')
+            return;
+        throw cause;
+    }
+}
+export function finishRunsWatch(data, stop) {
+    if (data.lifetime.cleanup)
+        return data.lifetime.cleanup;
+    data.lifetime.cleanup = (async () => {
+        try {
+            await stop();
+        }
+        catch (cause) {
+            data.error = cause;
+            throw cause;
+        }
+    })();
+    return data.lifetime.cleanup;
+}
+export function listenRunsAbort(data, signal) {
+    detachRunsAbort(data);
+    if (signal === undefined)
+        return;
+    const onAbort = () => {
+        closeRunsWatch(data).catch((cause) => {
+            data.error = cause;
+        });
+    };
+    data.lifetime.signal = signal;
+    data.lifetime.onAbort = onAbort;
+    signal.addEventListener('abort', onAbort, { once: true });
+}
+export function detachRunsAbort(data) {
+    if (data.lifetime.signal !== null && data.lifetime.onAbort !== null) {
+        data.lifetime.signal.removeEventListener('abort', data.lifetime.onAbort);
+    }
+    data.lifetime.signal = null;
+    data.lifetime.onAbort = null;
+}