@swirls/looms 0.0.1

package/dist/debugger/styles.css

@@ -0,0 +1,71 @@
+@source "./**/*.{ts,tsx}";
+
+@theme inline {
+  --color-status-running: var(--status-running);
+  --color-status-waiting: var(--status-waiting);
+  --color-status-completed: var(--status-completed);
+  --color-status-failed: var(--status-failed);
+  --color-status-cancelled: var(--status-cancelled);
+  --color-family-runtime: var(--family-runtime);
+  --color-family-agent: var(--family-agent);
+  --color-family-workflow: var(--family-workflow);
+  --color-family-approval: var(--family-approval);
+  --color-family-payments: var(--family-payments);
+  --color-family-wait: var(--family-wait);
+}
+
+:root {
+  --status-running: oklch(0.74 0.12 240);
+  --status-waiting: oklch(0.8 0.14 85);
+  --status-completed: oklch(0.76 0.13 155);
+  --status-failed: oklch(0.68 0.18 25);
+  --status-cancelled: oklch(0.62 0.01 260);
+  --family-runtime: oklch(0.76 0.13 155);
+  --family-agent: oklch(0.74 0.12 240);
+  --family-workflow: oklch(0.76 0.12 300);
+  --family-approval: oklch(0.8 0.14 85);
+  --family-payments: oklch(0.78 0.1 175);
+  --family-wait: oklch(0.8 0.14 85);
+}
+
+.debugger-event-stream {
+  container-type: inline-size;
+}
+
+.debugger-event-offset,
+.debugger-event-causation,
+.debugger-event-thread {
+  display: none;
+}
+
+@container (min-width: 24rem) {
+  .debugger-event-offset {
+    display: inline;
+  }
+}
+
+@container (min-width: 34rem) {
+  .debugger-event-thread {
+    display: inline;
+  }
+}
+
+@container (min-width: 44rem) {
+  .debugger-event-causation {
+    display: inline;
+  }
+}
+
+@container (max-width: 22rem) {
+  .debugger-follow-label {
+    position: absolute;
+    width: 1px;
+    height: 1px;
+    padding: 0;
+    margin: -1px;
+    overflow: hidden;
+    clip: rect(0, 0, 0, 0);
+    white-space: nowrap;
+    border: 0;
+  }
+}

package/dist/debugger/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import { Checkbox as CheckboxPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): React.JSX.Element;
+export { Checkbox };

package/dist/debugger/ui/checkbox.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Check } from 'lucide-react';
+import { Checkbox as CheckboxPrimitive } from 'radix-ui';
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Checkbox({ className, ...props }) {
+    return (_jsx(CheckboxPrimitive.Root, { "data-slot": "checkbox", className: cn('border-input data-[state=checked]:bg-foreground data-[state=checked]:text-background focus-visible:border-ring focus-visible:ring-ring/50 peer size-3.5 shrink-0 rounded-[3px] border transition-colors outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50', className), ...props, children: _jsx(CheckboxPrimitive.Indicator, { "data-slot": "checkbox-indicator", className: "flex items-center justify-center", children: _jsx(Check, { className: "size-2.5", strokeWidth: 3 }) }) }));
+}
+export { Checkbox };

package/dist/debugger/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare function Input({ className, type, ...props }: React.ComponentProps<'input'>): React.JSX.Element;
+export { Input };

package/dist/debugger/ui/input.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Input({ className, type, ...props }) {
+    return (_jsx("input", { type: type, "data-slot": "input", className: cn('border-input placeholder:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 flex h-8 w-full min-w-0 rounded-md border bg-transparent px-2.5 py-1 text-sm transition-colors outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50', className), ...props }));
+}
+export { Input };

package/dist/debugger/ui/scroll-area.d.ts

@@ -0,0 +1,9 @@
+import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
+import type { ComponentProps, Ref, UIEventHandler } from 'react';
+declare function ScrollArea({ className, children, viewportRef, onViewportScroll, horizontal, ...props }: ComponentProps<typeof ScrollAreaPrimitive.Root> & {
+    viewportRef?: Ref<HTMLDivElement>;
+    onViewportScroll?: UIEventHandler<HTMLDivElement>;
+    horizontal?: boolean;
+}): import("react").JSX.Element;
+declare function ScrollBar({ className, orientation, ...props }: ComponentProps<typeof ScrollAreaPrimitive.ScrollAreaScrollbar>): import("react").JSX.Element;
+export { ScrollArea, ScrollBar };

package/dist/debugger/ui/scroll-area.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ScrollArea as ScrollAreaPrimitive } from 'radix-ui';
+import { cn } from '../lib/cn.js';
+function ScrollArea({ className, children, viewportRef, onViewportScroll, horizontal = false, ...props }) {
+    return (_jsxs(ScrollAreaPrimitive.Root, { "data-slot": "scroll-area", type: "always", className: cn('relative overflow-hidden', className), ...props, children: [_jsx(ScrollAreaPrimitive.Viewport, { ref: viewportRef, "data-slot": "scroll-area-viewport", className: "size-full [scrollbar-width:none] rounded-[inherit] [&::-webkit-scrollbar]:hidden", onScroll: onViewportScroll, children: children }), _jsx(ScrollBar, {}), horizontal ? _jsx(ScrollBar, { orientation: "horizontal" }) : null, _jsx(ScrollAreaPrimitive.Corner, {})] }));
+}
+function ScrollBar({ className, orientation = 'vertical', ...props }) {
+    return (_jsx(ScrollAreaPrimitive.ScrollAreaScrollbar, { "data-slot": "scroll-area-scrollbar", orientation: orientation, className: cn('flex touch-none p-px select-none', orientation === 'vertical' && 'h-full w-2 border-l border-l-transparent', orientation === 'horizontal' && 'h-2 flex-col border-t border-t-transparent', className), ...props, children: _jsx(ScrollAreaPrimitive.ScrollAreaThumb, { "data-slot": "scroll-area-thumb", className: "bg-border relative flex-1 rounded-full" }) }));
+}
+export { ScrollArea, ScrollBar };

package/dist/debugger/ui/tabs.d.ts

@@ -0,0 +1,7 @@
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import * as React from 'react';
+declare function Tabs({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Root>): React.JSX.Element;
+declare function TabsList({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.List>): React.JSX.Element;
+declare function TabsTrigger({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Trigger>): React.JSX.Element;
+declare function TabsContent({ className, ...props }: React.ComponentProps<typeof TabsPrimitive.Content>): React.JSX.Element;
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/debugger/ui/tabs.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Tabs as TabsPrimitive } from 'radix-ui';
+import * as React from 'react';
+import { cn } from '../lib/cn.js';
+function Tabs({ className, ...props }) {
+    return (_jsx(TabsPrimitive.Root, { "data-slot": "tabs", className: cn('flex flex-col gap-2', className), ...props }));
+}
+function TabsList({ className, ...props }) {
+    return (_jsx(TabsPrimitive.List, { "data-slot": "tabs-list", className: cn('bg-secondary text-muted-foreground inline-flex h-8 w-fit items-center justify-center rounded-md p-0.5', className), ...props }));
+}
+function TabsTrigger({ className, ...props }) {
+    return (_jsx(TabsPrimitive.Trigger, { "data-slot": "tabs-trigger", className: cn('focus-visible:ring-ring/50 data-[state=active]:bg-background data-[state=active]:text-foreground inline-flex h-7 items-center justify-center rounded-sm px-2.5 text-xs font-medium whitespace-nowrap transition-colors focus-visible:ring-[3px] focus-visible:outline-none disabled:pointer-events-none disabled:opacity-50', className), ...props }));
+}
+function TabsContent({ className, ...props }) {
+    return (_jsx(TabsPrimitive.Content, { "data-slot": "tabs-content", className: cn('min-h-0 flex-1 outline-none', className), ...props }));
+}
+export { Tabs, TabsList, TabsTrigger, TabsContent };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index.js'
+export * from './runtime/index.js'

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './core/index.js'
+export * from './runtime/index.js'

package/dist/projectors/index-model.d.ts

@@ -0,0 +1,56 @@
+import type { EventEnvelope } from '@swirls/looms/core';
+import type { Projector } from './projector';
+export interface ActorIndexRow {
+    actorId: string;
+    kind: string | null;
+    status: string | null;
+    definitionName: string | null;
+    parentActorId: string | null;
+    updatedAt: number;
+}
+export interface ReviewIndexRow {
+    reviewId: string;
+    actorId: string;
+    status: string;
+    title: string;
+    updatedAt: number;
+}
+export type IndexOp = {
+    type: 'upsertActor';
+    actorId: string;
+    kind: string | null;
+    status: string | null;
+    definitionName: string | null;
+    parentActorId: string | null;
+    updatedAt: number;
+} | {
+    type: 'setActorStatus';
+    actorId: string;
+    status: string;
+    updatedAt: number;
+} | {
+    type: 'upsertReview';
+    reviewId: string;
+    actorId: string;
+    status: string;
+    title: string;
+    updatedAt: number;
+} | {
+    type: 'setReviewStatus';
+    reviewId: string;
+    status: string;
+    updatedAt: number;
+};
+export interface IndexBackend {
+    applyOps: (ops: ReadonlyArray<IndexOp>) => Promise<void>;
+    getActor: (actorId: string) => Promise<ActorIndexRow | null>;
+    listReviews: (actorId?: string) => Promise<ReviewIndexRow[]>;
+    init?: () => Promise<void>;
+    dispose?: () => Promise<void>;
+}
+export interface IndexProjector extends Projector {
+    getActor: (actorId: string) => Promise<ActorIndexRow | null>;
+    listReviews: (actorId?: string) => Promise<ReviewIndexRow[]>;
+}
+export declare function indexOpsFor(event: EventEnvelope): IndexOp[];
+export declare function createIndexProjector(name: string, backend: IndexBackend): IndexProjector;

package/dist/projectors/index-model.js

@@ -0,0 +1,117 @@
+import { Predicate } from 'effect';
+function payloadObject(event) {
+    if (!Predicate.isObject(event.payload)) {
+        return {};
+    }
+    return event.payload;
+}
+function readString(obj, key) {
+    const value = obj[key];
+    return Predicate.isString(value) ? value : undefined;
+}
+export function indexOpsFor(event) {
+    const payload = payloadObject(event);
+    switch (event.type) {
+        case 'runtime.run.started':
+            return [
+                {
+                    type: 'upsertActor',
+                    actorId: event.runId,
+                    kind: readString(payload, 'kind') ?? null,
+                    status: 'running',
+                    definitionName: readString(payload, 'definitionName') ?? null,
+                    parentActorId: null,
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'runtime.thread.started':
+            return [
+                {
+                    type: 'upsertActor',
+                    actorId: readString(payload, 'threadId') ?? event.threadId ?? event.runId,
+                    kind: readString(payload, 'kind') ?? null,
+                    status: 'running',
+                    definitionName: readString(payload, 'definitionName') ?? null,
+                    parentActorId: readString(payload, 'parentThreadId') ?? null,
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'runtime.run.completed':
+        case 'runtime.thread.completed':
+            return [
+                {
+                    type: 'setActorStatus',
+                    actorId: readString(payload, 'threadId') ?? event.threadId ?? event.runId,
+                    status: 'completed',
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'runtime.thread.failed':
+            return [
+                {
+                    type: 'setActorStatus',
+                    actorId: readString(payload, 'threadId') ?? event.threadId ?? event.runId,
+                    status: 'failed',
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'runtime.thread.cancelled':
+            return [
+                {
+                    type: 'setActorStatus',
+                    actorId: readString(payload, 'threadId') ?? event.threadId ?? event.runId,
+                    status: 'cancelled',
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'approval.requested':
+            return [
+                {
+                    type: 'upsertReview',
+                    reviewId: readString(payload, 'approvalId') ?? 'unknown',
+                    actorId: event.runId,
+                    status: 'pending',
+                    title: readString(payload, 'title') ?? 'Approval',
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'approval.decided':
+            return [
+                {
+                    type: 'upsertReview',
+                    reviewId: readString(payload, 'approvalId') ?? 'unknown',
+                    actorId: event.runId,
+                    status: payload.outcome === 'reject' ? 'rejected' : 'approved',
+                    title: 'Approval',
+                    updatedAt: event.ts,
+                },
+            ];
+        case 'approval.timed_out':
+            return [
+                {
+                    type: 'setReviewStatus',
+                    reviewId: readString(payload, 'approvalId') ?? 'unknown',
+                    status: 'timed_out',
+                    updatedAt: event.ts,
+                },
+            ];
+        default:
+            return [];
+    }
+}
+export function createIndexProjector(name, backend) {
+    return {
+        name,
+        init: backend.init,
+        dispose: backend.dispose,
+        project: async (events) => {
+            const ops = events.flatMap(indexOpsFor);
+            if (ops.length === 0) {
+                return;
+            }
+            await backend.applyOps(ops);
+        },
+        getActor: (actorId) => backend.getActor(actorId),
+        listReviews: (actorId) => backend.listReviews(actorId),
+    };
+}

package/dist/projectors/index.d.ts

@@ -0,0 +1,4 @@
+export type { Projector, ProjectorErrorHandler } from './projector';
+export { withProjectors, projectEvents, ProjectorsStoreLive, type WithProjectorsOptions, } from './with-projectors';
+export { indexOpsFor, createIndexProjector, type IndexOp, type IndexBackend, type IndexProjector, type ActorIndexRow, type ReviewIndexRow, } from './index-model';
+export { memory, noop } from './memory';

package/dist/projectors/index.js

@@ -0,0 +1,3 @@
+export { withProjectors, projectEvents, ProjectorsStoreLive, } from './with-projectors.js';
+export { indexOpsFor, createIndexProjector, } from './index-model.js';
+export { memory, noop } from './memory.js';

package/dist/projectors/memory.d.ts

@@ -0,0 +1,5 @@
+import { type IndexProjector } from './index-model';
+import type { Projector } from './projector';
+export declare function memory(): IndexProjector;
+/** No-op projector — safe default when indexing is disabled. */
+export declare function noop(): Projector;

package/dist/projectors/memory.js

@@ -0,0 +1,77 @@
+import { createIndexProjector, } from './index-model.js';
+function applyOp(actors, reviews, op) {
+    switch (op.type) {
+        case 'upsertActor':
+            actors.set(op.actorId, {
+                actorId: op.actorId,
+                kind: op.kind,
+                status: op.status,
+                definitionName: op.definitionName,
+                parentActorId: op.parentActorId,
+                updatedAt: op.updatedAt,
+            });
+            return;
+        case 'setActorStatus': {
+            const existing = actors.get(op.actorId);
+            actors.set(op.actorId, {
+                actorId: op.actorId,
+                kind: existing?.kind ?? null,
+                status: op.status,
+                definitionName: existing?.definitionName ?? null,
+                parentActorId: existing?.parentActorId ?? null,
+                updatedAt: op.updatedAt,
+            });
+            return;
+        }
+        case 'upsertReview': {
+            const existing = reviews.get(op.reviewId);
+            reviews.set(op.reviewId, {
+                reviewId: op.reviewId,
+                actorId: op.actorId,
+                status: op.status,
+                title: existing?.title ?? op.title,
+                updatedAt: op.updatedAt,
+            });
+            return;
+        }
+        case 'setReviewStatus': {
+            const existing = reviews.get(op.reviewId);
+            if (existing) {
+                reviews.set(op.reviewId, { ...existing, status: op.status, updatedAt: op.updatedAt });
+            }
+            return;
+        }
+        default: {
+            const exhaustiveCheck = op;
+            return exhaustiveCheck;
+        }
+    }
+}
+export function memory() {
+    const actors = new Map();
+    const reviews = new Map();
+    const backend = {
+        applyOps: async (ops) => {
+            for (const op of ops) {
+                applyOp(actors, reviews, op);
+            }
+        },
+        getActor: async (actorId) => actors.get(actorId) ?? null,
+        listReviews: async (actorId) => {
+            const rows = [...reviews.values()];
+            return actorId ? rows.filter((row) => row.actorId === actorId) : rows;
+        },
+        dispose: async () => {
+            actors.clear();
+            reviews.clear();
+        },
+    };
+    return createIndexProjector('memory', backend);
+}
+/** No-op projector — safe default when indexing is disabled. */
+export function noop() {
+    return {
+        name: 'noop',
+        project: async () => { },
+    };
+}

package/dist/projectors/postgres.d.ts

@@ -0,0 +1,9 @@
+import { type Sql } from 'postgres';
+import { type IndexProjector } from './index-model';
+export { POSTGRES_SCHEMA_SQL } from './schema';
+export type PostgresProjectorOptions = {
+    url: string;
+} | {
+    sql: Sql;
+};
+export declare function postgres(options: PostgresProjectorOptions): IndexProjector;

package/dist/projectors/postgres.js

@@ -0,0 +1,108 @@
+import createPostgresClient, {} from 'postgres';
+import { createIndexProjector, } from './index-model.js';
+import { POSTGRES_SCHEMA_SQL } from './schema.js';
+export { POSTGRES_SCHEMA_SQL } from './schema.js';
+function ownsClient(options) {
+    return 'url' in options;
+}
+async function applyOp(sql, op) {
+    switch (op.type) {
+        case 'upsertActor':
+            await sql `
+        INSERT INTO looms_actors (actor_id, kind, status, definition_name, parent_actor_id, updated_at)
+        VALUES (${op.actorId}, ${op.kind}, ${op.status}, ${op.definitionName}, ${op.parentActorId}, ${new Date(op.updatedAt)})
+        ON CONFLICT (actor_id) DO UPDATE SET
+          kind = EXCLUDED.kind,
+          status = EXCLUDED.status,
+          definition_name = EXCLUDED.definition_name,
+          parent_actor_id = EXCLUDED.parent_actor_id,
+          updated_at = EXCLUDED.updated_at
+      `;
+            return;
+        case 'setActorStatus':
+            await sql `
+        INSERT INTO looms_actors (actor_id, status, updated_at)
+        VALUES (${op.actorId}, ${op.status}, ${new Date(op.updatedAt)})
+        ON CONFLICT (actor_id) DO UPDATE SET
+          status = EXCLUDED.status,
+          updated_at = EXCLUDED.updated_at
+      `;
+            return;
+        case 'upsertReview':
+            await sql `
+        INSERT INTO looms_reviews (review_id, actor_id, status, title, updated_at)
+        VALUES (${op.reviewId}, ${op.actorId}, ${op.status}, ${op.title}, ${new Date(op.updatedAt)})
+        ON CONFLICT (review_id) DO UPDATE SET
+          status = EXCLUDED.status,
+          updated_at = EXCLUDED.updated_at
+      `;
+            return;
+        case 'setReviewStatus':
+            await sql `
+        UPDATE looms_reviews SET status = ${op.status}, updated_at = ${new Date(op.updatedAt)}
+        WHERE review_id = ${op.reviewId}
+      `;
+            return;
+        default: {
+            const exhaustiveCheck = op;
+            return exhaustiveCheck;
+        }
+    }
+}
+export function postgres(options) {
+    const createdClient = ownsClient(options);
+    const sql = createdClient ? createPostgresClient(options.url) : options.sql;
+    const backend = {
+        init: async () => {
+            await sql.unsafe(POSTGRES_SCHEMA_SQL);
+        },
+        applyOps: async (ops) => {
+            await sql.begin(async (tx) => {
+                for (const op of ops) {
+                    await applyOp(tx, op);
+                }
+            });
+        },
+        getActor: async (actorId) => {
+            const rows = await sql `
+        SELECT actor_id, kind, status, definition_name, parent_actor_id, updated_at
+        FROM looms_actors WHERE actor_id = ${actorId}
+      `;
+            const row = rows[0];
+            if (!row) {
+                return null;
+            }
+            return {
+                actorId: row.actor_id,
+                kind: row.kind,
+                status: row.status,
+                definitionName: row.definition_name,
+                parentActorId: row.parent_actor_id,
+                updatedAt: row.updated_at.getTime(),
+            };
+        },
+        listReviews: async (actorId) => {
+            const rows = actorId
+                ? await sql `
+            SELECT review_id, actor_id, status, title, updated_at
+            FROM looms_reviews WHERE actor_id = ${actorId}
+          `
+                : await sql `
+            SELECT review_id, actor_id, status, title, updated_at FROM looms_reviews
+          `;
+            return rows.map((row) => ({
+                reviewId: row.review_id,
+                actorId: row.actor_id,
+                status: row.status,
+                title: row.title,
+                updatedAt: row.updated_at.getTime(),
+            }));
+        },
+        dispose: async () => {
+            if (createdClient) {
+                await sql.end({ timeout: 5 });
+            }
+        },
+    };
+    return createIndexProjector('postgres', backend);
+}

package/dist/projectors/projector.d.ts

@@ -0,0 +1,11 @@
+import type { EventEnvelope } from '@swirls/looms/core';
+export interface Projector {
+    /** Used in error reporting / diagnostics. */
+    readonly name: string;
+    /** Optional one-time setup (open connection, create tables). Runtime calls this before the first `project`. */
+    readonly init?: () => Promise<void>;
+    /** Apply a batch of events in log order. Must be idempotent (a batch may be redelivered). */
+    readonly project: (events: ReadonlyArray<EventEnvelope>) => Promise<void>;
+    readonly dispose?: () => Promise<void>;
+}
+export type ProjectorErrorHandler = (error: Error, projector: Projector, events: ReadonlyArray<EventEnvelope>) => void;

package/dist/projectors/projector.js

@@ -0,0 +1 @@
+export {};

package/dist/projectors/schema.d.ts

@@ -0,0 +1,5 @@
+/**
+ * SQL schema for the optional Looms secondary index.
+ */
+export declare const POSTGRES_SCHEMA_SQL: string;
+export declare const SQLITE_SCHEMA_SQL: string;

package/dist/projectors/schema.js

@@ -0,0 +1,43 @@
+/**
+ * SQL schema for the optional Looms secondary index.
+ */
+export const POSTGRES_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS looms_actors (
+  actor_id TEXT PRIMARY KEY,
+  kind TEXT,
+  status TEXT,
+  definition_name TEXT,
+  parent_actor_id TEXT,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS looms_reviews (
+  review_id TEXT PRIMARY KEY,
+  actor_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  title TEXT NOT NULL,
+  updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS looms_reviews_actor_id_idx ON looms_reviews (actor_id);
+`.trim();
+export const SQLITE_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS looms_actors (
+  actor_id TEXT PRIMARY KEY,
+  kind TEXT,
+  status TEXT,
+  definition_name TEXT,
+  parent_actor_id TEXT,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS looms_reviews (
+  review_id TEXT PRIMARY KEY,
+  actor_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  title TEXT NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS looms_reviews_actor_id_idx ON looms_reviews (actor_id);
+`.trim();

package/dist/projectors/sqlite.d.ts

@@ -0,0 +1,9 @@
+import { Database } from 'bun:sqlite';
+import { type IndexProjector } from './index-model';
+export { SQLITE_SCHEMA_SQL } from './schema';
+export type SqliteProjectorOptions = {
+    path?: string;
+} | {
+    db: Database;
+};
+export declare function sqlite(options?: SqliteProjectorOptions): IndexProjector;