@fabrika/canvas-kernel 0.9.0-dev.1 → 0.9.0-dev.3

package/types/src/engine/watcher.d.ts

@@ -0,0 +1,16 @@
+import { type CanvasComponents } from './compiler';
+import { type AssertReadable } from './file-admission';
+import type { SessionManager } from './session';
+type BroadcastFn = (sessionId: string) => void;
+export interface WatchOptions {
+    assertReadable?: AssertReadable;
+    /** Scratch dir for recompiles, from `createCanvasPaths()`. */
+    tempDir?: string;
+    /** Host components, same value the push path compiles with — a recompile
+     *  that dropped them would fail on canvases the original push accepted. */
+    components?: CanvasComponents;
+}
+export declare function watchSession(sessionId: string, sessionManager: SessionManager, broadcast: BroadcastFn, options?: WatchOptions): void;
+export declare function unwatchSession(sessionId: string): void;
+export declare function unwatchAll(): void;
+export {};

package/types/src/engine/websocket.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The canvas vocabulary on top of the generic channel: topic = session id,
+ * `submit` persists feedback, and a waiter is the CLI blocking on one answer,
+ * so a delivery closes it.
+ */
+import { type ChannelSocket } from '@fabrika/daemon-kit';
+import type { RemoteFeedbackEntry, SessionManager } from './session';
+export type WSData = {
+    type: 'browser' | 'wait';
+    sessionId: string;
+};
+export interface CanvasSocket extends ChannelSocket {
+    data: WSData;
+}
+export interface WebSocketManagerOptions {
+    /**
+     * Who marks feedback consumed once a waiting client has been handed it.
+     *
+     * `"on-delivery"` (default) clears it in the same step, so the same feedback
+     * can never be delivered twice — right when the waiting client *is* the
+     * consumer. `"external"` leaves it pending for a separate gate to claim
+     * through the consume endpoint, for hosts where delivery and consumption are
+     * different steps.
+     */
+    feedbackConsumption?: 'on-delivery' | 'external';
+}
+export declare function createWebSocketManager(sessionManager: SessionManager, options?: WebSocketManagerOptions): {
+    handlers: {
+        open(socket: CanvasSocket): void;
+        message(socket: CanvasSocket, message: string | Buffer): void;
+        pong(socket: CanvasSocket): void;
+        close(socket: CanvasSocket): void;
+    };
+    broadcastPlanUpdate: (sessionId: string) => void;
+    broadcastRevisionUpdate: (sessionId: string) => void;
+    broadcastWatcherStatus: (sessionId: string) => void;
+    broadcastRemoteFeedback: (sessionId: string, revision: number, entries: RemoteFeedbackEntry[]) => void;
+};