@lostgradient/weft 0.2.0 → 0.2.1

package/dist/core/types/options.d.ts

@@ -52,6 +52,65 @@ export interface StartOptions {
     startAfter?: Duration;
     tags?: string[];
     searchAttributes?: Record<string, SearchAttributeValue>;
+    /**
+     * Host-supplied, per-run capabilities exposed to the workflow body as
+     * `ctx.services` (live clients, closures, tool registries). The value is
+     * **never checkpointed**; on a fresh-process recovery it is re-provided by the
+     * engine's {@link EngineOptions.resolveWorkflowServices} resolver before the
+     * generator advances.
+     *
+     * Inline execution mode only. Passing `services` under
+     * `workflowExecutionMode: 'worker'` throws at `engine.start()`, because a
+     * non-serializable value cannot cross to a Worker.
+     */
+    services?: unknown;
+}
+/**
+ * Result of {@link EngineOptions.resolveWorkflowServices}. An explicit union
+ * rather than a nullable return: `'unavailable'` is a deliberate, named outcome
+ * (the run's dependencies cannot be rebuilt in this process) that fails just
+ * that recovered run — it does not overload the resolved value with a lifecycle
+ * signal.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolution } from '@lostgradient/weft';
+ *
+ * const ok: WorkflowServicesResolution = {
+ *   status: 'available',
+ *   services: { db: { query: () => [] } },
+ * };
+ * const no: WorkflowServicesResolution = { status: 'unavailable', reason: 'no config' };
+ * void ok;
+ * void no;
+ * ```
+ */
+export type WorkflowServicesResolution = {
+    status: 'available';
+    services: unknown;
+} | {
+    status: 'unavailable';
+    reason: string;
+};
+/**
+ * Information passed to {@link EngineOptions.resolveWorkflowServices} for each
+ * recovered workflow. `input` is the original durable launch input, available
+ * at resume time — typically enough to rebuild the run's dependencies (tenant,
+ * model, tool registry) without a side table.
+ *
+ * @example
+ * ```ts
+ * import { type WorkflowServicesResolverInfo } from '@lostgradient/weft';
+ *
+ * function describe(info: WorkflowServicesResolverInfo): string {
+ *   return `${info.workflowType}/${info.workflowId}`;
+ * }
+ * ```
+ */
+export interface WorkflowServicesResolverInfo {
+    workflowId: string;
+    workflowType: string;
+    input: unknown;
 }
 /**
  * Options for {@link Engine.fork}. Controls which checkpoint step to fork
@@ -197,6 +256,36 @@ export interface EngineOptions {
      * after passing it has no effect.
      */
     interceptors?: readonly Interceptor[];
+    /**
+     * Re-provide the non-serialized per-run `services` value (see
+     * {@link StartOptions.services}) for a workflow recovered in a fresh process.
+     * `engine.recoverAll()` and `engine.resume(id)` call this **before** the
+     * generator is driven forward (and the delayed-start timer handler calls it
+     * for a `startAfter`/`startAt` run that crashed before firing), so the resumed
+     * body can read `ctx.services` exactly as it did before the crash.
+     *
+     * Return `{ status: 'available', services }` to supply the rebuilt
+     * capabilities, or `{ status: 'unavailable', reason }` to fail just that one
+     * recovered run — the engine and every other recovered run are unaffected.
+     * Without a resolver, a recovered inline workflow that reads `ctx.services`
+     * sees `undefined`.
+     *
+     * Contract a fresh integrator must know:
+     * - Fires only for recovered inline runs that were launched WITH `services`
+     *   (those carrying the durable "expects services" marker). A run started
+     *   without `services` never reaches the resolver, regardless of what it would
+     *   return — so a fail-closed resolver does not fail innocent no-services runs.
+     * - `{ status: 'unavailable' }` permanently fails the run (terminal `failed`,
+     *   `system` category) with `reason` as the message — not a "retry later"
+     *   signal. A resolver *throw* is treated identically (error message → reason).
+     * - May be called again on a later boot if a prior recovery left the run still
+     *   recoverable (e.g. the terminal-fail commit faulted), so keep it idempotent.
+     * - Inline only; worker-mode runs never invoke it.
+     *
+     * Engine-scoped: each engine instance carries its own resolver, so two engines
+     * in one process never collide on per-run dependency reconstruction.
+     */
+    resolveWorkflowServices?: (info: WorkflowServicesResolverInfo) => WorkflowServicesResolution | Promise<WorkflowServicesResolution>;
 }
 /**
  * Filter criteria for {@link Engine.list}. All fields are optional and

package/dist/core/types/workflow-context.d.ts

@@ -57,6 +57,31 @@ export interface WorkflowContext<TActivities extends ActivityMap = {}, TSignals
     readonly executionTimeRemaining: number;
     readonly startedAt: number;
     readonly state: WorkflowStateNamespace;
+    /**
+     * Host-supplied, per-run capabilities passed at launch via
+     * `engine.start(type, input, { services })` (or `ctx.run`-free closures, live
+     * clients, tool registries). The value is **never checkpointed**: it is held
+     * only in engine memory for this run, and on a fresh-process recovery it is
+     * re-provided by the engine's `resolveWorkflowServices` resolver before the
+     * generator advances. `undefined` when no services were supplied (and not yet
+     * re-provided on recovery). Inline execution mode only — passing `services`
+     * under `workflowExecutionMode: 'worker'` throws at `engine.start()`, since a
+     * non-serializable value cannot cross to a Worker.
+     *
+     * Typed `unknown`: narrow or cast at the call site
+     * (`const { db } = ctx.services as MyServices`). A threaded generic is a
+     * deliberate follow-on, not part of this surface yet. Optional so existing
+     * structural `WorkflowContext` implementors are not source-broken.
+     *
+     * Separate child *workflows* started from within a workflow (`ctx.startChild()`)
+     * do **not** inherit the parent's `services` — each run is its own workflow with
+     * its own services, configured the same way (and re-provided on recovery by the
+     * engine's `resolveWorkflowServices`). This is distinct from a *speculative
+     * child context*, which is the same run advanced in-memory for speculative
+     * replay (same `workflowId`) and therefore does carry the run's `services`
+     * across.
+     */
+    readonly services?: unknown;
     run<TName extends keyof TActivities & string>(name: TName, ...rest: ActivityArgsFor<TActivities[TName]>): WorkflowOperation<ActivityResultFor<TActivities[TName]>>;
     run<TName extends keyof TActivities & string>(name: TName, ...rest: [...ActivityArgsFor<TActivities[TName]>, ActivityCallOptions]): WorkflowOperation<ActivityResultFor<TActivities[TName]>>;
     run<TName extends string>(name: UnknownNameWhenRegistryHasNoKnownNames<TName, keyof TActivities & string>, input?: unknown, options?: ActivityCallOptions): WorkflowOperation<unknown>;

package/dist/core/weft-error.d.ts

@@ -5,16 +5,16 @@
  * exported from `@lostgradient/weft` carry internal codes that are intentionally absent
  * from this union and may change between releases.
  *
- * Prefer comparing `error.code` (or {@link isWeftErrorCode}) over `instanceof`
+ * Prefer comparing `error.code` (or {@link isWeftErrorLike}) over `instanceof`
  * when an error may have crossed a realm or duplicate-module boundary, where
  * `instanceof` is unreliable.
  *
  * @example
  * ```ts
- * import { isWeftError, isWeftErrorCode, type WeftErrorCode } from '@lostgradient/weft';
+ * import { isWeftErrorLike, type WeftErrorCode } from '@lostgradient/weft';
  *
  * function statusFor(error: unknown): number {
- *   if (isWeftError(error) && isWeftErrorCode(error.code)) {
+ *   if (isWeftErrorLike(error)) {
  *     const code: WeftErrorCode = error.code;
  *     return code === 'WorkflowNotFoundError' ? 404 : 400;
  *   }
@@ -50,8 +50,10 @@ export declare abstract class WeftError<TCode extends string = string> extends E
 /**
  * Same-realm narrowing: `true` when `value` is a Weft library error instance.
  * Use this for the common case of catching any Weft error. For comparisons
- * that may cross a realm or duplicate-module boundary, narrow on
- * {@link isWeftErrorCode} against `error.code` instead.
+ * that may cross a realm or duplicate-module boundary (where `instanceof` is
+ * unreliable), use {@link isWeftErrorLike} instead — it narrows the error
+ * object structurally. {@link isWeftErrorCode} narrows a bare `code` *string*,
+ * not a caught `unknown`.
  *
  * @example
  * ```ts
@@ -64,19 +66,49 @@ export declare abstract class WeftError<TCode extends string = string> extends E
  */
 export declare function isWeftError(value: unknown): value is WeftError;
 /**
- * Cross-boundary structural check: `true` when `value` is one of the public
- * {@link WeftErrorCode} values. Pair with {@link isWeftError} to safely switch
- * over public codes: `if (isWeftError(e) && isWeftErrorCode(e.code)) { ... }`.
+ * Cross-boundary discriminant check: `true` when `value` is one of the public
+ * {@link WeftErrorCode} string values. This narrows a `code` *string*; to test
+ * a caught `unknown` (the common `catch` case), reach for {@link isWeftErrorLike},
+ * which checks the whole error object structurally.
  *
  * @example
  * ```ts
- * import { isWeftError, isWeftErrorCode } from '@lostgradient/weft';
+ * import { isWeftErrorCode } from '@lostgradient/weft';
  *
- * function isMissingWorkflow(error: unknown): boolean {
- *   return isWeftError(error) && isWeftErrorCode(error.code)
- *     ? error.code === 'WorkflowNotFoundError'
- *     : false;
+ * function isPublicCode(code: string): boolean {
+ *   return isWeftErrorCode(code);
  * }
  * ```
  */
 export declare function isWeftErrorCode(value: unknown): value is WeftErrorCode;
+/**
+ * Cross-boundary structural narrowing: `true` when `value` looks like a public
+ * Weft error — an object carrying a public {@link WeftErrorCode} `code` and a
+ * string `message`. Unlike {@link isWeftError}, this does *not* use `instanceof`,
+ * so it stays reliable when the error crossed a realm or duplicate-module
+ * boundary — the common case when Weft is a transitive dependency in a monorepo,
+ * where two copies of the `WeftError` class make `instanceof` fail.
+ *
+ * Use this in a `catch` to branch on a caught `unknown` without first proving
+ * `instanceof`. It is the structural counterpart to {@link isWeftError}: prefer
+ * `isWeftError` for same-realm catches where you want the live class instance,
+ * and `isWeftErrorLike` whenever the error may have crossed a module boundary.
+ * To match a *specific* code, narrow with this guard then compare `error.code`
+ * — TypeScript narrows it to the matched literal in the branch.
+ *
+ * @example
+ * ```ts
+ * import { isWeftErrorLike } from '@lostgradient/weft';
+ *
+ * function statusFor(error: unknown): number {
+ *   if (isWeftErrorLike(error)) {
+ *     return error.code === 'WorkflowNotFoundError' ? 404 : 400;
+ *   }
+ *   return 500;
+ * }
+ * ```
+ */
+export declare function isWeftErrorLike(value: unknown): value is {
+    code: WeftErrorCode;
+    message: string;
+};

package/dist/core/weft-error.js

@@ -41,3 +41,12 @@ export function isWeftError(value) {
 export function isWeftErrorCode(value) {
   return typeof value === "string" && PUBLIC_WEFT_ERROR_CODES.has(value);
 }
+export function isWeftErrorLike(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  try {
+    return "code" in value && isWeftErrorCode(value.code) && "message" in value && typeof value.message === "string";
+  } catch {
+    return !1;
+  }
+}

package/dist/index.d.ts

@@ -8,17 +8,22 @@
  *
  * For end-to-end usage examples see the {@link Engine} class.
  *
+ * This is the package's public re-export barrel: it contains only `export`
+ * statements, no logic, and grows one line per public symbol. Line count here
+ * is semantically meaningless, so it carries a `max-lines: off` override in
+ * `.oxlintrc.json` (unlike logic-bearing files, which keep the numeric ceiling).
+ *
  * @module weft
  */
 export { VERSION } from './version.ts';
-export { WeftError, isWeftError, isWeftErrorCode } from './core/weft-error.ts';
+export { WeftError, isWeftError, isWeftErrorCode, isWeftErrorLike } from './core/weft-error.ts';
 export type { WeftErrorCode } from './core/weft-error.ts';
 export { FAULT_CODE_TO_FAILURE_CATEGORY, failureCategoryForFaultCode, isFaultCode, } from './core/fault-code.ts';
 export type { FaultCode } from './core/fault-code.ts';
 export { ActivityReconciliationCapabilityError, ActivityReconciliationConflictError, ActivityReconciliationIndeterminateError, ActivityResolutionError, AsyncActivityTokenNotFoundError, BulkDeleteRequiresTerminalWorkflowsError, BulkOperationConfirmationError, Engine, EngineCreateNameMismatchError, EngineDisposedError, PersistedDataIncompatibleError, ScheduleHandle, WorkflowAlreadyExistsError, WorkflowHandle, WorkflowNotFoundError, WorkflowNotRegisteredError, WorkflowTypeNotRegisteredForRecoveryError, } from './core/engine';
 export type { EngineCreateOptions, EngineStateNamespace, RecoverAllOptions } from './core/engine';
 export { DEFAULT_CHECKPOINT_SIZE_WARNING_THRESHOLD, DEFAULT_MAX_NESTING_DEPTH, DEFAULT_RETRY_POLICY, DEFAULT_VISIBILITY_TIMEOUT_MS, HISTORY_CIRCUIT_BREAKER_REASON, WorkflowBuilderError, query, schedule, signal, update, workflow, } from './core/types';
-export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowRegistry, WorkflowReplay, WorkflowSessionState, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
+export type { ActivityArgsFor, ActivityCallOptions, ActivityCallable, ActivityContext, ActivityDefinition, ActivityEntryInput, ActivityFunction, ActivityMap, ActivityMapInput, ActivityObjectInput, ActivityResultFor, ActivityVerificationContext, ActivityVerificationPhase, ActivityVerificationResult, AnyActivityDefinition, AnyWorkflowDefinition, ArchiveAdapter, BuilderState, BuiltWorkflowDefinition, BulkCancelResult, BulkDeleteResult, BulkOperationAction, BulkOperationAuditEvent, BulkOperationCommitOptions, BulkOperationDryRunOptions, BulkOperationDryRunResult, BulkOperationError, BulkOperationFilterSummary, BulkOperationOptions, BulkOperationPrincipal, BulkOperationScopeSummary, BulkSignalAllCommitOptions, BulkSignalAllDryRunOptions, BulkSignalAllOptions, BulkSignalResult, BulkTagResult, Checkpoint, CheckpointState, CheckpointSummary, CompletedReviewEntry, CoordinatedUpdateResult, DefinitionSchema, Duration, EngineOptions, FailureCategory, ForkLineage, ForkOptions, HistoryPolicy, InferActivityEntries, InferActivityEntry, InferWorkflowEntries, InferWorkflowEntry, InitialBuilderState, ListFilter, ListOptions, MarkBuilderState, NormalizeActivities, NormalizedActivityEntry, NormalizedRetentionPolicy, PaginatedResult, PayloadSizePolicy, PendingReviewEntry, PurgeResult, QueryDefinition, QueryMap, QueryShape, RegisteredWorkflowDefinition, RetentionOverview, RetentionPolicy, RetryPolicy, ReviewListEntry, ReviewListFilter, ReviewStatus, ScheduleDefinition, ScheduleFilter, ScheduleOptions, ScheduleOverlapPolicy, ScheduleSpec, ScheduleState, ScheduleStatus, ScheduleSummary, SearchAttributeDefinition, SearchAttributeHandle, SearchAttributeSchema, SearchAttributeValue, Serializer, SignalDefinition, SignalDeliveryOptions, SignalMap, SignalPayload, StartOptions, SubmitReviewOptions, TerminationReason, UpdateDefinition, UpdateMap, UpdatePayload, WorkerReplayOperationFailure, WorkerReplayOperationSignature, WorkflowAlreadyRegistered, WorkflowAtomicState, WorkflowAtomicStateOptions, WorkflowBuilder, WorkflowBuilderOptions, WorkflowContext, WorkflowDefinition, WorkflowEvent, WorkflowFunction, WorkflowGenerator, WorkflowId, WorkflowRegistry, WorkflowReplay, WorkflowServicesResolution, WorkflowServicesResolverInfo, WorkflowSessionState, WorkflowState, WorkflowStateNamespace, WorkflowStatus, WorkflowSummary, WorkflowTimelineEntry, WorkflowTimelineStatus, WorkflowTypeRetentionPolicy, } from './core/types';
 export { AlertManager } from './alerting/index';
 export type { AlertAction, AlertMetric, AlertRule, AlertState, AlertStatus, AlertingOptions, WebhookTarget, } from './alerting/types';
 export { ActivityAsyncPendingEvent, ActivityCompletedEvent, ActivityFailedEvent, ActivityStartedEvent, AlertFiredEvent, AlertResolvedEvent, AttributesChangedEvent, CheckpointSizeWarningEvent, ConstraintViolatedEvent, DevelopmentWarningEvent, SignalDeliveredEvent, SignalReceivedEvent, StorageSizeReportedEvent, UpdateCompletedEvent, UpdateReceivedEvent, WorkflowCancelledEvent, WorkflowCompletedEvent, WorkflowFailedEvent, WorkflowRecoverySkippedEvent, WorkflowResumedEvent, WorkflowStartedEvent, WorkflowTimedOutEvent, } from './core/events';

package/dist/index.js

@@ -1,5 +1,5 @@
 export { VERSION } from "./version.js";
-export { WeftError, isWeftError, isWeftErrorCode } from "./core/weft-error.js";
+export { WeftError, isWeftError, isWeftErrorCode, isWeftErrorLike } from "./core/weft-error.js";
 export {
   FAULT_CODE_TO_FAILURE_CATEGORY,
   failureCategoryForFaultCode,

package/dist/json-schema.js

@@ -1,4 +1,4 @@
 // @bun
-var B=Object.defineProperty;var D=(j)=>j;function L(j,q){this[j]=D.bind(null,q)}var _=(j,q)=>{for(var z in q)B(j,z,{get:q[z],enumerable:!0,configurable:!0,set:L.bind(q,z)})};var X=(j,q)=>()=>(j&&(q=j(j=0)),q);var K,U,N;var Y=X(()=>{K=class K extends Error{code;constructor(j,q,z){super(q,z);this.code=j,this.name=j}};U={WorkflowAlreadyExistsError:!0,BulkDeleteRequiresTerminalWorkflowsError:!0,BulkOperationConfirmationError:!0,WorkflowTypeNotRegisteredForRecoveryError:!0,EngineCreateNameMismatchError:!0,EngineDisposedError:!0,WorkflowNotFoundError:!0,WorkflowNotRegisteredError:!0,ActivityResolutionError:!0,PersistedDataIncompatibleError:!0,WorkflowTimeoutError:!0,HttpClientError:!0,WorkerProtocolIncompatibleError:!0,UpdateTimeoutError:!0,UpdateValidationError:!0,WorkflowTerminalError:!0,WorkflowBuilderError:!0,VersionMismatchError:!0,EffectReplayConflictError:!0,ReviewTimeoutError:!0,AtomicStateConflictError:!0,StandardSchemaValidationError:!0,ActivityReconciliationCapabilityError:!0,ActivityReconciliationConflictError:!0,ActivityReconciliationIndeterminateError:!0,AsyncActivityTokenNotFoundError:!0,PayloadSizeExceededError:!0},N=new Set(Object.keys(U))});async function Z(j,q,z){let G=j["~standard"];if(!J(G))throw TypeError(`Schema for ${z.fieldName} does not provide runtime validation. Attach a Standard Schema validator (Zod, Valibot, or another vendor) or supply a runtime-validating schema at this boundary.`);let H=await G.validate(q);if(H.issues===void 0)return H.value;throw new A({fieldName:z.fieldName,operation:z.operation,issues:H.issues.map(O)})}function Q(j){return j.map((q)=>q.path===""?q.message:`${q.path}: ${q.message}`).join(`
-`)}function J(j){return typeof j.validate==="function"}function O(j){return{message:j.message,path:T(j.path)}}function T(j){if(j===void 0||j.length===0)return"";let q="";for(let z of j)q+="/",q+=y(z);return q}function y(j){let q=F(j)?j.key:j;return M(String(q))}function F(j){return j!==null&&typeof j==="object"&&"key"in j}function M(j){return j.replace(/~/g,"~0").replace(/\//g,"~1")}function R(j,q,z){return`Validation failed for ${q===void 0?j:`${q} ${j}`}:
-${Q(z)}`}var A;var $=X(()=>{Y();A=class A extends K{fieldName;operation;issues;constructor(j){super("StandardSchemaValidationError",R(j.fieldName,j.operation,j.issues));this.fieldName=j.fieldName,this.operation=j.operation,this.issues=j.issues}}});$();var C=Q,x=A,k=Z;export{k as validateStandardSchema,C as formatStandardSchemaIssues,x as StandardSchemaValidationError};
+var w=Object.defineProperty;var y=(j)=>j;function B(j,q){this[j]=y.bind(null,q)}var T=(j,q)=>{for(var z in q)w(j,z,{get:q[z],enumerable:!0,configurable:!0,set:B.bind(q,z)})};var X=(j,q)=>()=>(j&&(q=j(j=0)),q);var K,D,_;var Y=X(()=>{K=class K extends Error{code;constructor(j,q,z){super(q,z);this.code=j,this.name=j}};D={WorkflowAlreadyExistsError:!0,BulkDeleteRequiresTerminalWorkflowsError:!0,BulkOperationConfirmationError:!0,WorkflowTypeNotRegisteredForRecoveryError:!0,EngineCreateNameMismatchError:!0,EngineDisposedError:!0,WorkflowNotFoundError:!0,WorkflowNotRegisteredError:!0,ActivityResolutionError:!0,PersistedDataIncompatibleError:!0,WorkflowTimeoutError:!0,HttpClientError:!0,WorkerProtocolIncompatibleError:!0,UpdateTimeoutError:!0,UpdateValidationError:!0,WorkflowTerminalError:!0,WorkflowBuilderError:!0,VersionMismatchError:!0,EffectReplayConflictError:!0,ReviewTimeoutError:!0,AtomicStateConflictError:!0,StandardSchemaValidationError:!0,ActivityReconciliationCapabilityError:!0,ActivityReconciliationConflictError:!0,ActivityReconciliationIndeterminateError:!0,AsyncActivityTokenNotFoundError:!0,PayloadSizeExceededError:!0},_=new Set(Object.keys(D))});async function Z(j,q,z){let G=j["~standard"];if(!L(G))throw TypeError(`Schema for ${z.fieldName} does not provide runtime validation. Attach a Standard Schema validator (Zod, Valibot, or another vendor) or supply a runtime-validating schema at this boundary.`);let H=await G.validate(q);if(H.issues===void 0)return H.value;throw new A({fieldName:z.fieldName,operation:z.operation,issues:H.issues.map(U)})}function Q(j){return j.map((q)=>q.path===""?q.message:`${q.path}: ${q.message}`).join(`
+`)}function L(j){return typeof j.validate==="function"}function U(j){return{message:j.message,path:b(j.path)}}function b(j){if(j===void 0||j.length===0)return"";let q="";for(let z of j)q+="/",q+=F(z);return q}function F(j){let q=J(j)?j.key:j;return M(String(q))}function J(j){return j!==null&&typeof j==="object"&&"key"in j}function M(j){return j.replace(/~/g,"~0").replace(/\//g,"~1")}function O(j,q,z){return`Validation failed for ${q===void 0?j:`${q} ${j}`}:
+${Q(z)}`}var A;var $=X(()=>{Y();A=class A extends K{fieldName;operation;issues;constructor(j){super("StandardSchemaValidationError",O(j.fieldName,j.operation,j.issues));this.fieldName=j.fieldName,this.operation=j.operation,this.issues=j.issues}}});$();var V=Q,P=A,W=Z;export{W as validateStandardSchema,V as formatStandardSchemaIssues,P as StandardSchemaValidationError};