@lostgradient/weft 0.2.0

package/dist/core/search-attributes.js

@@ -0,0 +1,196 @@
+import { KEYS } from "../storage/interface.js";
+export { searchAttribute, searchAttributeName } from "./types.js";
+const SIGN_BIT = 1n << 63n, ALL_BITS = (1n << 64n) - 1n;
+export const MAX_ENCODED_VALUE_BYTES = 1024;
+function floatToSortableHex(value) {
+  const buffer = new ArrayBuffer(8), view = new DataView(buffer);
+  view.setFloat64(0, value);
+  let bits = view.getBigUint64(0);
+  if (bits & SIGN_BIT)
+    bits = bits ^ ALL_BITS;
+  else
+    bits = bits ^ SIGN_BIT;
+  return bits.toString(16).padStart(16, "0");
+}
+function sortableHexToFloat(hex) {
+  let bits = BigInt(`0x${hex}`);
+  if (bits & SIGN_BIT)
+    bits = bits ^ SIGN_BIT;
+  else
+    bits = bits ^ ALL_BITS;
+  const buffer = new ArrayBuffer(8), view = new DataView(buffer);
+  view.setBigUint64(0, bits);
+  return view.getFloat64(0);
+}
+export function encodeAttributeValue(value) {
+  let encoded;
+  if (typeof value === "string")
+    encoded = `s:${value}`;
+  else if (typeof value === "number")
+    encoded = `n:${floatToSortableHex(value)}`;
+  else if (typeof value === "boolean")
+    encoded = `b:${value ? "1" : "0"}`;
+  else if (value instanceof Date)
+    encoded = `d:${value.toISOString()}`;
+  else
+    throw Error("Cannot encode a keyword list as a single value; encode elements individually.");
+  return encoded;
+}
+export function validateEncodedValueSize(encoded, attributeName) {
+  const byteLength = new TextEncoder().encode(encoded).byteLength;
+  if (byteLength > MAX_ENCODED_VALUE_BYTES)
+    throw Error(`Encoded search attribute "${attributeName}" exceeds the ${MAX_ENCODED_VALUE_BYTES}-byte limit (got ${byteLength} bytes). Reduce the value size before setting the attribute.`);
+}
+export function decodeAttributeValue(encoded, type) {
+  const colonIndex = encoded.indexOf(":"), payload = encoded.slice(colonIndex + 1);
+  switch (type) {
+    case "string":
+      return payload;
+    case "number":
+      return sortableHexToFloat(payload);
+    case "boolean":
+      return payload === "1";
+    case "date-time":
+    case "datetime":
+      return new Date(payload);
+    default:
+      throw Error(`Unknown search attribute type: ${type}`);
+  }
+}
+export function validateAttributeType(attributeName, value, definition) {
+  const { type: declaredType } = definition;
+  switch (declaredType) {
+    case "string":
+      validateStringAttribute(attributeName, value, definition);
+      break;
+    case "integer":
+      validateIntegerAttribute(attributeName, value);
+      break;
+    case "number":
+      validateNumberAttribute(attributeName, value);
+      break;
+    case "boolean":
+      validateBooleanAttribute(attributeName, value);
+      break;
+    case "array":
+      validateArrayAttribute(attributeName, value);
+      break;
+    default:
+      throw Error(`Unknown search attribute type declaration: ${String(declaredType)}`);
+  }
+}
+function validateStringAttribute(attributeName, value, definition) {
+  if (definition.format === "date-time") {
+    if (!(value instanceof Date))
+      throw Error(`Search attribute "${attributeName}" is declared as "string" with format "date-time" but received ${typeof value}.`);
+    return;
+  }
+  if (typeof value !== "string")
+    throw Error(`Search attribute "${attributeName}" is declared as "string" but received ${typeof value}.`);
+}
+function validateIntegerAttribute(attributeName, value) {
+  if (typeof value !== "number" || !Number.isInteger(value))
+    throw Error(`Search attribute "${attributeName}" is declared as "integer" but received ${typeof value}.`);
+}
+function validateNumberAttribute(attributeName, value) {
+  if (typeof value !== "number")
+    throw Error(`Search attribute "${attributeName}" is declared as "number" but received ${typeof value}.`);
+}
+function validateBooleanAttribute(attributeName, value) {
+  if (typeof value !== "boolean")
+    throw Error(`Search attribute "${attributeName}" is declared as "boolean" but received ${typeof value}.`);
+}
+function validateArrayAttribute(attributeName, value) {
+  if (!Array.isArray(value))
+    throw Error(`Search attribute "${attributeName}" is declared as "array" but received ${typeof value}.`);
+  if (!value.every((element) => typeof element === "string"))
+    throw Error(`Search attribute "${attributeName}" is declared as "array" but array contains non-string elements.`);
+}
+function valuesEqual(a, b) {
+  if (a instanceof Date && b instanceof Date)
+    return a.getTime() === b.getTime();
+  return a === b;
+}
+const EMPTY_VALUE = new Uint8Array(0);
+export function buildIndexOperations(workflowId, previous, current) {
+  const operations = [], allKeys = new Set([...Object.keys(previous), ...Object.keys(current)]);
+  for (const attributeName of allKeys)
+    operations.push(...buildAttributeIndexOperations(attributeName, workflowId, previous, current));
+  return operations;
+}
+function buildAttributeIndexOperations(attributeName, workflowId, previous, current) {
+  const oldValue = previous[attributeName], newValue = current[attributeName], hadOld = attributeName in previous, hasNew = attributeName in current;
+  if (Array.isArray(oldValue) || Array.isArray(newValue))
+    return buildArrayTransitionOperations({
+      attributeName,
+      workflowId,
+      oldValue,
+      newValue,
+      hadOld,
+      hasNew
+    });
+  return buildScalarTransitionOperations({
+    attributeName,
+    workflowId,
+    oldValue,
+    newValue,
+    hadOld,
+    hasNew
+  });
+}
+function buildScalarTransitionOperations(parameters) {
+  const { attributeName, workflowId, oldValue, newValue, hadOld, hasNew } = parameters;
+  if (hadOld && !hasNew)
+    return [deleteIndexOperation(attributeName, oldValue, workflowId)];
+  if (!hadOld && hasNew)
+    return [putIndexOperation(attributeName, newValue, workflowId)];
+  if (hadOld && hasNew && !valuesEqual(oldValue, newValue))
+    return [
+      deleteIndexOperation(attributeName, oldValue, workflowId),
+      putIndexOperation(attributeName, newValue, workflowId)
+    ];
+  return [];
+}
+function putIndexOperation(attributeName, value, workflowId) {
+  return {
+    type: "put",
+    key: KEYS.attributeIndex(attributeName, encodeAttributeValue(value), workflowId),
+    value: EMPTY_VALUE
+  };
+}
+function deleteIndexOperation(attributeName, value, workflowId) {
+  return {
+    type: "delete",
+    key: KEYS.attributeIndex(attributeName, encodeAttributeValue(value), workflowId)
+  };
+}
+function buildArrayTransitionOperations(parameters) {
+  const { oldValue, newValue } = parameters;
+  if (Array.isArray(oldValue) && Array.isArray(newValue))
+    return buildArrayDiffOperations(parameters.attributeName, oldValue, newValue, parameters.workflowId);
+  return [
+    ...buildDeleteOperationsForValues(parameters.attributeName, parameters.hadOld ? oldValue : void 0, parameters.workflowId),
+    ...buildPutOperationsForValues(parameters.attributeName, parameters.hasNew ? newValue : void 0, parameters.workflowId)
+  ];
+}
+function buildArrayDiffOperations(attributeName, oldValues, newValues, workflowId) {
+  const operations = [], oldElements = new Set(oldValues), newElements = new Set(newValues);
+  for (const element of oldElements)
+    if (!newElements.has(element))
+      operations.push(deleteIndexOperation(attributeName, element, workflowId));
+  for (const element of newElements)
+    if (!oldElements.has(element))
+      operations.push(putIndexOperation(attributeName, element, workflowId));
+  return operations;
+}
+function buildDeleteOperationsForValues(attributeName, value, workflowId) {
+  return valuesForIndexTransition(value).map((element) => deleteIndexOperation(attributeName, element, workflowId));
+}
+function buildPutOperationsForValues(attributeName, value, workflowId) {
+  return valuesForIndexTransition(value).map((element) => putIndexOperation(attributeName, element, workflowId));
+}
+function valuesForIndexTransition(value) {
+  if (value === void 0)
+    return [];
+  return Array.isArray(value) ? value : [value];
+}

package/dist/core/session-state.d.ts

@@ -0,0 +1,18 @@
+import { WeftError } from './weft-error.ts';
+export declare const SESSION_STATE_LOCAL_KEY = "stateSession";
+export declare const LEGACY_SESSION_STATE_LOCAL_KEY = "sessionState";
+export declare const MAX_SESSION_STATE_ENTRY_COUNT = 256;
+export declare const MAX_SESSION_STATE_KEY_LENGTH = 256;
+export declare const MAX_SESSION_STATE_SERIALIZED_BYTES: number;
+export declare class SessionStateValidationError extends WeftError<'SessionStateValidationError'> {
+    constructor(message: string);
+}
+export declare function createSessionStateStore(): Record<string, unknown>;
+export declare function hasSessionStateKey(store: Record<string, unknown>, key: string): boolean;
+export declare function assertValidSessionStateKey(key: string): void;
+export declare function cloneSessionStateValue<T>(value: T): T;
+export declare function cloneSessionStateStore(store: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function normalizeSessionStateRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function normalizeSessionStateLocals(locals: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function validateSessionStateStore(store: Record<string, unknown>): void;
+export declare function validateSessionStateLocals(locals: Record<string, unknown>): void;

package/dist/core/session-state.js

@@ -0,0 +1,71 @@
+import { encode } from "./codec.js";
+import { WeftError } from "./weft-error.js";
+export const SESSION_STATE_LOCAL_KEY = "stateSession", LEGACY_SESSION_STATE_LOCAL_KEY = "sessionState", MAX_SESSION_STATE_ENTRY_COUNT = 256, MAX_SESSION_STATE_KEY_LENGTH = 256, MAX_SESSION_STATE_SERIALIZED_BYTES = 32768;
+const RESERVED_SESSION_STATE_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+
+export class SessionStateValidationError extends WeftError {
+  constructor(message) {
+    super("SessionStateValidationError", message);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null);
+}
+export function createSessionStateStore() {
+  return Object.create(null);
+}
+export function hasSessionStateKey(store, key) {
+  return Object.prototype.hasOwnProperty.call(store, key);
+}
+export function assertValidSessionStateKey(key) {
+  if (key.length === 0 || key.length > MAX_SESSION_STATE_KEY_LENGTH)
+    throw new SessionStateValidationError(`Session state key must be 1-${String(MAX_SESSION_STATE_KEY_LENGTH)} characters long.`);
+  if (RESERVED_SESSION_STATE_KEYS.has(key))
+    throw new SessionStateValidationError(`Session state key "${key}" is reserved.`);
+}
+export function cloneSessionStateValue(value) {
+  return structuredClone(value);
+}
+export function cloneSessionStateStore(store) {
+  if (!store)
+    return;
+  const clonedStore = createSessionStateStore();
+  for (const [key, value] of Object.entries(store))
+    clonedStore[key] = cloneSessionStateValue(value);
+  return clonedStore;
+}
+export function normalizeSessionStateRecord(value) {
+  if (value === void 0)
+    return;
+  if (!isRecord(value))
+    throw new SessionStateValidationError("Session state must be a plain object record.");
+  const entries = Object.entries(value);
+  if (entries.length === 0)
+    return;
+  if (entries.length > MAX_SESSION_STATE_ENTRY_COUNT)
+    throw new SessionStateValidationError(`Session state may not contain more than ${String(MAX_SESSION_STATE_ENTRY_COUNT)} keys.`);
+  const normalized = createSessionStateStore();
+  for (const [key, entryValue] of entries) {
+    assertValidSessionStateKey(key);
+    normalized[key] = cloneSessionStateValue(entryValue);
+  }
+  validateSessionStateStore(normalized);
+  return normalized;
+}
+export function normalizeSessionStateLocals(locals) {
+  if (!locals)
+    return;
+  return normalizeSessionStateRecord(locals[SESSION_STATE_LOCAL_KEY] ?? locals[LEGACY_SESSION_STATE_LOCAL_KEY]);
+}
+export function validateSessionStateStore(store) {
+  const keys = Object.keys(store);
+  if (keys.length > MAX_SESSION_STATE_ENTRY_COUNT)
+    throw new SessionStateValidationError(`Session state may not contain more than ${String(MAX_SESSION_STATE_ENTRY_COUNT)} keys.`);
+  for (const key of keys)
+    assertValidSessionStateKey(key);
+  if (encode(store).byteLength > MAX_SESSION_STATE_SERIALIZED_BYTES)
+    throw new SessionStateValidationError(`Session state exceeds the ${String(MAX_SESSION_STATE_SERIALIZED_BYTES)} byte limit.`);
+}
+export function validateSessionStateLocals(locals) {
+  normalizeSessionStateLocals(locals);
+}

package/dist/core/signal-id.d.ts

@@ -0,0 +1,2 @@
+export declare function isSignalIdWithinByteLimit(signalId: string): boolean;
+export declare function validateSignalId(signalId: string): void;

package/dist/core/signal-id.js

@@ -0,0 +1,10 @@
+const MAX_SIGNAL_ID_BYTES = 128, textEncoder = new TextEncoder;
+export function isSignalIdWithinByteLimit(signalId) {
+  return textEncoder.encode(signalId).byteLength <= MAX_SIGNAL_ID_BYTES;
+}
+export function validateSignalId(signalId) {
+  if (signalId.length === 0)
+    throw Error("signalId must be non-empty");
+  if (!isSignalIdWithinByteLimit(signalId))
+    throw Error(`signalId must be at most ${String(MAX_SIGNAL_ID_BYTES)} bytes`);
+}

package/dist/core/start-workflow-validation.d.ts

@@ -0,0 +1,14 @@
+import type { Duration } from './types.ts';
+import { WeftError } from './weft-error.ts';
+export declare const MAX_WORKFLOW_TAGS = 32;
+export declare const MAX_WORKFLOW_TAG_BYTES = 128;
+export declare class StartWorkflowValidationError extends WeftError<'StartWorkflowValidationError'> {
+    constructor(message: string);
+}
+export declare const assertExclusiveStartWorkflowOptions: (startAt: unknown, startAfter: unknown) => void;
+export declare const coerceStartWorkflowId: (value: unknown, fieldName: string) => string;
+export declare function coerceStartWorkflowTimestamp(value: unknown, fieldName: string): number;
+export declare function parseStartWorkflowDuration(duration: Duration, fieldName: string): number;
+export declare function coerceStartWorkflowDuration(value: unknown, fieldName: string): Duration;
+export declare function assertWorkflowTagCount(tags: readonly unknown[], fieldName: string): void;
+export declare function coerceStartWorkflowTags(value: unknown, fieldName: string): string[];

package/dist/core/start-workflow-validation.js

@@ -0,0 +1,63 @@
+import { parseDuration } from "./scheduler.js";
+import { WeftError } from "./weft-error.js";
+import { assertValidWorkflowId } from "./workflow-identifiers.js";
+export const MAX_WORKFLOW_TAGS = 32, MAX_WORKFLOW_TAG_BYTES = 128;
+const textEncoder = new TextEncoder, EXCLUSIVE_START_WORKFLOW_OPTIONS_ERROR = "Provide only one of startAt or startAfter";
+
+export class StartWorkflowValidationError extends WeftError {
+  constructor(message) {
+    super("StartWorkflowValidationError", message);
+  }
+}
+export const assertExclusiveStartWorkflowOptions = (startAt, startAfter) => {
+  if (startAt !== void 0 && startAfter !== void 0)
+    throw new StartWorkflowValidationError(EXCLUSIVE_START_WORKFLOW_OPTIONS_ERROR);
+}, coerceStartWorkflowId = (value, fieldName) => {
+  if (typeof value !== "string")
+    throw new StartWorkflowValidationError(`${fieldName} must be a string`);
+  try {
+    assertValidWorkflowId(value, fieldName);
+    return value;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new StartWorkflowValidationError(message);
+  }
+};
+export function coerceStartWorkflowTimestamp(value, fieldName) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0)
+    throw new StartWorkflowValidationError(`${fieldName} must be a non-negative integer millisecond timestamp`);
+  return value;
+}
+export function parseStartWorkflowDuration(duration, fieldName) {
+  try {
+    return parseDuration(duration);
+  } catch {
+    throw new StartWorkflowValidationError(`${fieldName} must be a finite, non-negative number or a valid duration string`);
+  }
+}
+export function coerceStartWorkflowDuration(value, fieldName) {
+  if (typeof value !== "number" && typeof value !== "string")
+    throw new StartWorkflowValidationError(`${fieldName} must be a finite, non-negative number or valid duration string`);
+  parseStartWorkflowDuration(value, fieldName);
+  return value;
+}
+export function assertWorkflowTagCount(tags, fieldName) {
+  if (tags.length > MAX_WORKFLOW_TAGS)
+    throw new StartWorkflowValidationError(`${fieldName} must contain at most ${MAX_WORKFLOW_TAGS} tags`);
+}
+export function coerceStartWorkflowTags(value, fieldName) {
+  if (!Array.isArray(value))
+    throw new StartWorkflowValidationError(`${fieldName} must be an array of strings`);
+  assertWorkflowTagCount(value, fieldName);
+  const tags = [];
+  for (const tag of value) {
+    if (typeof tag !== "string")
+      throw new StartWorkflowValidationError(`${fieldName} must contain only strings`);
+    if (tag.trim().length === 0)
+      throw new StartWorkflowValidationError(`${fieldName} must not contain empty tags`);
+    if (textEncoder.encode(tag).byteLength > MAX_WORKFLOW_TAG_BYTES)
+      throw new StartWorkflowValidationError(`${fieldName} tags must be at most ${MAX_WORKFLOW_TAG_BYTES} UTF-8 bytes each`);
+    tags.push(tag);
+  }
+  return tags;
+}

package/dist/core/step-context.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Step-based workflow context — progressive disclosure API.
+ *
+ * Bridges plain async functions with the generator protocol used internally
+ * by the engine. Users write `await ctx.step(name, fn)` and the compiler
+ * produces a generator that yields one operation at a time.
+ *
+ * @module core/step-context
+ */
+import type { ContextOperationRequest } from './context.ts';
+import type { StepWorkflowContext, WorkflowFunction } from './types.ts';
+interface QueuedOperation {
+    request: ContextOperationRequest;
+    resolve: (value: unknown) => void;
+    reject: (reason: unknown) => void;
+}
+/**
+ * Internal implementation of {@link StepWorkflowContext} for step-based
+ * ("progressive disclosure") workflows. Wraps the generator protocol in a
+ * queue so that plain `async function` workflows can be registered on the
+ * engine without writing explicit generators. Build via
+ * {@link compileStepWorkflow} rather than constructing directly.
+ *
+ * @example
+ * ```ts
+ * import { StepContext } from '@lostgradient/weft';
+ *
+ * const controller = new AbortController();
+ * const ctx = new StepContext('wf-demo', controller.signal);
+ * ctx.step('fetch', async () => ({ name: 'Alice' })).then(console.log);
+ * void ctx;
+ * ```
+ */
+export declare class StepContext implements StepWorkflowContext {
+    #private;
+    readonly workflowId: string;
+    readonly signal: AbortSignal;
+    constructor(workflowId: string, signal: AbortSignal);
+    step<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+    /** Called by the generator loop to wait for the next operation. */
+    dequeue(): Promise<QueuedOperation | null>;
+    /** Unblocks dequeue() when the user function completes. */
+    signalDone(): void;
+}
+/**
+ * Wraps a {@link StepWorkflowFunction} (a plain `async function` using
+ * `ctx.step`) into a durable {@link WorkflowFunction} generator that the
+ * engine can register and persist. This bridges the "progressive disclosure"
+ * API with the underlying generator protocol.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, compileStepWorkflow, type StepWorkflowContext } from '@lostgradient/weft';
+ *
+ * async function process(ctx: StepWorkflowContext, input: unknown) {
+ *   const upper = await ctx.step('uppercase', () =>
+ *     (input as string).toUpperCase(),
+ *   );
+ *   return upper;
+ * }
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'process' }).execute(compileStepWorkflow(process)));
+ * const result = await (await engine.start('process', 'hello')).result();
+ * console.log(result); // 'HELLO'
+ * ```
+ */
+export declare function compileStepWorkflow<TInput = unknown, TOutput = unknown>(stepFunction: (context: StepWorkflowContext, input: TInput) => Promise<TOutput>): WorkflowFunction<TInput, TOutput>;
+/** Returns `true` if `fn` is a sync generator function (`function*`). */
+export declare function isGeneratorFunction(fn: Function): boolean;
+/**
+ * Returns `true` if `fn` is an async generator function (`async function*`).
+ *
+ * @example
+ * ```ts
+ * import { isAsyncGeneratorFunction } from '@lostgradient/weft';
+ *
+ * async function* myWorkflow() { yield 1; }
+ * function* syncGen() { yield 1; }
+ * async function asyncFn() { return 1; }
+ *
+ * console.log(isAsyncGeneratorFunction(myWorkflow)); // true
+ * console.log(isAsyncGeneratorFunction(syncGen));    // false
+ * console.log(isAsyncGeneratorFunction(asyncFn));    // false
+ * ```
+ */
+export declare function isAsyncGeneratorFunction(fn: Function): boolean;
+/**
+ * Check if a value is a Generator or AsyncGenerator object (not just any iterable).
+ * Arrays, Maps, Sets, etc. are NOT matched — only actual generator instances.
+ *
+ * The prototype chain for a generator instance is:
+ *   gen -> genFn.prototype -> Generator.prototype
+ * We compare the shared parent prototype so lookalike iterators do not match.
+ */
+export declare function isGeneratorResult(value: unknown): boolean;
+export {};

package/dist/core/step-context.js

@@ -0,0 +1,113 @@
+export class StepContext {
+  workflowId;
+  signal;
+  #queue = [];
+  #notifyQueue;
+  #done = !1;
+  constructor(workflowId, signal) {
+    this.workflowId = workflowId;
+    this.signal = signal;
+  }
+  async step(name, fn) {
+    const operationId = crypto.randomUUID(), { promise, resolve, reject } = Promise.withResolvers();
+    this.#queue.push({
+      request: {
+        type: "activity",
+        operationId,
+        activityName: name,
+        fn,
+        input: void 0
+      },
+      resolve,
+      reject
+    });
+    this.#notifyQueue?.();
+    return promise;
+  }
+  async dequeue() {
+    if (this.#queue.length > 0)
+      return this.#queue.shift();
+    if (this.#done)
+      return null;
+    const { promise, resolve } = Promise.withResolvers();
+    this.#notifyQueue = resolve;
+    await promise;
+    this.#notifyQueue = void 0;
+    if (this.#done && this.#queue.length === 0)
+      return null;
+    return this.#queue.shift() ?? null;
+  }
+  signalDone() {
+    this.#done = !0;
+    this.#notifyQueue?.();
+  }
+}
+export function compileStepWorkflow(stepFunction) {
+  return async function* (_rawContext, input) {
+    const rawContext = _rawContext, stepContext = new StepContext(rawContext.workflowId, rawContext.signal);
+    let workflowResult, workflowError;
+    const userPromise = stepFunction(stepContext, input).then((result) => {
+      workflowResult = result;
+      stepContext.signalDone();
+      return;
+    }).catch((error) => {
+      workflowError = error;
+      stepContext.signalDone();
+    });
+    while (!0) {
+      const queued = await stepContext.dequeue();
+      if (queued === null)
+        break;
+      try {
+        const result = yield queued.request;
+        queued.resolve(result);
+      } catch (error) {
+        queued.reject(error);
+      }
+    }
+    await userPromise;
+    if (workflowError !== void 0) {
+      if (workflowError instanceof Error)
+        throw workflowError;
+      throw Error(typeof workflowError === "string" ? workflowError : JSON.stringify(workflowError));
+    }
+    return workflowResult;
+  };
+}
+function* sampleSyncGenerator() {
+  yield void 0;
+}
+async function* sampleAsyncGenerator() {
+  yield void 0;
+}
+function getGeneratorDetectionPrototypes() {
+  sampleSyncGenerator().next();
+  sampleAsyncGenerator().next();
+  return {
+    syncGeneratorFunctionPrototype: Object.getPrototypeOf(sampleSyncGenerator),
+    asyncGeneratorFunctionPrototype: Object.getPrototypeOf(sampleAsyncGenerator),
+    syncGeneratorPrototype: Object.getPrototypeOf(sampleSyncGenerator.prototype),
+    asyncGeneratorPrototype: Object.getPrototypeOf(sampleAsyncGenerator.prototype)
+  };
+}
+const {
+  syncGeneratorFunctionPrototype: SYNC_GENERATOR_FUNCTION_PROTOTYPE,
+  asyncGeneratorFunctionPrototype: ASYNC_GENERATOR_FUNCTION_PROTOTYPE,
+  syncGeneratorPrototype: SYNC_GENERATOR_PROTOTYPE,
+  asyncGeneratorPrototype: ASYNC_GENERATOR_PROTOTYPE
+} = getGeneratorDetectionPrototypes();
+export function isGeneratorFunction(fn) {
+  return Object.getPrototypeOf(fn) === SYNC_GENERATOR_FUNCTION_PROTOTYPE;
+}
+export function isAsyncGeneratorFunction(fn) {
+  return Object.getPrototypeOf(fn) === ASYNC_GENERATOR_FUNCTION_PROTOTYPE;
+}
+export function isGeneratorResult(value) {
+  if (value === null || typeof value !== "object")
+    return !1;
+  const directPrototype = Object.getPrototypeOf(value);
+  if (directPrototype === null)
+    return !1;
+  const sharedPrototype = Object.getPrototypeOf(directPrototype);
+  return sharedPrototype === SYNC_GENERATOR_PROTOTYPE || sharedPrototype === ASYNC_GENERATOR_PROTOTYPE;
+}