@whitewall/blip-sdk 0.0.192 → 0.0.193

package/src/utils/minifier.ts

@@ -11,17 +11,19 @@ import {
     actionTypeSchema,
     baseActionSchema,
     type CONTENT_TYPES,
+    CUSTOM_ACTION_LISTS,
     conditionOutputSchema,
     defaultOutputSchema,
     type Flow,
     type InputState,
     inputStateSchema,
+    isChatStateSendMessage,
     type MIME_TYPES,
     ROOT_STATE_ID,
     type State,
     stateSchema,
 } from '../types/flow.ts'
-import { isChatStateSendMessage } from './builder.ts'
+import { checkFlow } from './flow-rules.ts'
 
 /**
  * Everything `minifyFlow` removes, grouped by where it lives. Together these
@@ -35,19 +37,12 @@ const STATE_NOISE = [
     '$invalidCustomActions',
     '$invalid',
     'id',
-    'root',
     '$tags',
     '$inputSuggestions',
     'isAiGenerated',
     'deskStateVersion',
 ] as const
 
-const CUSTOM_ACTION_LISTS = [
-    '$enteringCustomActions',
-    '$leavingCustomActions',
-    '$afterStateChangedActions',
-    '$localCustomActions',
-] as const
 const CUSTOM_ACTION_NOISE = ['$id', '$title', '$invalid', '$typeOfContent'] as const
 
 const CONTENT_ACTION_ITEM_NOISE = ['$invalid'] as const
@@ -144,32 +139,7 @@ function stripAngularKeys(target: unknown): void {
     }
 }
 
-const minifiedActionSchema = z.intersection(baseActionSchema.partial({ $id: true }), actionTypeSchema).check((ctx) => {
-    // expandMinifiedFlow derives $typeOfContent from the settings mime type, so
-    // a SendMessage without one cannot be pushed. Rejecting it here keeps
-    // validation and push in agreement instead of failing halfway through.
-    const action = ctx.value
-    if (action.type === 'SendMessage' && !action.settings.type) {
-        ctx.issues.push({
-            code: 'custom',
-            input: action,
-            path: ['settings', 'type'],
-            message: 'A SendMessage action requires a settings.type',
-        })
-    }
-
-    // The runtime deserializes the raw content as this media type and refuses to
-    // run the action without one, so a hand-written raw message that omits it
-    // would be accepted here and then fail in the conversation.
-    if (action.type === 'SendRawMessage' && !action.settings.type) {
-        ctx.issues.push({
-            code: 'custom',
-            input: action,
-            path: ['settings', 'type'],
-            message: 'A SendRawMessage action requires a settings.type',
-        })
-    }
-})
+const minifiedActionSchema = z.intersection(baseActionSchema.partial({ $id: true }), actionTypeSchema)
 
 const minifiedInputSchema = inputStateSchema.partial({ $cardContent: true, $invalid: true }).strict()
 
@@ -205,50 +175,22 @@ export const minifiedStateSchema = stateSchema
     .strict()
 
 /**
- * A push replaces the whole flow, so a dangling output and a title collision are
- * validation errors here instead of a broken canvas later.
+ * A push replaces the whole flow, so everything that decides whether the runtime
+ * loads it — the entry point, the outputs, the loops, every condition and every
+ * action — is a validation error here instead of a bot that does not start.
+ *
+ * The rules run from this one check, and never per state or per action: zod skips
+ * a check on a value that already has issues, so nesting them would report the
+ * innermost problem and hide the rest of the flow's.
  */
 export const minifiedFlowSchema = z.record(z.string(), minifiedStateSchema).check((ctx) => {
-    const titles = new Map<string, string>()
-
-    const checkOutput = (output: { stateId: string; typeOfStateId?: string }, path: Array<string | number>) => {
-        // A variable output is only resolved at runtime.
-        if (output.typeOfStateId === 'variable' || output.stateId in ctx.value) {
-            return
-        }
-
-        ctx.issues.push({
-            code: 'custom',
-            input: output.stateId,
-            path: [...path, 'stateId'],
-            message: `Output points at '${output.stateId}', which is not a state in this flow`,
-        })
-    }
-
-    for (const [stateId, state] of Object.entries(ctx.value)) {
-        // The builder addresses a state by its title, so a duplicate hides one.
-        const title = state.$title.toLowerCase()
-        const duplicate = titles.get(title)
-
-        if (duplicate) {
-            ctx.issues.push({
-                code: 'custom',
-                input: state.$title,
-                path: [stateId, '$title'],
-                message: `Duplicate state title '${state.$title}', already used by '${duplicate}'`,
-            })
-        } else {
-            titles.set(title, stateId)
-        }
-
-        checkOutput(state.$defaultOutput, [stateId, '$defaultOutput'])
-
-        for (const [index, output] of state.$conditionOutputs.entries()) {
-            checkOutput(output, [stateId, '$conditionOutputs', index])
-        }
-    }
+    checkFlow(ctx.value, (rule, path, message) => {
+        ctx.issues.push({ code: 'custom', input: ctx.value, path, message, params: { rule } })
+    })
 })
 
+export type MinifiedAction = z.infer<typeof minifiedActionSchema>
+export type MinifiedInput = z.infer<typeof minifiedInputSchema>
 export type MinifiedState = z.infer<typeof minifiedStateSchema>
 export type MinifiedFlow = z.infer<typeof minifiedFlowSchema>
 
@@ -271,10 +213,14 @@ export function minifyFlow(flow: Flow): MinifiedFlow {
         stripAngularKeys(minifiedState)
         stripKeys(minifiedState.$defaultOutput, DEFAULT_OUTPUT_NOISE)
 
-        // Expansion writes `false` here for a state that has no plugin, so only a
-        // real configuration is worth carrying.
+        // Only the state that is the entry point, and only a plugin that is really
+        // configured, are worth carrying: expansion writes `false` on all the others.
+        if (!minifiedState.root) {
+            delete minifiedState.root
+        }
+
         if (!minifiedState.$whiteWallIntegration) {
-            stripKeys(minifiedState, ['$whiteWallIntegration'])
+            delete minifiedState.$whiteWallIntegration
         }
 
         for (const output of minifiedState.$conditionOutputs ?? []) {
@@ -307,6 +253,9 @@ export function minifyFlow(flow: Flow): MinifiedFlow {
 
 export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow): Flow {
     const flow: Flow = {}
+    // All or nothing: mixing the flow's own entry point with the builder's would
+    // leave two states marked as root, which the runtime refuses.
+    const declaresRoot = Object.values(minifiedFlow).some((state) => state.root)
 
     for (const [stateId, minifiedState] of Object.entries(minifiedFlow)) {
         try {
@@ -318,10 +267,16 @@ export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow)
             state.$invalidCustomActions = false
             state.$invalid = false
             state.id = stateId
-            // When the builder already knows the state, its answer wins; a state
-            // being pushed for the first time falls back to the id convention, so
-            // a flow pushed without a stale one still gets an entry point.
-            state.root = staleState ? staleState.root : stateId === ROOT_STATE_ID || undefined
+            // The entry point is carried by the flow, because `Flow.Validate`
+            // asserts on the flag and nothing else can express "this state, not the
+            // one named `onboarding`". A flow that predates it falls back to what
+            // the builder already knows, then to the id convention, so a first push
+            // still gets an entry point either way.
+            state.root = declaresRoot
+                ? Boolean(minifiedState.root)
+                : staleState
+                  ? staleState.root
+                  : stateId === ROOT_STATE_ID || undefined
             state.$tags = staleState?.$tags ?? []
             state.$inputSuggestions = staleState?.$inputSuggestions ?? []
             state.isAiGenerated = staleState?.isAiGenerated ?? false
@@ -330,7 +285,7 @@ export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow)
             // keeps a plugin configured before this was carried through.
             state.$whiteWallIntegration =
                 minifiedState.$whiteWallIntegration ?? staleState?.$whiteWallIntegration ?? false
-            state.deskStateVersion = staleState?.deskStateVersion ?? undefined
+            state.deskStateVersion = staleState?.deskStateVersion
             state.$defaultOutput.$invalid = false
 
             // Reuse the ids the builder already knows so the canvas keeps its
@@ -342,11 +297,11 @@ export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow)
 
                 conditionOutput.$id = staleConditionOutput?.$id ?? crypto.randomUUID()
                 conditionOutput.$invalid = false
-                conditionOutput.$connId = staleConditionOutput?.$connId ?? undefined
-                conditionOutput.$isDeskOutput = staleConditionOutput?.$isDeskOutput ?? undefined
-                conditionOutput.$isDeskCustomOutput = staleConditionOutput?.$isDeskCustomOutput ?? undefined
-                conditionOutput.$isDeskDefaultOutput = staleConditionOutput?.$isDeskDefaultOutput ?? undefined
-                conditionOutput.$contentId = staleConditionOutput?.$contentId ?? undefined
+                conditionOutput.$connId = staleConditionOutput?.$connId
+                conditionOutput.$isDeskOutput = staleConditionOutput?.$isDeskOutput
+                conditionOutput.$isDeskCustomOutput = staleConditionOutput?.$isDeskCustomOutput
+                conditionOutput.$isDeskDefaultOutput = staleConditionOutput?.$isDeskDefaultOutput
+                conditionOutput.$contentId = staleConditionOutput?.$contentId
             }
 
             for (const actionType of CUSTOM_ACTION_LISTS) {
@@ -358,7 +313,7 @@ export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow)
                     action.$id = staleAction?.$id ?? crypto.randomUUID()
                     action.$invalid = false
                     action.$title = staleAction?.$title ?? createActionTitle(action)
-                    action.$typeOfContent = staleAction?.$typeOfContent ?? undefined
+                    action.$typeOfContent = staleAction?.$typeOfContent
                 }
             }
 
@@ -416,13 +371,9 @@ export function expandMinifiedFlow(minifiedFlow: MinifiedFlow, staleFlow?: Flow)
                 }
             }
 
-            // Walk backwards so the chat states can be spliced in without shifting
-            // the indexes still to be visited.
-            for (let index = (state.$contentActions ?? []).length - 1; index >= 0; index--) {
-                if (state.$contentActions[index].action) {
-                    state.$contentActions.splice(index, 0, createChatStateContentAction())
-                }
-            }
+            state.$contentActions = (state.$contentActions ?? []).flatMap((item) =>
+                item.action ? [createChatStateContentAction(), item] : [item],
+            )
 
             flow[stateId] = state
         } catch (err) {