effect 4.0.0-beta.98 → 4.0.0-rc.108

package/src/unstable/workflow/DurableQueue.ts

@@ -61,8 +61,8 @@ export interface DurableQueue<
  *
  * **Example** (Defining a durable queue with workers)
  *
- * ```ts
- * import { Effect, Schema } from "effect"
+ * ```ts import.meta.vitest
+ * import { Effect, Layer, Schema } from "effect"
  * import { DurableQueue, Workflow } from "effect/unstable/workflow"
  *
  * // Define a DurableQueue that can be used to derive workers and offer items for
@@ -88,25 +88,27 @@ export interface DurableQueue<
  *
  * const MyWorkflowLayer = MyWorkflow.toLayer(
  *   Effect.fnUntraced(function*() {
- *     // Add an item to the DurableQueue defined above.
- *     //
- *     // When the worker has finished processing the item, the workflow will
- *     // resume.
- *     //
+ *     // The workflow suspends until a worker completes this queue item.
  *     yield* DurableQueue.process(ApiQueue, { id: "api-call-1" })
- *
- *     yield* Effect.log("Workflow succeeded!")
+ *     return "Workflow succeeded!"
  *   })
  * )
  *
- * // Define a worker layer that can process items from the DurableQueue.
- * const ApiWorker = DurableQueue.worker(
- *   ApiQueue,
- *   Effect.fnUntraced(function*({ id }) {
- *     yield* Effect.log(`Worker processing API call with id: ${id}`)
- *   }),
- *   { concurrency: 5 } // Process up to 5 items concurrently
- * )
+ * const processed: Array<string> = []
+ * const processApiCall = ({ id }: { readonly id: string }) => Effect.sync(() => processed.push(id))
+ *
+ * // Construct the worker layer without starting background workers in this example.
+ * const ApiWorker = DurableQueue.worker(ApiQueue, processApiCall, {
+ *   concurrency: 5
+ * })
+ *
+ * const program = Effect.gen(function*() {
+ *   // Exercise the finite handler directly instead of running a queue worker.
+ *   yield* processApiCall({ id: "api-call-1" })
+ *   return [Layer.isLayer(MyWorkflowLayer), Layer.isLayer(ApiWorker), processed] as const
+ * })
+ *
+ * await Effect.runPromise(program) // => [true, true, ["api-call-1"]]
  * ```
  *
  * @category constructors
@@ -170,7 +172,7 @@ const getQueueSchema = <Payload extends Schema.Top>(
 /**
  * Adds an item to the queue and wait for a worker to process it.
  *
- * @category Processing
+ * @category running
  * @since 4.0.0
  */
 export const process: <
@@ -247,7 +249,7 @@ const defaultRetrySchedule = Schedule.min([
 /**
  * Create a worker effect that processes items from the durable queue.
  *
- * @category Worker
+ * @category workers
  * @since 4.0.0
  */
 export const makeWorker: <
@@ -334,7 +336,7 @@ export const makeWorker: <
 /**
  * Create a layer that runs workers for the durable queue.
  *
- * @category Worker
+ * @category workers
  * @since 4.0.0
  */
 export const worker: <

package/src/unstable/workflow/Workflow.ts

@@ -20,7 +20,7 @@ import * as Fiber from "../../Fiber.ts"
 import * as Filter from "../../Filter.ts"
 import { constFalse, constTrue, dual, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
-import * as Option from "../../Option.ts"
+import type * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import type * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
@@ -200,7 +200,7 @@ export interface AnyStructSchema extends Schema.Top {
  * Type-level marker for services associated with a specific workflow
  * execution tag.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export interface Execution<Tag extends string> {
@@ -252,7 +252,7 @@ export interface AnyWithProps extends Any {
 /**
  * Extracts the payload schema from a `Workflow`.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type PayloadSchema<W> = W extends Workflow<
@@ -267,7 +267,7 @@ export type PayloadSchema<W> = W extends Workflow<
  * Computes the schema services required by clients that execute or poll
  * workflows.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type RequirementsClient<Workflows extends Any> = Workflows extends Workflow<
@@ -285,7 +285,7 @@ export type RequirementsClient<Workflows extends Any> = Workflows extends Workfl
  * Computes the schema services required by handlers that decode workflow
  * payloads and encode workflow results.
  *
- * @category models
+ * @category utility types
  * @since 4.0.0
  */
 export type RequirementsHandler<Workflows extends Any> = Workflows extends Workflow<
@@ -465,7 +465,7 @@ const ResultTypeId = "~effect/workflow/Workflow/Result"
 /**
  * Returns `true` when a value is a workflow `Result`.
  *
- * @category results
+ * @category guards
  * @since 4.0.0
  */
 export const isResult = <A = unknown, E = unknown>(
@@ -476,7 +476,7 @@ export const isResult = <A = unknown, E = unknown>(
  * Result of a workflow execution, either a completed exit or a suspended
  * workflow state.
  *
- * @category results
+ * @category models
  * @since 4.0.0
  */
 export type Result<A, E> = Complete<A, E> | Suspended
@@ -484,7 +484,7 @@ export type Result<A, E> = Complete<A, E> | Suspended
 /**
  * Encoded representation of a workflow `Result`.
  *
- * @category results
+ * @category models
  * @since 4.0.0
  */
 export type ResultEncoded<A, E> =
@@ -495,7 +495,7 @@ export type ResultEncoded<A, E> =
  * Encoded representation of a completed workflow result containing an encoded
  * `Exit`.
  *
- * @category results
+ * @category models
  * @since 4.0.0
  */
 export interface CompleteEncoded<A, E> {
@@ -527,7 +527,7 @@ export interface CompleteSchema<
 /**
  * Represents a completed workflow execution with its success or failure `Exit`.
  *
- * @category results
+ * @category models
  * @since 4.0.0
  */
 export class Complete<A, E> extends Data.TaggedClass("Complete")<{
@@ -557,16 +557,13 @@ export class Complete<A, E> extends Data.TaggedClass("Complete")<{
       [Schema.Exit(options.success, options.error, Schema.Defect())],
       ([exit]) => (input, ast, options) => {
         if (!(isResult(input) && input._tag === "Complete")) {
-          return Effect.fail(new SchemaIssue.InvalidType(ast, Option.some(input)))
+          return Effect.fail(new SchemaIssue.InvalidType(ast, input, options))
         }
         return Effect.mapBothEager(
           SchemaParser.decodeEffect(exit)(input.exit, options),
           {
             onSuccess: (exit) => new Complete({ exit }),
-            onFailure: (issue) =>
-              new SchemaIssue.Composite(ast, Option.some(input), [
-                new SchemaIssue.Pointer(["exit"], issue)
-              ])
+            onFailure: (issue) => SchemaIssue.makeCompositeAtKey(ast, "exit", issue, input, options)
           }
         )
       },
@@ -599,7 +596,7 @@ export class Complete<A, E> extends Data.TaggedClass("Complete")<{
  * Represents a suspended workflow execution, optionally carrying the cause that
  * triggered suspension.
  *
- * @category results
+ * @category schemas
  * @since 4.0.0
  */
 export class Suspended extends Schema.Class<Suspended>(
@@ -620,7 +617,7 @@ export class Suspended extends Schema.Class<Suspended>(
  * Creates a schema for workflow results using the supplied success and error
  * schemas.
  *
- * @category results
+ * @category schemas
  * @since 4.0.0
  */
 export const Result = <
@@ -636,7 +633,7 @@ const AnyOrVoid = Schema.Union([Schema.Any, Schema.Void])
 /**
  * Schema for encoded workflow results with generic success and error payloads.
  *
- * @category results
+ * @category schemas
  * @since 4.0.0
  */
 export const ResultEncoded: Schema.Codec<ResultEncoded<any, any>> = Schema.toEncoded(
@@ -653,7 +650,7 @@ export const ResultEncoded: Schema.Codec<ResultEncoded<any, any>> = Schema.toEnc
  * `Result`, handling suspension, defect capture, interruption, and workflow
  * scope finalization.
  *
- * @category results
+ * @category converting
  * @since 4.0.0
  */
 export const intoResult = <A, E, R>(
@@ -716,7 +713,7 @@ export const intoResult = <A, E, R>(
  * Wraps an activity-like effect so workflow suspension waits for currently
  * running activities to finish or suspend.
  *
- * @category results
+ * @category resource management
  * @since 4.0.0
  */
 export const wrapActivityResult = <A, E, R>(
@@ -825,7 +822,7 @@ export const addFinalizer: <R>(
  *
  * Compensation finalizers are only registered for top-level effects in the workflow and do not work for nested activities.
  *
- * @category Compensation
+ * @category compensation
  * @since 4.0.0
  */
 export const withCompensation: {
@@ -845,7 +842,7 @@ export const withCompensation: {
    *
    * Compensation finalizers are only registered for top-level effects in the workflow and do not work for nested activities.
    *
-   * @category Compensation
+   * @category compensation
    * @since 4.0.0
    */
   <A, R2>(
@@ -869,7 +866,7 @@ export const withCompensation: {
    *
    * Compensation finalizers are only registered for top-level effects in the workflow and do not work for nested activities.
    *
-   * @category Compensation
+   * @category compensation
    * @since 4.0.0
    */
   <A, E, R, R2>(
@@ -891,7 +888,7 @@ export const withCompensation: {
  * Marks a workflow instance as suspended and interrupts the current fiber to
  * stop execution until it is resumed.
  *
- * @category results
+ * @category interruption
  * @since 4.0.0
  */
 export const suspend = (instance: WorkflowInstance["Service"]): Effect.Effect<never> =>
@@ -908,7 +905,7 @@ export const suspend = (instance: WorkflowInstance["Service"]): Effect.Effect<ne
  *
  * By default, this annotation is set to `true`, meaning defects are captured.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const CaptureDefects = Context.Reference<boolean>(
@@ -925,7 +922,7 @@ export const CaptureDefects = Context.Reference<boolean>(
  *
  * The suspended execution can later be resumed with the workflow's `resume` method, for example `MyWorkflow.resume(executionId)`.
  *
- * @category annotations
+ * @category services
  * @since 4.0.0
  */
 export const SuspendOnFailure = Context.Reference<boolean>(

package/src/unstable/workflow/WorkflowEngine.ts

@@ -9,7 +9,7 @@
  *
  * @since 4.0.0
  */
-import type * as Cause from "../../Cause.ts"
+import * as Cause from "../../Cause.ts"
 import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
@@ -261,6 +261,9 @@ export class WorkflowInstance extends Context.Service<
      */
     cause: Cause.Cause<never> | undefined
 
+    /** Deferred names this run parked on; their completions preempt the run. */
+    readonly awaitedDeferreds: Set<string>
+
     readonly activityState: {
       count: number
       readonly latch: Latch.Latch
@@ -269,15 +272,17 @@ export class WorkflowInstance extends Context.Service<
 >()("effect/workflow/WorkflowEngine/WorkflowInstance") {
   static initial(
     workflow: Workflow.Any,
-    executionId: string
+    executionId: string,
+    scope = Scope.makeUnsafe()
   ): WorkflowInstance["Service"] {
     return WorkflowInstance.of({
       executionId,
       workflow,
-      scope: Scope.makeUnsafe(),
+      scope,
       suspended: false,
       interrupted: false,
       cause: undefined,
+      awaitedDeferreds: new Set(),
       activityState: {
         count: 0,
         latch: Latch.makeUnsafe()
@@ -286,11 +291,93 @@ export class WorkflowInstance extends Context.Service<
   }
 }
 
+/**
+ * In-process deferred state for live workflow executions.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface DeferredState {
+  /** Returns a completion not yet durably readable. */
+  readonly pendingResult: (
+    executionId: string,
+    name: string
+  ) => Exit.Exit<unknown, unknown> | undefined
+
+  /** Tracks and provides a run, retaining pending results across suspension. */
+  readonly trackRun: <A, E, R>(
+    instance: WorkflowInstance["Service"],
+    effect: Effect.Effect<A, E, R>
+  ) => Effect.Effect<A, E, Exclude<R, WorkflowInstance>>
+
+  /** Records a completion, preempting a run parked on that deferred. */
+  readonly deferredDone: (
+    executionId: string,
+    name: string,
+    exit: Exit.Exit<unknown, unknown>
+  ) => Effect.Effect<void>
+}
+
+/**
+ * Creates deferred state shared by workflow engines.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeDeferredState = (): DeferredState => {
+  const pending = new Map<string, Map<string, Exit.Exit<unknown, unknown>>>()
+  const running = new Map<string, {
+    readonly instance: WorkflowInstance["Service"]
+    readonly fiber: Fiber.Fiber<unknown, unknown>
+  }>()
+  return {
+    pendingResult: (executionId, name) => pending.get(executionId)?.get(name),
+    trackRun: (instance, effect) =>
+      Effect.withFiber((fiber) => {
+        const run = { instance, fiber: fiber as Fiber.Fiber<unknown, unknown> }
+        running.set(instance.executionId, run)
+        return Effect.ensuring(
+          Effect.provideService(effect, WorkflowInstance, instance),
+          Effect.sync(() => {
+            if (!instance.suspended) {
+              pending.delete(instance.executionId)
+            }
+            if (running.get(instance.executionId) === run) {
+              running.delete(instance.executionId)
+            }
+          })
+        )
+      }),
+    deferredDone: (executionId, name, exit) =>
+      Effect.withFiber((current) => {
+        const run = running.get(executionId)
+        if (!run) return Effect.void
+        let entries = pending.get(executionId)
+        if (!entries) {
+          entries = new Map()
+          pending.set(executionId, entries)
+        }
+        entries.set(name, exit)
+        if (
+          run.fiber === current ||
+          run.fiber.pollUnsafe() ||
+          !run.instance.awaitedDeferreds.has(name)
+        ) {
+          return Effect.void
+        }
+        // Suspended retains the pending result; the engine re-runs the
+        // interrupted run and the replay observes the completion.
+        run.instance.suspended = true
+        return Fiber.interrupt(run.fiber)
+      })
+  }
+}
+
 /**
  * Low-level workflow engine contract that works with encoded payloads and
  * results before `makeUnsafe` adds typed schema decoding and encoding.
  *
- * @category Encoded
+ * @category services
  * @since 4.0.0
  */
 export interface Encoded {
@@ -603,6 +690,8 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
     }
     const activities = new Map<string, ActivityState>()
 
+    const deferredState = makeDeferredState()
+
     const resume = Effect.fnUntraced(function*(executionId: string): Effect.fn.Return<void> {
       const state = executions.get(executionId)
       if (!state) return
@@ -614,7 +703,11 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
       }
 
       const entry = workflows.get(state.instance.workflow._tag)!
-      const instance = WorkflowInstance.initial(state.instance.workflow, state.instance.executionId)
+      const instance = WorkflowInstance.initial(
+        state.instance.workflow,
+        state.instance.executionId,
+        state.instance.scope
+      )
       instance.interrupted = state.instance.interrupted
       state.instance = instance
       state.fiber = yield* state.execute(state.payload, state.instance.executionId).pipe(
@@ -626,8 +719,8 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
           return Effect.withFiber((fiber) => Effect.interruptible(Fiber.interrupt(fiber)))
         }),
         Workflow.intoResult,
-        Effect.provideService(WorkflowInstance, instance),
         Effect.provideService(WorkflowEngine, engine),
+        (effect) => deferredState.trackRun(instance, effect),
         Effect.tap((result) => {
           if (!state.parent || result._tag !== "Complete") {
             return Effect.void
@@ -669,7 +762,14 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
           yield* resume(options.executionId)
         }
         if (options.discard) return
-        return (yield* Fiber.join(state.fiber!)) as any
+        // Capture together so a wake that swaps in a replay cannot desync them.
+        const instance = state.instance
+        const exit = yield* Fiber.await(state.fiber!)
+        if (Exit.isFailure(exit) && Cause.hasInterruptsOnly(exit.cause) && instance.suspended) {
+          // A completion preempted the run; the caller retries into the replay.
+          return new Workflow.Suspended({}) as any
+        }
+        return (yield* exit) as any
       }),
       interrupt: Effect.fnUntraced(function*(_workflow, executionId) {
         const state = executions.get(executionId)
@@ -738,7 +838,10 @@ export const layerMemory: Layer.Layer<WorkflowEngine> = Layer.effect(WorkflowEng
           const id = `${options.executionId}/${options.deferredName}`
           if (deferredResults.has(id)) return Effect.void
           deferredResults.set(id, options.exit)
-          return resume(options.executionId)
+          return Effect.andThen(
+            deferredState.deferredDone(options.executionId, options.deferredName, options.exit),
+            resume(options.executionId)
+          )
         }),
       scheduleClock: (workflow, options) =>
         engine.deferredDone(options.clock.deferred, {

package/src/unstable/workflow/WorkflowProxy.ts

@@ -22,7 +22,7 @@ import type * as Workflow from "./Workflow.ts"
  *
  * **Example** (Deriving RPC endpoints from workflows)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Layer, Schema } from "effect"
  * import { RpcServer } from "effect/unstable/rpc"
  * import { Workflow, WorkflowProxy, WorkflowProxyServer } from "effect/unstable/workflow"
@@ -46,6 +46,7 @@ import type * as Workflow from "./Workflow.ts"
  * const ApiLayer = RpcServer.layer(MyRpcs).pipe(
  *   Layer.provide(WorkflowProxyServer.layerRpcHandlers(myWorkflows))
  * )
+ * const result = [MyRpcs.requests.size, Layer.isLayer(ApiLayer)] // => [3, true]
  * ```
  *
  * @category constructors
@@ -103,7 +104,7 @@ export type ConvertRpcs<Workflows extends Workflow.Any, Prefix extends string> =
  *
  * **Example** (Deriving HTTP API endpoints from workflows)
  *
- * ```ts
+ * ```ts import.meta.vitest
  * import { Layer, Schema } from "effect"
  * import { HttpApi, HttpApiBuilder } from "effect/unstable/httpapi"
  * import { Workflow, WorkflowProxy, WorkflowProxyServer } from "effect/unstable/workflow"
@@ -131,6 +132,7 @@ export type ConvertRpcs<Workflows extends Workflow.Any, Prefix extends string> =
  *     WorkflowProxyServer.layerHttpApi(MyApi, "workflows", myWorkflows)
  *   )
  * )
+ * const result = [Object.keys(MyApi.groups.workflows.endpoints).length, Layer.isLayer(ApiLayer)] // => [3, true]
  * ```
  *
  * @category constructors

package/dist/SchemaError.d.ts

@@ -1,53 +0,0 @@
-import type { Issue } from "./SchemaIssue.ts";
-declare const TypeId = "~effect/SchemaError/SchemaError";
-declare const SchemaError_base: new <A extends Record<string, any> = {}>(args: import("./Types.ts").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("./Cause.ts").YieldableError & {
-    readonly _tag: "SchemaError";
-} & Readonly<A>;
-/**
- * Error thrown (or returned as the error channel value) when schema decoding
- * or encoding fails.
- *
- * **Details**
- *
- * The `issue` field contains a structured {@link Issue} tree describing
- * every validation failure, including the path to the problematic value,
- * expected types, and actual values received. `message` renders the issue tree
- * as a human-readable string.
- *
- * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
- *
- * **Example** (Catching a SchemaError)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * try {
- *   Schema.decodeUnknownSync(Schema.Number)("not a number")
- * } catch (err) {
- *   if (Schema.isSchemaError(err)) {
- *     console.log(err.message)
- *     // Expected number, actual "not a number"
- *   }
- * }
- * ```
- *
- * @category errors
- * @since 4.0.0
- */
-export declare class SchemaError extends SchemaError_base<{
-    readonly issue: Issue;
-}> {
-    readonly [TypeId]: typeof TypeId;
-    constructor(issue: Issue);
-    get message(): string;
-    toString(): string;
-}
-/**
- * Returns `true` if `u` is a {@link SchemaError}.
- *
- * @category guards
- * @since 4.0.0
- */
-export declare function isSchemaError(u: unknown): u is SchemaError;
-export {};
-//# sourceMappingURL=SchemaError.d.ts.map

package/dist/SchemaError.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaError.d.ts","sourceRoot":"","sources":["../src/SchemaError.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAE7C,QAAA,MAAM,MAAM,oCAAoC,CAAA;;;;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,WAAY,SAAQ,iBAAgC;IAC/D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;CACtB,CAAC;IACA,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,MAAM,CAAS;IACzC,YAAY,KAAK,EAAE,KAAK,EAEvB;IACD,IAAa,OAAO,WAEnB;IACQ,QAAQ,WAEhB;CACF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,WAAW,CAE1D"}

package/dist/SchemaError.js

@@ -1,61 +0,0 @@
-/**
- * @since 4.0.0
- */
-import * as Data from "./Data.js";
-import * as Predicate from "./Predicate.js";
-const TypeId = "~effect/SchemaError/SchemaError";
-/**
- * Error thrown (or returned as the error channel value) when schema decoding
- * or encoding fails.
- *
- * **Details**
- *
- * The `issue` field contains a structured {@link Issue} tree describing
- * every validation failure, including the path to the problematic value,
- * expected types, and actual values received. `message` renders the issue tree
- * as a human-readable string.
- *
- * Use {@link isSchemaError} to narrow an unknown value to `SchemaError`.
- *
- * **Example** (Catching a SchemaError)
- *
- * ```ts
- * import { Schema } from "effect"
- *
- * try {
- *   Schema.decodeUnknownSync(Schema.Number)("not a number")
- * } catch (err) {
- *   if (Schema.isSchemaError(err)) {
- *     console.log(err.message)
- *     // Expected number, actual "not a number"
- *   }
- * }
- * ```
- *
- * @category errors
- * @since 4.0.0
- */
-export class SchemaError extends /*#__PURE__*/Data.TaggedError("SchemaError") {
-  [TypeId] = TypeId;
-  constructor(issue) {
-    super({
-      issue
-    });
-  }
-  get message() {
-    return this.issue.toString();
-  }
-  toString() {
-    return `SchemaError(${this.message})`;
-  }
-}
-/**
- * Returns `true` if `u` is a {@link SchemaError}.
- *
- * @category guards
- * @since 4.0.0
- */
-export function isSchemaError(u) {
-  return Predicate.hasProperty(u, TypeId);
-}
-//# sourceMappingURL=SchemaError.js.map

package/dist/SchemaError.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaError.js","names":["Data","Predicate","TypeId","SchemaError","TaggedError","constructor","issue","message","toString","isSchemaError","u","hasProperty"],"sources":["../src/SchemaError.ts"],"sourcesContent":[null],"mappings":"AAAA;;;AAGA,OAAO,KAAKA,IAAI,MAAM,WAAW;AACjC,OAAO,KAAKC,SAAS,MAAM,gBAAgB;AAG3C,MAAMC,MAAM,GAAG,iCAAiC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAM,MAAOC,WAAY,sBAAQH,IAAI,CAACI,WAAW,CAAC,aAAa,CAE7D;EACS,CAACF,MAAM,IAAmBA,MAAM;EACzCG,YAAYC,KAAY;IACtB,KAAK,CAAC;MAAEA;IAAK,CAAE,CAAC;EAClB;EACA,IAAaC,OAAOA,CAAA;IAClB,OAAO,IAAI,CAACD,KAAK,CAACE,QAAQ,EAAE;EAC9B;EACSA,QAAQA,CAAA;IACf,OAAO,eAAe,IAAI,CAACD,OAAO,GAAG;EACvC;;AAGF;;;;;;AAMA,OAAM,SAAUE,aAAaA,CAACC,CAAU;EACtC,OAAOT,SAAS,CAACU,WAAW,CAACD,CAAC,EAAER,MAAM,CAAC;AACzC","ignoreList":[]}

package/dist/SchemaUtils.d.ts

@@ -1,28 +0,0 @@
-import * as Schema from "./Schema.ts";
-/**
- * Builds an experimental schema for instances of a native class using a struct
- * schema as the encoded representation.
- *
- * **When to use**
- *
- * Use when you need a schema for an existing native class while keeping a
- * `Struct` schema as its encoded representation.
- *
- * **Details**
- *
- * Decoding constructs `new constructor(props)` from the encoded fields.
- * Encoding uses the instance as the encoded shape, so the class should expose
- * properties compatible with the provided encoding schema.
- *
- * @see {@link Schema.instanceOf} for validating existing class instances without a struct encoding
- * @see {@link Schema.Class} for defining schema-backed classes directly
- * @see {@link Schema.ErrorClass} for defining schema-backed error classes
- *
- * @category schemas
- * @since 4.0.0
- */
-export declare function getNativeClassSchema<C extends new (...args: any) => any, S extends Schema.Struct<Schema.Struct.Fields>>(constructor: C, options: {
-    readonly encoding: S;
-    readonly annotations?: Schema.Annotations.Declaration<InstanceType<C>>;
-}): Schema.decodeTo<Schema.instanceOf<InstanceType<C>, S["Iso"]>, S>;
-//# sourceMappingURL=SchemaUtils.d.ts.map

package/dist/SchemaUtils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"SchemaUtils.d.ts","sourceRoot":"","sources":["../src/SchemaUtils.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AAGrC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,KAAI,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,EACpH,WAAW,EAAE,CAAC,EACd,OAAO,EAAE;IACP,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAA;IACpB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAA;CACvE,GACA,MAAM,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CASlE"}