@lostgradient/weft 0.2.0

package/dist/core/context/durable-operations.js

@@ -0,0 +1,166 @@
+import { parseDuration } from "../scheduler.js";
+import { captureCallerStack } from "./validation.js";
+export function prepareSleepOperation(internals, duration) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return { cached: !0 };
+  const milliseconds = parseDuration(duration);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.sleep(${JSON.stringify(duration)})`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Scheduling timer for ${milliseconds}ms`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), referenceTime = internals.sleepReferenceTime ?? internals.getNow();
+  internals.sleepReferenceTime = void 0;
+  return {
+    cached: !1,
+    milliseconds,
+    request: {
+      type: "sleep",
+      operationId,
+      duration: milliseconds,
+      scheduledFireAt: referenceTime + milliseconds,
+      callerStack
+    },
+    step
+  };
+}
+export function* completePreparedSleepOperation(context, prepared) {
+  yield prepared.request;
+  context.accumulatedResults.set(prepared.step, void 0);
+}
+export function* sleep(context, internals, duration) {
+  const prepared = prepareSleepOperation(internals, duration);
+  if (prepared.cached)
+    return;
+  yield* completePreparedSleepOperation(context, prepared);
+}
+export function* waitForSignal(context, internals, name) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.waitForSignal("${name}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Waiting for signal "${name}"`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "wait-signal",
+    operationId,
+    signalName: name,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}
+export function* waitForUpdate(context, internals, name) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return { payload: internals.accumulatedResults.get(step).payload, respond: () => {} };
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.waitForUpdate("${name}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Waiting for update "${name}"`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), envelope = yield {
+    type: "wait-update",
+    operationId,
+    updateName: name,
+    callerStack
+  };
+  context.accumulatedResults.set(step, { payload: envelope.payload });
+  return envelope;
+}
+export function* review(context, internals, options) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.review(${JSON.stringify(options.reviewType ?? "general")})`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log("  \u2192 Pausing for human review");
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "wait-review",
+    operationId,
+    reviewOptions: options,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}
+export function* offload(context, internals, key, fn) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.offload("${key}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Offloading data for key "${key}" to external storage`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "offload",
+    operationId,
+    key,
+    fn,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}
+export function* stream(context, internals, key, fn) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.stream("${key}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Streaming data for key "${key}" to external storage`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "stream",
+    operationId,
+    key,
+    fn,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}
+export function* load(context, internals, reference) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return internals.accumulatedResults.get(step);
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.load("${reference.key}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Loading offloaded data for key "${reference.key}"`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack(), result = yield {
+    type: "load",
+    operationId,
+    reference,
+    callerStack
+  };
+  context.accumulatedResults.set(step, result);
+  return result;
+}
+export function* archive(context, internals, key, data) {
+  const step = internals.stepIndex++;
+  if (internals.accumulatedResults?.has(step))
+    return;
+  if (internals.explainMode) {
+    console.log(`[weft] ctx.archive("${key}")`);
+    console.log(`  \u2192 Creating checkpoint at step ${step}`);
+    console.log(`  \u2192 Archiving data for key "${key}"`);
+  }
+  const operationId = crypto.randomUUID(), callerStack = captureCallerStack();
+  yield {
+    type: "archive",
+    operationId,
+    key,
+    data,
+    callerStack
+  };
+  context.accumulatedResults.set(step, void 0);
+}

package/dist/core/context/index.d.ts

@@ -0,0 +1,114 @@
+import type { ComposedWorkflowInterceptor } from '../interceptor.ts';
+import type { HumanReviewOptions, HumanReviewResult } from '../review/index.ts';
+import type { ActivityCallable, ActivityCallOptions, ChildWorkflowOptions, ChildWorkflowTarget, Duration, QueryDefinition, RunAllResult, SearchAttributeHandle, SearchAttributeValue, SignalDefinition, UpdateDefinition, WorkflowContext, WorkflowMapOptions, WorkflowOperation, WorkflowOperationTupleResult, WorkflowPipeStageDefinition, WorkflowReduceInput, WorkflowReduceOptions, WorkflowRunAllBranch, WorkflowStateNamespace } from '../types.ts';
+import type { ContextOperationRequest } from './operation-request.ts';
+import type { ContextOptions, ErasedSagaStep, OffloadReference, StreamReference, StreamSink } from './types.ts';
+import * as contextUpdates from './updates.ts';
+export type { ContextOperationRequest } from './operation-request.ts';
+export type { ContextOptions, OffloadReference, SagaStep, StoredStreamChunk, StreamReference, StreamSink, } from './types.ts';
+export declare function setContextWorkflowInterceptor(context: Context, workflowInterceptor: ComposedWorkflowInterceptor | null): void;
+/**
+ * Concrete workflow execution context injected as the first argument of every
+ * registered workflow generator. Implements durable operations such as `run`,
+ * `sleep`, `waitForSignal`, `review`, `offload`, `stream`, and `saga`.
+ *
+ * @example
+ * ```ts
+ * import { Context } from '@lostgradient/weft';
+ *
+ * const ctx = new Context({ workflowId: 'wf-demo', workflowType: 'demo', startedAt: Date.now(), abortController: new AbortController() });
+ * void ctx;
+ * ```
+ */
+export declare class Context implements WorkflowContext {
+    readonly workflowId: string;
+    readonly workflowType: string;
+    readonly startedAt: number;
+    readonly signal: AbortSignal;
+    constructor(options: ContextOptions);
+    get executionTimeRemaining(): number;
+    get stepIndex(): number;
+    get nestingDepth(): number;
+    get accumulatedResults(): Map<number, unknown>;
+    get checkpointLocals(): Record<string, unknown>;
+    get pendingAttributeChanges(): Record<string, SearchAttributeValue>;
+    get exposedAccessors(): Map<string, () => unknown>;
+    get updateHandlers(): Map<string, (payload: unknown) => unknown>;
+    get updateValidators(): Map<string, (payload: unknown) => unknown>;
+    get queryHandlers(): Map<string, (input: unknown) => unknown>;
+    get explainEnabled(): boolean;
+    get checkpointAccumulatedResults(): Array<[number, unknown]>;
+    get checkpointPendingAttributeChanges(): Record<string, SearchAttributeValue> | undefined;
+    get hasPendingAttributeChanges(): boolean;
+    get hasUpdateHandlers(): boolean;
+    get hasExposedAccessors(): boolean;
+    createSpeculativeChild(): Context;
+    commitSpeculativeChild(child: Context): void;
+    get state(): WorkflowStateNamespace;
+    run<TName extends string>(name: TName, input?: unknown, options?: ActivityCallOptions): Generator<ContextOperationRequest, unknown, unknown>;
+    run<TResult>(fn: ActivityCallable<void, TResult>, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
+    run<TResult>(fn: (() => Promise<TResult> | TResult) & {
+        execute?: never;
+    }, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
+    run<TInput, TResult>(fn: ActivityCallable<TInput, TResult>, input: TInput, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
+    run<TInput, TResult>(fn: ((input: TInput) => Promise<TResult> | TResult) & {
+        execute?: never;
+    }, input: TInput, options?: ActivityCallOptions): Generator<ContextOperationRequest, TResult, unknown>;
+    sleep(duration: Duration): Generator<ContextOperationRequest, void, unknown>;
+    suspendUntil<T = unknown>(resumeToken: string): Generator<ContextOperationRequest, T, unknown>;
+    waitForSignal<TInput>(definition: SignalDefinition<TInput>): Generator<ContextOperationRequest, TInput, unknown>;
+    waitForSignal<T = unknown>(name: string): Generator<ContextOperationRequest, T, unknown>;
+    waitForUpdate<TInput, TOutput>(definition: UpdateDefinition<TInput, TOutput>): Generator<ContextOperationRequest, {
+        payload: TInput;
+        respond: (result: TOutput) => void;
+    }, unknown>;
+    waitForUpdate<T = unknown>(name: string): Generator<ContextOperationRequest, {
+        payload: T;
+        respond: (result: unknown) => void;
+    }, unknown>;
+    review(options: HumanReviewOptions): Generator<ContextOperationRequest, HumanReviewResult, unknown>;
+    all<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): Generator<ContextOperationRequest, WorkflowOperationTupleResult<TOperations>, unknown>;
+    race<const TOperations extends readonly WorkflowOperation<unknown>[]>(operations: TOperations): Generator<ContextOperationRequest, WorkflowOperationTupleResult<TOperations>[number], unknown>;
+    memo<T>(key: string, fn: () => T | Promise<T>): Generator<ContextOperationRequest, T, unknown>;
+    offload<T>(key: string, fn: () => Promise<T>): Generator<ContextOperationRequest, OffloadReference, unknown>;
+    stream(key: string, fn: (sink: StreamSink) => AsyncGenerator<unknown, void, unknown>): Generator<ContextOperationRequest, StreamReference, unknown>;
+    load<T>(reference: OffloadReference): Generator<ContextOperationRequest, T, unknown>;
+    archive(key: string, data: unknown): Generator<ContextOperationRequest, void, unknown>;
+    runAll<const TBranches extends Record<string, WorkflowRunAllBranch>>(branches: TBranches): Generator<ContextOperationRequest, RunAllResult<TBranches>, unknown>;
+    saga<TFinalOutput = unknown>(steps: ErasedSagaStep[]): Generator<ContextOperationRequest, TFinalOutput, unknown>;
+    startChild<TResult = unknown>(workflowType: string, input: unknown, options?: ChildWorkflowOptions): Generator<ContextOperationRequest, TResult, unknown>;
+    pipe<TInput, TOutput>(stages: [WorkflowPipeStageDefinition<TInput, TOutput>], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
+    pipe<TInput, TIntermediate, TOutput>(stages: [
+        WorkflowPipeStageDefinition<TInput, TIntermediate>,
+        WorkflowPipeStageDefinition<TIntermediate, TOutput>
+    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
+    pipe<TInput, TFirst, TSecond, TOutput>(stages: [
+        WorkflowPipeStageDefinition<TInput, TFirst>,
+        WorkflowPipeStageDefinition<TFirst, TSecond>,
+        WorkflowPipeStageDefinition<TSecond, TOutput>
+    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
+    pipe<TInput, TFirst, TSecond, TThird, TOutput>(stages: [
+        WorkflowPipeStageDefinition<TInput, TFirst>,
+        WorkflowPipeStageDefinition<TFirst, TSecond>,
+        WorkflowPipeStageDefinition<TSecond, TThird>,
+        WorkflowPipeStageDefinition<TThird, TOutput>
+    ], input: TInput): Generator<ContextOperationRequest, TOutput, unknown>;
+    map<TItem, TResult>(items: readonly TItem[], workflowType: ChildWorkflowTarget<TItem, TResult>, options?: WorkflowMapOptions): Generator<ContextOperationRequest, TResult[], unknown>;
+    reduce<TItem, TAccumulator>(items: readonly TItem[], workflowType: ChildWorkflowTarget<WorkflowReduceInput<TAccumulator, TItem>, TAccumulator>, initialValue: TAccumulator, options?: WorkflowReduceOptions): Generator<ContextOperationRequest, TAccumulator, unknown>;
+    explain(enabled?: boolean): void;
+    speculate<TResult>(execute: (context: Context) => Generator<ContextOperationRequest, TResult, unknown> | AsyncGenerator<unknown, TResult, unknown>): Generator<ContextOperationRequest, TResult, unknown>;
+    setAttribute<TValue extends SearchAttributeValue>(key: SearchAttributeHandle<TValue>, value: TValue): void;
+    setAttribute(key: string, value: SearchAttributeValue): void;
+    setAttributes(attributes: Record<string, SearchAttributeValue>): void;
+    getAttribute<T extends SearchAttributeValue>(key: SearchAttributeHandle<T>): T | undefined;
+    getAttribute<T extends SearchAttributeValue = SearchAttributeValue>(key: string): T | undefined;
+    getAttributes(): Readonly<Record<string, SearchAttributeValue>>;
+    onUpdate<TInput, TOutput>(definition: UpdateDefinition<TInput, TOutput>, handler: (payload: TInput) => TOutput | Promise<TOutput>, options?: contextUpdates.UpdateHandlerOptions): void;
+    onUpdate(name: string, handler: (payload: unknown) => unknown, options?: contextUpdates.UpdateHandlerOptions): void;
+    onQuery<TInput, TOutput>(definition: QueryDefinition<TInput, TOutput>, handler: (input: TInput) => TOutput | Promise<TOutput>): void;
+    onQuery<TOutput>(definition: QueryDefinition<void, TOutput>, handler: () => TOutput | Promise<TOutput>): void;
+    onQuery(name: string, handler: (input: unknown) => unknown): void;
+    expose(accessors: Record<string, () => unknown>): void;
+    onCancel(handler: () => Promise<void> | void): void;
+    streamUrl(reference: StreamReference): string;
+}

package/dist/core/context/index.js

@@ -0,0 +1,224 @@
+import { normalizeSessionStateLocals } from "../session-state.js";
+import { messageName, searchAttributeName } from "../types.js";
+import * as contextAttributes from "./attributes.js";
+import * as childWorkflowPipe from "./child-workflow-pipe.js";
+import * as durableOperations from "./durable-operations.js";
+import { getInternals, initializeInternals } from "./internals.js";
+import * as parallelOperations from "./parallel-operations.js";
+import { runActivityWithRetry } from "./run-operation.js";
+import * as sagaHelpers from "./saga.js";
+import * as speculateOperations from "./speculate-operations.js";
+import {
+  commitSpeculativeChild as commitSpeculativeChildState,
+  createSpeculativeChild as createSpeculativeChildState
+} from "./speculative-child.js";
+import * as stateNamespaceHelpers from "./state-namespace.js";
+import * as contextUpdates from "./updates.js";
+export function setContextWorkflowInterceptor(context, workflowInterceptor) {
+  getInternals(context).workflowInterceptor = workflowInterceptor;
+}
+
+export class Context {
+  workflowId;
+  workflowType;
+  startedAt;
+  signal;
+  constructor(options) {
+    this.workflowId = options.workflowId;
+    this.workflowType = options.workflowType;
+    this.startedAt = options.startedAt;
+    this.signal = options.abortController.signal;
+    const initialSessionState = normalizeSessionStateLocals(options.locals);
+    initializeInternals(this, options, initialSessionState);
+  }
+  get executionTimeRemaining() {
+    const internals = getInternals(this);
+    if (internals.deadline === void 0)
+      return 1 / 0;
+    return Math.max(0, internals.deadline - internals.getNow());
+  }
+  get stepIndex() {
+    return getInternals(this).stepIndex;
+  }
+  get nestingDepth() {
+    return getInternals(this).nestingDepth;
+  }
+  get accumulatedResults() {
+    const internals = getInternals(this);
+    internals.accumulatedResults ??= new Map;
+    return internals.accumulatedResults;
+  }
+  get checkpointLocals() {
+    return getInternals(this).checkpointLocals;
+  }
+  get pendingAttributeChanges() {
+    const internals = getInternals(this);
+    internals.pendingAttributeChanges ??= {};
+    return internals.pendingAttributeChanges;
+  }
+  get exposedAccessors() {
+    const internals = getInternals(this);
+    internals.exposedValues ??= new Map;
+    return internals.exposedValues;
+  }
+  get updateHandlers() {
+    const internals = getInternals(this);
+    internals.updateHandlers ??= new Map;
+    return internals.updateHandlers;
+  }
+  get updateValidators() {
+    const internals = getInternals(this);
+    internals.updateValidators ??= new Map;
+    return internals.updateValidators;
+  }
+  get queryHandlers() {
+    const internals = getInternals(this);
+    internals.queryHandlers ??= new Map;
+    return internals.queryHandlers;
+  }
+  get explainEnabled() {
+    return getInternals(this).explainMode;
+  }
+  get checkpointAccumulatedResults() {
+    const accumulatedResults = getInternals(this).accumulatedResults;
+    return accumulatedResults ? Array.from(accumulatedResults.entries()) : [];
+  }
+  get checkpointPendingAttributeChanges() {
+    const pendingAttributeChanges = getInternals(this).pendingAttributeChanges;
+    return pendingAttributeChanges ? { ...pendingAttributeChanges } : void 0;
+  }
+  get hasPendingAttributeChanges() {
+    const pendingAttributeChanges = getInternals(this).pendingAttributeChanges;
+    return pendingAttributeChanges !== void 0 && Object.keys(pendingAttributeChanges).length > 0;
+  }
+  get hasUpdateHandlers() {
+    const updateHandlers = getInternals(this).updateHandlers;
+    return updateHandlers !== void 0 && updateHandlers.size > 0;
+  }
+  get hasExposedAccessors() {
+    const exposedValues = getInternals(this).exposedValues;
+    return exposedValues !== void 0 && exposedValues.size > 0;
+  }
+  createSpeculativeChild() {
+    return createSpeculativeChildState(this, (options) => new Context(options));
+  }
+  commitSpeculativeChild(child) {
+    commitSpeculativeChildState(this, child);
+  }
+  get state() {
+    return stateNamespaceHelpers.createStateNamespace(this, getInternals(this));
+  }
+  *run(activity, ...rest) {
+    return yield* runActivityWithRetry(this, activity, rest);
+  }
+  *sleep(duration) {
+    const internals = getInternals(this), prepared = durableOperations.prepareSleepOperation(internals, duration);
+    if (prepared.cached)
+      return;
+    const execute = () => durableOperations.completePreparedSleepOperation(this, prepared);
+    if (!internals.workflowInterceptor)
+      return yield* execute();
+    return yield* internals.workflowInterceptor.sleep({
+      workflowId: this.workflowId,
+      duration: prepared.milliseconds,
+      headers: new Map
+    }, execute);
+  }
+  *suspendUntil(resumeToken) {
+    return yield* this.waitForSignal(resumeToken);
+  }
+  *waitForSignal(nameOrDefinition) {
+    const internals = getInternals(this), signalName = messageName(nameOrDefinition), execute = () => durableOperations.waitForSignal(this, internals, signalName);
+    if (internals.accumulatedResults?.has(internals.stepIndex))
+      return yield* execute();
+    if (!internals.workflowInterceptor)
+      return yield* execute();
+    return yield* internals.workflowInterceptor.waitForSignal({
+      workflowId: this.workflowId,
+      signalName,
+      payload: void 0,
+      headers: new Map
+    }, execute);
+  }
+  *waitForUpdate(nameOrDefinition) {
+    return yield* durableOperations.waitForUpdate(this, getInternals(this), messageName(nameOrDefinition));
+  }
+  *review(options) {
+    return yield* durableOperations.review(this, getInternals(this), options);
+  }
+  *all(operations) {
+    return yield* parallelOperations.all(this, getInternals(this), [...operations]);
+  }
+  *race(operations) {
+    return yield* parallelOperations.race(this, getInternals(this), [...operations]);
+  }
+  *memo(key, fn) {
+    return yield* parallelOperations.memo(this, getInternals(this), key, fn);
+  }
+  *offload(key, fn) {
+    return yield* durableOperations.offload(this, getInternals(this), key, fn);
+  }
+  *stream(key, fn) {
+    return yield* durableOperations.stream(this, getInternals(this), key, fn);
+  }
+  *load(reference) {
+    return yield* durableOperations.load(this, getInternals(this), reference);
+  }
+  *archive(key, data) {
+    return yield* durableOperations.archive(this, getInternals(this), key, data);
+  }
+  *runAll(branches) {
+    return yield* parallelOperations.runAll(this, getInternals(this), branches);
+  }
+  *saga(steps) {
+    return yield* sagaHelpers.saga(this, steps);
+  }
+  *startChild(workflowType, input, options) {
+    return yield* childWorkflowPipe.startChild(this, getInternals(this), workflowType, input, options);
+  }
+  *pipe(stages, input) {
+    return yield* childWorkflowPipe.pipe(this, getInternals(this), stages, input);
+  }
+  *map(items, workflowType, options) {
+    return yield* childWorkflowPipe.map(this, getInternals(this), items, workflowType, options);
+  }
+  *reduce(items, workflowType, initialValue, options) {
+    return yield* childWorkflowPipe.reduce(this, getInternals(this), items, workflowType, initialValue, options);
+  }
+  explain(enabled = !0) {
+    getInternals(this).explainMode = enabled;
+  }
+  *speculate(execute) {
+    return yield* speculateOperations.speculate(this, getInternals(this), execute);
+  }
+  setAttribute(key, value) {
+    contextAttributes.setAttribute(getInternals(this), searchAttributeName(key), value);
+  }
+  setAttributes(attributes) {
+    contextAttributes.setAttributes(getInternals(this), attributes);
+  }
+  getAttribute(key) {
+    return contextAttributes.getAttribute(getInternals(this), searchAttributeName(key));
+  }
+  getAttributes() {
+    return contextAttributes.getAttributes(getInternals(this));
+  }
+  onUpdate(nameOrDefinition, handler, options) {
+    contextUpdates.onUpdate(getInternals(this), messageName(nameOrDefinition), handler, options);
+  }
+  onQuery(nameOrDefinition, handler) {
+    contextUpdates.onQuery(getInternals(this), messageName(nameOrDefinition), handler);
+  }
+  expose(accessors) {
+    contextUpdates.expose(getInternals(this), accessors);
+  }
+  onCancel(handler) {
+    const internals = getInternals(this);
+    if (internals.registerCancelHandler === void 0)
+      throw Error("ctx.onCancel() is only supported for inline workflow execution");
+    internals.registerCancelHandler(handler);
+  }
+  streamUrl(reference) {
+    return `/v1/workflows/${encodeURIComponent(reference.workflowId)}/streams/${encodeURIComponent(reference.key)}`;
+  }
+}

package/dist/core/context/internals.d.ts

@@ -0,0 +1,30 @@
+import type { ComposedWorkflowInterceptor } from '../interceptor.ts';
+import type { SearchAttributeSchema, SearchAttributeValue } from '../types.ts';
+import type { Context, ContextOptions } from './index.ts';
+export interface ContextInternals {
+    context: Context;
+    abortController: AbortController;
+    stepIndex: number;
+    accumulatedResults: Map<number, unknown> | undefined;
+    checkpointLocals: Record<string, unknown>;
+    stateSession: Record<string, unknown> | undefined;
+    searchAttributes: Record<string, SearchAttributeValue>;
+    searchAttributeSchema: SearchAttributeSchema | undefined;
+    workflowInterceptor: ComposedWorkflowInterceptor | null | undefined;
+    pendingAttributeChanges: Record<string, SearchAttributeValue> | undefined;
+    updateHandlers: Map<string, (payload: unknown) => unknown> | undefined;
+    updateValidators: Map<string, (payload: unknown) => unknown> | undefined;
+    queryHandlers: Map<string, (input: unknown) => unknown> | undefined;
+    exposedValues: Map<string, () => unknown> | undefined;
+    memoCache: Map<string, unknown> | undefined;
+    deadline: number | undefined;
+    getNow: () => number;
+    sleepReferenceTime: number | undefined;
+    explainMode: boolean;
+    nestingDepth: number;
+    executionStateOwnerId: string;
+    resolveWorkflowType: ((target: string | Function) => string) | undefined;
+    registerCancelHandler: ((handler: () => Promise<void> | void) => () => void) | undefined;
+}
+export declare function initializeInternals(context: Context, options: ContextOptions, initialSessionState: Record<string, unknown> | undefined): void;
+export declare function getInternals(context: Context): ContextInternals;

package/dist/core/context/internals.js

@@ -0,0 +1,36 @@
+import { createCheckpointLocals } from "./session-state.js";
+const INTERNALS = new WeakMap;
+export function initializeInternals(context, options, initialSessionState) {
+  const internals = {
+    context,
+    abortController: options.abortController,
+    stepIndex: options.initialStep ?? 0,
+    accumulatedResults: options.accumulatedResults,
+    stateSession: initialSessionState,
+    checkpointLocals: createCheckpointLocals(initialSessionState, options.locals),
+    searchAttributes: options.searchAttributes ? { ...options.searchAttributes } : {},
+    searchAttributeSchema: options.searchAttributeSchema,
+    workflowInterceptor: void 0,
+    pendingAttributeChanges: void 0,
+    updateHandlers: void 0,
+    updateValidators: void 0,
+    queryHandlers: void 0,
+    exposedValues: void 0,
+    memoCache: void 0,
+    deadline: options.deadline,
+    getNow: options.getNow ?? Date.now,
+    sleepReferenceTime: options.sleepReferenceTime,
+    explainMode: !1,
+    nestingDepth: options.nestingDepth ?? 0,
+    executionStateOwnerId: options.executionStateOwnerId ?? options.workflowId,
+    resolveWorkflowType: options.resolveWorkflowType,
+    registerCancelHandler: options.registerCancelHandler
+  };
+  INTERNALS.set(context, internals);
+}
+export function getInternals(context) {
+  const internals = INTERNALS.get(context);
+  if (!internals)
+    throw Error("Context internals not initialized");
+  return internals;
+}