@requence/task 0.8.2-edge.1154 → 0.8.2-edge.1155

package/build/types/helpers/src/protocol/command.d.ts

@@ -58,7 +58,7 @@ export declare function createCommandSchemaWith(parseTreeList: (treeList: InputT
         references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strip>;
-    input: z.ZodAny;
+    input: z.ZodOptional<z.ZodAny>;
     options: z.ZodObject<{
         maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         mode: z.ZodDefault<z.ZodEnum<{
@@ -83,7 +83,7 @@ export declare function createCommandSchemaWith(parseTreeList: (treeList: InputT
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "CREATE";
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -393,7 +393,7 @@ export declare function createCommandSchemaWith(parseTreeList: (treeList: InputT
         references?: any[] | undefined;
         schemas?: Record<string, any> | undefined;
     };
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -437,7 +437,7 @@ export declare function createCommandSchemaWithAsync(parseTreeList: (treeList: I
         references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strip>;
-    input: z.ZodAny;
+    input: z.ZodOptional<z.ZodAny>;
     options: z.ZodObject<{
         maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         mode: z.ZodDefault<z.ZodEnum<{
@@ -462,7 +462,7 @@ export declare function createCommandSchemaWithAsync(parseTreeList: (treeList: I
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "CREATE";
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -772,7 +772,7 @@ export declare function createCommandSchemaWithAsync(parseTreeList: (treeList: I
         references?: any[] | undefined;
         schemas?: Record<string, any> | undefined;
     };
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -803,7 +803,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
         references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strip>;
-    input: z.ZodAny;
+    input: z.ZodOptional<z.ZodAny>;
     options: z.ZodObject<{
         maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         mode: z.ZodDefault<z.ZodEnum<{
@@ -828,7 +828,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "CREATE";
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -1138,7 +1138,7 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
         references?: any[] | undefined;
         schemas?: Record<string, any> | undefined;
     };
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -1160,6 +1160,49 @@ export declare const createCommandSchema: z.ZodPipe<z.ZodObject<{
     };
 }>>;
 export type CreateCommand = z.infer<typeof createCommandSchema>;
+/**
+ * A viewer drove a service-provided surface (#104).
+ *
+ * A command rather than a result, because there is no service process behind a
+ * click: ui/backend holds no capability of the service's, opens no connection on
+ * its behalf and composes no service-protocol message — it forwards *which
+ * handler, with what*, and the operator publishes the invocation. It travels the
+ * one channel ui/backend already has to the operator, so it hashes onto the
+ * task's own shard and cannot overtake or be overtaken by that task's other
+ * commands (knowledge/task-sharding.md).
+ *
+ * `nodeId` — not a message id — is what names the service the handler belongs
+ * to. The pair `(name, version)` is read off the node, and the node is the only
+ * one of the two that a **durable** handler can still be resolved through: it
+ * outlives the message that published the render, which is the whole point of
+ * being durable.
+ *
+ * The handler reference travels verbatim, exactly as the render carried it out
+ * (#103): its `lifetime` is what decides whether the operator publishes to the
+ * version's handler queue or to one connection's backchannel, and the browser
+ * never sees either — it names a props path, and ui/backend resolves it against
+ * what it stored.
+ */
+export declare const invokeSurfaceHandlerCommandSchema: z.ZodObject<{
+    type: z.ZodLiteral<"INVOKE_SURFACE_HANDLER">;
+    nodeId: z.ZodUUID;
+    surface: z.ZodUUID;
+    handler: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        __REQUENCE_type: z.ZodLiteral<"RequenceHandler">;
+        lifetime: z.ZodLiteral<"durable">;
+        uiId: z.ZodString;
+        path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        __REQUENCE_type: z.ZodLiteral<"RequenceHandler">;
+        lifetime: z.ZodLiteral<"connection">;
+        uiId: z.ZodString;
+        path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+        connectionId: z.ZodString;
+        handlerId: z.ZodUUID;
+    }, z.core.$strip>], "lifetime">;
+    arg: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type InvokeSurfaceHandlerCommand = z.infer<typeof invokeSurfaceHandlerCommandSchema>;
 export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
     type: z.ZodLiteral<"ABORT">;
     reason: z.ZodOptional<z.ZodString>;
@@ -1175,7 +1218,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
         references: z.ZodOptional<z.ZodArray<z.ZodAny>>;
         schemas: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     }, z.core.$strip>;
-    input: z.ZodAny;
+    input: z.ZodOptional<z.ZodAny>;
     options: z.ZodObject<{
         maxExecutions: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         mode: z.ZodDefault<z.ZodEnum<{
@@ -1200,7 +1243,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodTransform<{
     type: "CREATE";
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -1510,7 +1553,7 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
         references?: any[] | undefined;
         schemas?: Record<string, any> | undefined;
     };
-    input: any;
+    input?: any;
     options: {
         maxExecutions: number;
         mode: "CONTINUOUS" | "LINEAR";
@@ -1530,7 +1573,25 @@ export declare const commandSchema: z.ZodUnion<readonly [z.ZodObject<{
             epoch?: string | undefined;
         } | undefined;
     };
-}>>]>;
+}>>, z.ZodObject<{
+    type: z.ZodLiteral<"INVOKE_SURFACE_HANDLER">;
+    nodeId: z.ZodUUID;
+    surface: z.ZodUUID;
+    handler: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        __REQUENCE_type: z.ZodLiteral<"RequenceHandler">;
+        lifetime: z.ZodLiteral<"durable">;
+        uiId: z.ZodString;
+        path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    }, z.core.$strip>, z.ZodObject<{
+        __REQUENCE_type: z.ZodLiteral<"RequenceHandler">;
+        lifetime: z.ZodLiteral<"connection">;
+        uiId: z.ZodString;
+        path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+        connectionId: z.ZodString;
+        handlerId: z.ZodUUID;
+    }, z.core.$strip>], "lifetime">;
+    arg: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>]>;
 export type Command = z.infer<typeof commandSchema>;
 export type CommandInput = z.input<typeof commandSchema>;
 //# sourceMappingURL=command.d.ts.map

package/build/types/helpers/src/protocol/command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/command.ts"],"names":[],"mappings":"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"}

package/build/types/helpers/src/protocol/update.d.ts

@@ -90,7 +90,7 @@ declare const nodeUpdateSchema: z.ZodObject<{
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_UPDATE">;
     output: z.ZodNullable<z.ZodString>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
     overwrite: z.ZodBoolean;
 }, z.core.$strip>;
 export type NodeUpdate = z.infer<typeof nodeUpdateSchema>;
@@ -122,7 +122,7 @@ declare const nodeCallbackSchema: z.ZodObject<{
     }, z.core.$strip>;
     propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     output: z.ZodNullable<z.ZodString>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type NodeCallback = z.infer<typeof nodeCallbackSchema>;
 declare const nodeEndUpdateSchema: z.ZodObject<{
@@ -166,9 +166,72 @@ declare const nodeDebugUpdateSchema: z.ZodObject<{
         system: "system";
         warn: "warn";
     }>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type NodeDebugUpdate = z.infer<typeof nodeDebugUpdateSchema>;
+declare const nodeRenderUpdateSchema: z.ZodObject<{
+    component: z.ZodObject<{
+        id: z.ZodString;
+        hash: z.ZodString;
+        source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    props: z.ZodUnknown;
+    defaults: z.ZodOptional<z.ZodUnknown>;
+    surfaceId: z.ZodString;
+    devSession: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+            service: "service";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_RENDER">;
+    messageId: z.ZodUUID;
+    connectionId: z.ZodUUID;
+    ownTraceId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    handlerQueue: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type NodeRenderUpdate = z.infer<typeof nodeRenderUpdateSchema>;
+declare const surfaceDeadUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"SURFACE_DEAD">;
+    messageId: z.ZodUUID;
+    connectionId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+}, z.core.$strip>;
+export type SurfaceDeadUpdate = z.infer<typeof surfaceDeadUpdateSchema>;
+declare const surfaceInteractionErrorUpdateSchema: z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"SURFACE_INTERACTION_ERROR">;
+    surface: z.ZodUUID;
+    message: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>;
+export type SurfaceInteractionErrorUpdate = z.infer<typeof surfaceInteractionErrorUpdateSchema>;
+declare const uiRebuiltUpdateSchema: z.ZodObject<{
+    devSession: z.ZodString;
+    uiId: z.ZodString;
+    hash: z.ZodString;
+    source: z.ZodString;
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"UI_REBUILT">;
+}, z.core.$strip>;
+export type UiRebuiltUpdate = z.infer<typeof uiRebuiltUpdateSchema>;
 declare const nodeDeferUpdateSchema: z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
@@ -185,7 +248,7 @@ declare const nodeDeferUpdateSchema: z.ZodObject<{
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_DEFER">;
-    reason: z.ZodUnknown;
+    reason: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type NodeDeferUpdate = z.infer<typeof nodeDeferUpdateSchema>;
 declare const taskStartUpdateSchema: z.ZodObject<{
@@ -200,7 +263,7 @@ declare const taskStartUpdateSchema: z.ZodObject<{
         nodeId: z.ZodUUID;
         messageId: z.ZodUUID;
     }, z.core.$strip>>>;
-    input: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>;
 export type TaskStartUpdate = z.infer<typeof taskStartUpdateSchema>;
 declare const taskErrorUpdateSchema: z.ZodObject<{
@@ -307,7 +370,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_UPDATE">;
     output: z.ZodNullable<z.ZodString>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
     overwrite: z.ZodBoolean;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
@@ -337,7 +400,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     }, z.core.$strip>;
     propertyPath: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
     output: z.ZodNullable<z.ZodString>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
@@ -377,7 +440,62 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         system: "system";
         warn: "warn";
     }>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    component: z.ZodObject<{
+        id: z.ZodString;
+        hash: z.ZodString;
+        source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    props: z.ZodUnknown;
+    defaults: z.ZodOptional<z.ZodUnknown>;
+    surfaceId: z.ZodString;
+    devSession: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    node: z.ZodObject<{
+        id: z.ZodUUID;
+        type: z.ZodEnum<{
+            logic: "logic";
+            or: "or";
+            reference: "reference";
+            service: "service";
+        }>;
+        alias: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    type: z.ZodLiteral<"NODE_RENDER">;
+    messageId: z.ZodUUID;
+    connectionId: z.ZodUUID;
+    ownTraceId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    handlerQueue: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"SURFACE_DEAD">;
+    messageId: z.ZodUUID;
+    connectionId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
+}, z.core.$strip>, z.ZodObject<{
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"SURFACE_INTERACTION_ERROR">;
+    surface: z.ZodUUID;
+    message: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+}, z.core.$strip>, z.ZodObject<{
+    devSession: z.ZodString;
+    uiId: z.ZodString;
+    hash: z.ZodString;
+    source: z.ZodString;
+    timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
+    id: z.ZodUUID;
+    rootTaskId: z.ZodOptional<z.ZodUUID>;
+    traceIds: z.ZodArray<z.ZodString>;
+    type: z.ZodLiteral<"UI_REBUILT">;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
@@ -394,7 +512,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     type: z.ZodLiteral<"NODE_DEFER">;
-    reason: z.ZodUnknown;
+    reason: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;
@@ -407,7 +525,7 @@ export declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         nodeId: z.ZodUUID;
         messageId: z.ZodUUID;
     }, z.core.$strip>>>;
-    input: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodPipe<z.ZodNumber, z.ZodTransform<Date, number>>;
     id: z.ZodUUID;

package/build/types/helpers/src/protocol/update.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAsB1B,QAAA,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;iBAIxB,CAAA;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAYjE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAezB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAKpB,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAEzD,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMtB,CAAA;AAEF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAE7D,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAEvB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAIzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;;;;;;;iBAYzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,qBAAqB;;;;;;;iBAGzB,CAAA;AACF,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEnE,QAAA,MAAM,mBAAmB;;;;;;;;iBAIvB,CAAA;AACF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAO/D,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAavB,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"update.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/protocol/update.ts"],"names":[],"mappings":"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"}

package/build/types/helpers/src/utils/matchSchema.d.ts

@@ -1,4 +1,18 @@
 import type { z } from 'zod/v4';
+/**
+ * Curried on **arity**, never on the value — which is what the rest parameter
+ * buys over an optional one.
+ *
+ * It used to branch on `if (input)`, so a falsy second argument fell through to
+ * the curried arm and the caller was handed a predicate *function* instead of an
+ * answer. A function is truthy, so `if (!matchSchema(schema, value))` passed on
+ * exactly the input it was written to catch (a missing `correlationId`, an absent
+ * `taskId` header), and `if (matchSchema(schema, value))` fired on values that
+ * match nothing — `resolveAccept`'s unresolvable `#/definitions/…` hop reached
+ * `undefined.const` that way. The mirror image was just as wrong: `0`, `''` and
+ * `false` are legitimate values a guard must be able to say *yes* about, and
+ * `index: 0` is the first publish of every service message.
+ */
 export declare function matchSchema<Schema extends z.ZodSchema>(schema: Schema, input: unknown): input is z.infer<Schema>;
 export declare function matchSchema<Schema extends z.ZodSchema>(schema: Schema): (input: unknown) => input is z.infer<Schema>;
 //# sourceMappingURL=matchSchema.d.ts.map

package/build/types/helpers/src/utils/matchSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matchSchema.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/matchSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;AAC3B,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,GACb,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA"}
+{"version":3,"file":"matchSchema.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/matchSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE/B;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA;AAC3B,wBAAgB,WAAW,CAAC,MAAM,SAAS,CAAC,CAAC,SAAS,EACpD,MAAM,EAAE,MAAM,GACb,CAAC,KAAK,EAAE,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAA"}

package/build/types/helpers/src/utils/serviceRender.d.ts

@@ -0,0 +1,73 @@
+import { z } from 'zod/v4';
+/**
+ * The render payload a service publishes when a handler calls
+ * `context.render(ui, props)` — the wire shape shared by the service SDK
+ * (which composes it) and the operator (which parses it before emitting the
+ * render as a task update). See `knowledge/service-ui-surfaces.md`.
+ *
+ * `component.source` travels only on the **first** render of a given hash into a
+ * given task; later renders carry the hash alone, because ui/backend stores the
+ * bundle hash-addressed and that row outlives every render. A hash arriving
+ * without a source that ui/backend has never seen is an error state on the
+ * surface, not a silent fallback (D16).
+ *
+ * Per task rather than per connection because bundle retention is per task
+ * (D19): the last-referent sweep removes a bundle once no task references it, and
+ * a connection can outlive every task that referenced its component.
+ *
+ * Every field is deliberately a *top-level* key, because that is the granularity
+ * the size-triggered claim-check works at: it offloads a record body's largest
+ * top-level values first, and the publisher pins every one of these inline except
+ * `props`. So an oversized render always offloads `props` — the one value whose
+ * loss is a named error state rather than a broken surface. The source is capped
+ * at {@link MAX_UI_SOURCE_BYTES} anyway, well under the offload threshold, so the
+ * bundle always travels inline (D4).
+ */
+export declare const serviceRenderSchema: z.ZodObject<{
+    component: z.ZodObject<{
+        id: z.ZodString;
+        hash: z.ZodString;
+        source: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    props: z.ZodUnknown;
+    defaults: z.ZodOptional<z.ZodUnknown>;
+    surfaceId: z.ZodString;
+    devSession: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type ServiceRender = z.infer<typeof serviceRenderSchema>;
+/**
+ * Hard cap on a UI component bundle, enforced when the component is registered
+ * (D4). Fits a self-contained React component, stays storable inline in
+ * Postgres, and fails fast on an accidental whole-app bundle.
+ */
+export declare const MAX_UI_SOURCE_BYTES: number;
+/**
+ * The surface a render targets when it names none (D3). A node's surfaces are
+ * keyed by this id, so the default is a single surface per node/trace.
+ */
+export declare const DEFAULT_SURFACE_ID = "default";
+/**
+ * Hard cap on one value a browser sends into a surface — a callback
+ * invocation's argument, or a deferred form's submitted response — enforced in
+ * ui/backend before either is published (D7).
+ *
+ * One number for both because they are the same thing arriving by two routes:
+ * viewer-authored bytes that reach service code, bounded before they enter the
+ * fabric. A response additionally has to fit the node's own output, which the
+ * operator enforces on the way in as it does for any service result.
+ *
+ * An interaction is exactly that — a click, a form submit, an approval — not
+ * a data transfer, and unlike a service's own publishes it crosses no outbound
+ * boundary: nothing offloads it, so its bytes reach the broker as they are. The
+ * cap is what keeps that true, and it is deliberately far below any message
+ * limit rather than tuned to one, so a task's `maxPayloadSize` can never make
+ * the difference between a usable synchronous rejection and a dropped AMQP
+ * connection.
+ *
+ * Lives here, next to {@link MAX_UI_SOURCE_BYTES}, rather than inside ui/backend:
+ * the browser is the other party that has to respect it, and when the surface
+ * host starts refusing an oversized argument before the round trip it should
+ * read the number from where the server enforces it, not restate it.
+ */
+export declare const MAX_SURFACE_INTERACTION_BYTES: number;
+//# sourceMappingURL=serviceRender.d.ts.map

package/build/types/helpers/src/utils/serviceRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serviceRender.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/serviceRender.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;iBAkD9B,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAE/D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,QAAc,CAAA;AAE9C;;;GAGG;AACH,eAAO,MAAM,kBAAkB,YAAY,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,6BAA6B,QAAY,CAAA"}

package/build/types/helpers/src/utils/surfaceComponent.d.ts

@@ -0,0 +1,116 @@
+/**
+ * What a **surface component** is handed, declared once (#113).
+ *
+ * These types have three readers and no natural owner among them: the service
+ * SDK ships them to the component author (`@requence/service`), the frame
+ * protocol describes the object the bootstrap actually builds
+ * (`ui/frontend/src/routes/tasks/Show/surface/protocol.ts`), and the shared
+ * runtime's facade *implements* them in `createSurface`
+ * (`ui/frontend/surface-runtime/ui.tsx`). They lived in the SDK and were mirrored
+ * in the protocol, which was survivable while the mirror was two fields wide; a
+ * third copy in the facade is not, because the drift would land as a helper whose
+ * signature promises state the frame does not deliver — and the author's types
+ * would be the last thing to find out.
+ *
+ * So they live here, beside the render wire shape (`serviceRender.ts`) and the
+ * handler reference (`surfaceHandler.ts`), which is the seam both verticals
+ * already share for exactly this reason.
+ *
+ * Nothing here has a runtime half: the props themselves cross as
+ * `serviceRender`'s payload, and the rest is the browser's own object.
+ */
+/** The viewer's app theme, as the surface host reports it. */
+export type SurfaceTheme = 'dark' | 'light';
+/**
+ * Everything about a surface that can change while the component is mounted —
+ * what `ctx` carries at mount and what `onUpdate` hands over afterwards. Named
+ * once so the two cannot drift.
+ *
+ * There is no surface-wide liveness flag on it (#106). Reachability rides on
+ * each handler prop instead — `props.onSubmit.reachable` — because a surface can
+ * carry a durable handler and a connection-bound one at once and one flag over
+ * both necessarily lies about one of them.
+ *
+ * It is also what a component written with `createSurface` receives as its own
+ * props (#113), which is why the three fields are named for a component and not
+ * for the message that carries them.
+ */
+export interface SurfaceState<Props> {
+    props: Props;
+    canInvoke: boolean;
+    theme: SurfaceTheme;
+}
+/**
+ * The context a mounted component is handed. `props` is the object the service
+ * sent (handlers invokable, each carrying its own `reachable`); `canInvoke` is
+ * the viewer's `task: UPDATE` verdict; `theme` is the viewer's app theme;
+ * `onUpdate` fires on every re-render and returns an unsubscribe.
+ *
+ * A React component rarely touches this: `createSurface` subscribes for it and
+ * hands the state down as props. It is the layer underneath — what a component
+ * written without the helper, or in another framework, works against.
+ *
+ * `canInvoke` is an **affordance signal only** — disable the control, label it
+ * read-only. It is not the check: a viewer without the permission has their
+ * invocation refused by the parent frame, and ui/backend enforces it again on
+ * the mutation, so a component that ignores the flag cannot grant anything.
+ *
+ * **Reachability is separate, and per prop.** AND the two: `canInvoke` says
+ * whether this viewer may drive the surface, `reachable` says whether there is
+ * anything at the other end of that particular prop. The flag a form used to get
+ * this wrong with — one `live` for the whole surface — is gone, because a
+ * **durable** handler is reachable with no live message at all (which is the whole
+ * point of the kind: the service renders a form and exits within seconds while
+ * the node waits for days) while a connection-bound one on the same surface is
+ * not.
+ *
+ * There is no `submit` here. A form answers its node by calling a handler its own
+ * service put in the props — an ordinary function like every other interaction —
+ * rather than through a channel Requence defines. Write that handler in the UI's
+ * **defaults** so it is durable, and let it `act()` on the key the props carry.
+ *
+ * **A failed interaction is not reported here either** (#143). Calling a handler
+ * prop is *accepted* and nothing more: no return value, no promise, no request.
+ * When one could not run — it threw, nothing was registered under it, the version
+ * is gone — Requence records a generic sentence and renders it itself, beside the
+ * surface, in the same place as a refused click. Nothing arrives in this context,
+ * and a component must not try to render it.
+ *
+ * To say something better than the generic sentence, catch the error **in the
+ * handler** and **re-render** the surface with a prop of your own
+ * (`{ error: 'unknown address' }`). That statement is in the props, so no generic
+ * report can overwrite it, and both can be shown at once — the handler said
+ * something *and* it threw.
+ *
+ * **A `<form>` works, and it must call `preventDefault()`** (D31). The frame is
+ * sandboxed with `allow-scripts allow-forms`, so `<form onSubmit>` fires normally
+ * and Enter-to-submit comes with it. What the sandbox does *not* grant is
+ * `allow-top-navigation` or `allow-popups`, so a submission can only ever navigate
+ * **this frame** — which unloads the component. Call `preventDefault()` and invoke
+ * the handler prop instead. Forget it and the frame reloads; the surface
+ * re-initialises and remounts with its current props rather than going blank, but
+ * whatever the component held in local state is gone. A plain `onClick` button is
+ * still fine and needs none of this.
+ *
+ * A component that paints its own colours can follow a theme switch through
+ * `onUpdate` — but it rarely has to: the surface host also writes the theme onto
+ * `<html data-theme>`, which is what the shared runtime's CSS keys off, so a
+ * component drawn with the primitives facade follows the app for free.
+ */
+export interface SurfaceContext<Props> {
+    readonly props: Props;
+    readonly canInvoke: boolean;
+    readonly theme: SurfaceTheme;
+    onUpdate(callback: (next: SurfaceState<Props>) => void): () => void;
+}
+/**
+ * The component contract: one default-exported `mount(element, ctx)` that
+ * optionally returns a teardown. Typing the export with `Mount<PropsOf<typeof
+ * ui>>` checks the component against exactly what the service sends.
+ *
+ * A React component does not write one by hand — `createSurface` returns one
+ * (#113) — but it is still what the frame calls, and what any other framework
+ * exports.
+ */
+export type Mount<Props> = (element: HTMLElement, ctx: SurfaceContext<Props>) => (() => void) | void;
+//# sourceMappingURL=surfaceComponent.d.ts.map

package/build/types/helpers/src/utils/surfaceComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceComponent.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/surfaceComponent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,OAAO,CAAA;AAE3C;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,YAAY,CAAC,KAAK;IACjC,KAAK,EAAE,KAAK,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,KAAK,EAAE,YAAY,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AACH,MAAM,WAAW,cAAc,CAAC,KAAK;IACnC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAA;IAC3B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAA;IAC5B,QAAQ,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,YAAY,CAAC,KAAK,CAAC,KAAK,IAAI,GAAG,MAAM,IAAI,CAAA;CACpE;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,KAAK,CAAC,KAAK,IAAI,CACzB,OAAO,EAAE,WAAW,EACpB,GAAG,EAAE,cAAc,CAAC,KAAK,CAAC,KACvB,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAA"}