fix: preserve actor runtime context

Author: cardmagic

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Preserve isolated runtime ownership across operation, lifecycle, observable,
+  and payload callbacks while keeping lifecycle callbacks message-free.
 - Retry transient SQLite writer acquisition with bounded capped backoff without
   replaying transaction callbacks or extending synchronous deadlines.
 - Expose concise `configure()` and isolated `createRuntime()` entry points;

docs/correctness.md

@@ -12,6 +12,9 @@
 - Permanent operation failure raises `MessageFailed` with the durable message
   ID and persisted error details instead of treating actor code text as the
   public exception contract.
+- Operation, lifecycle, observable, and payload callbacks retain their owning
+  runtime through async context. Isolated runtimes therefore never fall back to
+  a global default while actor-owned code resolves another actor reference.
 - Observable outbox rows are claimed in actor revision order. Subscription
   sessions and browser clients reject duplicate or stale revisions within an
   incarnation, while a recreated actor starts a new revision sequence.

docs/parity.md

@@ -21,7 +21,7 @@ Reference: Ruby `solid_objects` 0.12.0 at commit `a01b6f5`.
 
 | Capability                                                                                                    | Status  | TypeScript shape or remaining work                                                                                                                                                                                 |
 | ------------------------------------------------------------------------------------------------------------- | ------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Actor registry, durable identity, JSON state, and adjacent state migrations                                   | Native  | Ordinary classes, static actor types, inferred state, and explicit migrations.                                                                                                                                     |
+| Actor registry, durable identity, JSON state, and adjacent state migrations                                   | Native  | Ordinary classes, static actor types, inferred state, explicit migrations, and isolated runtime context across every actor-instance callback.                                                                      |
 | Fluent committed calls and background delivery                                                                | Native  | `await reference.operation()` and `reference.send.operation()`.                                                                                                                                                    |
 | Ordered mailbox, sequence allocation, idempotency, retries, dead letters, leases, renewal, and fenced commits | Native  | Relational ready/claimed membership tables, durable history, and adapter-appropriate sequence locking.                                                                                                             |
 | Domain rejection and strict poison ordering                                                                   | Native  | Rejections roll back without retry; retryable failures block later operations until completion or dead-lettering.                                                                                                  |

src/context.ts

@@ -13,7 +13,7 @@ interface ExecutionContext {
 interface ActorExecutionContext {
   actor: Actor
   runtime: SolidObjectsRuntime
-  message: MessageContext
+  message?: MessageContext
 }
 
 const storage = new AsyncLocalStorage<ExecutionContext>()

src/runtime.ts

@@ -8,12 +8,7 @@ import {
   type ComponentRegistration,
   type SolidObjectsConfiguration,
 } from "./configuration.js"
-import {
-  currentActor,
-  withActorContext,
-  withActorProjection,
-  withApplicationWritesForbidden,
-} from "./context.js"
+import { currentActor, withActorContext, withActorProjection } from "./context.js"
 import { DeadLetterManager, type DeadLetter } from "./dead-letters.js"
 import { Doctor } from "./doctor.js"
 import { clearDefaultRuntime, setDefaultRuntime } from "./default-runtime.js"
@@ -104,6 +99,7 @@ import type {
   JsonObject,
   JsonValue,
   LongRunningComponent,
+  MessageContext,
   MessageStatus,
   SnapshotOptions,
 } from "./types.js"
@@ -1019,14 +1015,7 @@ export class SolidObjectsRuntime {
         state: deepCopy(state),
       })
     let activated = cachedActor !== undefined
-    const messageContext = {
-      id: turn.message.id,
-      requestId: turn.message.request_id,
-      actorType: turn.message.actor_type,
-      actorId: turn.message.actor_id,
-      sequence: BigInt(turn.message.sequence),
-      attempt: Number(turn.message.attempt_count),
-    }
+    const messageContext = actorMessageContext(turn.message)
     const renewalController = new AbortController()
     let renewalError: unknown
     const renewal = this.renewLease(turn, renewalController.signal).catch((error: unknown) => {
@@ -1036,7 +1025,7 @@ export class SolidObjectsRuntime {
 
     try {
       if (!activated) {
-        await withApplicationWritesForbidden(() => actor.activate())
+        await withActorContext({ actor, runtime: this }, () => actor.activate())
         activated = true
         this.emitInstrumentation("activation.started", {
           actorType: turn.message.actor_type,
@@ -1191,7 +1180,7 @@ export class SolidObjectsRuntime {
     const { turn, actor } = options
     try {
       if (actor && options.lifecycle === "activated") {
-        await withApplicationWritesForbidden(() => actor.deactivate())
+        await withActorContext({ actor, runtime: this }, () => actor.deactivate())
       }
     } catch (error) {
       this.emitInstrumentation("activation.deactivation_failed", {
@@ -1537,7 +1526,7 @@ export class SolidObjectsRuntime {
   private readObservables(actor: Actor, definition: ValidatedActorDefinition): JsonObject {
     const stateBefore = stableJson(actorState(actor, definition.stateKeys))
     const intentCount = actor.intentCount()
-    const values = withApplicationWritesForbidden(() => actor.observableValues())
+    const values = withActorProjection({ actor, runtime: this }, () => actor.observableValues())
     if (
       stableJson(actorState(actor, definition.stateKeys)) !== stateBefore ||
       actor.intentCount() !== intentCount
@@ -1793,6 +1782,17 @@ function messageInstrumentation(message: MessageRow): JsonObject {
   }
 }
 
+function actorMessageContext(message: MessageRow): MessageContext {
+  return {
+    id: message.id,
+    requestId: message.request_id,
+    actorType: message.actor_type,
+    actorId: message.actor_id,
+    sequence: BigInt(message.sequence),
+    attempt: Number(message.attempt_count),
+  }
+}
+
 function restoreActorState(options: {
   actor: Actor
   definition: ValidatedActorDefinition

test/runtime.test.ts

@@ -72,11 +72,39 @@ class Account extends Actor {
   }
 }
 
+class IsolatedLifecycle extends Actor {
+  static override readonly actorType = "IsolatedLifecycle"
+  static deactivationTargetType: string | null = null
+  static lifecycleHadMessage = false
+
+  count = 0
+
+  protected override onActivate(): void {
+    IsolatedLifecycle.lifecycleHadMessage ||= this.currentMessage !== undefined
+    this.sendTo(AuditLog.ref("lifecycle")).record({ eventName: "activated" })
+  }
+
+  protected override onDeactivate(): void {
+    IsolatedLifecycle.lifecycleHadMessage ||= this.currentMessage !== undefined
+    IsolatedLifecycle.deactivationTargetType = AuditLog.ref("lifecycle").actorType
+  }
+
+  increment(): void {
+    this.count += 1
+  }
+
+  override observables(): Record<string, unknown> {
+    return { count: this.count, targetType: AuditLog.ref("lifecycle").actorType }
+  }
+}
+
 let runtime: SolidObjectsRuntime | undefined
 
 afterEach(async () => {
   await runtime?.close()
   runtime = undefined
+  IsolatedLifecycle.deactivationTargetType = null
+  IsolatedLifecycle.lifecycleHadMessage = false
 })
 
 describe("typed actor references", () => {
@@ -91,6 +119,21 @@ describe("typed actor references", () => {
     await expect(runtime.ref(AuditLog, "audit").events).resolves.toEqual(["account_disabled"])
   })
 
+  it("keeps lifecycle and observable callbacks inside their isolated runtime", async () => {
+    runtime = createRuntime(configuredSettings())
+    runtime.register(IsolatedLifecycle)
+    runtime.register(AuditLog)
+    await runtime.install()
+    const message = await runtime.ref(IsolatedLifecycle, "source").send.increment()
+
+    await runtime.testing.drain({ roles: ["actors"] })
+
+    await expect(message.result()).resolves.toBeNull()
+    await expect(runtime.ref(AuditLog, "lifecycle").events).resolves.toEqual(["activated"])
+    expect(IsolatedLifecycle.deactivationTargetType).toBe(AuditLog.actorType)
+    expect(IsolatedLifecycle.lifecycleHadMessage).toBe(false)
+  })
+
   it("invokes messages and reads fields and getters as committed queries", async () => {
     runtime = configuredRuntime()
     await runtime.install()