@weft-js/start 0.1.1 → 0.1.2

package/src/data/cache.ts

@@ -0,0 +1,354 @@
+import { createRoot, derived, state, untrack, type Derived, type State } from '@weft-js/core'
+import { client, peers } from '../router'
+import { fnOf, fns, go, net, registered, runtime, server } from './foundation'
+import { FnError, isRedirect, keyOf, redirect } from './primitives'
+import { isMade, produce, resetMade, share } from './draft'
+import { transport } from './transport'
+import type { Fn, OptimisticCache, QueryRef, Wire } from './types'
+
+export interface Layer {
+  m: number
+  apply: (draft: unknown) => unknown
+  waiting?: boolean
+}
+export interface Entry {
+  key: string
+  id: string
+  input: unknown
+  base: State<unknown>
+  has: State<boolean>
+  stale: State<boolean>
+  layers: State<Layer[]>
+  value: Derived<unknown>
+  tags: string[]
+  readers: number
+  p?: Promise<unknown> | undefined
+  /** The `clock` when `p` left. */
+  since: number
+  /** The `clock` when something newer than any read in flight reached the entry. */
+  gen: number
+  /** Which overlapping run of calls last landed a reply here. */
+  run: number
+  /** A value was turned away while layers were on it: it reads again once they're done. */
+  held?: boolean
+  /** When a server value last landed. */
+  at: number
+}
+
+export const entries = new Map<string, Entry>()
+/** Orders what reaches an entry: a read or a navigation that left before `gen` is older than what's there. */
+export let clock = 0
+/** When each tag was last invalidated: a value read before that is out of date, whether or not the cache held it then. */
+const written = new Map<string, number>()
+const passed = (tags: string[], since: number) => tags.some((t) => written.get(t)! > since)
+/** Each query's latest entry: a skeleton for other args takes its shape (research 31 §4). */
+export const lastSeen = new Map<string, Entry>()
+
+export function entry(fn: Fn, input: unknown): Entry {
+  if (!registered) net()
+  const key = keyOf(fn.$id, input)
+  let e = entries.get(key)
+  if (e) {
+    entries.delete(key) // the map is in order of use: `evict` starts from its far end
+    entries.set(key, e)
+  } else {
+    // Owned by no component: the entry outlives its readers (the next reader finds it seeded).
+    e = createRoot(() => {
+      const base = state<unknown>(undefined),
+        has = state(false),
+        dated = state(false),
+        layers = state<Layer[]>([])
+      const value = derived(() => {
+        let v = base.value
+        if (!has.value) return v
+        for (const l of layers.value) v = produce(v, l.apply)
+        return v
+      })
+      return {
+        key,
+        id: fn.$id,
+        input,
+        base,
+        has,
+        stale: dated,
+        layers,
+        value,
+        tags: [],
+        readers: 0,
+        since: 0,
+        gen: 0,
+        run: 0,
+        at: 0,
+      }
+    }, null)
+    entries.set(key, e)
+    if (entries.size > ceiling) evict(e)
+  }
+  return e
+}
+
+const ENTRIES = 1000
+/** When to look again: a quarter past what's left, so a page with thousands of readers doesn't walk them all per entry. */
+let ceiling = ENTRIES
+/** A search box writes an entry per keystroke for the tab's life. What nothing reads goes, least recently used first. `fresh` is about to get its reader. */
+function evict(fresh: Entry) {
+  for (const e of entries.values()) {
+    if (entries.size <= ENTRIES) break
+    if (
+      e !== fresh &&
+      !e.readers &&
+      !e.p &&
+      !untrack(() => e.layers.value.length) &&
+      lastSeen.get(e.id) !== e
+    )
+      entries.delete(e.key)
+  }
+  ceiling = Math.max(ENTRIES, entries.size + (entries.size >> 2))
+}
+
+export const fresh = (e: Entry) => e.has.value && !e.stale.value
+
+/** A prediction no reply has confirmed yet. */
+export const predicted = (e: Entry) => e.layers.value.some((l) => !l.waiting)
+
+export function load(e: Entry): Promise<unknown> {
+  if (e.p && e.gen <= e.since) return e.p
+  // What's read now may or may not hold the calls in flight, so it can't go under their layers: it waits for them.
+  if (untrack(() => e.has.value && predicted(e))) {
+    e.held = true
+    return Promise.resolve(untrack(() => e.value.value))
+  }
+  const since = (e.since = clock)
+  const p: Promise<unknown> = transport()
+    .query(e.id, e.input)
+    .then(
+      (a) => {
+        if (e.p === p) e.p = undefined
+        tries = 0
+        if (a.r !== undefined) {
+          go(a.r, true)
+          redirect(a.r)
+        }
+        const tags = a.t ?? []
+        if (untrack(() => !e.has.value) && passed(tags, since)) return load(e) // a first load's tags come with its answer
+        if (!land(e, a.v, tags, since)) {
+          if (e.p) return e.p
+          if (untrack(() => e.stale.value)) return load(e)
+        }
+        return untrack(() => e.value.value)
+      },
+      (err) => {
+        if (e.p === p) e.p = undefined
+        untrack(() => {
+          if (!e.has.value) return
+          if (err instanceof FnError && (err.status === 401 || err.status === 403)) forget(e)
+          else if (!isRedirect(err) && (!(err instanceof FnError) || err.status >= 500)) retry()
+        })
+        throw err
+      },
+    )
+  return (e.p = p)
+}
+
+/** The server refused this session, so the value may not be this user's any more: readers get the first-load error. */
+function forget(e: Entry) {
+  e.has.value = false
+  e.base.value = undefined
+  if (lastSeen.get(e.id) === e) lastSeen.delete(e.id)
+}
+
+/** How often a failed read is tried again, doubling, for as long as something on screen is out of date. */
+const RETRY = 1000,
+  RETRIES = 30_000
+let again: ReturnType<typeof setTimeout> | undefined
+let tries = 0
+
+function retry() {
+  if (again === undefined) again = setTimeout(owed, Math.min(RETRIES, RETRY * 2 ** tries++))
+}
+
+/** Read what readers are owed, once the tab can use it. `online` and a returning tab come here at once. */
+export function owed() {
+  clearTimeout(again)
+  again = undefined
+  // Off a browser `onLine` isn't there, and that isn't offline.
+  if (globalThis.document?.hidden || (navigator as { onLine?: boolean }).onLine === false) return // `back` or `online` comes here
+  untrack(() => {
+    for (const e of entries.values())
+      if (e.readers && e.has.value && e.stale.value && !e.p && !e.held && !predicted(e))
+        load(e).catch(() => {})
+  })
+}
+
+/** A read or a navigation's value lands, unless something newer got here after it left, or layers are on the entry. */
+function land(e: Entry, v: unknown, tags: string[], since: number): boolean {
+  return untrack(() => {
+    if (e.gen > since) return false
+    if (e.has.value && predicted(e)) return !(e.held = true)
+    setBase(e, v, tags)
+    return true
+  })
+}
+
+/** Mark the entry out of date: a read already out is older than what it has to tell. */
+export function outdate(e: Entry) {
+  e.gen = ++clock
+  e.stale.value = true
+}
+
+/** The layers that held a value off are gone: read once, now that every call behind them has answered. */
+export function relieve(e: Entry) {
+  if (!e.held || predicted(e)) return
+  e.held = false
+  outdate(e)
+  load(e).catch(() => {})
+}
+
+/** A server value lands: shared with the old base, layers of settled calls dropped, readers updated in place. */
+export function setBase(e: Entry, v: unknown, tags: string[]) {
+  untrack(() => {
+    e.gen = ++clock
+    e.at = performance.now()
+    e.tags = tags
+    e.base.value = share(e.base.value, v)
+    e.has.value = true
+    e.stale.value = false
+    lastSeen.set(e.id, e)
+    if (e.layers.value.some((l) => l.waiting))
+      e.layers.value = e.layers.value.filter((l) => !l.waiting)
+  })
+}
+
+/** Seed the cache from the server (the page's `#weft-cache`, a navigation's `c`). `since`: when that navigation left. */
+export function seed(list: Wire[] | null | undefined, since = Infinity) {
+  for (const [id, input, v, tags] of list ?? []) {
+    const e = entry(fns.get(id) ?? ({ $id: id } as Fn), input)
+    if (land(e, v, tags, since) && passed(tags, since)) outdate(e)
+  }
+}
+
+/** Mark entries with any of `tags` stale: entries with readers refetch now, the rest on their next read. */
+export function staleTags(tags: string[], except: Set<string> = new Set()) {
+  if (!tags.length) return
+  ++clock
+  for (const t of tags) {
+    written.delete(t) // in order of use, like `entries`
+    written.set(t, clock)
+  }
+  for (const t of written.keys()) {
+    if (written.size <= ENTRIES) break
+    written.delete(t)
+  }
+  untrack(() => {
+    for (const e of entries.values())
+      if (!except.has(e.key) && e.tags.some((t) => tags.includes(t))) outdate(e)
+  })
+  owed() // one a failed read left stale has nothing else to wake it
+  client.invalidated?.(tags)
+}
+
+/**
+ * The client cache. In `optimistic`, `update`/`set` add layers; elsewhere they write the base (until the next server
+ * value). `invalidate` marks tags stale (readers refetch).
+ */
+export const cache: OptimisticCache & {
+  invalidate(...tags: string[]): Promise<void> | undefined
+  clear(): void
+} = {
+  update(q, input, recipe) {
+    const e = entry(fnOf(q), input)
+    if (untrack(() => e.has.value))
+      setBase(
+        e,
+        produce(
+          untrack(() => e.base.value),
+          recipe as Layer['apply'],
+        ),
+        e.tags,
+      )
+  },
+  set(q, input, value) {
+    const e = entry(fnOf(q), input)
+    setBase(e, value, e.tags)
+  },
+  get<O>(q: QueryRef<O>, input?: unknown) {
+    const e = entries.get(keyOf(fnOf(q).$id, input))
+    return e && (untrack(() => e.value.value) as O)
+  },
+  isOptimistic: (v) => !!v && typeof v === 'object' && isMade(v),
+  invalidate(...tags) {
+    const scope = server()
+    if (scope) return runtime.exec!.invalidate(scope, tags)
+    staleTags(tags)
+    return undefined
+  },
+  clear() {
+    entries.clear()
+    lastSeen.clear()
+    written.clear()
+    ceiling = ENTRIES
+    resetMade()
+  },
+}
+
+export function resetRetry() {
+  clearTimeout(again)
+  again = undefined
+  tries = 0
+}
+
+/** Server: drop `tags` for this response and the shared cache. Client: refetch what reads them. */
+export const invalidate = (...tags: string[]) => cache.invalidate(...tags)
+
+/** How old a value can be when its tab comes back and still be left alone. */
+const FOCUS = 30_000
+
+if ((import.meta as ImportMeta & { hot?: unknown }).hot)
+  client.refreshed = () =>
+    untrack(() => {
+      for (const e of entries.values()) outdate(e)
+    })
+
+// ---- start-up ----------------------------------------------------------------------------------------------------
+
+// In the browser, as the first route chunk that uses a query loads (before hydration): the page's entries, and
+// whatever a navigation brought before this module loaded.
+if (typeof document !== 'undefined' && !runtime.scope) {
+  client.seed = seed
+  client.now = () => clock
+  seed(client.seeds)
+  client.seeds = undefined
+  const el = document.getElementById('weft-cache')
+  if (el) seed(JSON.parse(el.textContent))
+  // A stream's chunks say what landed: here is everything so far, and each one's script pushes the next.
+  // They were read for this page, so anything written here since is newer.
+  const landed = ((globalThis as { $wc?: { c: Wire[] }[] }).$wc ||= []),
+    since = clock
+  for (const l of landed) seed(l.c, since)
+  landed.push = (...l) => {
+    for (const x of l) seed(x.c, since)
+    return Array.prototype.push.apply(landed, l)
+  }
+  const later: string[] = []
+  const back = () => {
+    if (document.hidden) return
+    const old = performance.now() - FOCUS
+    // Showing and focus can come apart: one already stale is being read, and marking it again would throw that read away.
+    untrack(() => {
+      for (const e of entries.values())
+        if (e.readers && e.has.value && e.at < old && !e.stale.value) outdate(e)
+    })
+    if (later.length) staleTags(later.splice(0))
+    owed()
+  }
+  // A hidden tab reads nothing until it shows: every open tab refetching on every write is what this would cost otherwise.
+  if (peers)
+    peers.onmessage = (m) => {
+      if (!m.data) return // the session changed: run.tsx reloads
+      if (document.hidden) later.push(...m.data)
+      else staleTags(m.data)
+    }
+  addEventListener('focus', back)
+  addEventListener('online', owed)
+  document.addEventListener('visibilitychange', back)
+}

package/src/data/definitions.ts

@@ -0,0 +1,94 @@
+import { createRoot, derived, state } from '@weft-js/core'
+import { FN, SUBMIT, fns, nextAuto } from './foundation'
+import { mutate } from './mutation'
+import { StartError } from './primitives'
+import { fetchQuery, liveQuery, shapeOf, use } from './query'
+import type {
+  AuthScope,
+  Fn,
+  ImplMutationDef,
+  ImplQueryDef,
+  In,
+  Mutation,
+  MutationDef,
+  Out,
+  Query,
+  QueryDef,
+  StandardSchemaV1,
+  LiveOptions,
+} from './types'
+
+const oneBody = (def: { run?: unknown; impl?: unknown; $id?: string }) => {
+  if (def.run && def.impl)
+    throw new StartError(
+      'R103',
+      `\`${def.$id ?? 'a function'}\` has both \`run\` and \`impl\``,
+      'keep one: `impl` replaces the body',
+    )
+}
+
+/** A server function that reads, with its output typed by a schema. */
+export function query<
+  OS extends StandardSchemaV1,
+  S extends StandardSchemaV1 | undefined = undefined,
+  const A extends AuthScope | undefined = undefined,
+>(def: ImplQueryDef<S, OS, A>): Query<In<S>, Out<OS>>
+/** A server function that reads, with its output typed by `run`. */
+export function query<
+  O,
+  S extends StandardSchemaV1 | undefined = undefined,
+  const A extends AuthScope | undefined = undefined,
+>(def: QueryDef<S, O, A>): Query<In<S>, Awaited<O>>
+/** A server function that reads: cached by input on the client, and tagged for what invalidates it. */
+export function query(def: unknown): unknown {
+  const d = def as Fn['def'] & { $id?: string }
+  oneBody(d)
+  const id = d.$id ?? `q${nextAuto()}`
+  const fn: Fn = { kind: 'query', $id: id, def: d }
+  fns.set(id, fn)
+  const q = (input?: unknown) => use(fn, input)
+  q.fetch = (input?: unknown) => fetchQuery(fn, input)
+  q.shape = (input?: unknown) => shapeOf(fn, input)
+  q.live = (input?: unknown, options?: LiveOptions) => liveQuery(fn, input, options)
+  return Object.assign(q, { kind: 'query', $id: id, [FN]: fn })
+}
+
+/** A server function that writes, with its output typed by a schema. */
+export function mutation<
+  OS extends StandardSchemaV1,
+  S extends StandardSchemaV1 | undefined = undefined,
+  const A extends AuthScope | undefined = undefined,
+>(def: ImplMutationDef<S, OS, A>): Mutation<In<S>, Out<OS>>
+/** A server function that writes, with its output typed by `run`. */
+export function mutation<
+  O,
+  S extends StandardSchemaV1 | undefined = undefined,
+  const A extends AuthScope | undefined = undefined,
+>(def: MutationDef<S, O, A>): Mutation<In<S>, Awaited<O>>
+/** A server function that writes, and invalidates the queries that read what it changed. */
+export function mutation(def: unknown): unknown {
+  const d = def as Fn['def'] & { $id?: string }
+  oneBody(d)
+  const id = d.$id ?? `m${nextAuto()}`
+  const fn: Fn = { kind: 'mutation', $id: id, def: d }
+  fns.set(id, fn)
+  // Module-level boxes, read on the client only (a server render never shows a call in flight).
+  const { calls, error } = createRoot(
+    () => ({ calls: state(0), error: state<unknown>(undefined) }),
+    null,
+  )
+  const pending = createRoot(() => derived(() => calls.value > 0), null)
+  const m = (input?: unknown) => mutate(fn, input, calls, error)
+  return Object.assign(m, {
+    kind: 'mutation',
+    $id: id,
+    pending,
+    error: {
+      get value() {
+        return error.value
+      },
+    },
+    [FN]: fn,
+    [SUBMIT]: (input: unknown, form: true | FormData) => mutate(fn, input, calls, error, form),
+  })
+}

package/src/data/draft.ts

@@ -0,0 +1,104 @@
+let made = new WeakSet<object>()
+export const resetMade = () => {
+  made = new WeakSet()
+}
+export const isMade = (value: object) => made.has(value)
+
+type Obj = Record<PropertyKey, unknown>
+
+const plain = (v: unknown): v is Obj =>
+  !!v &&
+  typeof v === 'object' &&
+  (Array.isArray(v) ||
+    Object.getPrototypeOf(v) === Object.prototype ||
+    Object.getPrototypeOf(v) === null)
+
+/** `next`, with every subtree deep-equal to `prev`'s replaced by `prev`'s (TanStack's replaceEqualDeep). */
+export function share<T>(prev: unknown, next: T): T {
+  if (prev === next || !plain(prev) || !plain(next) || Array.isArray(prev) !== Array.isArray(next))
+    return next
+  const keys = Object.keys(next)
+  let same = Object.keys(prev).length === keys.length
+  const out = (Array.isArray(next) ? [] : {}) as Obj
+  for (const k of keys) {
+    out[k] = share(prev[k], next[k])
+    if (out[k] !== prev[k]) same = false
+  }
+  return (same ? prev : out) as T
+}
+
+interface Draft {
+  b: Obj
+  c?: Obj
+  px: Obj
+  done?: Obj
+}
+
+/**
+ * Run `recipe` on a copy-on-write draft of `base`: only objects it writes (and their parents) are copied. A recipe
+ * may instead return a new value. The copies are remembered for `cache.isOptimistic`.
+ */
+export function produce<T>(base: T, recipe: (draft: T) => T | void): T {
+  if (!plain(base)) {
+    const r = recipe(base)
+    return r === undefined ? base : r
+  }
+  const nodes = new Map<object, Draft>()
+  const byProxy = new WeakMap<object, Draft>()
+  const unwrap = (v: unknown) =>
+    v && typeof v === 'object' && byProxy.has(v) ? byProxy.get(v)!.b : v
+  const cur = (n: Draft) => n.c ?? n.b
+  const own = (n: Draft) => (n.c ??= (Array.isArray(n.b) ? n.b.slice() : { ...n.b }) as Obj)
+  const node = (b: Obj): Draft => {
+    let n = nodes.get(b)
+    if (n) return n
+    const self: Draft = (n = { b, px: b })
+    n.px = new Proxy((Array.isArray(b) ? [] : {}) as Obj, {
+      get: (_, k) => {
+        const v = cur(self)[k]
+        return plain(v) ? node(v).px : v
+      },
+      set: (_, k, v) => {
+        v = unwrap(v)
+        if (plain(v) && !nodes.has(v)) made.add(v) // a new object (a pushed row) is optimistic too
+        own(self)[k] = v
+        return true
+      },
+      deleteProperty: (_, k) => (delete own(self)[k], true),
+      has: (_, k) => k in cur(self),
+      ownKeys: () => Reflect.ownKeys(cur(self)),
+      getOwnPropertyDescriptor: (t, k) => {
+        const d = Reflect.getOwnPropertyDescriptor(cur(self), k)
+        if (d && k === 'length' && Array.isArray(t)) return { ...d, configurable: false }
+        return d && { ...d, configurable: true, value: self.px[k] }
+      },
+    })
+    nodes.set(b, n)
+    byProxy.set(n.px, n)
+    return n
+  }
+  // The result: copies where something changed, the original objects everywhere else.
+  const fin = (n: Draft): Obj => {
+    if (n.done !== undefined) return n.done
+    n.done = n.b // cycles stop here
+    const src = cur(n)
+    let out = n.c
+    for (const k of Object.keys(src)) {
+      const v = src[k]
+      if (!plain(v) || !nodes.has(v)) continue
+      const f = fin(nodes.get(v)!)
+      if (f !== v) (out ??= own(n))[k] = f
+    }
+    if (out) made.add(out)
+    return (n.done = out ?? n.b)
+  }
+  const deep = (v: unknown): unknown => {
+    if (v && typeof v === 'object' && byProxy.has(v)) return fin(byProxy.get(v)!)
+    if (Array.isArray(v)) return v.map(deep)
+    if (plain(v)) return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, deep(x)]))
+    return v
+  }
+  const root = node(base)
+  const r = recipe(root.px as T)
+  return (r === undefined || r === root.px ? fin(root) : deep(r)) as T
+}

package/src/data/foundation.ts

@@ -0,0 +1,95 @@
+import { createRoot, state, type Derived } from '@weft-js/core'
+import { client } from '../router'
+import type * as Exec from '../exec'
+import type { Scope } from '../exec'
+import type { Fn, LiveStatus, LiveMode, NetControl, Transport } from './types'
+
+/** The typed "no query" input: `getTodo(() => (id.value ? { id: id.value } : skip))`. */
+export const skip: unique symbol = Symbol.for('weft.skip') as never
+/** The marker a live query's input takes to subscribe to nothing yet. */
+export type Skip = typeof skip
+
+/** Every definition by id (the server answers `/_weft/fn/<id>` from it). */
+export const fns = new Map<string, Fn>()
+let auto = 0
+export const nextAuto = () => ++auto
+
+/**
+ * Set by the server half (server.tsx): the request in progress and the executor. `navigate` overrides the client
+ * router's (tests). Unset in plain tests.
+ */
+export const runtime: {
+  scope?: (() => Scope | undefined) | undefined
+  /** Run `fn` with `scope` current (the request's AsyncLocalStorage). */
+  enter?: (<T>(scope: unknown, fn: () => T) => T) | undefined
+  exec?: typeof Exec
+  transport?: Transport
+  navigate?: ((href: string, replace?: boolean) => void) | undefined
+  /** Set by the server's first request (and in dev when `drizzle/` grows): what each database applies before its first statement (db/core.ts). */
+  migrations?: { list: { tag: string; sql: string }[]; report(e: unknown): void } | undefined
+  /** The gates of clients whose statements can't be held (Prisma's): the server waits on them per request, and a failure doesn't fail it. */
+  dbs?: Set<() => Promise<void> | undefined>
+  /** Fan invalidated tags out to live subscribers (hub.ts). `origin`: the connection that needs no poke. */
+  poke?: ((tags: string[], origin?: string | null) => Promise<void>) | undefined
+  /** This tab's realtime connection: sent with mutations, so the tab doesn't poke itself. */
+  conn?: string | undefined
+  /** `room.in(params).publish`: socket.ts, on a server or under the fake. */
+  channels?: {
+    publish(
+      fn: Fn,
+      params: unknown,
+      name: string,
+      message: unknown,
+      options?: { exceptSelf?: boolean; from?: string },
+    ): Promise<void>
+    set(fn: Fn, key: unknown, value: unknown): Promise<void>
+  }
+} = {}
+
+/** The realtime connection's status and "this tab is older than the server" (research 30 §2). */
+export const rt = createRoot(
+  () => ({
+    status: state<LiveStatus>('connecting'),
+    mode: state<LiveMode>('app'),
+    stale: state(false),
+  }),
+  null,
+)
+/** The server runs a different build than this tab loaded: offer a reload. */
+export const stale: Derived<boolean> = rt.stale
+
+export const go = (href: string, replace?: boolean) =>
+  runtime.navigate ? runtime.navigate(href, replace) : void client.navigate?.(href, { replace })
+
+/** @weft-js/core/test's controls, when it's loaded; the first look registers the cache reset it runs after each test. */
+export let registered = false
+let reset = () => {}
+export const configureReset = (fn: () => void) => {
+  reset = fn
+}
+/** The test controls, once `@weft-js/core/test` has registered them. */
+export const net = () => {
+  const n = Reflect.get(globalThis, Symbol.for('weft.net')) as NetControl | undefined
+  if (n && !registered) {
+    registered = true
+    n.resets.push(() => {
+      reset()
+    })
+  }
+  return n
+}
+
+export const FN = Symbol.for('weft.fn')
+/** `<Form>`'s call: a mutation handle's `m(input)` with the input marked as coming from a form. */
+export const SUBMIT = Symbol.for('weft.submit')
+/** The definition behind a query or mutation handle (also accepts the definition). */
+export const fnOf = (h: unknown): Fn => ((h as Record<symbol, Fn> | null)?.[FN] ?? h) as Fn
+
+// ---- server and client calls ---------------------------------------------------------------------------------
+
+export const server = () => runtime.scope?.() ?? (net()?.als.getStore() as Scope | undefined)
+/** The request scope in progress, on the server or under the fake transport. */
+export const currentScope = server
+/** Run `fn` with `scope` current. */
+export const enter = <T>(scope: unknown, fn: () => T): T =>
+  runtime.enter ? runtime.enter(scope, fn) : net() ? net()!.als.run(scope, fn) : fn()

package/src/data/live-api.ts

@@ -0,0 +1,22 @@
+import { cache } from './cache'
+import { currentScope, fns, net, rt, runtime, skip } from './foundation'
+import { FnError, keyOf, StartError } from './primitives'
+import { fakeScope, track } from './transport'
+
+/** What `live.ts` reads from here; see its header. */
+export const liveApi = {
+  cache,
+  currentScope,
+  fakeScope,
+  fns,
+  FnError,
+  keyOf,
+  net,
+  rt,
+  runtime,
+  skip,
+  StartError,
+  track,
+}
+/** What `live.ts` is handed, instead of a static import that would close a cycle. */
+export type LiveApi = typeof liveApi