@playfast/reform 1.3.0 → 1.4.0

package/src/compose/compose-identity.test.ts

@@ -0,0 +1,175 @@
+import { expect, it } from '@effect/vitest'
+import { Data, Effect, Layer, Option, Schema as S } from 'effect'
+import {
+  absent,
+  AsyncCalc,
+  Boundary,
+  Composition,
+  each,
+  mount,
+  provide,
+  slot,
+  State,
+  StateGroup,
+  structureEquals,
+  Ui,
+  ui,
+} from '../index'
+import type { Contract } from './ui'
+import { makeFlightGate, until } from '../testkit/flight.testkit'
+
+// ---------------------------------------------------------------------------
+// 1. compose/composition.ts:78 — `parseProps` is built with `decodeUnknownOption`,
+//    so it parses the schema's ENCODED side. But `PropsOf<Config>` (and therefore
+//    `CompositionClass['Props']`, `RenderEnv.props`, `SlotProps`, and every
+//    `one(...)`/`each(...)` fill) is the schema's TYPE side, and every call site
+//    (react/compose.ts:198, proof/engineSink.ts:137, reform-remote/wireRender.ts:63,
+//    feature/featureFactory.ts:62) hands it an already-decoded Type value. This is
+//    the same defect the package already fixed for `State` (state.ts:105, "check the
+//    Type side — decodeUnknownSync would reject transforming schemas") and `Event`
+//    (event.ts:53); the props path was missed. A composition whose props schema is
+//    not an identity transform can never render.
+
+const propsSchema = S.Struct({ count: S.NumberFromString })
+
+class StampUi extends ui('hunt.StampUi')<{ props: { readonly count: number } }>() {}
+class Stamp extends Composition.make('hunt.Stamp', {
+  title: 'Stamp',
+  props: propsSchema,
+  ui: StampUi,
+})<Stamp>() {}
+
+it('composition: parseProps accepts the props value its own Props type declares', () => {
+  // The declared Props type of this composition is `{ count: number }` — this
+  // assignment is what the framework's own typing promises a parent may render with.
+  const props: typeof Stamp.Props = { count: 3 }
+  // `Schema.validateOption` — what State/Event/`makeFeatureInputParser` use for an
+  // already-decoded domain value — accepts it:
+  expect(S.validateOption(propsSchema)(props)).toEqual(Option.some({ count: 3 }))
+  // `parseProps` accepts only the ENCODED form, which no call site ever holds:
+  expect(Stamp.parseProps({ count: '3' })).toEqual(Option.some({ count: 3 }))
+  expect(Stamp.parseProps(props)).toEqual(Option.some({ count: 3 }))
+})
+
+// ---------------------------------------------------------------------------
+// 2. compose/ui.ts:150-151 — a Ui contract's runtime tag key is `reform/ui/${name}`
+//    with no per-definition discriminator, unlike `slot()` (slot.ts:150) and
+//    `Composition.make` (composition.ts:57) which both mint a sequenced key so that
+//    independently authored same-name definitions stay distinct. Two features that
+//    each declare `ui('Header')` silently share one provider entry: the last
+//    `provide` wins and the wrong view renders for the other contract.
+
+it.live('ui: independently authored same-name contracts resolve their own views', () => {
+  class First extends ui('hunt.Header')<{ props: { readonly label: string } }>() {}
+  class Second extends ui('hunt.Header')<{ props: { readonly label: string } }>() {}
+  const FirstView = Ui.make(First, ({ label }) => `first:${label}`)
+  const SecondView = Ui.make(Second, ({ label }) => `second:${label}`)
+  const Live = Layer.mergeAll(provide(First, FirstView), provide(Second, SecondView))
+  return Effect.gen(function* () {
+    const first = yield* First.impl
+    const second = yield* Second.impl
+    expect(second({ label: 'x' }, {}, {})).toBe('second:x')
+    expect(first({ label: 'x' }, {}, {})).toBe('first:x')
+  }).pipe(Effect.provide(Live))
+})
+
+// ---------------------------------------------------------------------------
+// 3. calc/queryState.ts:37 read through boundary/boundary.ts:194 — when the inputs
+//    move, a withheld previous-key result reads Loading, so the Boundary re-pends.
+//    `keepPreviousData: true` is documented as retaining the previous key's PAYLOAD
+//    ("safe when the payload is only displayed"), but the same switch also republishes
+//    the previous key's ERROR as the new key's `Error` arm. Here nothing is being
+//    "kept" — the failed key produced no data at all — yet the Boundary reports
+//    Errored for a key that is still in flight and has never failed.
+
+class Boom extends Data.TaggedError('hunt.Boom')<{ readonly detail: string }> {}
+
+const keyGate = makeFlightGate()
+Effect.runSync(keyGate.hold)
+
+it.live('boundary: a previous key’s error must not gate the key now in flight', () => {
+  class Subject extends State.make('subject', S.Number) {}
+  class Inputs extends StateGroup.make(Subject) {}
+  class Q extends AsyncCalc.make('hunt.Q', {
+    inputs: [StateGroup.select(Inputs, 'subject')],
+    output: S.Number,
+    error: S.instanceOf(Boom),
+    alwaysOn: true,
+  }) {}
+  class Gate extends Boundary.make('hunt.Gate', { over: [Q] }) {}
+  const TestLayer = Boundary.live(Gate).pipe(
+    Layer.provideMerge(
+      AsyncCalc.live(Q, {
+        keepPreviousData: true,
+        query: ({ subject }) =>
+          subject === 1
+            ? Effect.fail(new Boom({ detail: 'subject-1 failed' }))
+            : keyGate.through(Effect.succeed(subject)),
+      }),
+    ),
+    Layer.provideMerge(StateGroup.live(Inputs, { subject: 1 })),
+  )
+  return Effect.gen(function* () {
+    const subject = yield* StateGroup.select(Inputs, 'subject').store
+    const qStore = yield* Q.store
+    const store = yield* Gate.store
+
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Errored',
+    )
+
+    subject.set(2)
+    // The gate proves the query for subject 2 is parked in flight and has never settled.
+    yield* keyGate.awaitEntry(1)
+    expect(store.get()._tag).toBe('Pending')
+    // Root cause: the arm itself reports key 1's failure as key 2's state.
+    expect(qStore.get()._tag).not.toBe('Error')
+
+    yield* keyGate.release
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
+  }).pipe(Effect.provide(TestLayer))
+})
+
+// ---------------------------------------------------------------------------
+// 4. compose/structure.ts:170-186 — `deepEquals` classifies every non-array object as
+//    a bag of own enumerable keys, so any value that carries its data outside such keys
+//    (Date, Map, Set, class instances) compares EQUAL to every other value of its kind.
+//    That verdict feeds `retainEach` (structure.ts:114), which then hands back the
+//    PREVIOUS render's fill: `each` returns props holding a stale value, not merely a
+//    stale equality answer.
+
+class StampedUi extends ui('hunt.StampedUi')<{ props: { readonly at: Date } }>() {}
+class Stamped extends Composition.make('hunt.Stamped', {
+  title: 'Stamped',
+  ui: StampedUi,
+})<Stamped>() {}
+class RowSlot extends slot('Row')<RowSlot, typeof Stamped>() {}
+class BoardUi extends ui('hunt.BoardUi')<{
+  props: { readonly at: Date }
+  slots: { Row: RowSlot }
+}>() {}
+type Board = Contract<typeof BoardUi>
+
+it('each: a changed prop value must not be retained from the previous fill', () => {
+  const rows = [{ id: 'a' }]
+  const first = each(rows, {
+    key: (row) => row.id,
+    props: (row) => ({ at: new Date(1), id: row.id }),
+  })
+  const second = each(rows, {
+    key: (row) => row.id,
+    props: (row) => ({ at: new Date(2), id: row.id }),
+  })
+  expect(first.items[0]?.props.at.getTime()).toBe(1)
+  expect(second.items[0]?.props.at.getTime()).toBe(2)
+})
+
+it('structureEquals: frames whose props differ must not compare equal', () => {
+  const left = mount<Board>({ props: { at: new Date(1) }, slots: { Row: absent } })
+  const right = mount<Board>({ props: { at: new Date(2) }, slots: { Row: absent } })
+  expect(structureEquals(left, right)).toBe(false)
+})

package/src/compose/composition.ts

@@ -50,7 +50,6 @@ export type {
   SlotClassesOf,
 } from './compositionTypes'
 
-
 const compositionDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
   Symbol.for('reform/CompositionDefinitionSequence'),
   () => MutableRef.make(0),
@@ -75,8 +74,14 @@ export const make =
     const propsSchema = Schema.make<PropsOf<Config>, EncodedPropsOf<Config>>(
       config.props?.ast ?? Schema.Unknown.ast,
     )
-    const parseProps: (input: unknown) => Option.Option<PropsOf<Config>> =
-      Schema.decodeUnknownOption(propsSchema)
+    // Both sides. `PropsOf<Config>` — and so every value a parent renders with — is
+    // the schema's Type, which is what the in-process call sites hold; a decode-only
+    // parser rejects a transforming props schema's own declared props. Props
+    // arriving over the wire are Encoded, so that reading has to keep working too.
+    const validateProps = Schema.validateOption(propsSchema)
+    const decodeProps = Schema.decodeUnknownOption(propsSchema)
+    const parseProps = (input: unknown): Option.Option<PropsOf<Config>> =>
+      Option.orElse(validateProps(input), () => decodeProps(input))
     const tag = Context.GenericTag<
       CompositionId<N, Self, RequiredSlotIdentities<C>>,
       CompositionService<PropsOf<Config>, C>
@@ -100,7 +105,6 @@ export const make =
     return composition
   }
 
-
 export const live = <
   P,
   C extends UiContract,

package/src/compose/structure.ts

@@ -1,4 +1,4 @@
-import { Option, Struct } from 'effect'
+import { Equal, Option, Struct } from 'effect'
 import { reuse } from '../internal/reuse'
 import type { SlotProps } from './slot'
 import type { EventsOf, UiContract } from './ui'
@@ -164,6 +164,29 @@ interface ValuePair {
   readonly right: unknown
 }
 
+// A structural comparison is only meaningful over own enumerable keys when those
+// keys are the whole value — true of JSON-shaped records, false of everything
+// carrying its state anywhere else.
+const isPlainRecord = (candidate: unknown): candidate is Record<string, unknown> => {
+  if (!isRecord(candidate)) {
+    return false
+  }
+  const prototype = Object.getPrototypeOf(candidate)
+  return prototype === Object.prototype || prototype === null
+}
+
+const recordEntriesEqual = (
+  left: Record<string, unknown>,
+  right: Record<string, unknown>,
+  leftKeys: ReadonlyArray<string>,
+): boolean =>
+  leftKeys.length === Struct.keys(right).length &&
+  leftKeys.every(
+    (key) =>
+      Object.prototype.hasOwnProperty.call(right, key) &&
+      deepEquals({ left: left[key], right: right[key] }),
+  )
+
 const deepEquals = ({ left, right }: ValuePair): boolean => {
   if (Object.is(left, right)) {
     return true
@@ -174,19 +197,28 @@ const deepEquals = ({ left, right }: ValuePair): boolean => {
       left.every((element, index) => deepEquals({ left: element, right: right[index] }))
     )
   }
-  if (isRecord(left) && isRecord(right)) {
-    const leftKeys = Struct.keys(left)
-    const rightKeys = Struct.keys(right)
-    return (
-      leftKeys.length === rightKeys.length &&
-      leftKeys.every(
-        (key) =>
-          Object.prototype.hasOwnProperty.call(right, key) &&
-          deepEquals({ left: left[key], right: right[key] }),
-      )
-    )
+  if (isPlainRecord(left) && isPlainRecord(right)) {
+    return recordEntriesEqual(left, right, Struct.keys(left))
+  }
+  // Not a plain record. Own enumerable keys describe nothing about a `Date`, `Map` or
+  // `Set` — comparing by them calls every one of them empty, and so equal — so ask
+  // the value itself first.
+  if (Equal.equals(left, right)) {
+    return true
   }
-  return false
+  // Effect containers say no whenever they wrap a freshly allocated record, because
+  // their own equality bottoms out in reference identity. They do carry their payload
+  // in own properties, so descend: two structurally equal `Option.some({…})` are the
+  // same frame. A value with no own keys (a `Date`, a `Map`) has already answered.
+  if (!isRecord(left) || !isRecord(right)) {
+    return false
+  }
+  const leftKeys = Struct.keys(left)
+  return (
+    leftKeys.length > 0 &&
+    Object.getPrototypeOf(left) === Object.getPrototypeOf(right) &&
+    recordEntriesEqual(left, right, leftKeys)
+  )
 }
 
 export const structureEquals = (

package/src/compose/ui.ts

@@ -1,5 +1,5 @@
 import type { FunctionComponent } from 'react'
-import { Context, type Schema } from 'effect'
+import { Context, GlobalValue, MutableRef, type Schema } from 'effect'
 import type { AST } from 'effect/SchemaAST'
 import { type Manifest, definitionClass } from '../definition/definition'
 import type { Trigger } from '../ui/trigger'
@@ -139,6 +139,18 @@ type UiDefinitionStatics<
   typeof UiTypeId | 'manifest' | 'impl' | 'provider' | 'capture'
 >
 
+// Same rationale as `slot()` and `Composition.make`: two independently authored
+// definitions that happen to share a name are two contracts, not one. Keying the
+// runtime tag by name alone collapses them, and the last `provide` wins silently.
+// The wire still identifies a view by `manifest.name`, which is untouched.
+const uiDefinitionSequence: MutableRef.MutableRef<number> = GlobalValue.globalValue(
+  Symbol.for('reform/UiDefinitionSequence'),
+  () => MutableRef.make(0),
+)
+
+const nextUiTagKey = (name: string): string =>
+  `reform/ui/${name}/${MutableRef.incrementAndGet(uiDefinitionSequence)}`
+
 const buildUi = <
   N extends string,
   C extends UiContract,
@@ -147,8 +159,9 @@ const buildUi = <
   name: N,
   manifest: M,
 ): UiClass<C, N> & { readonly manifest: M } => {
-  const impl = Context.GenericTag<UiService<N>, ViewImpl<C>>(`reform/ui/${name}`)
-  const provider = Context.GenericTag<UiService<N>, CallableView>(`reform/ui/${name}`)
+  const key = nextUiTagKey(name)
+  const impl = Context.GenericTag<UiService<N>, ViewImpl<C>>(key)
+  const provider = Context.GenericTag<UiService<N>, CallableView>(key)
   const contract = definitionClass<UiClass<C, N> & { readonly manifest: M }>({
     [UiTypeId]: UiTypeId,
     manifest,
@@ -213,8 +226,12 @@ export const make = <U extends AnyUi>(
   contract: U,
   view: ViewImpl<Contract<U>>,
 ): MadeView<Contract<U>, UiName<U>, U> => {
-  // oxlint-disable-next-line reform-rules/no-object-assign -- `view` is callable; spread would drop callability, so its reflection statics are attached in place
-  const made: MadeView<Contract<U>, UiName<U>, U> = Object.assign(view, {
+  // Branded on a fresh wrapper rather than on `view` itself: the caller's function is
+  // theirs, and attaching in place lets a second `Ui.make` over the same view rebrand
+  // the first contract's binding out from under it.
+  const wrapped: ViewImpl<Contract<U>> = (props, slots, events) => view(props, slots, events)
+  // oxlint-disable-next-line reform-rules/no-object-assign -- `wrapped` is callable; spread would drop callability, so its reflection statics are attached in place
+  const made: MadeView<Contract<U>, UiName<U>, U> = Object.assign(wrapped, {
     [UiViewContract]: contract,
     capture: <Result>(visit: MadeViewCapture<Result>): Result => visit(made),
   })

package/src/event/event.ts

@@ -1,7 +1,8 @@
 import { Effect, Layer, MutableRef, Option, PubSub, Runtime, Schema } from 'effect'
 import { type Manifest, definitionClass } from '../definition/definition'
-import { resolveScheduler } from '../internal/scheduler'
+import { resolveScheduler, withInlineNotifications } from '../internal/scheduler'
 import { Bus, publish, type Tagged } from '../runtime/bus'
+import { applyReducers, Reducers } from '../runtime/loop'
 import type { Source } from '../state/token'
 import type { Trigger } from '../ui/trigger'
 
@@ -52,11 +53,39 @@ export const make = <const N extends string, P, Encoded>(
   // (e.g. a real Option, whose _tag lives on the prototype).
   const validatePayload = Schema.validateSync(schema)
   const buildUnknown = (payload: unknown): Tagged => build(validatePayload(payload))
+  // A trigger is the UI's edge of the loop: it runs inside a discrete DOM event, and
+  // React decides what the DOM should look like before that event finishes. Deferring
+  // the reducer to the drain fiber means the props React reads back are one turn stale,
+  // which is what rewrites a controlled input's value and drops the caret to the end.
+  // So reducers for this one event run here, before the trigger returns, and the
+  // envelope goes out marked `reduced` for the channel/procedure half. Every batched
+  // path — `Event.dispatch`, procedure fan-out, streams — is untouched and still
+  // coalesces on the drain loop.
   const trigger = Effect.gen(function* () {
     const bus = yield* Bus
+    // Optional: a bus can be provided without a reducer registry (bare harnesses,
+    // some test layers), and those keep the original deferred behaviour.
+    const reducers = yield* Effect.serviceOption(Reducers)
     const runtime = yield* Effect.runtime<never>()
     return (payload: P) => {
-      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: build(payload) }))
+      const built = build(payload)
+      const reduced = Option.match(reducers, {
+        onNone: () => false,
+        onSome: (registry) =>
+          withInlineNotifications(() => {
+            const failures = applyReducers({ registry, event: built })
+            failures.forEach((failure) =>
+              Effect.runSync(
+                Effect.logError(
+                  `reform: reducer threw handling '${failure.event._tag}'`,
+                  failure.error,
+                ),
+              ),
+            )
+            return true
+          }),
+      })
+      Runtime.runSync(runtime)(PubSub.publish(bus, { priority: 'High', event: built, reduced }))
     }
   })
   const event: EventClass<N, P> = definitionClass<EventClass<N, P>>({

package/src/event/syncTrigger.test.ts

@@ -0,0 +1,66 @@
+import { Effect, Layer, MutableRef, Schema as S } from 'effect'
+import { it } from '@effect/vitest'
+import { describe, expect } from 'vitest'
+import { until } from '../testkit/flight.testkit'
+import { Engine } from '../runtime/loop'
+import { publish } from '../runtime/bus'
+import * as Event from './event'
+import * as Reducer from '../reducer/reducer'
+import * as State from '../state/state'
+
+class Counter extends State.make('sync-trigger-counter', S.Number) {}
+class Bumped extends Event.make('SyncTriggerBumped', S.Struct({ to: S.Number })) {}
+class Fold extends Reducer.make('SyncTriggerFold', {
+  states: [Counter],
+  events: [Bumped],
+}) {}
+
+const makeLayer = (runs: MutableRef.MutableRef<number>) =>
+  Reducer.live(Fold, (_current: number, event: { readonly to: number }) => {
+    MutableRef.set(runs, MutableRef.get(runs) + 1)
+    return event.to
+  }).pipe(Layer.provideMerge(Layer.mergeAll(State.live(Counter, 0), Engine)))
+
+describe('synchronous trigger path', () => {
+  it.live('applies a reducer exactly once — the drain must not re-apply it', () => {
+    const runs = MutableRef.make(0)
+    return Effect.gen(function* () {
+      const bump = yield* Event.trigger(Bumped)
+      const store = yield* Counter.store
+
+      yield* Effect.sync(() => bump({ to: 7 }))
+
+      // Already applied before the trigger returned, with no turn of the loop.
+      expect(MutableRef.get(runs)).toBe(1)
+      expect(store.get()).toBe(7)
+
+      // The envelope still reaches the drain for channels and procedures; give it
+      // several turns and prove the reducer was not run a second time.
+      yield* until(
+        () => MutableRef.get(runs),
+        (count) => count > 1,
+        20,
+      )
+      expect(MutableRef.get(runs)).toBe(1)
+      expect(store.get()).toBe(7)
+    }).pipe(Effect.provide(makeLayer(runs)))
+  })
+
+  it.live('leaves Event.dispatch on the batched drain', () => {
+    const runs = MutableRef.make(0)
+    return Effect.gen(function* () {
+      const store = yield* Counter.store
+
+      yield* publish('Normal', Event.construct(Bumped, { to: 3 }))
+
+      // Nothing synchronous about this path: it is still the drain fiber's job.
+      expect(MutableRef.get(runs)).toBe(0)
+
+      yield* until(
+        () => store.get(),
+        (value) => value === 3,
+      )
+      expect(MutableRef.get(runs)).toBe(1)
+    }).pipe(Effect.provide(makeLayer(runs)))
+  })
+})

package/src/internal/familyKeys.ts

@@ -0,0 +1,41 @@
+import { MutableHashMap, Option, Predicate } from 'effect'
+
+export interface KeyCanonicalizer<K> {
+  readonly canonical: (key: K) => K
+  readonly release: (key: K) => void
+  readonly reset: () => void
+}
+
+/**
+ * A family indexes its members in a plain `Map`, which compares keys by reference. A
+ * composite key — `S.Data(S.Struct({ board, row }))`, the value-typed key Effect makes
+ * canonical — is decoded fresh on every lookup, so a plain `Map` mints a new member per
+ * lookup and strands the one before it: the fold reads its seed forever and the family
+ * grows without bound. Everything else in reform compares values with `Equal.equals`;
+ * this makes family keys agree. Primitive keys are their own canonical form and never
+ * touch the table, so the hot path is unchanged.
+ */
+export const makeKeyCanonicalizer = <K>(): KeyCanonicalizer<K> => {
+  const table = MutableHashMap.empty<K, K>()
+  return {
+    canonical: (key) => {
+      if (!Predicate.isObject(key)) {
+        return key
+      }
+      const known = MutableHashMap.get(table, key)
+      if (Option.isSome(known)) {
+        return known.value
+      }
+      MutableHashMap.set(table, key, key)
+      return key
+    },
+    release: (key) => {
+      if (Predicate.isObject(key)) {
+        MutableHashMap.remove(table, key)
+      }
+    },
+    reset: () => {
+      MutableHashMap.clear(table)
+    },
+  }
+}

package/src/internal/platform.test.ts

@@ -0,0 +1,55 @@
+import { afterEach, describe, expect, test, vi } from 'vitest'
+import { microtask, operationId } from './platform'
+
+// A host without them is the case these exist for, and it is not reachable by
+// reading the code: on every runtime the suite runs on, both globals are there
+// and the fallback branch never executes. Removing them is the only way to
+// measure it.
+afterEach(() => {
+  vi.unstubAllGlobals()
+})
+
+describe('microtask', () => {
+  test('runs the callback where the host has queueMicrotask', async () => {
+    const ran = await new Promise<boolean>((resolve) => {
+      microtask(() => resolve(true))
+    })
+    expect(ran).toBe(true)
+  })
+
+  test('runs the callback where the host has none', async () => {
+    vi.stubGlobal('queueMicrotask', undefined)
+    const ran = await new Promise<boolean>((resolve) => {
+      microtask(() => resolve(true))
+    })
+    expect(ran).toBe(true)
+  })
+
+  test('does not run the callback synchronously', async () => {
+    vi.stubGlobal('queueMicrotask', undefined)
+    const order: string[] = []
+    microtask(() => order.push('ran'))
+
+    // The whole of what "microtask" claims, stated without a timer: not during
+    // this turn, and by the time a couple of already-resolved promises have
+    // been awaited. A `setTimeout` comparison would say the same thing and is
+    // banned in tests here, because it settles on the host clock.
+    expect(order).toEqual([])
+    await Promise.resolve()
+    await Promise.resolve()
+    expect(order).toEqual(['ran'])
+  })
+})
+
+describe('operationId', () => {
+  test('mints ids that differ where the host has crypto', () => {
+    expect(new Set([operationId(), operationId(), operationId()]).size).toBe(3)
+  })
+
+  test('mints ids that differ where the host has none', () => {
+    vi.stubGlobal('crypto', undefined)
+    // Same millisecond by construction, so the counter is the only thing
+    // separating these three and the assertion is about the counter.
+    expect(new Set([operationId(), operationId(), operationId()]).size).toBe(3)
+  })
+})

package/src/internal/platform.ts

@@ -0,0 +1,72 @@
+import { MutableRef } from 'effect'
+
+/**
+ * The two host globals reform reaches for, behind a check.
+ *
+ * The core is renderer-neutral and the React package peers on `react` alone, so
+ * a scene is expected to run wherever a React reconciler does — including hosts
+ * that are neither a browser nor Node. Two globals were reached for directly and
+ * neither is guaranteed off the web: measured on `@react-gpui/core`, whose
+ * deno_core host installs `console` and the timers and nothing else, a scene
+ * dies at the first scheduler tick with `queueMicrotask is not defined`.
+ *
+ * Both fall back rather than throw, because the property each is used for
+ * survives the fallback: a resolved promise is a microtask by definition, and an
+ * operation id has to be unique among the ids one runtime mints.
+ */
+
+/**
+ * Run `callback` on a microtask.
+ *
+ * `queueMicrotask` where the host has it, a resolved promise where it does not.
+ * The two differ in one way that matters, which is why the check is kept rather
+ * than always taking the promise: a callback that throws inside `queueMicrotask`
+ * reaches the host's global error handler, where the same callback inside
+ * `.then` becomes an unhandled rejection nobody sees. The rethrow below puts the
+ * fallback back on the first of those.
+ */
+export const microtask = (callback: () => void): void => {
+  if (typeof queueMicrotask === 'function') {
+    queueMicrotask(callback)
+    return
+  }
+  // oxlint-disable-next-line reform-rules/no-promise-static-methods, reform-rules/no-promise-methods -- a microtask is the primitive being polyfilled here; Effect.succeed is not one, and this branch exists precisely because the host has no scheduling primitive to reach for
+  void Promise.resolve()
+    .then(callback)
+    .catch((error: unknown) => {
+      // oxlint-disable-next-line reform-rules/no-set-timeout-interval -- rethrowing on a macrotask is what reaches the host's global error handler, which is the semantics `queueMicrotask` has and a rejected promise does not
+      setTimeout(() => {
+        // oxlint-disable-next-line reform-rules/no-throw -- only way to surface a listener defect to the host's global error handler, as internal/scheduler.ts does for the same reason
+        throw error
+      })
+    })
+}
+
+const RADIX = 36
+
+const minted = MutableRef.make(0)
+
+/**
+ * An id no other operation of this runtime shares.
+ *
+ * `crypto.randomUUID` where the host has it, because an id that leaves the
+ * process should not be guessable from another one. Where it does not, the
+ * COUNTER carries uniqueness — every id this runtime mints differs from every
+ * other, which is the whole of what a `queued`/`settled` pairing needs — and the
+ * clock only separates two runtimes started at different milliseconds. Two
+ * started inside one millisecond can agree, so a host that sends these ids
+ * somewhere they meet another runtime's should install `crypto.randomUUID`
+ * rather than rely on this.
+ *
+ * `Math.random` is deliberately absent and should not be added: this package
+ * forbids it in favour of Effect's `Random`, and a service cannot be reached
+ * from a function the scheduler calls synchronously.
+ */
+export const operationId = (): string => {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+  MutableRef.update(minted, (count) => count + 1)
+  // oxlint-disable-next-line reform-rules/no-date-constructor -- DateTime is an Effect and this mint is synchronous; the clock is only a tiebreak between runtimes here, never read as a time
+  return `op-${Date.now().toString(RADIX)}-${MutableRef.get(minted).toString(RADIX)}`
+}