@vibesdotdev/workboard 0.0.0-stage → 1.0.0-rc.1

package/dist/svelte/lane-board.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Pure helpers for the HQ lane board — the glanceable projection of the
+ * workboard's task rows grouped by lane.
+ *
+ * Zero Svelte/SvelteKit/runtime imports on purpose: this module is shared by
+ * the package-owned browser components, the
+ * tracking projection (lane id on the authority row's metadata), the lane
+ * query/route, and the page loader — so the ONE definition of "what a lane id
+ * looks like", "which lane a task sits in", and "what a task's glance line
+ * says" holds on every door and is unit-tested here.
+ */
+import type { TaskNote, WorkboardLane, WorkboardTask } from '../types.ts';
+/** Group id for tasks that carry no lane. Sorts last; never a real lane id. */
+export declare const NO_LANE_ID = "";
+/**
+ * Canonical lane id: trimmed, lower-cased, whitespace runs → `-`. Mirrors the
+ * lane row's primary-key normalization so "Appearance SSR" typed into a form,
+ * `appearance-ssr` sent by an agent, and the stored lane row all agree.
+ */
+export declare function normalizeLaneId(raw: string | null | undefined): string;
+export interface StatusCounts {
+    pending: number;
+    in_progress: number;
+    blocked: number;
+    completed: number;
+    cancelled: number;
+    /** pending + in_progress + blocked — the work still live on the board. */
+    open: number;
+    total: number;
+}
+export declare function countByStatus(tasks: readonly WorkboardTask[]): StatusCounts;
+/**
+ * Blocked → in progress → pending → done; then priority; then most recently
+ * updated first (oversight reads "what moved last", not "what was created
+ * last" — the board's creation-order comparator lives in the package).
+ */
+export declare function compareTasksForGlance(a: WorkboardTask, b: WorkboardTask): number;
+export interface LaneGroup {
+    /** Normalized lane id; `NO_LANE_ID` for the trailing "no lane" group. */
+    id: string;
+    label: string;
+    description: string;
+    /** Lane row `color` (an emoji or a CSS color); '' when unregistered. */
+    color: string;
+    /** True when a lane row exists; false for lanes only seen on tasks. */
+    registered: boolean;
+    tasks: WorkboardTask[];
+    counts: StatusCounts;
+}
+/**
+ * Group tasks by lane for the board:
+ *   1. every registered lane (sorted by id), INCLUDING empty ones — an empty
+ *      lane is a fact worth seeing ("lane exists, nothing assigned");
+ *   2. lanes that exist only on tasks (an agent filed into a lane nobody
+ *      registered yet) — shown, flagged `registered: false`, never hidden;
+ *   3. the "no lane" group last, only when it has tasks.
+ */
+export declare function groupTasksByLane(tasks: readonly WorkboardTask[], lanes: readonly WorkboardLane[]): LaneGroup[];
+/** Lane ids a task can be moved into: registered + already-seen, never ''. */
+export declare function laneOptions(groups: readonly LaneGroup[]): string[];
+/** Most recent note by `at`; falls back to array order for unparsable dates. */
+export declare function latestNote(task: Pick<WorkboardTask, 'notes'>): TaskNote | null;
+export type GlanceKind = 'blocker' | 'next' | 'none';
+export interface GlanceLine {
+    kind: GlanceKind;
+    /** Note text; '' when a blocked task has no note yet (the UI says so). */
+    text: string;
+    by: string | null;
+    at: string | null;
+}
+/**
+ * The one line under a task that answers "why is this stuck / what happens
+ * next": the latest note. A blocked task's latest note is its blocker; an open
+ * task's latest note is its next action; finished work has no glance line.
+ * This reuses the workboard's own note primitive — an agent that can add a
+ * note can keep the board glanceable without any new field.
+ */
+export declare function glanceLine(task: WorkboardTask): GlanceLine;
+export type AgentLabel = {
+    name: string;
+    status?: string | null;
+};
+/** id → label (string) or `{ name, status }`; from `agentsState` in HQ. */
+export type AgentLabelMap = Record<string, AgentLabel | string>;
+/** The assignment first, then the producing agent, else '' (unassigned). */
+export declare function ownerKey(task: Pick<WorkboardTask, 'assigned_to' | 'agentId'>): string;
+export declare function ownerLabel(task: Pick<WorkboardTask, 'assigned_to' | 'agentId'>, agents?: AgentLabelMap): string;
+/** Agent liveness for the owner chip when the owner is a known agent. */
+export declare function ownerStatus(task: Pick<WorkboardTask, 'assigned_to' | 'agentId'>, agents?: AgentLabelMap): string | null;
+export interface OwnerOption {
+    id: string;
+    label: string;
+    count: number;
+}
+export declare function distinctOwners(tasks: readonly WorkboardTask[], agents?: AgentLabelMap): OwnerOption[];
+export type StatusFilter = 'all' | 'open' | 'in_progress' | 'blocked' | 'pending' | 'completed';
+export declare const STATUS_FILTERS: ReadonlyArray<{
+    value: StatusFilter;
+    label: string;
+}>;
+/** Owner-filter sentinel for "tasks nobody owns" (a real owner id is never ''). */
+export declare const UNASSIGNED_OWNER_FILTER = "__unassigned__";
+export declare function matchesStatusFilter(task: WorkboardTask, filter: StatusFilter): boolean;
+export interface TaskFilter {
+    /** Narrow to one agent (by provenance or assignment); null = all agents. */
+    agentId?: string | null;
+    status?: StatusFilter;
+    /** '' = every owner; `UNASSIGNED_OWNER_FILTER` = no owner; else an owner id. */
+    owner?: string;
+}
+/** Narrows only — never widens beyond the rows given. */
+export declare function filterTasks(tasks: readonly WorkboardTask[], filter: TaskFilter): WorkboardTask[];
+export declare const STALE_AFTER_MS: number;
+/** Live work (in progress or blocked) that nobody has touched in a day. */
+export declare function isStale(task: WorkboardTask, now?: number): boolean;
+export interface BoardSummary extends StatusCounts {
+    stale: number;
+}
+export declare function summarize(tasks: readonly WorkboardTask[], now?: number): BoardSummary;
+//# sourceMappingURL=lane-board.d.ts.map

package/dist/svelte/lane-board.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-board.d.ts","sourceRoot":"","sources":["../../src/svelte/lane-board.ts"],"names":[],"mappings":"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"}

package/dist/svelte/lane-board.js

@@ -0,0 +1,221 @@
+import { WorkboardAgentLabelSchema } from "../schemas/surface.js";
+/** Group id for tasks that carry no lane. Sorts last; never a real lane id. */
+export const NO_LANE_ID = '';
+/**
+ * Canonical lane id: trimmed, lower-cased, whitespace runs → `-`. Mirrors the
+ * lane row's primary-key normalization so "Appearance SSR" typed into a form,
+ * `appearance-ssr` sent by an agent, and the stored lane row all agree.
+ */
+export function normalizeLaneId(raw) {
+    return (raw ?? '').trim().toLowerCase().replace(/\s+/g, '-');
+}
+export function countByStatus(tasks) {
+    const counts = {
+        pending: 0,
+        in_progress: 0,
+        blocked: 0,
+        completed: 0,
+        cancelled: 0,
+        open: 0,
+        total: tasks.length
+    };
+    for (const task of tasks) {
+        if (task.status in counts)
+            counts[task.status] += 1;
+    }
+    counts.open = counts.pending + counts.in_progress + counts.blocked;
+    return counts;
+}
+// ── Ordering ──
+/** Glance order inside a lane: what needs a human first. */
+const STATUS_GLANCE_RANK = {
+    blocked: 0,
+    in_progress: 1,
+    pending: 2,
+    completed: 3,
+    cancelled: 4
+};
+const PRIORITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 };
+function epoch(iso) {
+    const t = iso ? new Date(iso).getTime() : Number.NaN;
+    return Number.isFinite(t) ? t : 0;
+}
+/**
+ * Blocked → in progress → pending → done; then priority; then most recently
+ * updated first (oversight reads "what moved last", not "what was created
+ * last" — the board's creation-order comparator lives in the package).
+ */
+export function compareTasksForGlance(a, b) {
+    const status = (STATUS_GLANCE_RANK[a.status] ?? 9) - (STATUS_GLANCE_RANK[b.status] ?? 9);
+    if (status !== 0)
+        return status;
+    const priority = (PRIORITY_RANK[a.priority] ?? 9) - (PRIORITY_RANK[b.priority] ?? 9);
+    if (priority !== 0)
+        return priority;
+    return epoch(b.updated_at) - epoch(a.updated_at);
+}
+function laneGroup(id, lane, tasks) {
+    const sorted = [...tasks].sort(compareTasksForGlance);
+    return {
+        id,
+        label: id === NO_LANE_ID ? 'No lane' : id,
+        description: lane?.description ?? '',
+        color: lane?.color ?? '',
+        registered: lane !== null,
+        tasks: sorted,
+        counts: countByStatus(sorted)
+    };
+}
+/**
+ * Group tasks by lane for the board:
+ *   1. every registered lane (sorted by id), INCLUDING empty ones — an empty
+ *      lane is a fact worth seeing ("lane exists, nothing assigned");
+ *   2. lanes that exist only on tasks (an agent filed into a lane nobody
+ *      registered yet) — shown, flagged `registered: false`, never hidden;
+ *   3. the "no lane" group last, only when it has tasks.
+ */
+export function groupTasksByLane(tasks, lanes) {
+    const byLane = new Map();
+    for (const task of tasks) {
+        const id = normalizeLaneId(task.lane);
+        const bucket = byLane.get(id);
+        if (bucket)
+            bucket.push(task);
+        else
+            byLane.set(id, [task]);
+    }
+    const groups = [];
+    const seen = new Set();
+    const registered = [...lanes].sort((a, b) => a.id.localeCompare(b.id));
+    for (const lane of registered) {
+        const id = normalizeLaneId(lane.id);
+        if (!id || seen.has(id))
+            continue;
+        seen.add(id);
+        groups.push(laneGroup(id, lane, byLane.get(id) ?? []));
+    }
+    const unregistered = [...byLane.keys()].filter((id) => id !== NO_LANE_ID && !seen.has(id)).sort();
+    for (const id of unregistered)
+        groups.push(laneGroup(id, null, byLane.get(id) ?? []));
+    const none = byLane.get(NO_LANE_ID);
+    if (none && none.length > 0)
+        groups.push(laneGroup(NO_LANE_ID, null, none));
+    return groups;
+}
+/** Lane ids a task can be moved into: registered + already-seen, never ''. */
+export function laneOptions(groups) {
+    return groups.map((group) => group.id).filter((id) => id !== NO_LANE_ID);
+}
+// ── Glance line (blocker / next action) ──
+/** Most recent note by `at`; falls back to array order for unparsable dates. */
+export function latestNote(task) {
+    let best = null;
+    let bestAt = Number.NEGATIVE_INFINITY;
+    for (const note of task.notes ?? []) {
+        const parsed = new Date(note.at).getTime();
+        const at = Number.isFinite(parsed) ? parsed : Number.NEGATIVE_INFINITY;
+        if (best === null || at >= bestAt) {
+            best = note;
+            bestAt = at;
+        }
+    }
+    return best;
+}
+/**
+ * The one line under a task that answers "why is this stuck / what happens
+ * next": the latest note. A blocked task's latest note is its blocker; an open
+ * task's latest note is its next action; finished work has no glance line.
+ * This reuses the workboard's own note primitive — an agent that can add a
+ * note can keep the board glanceable without any new field.
+ */
+export function glanceLine(task) {
+    const note = latestNote(task);
+    if (task.status === 'blocked') {
+        return { kind: 'blocker', text: note?.text ?? '', by: note?.by ?? null, at: note?.at ?? null };
+    }
+    if (note && task.status !== 'completed' && task.status !== 'cancelled') {
+        return { kind: 'next', text: note.text, by: note.by, at: note.at };
+    }
+    return { kind: 'none', text: '', by: null, at: null };
+}
+/** The assignment first, then the producing agent, else '' (unassigned). */
+export function ownerKey(task) {
+    return task.assigned_to || task.agentId || '';
+}
+export function ownerLabel(task, agents = {}) {
+    const key = ownerKey(task);
+    if (!key)
+        return 'Unassigned';
+    const entry = agents[key];
+    if (!entry)
+        return key;
+    return WorkboardAgentLabelSchema.parse(entry).name || key;
+}
+/** Agent liveness for the owner chip when the owner is a known agent. */
+export function ownerStatus(task, agents = {}) {
+    const entry = agents[ownerKey(task)];
+    return entry ? WorkboardAgentLabelSchema.parse(entry).status ?? null : null;
+}
+export function distinctOwners(tasks, agents = {}) {
+    const byId = new Map();
+    for (const task of tasks) {
+        const id = ownerKey(task);
+        if (!id)
+            continue;
+        const existing = byId.get(id);
+        if (existing)
+            existing.count += 1;
+        else
+            byId.set(id, { id, label: ownerLabel(task, agents), count: 1 });
+    }
+    return [...byId.values()].sort((a, b) => a.label.localeCompare(b.label));
+}
+export const STATUS_FILTERS = [
+    { value: 'open', label: 'Open' },
+    { value: 'in_progress', label: 'In progress' },
+    { value: 'blocked', label: 'Blocked' },
+    { value: 'pending', label: 'Pending' },
+    { value: 'completed', label: 'Done' },
+    { value: 'all', label: 'All' }
+];
+/** Owner-filter sentinel for "tasks nobody owns" (a real owner id is never ''). */
+export const UNASSIGNED_OWNER_FILTER = '__unassigned__';
+export function matchesStatusFilter(task, filter) {
+    if (filter === 'all')
+        return true;
+    if (filter === 'open')
+        return task.status !== 'completed' && task.status !== 'cancelled';
+    return task.status === filter;
+}
+/** Narrows only — never widens beyond the rows given. */
+export function filterTasks(tasks, filter) {
+    const { agentId = null, status = 'all', owner = '' } = filter;
+    return tasks.filter((task) => {
+        if (agentId != null && task.agentId !== agentId && task.assigned_to !== agentId)
+            return false;
+        if (!matchesStatusFilter(task, status))
+            return false;
+        if (owner === UNASSIGNED_OWNER_FILTER)
+            return ownerKey(task) === '';
+        if (owner && ownerKey(task) !== owner)
+            return false;
+        return true;
+    });
+}
+// ── Staleness / summary ──
+export const STALE_AFTER_MS = 24 * 60 * 60 * 1000;
+/** Live work (in progress or blocked) that nobody has touched in a day. */
+export function isStale(task, now = Date.now()) {
+    if (task.status !== 'in_progress' && task.status !== 'blocked')
+        return false;
+    const updated = new Date(task.updated_at).getTime();
+    if (!Number.isFinite(updated))
+        return false;
+    return now - updated > STALE_AFTER_MS;
+}
+export function summarize(tasks, now = Date.now()) {
+    return {
+        ...countByStatus(tasks),
+        stale: tasks.filter((task) => isStale(task, now)).length
+    };
+}

package/dist/svelte/rest-workboard-client.d.ts

@@ -0,0 +1,235 @@
+import { type WorkboardTaskDraft, type WorkboardTaskPatch, type WorkboardTaskFilter, type WorkboardRequestDraft, type WorkboardRequestReview, type WorkboardRequestFilter, type WorkboardLaneDraft } from '../schemas/index.ts';
+export interface RestWorkboardClientOptions {
+    basePath?: string;
+    fetchImpl?: typeof fetch;
+}
+export declare function createRestWorkboardClient(options?: RestWorkboardClientOptions): {
+    tasks: {
+        list: (filter?: WorkboardTaskFilter) => Promise<{
+            id: string;
+            title: string;
+            lane: string;
+            status: "cancelled" | "completed" | "pending" | "blocked" | "in_progress";
+            priority: "high" | "medium" | "low" | "critical";
+            assigned_to: string;
+            notes: {
+                at: string;
+                by: string;
+                text: string;
+            }[];
+            created_at: string;
+            updated_at: string;
+            description?: string | undefined;
+            response?: string | undefined;
+            note?: string | undefined;
+            completed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            displayId?: string | undefined;
+            authorityUrl?: string | undefined;
+        }[]>;
+        add: (data: WorkboardTaskDraft) => Promise<{
+            id: string;
+            title: string;
+            lane: string;
+            status: "cancelled" | "completed" | "pending" | "blocked" | "in_progress";
+            priority: "high" | "medium" | "low" | "critical";
+            assigned_to: string;
+            notes: {
+                at: string;
+                by: string;
+                text: string;
+            }[];
+            created_at: string;
+            updated_at: string;
+            description?: string | undefined;
+            response?: string | undefined;
+            note?: string | undefined;
+            completed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            displayId?: string | undefined;
+            authorityUrl?: string | undefined;
+        }>;
+        update: (id: string, patch: WorkboardTaskPatch) => Promise<{
+            id: string;
+            title: string;
+            lane: string;
+            status: "cancelled" | "completed" | "pending" | "blocked" | "in_progress";
+            priority: "high" | "medium" | "low" | "critical";
+            assigned_to: string;
+            notes: {
+                at: string;
+                by: string;
+                text: string;
+            }[];
+            created_at: string;
+            updated_at: string;
+            description?: string | undefined;
+            response?: string | undefined;
+            note?: string | undefined;
+            completed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            displayId?: string | undefined;
+            authorityUrl?: string | undefined;
+        }>;
+        remove: (id: string) => Promise<void>;
+        addNote: (id: string, text: string) => Promise<{
+            id: string;
+            title: string;
+            lane: string;
+            status: "cancelled" | "completed" | "pending" | "blocked" | "in_progress";
+            priority: "high" | "medium" | "low" | "critical";
+            assigned_to: string;
+            notes: {
+                at: string;
+                by: string;
+                text: string;
+            }[];
+            created_at: string;
+            updated_at: string;
+            description?: string | undefined;
+            response?: string | undefined;
+            note?: string | undefined;
+            completed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            displayId?: string | undefined;
+            authorityUrl?: string | undefined;
+        }>;
+        clearCompleted: () => Promise<void>;
+    };
+    requests: {
+        list: (filter?: WorkboardRequestFilter) => Promise<{
+            id: string;
+            title: string;
+            type: "email" | "action" | "deployment" | "code_review" | "plan_confirmation" | "escalation";
+            status: "cancelled" | "rejected" | "approved" | "pending" | "expired";
+            requested_by: string;
+            description: string;
+            created_at: string;
+            updated_at: string;
+            details?: Record<string, unknown> | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            response?: string | undefined;
+            reviewed_by?: string | undefined;
+            reviewed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+        }[]>;
+        add: (data: WorkboardRequestDraft) => Promise<{
+            id: string;
+            title: string;
+            type: "email" | "action" | "deployment" | "code_review" | "plan_confirmation" | "escalation";
+            status: "cancelled" | "rejected" | "approved" | "pending" | "expired";
+            requested_by: string;
+            description: string;
+            created_at: string;
+            updated_at: string;
+            details?: Record<string, unknown> | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            response?: string | undefined;
+            reviewed_by?: string | undefined;
+            reviewed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+        }>;
+        review: (id: string, decision: WorkboardRequestReview) => Promise<{
+            id: string;
+            title: string;
+            type: "email" | "action" | "deployment" | "code_review" | "plan_confirmation" | "escalation";
+            status: "cancelled" | "rejected" | "approved" | "pending" | "expired";
+            requested_by: string;
+            description: string;
+            created_at: string;
+            updated_at: string;
+            details?: Record<string, unknown> | undefined;
+            links?: {
+                kind: string;
+                id: string;
+                source: string;
+                role: string;
+            }[] | undefined;
+            response?: string | undefined;
+            reviewed_by?: string | undefined;
+            reviewed_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+            agentId?: string | null | undefined;
+            sourceEventId?: string | null | undefined;
+        }>;
+        remove: (id: string) => Promise<void>;
+        clearResolved: () => Promise<void>;
+    };
+    lanes: {
+        list: () => Promise<{
+            id: string;
+            description: string;
+            auto: boolean;
+            color: string;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+        }[]>;
+        add: (input: WorkboardLaneDraft) => Promise<{
+            id: string;
+            description: string;
+            auto: boolean;
+            color: string;
+            created_at?: string | undefined;
+            updated_at?: string | undefined;
+            ownerType?: "user" | "organization" | "system" | null | undefined;
+            ownerId?: string | null | undefined;
+        }>;
+    };
+};
+export type RestWorkboardClient = ReturnType<typeof createRestWorkboardClient>;
+//# sourceMappingURL=rest-workboard-client.d.ts.map

package/dist/svelte/rest-workboard-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rest-workboard-client.d.ts","sourceRoot":"","sources":["../../src/svelte/rest-workboard-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAON,KAAK,kBAAkB,EAAE,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAC1E,KAAK,qBAAqB,EAAE,KAAK,sBAAsB,EAAE,KAAK,sBAAsB,EACpF,KAAK,kBAAkB,EACvB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,0BAA0B;IAC1C,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,KAAK,CAAC;CACzB;AAED,wBAAgB,yBAAyB,CAAC,OAAO,GAAE,0BAA+B;;wBAwBjE,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAEtB,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEjB,MAAM,SAAS,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAE3B,MAAM;sBAGX,MAAM,QAAQ,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAOnB,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;oBAEzB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;qBAEpB,MAAM,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;qBAElC,MAAM;;;;;;;;;;;;;;qBASZ,kBAAkB;;;;;;;;;;;EAIhC;AACD,MAAM,MAAM,mBAAmB,GAAG,UAAU,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/dist/svelte/rest-workboard-client.js

@@ -0,0 +1,52 @@
+import { WorkboardTaskDraftSchema, WorkboardTaskPatchSchema, WorkboardTaskFilterSchema, WorkboardTaskResultSchema, WorkboardTasksResultSchema, WorkboardTaskNoteInputSchema, WorkboardRequestDraftSchema, WorkboardRequestReviewSchema, WorkboardRequestFilterSchema, WorkboardRequestResultSchema, WorkboardRequestsResultSchema, WorkboardLaneDraftSchema, WorkboardLaneResultSchema, WorkboardLanesResultSchema, WorkboardOperationResultSchema } from "../schemas/index.js";
+export function createRestWorkboardClient(options = {}) {
+    const base = options.basePath ?? '/api/workboard';
+    const doFetch = options.fetchImpl ?? fetch;
+    async function request(path, schema, init) {
+        const headers = new Headers(init?.headers);
+        if (init?.body)
+            headers.set('content-type', 'application/json');
+        const response = await doFetch(base + path, { ...init, headers });
+        const text = await response.text();
+        if (!response.ok) {
+            throw new Error(`workboard ${init?.method ?? 'GET'} ${base + path} failed (HTTP ${response.status})${text ? ': ' + text.slice(0, 200) : ''}`);
+        }
+        return schema.parse(text.length ? JSON.parse(text) : undefined);
+    }
+    function queryString(filter) {
+        const query = new URLSearchParams();
+        for (const [key, value] of Object.entries(filter)) {
+            if (value !== undefined)
+                query.set(key, value);
+        }
+        return query.size ? '?' + query.toString() : '';
+    }
+    const tasks = {
+        list: (filter = {}) => request('/tasks' + queryString(WorkboardTaskFilterSchema.parse(filter)), WorkboardTasksResultSchema),
+        add: (data) => request('/tasks', WorkboardTaskResultSchema, { method: 'POST', body: JSON.stringify(WorkboardTaskDraftSchema.parse(data)) }),
+        update: (id, patch) => request('/tasks/' + encodeURIComponent(id), WorkboardTaskResultSchema, { method: 'PATCH', body: JSON.stringify(WorkboardTaskPatchSchema.parse(patch)) }),
+        remove: async (id) => {
+            await request('/tasks/' + encodeURIComponent(id), WorkboardOperationResultSchema, { method: 'DELETE' });
+        },
+        addNote: (id, text) => request('/tasks/' + encodeURIComponent(id) + '/note', WorkboardTaskResultSchema, { method: 'POST', body: JSON.stringify(WorkboardTaskNoteInputSchema.parse({ text })) }),
+        clearCompleted: async () => {
+            await request('/tasks/clear-completed', WorkboardOperationResultSchema, { method: 'POST' });
+        }
+    };
+    const requests = {
+        list: (filter = {}) => request('/requests' + queryString(WorkboardRequestFilterSchema.parse(filter)), WorkboardRequestsResultSchema),
+        add: (data) => request('/requests', WorkboardRequestResultSchema, { method: 'POST', body: JSON.stringify(WorkboardRequestDraftSchema.parse(data)) }),
+        review: (id, decision) => request('/requests/' + encodeURIComponent(id) + '/review', WorkboardRequestResultSchema, { method: 'POST', body: JSON.stringify(WorkboardRequestReviewSchema.parse(decision)) }),
+        remove: async (id) => {
+            await request('/requests/' + encodeURIComponent(id), WorkboardOperationResultSchema, { method: 'DELETE' });
+        },
+        clearResolved: async () => {
+            await request('/requests/clear-resolved', WorkboardOperationResultSchema, { method: 'POST' });
+        }
+    };
+    const lanes = {
+        list: () => request('/lanes', WorkboardLanesResultSchema),
+        add: (input) => request('/lanes', WorkboardLaneResultSchema, { method: 'POST', body: JSON.stringify(WorkboardLaneDraftSchema.parse(input)) })
+    };
+    return { tasks, requests, lanes };
+}

package/dist/svelte/styles.css

@@ -0,0 +1,10 @@
+/*
+ * Tailwind v4 source declaration for consumers — mirrors @vibesdotdev/kit's
+ * styles.css pattern. Apps that @import this file get this package's
+ * components scanned by their Tailwind build, so utility classes used only
+ * inside these components are emitted in the app's CSS bundle. Without it,
+ * such classes are missing per-app by lottery (Tailwind never scans
+ * node_modules). Paths resolve relative to this file: dist/styles.css at
+ * runtime, src/styles.css under the bun condition.
+ */
+@source "./";