@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/runtime/resume-latency.d.ts

@@ -0,0 +1,150 @@
+import type { HookResumeTiming } from '@workflow/world';
+/**
+ * Hook-triggered time-to-resume (TTR): wall-clock from entry into
+ * `resumeHook()` (T0) to the first line of the next durable step (T7), plus a
+ * decomposition into non-overlapping phases that sum exactly to it.
+ *
+ * ```text
+ * T0 resumeHook() entered
+ *      producer_prep   : hook lookup, serialization, encryption
+ * T1 queue publish requested
+ *      queue_delivery  : network + VQS delivery (incl. any affinity re-route)
+ * T2 final consumer's queue handler entered
+ *      resume_setup    : affinity check, hook_received re-ensure, replay preload
+ * T3 replay begins
+ *      replay          : VM/session creation and workflow replay
+ * T4 next durable step encountered
+ *      step_dispatch   : suspension handling, inline batch or queue dispatch
+ * T5 step_started request begins
+ *      step_claim      : the claim round trip
+ * T6 step_started response returned
+ *      step_prepare    : key resolution, argument hydration, context setup
+ * T7 immediately before stepFn.apply()
+ * ```
+ *
+ * The producer's `hook_received` write is awaited inside `producer_prep`
+ * (the wake is only published after it commits). Older producers may report
+ * `lazy`, where the consumer materializes the event from `hookInput`, or
+ * `parallel`, where the write raced the publish. The write has no phase of
+ * its own; it remains visible as a contextual span (`hook.resume`).
+ *
+ * T0/T1 are stamped on the producer's machine and T2..T7 on the consumer's, so
+ * the measurement is subject to cross-machine clock skew. Rather than clamp
+ * (which would break the sum-equals-total property this decomposition exists
+ * for), a non-monotonic boundary set drops the whole sample; see
+ * {@link computeResumeTtrAttributes}.
+ */
+/** What caused the resumption being measured. Only hooks are measured today. */
+export type ResumeTrigger = 'hook';
+/**
+ * Which `resumeHook()` dispatch path produced this resume.
+ *
+ * Current producers always send `sequential` (durable write, then wake).
+ * Older producers may send `lazy` (the consumer materializes the event from
+ * `hookInput`) or `parallel` (the write raced the publish).
+ */
+export type ResumeStrategy = 'lazy' | 'parallel' | 'sequential';
+/**
+ * How the consuming invocation initialized its replay state:
+ *
+ * - `hook_preload`: the hoisted `hook_received` write returned a usable
+ *   replay preload, so neither `run_started` nor the initial `events.list` ran.
+ * - `run_started`: the generic `run_started` setup ran (including the fast
+ *   path's fallback, where the hoisted write succeeded but returned no usable
+ *   preload).
+ * - `event_load`: neither setup ran because the run arrived already loaded,
+ *   so setup was a plain event load. No current path produces it (the one
+ *   preloaded-run path, the background-step fall-through, consumes the
+ *   tracking on its own step first); it is the honest default rather than a
+ *   live value, and keeps the dimension total if such a path is added.
+ */
+export type ResumeSetupSource = 'hook_preload' | 'run_started' | 'event_load';
+/** Whether the measured step ran in the resuming invocation or a queued one. */
+export type ResumeStepExecution = 'inline' | 'dispatched';
+/**
+ * The resume boundaries observed so far, threaded from the queue handler into
+ * `executeStep`. Producer fields arrive on the queue message
+ * ({@link HookResumeTiming}); consumer fields are stamped by the invocation
+ * that replays the resume.
+ *
+ * The runtime holds at most one of these per invocation and CONSUMES it when
+ * it hands it to the execution that will attempt the next durable step, so a
+ * later step in the same invocation (or a retry of the same step) never
+ * re-reports the same resumption. Within one inline batch the object is
+ * shared by every step and the {@link ResumeTtrTracking.reported} latch picks
+ * the single reporter.
+ */
+export interface ResumeTtrTracking {
+    trigger: ResumeTrigger;
+    /** Absent only if an older producer omitted it from the queue message. */
+    strategy?: ResumeStrategy;
+    /** T0: entry into `resumeHook()`. */
+    resumeRequestedAtMs: number;
+    /** T1: immediately before the queue publish was requested. */
+    queuePublishRequestedAtMs: number;
+    /**
+     * T2: entry into the FINAL consumer's queue handler. A delivery that
+     * re-routes for deployment affinity never stamps this, so the re-routed hop
+     * stays inside `queue_delivery` where it belongs.
+     */
+    consumerStartedAtMs: number;
+    /** T3: this invocation's first replay pass. */
+    replayStartedAtMs?: number;
+    /** T4: replay first encountered a durable step after the resume. */
+    nextStepEncounteredAtMs?: number;
+    setupSource?: ResumeSetupSource;
+    stepExecution: ResumeStepExecution;
+    /**
+     * One-shot latch, set by the step executor once this resumption has been
+     * reported. Every step of an inline batch is handed the SAME tracking
+     * object, so the first one to reach user code takes the measurement and the
+     * rest see this and skip: one resumption, one sample, without pinning the
+     * sample to a step that may lose its create-claim and never run.
+     *
+     * Deliberately not part of {@link HookResumeTiming}: it is invocation-local
+     * state, and a queue message carries the boundaries, not the claim.
+     */
+    reported?: boolean;
+}
+/**
+ * Rebuild tracking from a queue message's timing object. Returns undefined for
+ * a message that carries none (an older producer, or any non-hook delivery);
+ * the caller then reports no TTR.
+ */
+export declare function resumeTrackingFromMessage(timing: HookResumeTiming | undefined, stepExecution: ResumeStepExecution): ResumeTtrTracking | undefined;
+/**
+ * Serialize tracking back onto a queue message, for the case where the
+ * resuming invocation dispatches the next durable step to another invocation
+ * instead of running it inline. Returns undefined when the tracking is not
+ * complete enough to be worth forwarding.
+ */
+export declare function resumeTimingForMessage(tracking: ResumeTtrTracking | undefined): HookResumeTiming | undefined;
+/**
+ * Compute the TTR span attributes for a step that is the first durable step
+ * following a hook resume. Returns undefined (emitting nothing at all) when
+ * any of these hold:
+ *
+ * - the invocation carries no resume tracking (not a hook resume, or an older
+ *   queue message with no timing);
+ * - this is a retry (`attempt !== 1`), which measures a re-execution rather
+ *   than the resumption;
+ * - a required boundary is missing, non-finite, or out of order.
+ *
+ * `step_claim_ms` is the one phase that may be individually omitted. Under
+ * optimistic inline start the `step_started` claim is deliberately NOT awaited
+ * before the body runs, so its completion instant does not exist yet at T7;
+ * rather than invent one, the claim phase is dropped and `step_prepare_ms`
+ * spans T5→T7. The sum-equals-total property holds either way.
+ */
+export declare function computeResumeTtrAttributes(params: {
+    tracking: ResumeTtrTracking | undefined;
+    /** The attempt number of the execution about to run. */
+    attempt: number;
+    /** T5: `Date.now()` immediately before the `step_started` request. */
+    stepClaimStartedAtMs: number | undefined;
+    /** T6: `Date.now()` once the `step_started` response returned. */
+    stepClaimCompletedAtMs: number | undefined;
+    /** T7: `Date.now()` immediately before `stepFn.apply()`. */
+    stepCodeStartedAtMs: number;
+}): Record<string, string | number> | undefined;
+//# sourceMappingURL=resume-latency.d.ts.map

package/dist/runtime/resume-latency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume-latency.d.ts","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,UAAU,GAAG,YAAY,CAAC;AAEhE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG,aAAa,GAAG,YAAY,CAAC;AAE9E,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,YAAY,CAAC;AAE1D;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,aAAa,CAAC;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,qCAAqC;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,yBAAyB,EAAE,MAAM,CAAC;IAClC;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAC5B,+CAA+C;IAC/C,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,oEAAoE;IACpE,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,WAAW,CAAC,EAAE,iBAAiB,CAAC;IAChC,aAAa,EAAE,mBAAmB,CAAC;IACnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,gBAAgB,GAAG,SAAS,EACpC,aAAa,EAAE,mBAAmB,GACjC,iBAAiB,GAAG,SAAS,CAkC/B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,GACtC,gBAAgB,GAAG,SAAS,CAkB9B;AA6CD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE;IACjD,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACxC,wDAAwD;IACxD,OAAO,EAAE,MAAM,CAAC;IAChB,sEAAsE;IACtE,oBAAoB,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,kEAAkE;IAClE,sBAAsB,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C,4DAA4D;IAC5D,mBAAmB,EAAE,MAAM,CAAC;CAC7B,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,SAAS,CAoD9C"}

package/dist/runtime/resume-latency.js

@@ -0,0 +1,155 @@
+import * as Attribute from '../telemetry/semantic-conventions.js';
+/**
+ * Rebuild tracking from a queue message's timing object. Returns undefined for
+ * a message that carries none (an older producer, or any non-hook delivery);
+ * the caller then reports no TTR.
+ */
+export function resumeTrackingFromMessage(timing, stepExecution) {
+    if (!timing)
+        return undefined;
+    if (!Number.isFinite(timing.resumeRequestedAtMs) ||
+        !Number.isFinite(timing.queuePublishRequestedAtMs)) {
+        return undefined;
+    }
+    return {
+        trigger: 'hook',
+        ...(timing.strategy === 'lazy' ||
+            timing.strategy === 'parallel' ||
+            timing.strategy === 'sequential'
+            ? { strategy: timing.strategy }
+            : {}),
+        resumeRequestedAtMs: timing.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,
+        // A dispatched step reads the resuming invocation's boundaries off the
+        // message; an inline one has them stamped locally by the caller, which
+        // overwrites this placeholder immediately after construction.
+        consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,
+        ...(timing.replayStartedAtMs !== undefined
+            ? { replayStartedAtMs: timing.replayStartedAtMs }
+            : {}),
+        ...(timing.nextStepEncounteredAtMs !== undefined
+            ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs }
+            : {}),
+        ...(timing.setupSource === 'hook_preload' ||
+            timing.setupSource === 'run_started' ||
+            timing.setupSource === 'event_load'
+            ? { setupSource: timing.setupSource }
+            : {}),
+        stepExecution,
+    };
+}
+/**
+ * Serialize tracking back onto a queue message, for the case where the
+ * resuming invocation dispatches the next durable step to another invocation
+ * instead of running it inline. Returns undefined when the tracking is not
+ * complete enough to be worth forwarding.
+ */
+export function resumeTimingForMessage(tracking) {
+    if (!tracking)
+        return undefined;
+    if (!Number.isFinite(tracking.consumerStartedAtMs))
+        return undefined;
+    return {
+        resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+        ...(tracking.strategy !== undefined ? { strategy: tracking.strategy } : {}),
+        consumerStartedAtMs: tracking.consumerStartedAtMs,
+        ...(tracking.replayStartedAtMs !== undefined
+            ? { replayStartedAtMs: tracking.replayStartedAtMs }
+            : {}),
+        ...(tracking.nextStepEncounteredAtMs !== undefined
+            ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs }
+            : {}),
+        ...(tracking.setupSource !== undefined
+            ? { setupSource: tracking.setupSource }
+            : {}),
+    };
+}
+/**
+ * Validate that every required boundary is a finite epoch-ms value and that
+ * the whole sequence is non-decreasing. Returns undefined otherwise, which
+ * suppresses the metric entirely rather than reporting a phase that never
+ * happened or a negative duration.
+ */
+function validateBoundaries(b) {
+    const ordered = [
+        b.resumeRequestedAtMs,
+        b.queuePublishRequestedAtMs,
+        b.consumerStartedAtMs,
+        b.replayStartedAtMs,
+        b.nextStepEncounteredAtMs,
+        b.stepClaimStartedAtMs,
+        ...(b.stepClaimCompletedAtMs !== undefined
+            ? [b.stepClaimCompletedAtMs]
+            : []),
+        b.stepCodeStartedAtMs,
+    ];
+    for (const value of ordered) {
+        if (typeof value !== 'number' || !Number.isFinite(value))
+            return undefined;
+    }
+    for (let i = 1; i < ordered.length; i++) {
+        if (ordered[i] < ordered[i - 1])
+            return undefined;
+    }
+    return ordered;
+}
+/**
+ * Compute the TTR span attributes for a step that is the first durable step
+ * following a hook resume. Returns undefined (emitting nothing at all) when
+ * any of these hold:
+ *
+ * - the invocation carries no resume tracking (not a hook resume, or an older
+ *   queue message with no timing);
+ * - this is a retry (`attempt !== 1`), which measures a re-execution rather
+ *   than the resumption;
+ * - a required boundary is missing, non-finite, or out of order.
+ *
+ * `step_claim_ms` is the one phase that may be individually omitted. Under
+ * optimistic inline start the `step_started` claim is deliberately NOT awaited
+ * before the body runs, so its completion instant does not exist yet at T7;
+ * rather than invent one, the claim phase is dropped and `step_prepare_ms`
+ * spans T5→T7. The sum-equals-total property holds either way.
+ */
+export function computeResumeTtrAttributes(params) {
+    const { tracking } = params;
+    if (!tracking || params.attempt !== 1)
+        return undefined;
+    if (tracking.replayStartedAtMs === undefined ||
+        tracking.nextStepEncounteredAtMs === undefined ||
+        params.stepClaimStartedAtMs === undefined) {
+        return undefined;
+    }
+    const boundaries = {
+        resumeRequestedAtMs: tracking.resumeRequestedAtMs,
+        queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,
+        consumerStartedAtMs: tracking.consumerStartedAtMs,
+        replayStartedAtMs: tracking.replayStartedAtMs,
+        nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,
+        stepClaimStartedAtMs: params.stepClaimStartedAtMs,
+        stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,
+        stepCodeStartedAtMs: params.stepCodeStartedAtMs,
+    };
+    if (!validateBoundaries(boundaries))
+        return undefined;
+    const { resumeRequestedAtMs: t0, queuePublishRequestedAtMs: t1, consumerStartedAtMs: t2, replayStartedAtMs: t3, nextStepEncounteredAtMs: t4, stepClaimStartedAtMs: t5, stepClaimCompletedAtMs: t6, stepCodeStartedAtMs: t7, } = boundaries;
+    return {
+        ...Attribute.ResumeTotalMs(t7 - t0),
+        ...Attribute.ResumeProducerPrepMs(t1 - t0),
+        ...Attribute.ResumeQueueDeliveryMs(t2 - t1),
+        ...Attribute.ResumeSetupMs(t3 - t2),
+        ...Attribute.ResumeReplayMs(t4 - t3),
+        ...Attribute.ResumeStepDispatchMs(t5 - t4),
+        ...(t6 !== undefined ? Attribute.ResumeStepClaimMs(t6 - t5) : {}),
+        ...Attribute.ResumeStepPrepareMs(t7 - (t6 ?? t5)),
+        ...Attribute.ResumeTrigger(tracking.trigger),
+        ...(tracking.strategy !== undefined
+            ? Attribute.ResumeStrategy(tracking.strategy)
+            : {}),
+        ...(tracking.setupSource !== undefined
+            ? Attribute.ResumeSetupSource(tracking.setupSource)
+            : {}),
+        ...Attribute.ResumeStepExecution(tracking.stepExecution),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resume-latency.js","sourceRoot":"","sources":["../../src/runtime/resume-latency.ts"],"names":[],"mappings":"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","sourcesContent":["import type { HookResumeTiming } from '@workflow/world';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\n\n/**\n * Hook-triggered time-to-resume (TTR): wall-clock from entry into\n * `resumeHook()` (T0) to the first line of the next durable step (T7), plus a\n * decomposition into non-overlapping phases that sum exactly to it.\n *\n * ```text\n * T0 resumeHook() entered\n *      producer_prep   : hook lookup, serialization, encryption\n * T1 queue publish requested\n *      queue_delivery  : network + VQS delivery (incl. any affinity re-route)\n * T2 final consumer's queue handler entered\n *      resume_setup    : affinity check, hook_received re-ensure, replay preload\n * T3 replay begins\n *      replay          : VM/session creation and workflow replay\n * T4 next durable step encountered\n *      step_dispatch   : suspension handling, inline batch or queue dispatch\n * T5 step_started request begins\n *      step_claim      : the claim round trip\n * T6 step_started response returned\n *      step_prepare    : key resolution, argument hydration, context setup\n * T7 immediately before stepFn.apply()\n * ```\n *\n * The producer's `hook_received` write is awaited inside `producer_prep`\n * (the wake is only published after it commits). Older producers may report\n * `lazy`, where the consumer materializes the event from `hookInput`, or\n * `parallel`, where the write raced the publish. The write has no phase of\n * its own; it remains visible as a contextual span (`hook.resume`).\n *\n * T0/T1 are stamped on the producer's machine and T2..T7 on the consumer's, so\n * the measurement is subject to cross-machine clock skew. Rather than clamp\n * (which would break the sum-equals-total property this decomposition exists\n * for), a non-monotonic boundary set drops the whole sample; see\n * {@link computeResumeTtrAttributes}.\n */\n\n/** What caused the resumption being measured. Only hooks are measured today. */\nexport type ResumeTrigger = 'hook';\n\n/**\n * Which `resumeHook()` dispatch path produced this resume.\n *\n * Current producers always send `sequential` (durable write, then wake).\n * Older producers may send `lazy` (the consumer materializes the event from\n * `hookInput`) or `parallel` (the write raced the publish).\n */\nexport type ResumeStrategy = 'lazy' | 'parallel' | 'sequential';\n\n/**\n * How the consuming invocation initialized its replay state:\n *\n * - `hook_preload`: the hoisted `hook_received` write returned a usable\n *   replay preload, so neither `run_started` nor the initial `events.list` ran.\n * - `run_started`: the generic `run_started` setup ran (including the fast\n *   path's fallback, where the hoisted write succeeded but returned no usable\n *   preload).\n * - `event_load`: neither setup ran because the run arrived already loaded,\n *   so setup was a plain event load. No current path produces it (the one\n *   preloaded-run path, the background-step fall-through, consumes the\n *   tracking on its own step first); it is the honest default rather than a\n *   live value, and keeps the dimension total if such a path is added.\n */\nexport type ResumeSetupSource = 'hook_preload' | 'run_started' | 'event_load';\n\n/** Whether the measured step ran in the resuming invocation or a queued one. */\nexport type ResumeStepExecution = 'inline' | 'dispatched';\n\n/**\n * The resume boundaries observed so far, threaded from the queue handler into\n * `executeStep`. Producer fields arrive on the queue message\n * ({@link HookResumeTiming}); consumer fields are stamped by the invocation\n * that replays the resume.\n *\n * The runtime holds at most one of these per invocation and CONSUMES it when\n * it hands it to the execution that will attempt the next durable step, so a\n * later step in the same invocation (or a retry of the same step) never\n * re-reports the same resumption. Within one inline batch the object is\n * shared by every step and the {@link ResumeTtrTracking.reported} latch picks\n * the single reporter.\n */\nexport interface ResumeTtrTracking {\n  trigger: ResumeTrigger;\n  /** Absent only if an older producer omitted it from the queue message. */\n  strategy?: ResumeStrategy;\n  /** T0: entry into `resumeHook()`. */\n  resumeRequestedAtMs: number;\n  /** T1: immediately before the queue publish was requested. */\n  queuePublishRequestedAtMs: number;\n  /**\n   * T2: entry into the FINAL consumer's queue handler. A delivery that\n   * re-routes for deployment affinity never stamps this, so the re-routed hop\n   * stays inside `queue_delivery` where it belongs.\n   */\n  consumerStartedAtMs: number;\n  /** T3: this invocation's first replay pass. */\n  replayStartedAtMs?: number;\n  /** T4: replay first encountered a durable step after the resume. */\n  nextStepEncounteredAtMs?: number;\n  setupSource?: ResumeSetupSource;\n  stepExecution: ResumeStepExecution;\n  /**\n   * One-shot latch, set by the step executor once this resumption has been\n   * reported. Every step of an inline batch is handed the SAME tracking\n   * object, so the first one to reach user code takes the measurement and the\n   * rest see this and skip: one resumption, one sample, without pinning the\n   * sample to a step that may lose its create-claim and never run.\n   *\n   * Deliberately not part of {@link HookResumeTiming}: it is invocation-local\n   * state, and a queue message carries the boundaries, not the claim.\n   */\n  reported?: boolean;\n}\n\n/**\n * Rebuild tracking from a queue message's timing object. Returns undefined for\n * a message that carries none (an older producer, or any non-hook delivery);\n * the caller then reports no TTR.\n */\nexport function resumeTrackingFromMessage(\n  timing: HookResumeTiming | undefined,\n  stepExecution: ResumeStepExecution\n): ResumeTtrTracking | undefined {\n  if (!timing) return undefined;\n  if (\n    !Number.isFinite(timing.resumeRequestedAtMs) ||\n    !Number.isFinite(timing.queuePublishRequestedAtMs)\n  ) {\n    return undefined;\n  }\n  return {\n    trigger: 'hook',\n    ...(timing.strategy === 'lazy' ||\n    timing.strategy === 'parallel' ||\n    timing.strategy === 'sequential'\n      ? { strategy: timing.strategy }\n      : {}),\n    resumeRequestedAtMs: timing.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: timing.queuePublishRequestedAtMs,\n    // A dispatched step reads the resuming invocation's boundaries off the\n    // message; an inline one has them stamped locally by the caller, which\n    // overwrites this placeholder immediately after construction.\n    consumerStartedAtMs: timing.consumerStartedAtMs ?? Number.NaN,\n    ...(timing.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: timing.replayStartedAtMs }\n      : {}),\n    ...(timing.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: timing.nextStepEncounteredAtMs }\n      : {}),\n    ...(timing.setupSource === 'hook_preload' ||\n    timing.setupSource === 'run_started' ||\n    timing.setupSource === 'event_load'\n      ? { setupSource: timing.setupSource }\n      : {}),\n    stepExecution,\n  };\n}\n\n/**\n * Serialize tracking back onto a queue message, for the case where the\n * resuming invocation dispatches the next durable step to another invocation\n * instead of running it inline. Returns undefined when the tracking is not\n * complete enough to be worth forwarding.\n */\nexport function resumeTimingForMessage(\n  tracking: ResumeTtrTracking | undefined\n): HookResumeTiming | undefined {\n  if (!tracking) return undefined;\n  if (!Number.isFinite(tracking.consumerStartedAtMs)) return undefined;\n  return {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    ...(tracking.strategy !== undefined ? { strategy: tracking.strategy } : {}),\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    ...(tracking.replayStartedAtMs !== undefined\n      ? { replayStartedAtMs: tracking.replayStartedAtMs }\n      : {}),\n    ...(tracking.nextStepEncounteredAtMs !== undefined\n      ? { nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs }\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? { setupSource: tracking.setupSource }\n      : {}),\n  };\n}\n\n/** Every boundary the emission gate requires, plus the optional claim end. */\ninterface ResumeBoundaries {\n  /** T0 */ resumeRequestedAtMs: number;\n  /** T1 */ queuePublishRequestedAtMs: number;\n  /** T2 */ consumerStartedAtMs: number;\n  /** T3 */ replayStartedAtMs: number;\n  /** T4 */ nextStepEncounteredAtMs: number;\n  /** T5 */ stepClaimStartedAtMs: number;\n  /** T6: absent on the optimistic-start path; see below. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7 */ stepCodeStartedAtMs: number;\n}\n\n/**\n * Validate that every required boundary is a finite epoch-ms value and that\n * the whole sequence is non-decreasing. Returns undefined otherwise, which\n * suppresses the metric entirely rather than reporting a phase that never\n * happened or a negative duration.\n */\nfunction validateBoundaries(\n  b: ResumeBoundaries\n): readonly number[] | undefined {\n  const ordered = [\n    b.resumeRequestedAtMs,\n    b.queuePublishRequestedAtMs,\n    b.consumerStartedAtMs,\n    b.replayStartedAtMs,\n    b.nextStepEncounteredAtMs,\n    b.stepClaimStartedAtMs,\n    ...(b.stepClaimCompletedAtMs !== undefined\n      ? [b.stepClaimCompletedAtMs]\n      : []),\n    b.stepCodeStartedAtMs,\n  ];\n  for (const value of ordered) {\n    if (typeof value !== 'number' || !Number.isFinite(value)) return undefined;\n  }\n  for (let i = 1; i < ordered.length; i++) {\n    if (ordered[i] < ordered[i - 1]) return undefined;\n  }\n  return ordered;\n}\n\n/**\n * Compute the TTR span attributes for a step that is the first durable step\n * following a hook resume. Returns undefined (emitting nothing at all) when\n * any of these hold:\n *\n * - the invocation carries no resume tracking (not a hook resume, or an older\n *   queue message with no timing);\n * - this is a retry (`attempt !== 1`), which measures a re-execution rather\n *   than the resumption;\n * - a required boundary is missing, non-finite, or out of order.\n *\n * `step_claim_ms` is the one phase that may be individually omitted. Under\n * optimistic inline start the `step_started` claim is deliberately NOT awaited\n * before the body runs, so its completion instant does not exist yet at T7;\n * rather than invent one, the claim phase is dropped and `step_prepare_ms`\n * spans T5→T7. The sum-equals-total property holds either way.\n */\nexport function computeResumeTtrAttributes(params: {\n  tracking: ResumeTtrTracking | undefined;\n  /** The attempt number of the execution about to run. */\n  attempt: number;\n  /** T5: `Date.now()` immediately before the `step_started` request. */\n  stepClaimStartedAtMs: number | undefined;\n  /** T6: `Date.now()` once the `step_started` response returned. */\n  stepClaimCompletedAtMs: number | undefined;\n  /** T7: `Date.now()` immediately before `stepFn.apply()`. */\n  stepCodeStartedAtMs: number;\n}): Record<string, string | number> | undefined {\n  const { tracking } = params;\n  if (!tracking || params.attempt !== 1) return undefined;\n  if (\n    tracking.replayStartedAtMs === undefined ||\n    tracking.nextStepEncounteredAtMs === undefined ||\n    params.stepClaimStartedAtMs === undefined\n  ) {\n    return undefined;\n  }\n\n  const boundaries: ResumeBoundaries = {\n    resumeRequestedAtMs: tracking.resumeRequestedAtMs,\n    queuePublishRequestedAtMs: tracking.queuePublishRequestedAtMs,\n    consumerStartedAtMs: tracking.consumerStartedAtMs,\n    replayStartedAtMs: tracking.replayStartedAtMs,\n    nextStepEncounteredAtMs: tracking.nextStepEncounteredAtMs,\n    stepClaimStartedAtMs: params.stepClaimStartedAtMs,\n    stepClaimCompletedAtMs: params.stepClaimCompletedAtMs,\n    stepCodeStartedAtMs: params.stepCodeStartedAtMs,\n  };\n  if (!validateBoundaries(boundaries)) return undefined;\n\n  const {\n    resumeRequestedAtMs: t0,\n    queuePublishRequestedAtMs: t1,\n    consumerStartedAtMs: t2,\n    replayStartedAtMs: t3,\n    nextStepEncounteredAtMs: t4,\n    stepClaimStartedAtMs: t5,\n    stepClaimCompletedAtMs: t6,\n    stepCodeStartedAtMs: t7,\n  } = boundaries;\n\n  return {\n    ...Attribute.ResumeTotalMs(t7 - t0),\n    ...Attribute.ResumeProducerPrepMs(t1 - t0),\n    ...Attribute.ResumeQueueDeliveryMs(t2 - t1),\n    ...Attribute.ResumeSetupMs(t3 - t2),\n    ...Attribute.ResumeReplayMs(t4 - t3),\n    ...Attribute.ResumeStepDispatchMs(t5 - t4),\n    ...(t6 !== undefined ? Attribute.ResumeStepClaimMs(t6 - t5) : {}),\n    ...Attribute.ResumeStepPrepareMs(t7 - (t6 ?? t5)),\n    ...Attribute.ResumeTrigger(tracking.trigger),\n    ...(tracking.strategy !== undefined\n      ? Attribute.ResumeStrategy(tracking.strategy)\n      : {}),\n    ...(tracking.setupSource !== undefined\n      ? Attribute.ResumeSetupSource(tracking.setupSource)\n      : {}),\n    ...Attribute.ResumeStepExecution(tracking.stepExecution),\n  };\n}\n"]}

package/dist/runtime/run-id-time.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Extracts the run's creation timestamp (epoch milliseconds) from a `wrun_`
+ * run ID by decoding the embedded ULID time component.
+ *
+ * `@workflow/world-vercel`'s region-tagged run IDs mark an ID as carrying
+ * metadata by setting the most-significant bit of the ULID's 48-bit
+ * timestamp, which would otherwise skew the decoded time past the year 6400.
+ * The tag-bit handling is delegated to the scheme's own codec
+ * (`decode()` returns the ULID with the tag bit cleared), so if the tagged
+ * layout ever evolves (the scheme carries a 5-bit version field for exactly
+ * that), this anchor keeps tracking the codec instead of silently diverging.
+ * For untagged input `decode()` is a passthrough.
+ *
+ * Returns `undefined` when `runId` is not a decodable `wrun_<ulid>` (e.g. a
+ * legacy/non-ULID id, or a test fixture like `wrun_test`); callers fall back to
+ * an authoritative timestamp from the run snapshot (`createdAt`) in that case.
+ */
+export declare function runIdCreatedAt(runId: string): number | undefined;
+//# sourceMappingURL=run-id-time.d.ts.map

package/dist/runtime/run-id-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-id-time.d.ts","sourceRoot":"","sources":["../../src/runtime/run-id-time.ts"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAShE"}

package/dist/runtime/run-id-time.js

@@ -0,0 +1,42 @@
+import { decode } from '@workflow/world-vercel/run-id';
+import { decodeTime } from 'ulid';
+/**
+ * Run IDs are minted client-side in `start()` as `wrun_<ulid>` (via
+ * `World.createRunId()` when the world provides one, else a plain ULID; see
+ * `runtime/helpers.ts`). A ULID encodes its creation time in its first 48 bits,
+ * so the run's creation timestamp is recoverable from the run ID alone,
+ * without any server round-trip or run-snapshot load. This is the earliest
+ * replay-stable timestamp a delivery has (the run ID arrives in the queue
+ * payload), which lets the workflow VM be seeded and clock-initialized before
+ * `run_started`.
+ */
+const RUN_ID_PREFIX = 'wrun_';
+/**
+ * Extracts the run's creation timestamp (epoch milliseconds) from a `wrun_`
+ * run ID by decoding the embedded ULID time component.
+ *
+ * `@workflow/world-vercel`'s region-tagged run IDs mark an ID as carrying
+ * metadata by setting the most-significant bit of the ULID's 48-bit
+ * timestamp, which would otherwise skew the decoded time past the year 6400.
+ * The tag-bit handling is delegated to the scheme's own codec
+ * (`decode()` returns the ULID with the tag bit cleared), so if the tagged
+ * layout ever evolves (the scheme carries a 5-bit version field for exactly
+ * that), this anchor keeps tracking the codec instead of silently diverging.
+ * For untagged input `decode()` is a passthrough.
+ *
+ * Returns `undefined` when `runId` is not a decodable `wrun_<ulid>` (e.g. a
+ * legacy/non-ULID id, or a test fixture like `wrun_test`); callers fall back to
+ * an authoritative timestamp from the run snapshot (`createdAt`) in that case.
+ */
+export function runIdCreatedAt(runId) {
+    const ulidPart = runId.startsWith(RUN_ID_PREFIX)
+        ? runId.slice(RUN_ID_PREFIX.length)
+        : runId;
+    try {
+        return decodeTime(decode(ulidPart).ulid);
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/run.d.ts

@@ -1,6 +1,25 @@
 import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
-import { type WorkflowRunStatus } from '@workflow/world';
-import { type StopSleepOptions, type StopSleepResult } from './runs.js';
+import type { WorkflowRunStatus } from '@workflow/world';
+import { type CancelRunOptions, type StopSleepOptions, type StopSleepResult } from './runs.js';
+/** @internal */
+export declare function getReturnValuePollIntervalMs(): number;
+/** @internal */
+export declare function getReturnValueWaitTimeoutMs(): number;
+/** @internal */
+export declare function getReturnValueMaxLongPolls(): number;
+/**
+ * Whether `await run.returnValue` may use the World's long poll
+ * (`runs.waitForTerminalStatus`) instead of interval-polling `runs.get`.
+ *
+ * Default **ON** wherever the World implements the method; a World that does
+ * not is already on the interval path with nothing to switch off. Reads
+ * `process.env.WORKFLOW_RETURN_VALUE_LONG_POLL` lazily; an explicit `'0'` /
+ * `'false'` is the kill switch, restoring the fixed-interval poll exactly as
+ * it behaved before the fast path existed.
+ *
+ * @internal
+ */
+export declare function isReturnValueLongPollEnabled(): boolean;
 /**
  * A `ReadableStream` extended with workflow-specific helpers.
  */
@@ -8,7 +27,7 @@ export type WorkflowReadableStream<R = any> = ReadableStream<R> & {
     /**
      * Returns the tail index (index of the last known chunk, 0-based) of the
      * underlying workflow stream. Useful for resolving a negative `startIndex`
-     * into an absolute position — for example, when building reconnection
+     * into an absolute position, for example, when building reconnection
      * endpoints that need to inform the client where the stream starts.
      *
      * Returns `-1` when no chunks have been written yet.
@@ -30,8 +49,8 @@ export interface WorkflowReadableStreamOptions {
      */
     startIndex?: number;
     /**
-     * Any asynchronous operations that need to be performed before the execution
-     * environment is paused / terminated
+     * Any asynchronous operations to complete before pausing or terminating the
+     * execution environment
      * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).
      */
     ops?: Promise<any>[];
@@ -42,6 +61,32 @@ export interface WorkflowReadableStreamOptions {
      */
     global?: Record<string, any>;
 }
+/**
+ * Options for configuring a writable onto a workflow run's stream.
+ */
+export interface WorkflowRunWritableStreamOptions {
+    /**
+     * An optional namespace to distinguish between multiple streams associated
+     * with the same workflow run.
+     */
+    namespace?: string;
+    /**
+     * Any asynchronous operations to complete before pausing or terminating the
+     * execution environment
+     * (i.e. using [`waitUntil()`](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) or similar).
+     *
+     * Writes are acknowledged on buffer entry, so a caller that needs them
+     * durable before the environment goes away should pass an array here and
+     * await it after releasing the writer lock.
+     */
+    ops?: Promise<any>[];
+    /**
+     * The global object to use for reducing types from the global scope.
+     *
+     * Defaults to {@link [`globalThis`](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/globalThis)}.
+     */
+    global?: Record<string, any>;
+}
 /**
  * A handler class for a workflow run.
  */
@@ -72,8 +117,12 @@ export declare class Run<TResult> {
     wakeUp(options?: StopSleepOptions): Promise<StopSleepResult>;
     /**
      * Cancels the workflow run.
+     *
+     * @param options - Optional cancellation settings. `cancelReason` records a
+     *   free-text reason (max 512 chars) on the run_cancelled event, surfaced in
+     *   the run detail view.
      */
-    cancel(): Promise<void>;
+    cancel(options?: CancelRunOptions): Promise<void>;
     /**
      * Whether the workflow run exists.
      */
@@ -84,7 +133,7 @@ export declare class Run<TResult> {
     get status(): Promise<WorkflowRunStatus>;
     /**
      * The return value of the workflow run.
-     * Polls the workflow return value until it is completed.
+     * Polls the workflow return value until the workflow run completes.
      */
     get returnValue(): Promise<TResult>;
     /**
@@ -122,6 +171,22 @@ export declare class Run<TResult> {
      * @returns A `WorkflowReadableStream` for the workflow run.
      */
     getReadable<R = any>(options?: WorkflowReadableStreamOptions): WorkflowReadableStream<R>;
+    /** The writable stream of the workflow run. */
+    get writable(): WritableStream;
+    /**
+     * Returns a writable that appends to this run's stream.
+     *
+     * Initialization is deferred until the first write. The run must already
+     * exist. The writable may be forwarded through `start()` and into steps, but
+     * grants no read access or additional authorization.
+     *
+     * @remarks
+     * `writer.close()` closes the shared stream. Contributors should call
+     * `releaseLock()`, which also drains pending writes.
+     *
+     * @param options - The writable stream options.
+     */
+    getWritable<W = any>(options?: WorkflowRunWritableStreamOptions): WritableStream<W>;
 }
 /**
  * Retrieves a `Run` object for a given run ID.

package/dist/runtime/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,EAEL,KAAK,iBAAiB,EAEvB,MAAM,iBAAiB,CAAC;AAQzB,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAGnB;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,GAAG,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG;IAChE;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,qBAAa,GAAG,CAAC,OAAO;;IACtB,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;;;;IAIlD,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAID;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;gBA4BF,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE;IAuB9D;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKlE;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAS7B;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAa7B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAKvC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGlC;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAKlC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAKzC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAK3C;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,6BAAkC,GAC1C,sBAAsB,CAAC,CAAC,CAAC;CA4G7B;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAE3D"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/runtime/run.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC3E,OAAO,KAAK,EAAe,iBAAiB,EAAS,MAAM,iBAAiB,CAAC;AAiB7E,OAAO,EACL,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EAErB,MAAM,WAAW,CAAC;AAWnB,gBAAgB;AAChB,wBAAgB,4BAA4B,IAAI,MAAM,CAMrD;AAiBD,gBAAgB;AAChB,wBAAgB,2BAA2B,IAAI,MAAM,CAMpD;AAqBD,gBAAgB;AAChB,wBAAgB,0BAA0B,IAAI,MAAM,CAMnD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,IAAI,OAAO,CAItD;AAED;;GAEG;AACH,MAAM,MAAM,sBAAsB,CAAC,CAAC,GAAG,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,GAAG;IAChE;;;;;;;OAOG;IACH,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,6BAA6B;IAC5C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED;;GAEG;AACH,qBAAa,GAAG,CAAC,OAAO;;IACtB,MAAM,CAAC,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE,GAAG,CAAC,OAAO,CAAC;;;;IAIlD,MAAM,CAAC,CAAC,oBAAoB,CAAC,CAAC,IAAI,EAAE;QAClC,KAAK,EAAE,MAAM,CAAC;QACd,cAAc,CAAC,EAAE,OAAO,CAAC;KAC1B;IAID;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;gBA4BF,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,cAAc,CAAC,EAAE,OAAO,CAAA;KAAE;IAiC9D;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,eAAe,CAAC;IAKlE;;;;;;OAMG;IACG,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAYvD;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAa7B;IAED;;OAEG;IACH,IAAI,MAAM,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAOvC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGlC;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAKlC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAK7B;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAKzC;IAED;;;OAGG;IACH,IAAI,WAAW,IAAI,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC,CAK3C;IAED;;OAEG;IACH,IAAI,QAAQ,IAAI,sBAAsB,CAErC;IAED;;;;;;;;;;;OAWG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,6BAAkC,GAC1C,sBAAsB,CAAC,CAAC,CAAC;IA4B5B,+CAA+C;IAC/C,IAAI,QAAQ,IAAI,cAAc,CAE7B;IAED;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,CAAC,GAAG,GAAG,EACjB,OAAO,GAAE,gCAAqC,GAC7C,cAAc,CAAC,CAAC,CAAC;CA2OrB;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAE3D"}