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

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"}

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

@@ -0,0 +1,171 @@
+import { z } from 'zod/v4';
+/**
+ * The reference tag of a **surface handler** — a function a service put in a
+ * surface's props, which a viewer's interaction runs back in the service that
+ * issued the render (#103).
+ *
+ * Deliberately not a `RequenceCallback`, even though the connection-bound arm
+ * is routed the same way today. The two answer different questions and address
+ * different things: a callback reference is a peer-to-peer control-flow handle
+ * whose `outputName`/`propertyPath` address a position in the node's declared
+ * *output schema*, while a handler reference addresses a **prop of a UI**, has
+ * no output behind it, and — in its durable arm — names no connection at all.
+ * Merging them would put a lifetime on every callback in the fabric and make a
+ * durable reference look like something the operator should route by `sourceId`.
+ */
+export declare const SURFACE_HANDLER_TAG = "RequenceHandler";
+/**
+ * How long a handler can be reached, decided by **where the function was
+ * written** — which is the only thing that actually bounds the closure's life:
+ *
+ * - `durable` — a function in the UI's default props. It closes over module
+ *   scope, so *any* instance of the service version can run it, now or after a
+ *   redeploy, and an invocation waits in the version's handler queue when none
+ *   is running. Addressed by `(uiId, path)`, because that pair is what survives
+ *   a rebuild and a restart; the component's content hash does not.
+ * - `connection` — a function written inline at `context.render(...)`. It closes
+ *   over the running handler, so only that process can serve it and it dies when
+ *   the handler returns. Addressed by the registering connection plus an id in
+ *   its registry, exactly as a callback is.
+ *
+ * `uiId`/`path` ride on both arms: the connection-bound arm does not need them
+ * to be *routed*, but they are what says which prop of which component this
+ * handle belongs to, which is what the row-level `live` flag could never say
+ * (#106).
+ */
+export declare const surfaceHandlerObjectSchema: 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">;
+export type SurfaceHandlerObject = z.infer<typeof surfaceHandlerObjectSchema>;
+export type SurfaceHandlerLifetime = SurfaceHandlerObject['lifetime'];
+export declare function isSurfaceHandlerObject(data: unknown): data is SurfaceHandlerObject;
+/**
+ * The per-version **handler queue**: where a durable invocation waits until
+ * some instance of that service version consumes it.
+ *
+ * Derived from the version's dispatch queue rather than composed from the
+ * service and version names, so the two can never drift and a dev-overlay
+ * connection — which consumes a rewritten dispatch queue — gets a handler queue
+ * of its own for free.
+ */
+export declare function serviceHandlerQueueName(dispatchQueue: string): string;
+/**
+ * How long a durable invocation may wait in the handler queue before the broker
+ * drops it (#116).
+ *
+ * The queue is **not a mailbox**. Reachability is checked before the click — a
+ * version with no consumers reports `reachable: false` and the control is
+ * withheld — so all this has to bridge is the seconds between that check and the
+ * consume: a rolling redeploy, a scale-to-zero that started a moment ago, a
+ * replica that took the invocation and died. Long enough that a normal restart
+ * still serves the click, short enough that nobody is surprised by an effect
+ * they pressed for hours ago.
+ *
+ * That is the half the flag cannot do on its own: the flag only makes the click
+ * harder to fire, and a click that IS fired into an empty queue must expire and
+ * be *reported* rather than sit there waiting for whoever deploys next.
+ *
+ * Expiry is not a drop: the queue dead-letters to `error`, so an expired
+ * invocation comes back to the operator carrying its own `taskId` and surface
+ * row, and is recorded as an `interactionError` (#107).
+ */
+export declare const SURFACE_HANDLER_INVOCATION_TTL_MS = 60000;
+/**
+ * The handler queue's declaration arguments, as **one** object, because two
+ * parties declare that queue — ui/backend's provisioner and the service SDK on
+ * connect — and a broker answers a mismatch with a 406 that kills the declaring
+ * channel. Anything short of a shared literal is a service that will not start.
+ *
+ * `deadLetterExchange` is what turns expiry into a *report*: `error` fans back
+ * into the operator's own shard family, so an expired invocation arrives at the
+ * error consumer still carrying its `taskId`, its surface row and its
+ * `surfaceHandlerInvocation` marker. Without it the broker would simply drop the
+ * message, which is the silent outcome #116 replaced.
+ *
+ * Note for whoever changes this: declaring a queue with a dead-letter exchange
+ * needs WRITE permission on that exchange, so the service AMQP user is granted
+ * it (`assertService`). It costs nothing — `error` is an internal exchange and
+ * the broker refuses a client publish to one however the permissions read.
+ */
+export declare const SURFACE_HANDLER_QUEUE_ARGUMENTS: {
+    readonly messageTtl: 60000;
+    readonly deadLetterExchange: 'error';
+};
+export declare function isDevOverlayHandlerQueue(queueName: string): boolean;
+/**
+ * The header a durable invocation is stamped with, so the party that has to
+ * answer an **unroutable** one can tell it from a dispatch (#104).
+ *
+ * A durable invocation is published `mandatory` into the `service` exchange, so
+ * one whose queue is gone comes back to the operator looking like any other
+ * undeliverable service message — and every other arm there fails the task's
+ * node, which a viewer's click must never do.
+ *
+ * A header rather than the routing key's `-handlers` suffix, which is *nearly*
+ * unambiguous and therefore worse: a version named `…-handlers` gives a dispatch
+ * queue that ends the same way, and the failure that buys is a real service
+ * dispatch silently swallowed instead of failing its node. This is exact, and it
+ * is set by the only publisher there is.
+ */
+export declare const SURFACE_HANDLER_INVOCATION_HEADER = "surfaceHandlerInvocation";
+/**
+ * One durable handler invocation, as it travels on the queue above.
+ *
+ * The pair `(uiId, path)` is the whole address: the consuming instance looks the
+ * UI up in its own registry and resolves the path against that UI's default
+ * props. `taskId` is not part of the address — it is what makes the failure of
+ * an invocation that names nothing say *which run* it belonged to.
+ */
+export declare const surfaceHandlerInvocationSchema: z.ZodObject<{
+    taskId: z.ZodUUID;
+    surface: z.ZodUUID;
+    uiId: z.ZodString;
+    path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodInt]>>;
+    arg: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type SurfaceHandlerInvocation = z.infer<typeof surfaceHandlerInvocationSchema>;
+/**
+ * How long a recorded interaction failure may be (#107).
+ *
+ * A thrown error's message is author-supplied text of no bounded length, and it
+ * ends up on a row that is pushed to every viewer of the task on every render.
+ * Truncated rather than rejected: a long message is still the most useful thing
+ * anyone has about the failure, and its first characters are where the cause is.
+ */
+export declare const MAX_SURFACE_INTERACTION_ERROR_CHARS = 500;
+/**
+ * The header a **surface interaction failure report** is stamped with (#107), so
+ * the operator can tell it from an ordinary service result.
+ *
+ * A report carries no message id and no index: the handler that failed was not
+ * running for any message of the operator's — that is the whole of what makes a
+ * durable handler durable — so it cannot ride the ordered dispatch buffer, and
+ * every other arm of the result path would fail the node the surface is painted
+ * on. It names a task, a surface row and what went wrong, and the operator
+ * forwards it as a task update.
+ */
+export declare const SURFACE_INTERACTION_ERROR_HEADER = "surfaceInteractionError";
+/**
+ * One interaction failure, as a service reports it back to the operator (#107).
+ *
+ * The failing party writes the sentence: only it knows whether the component was
+ * unregistered, the prop held nothing invokable, or the handler threw — and only
+ * it can quote the error. The operator forwards the text verbatim; ui/backend
+ * masks it and stores it on the row.
+ */
+export declare const surfaceInteractionErrorReportSchema: z.ZodObject<{
+    surface: z.ZodUUID;
+    message: z.ZodString;
+}, z.core.$strip>;
+export type SurfaceInteractionErrorReport = z.infer<typeof surfaceInteractionErrorReportSchema>;
+//# sourceMappingURL=surfaceHandler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"surfaceHandler.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/surfaceHandler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,oBAAoB,CAAA;AAIpD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;+BAiBrC,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAA;AAC7E,MAAM,MAAM,sBAAsB,GAAG,oBAAoB,CAAC,UAAU,CAAC,CAAA;AAErE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,OAAO,GACZ,IAAI,IAAI,oBAAoB,CAE9B;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAErE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,iCAAiC,QAAS,CAAA;AAEvD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,+BAA+B;aAC1C,UAAU;aACV,kBAAkB,EAAE,OAAO;CACnB,CAAA;AAmBV,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,iCAAiC,6BAA6B,CAAA;AAE3E;;;;;;;GAOG;AACH,eAAO,MAAM,8BAA8B;;;;;;iBA0BzC,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAC5C,OAAO,8BAA8B,CACtC,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gCAAgC,4BAA4B,CAAA;AAEzE;;;;;;;GAOG;AACH,eAAO,MAAM,mCAAmC;;;iBAG9C,CAAA;AAEF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CACjD,OAAO,mCAAmC,CAC3C,CAAA"}

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

@@ -0,0 +1,48 @@
+import { z } from 'zod/v4';
+/**
+ * Marks a service message as a **dev-loop bundle swap** (#108) rather than a
+ * result for one of the operator's dispatches.
+ *
+ * A rebuild changes which bytes the frame imports and nothing else — not the
+ * props, not the handlers, not the node — so it is deliberately not a render. A
+ * render would need the registering message to be unsettled and its registry
+ * alive, which is what took the dev loop away from a deferred form: the handler
+ * that drew it returned at the defer, so there is nothing left to re-render
+ * through. A swap needs none of that, and so works identically for a live panel,
+ * a deferred form, and a surface on a task that has already finished.
+ *
+ * Read on the same path as a result, and answered before it — like
+ * `SURFACE_INTERACTION_ERROR_HEADER`, this message has no correlation id, no
+ * index and no place in the ordered dispatch buffer, because it belongs to no
+ * message of the operator's.
+ */
+export declare const UI_REBUILD_HEADER = "uiRebuild";
+/**
+ * What a rebuild says: *this component of this dev session is now these bytes*.
+ *
+ * `devSession` is opaque here and produced by the service SDK, which is the only
+ * party that can: it is the one identity that survives the process being
+ * restarted (a dev token plus the service version it is overlaying), so the
+ * surfaces a session drew before a restart are still the same session's
+ * afterwards. It deliberately carries no dev token in the clear — the token is
+ * hashed into it — because it comes to rest in `task_surface`.
+ *
+ * `uiId` is the component's stable id (#103), which is what makes the swap
+ * addressable at all: the hash is the thing that changed, so it cannot be the
+ * thing looked up. A surface repoints when it belongs to this session AND shows
+ * this component, whatever hash it is currently on — which is why a swap reaches
+ * a surface that has sat through several rebuilds unseen.
+ *
+ * `source` always travels. The render payload's per-task dedup does not apply: a
+ * swap is the first anyone has heard of this hash, and the surfaces it repoints
+ * are precisely the ones that would otherwise be left naming a bundle nobody
+ * stored.
+ */
+export declare const uiRebuildSchema: z.ZodObject<{
+    devSession: z.ZodString;
+    uiId: z.ZodString;
+    hash: z.ZodString;
+    source: z.ZodString;
+}, z.core.$strip>;
+export type UiRebuild = z.infer<typeof uiRebuildSchema>;
+//# sourceMappingURL=uiRebuild.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uiRebuild.d.ts","sourceRoot":"","sources":["../../../../../../helpers/src/utils/uiRebuild.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAA;AAE1B;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,cAAc,CAAA;AAE5C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe;;;;;iBAK1B,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/build/types/task/src/createTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../../../../src/createTask.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,MAAM,EAGZ,MAAM,YAAY,CAAA;AAGnB,cAAM,gBAAiB,SAAQ,KAAK;aAGhB,YAAY,EAAE,MAAM;IAFtC,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM,EAGrC;CACF;AAED,qBAAa,SAAU,SAAQ,gBAAgB;aAG3B,YAAY,EAAE,MAAM;aACpB,MAAM,EAAE,MAAM;IAHhC,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EAG/B;CACF;AAED,KAAK,iBAAiB,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;AAEvD,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,YAAY,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,IACjE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,GAAG;IACvD,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAC5B,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACpC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAA;AAEL,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,YAAY,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EACzD,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAgfzE"}
+{"version":3,"file":"createTask.d.ts","sourceRoot":"","sources":["../../../../src/createTask.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,MAAM,EACX,KAAK,MAAM,EAGZ,MAAM,YAAY,CAAA;AAGnB,cAAM,gBAAiB,SAAQ,KAAK;aAGhB,YAAY,EAAE,MAAM;IAFtC,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM,EAGrC;CACF;AAED,qBAAa,SAAU,SAAQ,gBAAgB;aAG3B,YAAY,EAAE,MAAM;aACpB,MAAM,EAAE,MAAM;IAHhC,YACE,OAAO,EAAE,MAAM,EACC,YAAY,EAAE,MAAM,EACpB,MAAM,EAAE,MAAM,EAG/B;CACF;AAED,KAAK,iBAAiB,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,CAAA;AAEvD,KAAK,IAAI,CAAC,CAAC,SAAS,MAAM,YAAY,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,IACjE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GACtB,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC,GAAG;IACvD,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAC5B,UAAU,IAAI,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAA;IACpC,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACrC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB,CAAA;AAEL,wBAAgB,UAAU,CACxB,CAAC,SAAS,MAAM,YAAY,CAAC,YAAY,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,EACzD,OAAO,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,EAAE,iBAAiB,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CA0ezE"}

package/build/types/task/src/getTask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getTask.d.ts","sourceRoot":"","sources":["../../../../src/getTask.ts"],"names":[],"mappings":"AA6BA,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAsB,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,cAAc;;;;;;;;;;;;;;;;;;;GA0DrE"}
+{"version":3,"file":"getTask.d.ts","sourceRoot":"","sources":["../../../../src/getTask.ts"],"names":[],"mappings":"AAmCA,UAAU,cAAc;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,wBAAsB,OAAO,CAAC,eAAe,EAAE,MAAM,GAAG,cAAc;;;;;;;;;;;;;;;;;;;GA0DrE"}

package/build/types/task/src/types.d.ts

@@ -35,7 +35,7 @@ declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     name: z.ZodString;
     updateId: z.ZodUUID;
     type: z.ZodLiteral<"taskStart">;
-    input: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
     rootTaskId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodCoercedDate<unknown>;
@@ -84,7 +84,7 @@ declare const updateSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"logic" | "or" | "reference" | "service">;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
     output: z.ZodUnion<readonly [z.ZodNull, z.ZodString]>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodCoercedDate<unknown>;
@@ -151,7 +151,7 @@ export declare const eventSchema: z.ZodPipe<z.ZodPipe<z.ZodObject<{
     name: z.ZodString;
     updateId: z.ZodUUID;
     type: z.ZodLiteral<"taskStart">;
-    input: z.ZodUnknown;
+    input: z.ZodOptional<z.ZodUnknown>;
     rootTaskId: z.ZodDefault<z.ZodNullable<z.ZodUUID>>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodCoercedDate<unknown>;
@@ -200,7 +200,7 @@ export declare const eventSchema: z.ZodPipe<z.ZodPipe<z.ZodObject<{
         type: z.ZodLiteral<"logic" | "or" | "reference" | "service">;
         alias: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
-    data: z.ZodUnknown;
+    data: z.ZodOptional<z.ZodUnknown>;
     output: z.ZodUnion<readonly [z.ZodNull, z.ZodString]>;
 }, z.core.$strip>, z.ZodObject<{
     timestamp: z.ZodCoercedDate<unknown>;

package/build/types/task/src/types.d.ts.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@requence/task",
   "type": "module",
-  "version": "0.8.2-edge.1151",
+  "version": "0.8.2-edge.1155",
   "bin": {
     "requence-task": "build/cli.js"
   },
@@ -21,7 +21,6 @@
   },
   "dependencies": {
     "ajv": "^8.17.1",
-    "chalk": "^5.6.2",
     "eventsource-client": "^1.2.0",
     "mime-types": "^3.0.1",
     "yargs": "^17.7.2",
@@ -31,6 +30,7 @@
     "@requence/callbacks": "workspace:*",
     "@requence/files": "workspace:*",
     "@requence/helpers": "workspace:*",
+    "@requence/logger": "workspace:*",
     "@requence/transformer": "workspace:*",
     "@requence/utils": "workspace:*",
     "@types/bun": "^1.2.23",

package/build/chunk-f7g9gsa0.js

@@ -1,65 +0,0 @@
-// ../helpers/src/utils/obfuscate.ts
-var separator = "";
-var base65Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
-var base65CharToIndex = {};
-for (let i = 0;i < base65Chars.length; i++) {
-  base65CharToIndex[base65Chars[i]] = i;
-}
-function deobfuscate(str) {
-  const paddingCount = parseInt(str.slice(-1), 10);
-  str = str.slice(0, -1);
-  let binaryString = "";
-  for (let i = 0;i < str.length; i++) {
-    const decimalValue = base65CharToIndex[str[i]];
-    const binaryChunk = decimalValue.toString(2).padStart(6, "0");
-    binaryString += binaryChunk;
-  }
-  if (paddingCount > 0) {
-    binaryString = binaryString.slice(0, -paddingCount);
-  }
-  let decodedString = "";
-  const charSize = 16;
-  for (let i = 0;i < binaryString.length; i += charSize) {
-    const byte = binaryString.substring(i, i + charSize);
-    if (byte.length === 16) {
-      const charCode = parseInt(byte, 2);
-      decodedString += String.fromCharCode(charCode);
-    }
-  }
-  return decodedString.split(separator);
-}
-
-// src/errors.ts
-var UNREACHABLE_STATUS = new Set([502, 503, 504]);
-
-class RequenceUnreachableError extends Error {
-  status;
-  constructor(status, options) {
-    super("The requence system is currently not reachable. Please retry later.", options);
-    this.status = status;
-    this.name = "RequenceUnreachableError";
-  }
-}
-function isUnreachableStatus(status) {
-  return UNREACHABLE_STATUS.has(status);
-}
-function assertReachable(response) {
-  if (isUnreachableStatus(response.status)) {
-    throw new RequenceUnreachableError(response.status);
-  }
-}
-async function reachableFetch(input, init) {
-  let response;
-  try {
-    response = await fetch(input, init);
-  } catch (error) {
-    throw new RequenceUnreachableError(undefined, { cause: error });
-  }
-  assertReachable(response);
-  return response;
-}
-
-export { deobfuscate, RequenceUnreachableError, isUnreachableStatus, reachableFetch };
-
-//# debugId=BB37885AF7B09DA164756E2164756E21
-//# sourceMappingURL=chunk-f7g9gsa0.js.map

package/build/chunk-f7g9gsa0.js.map

@@ -1,11 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../helpers/src/utils/obfuscate.ts", "../src/errors.ts"],
-  "sourcesContent": [
-    "const separator = '\\u{f6ee}'\n\nconst base65Chars =\n  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$'\n\nconst base65CharToIndex: Record<string, number> = {}\nfor (let i = 0; i < base65Chars.length; i++) {\n  base65CharToIndex[base65Chars[i]] = i\n}\n\nexport function obfuscate(...parts: Array<string>) {\n  const str = parts.join(separator)\n  let binaryString = ''\n\n  for (let i = 0; i < str.length; i++) {\n    const charCode = str.charCodeAt(i)\n    binaryString += charCode.toString(2).padStart(16, '0')\n  }\n\n  let encodedString = ''\n  const chunkSize = 6\n  let paddingCount = 0\n\n  for (let i = 0; i < binaryString.length; i += chunkSize) {\n    let chunk = binaryString.substring(i, i + chunkSize)\n\n    if (chunk.length < chunkSize) {\n      paddingCount = chunkSize - chunk.length\n      chunk = chunk.padEnd(chunkSize, '0')\n    }\n\n    const decimalValue = parseInt(chunk, 2)\n    encodedString += base65Chars[decimalValue]\n  }\n\n  return encodedString + paddingCount.toString()\n}\n\nexport function randomString(length: number) {\n  const randomValues = new Uint8Array(length)\n  crypto.getRandomValues(randomValues)\n\n  let randomString = ''\n  for (let i = 0; i < length; i++) {\n    randomString += base65Chars[randomValues[i] % base65Chars.length]\n  }\n\n  return randomString\n}\n\nexport function deobfuscate(str: string) {\n  const paddingCount = parseInt(str.slice(-1), 10)\n  str = str.slice(0, -1)\n\n  let binaryString = ''\n\n  for (let i = 0; i < str.length; i++) {\n    const decimalValue = base65CharToIndex[str[i]]\n    const binaryChunk = decimalValue.toString(2).padStart(6, '0')\n    binaryString += binaryChunk\n  }\n\n  if (paddingCount > 0) {\n    binaryString = binaryString.slice(0, -paddingCount)\n  }\n\n  let decodedString = ''\n  const charSize = 16\n\n  for (let i = 0; i < binaryString.length; i += charSize) {\n    const byte = binaryString.substring(i, i + charSize)\n    if (byte.length === 16) {\n      const charCode = parseInt(byte, 2)\n      decodedString += String.fromCharCode(charCode)\n    }\n  }\n\n  return decodedString.split(separator)\n}\n",
-    "// Gateway statuses an ingress/load balancer emits when no healthy backend is\n// available (maintenance window, deploy, cutover). The task endpoints never\n// return these themselves, so treating them as \"unreachable\" is unambiguous.\nconst UNREACHABLE_STATUS = new Set([502, 503, 504])\n\n/**\n * Signals that the requence system could not be reached — e.g. during a\n * maintenance window or deploy, when the ui backend is unreachable (connection\n * refused / timeout / DNS failure) or an ingress returns a gateway error\n * (502/503/504). Callers should treat this as transient and retry later.\n */\nexport class RequenceUnreachableError extends Error {\n  constructor(\n    public readonly status?: number,\n    options?: { cause?: unknown },\n  ) {\n    super(\n      'The requence system is currently not reachable. Please retry later.',\n      options,\n    )\n    this.name = 'RequenceUnreachableError'\n  }\n}\n\nexport function isUnreachableStatus(status: number): boolean {\n  return UNREACHABLE_STATUS.has(status)\n}\n\n/**\n * Throws a {@link RequenceUnreachableError} when the response carries a gateway\n * status indicating the system is unreachable. Call right after a fetch, before\n * inspecting `response.ok`.\n */\nexport function assertReachable(response: Response): void {\n  if (isUnreachableStatus(response.status)) {\n    throw new RequenceUnreachableError(response.status)\n  }\n}\n\n/**\n * Wraps `fetch` so a transport-level failure (connection refused, DNS failure,\n * timeout) surfaces as a {@link RequenceUnreachableError} instead of a raw\n * TypeError, and gateway statuses (502/503/504) do the same. The returned\n * response is guaranteed not to be a gateway-error response.\n */\nexport async function reachableFetch(\n  input: Parameters<typeof fetch>[0],\n  init?: Parameters<typeof fetch>[1],\n): Promise<Response> {\n  let response: Response\n  try {\n    response = await fetch(input, init)\n  } catch (error) {\n    throw new RequenceUnreachableError(undefined, { cause: error })\n  }\n  assertReachable(response)\n  return response\n}\n"
-  ],
-  "mappings": ";AAAA,IAAM,YAAY;AAElB,IAAM,cACJ;AAEF,IAAM,oBAA4C,CAAC;AACnD,SAAS,IAAI,EAAG,IAAI,YAAY,QAAQ,KAAK;AAAA,EAC3C,kBAAkB,YAAY,MAAM;AACtC;AA0CO,SAAS,WAAW,CAAC,KAAa;AAAA,EACvC,MAAM,eAAe,SAAS,IAAI,MAAM,EAAE,GAAG,EAAE;AAAA,EAC/C,MAAM,IAAI,MAAM,GAAG,EAAE;AAAA,EAErB,IAAI,eAAe;AAAA,EAEnB,SAAS,IAAI,EAAG,IAAI,IAAI,QAAQ,KAAK;AAAA,IACnC,MAAM,eAAe,kBAAkB,IAAI;AAAA,IAC3C,MAAM,cAAc,aAAa,SAAS,CAAC,EAAE,SAAS,GAAG,GAAG;AAAA,IAC5D,gBAAgB;AAAA,EAClB;AAAA,EAEA,IAAI,eAAe,GAAG;AAAA,IACpB,eAAe,aAAa,MAAM,GAAG,CAAC,YAAY;AAAA,EACpD;AAAA,EAEA,IAAI,gBAAgB;AAAA,EACpB,MAAM,WAAW;AAAA,EAEjB,SAAS,IAAI,EAAG,IAAI,aAAa,QAAQ,KAAK,UAAU;AAAA,IACtD,MAAM,OAAO,aAAa,UAAU,GAAG,IAAI,QAAQ;AAAA,IACnD,IAAI,KAAK,WAAW,IAAI;AAAA,MACtB,MAAM,WAAW,SAAS,MAAM,CAAC;AAAA,MACjC,iBAAiB,OAAO,aAAa,QAAQ;AAAA,IAC/C;AAAA,EACF;AAAA,EAEA,OAAO,cAAc,MAAM,SAAS;AAAA;;;AC1EtC,IAAM,qBAAqB,IAAI,IAAI,CAAC,KAAK,KAAK,GAAG,CAAC;AAAA;AAQ3C,MAAM,iCAAiC,MAAM;AAAA,EAEhC;AAAA,EADlB,WAAW,CACO,QAChB,SACA;AAAA,IACA,MACE,uEACA,OACF;AAAA,IANgB;AAAA,IAOhB,KAAK,OAAO;AAAA;AAEhB;AAEO,SAAS,mBAAmB,CAAC,QAAyB;AAAA,EAC3D,OAAO,mBAAmB,IAAI,MAAM;AAAA;AAQ/B,SAAS,eAAe,CAAC,UAA0B;AAAA,EACxD,IAAI,oBAAoB,SAAS,MAAM,GAAG;AAAA,IACxC,MAAM,IAAI,yBAAyB,SAAS,MAAM;AAAA,EACpD;AAAA;AASF,eAAsB,cAAc,CAClC,OACA,MACmB;AAAA,EACnB,IAAI;AAAA,EACJ,IAAI;AAAA,IACF,WAAW,MAAM,MAAM,OAAO,IAAI;AAAA,IAClC,OAAO,OAAO;AAAA,IACd,MAAM,IAAI,yBAAyB,WAAW,EAAE,OAAO,MAAM,CAAC;AAAA;AAAA,EAEhE,gBAAgB,QAAQ;AAAA,EACxB,OAAO;AAAA;",
-  "debugId": "BB37885AF7B09DA164756E2164756E21",
-  "names": []
-}