@corbits/react-ui 0.1.0 → 0.2.0

package/dist/lib/theme.js

@@ -6,15 +6,12 @@
  * opt-out and only works on `documentElement`. This module owns the pure
  * resolution rules; ThemeProvider applies them to the document and persists
  * the choice.
- */ export const THEME_MODES = [
-    "system",
-    "light",
-    "dark"
-];
+ */
+export const THEME_MODES = ["system", "light", "dark"];
 export const THEME_PRESETS = [
     "default",
     "warm",
-    "cool"
+    "cool",
 ];
 export const DEFAULT_THEME_STORAGE_KEY = "corbits-theme";
 export function isThemeMode(value) {
@@ -23,44 +20,48 @@ export function isThemeMode(value) {
 export function isThemePreset(value) {
     return value === "default" || value === "warm" || value === "cool";
 }
-/** Resolve light/dark after consulting the system preference when mode is system. */ export function resolveThemeMode(mode, systemPrefersDark) {
-    if (mode === "light") return "light";
-    if (mode === "dark") return "dark";
+/** Resolve light/dark after consulting the system preference when mode is system. */
+export function resolveThemeMode(mode, systemPrefersDark) {
+    if (mode === "light")
+        return "light";
+    if (mode === "dark")
+        return "dark";
     return systemPrefersDark ? "dark" : "light";
 }
 export function parseThemePreference(raw, fallback) {
-    if (raw === null || raw.length === 0) return fallback;
+    if (raw === null || raw.length === 0)
+        return fallback;
     try {
         const parsed = JSON.parse(raw);
-        if (typeof parsed !== "object" || parsed === null) return fallback;
+        if (typeof parsed !== "object" || parsed === null)
+            return fallback;
         const record = parsed;
         const mode = isThemeMode(record.mode) ? record.mode : fallback.mode;
-        const preset = isThemePreset(record.preset) ? record.preset : fallback.preset;
-        return {
-            mode,
-            preset
-        };
-    } catch  {
+        const preset = isThemePreset(record.preset)
+            ? record.preset
+            : fallback.preset;
+        return { mode, preset };
+    }
+    catch {
         // Legacy: a bare mode string from an earlier client.
-        if (isThemeMode(raw)) return {
-            mode: raw,
-            preset: fallback.preset
-        };
+        if (isThemeMode(raw))
+            return { mode: raw, preset: fallback.preset };
         return fallback;
     }
 }
 export function serializeThemePreference(preference) {
-    return JSON.stringify({
-        mode: preference.mode,
-        preset: preference.preset
-    });
+    return JSON.stringify({ mode: preference.mode, preset: preference.preset });
 }
-/** Cycle system → light → dark → system for a one-control toggle. */ export function nextThemeMode(mode) {
-    if (mode === "system") return "light";
-    if (mode === "light") return "dark";
+/** Cycle system → light → dark → system for a one-control toggle. */
+export function nextThemeMode(mode) {
+    if (mode === "system")
+        return "light";
+    if (mode === "light")
+        return "dark";
     return "system";
 }
-/** Apply resolved mode + preset to a root element (usually documentElement). */ export function applyThemeToRoot(root, resolved, preset) {
+/** Apply resolved mode + preset to a root element (usually documentElement). */
+export function applyThemeToRoot(root, resolved, preset) {
     root.classList.toggle("dark", resolved === "dark");
     // `.light` is the explicit-light escape hatch from the `prefers-color-scheme`
     // media query in theme.css — without it, "light" mode chosen on a dark-OS
@@ -68,7 +69,8 @@ export function serializeThemePreference(preference) {
     root.classList.toggle("light", resolved === "light");
     if (preset === "default") {
         root.removeAttribute("data-theme");
-    } else {
+    }
+    else {
         root.setAttribute("data-theme", preset);
     }
     if (root instanceof HTMLElement) {

package/dist/lib/url.js

@@ -1,7 +1,4 @@
-const DEFAULT_ALLOWED_PROTOCOLS = [
-    "http:",
-    "https:"
-];
+const DEFAULT_ALLOWED_PROTOCOLS = ["http:", "https:"];
 /**
  * Is `url` safe to hand to a live sink — `href`, `src`, `window.open` — as-is?
  *
@@ -17,10 +14,12 @@ const DEFAULT_ALLOWED_PROTOCOLS = [
  * sink this guards links to a third-party resource — a citation, a download,
  * an embed — so there is no in-app page a bare path could sensibly mean, and
  * inventing a base to resolve against would only guess wrong.
- */ export function isSafeUrl(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
+ */
+export function isSafeUrl(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
     try {
         return allowedProtocols.includes(new URL(url).protocol);
-    } catch  {
+    }
+    catch {
         return false;
     }
 }
@@ -31,7 +30,9 @@ const DEFAULT_ALLOWED_PROTOCOLS = [
  * into `href`/`src` when present, and a clean signal to fall back to plain
  * text when not. Never returns a placeholder like `"#"` — a disabled-looking
  * link that is secretly still a link is its own trap.
- */ export function toSafeHref(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
-    if (url === undefined) return undefined;
+ */
+export function toSafeHref(url, allowedProtocols = DEFAULT_ALLOWED_PROTOCOLS) {
+    if (url === undefined)
+        return undefined;
     return isSafeUrl(url, allowedProtocols) ? url : undefined;
 }

package/dist/lib/workflow-display-flow.js

@@ -1,5 +1,5 @@
 function characterOf(primitive) {
-    switch(primitive.kind){
+    switch (primitive.kind) {
         case "step":
         case "map":
             return primitive.deterministic === true ? "deterministic" : "reasoning";
@@ -25,14 +25,15 @@ function characterOf(primitive) {
  * author-tagging convention (a legacy tag, a metadata field) out of a
  * published library, where the tag vocabulary would become part of the
  * public surface.
- */ export function deriveDisplayFlow(primitives) {
+ */
+export function deriveDisplayFlow(primitives) {
     return {
-        steps: primitives.map((primitive)=>({
-                stepId: primitive.stepId,
-                label: primitive.label ?? primitive.stepId,
-                character: characterOf(primitive),
-                after: primitive.after ?? []
-            }))
+        steps: primitives.map((primitive) => ({
+            stepId: primitive.stepId,
+            label: primitive.label ?? primitive.stepId,
+            character: characterOf(primitive),
+            after: primitive.after ?? [],
+        })),
     };
 }
 /**
@@ -40,7 +41,8 @@ function characterOf(primitive) {
  * with different characters — the strongest signal wins so a group never
  * under-represents itself (a group containing one human `await` step reads
  * as `await` even if every other step in it is `deterministic`).
- */ const CHARACTER_PRIORITY = [
+ */
+const CHARACTER_PRIORITY = [
     "await",
     "gate",
     "child",
@@ -48,11 +50,12 @@ function characterOf(primitive) {
     "reasoning",
     "sleep",
     "deterministic",
-    "other"
+    "other",
 ];
 function aggregateCharacter(characters) {
-    for (const candidate of CHARACTER_PRIORITY){
-        if (characters.includes(candidate)) return candidate;
+    for (const candidate of CHARACTER_PRIORITY) {
+        if (characters.includes(candidate))
+            return candidate;
     }
     return "other";
 }
@@ -61,14 +64,12 @@ function aggregateCharacter(characters) {
  * group's `steps` is validated against the flow's actual step ids — an
  * unknown id throws immediately rather than silently producing an empty or
  * partial group.
- */ export function applyDisplayOverlay(flow, overlay) {
-    const byId = new Map(flow.steps.map((step)=>[
-            step.stepId,
-            step
-        ]));
-    const groups = overlay.groups.map((group)=>{
+ */
+export function applyDisplayOverlay(flow, overlay) {
+    const byId = new Map(flow.steps.map((step) => [step.stepId, step]));
+    const groups = overlay.groups.map((group) => {
         const characters = [];
-        for (const stepId of group.steps){
+        for (const stepId of group.steps) {
             const step = byId.get(stepId);
             if (step === undefined) {
                 throw new Error(`display overlay group ${JSON.stringify(group.key)} references unknown step ${JSON.stringify(stepId)}`);
@@ -80,25 +81,28 @@ function aggregateCharacter(characters) {
             label: group.label,
             character: aggregateCharacter(characters),
             stepIds: group.steps,
-            ...group.activityLabel !== undefined ? {
-                activityLabel: group.activityLabel
-            } : {}
+            ...(group.activityLabel !== undefined
+                ? { activityLabel: group.activityLabel }
+                : {}),
         };
     });
-    return {
-        groups
-    };
+    return { groups };
 }
 /**
  * Maps pure display-flow steps into `StepList` items, all `pending` unless a
  * status lookup is given — the host overlays real run state on top once it
  * has any.
- */ export function stepListFromDisplayFlow(steps, statusById) {
-    const lookup = statusById instanceof Map ? (id)=>statusById.get(id) : statusById !== undefined ? (id)=>statusById[id] : ()=>undefined;
-    return steps.map((step)=>({
-            id: step.stepId,
-            name: step.label,
-            status: lookup(step.stepId) ?? "pending",
-            character: step.character
-        }));
+ */
+export function stepListFromDisplayFlow(steps, statusById) {
+    const lookup = statusById instanceof Map
+        ? (id) => statusById.get(id)
+        : statusById !== undefined
+            ? (id) => statusById[id]
+            : () => undefined;
+    return steps.map((step) => ({
+        id: step.stepId,
+        name: step.label,
+        status: lookup(step.stepId) ?? "pending",
+        character: step.character,
+    }));
 }

package/dist/lib/workflow-registry.d.ts

@@ -30,33 +30,6 @@ export declare function workflowScopeLabel(scope: WorkflowScope): string;
  * as shared infrastructure; `personal` gets the accent tone that marks
  * "yours" everywhere else in the registry. */
 export declare const WORKFLOW_SCOPE_BADGE_TONE: Record<WorkflowScope, BadgeTone>;
-/** A live run's phase as an inspector or list row reports it — a coarser
- * vocabulary than `RunStatus` in `workflow-run.ts` (no `provisioning`), for
- * surfaces that only distinguish what a reader can act on. */
-export type LiveRunPhase = "running" | "awaiting" | "completed" | "failed" | "cancelled";
-export declare const LIVE_RUN_PHASE_TONE: Record<LiveRunPhase, WorkflowStatusTone>;
-export declare const LIVE_RUN_PHASE_LABEL: Record<LiveRunPhase, string>;
-export type WorkflowListItemKind = "run" | "schedule";
-/** One dense row in the combined live-runs-and-schedules list. */
-export type WorkflowListItem = {
-    readonly id: string;
-    readonly itemKind: WorkflowListItemKind;
-    /** Primary label — the workflow's kind, already humanised. */
-    readonly title: string;
-    /** Secondary line under the title: an alias, an origin tag. */
-    readonly subtitle?: string;
-    /** The "when" column: origin phrase for a run, cadence for a schedule. */
-    readonly when: string;
-    readonly scope: WorkflowScope;
-    readonly statusTone: WorkflowStatusTone;
-    readonly statusLabel: string;
-    /** Next-fire or elapsed text, already formatted by the caller. */
-    readonly nextOrElapsed: string;
-    /** Highlights `nextOrElapsed` — the next fire is close, or the run is fresh. */
-    readonly nextSoon?: boolean;
-    /** A live run parked on a human decision gets a subtle accent stripe. */
-    readonly needsYou?: boolean;
-};
 export type GateKind = "reviewList" | "choice" | "form" | "multiSelect";
 export declare const GATE_KIND_LABEL: Record<GateKind, string>;
 /** Shell model for a pending gate; the interactive payload is the caller's. */
@@ -65,20 +38,6 @@ export type GateShellModel = {
     readonly title: string;
     readonly prompt?: string;
 };
-/** One offering in a workflow-kind picker (distinct from `WorkflowOffering` in
- * `workflow-catalog.tsx`, which drives the run-once grid): this shape adds
- * category grouping and an "already on" badge for a picker that lists kinds
- * to attach to a schedule or an automation rather than to run once. */
-export type KindPickerItem = {
-    readonly id: string;
-    readonly label: string;
-    readonly description: string;
-    /** Grouping key. Omit when every item shares one category. */
-    readonly category?: string;
-    readonly categoryLabel?: string;
-    readonly alreadyOn?: boolean;
-    readonly alreadyOnLabel?: string;
-};
 export type StepDisplayStatus = "pending" | "active" | "done" | "failed";
 /** One step row in the live inspector's step list. */
 export type StepListItem = {

package/dist/lib/workflow-registry.js

@@ -3,26 +3,29 @@ export const WORKFLOW_STATUS_LABEL = {
     awaiting: "Needs you",
     done: "Done",
     paused: "Paused",
-    fail: "Failed"
+    fail: "Failed",
 };
-/** Badge tone for a status chip composed as `<Badge tone={...}><StatusDot .../>{label}</Badge>`. */ export const WORKFLOW_STATUS_BADGE_TONE = {
+/** Badge tone for a status chip composed as `<Badge tone={...}><StatusDot .../>{label}</Badge>`. */
+export const WORKFLOW_STATUS_BADGE_TONE = {
     running: "info",
     awaiting: "accent",
     done: "success",
     paused: "neutral",
-    fail: "danger"
+    fail: "danger",
 };
-/** Dot tone for the same chip — see `status-dot.tsx` for why only three exist. */ export const WORKFLOW_STATUS_DOT_TONE = {
+/** Dot tone for the same chip — see `status-dot.tsx` for why only three exist. */
+export const WORKFLOW_STATUS_DOT_TONE = {
     running: "emphasis",
     awaiting: "emphasis",
     done: "neutral",
     paused: "neutral",
-    fail: "danger"
+    fail: "danger",
 };
 /** Whether a status tone's dot pulses by default — the two tones that are
  * still moving or still waiting on someone. A caller composing `Badge` +
  * `StatusDot` directly (there is no `StatusChip` component) passes this as
- * `StatusDot`'s `live` prop unless it has a more specific signal. */ export function workflowStatusLive(tone) {
+ * `StatusDot`'s `live` prop unless it has a more specific signal. */
+export function workflowStatusLive(tone) {
     return tone === "running" || tone === "awaiting";
 }
 export function workflowScopeLabel(scope) {
@@ -30,27 +33,14 @@ export function workflowScopeLabel(scope) {
 }
 /** Badge tone for a workflow's scope. `tenant` gets the info tone so it reads
  * as shared infrastructure; `personal` gets the accent tone that marks
- * "yours" everywhere else in the registry. */ export const WORKFLOW_SCOPE_BADGE_TONE = {
+ * "yours" everywhere else in the registry. */
+export const WORKFLOW_SCOPE_BADGE_TONE = {
     tenant: "info",
-    personal: "accent"
-};
-export const LIVE_RUN_PHASE_TONE = {
-    running: "running",
-    awaiting: "awaiting",
-    completed: "done",
-    failed: "fail",
-    cancelled: "fail"
-};
-export const LIVE_RUN_PHASE_LABEL = {
-    running: "Running",
-    awaiting: "Needs you",
-    completed: "Done",
-    failed: "Failed",
-    cancelled: "Cancelled"
+    personal: "accent",
 };
 export const GATE_KIND_LABEL = {
     reviewList: "Needs you · review",
     choice: "Needs you · choice",
     form: "Needs you · form",
-    multiSelect: "Needs you · select"
+    multiSelect: "Needs you · select",
 };

package/dist/lib/workflow-run-error.js

@@ -8,7 +8,8 @@
  * plain-language messages, and defaults everything unrecognized to a
  * generic-but-honest internal message. The raw text survives on the result
  * for an operator surface or a log; it must never reach an end-user panel.
- */ const PROVIDER_API_ERROR = /^([A-Za-z][A-Za-z0-9]*(?: [A-Za-z0-9]+){0,2}) API error: (\d{3})/;
+ */
+const PROVIDER_API_ERROR = /^([A-Za-z][A-Za-z0-9]*(?: [A-Za-z0-9]+){0,2}) API error: (\d{3})/;
 const ANY_API_ERROR = /\bAPI error: (\d{3})/;
 const GENERIC_PROVIDER_LABEL = "An external service";
 const NETWORK_PATTERNS = [
@@ -19,37 +20,39 @@ const NETWORK_PATTERNS = [
     /\bEAI_AGAIN\b/,
     /\bsocket\b.*\b(closed|hang ?up|reset)\b/i,
     /\b(request|fetch|connect(?:ion)?|socket)\b.*\btimed out\b/i,
-    /\bnetwork (error|request failed)\b/i
+    /\bnetwork (error|request failed)\b/i,
 ];
 const INTERNAL_MESSAGE = "Something went wrong inside this workflow run. Try running it again; if it keeps failing, contact your workspace admin.";
 const NETWORK_MESSAGE = "A service this workflow depends on couldn't be reached. Try running it again in a moment.";
 function classifyProviderError(provider, status, raw) {
-    const credentialRef = provider === GENERIC_PROVIDER_LABEL ? "credential's" : `${provider} credential's`;
+    const credentialRef = provider === GENERIC_PROVIDER_LABEL
+        ? "credential's"
+        : `${provider} credential's`;
     if (status === 401 || status === 403) {
         return {
             kind: "external-auth",
             userMessage: `${provider} declined the request (${status}). Check the connected ${credentialRef} access and try again.`,
-            raw
+            raw,
         };
     }
     if (status === 429) {
         return {
             kind: "external-rate-limit",
             userMessage: `${provider} is rate-limiting requests right now. Wait a few minutes and run this again.`,
-            raw
+            raw,
         };
     }
     if (status >= 500) {
         return {
             kind: "external-unavailable",
             userMessage: `${provider} had a problem on its end (${status}). Try running this again shortly.`,
-            raw
+            raw,
         };
     }
     return {
         kind: "external-rejected",
         userMessage: `${provider} rejected the request (${status}). Try again, and contact your workspace admin if it keeps failing.`,
-        raw
+        raw,
     };
 }
 export function classifyRunError(raw) {
@@ -61,18 +64,10 @@ export function classifyRunError(raw) {
     if (anyApiErrorMatch?.[1] !== undefined) {
         return classifyProviderError(GENERIC_PROVIDER_LABEL, Number(anyApiErrorMatch[1]), raw);
     }
-    if (NETWORK_PATTERNS.some((pattern)=>pattern.test(raw))) {
-        return {
-            kind: "network",
-            userMessage: NETWORK_MESSAGE,
-            raw
-        };
+    if (NETWORK_PATTERNS.some((pattern) => pattern.test(raw))) {
+        return { kind: "network", userMessage: NETWORK_MESSAGE, raw };
     }
-    return {
-        kind: "internal",
-        userMessage: INTERNAL_MESSAGE,
-        raw
-    };
+    return { kind: "internal", userMessage: INTERNAL_MESSAGE, raw };
 }
 /**
  * Plain-language line for a step's live inference issue — a still-running
@@ -83,8 +78,9 @@ export function classifyRunError(raw) {
  * runtime's error types. The step keeps running for every category except
  * `context_overflow`, where the input itself must shrink before a retry can
  * help — its message is the one that omits the retry claim.
- */ export function describeLiveInferenceIssue(category) {
-    switch(category){
+ */
+export function describeLiveInferenceIssue(category) {
+    switch (category) {
         case "timeout":
             return "Model provider timed out — retrying";
         case "retryable":