tardie 0.47.2-rc.495 → 0.47.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tardie",
-  "version": "0.47.2-rc.495",
+  "version": "0.47.2",
   "license": "MIT",
   "author": "Clavia, Inc.",
   "description": "Actor, agent, client, and host APIs for Tardigrade.",
@@ -16,7 +16,7 @@
     "access": "public"
   },
   "tardigrade": {
-    "sourceTree": "1cdd75351fedad878fb634173bfb109d56e3ddff"
+    "sourceTree": "464249e5baa63a2b89b31edfb59bf6917bd82fc7"
   },
   "files": [
     "src",

package/src/core/runtime/layers.ts

@@ -1,3 +1,4 @@
+import type { RetryOptions } from "../services/effect-execution"
 import type { WatchdogTarget } from "../services/watchdog"
 import { prepareInitialState } from "./initialisation"
 import type { ThreadCoordinate, ChildPlacement } from "../actor/thread"
@@ -31,6 +32,7 @@ export function createThreadHost<Event extends object, Services, State, Contract
   readonly actorTransport?: ActorMessageTransport
   readonly transports?: Readonly<Record<string, MessageTransport>>
   readonly delivery?: { readonly retryIntervalMs?: number }
+  readonly provisionRetry?: RetryOptions<Error>
   readonly generateName?: () => string
   readonly defaultChildPlacement?: ChildPlacement
 }) {
@@ -49,6 +51,7 @@ export function createThreadHost<Event extends object, Services, State, Contract
     ...(options.checkpointPolicy ? { checkpointPolicy: options.checkpointPolicy } : {}),
     ...(options.canDrive ? { canDrive: (instance: string) => options.canDrive!({ actor: options.actor.actorName, instance }) } : {}),
     ...(options.promises ? { promises: options.promises } : {}),
+    ...(options.provisionRetry ? { provisionRetry: options.provisionRetry } : {}),
     journal: instance => options.storage.supervisor(options.actor.actorName, instance),
     validateInitialState: state => prepareInitialState(options.initialStateAtoms ?? [], state).pipe(Effect.asVoid),
     provision: allocation => actors.provision({
@@ -62,7 +65,7 @@ export function createThreadHost<Event extends object, Services, State, Contract
     run,
   })
   const services: ActorExecutionOptions<Event, Services, State, Contracts>["services"] = (coordinate, runtime) => options.services(coordinate, runtime).pipe(Layer.provideMerge(Layer.merge(Layer.succeed(Supervisor, supervisor), Layer.succeed(Invocation, invocation.forSender(coordinate)))))
-  const actors: ReturnType<typeof createActorExecution<Event, Services, State, Contracts>> = createActorExecution({
+  const actors: ReturnType<typeof createActorExecution<Event, Services, State, Contracts>> = createActorExecution<Event, Services, State, Contracts>({
     ...options, executionStreamBus: executionStream, run, from: options.from ?? DEFAULT_EXTERNAL_SENDER,
     delivery: coordinate => ({ ...options.delivery, address: coordinate, send: invocation.forSender(coordinate).send }),
     services,

package/src/core/services/supervisor/graph.ts

@@ -16,6 +16,7 @@ const Allocation = Schema.Struct({
   initialState: Schema.optionalKey(InitialState),
 })
 export type ThreadAllocation = typeof Allocation.Type
+const sameAllocation = Schema.toEquivalence(Allocation)
 const Thread = Schema.Struct({ ...Allocation.fields, origin: Schema.Finite, status: Schema.Literals(["requested", "registered", "failed"]), reason: Schema.optionalKey(Schema.String) })
 export const SupervisorEvent = Schema.Union([
   Schema.Struct({ type: Schema.Literal("ThreadRequested"), allocation: Allocation }),
@@ -24,7 +25,7 @@ export const SupervisorEvent = Schema.Union([
 ])
 export type SupervisorEvent = typeof SupervisorEvent.Type
 
-// threads projects allocation state; provisioning must tolerate repetition after interrupted registration.
+// threads preserves allocation identity across failed re-requests (packages/platform/test/workerd/thread-layout.workers.ts). Provisioning must tolerate repetition after interrupted registration.
 export const threads = durableAtom({ name: "host.supervisor.threads",
   input: SupervisorEvent,
   schema: Schema.Array(Thread),
@@ -32,12 +33,14 @@ export const threads = durableAtom({ name: "host.supervisor.threads",
   reduce: (state, event: SupervisorEvent, _metadata, position) => {
     if (event.type === "ThreadRequested") {
       const next = event.allocation
-      if (state.some(entry => entry.coordinate.thread === next.coordinate.thread || (entry.parent === next.parent && entry.name === next.name))) throw new Error("Duplicate thread allocation")
+      const existing = state.find(entry => entry.coordinate.thread === next.coordinate.thread || (entry.parent === next.parent && entry.name === next.name))
+      if (existing && (existing.status !== "failed" || !sameAllocation(existing, next))) throw new Error("Duplicate thread allocation")
       const parent = next.parent === null ? undefined : state.find(entry => entry.coordinate.thread === next.parent && entry.status === "registered")
       if (next.parent !== null && !parent) throw new Error("Unknown parent thread")
       if (next.depth !== (parent ? parent.depth + 1 : 0)) throw new Error("Invalid thread depth")
       if (state.some(entry => entry.coordinate.actor !== next.coordinate.actor || entry.coordinate.instance !== next.coordinate.instance)) throw new Error("Supervisor instance mismatch")
-      return [...state, { ...next, origin: position, status: "requested" as const }]
+      const requested = { ...next, origin: position, status: "requested" as const }
+      return existing ? state.map(entry => entry === existing ? requested : entry) : [...state, requested]
     }
     const current = state.find(entry => entry.coordinate.thread === event.coordinate.thread)
     if (!current || current.status !== "requested" || current.coordinate.actor !== event.coordinate.actor || current.coordinate.instance !== event.coordinate.instance) throw new Error("Unknown thread registration")
@@ -54,7 +57,7 @@ export const supervisorActor = defineActor("supervisor", Effect.sync(() => {
     const acts = Object.fromEntries(directory.filter(entry => entry.status === "requested").map(allocation => {
       const key = allocation.coordinate.thread
       let request = requests.get(key)
-      if (!request) {
+      if (!request || request.origin !== allocation.origin) {
         request = Provision.request({ origin: allocation.origin, input: allocation, onSettled: result => {
           if (result.status === "rejected") return [{ type: "ThreadFailed", coordinate: allocation.coordinate, reason: typeof result.reason === "string" ? result.reason : JSON.stringify(result.reason) } satisfies SupervisorEvent]
           return [{ type: "ThreadRegistered", coordinate: allocation.coordinate } satisfies SupervisorEvent]

package/src/core/services/supervisor.ts

@@ -2,9 +2,9 @@ import { isDeepStrictEqual } from "node:util"
 import type { RecoveryState } from "./watchdog"
 import type { PromisePolicy } from "./promises"
 import type { InitialState } from "../initialise"
+import { EffectExecution, type RetryOptions } from "./effect-execution"
 import { Context, Deferred, Effect, Exit, Random, Schema, Semaphore } from "effect"
 import { durablePromise } from "../atoms/promise"
-import { EffectExecution } from "../atoms/effect"
 import { RuntimeError } from "../runtime/effects"
 import type { ChildPlacement, ThreadCoordinate } from "../actor/thread"
 import type { Journal } from "./journal"
@@ -13,6 +13,13 @@ import { createActorStore, type CheckpointPolicy } from "../runtime/execution"
 import type { ActorRuntime } from "../runtime/contracts"
 import { createSupervisorStore, type SupervisorStore } from "../runtime/stores/supervisor"
 
+export const DEFAULT_PROVISION_RETRY_LIMIT = 2
+export const DEFAULT_PROVISION_RETRY_INTERVAL_MS = 1_000
+// DEFAULT_PROVISION_RETRY bounds typed provisioning failures using durable retries (platform/test/workerd/thread-layout.workers.ts).
+export const DEFAULT_PROVISION_RETRY: RetryOptions<Error> = {
+  decide: (failure, attempt) => Effect.succeed(attempt < DEFAULT_PROVISION_RETRY_LIMIT ? { delayMs: DEFAULT_PROVISION_RETRY_INTERVAL_MS, reason: String(failure) } : undefined),
+}
+
 export interface ThreadRequest {
   readonly instance: string
   readonly parent?: ThreadCoordinate
@@ -36,6 +43,7 @@ export function createSupervisor(options: {
   readonly promises?: Partial<PromisePolicy>
   readonly canDrive?: (instance: string) => Effect.Effect<boolean, Error>
   readonly journal: (instance: string) => Journal<SupervisorEvent>
+  readonly provisionRetry?: RetryOptions<Error>
   readonly provision: (allocation: ThreadAllocation) => Effect.Effect<void, Error>
   readonly validateInitialState?: (state: InitialState) => Effect.Effect<void, Error>
   readonly generateName?: () => string
@@ -59,7 +67,7 @@ export function createSupervisor(options: {
         return Provision.layer(allocation => Effect.gen(function* () {
           const execution = yield* EffectExecution
           const reply = durablePromise(execution.ref, { success: Schema.Null, error: Schema.String })
-          const handle = yield* execution.fork(options.provision(allocation).pipe(
+          const handle = yield* execution.fork(execution.retry(options.provision(allocation), options.provisionRetry ?? DEFAULT_PROVISION_RETRY).pipe(
             Effect.match({ onFailure: error => reply.fail(String(error)), onSuccess: () => reply.succeed(null) }),
           ))
           return Provision.defer(handle)
@@ -107,7 +115,10 @@ export function createSupervisor(options: {
       if (initialState !== undefined && !isDeepStrictEqual(existing.initialState, initialState)) return yield* Effect.fail(new RuntimeError("Named thread already has different initial state"))
       if (requestedPlacement !== undefined && existing.placement !== requestedPlacement) return yield* Effect.fail(new RuntimeError("Named thread already has different placement"))
       if (suppliedName === undefined) return yield* Effect.fail(new RuntimeError("Generated thread name already exists; supply a different name or generator"))
-      yield* supervisor.resume
+      if (existing.status === "failed") {
+        const { coordinate, name, parent, depth, placement, initialState } = existing
+        yield* supervisor.send([{ type: "ThreadRequested", allocation: { coordinate, name, parent, depth, placement, ...(initialState === undefined ? {} : { initialState }) } }])
+      } else yield* supervisor.resume
       return { supervisor, coordinate: existing.coordinate }
     }
     const thread = directory.some(entry => entry.coordinate.thread === name) ? `${name}-${yield* randomName}` : name

package/src/platform/cloudflare/objects.ts

@@ -38,7 +38,7 @@ export interface CloudflareObjectBindings {
 }
 
 type ExecutionOptions<Event extends object, Services, State, Contracts extends ActorMethods<Event>> = ActorExecutionOptions<Event, Services, State, Contracts>
-export type ActorObjectOptions<Env extends object, Event extends object, Services, State, Contracts extends ActorMethods<Event>> = Omit<ExecutionOptions<Event, Services, State, Contracts>, "storage" | "services" | "from" | "delivery" | "actorContext" | "executionStreamBus"> & Pick<Parameters<typeof createThreadHost<Event, Services, State, Contracts>>[0], "from" | "delivery" | "transports" | "actorTransport" | "telemetry" | "defaultChildPlacement"> & {
+export type ActorObjectOptions<Env extends object, Event extends object, Services, State, Contracts extends ActorMethods<Event>> = Omit<ExecutionOptions<Event, Services, State, Contracts>, "storage" | "services" | "from" | "delivery" | "actorContext" | "executionStreamBus"> & Pick<Parameters<typeof createThreadHost<Event, Services, State, Contracts>>[0], "from" | "delivery" | "transports" | "actorTransport" | "telemetry" | "defaultChildPlacement" | "provisionRetry"> & {
   readonly actorContext?: ExecutionOptions<Event, Services, State, Contracts>["actorContext"]
   // services receives the current Durable Object storage for local cache layers.
   readonly services: (env: Env, ...args: [...Parameters<ExecutionOptions<Event, Services, State, Contracts>["services"]>, DurableObjectStorage]) => Layer.Layer<Layer.Success<ReturnType<ExecutionOptions<Event, Services, State, Contracts>["services"]>>, Error, Supervisor | Invocation>
@@ -146,6 +146,7 @@ export function createActorObjects<Env extends object = Record<string, unknown>,
       if (!this.directory) {
         this.journal = objectJournal({ storage: this.ctx.storage, key: JSON.stringify([options.actor.actorName, instance, "supervisor"]), checkpointChunkBytes: options.checkpointChunkBytes, eventInlineBytes: options.eventInlineBytes, target: { actor: options.actor.actorName, instance }, watchdog: this.watchdog, ...(options.alarms ? { alarms: options.alarms } : {}) })
         this.directory = createSupervisor({ actor: options.actor.actorName, journal: () => this.journal!, run: this.run,
+          ...(options.provisionRetry ? { provisionRetry: options.provisionRetry } : {}),
           ...(options.attemptTimeoutMs === undefined ? {} : { attemptTimeoutMs: options.attemptTimeoutMs }),
         ...(options.checkpointPolicy ? { checkpointPolicy: options.checkpointPolicy } : {}),
           canDrive: () => this.watchdog.status.pipe(Effect.flatMap(entries => entries.get(watchdogKey({ actor: options.actor.actorName, instance }))?.status === "blocked" ? Effect.succeed(false) : options.canDrive ? options.canDrive({ actor: options.actor.actorName, instance }) : Effect.succeed(true))),