@marketrix.ai/widget 4.0.135 → 4.0.137

package/dist/src/components/views/ChatView.d.ts

@@ -6,7 +6,11 @@
  * shell's toolbar button fills with a share toggle, and the composer textarea ref. `MODES` pairs the
  * mode chips' display order with the tenant setting enabling each, so the composer offers only what
  * the workspace turned on. `ChatView` owns the draft text; `handleSendMessage` posts the turn and
- * `handleModeChange` announces a mode switch in the transcript before flipping state.
+ * `handleModeChange` announces a mode switch in the transcript before flipping state. A POST failure
+ * restores the composed text to the (now-cleared) composer — `messageDispatch`'s resolved `false` —
+ * unless the visitor already started typing a new message in the meantime, so a resend is one tap on
+ * Send rather than a retype, and the failed turn's own bubble (added optimistically, unconditionally)
+ * still shows what was said either way.
  *
  * The composer is locked both while a reply is outstanding and while a screen-access request is open,
  * since a second turn queued behind an unanswered permission card has nowhere to land. `use_screenshare`

package/dist/src/context/ChatContext.d.ts

@@ -8,15 +8,30 @@
  * defers updaters and loses the effects captured in them, so tool calls never execute. `messageDispatch`
  * POSTs fire-and-forget: the reply arrives over SSE, so only a POST failure resolves the placeholder
  * locally, and a stale-reply watchdog keyed on id AND part count re-arms on every progress line.
+ * `messageDispatch` resolves `false` on that same POST failure (`true` otherwise, including preview
+ * mode) so a caller holding the composed text — `ChatView`'s composer — can restore it instead of the
+ * visitor having to retype a message the widget already dropped from the input box.
  *
  * The stream effect subscribes to the `StreamClient` singleton: `handleMessage` does the bookkeeping the
- * pure reducer cannot hold (`tool_call_id` dedupe in a bounded set, cleared on a terminal status), then
- * each effect runs its browser tool, stamps progress, replies `tool/response` and only then fires
- * `afterResponseAttempt`. `handleError` converts only a `StreamGaveUpError` into a transport failure, as a
- * retriable blip settles when the reply lands on the reconnected stream. `stopTask` sends `chat/stop`,
- * which carries no task id. Every failure on the tool and stop paths reaches `uiActions.setError` as well
- * as the console: an undelivered `tool/response` leaves the agent waiting on a reply that never comes, so
- * the run stalls with nothing on screen unless the visitor is told, and `do` mode may still be clicking.
+ * pure reducer cannot hold (`tool_call_id` dedupe in a bounded set, cleared on a terminal status; the
+ * mirror-shaped `respondedRequestIds` below), then each effect runs its browser tool, stamps progress,
+ * replies `tool/response` and only then fires `afterResponseAttempt`. `handleError` converts only a
+ * `StreamGaveUpError` into a transport failure, as a retriable blip settles when the reply lands on the
+ * reconnected stream. `stopTask` sends `chat/stop`, which carries no task id. Every failure on the tool
+ * and stop paths reaches `uiActions.setError` as well as the console: an undelivered `tool/response`
+ * leaves the agent waiting on a reply that never comes, so the run stalls with nothing on screen unless
+ * the visitor is told, and `do` mode may still be clicking.
+ *
+ * `respondedRequestIds` closes the other half of the reconnect-replay contract `StreamClient.ts`
+ * documents (the api replays a chat_id's whole turn history, not just the tail a client missed):
+ * `reduceText`'s own exact-repeat guard (`sseReducer.ts`) only catches an identical FINAL
+ * `chat/response` replayed after the answer already closed, because it only ever compares against the
+ * message's LAST part. A replayed `chat/delta` fails that same-string check (it's a partial fragment,
+ * not the full closed text) and would otherwise be appended as a brand-new, visibly duplicated text
+ * segment ahead of the closing response that then only overwrites the one it just added — leaving two
+ * copies of the same answer on screen. Scoped by `request_id`, not globally, so an unrelated later
+ * turn's genuinely new `chat/delta`/`chat/response` is untouched; marked closed only once, on the
+ * request's own terminal `chat/response`, since a delta is by definition still open.
  *
  * `lastStreamErrorRef`/`currentErrorRef` close the loop `handleError` alone leaves open: `StreamClient`
  * calls `onError` on every failed dial, not only a terminal give-up, so the visitor sees "Stream
@@ -43,7 +58,7 @@ interface ChatActions {
     removeMessage: (messageId: string) => void;
     setMessages: (messages: ChatMessage[]) => void;
     clearMessages: () => void;
-    messageDispatch: (content: string, mode?: InstructionType, skipUserMessage?: boolean) => Promise<void>;
+    messageDispatch: (content: string, mode?: InstructionType, skipUserMessage?: boolean) => Promise<boolean>;
 }
 interface TaskActions {
     resetTask: () => void;

package/dist/src/hooks/useWidget.d.ts

@@ -21,7 +21,7 @@ export declare const useWidget: () => {
         removeMessage: (messageId: string) => void;
         setMessages: (messages: import("..").ChatMessage[]) => void;
         clearMessages: () => void;
-        messageDispatch: (content: string, mode?: import("..").InstructionType, skipUserMessage?: boolean) => Promise<void>;
+        messageDispatch: (content: string, mode?: import("..").InstructionType, skipUserMessage?: boolean) => Promise<boolean>;
         resetTask: () => void;
         stopTask: () => Promise<void>;
         setActiveView: (view: import("../types").WidgetView) => void;

package/dist/src/sdk/contracts/activityLogMetadata.d.ts

@@ -1,15 +1,8 @@
 /**
- * `ActivityMetadataByType` — the strict, per-`ActivityLogType` shape of `activity_log.metadata`, the
- * one write-time gate `models/columnSchemas.ts` registers against the column. Moved out of that file
- * so `contracts/entities.ts` can import it to type `ActivityLogEntitySchema.metadata` precisely
- * (a union of every branch) instead of the open `.passthrough()` it carried before — deriving from a
- * registry that lived inside `models/columnSchemas.ts`, which itself imports from `entities.ts`,
- * would have cycled.
+ * The strict shape of an activity log row's `metadata` column, one schema per activity type.
  *
- * `slack_command`'s `status` imports `SlackCommandLogStatusSchema` from `./activityLogVocabulary` —
- * the one home `tests/unit/contractEnumHomes.test.ts` requires for that value set — a dependency-free
- * leaf, so this registry (and everything importing it through `entities.ts`) never pulls in
- * `contracts/slack.ts`'s `@orpc/contract` import.
+ * `ActivityMetadataByType` maps each `ActivityLogType` to its metadata shape; `contracts/entities.ts`
+ * and `models/columnSchemas.ts` both read it, which is why it lives in its own file rather than either.
  */
 import { z } from 'zod';
 export declare const ActivityMetadataByType: {

package/dist/src/sdk/contracts/activityLogVocabulary.d.ts

@@ -1,15 +1,7 @@
 /**
- * The four closed vocabularies an activity-log row's shape is keyed on — `type` (what happened),
- * the two enums that ride INSIDE some per-type metadata shapes (`ApplicationTypeSchema`,
- * `WidgetTypeSchema`), and `SlackCommandLogStatusSchema` (the `slack_command` metadata's `status`,
- * and `contracts/slack.ts`'s command-log entity status — one home per `tests/unit/contractEnumHomes.test.ts`).
- * Split out of `contracts/entities.ts` into this dependency-free leaf — no `@orpc/contract` import —
- * so `contracts/activityLogMetadata.ts`'s per-type registry can import them without cycling back
- * through `entities.ts`, which needs the registry to type `ActivityLogEntitySchema.metadata`
- * precisely instead of `.passthrough()`, and so an audience that never touches oRPC contract routes
- * (the internal/monitor mirror) doesn't pull `@orpc/contract` in through the metadata registry.
- * `entities.ts` re-exports the first three (unchanged); `SlackCommandLogStatusSchema` is new here and
- * has no `entities.ts` re-export since nothing imported it from there before.
+ * Closed vocabularies used across activity log rows: application and widget types, every activity
+ * `type` value, and Slack command log status. Kept dependency-free so other contract files can use
+ * them without pulling in unrelated imports.
  */
 import { z } from 'zod';
 export declare const ApplicationTypeSchema: z.ZodEnum<{

package/dist/src/sdk/contracts/common.d.ts

@@ -1,31 +1,10 @@
 /**
- * Cross-domain wire primitives shared by every audience — this file is mirrored WHOLE into the widget
- * closure, so any shape it exports republishes the widget SDK regardless of which audience actually
- * reads it.
- * - `unionOfRecord` builds a plain (non-discriminated) union of every variant in a
- *   `{ <discriminant value>: ZodType }` map — the shape `TriggerSourceConfigSchemas`/
- *   `WorkflowActionTargetConfigSchemas` are declared in, and the registry (`models/columnSchemas.ts`)
- *   keys by the same discriminant separately. Typed off the map's own value type rather than a bare
- *   `z.ZodType`, whose inferred output is `unknown` and would erase every variant's real shape from the
- *   union.
- * - `ToolCallRecordSchema.params`/`.result` stay `z.record(z.string(), z.unknown())` ON PURPOSE —
- *   `models/columnSchemas.ts`'s header lists a tool call's own arguments and result as one of the few
- *   open boundaries kept opaque deliberately, since a tool's shape varies per tool name with no closed
- *   vocabulary this file (or the widget/app readers of `simulation_step.tool_calls`) can type against.
- * - `SessionStateSchema` is `simulation.session_state` (Browserbase cookies + localStorage snapshot).
- *   Lives here rather than `models/columnSchemas.ts`, which imports FROM
- *   `contracts/foundationEntities.ts` — a leaf-shaped schema this file already is one, so
- *   `contracts/foundationEntities.ts` can type `SimulationEntitySchema`'s own `session_state` field
- *   with it without cycling back through `columnSchemas.ts`. Its `cookies` field is the other
- *   deliberately-open boundary from that same registry header: a browser cookie as the browser itself
- *   reports it, no closed shape to narrow to.
- * - `GraphNodeSummarySchema` is the whole-graph tier — `applicationGraphGet`/`simulationGraphGet` load
- *   nodes with `readGraph`, which always resolves sections to `[]` for speed; a node's real sections
- *   are a lazy drill-in fetched one at a time by `graphNodeSectionsGet` (its own
- *   `GraphSectionSchema`-shaped output), so this tier never carries them. `sequence_ids` is DROPPED
- *   (not just unselected) — the stored `graph.graph_nodes` column stays for the agent's own write-side
- *   dedupe, but no app/widget graph or heatmap component ever read the wire field, and this file's
- *   widget-closure membership means dropping it republishes the widget.
+ * Wire primitives shared across every domain: id/pagination shapes, tool call and browser session
+ * state, and the application knowledge graph.
+ *
+ * Exports helpers like `paginatedListOf`/`unionOfRecord`, the id and pagination input schemas, and the
+ * graph and session-state entity schemas. This file mirrors whole into the widget SDK, so any shape
+ * added here reaches the widget even if nothing else changes.
  */
 import { z } from 'zod';
 export declare const EntityStatusSchema: z.ZodEnum<{

package/dist/src/sdk/contracts/entities.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Entity schemas for users, workspaces, applications, widgets and activity log rows — the shapes most
+ * other contracts build on.
+ *
+ * Exports the full entity schema and a narrower read/summary variant for each, plus the activity log's
+ * per-type metadata union. `ApplicationEntitySchema`'s `skill_distillation_status`/`_error` track the
+ * last skill-distillation attempt for that application, since a distilled skill is written directly with
+ * no separate draft row. `ApplicationReadSchema` never returns `password`; `WidgetPublicSchema` never
+ * returns the widget's own auth credentials, since an unauthenticated visitor's browser is the caller.
+ */
 import { z } from 'zod';
 import { type ActivityLogType, ActivityLogTypeSchema, type ApplicationType, ApplicationTypeSchema, type WidgetType, WidgetTypeSchema } from './activityLogVocabulary';
 export { ActivityLogTypeSchema, ApplicationTypeSchema, WidgetTypeSchema };
@@ -9,7 +19,6 @@ export declare const WorkspacePackageSchema: z.ZodEnum<{
     enterprise: "enterprise";
 }>;
 export type PlanTier = z.infer<typeof WorkspacePackageSchema>;
-/** The plan a Billing Cycle was opened on. `legacy_unknown` is pre-ledger history, which no plan sells. */
 export declare const PlanSnapshotSchema: z.ZodEnum<{
     free: "free";
     startup: "startup";
@@ -36,11 +45,6 @@ export declare const InstructionTypeSchema: z.ZodEnum<{
     do: "do";
 }>;
 export type InstructionType = z.infer<typeof InstructionTypeSchema>;
-/**
- * The workspace role vocabulary — `admin` administers, `member` does not. One spelling everywhere:
- * DB enum, this contract, the dashboard, and the WorkOS role slug. Declared here (not `workspace.ts`)
- * because `UserEntitySchema` needs it and `workspace.ts` already imports from this file.
- */
 export declare const WorkspaceMemberRoleSchema: z.ZodEnum<{
     admin: "admin";
     member: "member";
@@ -135,6 +139,12 @@ export declare const WorkspaceSummarySchema: z.ZodObject<{
     notify_all_members_on_question: z.ZodBoolean;
 }, z.core.$strip>;
 export type WorkspaceSummary = z.infer<typeof WorkspaceSummarySchema>;
+export declare const ApplicationSkillDistillationStatusSchema: z.ZodEnum<{
+    failed: "failed";
+    idle: "idle";
+    pending: "pending";
+}>;
+export type ApplicationSkillDistillationStatus = z.infer<typeof ApplicationSkillDistillationStatusSchema>;
 export declare const ApplicationEntitySchema: z.ZodObject<{
     id: z.ZodNumber;
     created_at: z.ZodCoercedDate<unknown>;
@@ -150,9 +160,14 @@ export declare const ApplicationEntitySchema: z.ZodObject<{
     username: z.ZodNullable<z.ZodString>;
     password: z.ZodNullable<z.ZodString>;
     allowed_domains: z.ZodArray<z.ZodString>;
+    skill_distillation_status: z.ZodEnum<{
+        failed: "failed";
+        idle: "idle";
+        pending: "pending";
+    }>;
+    skill_distillation_error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type ApplicationData = z.infer<typeof ApplicationEntitySchema>;
-/** Used for all API responses; password is write-only and never returned to clients. */
 export declare const ApplicationReadSchema: z.ZodObject<{
     id: z.ZodNumber;
     created_at: z.ZodCoercedDate<unknown>;
@@ -167,6 +182,12 @@ export declare const ApplicationReadSchema: z.ZodObject<{
     workspace_id: z.ZodNumber;
     username: z.ZodNullable<z.ZodString>;
     allowed_domains: z.ZodArray<z.ZodString>;
+    skill_distillation_status: z.ZodEnum<{
+        failed: "failed";
+        idle: "idle";
+        pending: "pending";
+    }>;
+    skill_distillation_error: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
 export type ApplicationReadData = z.infer<typeof ApplicationReadSchema>;
 export declare const WidgetChipSchema: z.ZodObject<{

package/dist/src/sdk/contracts/widget.d.ts

@@ -1,3 +1,11 @@
+/**
+ * The support widget: its settings, its public boot lookup, and the SSE event/command vocabulary that
+ * drives a live chat session.
+ *
+ * Exports the widget entity and create/update schemas, `WidgetEventSchema`/`WidgetCommandSchema`, and
+ * every widget CRUD and streaming procedure. `widgetPublicSearch` is the widget's own credentialed boot
+ * call and never returns the credentials that authenticated it.
+ */
 import { z } from 'zod';
 export declare const WidgetCreateSchema: z.ZodObject<{
     status: z.ZodOptional<z.ZodEnum<{
@@ -101,7 +109,6 @@ export declare const WidgetUpdateSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WidgetUpdateData = z.infer<typeof WidgetUpdateSchema>;
-/** Server → Widget events. */
 export declare const WidgetEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"registered">;
     chat_id: z.ZodString;
@@ -141,7 +148,6 @@ export declare const WidgetEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     explanation: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">;
 export type WidgetEvent = z.infer<typeof WidgetEventSchema>;
-/** Widget → Server commands. */
 export declare const WidgetCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"chat/tell">;
     request_id: z.ZodString;

package/dist/src/services/StorageService.d.ts

@@ -5,7 +5,12 @@
  * browser-local key shares via `scopedKey`, so the chat-context, drag-position and resize keys all
  * partition by tenant identically. `readLocal`/`writeLocal` are the only `localStorage` access in `src/`;
  * a host page can deny storage outright (third-party cookies off, sandboxed iframe), so both degrade to
- * a warn and the widget keeps working unpersisted.
+ * memory and the widget keeps working unpersisted. `updateContext` calls `writeLocal` on every UI-state
+ * change (a drag, a resize, every chat message), so without `warnOnce` a denied host page would spam one
+ * console line per write for the visitor's whole session; a single warn on first denial says everything
+ * a customer's console needs. `warnOnce` is keyed by read vs. write since `readLocal` also fires once on
+ * its own (`loadContext` at module init, before any write) and both should still surface if a page
+ * somehow denies one and not the other.
  *
  * `loadContext` merges one parsed key over `DEFAULT_CONTEXT`, so an older widget version's payload reads
  * as incomplete rather than corrupt, and discards anything past `CONTEXT_EXPIRY_MS` (7 days).
@@ -55,6 +60,10 @@ type MarketrixChatContext = Omit<ChatSnapshot, 'messages'> & {
 };
 export declare function tenantScope(config: MarketrixConfig): string;
 export declare function scopedKey(name: string, config: MarketrixConfig): string;
+/** Test-only: `warned` is module-level so a "denies storage, keeps working" proof isn't the last test in
+ * the file to touch a denied `Storage.prototype`, and a later test in the same `bun test` process (one
+ * process per file, not per test) would otherwise see zero warns instead of one. Never called from `src/`. */
+export declare function resetStorageWarningsForTests(): void;
 export declare function readLocal(key: string): string | null;
 export declare function writeLocal(key: string, value: string): void;
 declare class StorageService {

package/dist/src/services/StreamClient.d.ts

@@ -6,7 +6,10 @@
  *
  * `open` is the transport, `registered` is the chat: only the latter can carry a reply, so `isConnected` reads
  * `registered` and nothing waits on `open`. Backoff counters reset only on `registered` — resetting at `open` would
- * defeat the max-attempts cap if registration never lands and the stream flaps open→closed. Tabs share the
+ * defeat the max-attempts cap if registration never lands and the stream flaps open→closed. `scheduleReconnect`'s
+ * EQUAL JITTER (the doubling delay's own second half, chosen uniformly) keeps every dial within the documented
+ * schedule's bound while stopping every tab across every open customer page from redialing on the exact same
+ * clock tick after a shared outage — a thundering herd the deterministic schedule alone cannot prevent. Tabs share the
  * localStorage chat id, so the server keys SSE by (chat_id, tab_id) and `tabId` stops tabs evicting each other's
  * stream. Credentials are read at connect time, not captured at init, so a reconnect after `updateMarketrixConfig`
  * dials with the current ones.