@marketrix.ai/widget 4.0.136 → 4.0.137

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";
@@ -164,7 +168,6 @@ export declare const ApplicationEntitySchema: z.ZodObject<{
     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>;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marketrix.ai/widget",
-  "version": "4.0.136",
+  "version": "4.0.137",
   "type": "module",
   "packageManager": "bun@1.4.2",
   "sideEffects": false,