@calliopelabs/ui 0.14.0 → 0.18.0

package/dist/workbench/sql-completion.js

@@ -0,0 +1,475 @@
+/**
+ * Schema-aware SQL completion, without Monaco: what to suggest at a cursor,
+ * given the text and a host-provided schema. `SqlEditor` turns the result
+ * into Monaco completion items; anything else (a plain textarea, a test) can
+ * use it as it is. Pure.
+ */
+export const SQL_KEYWORDS = [
+    "SELECT",
+    "FROM",
+    "WHERE",
+    "AND",
+    "OR",
+    "NOT",
+    "IN",
+    "BETWEEN",
+    "LIKE",
+    "IS",
+    "NULL",
+    "AS",
+    "ON",
+    "JOIN",
+    "INNER",
+    "LEFT",
+    "RIGHT",
+    "FULL",
+    "OUTER",
+    "CROSS",
+    "GROUP BY",
+    "ORDER BY",
+    "HAVING",
+    "LIMIT",
+    "OFFSET",
+    "UNION",
+    "ALL",
+    "DISTINCT",
+    "INSERT INTO",
+    "VALUES",
+    "UPDATE",
+    "SET",
+    "DELETE",
+    "CREATE TABLE",
+    "ALTER TABLE",
+    "DROP TABLE",
+    "CREATE INDEX",
+    "DROP INDEX",
+    "TRUNCATE",
+    "EXISTS",
+    "CASE",
+    "WHEN",
+    "THEN",
+    "ELSE",
+    "END",
+    "CAST",
+    "COALESCE",
+    "NULLIF",
+    "WITH",
+    "RECURSIVE",
+    "ASC",
+    "DESC",
+    "TRUE",
+    "FALSE",
+    "DEFAULT",
+    "PRIMARY KEY",
+    "FOREIGN KEY",
+    "REFERENCES",
+    "CONSTRAINT",
+    "UNIQUE",
+    "CHECK",
+    "INDEX",
+    "USE",
+    "FETCH FIRST",
+    "ROWS ONLY",
+    "PERCENT",
+    "TOP",
+    "WINDOW",
+];
+export const SQL_FUNCTIONS = [
+    "COUNT",
+    "SUM",
+    "AVG",
+    "MIN",
+    "MAX",
+    "ROUND",
+    "UPPER",
+    "LOWER",
+    "TRIM",
+    "LENGTH",
+    "SUBSTRING",
+    "REPLACE",
+    "CONCAT",
+    "NOW",
+    "CURRENT_TIMESTAMP",
+    "CURRENT_DATE",
+    "DATE",
+    "EXTRACT",
+    "COALESCE",
+    "NULLIF",
+    "CAST",
+    "CONVERT",
+    "ROW_NUMBER",
+    "RANK",
+    "DENSE_RANK",
+    "LAG",
+    "LEAD",
+    "FIRST_VALUE",
+    "LAST_VALUE",
+    "NTILE",
+    "PERCENT_RANK",
+    "CUME_DIST",
+    "NTH_VALUE",
+    "ARRAY_AGG",
+    "STRING_AGG",
+    "JSON_AGG",
+    "JSONB_AGG",
+    "ABS",
+    "CEIL",
+    "FLOOR",
+    "MOD",
+    "POWER",
+    "SQRT",
+    "LOG",
+    "EXP",
+    "LEFT",
+    "RIGHT",
+    "LPAD",
+    "RPAD",
+    "LTRIM",
+    "RTRIM",
+    "REVERSE",
+    "DATE_TRUNC",
+    "DATE_PART",
+    "AGE",
+    "INTERVAL",
+    "TO_CHAR",
+    "TO_DATE",
+    "TO_NUMBER",
+    "TO_TIMESTAMP",
+    "GREATEST",
+    "LEAST",
+    "GENERATE_SERIES",
+];
+const WINDOW_SNIPPETS = [
+    {
+        label: "ROW_NUMBER() OVER ...",
+        insertText: "ROW_NUMBER() OVER (PARTITION BY ${1:column} ORDER BY ${2:column})",
+        detail: "Window: row number",
+    },
+    {
+        label: "RANK() OVER ...",
+        insertText: "RANK() OVER (PARTITION BY ${1:column} ORDER BY ${2:column})",
+        detail: "Window: rank",
+    },
+    {
+        label: "DENSE_RANK() OVER ...",
+        insertText: "DENSE_RANK() OVER (PARTITION BY ${1:column} ORDER BY ${2:column})",
+        detail: "Window: dense rank",
+    },
+    {
+        label: "LAG() OVER ...",
+        insertText: "LAG(${1:column}, ${2:1}) OVER (ORDER BY ${3:column})",
+        detail: "Window: previous row value",
+    },
+    {
+        label: "LEAD() OVER ...",
+        insertText: "LEAD(${1:column}, ${2:1}) OVER (ORDER BY ${3:column})",
+        detail: "Window: next row value",
+    },
+    {
+        label: "SUM() OVER ...",
+        insertText: "SUM(${1:column}) OVER (PARTITION BY ${2:column} ORDER BY ${3:column})",
+        detail: "Window: running sum",
+    },
+    {
+        label: "AVG() OVER ...",
+        insertText: "AVG(${1:column}) OVER (PARTITION BY ${2:column} ORDER BY ${3:column})",
+        detail: "Window: running average",
+    },
+    {
+        label: "COUNT() OVER ...",
+        insertText: "COUNT(${1:*}) OVER (PARTITION BY ${2:column})",
+        detail: "Window: count per partition",
+    },
+    {
+        label: "NTILE() OVER ...",
+        insertText: "NTILE(${1:4}) OVER (ORDER BY ${2:column})",
+        detail: "Window: distribute into N buckets",
+    },
+];
+/** Case-insensitive substring match; an empty input matches everything. */
+export function sqlMatch(input, candidate) {
+    return !input || candidate.toLowerCase().includes(input.toLowerCase());
+}
+/** What the cursor is in, from the text before it: after FROM, after SELECT, after `alias.`. */
+export function sqlCursorContext(textBeforeCursor) {
+    const trimmed = textBeforeCursor.trimEnd();
+    const dot = /([A-Za-z_][\w$]*)\.([\w$]*)$/.exec(trimmed);
+    if (dot)
+        return { context: "dot", prefix: dot[1] ?? "", word: dot[2] ?? "" };
+    const upper = trimmed.toUpperCase().replace(/\s+/g, " ");
+    if (/\bUSE$/.test(upper))
+        return { context: "database" };
+    if (/(?:FROM|JOIN|INTO|UPDATE|TABLE)$/.test(upper) ||
+        /(?:FROM|JOIN|INTO|UPDATE|TABLE) [\w, ]*,$/.test(upper)) {
+        return { context: "table" };
+    }
+    if (/(?:SELECT|WHERE|AND|OR|ON|SET|HAVING|BY)$/.test(upper) ||
+        /(?:SELECT|WHERE|AND|OR|ON|SET|HAVING|BY) [\w.]+ ?,$/.test(upper)) {
+        return { context: "column" };
+    }
+    return { context: "general" };
+}
+/**
+ * The statement around `offset` in a buffer of several. Semicolons inside
+ * string literals and line comments do not split, so aliases resolve against
+ * the statement being written, never an earlier one.
+ */
+export function statementAt(text, offset) {
+    let start = 0;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "'" && !inDouble) {
+            if (inSingle && text[i + 1] === "'") {
+                i++;
+                continue;
+            }
+            inSingle = !inSingle;
+        }
+        else if (ch === '"' && !inSingle) {
+            inDouble = !inDouble;
+        }
+        else if (ch === "-" && text[i + 1] === "-" && !inSingle && !inDouble) {
+            const nl = text.indexOf("\n", i);
+            if (nl === -1)
+                break;
+            i = nl;
+        }
+        else if (ch === ";" && !inSingle && !inDouble) {
+            if (i >= offset)
+                return text.slice(start, i);
+            start = i + 1;
+        }
+    }
+    return text.slice(start);
+}
+const NON_ALIAS = new Set([
+    ...SQL_KEYWORDS.map((k) => k.split(" ")[0] ?? k),
+    "GROUP",
+    "ORDER",
+    "NATURAL",
+    "LATERAL",
+    "USING",
+    "EXCEPT",
+    "INTERSECT",
+    "RETURNING",
+    "TABLESAMPLE",
+    "PARTITION",
+    "STRAIGHT_JOIN",
+    "FETCH",
+    "FOR",
+]);
+const IDENT = String.raw `(?:"[^"]+"|\`[^\`]+\`|[A-Za-z_][\w$]*)`;
+const TABLE_REF = new RegExp(String.raw `\b(?:FROM|JOIN|UPDATE|INTO)\s+(${IDENT}(?:\s*\.\s*${IDENT})*)(?:\s+(?:AS\s+)?(${IDENT}))?`, "gi");
+const unquote = (ident) => ident.replace(/^["`]|["`]$/g, "").toLowerCase();
+/** The tables a statement's FROM, JOIN, UPDATE and INTO name, with their aliases. */
+export function extractTableRefs(statement) {
+    const refs = [];
+    for (const match of statement.matchAll(TABLE_REF)) {
+        const parts = (match[1] ?? "").split(".").map((p) => unquote(p.trim()));
+        const table = parts[parts.length - 1] ?? "";
+        const schema = parts.length > 1 ? parts[parts.length - 2] : undefined;
+        const raw = match[2];
+        const alias = raw && !NON_ALIAS.has(unquote(raw).toUpperCase()) ? unquote(raw) : undefined;
+        refs.push({ table, schema, alias });
+    }
+    return refs;
+}
+/**
+ * What `prefix.` refers to: an alias in this statement first, then a table
+ * the statement names, a known table, a known schema, a known database. An
+ * unrecognised prefix is unknown, and nothing should be requested for it.
+ */
+export function resolveSqlDot(prefix, statement, schema) {
+    const needle = unquote(prefix);
+    if (!needle)
+        return { kind: "unknown" };
+    const refs = extractTableRefs(statement);
+    const aliased = refs.find((r) => r.alias === needle);
+    if (aliased)
+        return { kind: "columns", table: aliased.table };
+    const named = refs.find((r) => !r.alias && r.table === needle);
+    if (named)
+        return { kind: "columns", table: named.table };
+    const known = schema.tables.find((t) => t.name.toLowerCase() === needle);
+    if (known)
+        return { kind: "columns", table: known.name };
+    const sch = schema.schemas?.find((s) => s.toLowerCase() === needle);
+    if (sch)
+        return { kind: "schema", schema: sch };
+    const db = schema.databases?.find((d) => d.toLowerCase() === needle);
+    if (db)
+        return { kind: "database", database: db };
+    return { kind: "unknown" };
+}
+/** Column names that more than one table has, which completion qualifies. */
+export function ambiguousColumns(tables) {
+    const seen = new Map();
+    for (const t of tables) {
+        for (const c of t.columns ?? []) {
+            const key = c.name.toLowerCase();
+            seen.set(key, (seen.get(key) ?? 0) + 1);
+        }
+    }
+    return new Set([...seen].filter(([, n]) => n > 1).map(([k]) => k));
+}
+/** True when a statement changes the schema, so a host's cached schema is stale. */
+export function isDdlStatement(sql) {
+    return /^\s*(CREATE|ALTER|DROP|TRUNCATE|RENAME|COMMENT\s+ON|REFRESH\s+MATERIALIZED)\b/i.test(sql);
+}
+const columnDetail = (c, table) => [c.type, c.nullable ? "nullable" : undefined, table].filter(Boolean).join(" · ");
+/**
+ * The completions at `offset` in `text`, from the schema the host gave.
+ * Never waits for anything: what the schema lacks comes back as `requests`.
+ */
+export function sqlCompletions(text, offset, schema) {
+    const before = text.slice(0, offset);
+    const word = /[\w$]*$/.exec(before)?.[0] ?? "";
+    const ctx = sqlCursorContext(before);
+    const items = [];
+    const requests = [];
+    const databases = schema.databases ?? [];
+    const tables = (list, sort, detail) => {
+        for (const t of list) {
+            if (sqlMatch(word, t.name)) {
+                items.push({
+                    label: t.name,
+                    kind: "table",
+                    insertText: t.name,
+                    detail: detail(t),
+                    sortText: sort + t.name,
+                });
+            }
+        }
+    };
+    const dbs = (sort) => {
+        for (const d of databases) {
+            if (sqlMatch(word, d))
+                items.push({
+                    label: d,
+                    kind: "database",
+                    insertText: d,
+                    detail: "Database",
+                    sortText: sort + d,
+                });
+        }
+    };
+    const windows = () => {
+        for (const s of WINDOW_SNIPPETS) {
+            if (sqlMatch(word, s.label)) {
+                items.push({
+                    label: s.label,
+                    kind: "snippet",
+                    insertText: s.insertText,
+                    snippet: true,
+                    detail: s.detail,
+                    sortText: "1w" + s.label,
+                });
+            }
+        }
+    };
+    const tableDetail = (t) => (t.schema ? `Table · ${t.schema}` : "Table");
+    switch (ctx.context) {
+        case "database":
+            dbs("0");
+            break;
+        case "table":
+            tables(schema.tables, "0", tableDetail);
+            dbs("1");
+            break;
+        case "dot": {
+            // The half-typed `prefix.word` is not a table reference of the statement.
+            const start = before.lastIndexOf(`${ctx.prefix}.${ctx.word}`);
+            const rest = start >= 0 ? text.slice(0, start) + text.slice(offset) : text;
+            const target = resolveSqlDot(ctx.prefix, statementAt(rest, Math.max(start, 0)), schema);
+            if (target.kind === "columns") {
+                const table = schema.tables.find((t) => t.name.toLowerCase() === target.table.toLowerCase());
+                if (table?.columns) {
+                    for (const c of table.columns) {
+                        if (sqlMatch(word, c.name)) {
+                            items.push({
+                                label: c.name,
+                                kind: "column",
+                                insertText: c.name,
+                                detail: columnDetail(c, table.name),
+                                sortText: "0" + c.name,
+                            });
+                        }
+                    }
+                }
+                else if (table) {
+                    requests.push({ kind: "columns", table: table.name, schema: table.schema });
+                }
+            }
+            else if (target.kind === "schema") {
+                const inSchema = schema.tables.filter((t) => !t.schema || t.schema.toLowerCase() === target.schema.toLowerCase());
+                tables(inSchema, "0", () => `Table · ${target.schema}`);
+            }
+            else if (target.kind === "database") {
+                const other = schema.otherDatabases?.[target.database];
+                if (other)
+                    tables(other, "0", () => `Table · ${target.database}`);
+                else
+                    requests.push({ kind: "database", database: target.database });
+            }
+            break;
+        }
+        case "column": {
+            const ambiguous = ambiguousColumns(schema.tables);
+            const seen = new Set();
+            for (const t of schema.tables) {
+                for (const c of t.columns ?? []) {
+                    if (!sqlMatch(word, c.name))
+                        continue;
+                    const key = c.name.toLowerCase();
+                    const ambig = ambiguous.has(key);
+                    if (ambig) {
+                        items.push({
+                            label: `${t.name}.${c.name}`,
+                            kind: "column",
+                            insertText: `${t.name}.${c.name}`,
+                            detail: columnDetail(c, t.name),
+                            sortText: "0a" + c.name,
+                        });
+                    }
+                    if (!seen.has(key)) {
+                        seen.add(key);
+                        items.push({
+                            label: c.name,
+                            kind: "column",
+                            insertText: c.name,
+                            detail: columnDetail(c, t.name),
+                            sortText: (ambig ? "0b" : "0") + c.name,
+                        });
+                    }
+                }
+            }
+            tables(schema.tables, "1", () => "Table");
+            windows();
+            break;
+        }
+        default: {
+            for (const k of SQL_KEYWORDS) {
+                if (sqlMatch(word, k))
+                    items.push({ label: k, kind: "keyword", insertText: k, sortText: "2" + k });
+            }
+            for (const f of SQL_FUNCTIONS) {
+                if (sqlMatch(word, f)) {
+                    items.push({
+                        label: f,
+                        kind: "function",
+                        insertText: `${f}(\${1})`,
+                        snippet: true,
+                        detail: "Function",
+                        sortText: "1" + f,
+                    });
+                }
+            }
+            windows();
+            tables(schema.tables, "0", tableDetail);
+            dbs("3");
+        }
+    }
+    return { items, requests };
+}

package/dist/workbench/typeahead.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Type-to-find for trees, lists and grids: printable keys typed within half
+ * a second build a prefix; the next name after the current one that starts
+ * with it (case-insensitive) is the answer. Returns that index, or null when
+ * the key is not a typeahead key or nothing matches.
+ */
+export declare function typeahead(state: {
+    text: string;
+    at: number;
+}, event: {
+    key: string;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    altKey: boolean;
+}, names: readonly string[], current: number): number | null;

package/dist/workbench/typeahead.js

@@ -0,0 +1,22 @@
+/**
+ * Type-to-find for trees, lists and grids: printable keys typed within half
+ * a second build a prefix; the next name after the current one that starts
+ * with it (case-insensitive) is the answer. Returns that index, or null when
+ * the key is not a typeahead key or nothing matches.
+ */
+export function typeahead(state, event, names, current) {
+    if (event.key.length !== 1 || event.ctrlKey || event.metaKey || event.altKey || event.key === " ")
+        return null;
+    const now = Date.now();
+    state.text = now - state.at > 500 ? event.key : state.text + event.key;
+    state.at = now;
+    const prefix = state.text.toLowerCase();
+    // A repeated single letter cycles; a longer prefix may stay on the current name.
+    const start = state.text.length === 1 ? current + 1 : current;
+    for (let i = 0; i < names.length; i++) {
+        const index = (start + i) % names.length;
+        if (names[index]?.toLowerCase().startsWith(prefix))
+            return index;
+    }
+    return null;
+}

package/dist/workflow/WorkflowRuntimeControls.d.ts

@@ -0,0 +1,21 @@
+import * as React from "react";
+import { type WorkflowRuntimeState, type WorkflowRuntimeBinding, type WorkflowPauseReceipt, type WorkflowRuntimeIntent } from "./runtime-controls.js";
+export interface WorkflowRuntimeControlsProps {
+    state: WorkflowRuntimeState;
+    /** Current execution phase, independent of the last control's delivery state. */
+    phase: "running" | "paused" | null;
+    binding: WorkflowRuntimeBinding | null;
+    /** Verified by the host against the current runtime. A scheduling pause supplies no receipt. */
+    pausedReceipt?: WorkflowPauseReceipt | null;
+    draft?: string;
+    onDraftChange?: (value: string) => void;
+    /** The host must retain request identity before delivery. No network calls occur here. */
+    onIntent?: (intent: WorkflowRuntimeIntent) => void;
+    onRefresh?: () => void;
+    canControl?: boolean;
+    loading?: boolean;
+    reason?: string;
+    className?: string;
+}
+/** Controlled original-agent controls. Unknown delivery cannot emit a new operation. */
+export declare function WorkflowRuntimeControls({ state, phase, binding, pausedReceipt, draft, onDraftChange, onIntent, onRefresh, canControl, loading, reason, className, }: WorkflowRuntimeControlsProps): React.JSX.Element;

package/dist/workflow/WorkflowRuntimeControls.js

@@ -0,0 +1,54 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import * as React from "react";
+import { cn } from "../lib/cn.js";
+import { Button } from "../primitives/Button.js";
+import { Field } from "../primitives/Field.js";
+import { Textarea } from "../primitives/Textarea.js";
+import { Skeleton } from "../primitives/Skeleton.js";
+import { StatusBadge } from "../status/StatusBadge.js";
+import { useUI } from "../provider/UIProvider.js";
+import { validWorkflowSteering, } from "./runtime-controls.js";
+const tone = {
+    running: "info",
+    paused: "warn",
+    "pause-requested": "info",
+    "resume-requested": "info",
+    "steering-queued": "info",
+    "steering-applied": "ok",
+    refused: "error",
+    "delivery-unknown": "warn",
+    unavailable: "muted",
+    finished: "muted",
+};
+/** Controlled original-agent controls. Unknown delivery cannot emit a new operation. */
+export function WorkflowRuntimeControls({ state, phase, binding, pausedReceipt, draft = "", onDraftChange, onIntent, onRefresh, canControl = false, loading = false, reason, className, }) {
+    const t = useUI().messages.workflowRuntime;
+    const id = React.useId();
+    const running = phase === "running" &&
+        (state === "running" || state === "steering-applied" || state === "refused");
+    const editable = !loading && canControl && !!binding && !!onIntent;
+    const canResume = editable &&
+        phase === "paused" &&
+        (state === "paused" || state === "refused") &&
+        !!pausedReceipt &&
+        pausedReceipt.kind === "paused" &&
+        pausedReceipt.sessionId === binding?.sessionId &&
+        pausedReceipt.revision === binding?.revision &&
+        pausedReceipt.checksum === binding?.checksum;
+    const valid = validWorkflowSteering(draft);
+    function send(operation) {
+        if (!editable || !binding)
+            return;
+        if (operation === "resume" && canResume && pausedReceipt)
+            onIntent?.({ operation, binding: { ...binding }, pausedReceipt: { ...pausedReceipt } });
+        else if (operation === "pause" && running)
+            onIntent?.({ operation, binding: { ...binding } });
+        else if (operation === "steer" && running && valid)
+            onIntent?.({ operation, binding: { ...binding }, text: draft });
+    }
+    return (_jsxs("section", { "aria-labelledby": `${id}-title`, "aria-busy": loading, "data-slot": "workflow-runtime-controls", className: cn("space-y-4 rounded-lg border bg-card p-4 text-card-foreground", className), children: [_jsxs("div", { className: "flex flex-wrap items-center justify-between gap-3", children: [_jsx("h3", { id: `${id}-title`, className: "font-medium break-words", children: t.title }), !loading && (_jsx(StatusBadge, { tone: tone[state], pulse: ["pause-requested", "resume-requested", "steering-queued"].includes(state), children: t.state(state) }))] }), _jsx("p", { role: "status", className: "text-sm text-muted-foreground", children: loading ? t.loading : t.description(state) }), reason && _jsx("p", { className: "text-sm break-words text-muted-foreground", children: reason }), loading ? (_jsx(Skeleton, { className: "h-20 w-full" })) : (_jsxs(_Fragment, { children: [!binding && _jsx("p", { className: "text-sm text-muted-foreground", children: t.empty }), !canControl && _jsx("p", { className: "text-sm text-muted-foreground", children: t.readOnly }), _jsxs("div", { className: "flex flex-wrap gap-2", children: [_jsx(Button, { type: "button", variant: "outline", disabled: !editable || !running, onClick: () => send("pause"), children: t.pause }), _jsx(Button, { type: "button", variant: "outline", disabled: !canResume, onClick: () => send("resume"), children: t.resume }), onRefresh && (_jsx(Button, { type: "button", variant: "ghost", onClick: onRefresh, children: t.refresh }))] }), _jsxs("form", { className: "space-y-3", onSubmit: (event) => {
+                            event.preventDefault();
+                            send("steer");
+                        }, children: [_jsx(Field, { label: t.steering, hint: t.steeringHint, error: draft.length > 0 && !valid ? t.invalidSteering : undefined, children: _jsx(Textarea, { value: draft, readOnly: !editable || !running || !onDraftChange, onChange: (event) => onDraftChange?.(event.target.value) }) }), _jsx(Button, { type: "submit", disabled: !editable || !running || !valid || !onDraftChange, children: t.send })] })] }))] }));
+}

package/dist/workflow/runtime-controls.d.ts

@@ -0,0 +1,29 @@
+/** Confirmed host projection; submitting intent never changes these states locally. */
+export type WorkflowRuntimeState = "running" | "paused" | "pause-requested" | "resume-requested" | "steering-queued" | "steering-applied" | "refused" | "delivery-unknown" | "unavailable" | "finished";
+export interface WorkflowRuntimeBinding {
+    taskId: string;
+    invocationId: string;
+    sessionId: string;
+    revision: string;
+    checksum: string;
+}
+export interface WorkflowPauseReceipt {
+    sessionId: string;
+    requestId: string;
+    revision: string;
+    checksum: string;
+    kind: "paused";
+}
+export type WorkflowRuntimeIntent = {
+    operation: "pause";
+    binding: WorkflowRuntimeBinding;
+} | {
+    operation: "resume";
+    binding: WorkflowRuntimeBinding;
+    pausedReceipt: WorkflowPauseReceipt;
+} | {
+    operation: "steer";
+    binding: WorkflowRuntimeBinding;
+    text: string;
+};
+export declare function validWorkflowSteering(text: string): boolean;

package/dist/workflow/runtime-controls.js

@@ -0,0 +1,10 @@
+export function validWorkflowSteering(text) {
+    const characters = Array.from(text);
+    return (text.trim().length > 0 &&
+        characters.length <= 4000 &&
+        !text.includes("\0") &&
+        characters.every((c) => {
+            const code = c.codePointAt(0);
+            return code < 0xd800 || code > 0xdfff;
+        }));
+}