ActorsForJS.ns

Newspeak3
'Newspeak'
class ActorsForJS usingPlatform: p = Object new (
	|
		private WeakMap = p collections IdentityMap.
		private List = p collections List.
		private Message = p kernel Message.
		private internalRefs <WeakMap[FarReference, InternalFarReference]> = WeakMap new.
		public Promise = PromiseUtils new.
		handlerOfLastResort_slot
		defaultActor = DOMActor named: 'Default actor'.
	|
	_js assign: (_js ident: 'currentActor') toBe: defaultActor.
) (
	public class Actor named: debugName <String> = Object new (
		|
			private (* N.B. Do not leak to subinstances. *) internalActor = DOMActor named: debugName.
		|
	) (
		public interrupt = (
			unimplemented
		)
		public onError: onError <[:E | Object]> = (
			unimplemented
		)
		public seed: value <Value> ^<FarReference[Value]> = (
			(* Creating a far reference to a PassByCopy is questionable. It may be that this should be seed: receiver perform: selector with: argument. *)
			
			(isValueObject: value) ifFalse: [
					Error signal: 'Cannot seed an actor with a non-Value.'
				].
			^createFarReferenceTo: value in: internalActor for: currentActor
		)
		public terminate = (
			unimplemented
		)
	) : ()
	class DOMActor named: n = InternalActor new (
		(* An actor whose turns run in the DOM Context. *)
		
		|
			name <String> = n.
		|
	) (
		public enqueueMessage: actorMessage = (
			actorMessage postedTo: self.
			
			(* bogus - should drain an explicit queue to allow for a randomizing scheduler *)
			js call: (_js propertyOf: (_js ident: 'theGlobalObject')
					at: (_js literal: 'setTimeout'))
				with: {[
					_js assign: (_js ident: 'currentActor') toBe: self.
					actorMessage deliverIn: self
				]. _js literal: 0. }
		)
	) : ()
	class EventualSendReactor selector: s arguments: a resolver: r = Object new (
		(* An eventual-send to a promise.

Note that all slots contain objects that belong to the actor which performed the eventual send. *)
		
		|
			selector <Symbol> = s.
			arguments <Array> = a.
			resolver <InternalResolver> = r.
		|
	) (
		public reactBroken: error = (
			(* Broken promise contagion. *)
			
			resolver __owner == currentActor ifFalse: [ halt ].
			
			(* Should this be immediate? *)
			
			(* resolver internalBreak: error. ? *)
			currentActor enqueueMessage: (PendingDelivery receiver: resolver
					selector: #internalResolve:
					arguments: {InternalBrokenRef problem: error __owner: resolver __owner. }
					resolver: nil)
		)
		public reactMoreResolved: internalRef = (
			resolver internalResolve: (asInternalRef: (internalRef eventualSend: selector
						arguments: arguments))
		)
		public reactResolved: value = (
			resolver __owner == currentActor ifFalse: [ halt ].
			resolver internalResolve: (asInternalRef: (currentActor eventualSendTo: value
						selector: selector
						arguments: arguments))
		)
	) : ()
	class InternalActor new = Object new (
	) (
		public currentActor = (
			(* BOGUS. Polymorphic with other actor system. *)
			
			^self
		)
		public enqueueReceiver: receiver selector: selector arguments: arguments resolver: resolver = (
			(* Convenience wrapper matching psoup's [InternalActor]>>same. Posts a
	   PendingDelivery to this actor's queue. *)
			
			self enqueueMessage: (PendingDelivery receiver: receiver
					selector: selector
					arguments: arguments
					resolver: resolver)
		)
		public eventualSendTo: receiver selector: selector arguments: arguments ^<Ref> = (
			(* Sent from the compilation of an eventual send, via the same method in ProcessScheduler. *)
			
			^(asInternalRef: receiver) eventualSend: selector arguments: arguments
		)
	) : ()
	class InternalBrokenRef problem: p __owner: o = InternalRef __owner: o (
		|
			problem = p.
		|
	) (
		public addReactor: reactor = (
			reactor reactBroken: problem
		)
		public checkCycle ^<Boolean> = (
			^false
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			^self externalRef
			(* I.e., broken with same problem. Should this wait for the next turn? *)
			
		)
		public immediateSend: message <Message> ^<Object> = (
			^Error signal: 'Cannot immediate-send to a broken ref: ' , message selector
		)
		public printOn: stream = (
			stream nextPutAll: 'InternalBrokenRef: '.
			problem printOn: stream
		)
		public refPrintOn: stream = (
			stream nextPutAll: '<broken ref: '.
			problem printOn: stream.
			stream nextPutAll: '>'
		)
		public shorten ^<InternalRef> = (
			^self
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			| localPromise = InternalLocalPromise __owner: __owner. |
			currentActor enqueueMessage: (PendingDelivery receiver: onError
					selector: #cull:
					arguments: {problem. }
					resolver: localPromise).
			^localPromise externalRef
		)
		public wrapFor: targetActor = (
			self checkCurrentActor.
			^(InternalBrokenRef problem: problem __owner: targetActor) externalRef
		)
	) : ()
	class InternalFarReference target: t targetsActor: ta __owner: o = InternalRef __owner: o (
		|
			target = t.
			targetsActor = ta.
		|
	) (
		public addReactor: reactor = (
			reactor reactResolved: externalRef
		)
		public checkCycle ^<Boolean> = (
			^false
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			| resolverInTarget remotePromise redirector |
			resolverInTarget:: InternalLocalPromise __owner: targetsActor.
			targetsActor enqueueMessage: (PendingDelivery receiver: target
					selector: selector
					arguments: (wrapArguments: arguments from: currentActor to: targetsActor)
					resolver: resolverInTarget).
			remotePromise:: InternalRemotePromise target: resolverInTarget
				targetsActor: targetsActor
				__owner: currentActor.
			redirector:: RedirectReactor from: targetsActor
				to: currentActor
				resolver: remotePromise.
			targetsActor enqueueMessage: (PendingDelivery receiver: resolverInTarget
					selector: #addReactor:
					arguments: {redirector. }
					resolver: nil).
			^remotePromise externalRef
		)
		public immediateSend: message <Message> ^<Object> = (
			^Error signal: 'Cannot immediate-send to an eventual ref: ' , message selector
		)
		public printOn: stream = (
			stream nextPutAll: 'InternalFarRef: '.
			target printOn: stream
		)
		public refPrintOn: stream = (
			stream nextPutAll: '<far ref: '.
			target printOn: stream.
			stream nextPutAll: '>'
		)
		public shorten ^<InternalRef> = (
			^self
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			| localPromise = InternalLocalPromise __owner: __owner. |
			currentActor enqueueMessage: (PendingDelivery receiver: onValue
					selector: #cull:
					arguments: {externalRef. }
					resolver: localPromise).
			^localPromise externalRef
		)
		public wrapFor: targetActor = (
			targetsActor == targetActor ifTrue: [ ^target ].
			^(InternalFarReference target: target
				targetsActor: targetsActor
				__owner: targetActor) externalRef
		)
	) : ()
	class InternalLocalPromise __owner: o = InternalRef __owner: o (
		|
			state ::= #unresolved.
			
			(* resolving. resolved *)
			resolution <InternalRef>
			reactors
		|
	) (
		public addReactor: reactor = (
			state == #unresolved ifTrue: [
					reactors == nil ifTrue: [ reactors:: List new ].
					reactors add: reactor.
					^self
				].
			state == #resolved ifTrue: [ ^resolution addReactor: reactor ].
			halt
		)
		public checkCycle ^<Boolean> = (
			state == #resolving ifTrue: [ ^true ].
			state == #unresolved ifTrue: [ ^false ].
			state == #resolved ifTrue: [ ^resolution checkCycle ].
			halt
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			| localPromise |
			self checkCurrentActor.
			state == #resolved ifTrue: [
					^resolution eventualSend: selector arguments: arguments
				].
			localPromise:: InternalLocalPromise __owner: __owner.
			self addReactor: (EventualSendReactor selector: selector
					arguments: arguments
					resolver: localPromise).
			^localPromise externalRef
		)
		public immediateSend: message <Message> ^<Object> = (
			state == #resolved ifTrue: [ ^resolution immediateSend: message ].
			^Error signal: 'Cannot immediate-send to an eventual ref: ' , message selector
		)
		public internalResolve: internalRef <InternalRef> = (
			state == #unresolved ifFalse: [ ^Error signal: 'Already resolved' ].
			internalRef isInternalRef ifFalse: [ halt ].
			state:: #resolving.
			internalRef checkCycle ifTrue: [
					resolution:: InternalBrokenRef problem: (Error new messageText: 'Cyclic resolution')
						__owner: __owner
				]
				ifFalse: [ resolution:: internalRef ].
			state:: #resolved.
			nil == reactors ifFalse: [
					reactors do: [:reactor | resolution addReactor: reactor ].
					reactors:: nil
				]
		)
		public printOn: stream = (
			stream nextPutAll: 'InternalLocalPromise: '.
			state printOn: stream
		)
		public refPrintOn: stream = (
			state == #resolved ifTrue: [ resolution refPrintOn: stream ]
				ifFalse: [ stream nextPutAll: '<local promise>' ]
		)
		public shorten ^<InternalRef> = (
			state == #unresolved ifTrue: [ ^self ].
			state == #resolved ifTrue: [ ^resolution ].
			halt
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			| localPromise |
			self checkCurrentActor.
			state == #resolved ifTrue: [
					^resolution whenFulfilled: onValue whenBroken: onError
				].
			localPromise:: InternalLocalPromise __owner: __owner.
			self addReactor: (WhenReactor onValue: onValue
					onError: onError
					resolver: localPromise).
			^localPromise externalRef
		)
		public wrapFor: targetActor = (
			state == #resolved ifTrue: [ ^resolution wrapFor: targetActor ].
			checkCurrentActor.
			targetActor == __owner ifTrue: [ halt ].
			^(InternalRemotePromise target: self
				targetsActor: currentActor
				__owner: targetActor) externalRef
		)
	) : ()
	class InternalNearRef wrapping: t __owner: o = InternalRef __owner: o (
		|
			target = t.
		|
	) (
		public addReactor: reactor = (
			reactor reactResolved: target
		)
		public checkCycle ^<Boolean> = (
			^false
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			| localPromise = InternalLocalPromise __owner: __owner. |
			currentActor enqueueMessage: (PendingDelivery receiver: target
					selector: selector
					arguments: arguments
					resolver: localPromise).
			^localPromise externalRef
		)
		public immediateSend: message <Message> ^<Object> = (
			^message sendTo: target
		)
		public printOn: stream = (
			stream nextPutAll: 'InternalNearRef: '.
			target printOn: stream
		)
		public refPrintOn: stream = (
			stream nextPutAll: '<near ref: '.
			target printOn: stream.
			stream nextPutAll: '>'
		)
		public shorten ^<InternalRef> = (
			^self
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			| localPromise = InternalLocalPromise __owner: __owner. |
			currentActor enqueueMessage: (PendingDelivery receiver: onValue
					selector: #cull:
					arguments: {target. }
					resolver: localPromise).
			^localPromise externalRef
		)
		public wrapFor: targetActor = (
			self checkCurrentActor.
			(isValueObject: target) ifTrue: [ ^target ].
			^createFarReferenceTo: target in: currentActor for: targetActor
		)
	) : ()
	class InternalRef __owner: o = Object new (
		|
			public __owner <InternalActor> = o.
		|
	) (
		checkCurrentActor = (
			currentActor == __owner ifFalse: [ halt ]
		)
		public checkCycle ^<Boolean> = (
			subclassResponsibility
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			subclassResponsibility
		)
		public externalRef = (
			^Ref wrapping: self
		)
		public immediateSend: message <Message> ^<Object> = (
			subclassResponsibility
		)
		public isInternalRef ^<Boolean> = (
			^true
		)
		public refPrintOn: stream = (
			subclassResponsibility
		)
		public shorten ^<InternalRef> = (
			subclassResponsibility
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			subclassResponsibility
		)
		public wrapFor: targetActor = (
			subclassResponsibility
		)
	) : ()
	class InternalRemotePromise target: t targetsActor: ta __owner: o = InternalRef __owner: o (
		|
			target <InternalLocalPromise> = t.
			targetsActor <InternalActor> = ta.
			state ::= #unresolved.
			resolution <InternalRef>
		|
	) (
		public addReactor: reactor = (
			state == #resolved ifTrue: [ ^resolution addReactor: reactor ].
			state == #unresolved ifTrue: [ ^reactor reactMoreResolved: self ].
			stop5
		)
		public checkCycle ^<Boolean> = (
			state == #resolving ifTrue: [ ^true ].
			state == #unresolved ifTrue: [ ^false ].
			state == #resolved ifTrue: [ ^resolution checkCycle ].
			halt
		)
		public eventualSend: selector <Symbol> arguments: arguments <Array> ^<Ref> = (
			| resolverInTarget remotePromise redirector |
			resolverInTarget:: InternalLocalPromise __owner: targetsActor.
			targetsActor enqueueMessage: (PendingDelivery receiver: target
					selector: #eventualSend:arguments:
					arguments: {selector. wrapArguments: arguments
						from: currentActor
						to: targetsActor. }
					resolver: resolverInTarget).
			remotePromise:: InternalRemotePromise target: resolverInTarget
				targetsActor: targetsActor
				__owner: currentActor.
			redirector:: RedirectReactor from: targetsActor
				to: currentActor
				resolver: remotePromise.
			targetsActor enqueueMessage: (PendingDelivery receiver: resolverInTarget
					selector: #addReactor:
					arguments: {redirector. }
					resolver: nil).
			^remotePromise externalRef
		)
		public immediateSend: message <Message> ^<Object> = (
			state == #resolved ifTrue: [ ^resolution immediateSend: message ].
			^Error signal: 'Cannot immediate-send to an eventual ref: ' , message selector
		)
		public internalResolve: internalRef <InternalRef> = (
			state == #unresolved ifFalse: [ ^Error signal: 'Already resolved' ].
			internalRef isInternalRef ifFalse: [ halt ].
			state:: #resolving.
			internalRef checkCycle ifTrue: [
					resolution:: InternalBrokenRef problem: (Error new messageText: 'Cyclic resolution')
						__owner: __owner
				]
				ifFalse: [ resolution:: internalRef ].
			state:: #resolved
		)
		public printOn: stream = (
			stream nextPutAll: 'InternalRemotePromise: '.
			state printOn: stream
		)
		public redirectFrom: sourceActor to: destinationActor resolving: resolver = (
			| redirector |
			destinationActor == targetsActor ifTrue: [
					targetsActor enqueueMessage: (PendingDelivery receiver: resolver
							selector: #internalResolve:
							arguments: {target. }
							resolver: nil).
					^self
				].
			redirector:: RedirectReactor from: targetsActor
				to: destinationActor
				resolver: resolver.
			targetsActor enqueueMessage: (PendingDelivery receiver: target
					selector: #addReactor:
					arguments: {redirector. }
					resolver: nil)
		)
		public refPrintOn: stream = (
			state == #resolved ifTrue: [ resolution refPrintOn: stream ]
				ifFalse: [ stream nextPutAll: '<remote promise>' ]
		)
		public shorten ^<InternalRef> = (
			state == #unresolved ifTrue: [ ^self ].
			state == #resolved ifTrue: [ ^resolution ].
			halt
		)
		public whenFulfilled: onValue whenBroken: onError ^<Ref> = (
			| localPromise redirector |
			self checkCurrentActor.
			state == #resolved ifTrue: [
					^resolution whenFulfilled: onValue whenBroken: onError
				].
			localPromise:: InternalLocalPromise __owner: __owner.
			redirector:: RedirectReactor from: targetsActor
				to: currentActor
				resolver: localPromise.
			targetsActor enqueueMessage: (PendingDelivery receiver: target
					selector: #addReactor:
					arguments: {redirector. }
					resolver: nil).
			^localPromise whenFulfilled: onValue whenBroken: onError
		)
		public wrapFor: targetActor = (
			state == #resolved ifTrue: [ ^resolution wrapFor: targetActor ].
			targetActor == targetsActor ifTrue: [ ^target externalRef ].
			^(InternalRemotePromise target: target
				targetsActor: targetsActor
				__owner: targetActor) externalRef
		)
	) : ()
	class PendingDelivery receiver: r selector: s arguments: a resolver: y = Object new (
		(* A message in an actor's event queue. Every turn starts by sending #deliverIn:.

Note that all slots contain objects that belong to the actor in which the message is queued, even the resolver. *)
		
		|
			receiver <Object> = r.
			selector <Symbol> = s.
			arguments <Array> = a.
			resolver <InternalResolver> = y.
		|
	) (
		public deliverIn: fastCurrentActor = (
			| resolution type msg |
			
			(* Transcript print: fastCurrentActor; space; print: self; cr. *)
			msg:: Message selector: selector arguments: arguments.
			[
				resolution:: msg sendTo: receiver.
				type:: #internalResolve:
			] on: Exception
				do: 
				(* was [on: Error], which doesn't catch MessageNotUnderstood (an Exception, not an Error) *)
				[:error |
					error out.
					resolver == nil ifTrue: [ error pass ].
					resolution:: error.
					type:: #internalBreak:
				].
			
			(* Transcript show: {resolver. type. resolution}; cr. *)
			nil == resolver ifTrue: [
					type == #internalBreak: ifTrue: [ {'silent failure'. resolution. } out ].
					^self
				].
			resolver internalResolve: (type == #internalResolve: ifTrue: [
						asInternalRef: resolution
					]
					ifFalse: [ InternalBrokenRef problem: resolution __owner: currentActor ])
			(* __owner: was [self] (a PendingDelivery); should be the actor that owns the ref. *)
			
		)
		public postedTo: actor = (
			(* check: receiver allowedIn: actor.
	arguments do: [:arg | check: arg allowedIn: actor]. *)
			
			(* selector numArgs == arguments size ifFalse: [halt]. *)
			
			resolver == nil ifFalse: [ resolver __owner == actor ifFalse: [ halt ] ]
		)
		public printOn: stream = (
			receiver printOn: stream.
			stream nextPutAll: ' <-: '.
			stream nextPutAll: selector.
			stream space.
			arguments isEmpty ifFalse: [ arguments printOn: stream ]
		)
	) : ()
	class PromiseUtils new = Object new (
	) (
		public all: refs <List[Promise[V, E]]> ^<Promise[List[V], E]> = (
			(* Answers a promise that resolves with all the resolutions of refs, or the first problem. *)
			
		)
		public broken: problem <E> ^<Promise[nil, E]> = (
			^Resolver new break: problem;
				promise
		)
		public fulfilled: resolution <V> ^<Promise[V, nil]> = (
			^Resolver new fulfill: resolution;
				promise
		)
		public timeout: ref <Promise[V, E]> after: milliseconds <Integer> ^<Promise[V, E | TimeoutError]> = (
			(* Answers a promise that resolves with the resolution of ref, or a TimeoutError if refs is not resolved within milliseconds. *)
			
			#BOGUS
			(* Should have proper duration type. *)
			
		)
		public when: ref <Promise[V, E]> fulfilled: onValue <[:V | V2 def]> ^<Promise[V2, E]> = (
			(* Subscribe to notification of a reference being fulfilled. If ref is fulfilled, onValue will run in some turn after the turn that resolves ref, and the returned promise with be resolved with the result of onValue. If ref is broken, the returned promise with be broken with the same error. *)
			
			^(asInternalRef: ref) whenFulfilled: onValue whenBroken: [:e | e signal ]
			(* Should we make this the behavior of a nil catch-clause instead? *)
			
		)
		public when: ref <Promise[V, E]> fulfilled: onValue <[:V | V2 def]> broken: onError <[:E | E2 def]> ^<Promise[V2, E2]> = (
			(* Subscribe to notification of a reference being fulfilled or broken. onValue or onError respectively will run in some turn after the turn that resolves ref., and the returned promise with be resolved with the result of the callback. *)
			
			^(asInternalRef: ref) whenFulfilled: onValue whenBroken: onError
		)
		public when: ref <Promise> partitioned: onPartition <[:Promise | R def] | [R def]> ^<Promise[R, nil]> = (
			(* Subscribe to notification of a reference breaking due to partition. *)
			
		)
	) : ()
	class RedirectReactor from: s to: d resolver: r = Object new (
		(* A bridge between InternalResolvers in different actors. *)
		
		|
			sourceActor <Actor> = s.
			destinationActor <Actor> = d.
			resolver <InternalResolver> = r.
		|
	) (
		public reactBroken: r = (
			| msg |
			currentActor == sourceActor ifFalse: [ halt ].
			msg:: PendingDelivery receiver: resolver
				selector: #internalResolve:
				arguments: {InternalBrokenRef problem: r __owner: destinationActor. }
				resolver: nil.
			destinationActor enqueueMessage: msg
		)
		public reactMoreResolved: internalRef = (
			internalRef redirectFrom: sourceActor
				to: destinationActor
				resolving: resolver
		)
		public reactResolved: r = (
			| msg |
			currentActor == sourceActor ifFalse: [ halt ].
			msg:: PendingDelivery receiver: resolver
				selector: #internalResolve:
				arguments: {asInternalRef: (wrapArgument: r
						from: sourceActor
						to: destinationActor). }
				resolver: nil.
			destinationActor enqueueMessage: msg
		)
	) : ()
	class Ref wrapping: ref = Object new (
		|
			internalRef = ref.
		|
		internalRefs at: self put: ref.
	) (
		doesNotUnderstand: message <Message> = (
			(* For the debugger/inspector. Short-circuit [isKindOfX]-style predicates
	   to false (matches psoup's Object>>doesNotUnderstand: behavior); use
	   psoup's narrow [isKindOf] prefix rather than the over-broad [is]
	   prefix that previously swallowed [isEmpty]/[isNil]/[isPromise]/etc. *)
			
			0 = message arguments size ifTrue: [
					(message selector startsWith: 'isKindOf') ifTrue: [ ^false ]
				].
			^internalRef immediateSend: message
		)
		public identityHash = (
			(* :bogus: Need a proper implementation of WeakMap that does not send messages to its keys. *)
			
			^super hash
		)
		public isKindOfPromise ^<Boolean> = (
			^true
		)
		public isPromise = (
			(* Retained as an alias of isKindOfPromise for callers that used the
	   short form before the naming was aligned with psoup. *)
			
			^true
		)
		public printOn: stream = (
			(* BOGUS - debugging *)
			
			internalRef refPrintOn: stream
		)
		yourself = (
			^super yourself
		)
	) : ()
	public class Resolver new = Object new (
		(* A Resolver represents the authority to resolve a Promise and is the control facet of the promise's eventual resolution. *)
		
		|
			private (* N.B. We must not leak access to an InternalResolver via subobjects. *) internalResolver = InternalLocalPromise __owner: currentActor.
			public promise <Promise[V, E]> = internalResolver externalRef.
		|
	) (
		public break: error <E> = (
			internalResolver internalResolve: (InternalBrokenRef problem: error
					__owner: currentActor)
		)
		public fulfill: value <V> = (
			internalResolver internalResolve: (asInternalRef: value)
		)
		public isKindOfResolver ^<Boolean> = (
			^true
		)
		public isResolver ^<Boolean> = (
			(* Alias of isKindOfResolver — see Ref>>isPromise for the same rationale. *)
			
			^true
		)
	) : ()
	public class Timer __duration: milliseconds callback: callback repeating: repeating = Object new (
		|
			cancelled ::= false.
			handle
			isRepeating <Boolean> = repeating.
			userCallback = callback.
		|
		repeating ifTrue: [ self schedule: callback every: milliseconds ]
			ifFalse: [ self schedule: callback after: milliseconds ].
	) (
		public cancel = (
			(* Previously referenced an undeclared [process] slot — sending [cancel]
	   to any Timer crashed with DNU. We now capture the JS timer handle in
	   [schedule:after:]/[schedule:every:] and clearTimeout/clearInterval
	   here. *)
			
			cancelled:: true.
			nil = handle ifFalse: [
					isRepeating ifTrue: [
							_js call: (_js propertyOf: (_js ident: 'window')
									at: (_js literal: 'clearInterval'))
								with: {handle. }
						]
						ifFalse: [
							_js call: (_js propertyOf: (_js ident: 'window')
									at: (_js literal: 'clearTimeout'))
								with: {handle. }
						].
					handle:: nil
				]
		)
		public isActive ^<Boolean> = (
			cancelled ifTrue: [ ^false ].
			^nil ~= handle
		)
		public isTimer ^<Boolean> = (
			^true
		)
		schedule: callback after: ms = (
			handle:: _js call: (_js propertyOf: (_js ident: 'window')
					at: (_js literal: 'setTimeout'))
				with: {callback. ms. }
		)
		schedule: callback every: ms = (
			(* Wrap the user callback so it receives [self] as the argument,
	   matching psoup's [:Timer] signature for [Timer>>every:do:]. *)
			
			handle:: _js call: (_js propertyOf: (_js ident: 'window')
					at: (_js literal: 'setInterval'))
				with: {[ callback value: self ]. ms. }
		)
	) : (
		public after: duration do: callback <[]> ^<Timer> = (
			^self __duration: duration callback: callback repeating: false
		)
		public every: duration do: callback <[:Timer | Object]> ^<Timer> = (
			^self __duration: duration callback: callback repeating: true
		)
	)
	class WhenReactor onValue: v onError: e resolver: r = Object new (
		(* A when-catch for a promise.

Note that all slots contain objects that belong to the actor which sent #whenResolved:. *)
		
		|
			onValue <[:V | Object] | []> = v.
			onError <[:E | Object] | []> = e.
			resolver <InternalResolver> = r.
		|
	) (
		public reactBroken: value = (
			resolver __owner == currentActor ifFalse: [ halt ].
			currentActor enqueueMessage: (PendingDelivery receiver: onError
					selector: #cull:
					arguments: {value. }
					resolver: resolver)
		)
		public reactMoreResolved: internalRef = (
			resolver internalResolve: (asInternalRef: (internalRef whenFulfilled: onValue
						whenBroken: onError))
		)
		public reactResolved: value = (
			resolver __owner == currentActor ifFalse: [ halt ].
			currentActor enqueueMessage: (PendingDelivery receiver: onValue
					selector: #cull:
					arguments: {value. }
					resolver: resolver)
		)
	) : ()
	private asInternalRef: externalRefOrUnboxedNearRef = (
		^(isRef: externalRefOrUnboxedNearRef) ifTrue: [
				internalRefs at: externalRefOrUnboxedNearRef ifAbsent: [ halt ]
			]
			ifFalse: [
				InternalNearRef wrapping: externalRefOrUnboxedNearRef __owner: currentActor
			]
	)
	private check: object allowedIn: actor = (
		assert: [ nil ~= actor ] message: 'Invalid actor'.
		(isRef: object) ifTrue: [ object __owner == actor ifFalse: [ halt ] ]
		(* Otherwise near reference *)
		
	)
	private createFarReferenceTo: target in: targetActor for: sourceActor = (
		^(InternalFarReference target: target
			targetsActor: targetActor
			__owner: sourceActor) externalRef
	)
	private createRemotePromiseOf: resolverInTarget in: targetActor for: sourceActor = (
		| sourceResolver redirector message remotePromise |
		sourceActor == targetActor ifTrue: [ halt ].
		sourceResolver:: InternalLocalPromise __owner: sourceActor.
		sourceResolver state: #remote.
		sourceResolver _targetPromise: resolverInTarget.
		sourceResolver _targetActor: targetActor.
		redirector:: RedirectReactor from: targetActor
			to: sourceActor
			resolver: sourceResolver.
		message:: PendingDelivery receiver: resolverInTarget
			selector: #addReactor:
			arguments: {redirector. }
			resolver: nil.
		targetActor enqueueMessage: message.
		^Ref wrapping: sourceResolver __owner: sourceActor
	)
	private currentActor = (
		^_js ident: 'currentActor'
	)
	private isRef: object <Object> ^<Boolean> = (
		^Ref == (_js propertyOf: object at: (_js literal: 'newspeakClass'))
	)
	private isValueObject: object <Object> ^<Boolean> = (
		nil == object ifTrue: [ ^true ].
		true == object ifTrue: [ ^true ].
		false == object ifTrue: [ ^true ].
		object isKindOfString ifTrue: [ ^true ].
		object isKindOfNumber ifTrue: [ ^true ].
		object isKindOfCharacter ifTrue: [ ^true ].
		object isKindOfBehavior ifTrue: [ ^isValueObject: object enclosingClass ].
		Promise == object ifTrue: [ ^true ].
		^false
	)
	private wrapArgument: argument from: sourceActor to: targetActor = (
		(* [argument] lives in [sourceActor], answer the corresponding proxy that lives in [targetActor] *)
		
		sourceActor == targetActor ifTrue: [ halt ].
		
		(* We can't tell which side a near reference belongs to here, so we must have decided this earlier. *)
		^(asInternalRef: argument) wrapFor: targetActor
	)
	private wrapArguments: arguments from: sourceActor to: targetActor = (
		^arguments collect: [:argument |
				wrapArgument: argument from: sourceActor to: targetActor
			]
	)
	public ultimateExceptionHandler: h <[:Exception :Activation | Object]> = (
		(* Stash the handler in the module-level slot. The browser-side path
     that surfaces unhandled exceptions still needs to call
     [handlerOfLastResort_slot value: e value: nil] on a real failure;
     wiring that up to JS [window.onerror] / [unhandledrejection] is a
     follow-up. *)
		
		handlerOfLastResort_slot:: h
	)
	public handlerOfLastResort = (
		^handlerOfLastResort_slot
	)
) : ()