foldkit-mirror 0.2.3 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -125,7 +125,9 @@ subscriptions write Model changes outward
125
125
  ```
126
126
 
127
127
  A URL mirror does not need a restore Command because the initial URL is already
128
- available to application startup. A store mirror does.
128
+ available to application startup. A store mirror does — unless the store's keys
129
+ are already in hand at boot, in which case it bootstraps them into the initial
130
+ Model instead (see "Restore before the first render with bootstrap").
129
131
 
130
132
  ## Install
131
133
 
@@ -141,7 +143,7 @@ package.
141
143
  Start from a normal Surface application:
142
144
 
143
145
  ```ts
144
- import { Schema } from 'effect'
146
+ import { Match, Schema } from 'effect'
145
147
  import { defineMessageUnion } from 'foldkit/message'
146
148
  import { Url } from 'foldkit/url'
147
149
  import { Surface } from 'foldkit-surface'
@@ -205,12 +207,10 @@ Navigation comes back through the application's normal URL Message:
205
207
 
206
208
  ```ts
207
209
  function update(model: Model, message: Message) {
208
- switch (message._tag) {
209
- case 'UrlChanged':
210
- return {
211
- model: Filters.reduce(model, message.url),
212
- }
213
- }
210
+ return Match.value(message).pipe(
211
+ Match.tag('UrlChanged', ({ url }) => ({ model: Filters.reduce(model, url) })),
212
+ Match.orElse(() => ({ model })),
213
+ )
214
214
  }
215
215
  ```
216
216
 
@@ -226,8 +226,9 @@ const subscriptions = Subscription.make<Model, Message>()(() => ({
226
226
 
227
227
  At runtime, also reduce the initial URL before the first render and map later
228
228
  navigation into `Message.UrlChanged`. The Subscription writes outward; it does
229
- not replace those inbound steps. The assembly-based version below wires them
230
- through `Filters.wiring('UrlChanged')` and `placements.url(...)`.
229
+ not replace those inbound steps. `Mirror.routing` (next section) wires both into
230
+ `Runtime.makeApplication`; with `foldkit-bundle`, `Filters.wiring('UrlChanged')`
231
+ and `wiring.url(...)` do (see "One list per application with wiring").
231
232
 
232
233
  That is the entire URL loop:
233
234
 
@@ -236,6 +237,63 @@ Model -> subscription -> URL
236
237
  URL -> UrlChanged -> reduce -> Model
237
238
  ```
238
239
 
240
+ The loop closes without a second render: the mirror's own write comes back
241
+ as a `UrlChanged` whose keys hold what the Model already holds, and `reduce`
242
+ then returns the Model it was given. It does the same for a navigation that
243
+ leaves its keys alone, and `Prefs.reduce` for a restore that finds nothing new.
244
+
245
+ ## Plug the URL into `makeApplication` with `Mirror.routing`
246
+
247
+ Foldkit's `makeApplication` takes `init(url)`, `update` and
248
+ `routing: { onUrlRequest, onUrlChange }`. `Mirror.routing` takes the
249
+ application's own three and gives back the same three, with the mirrors
250
+ reading every URL, so the result spreads straight into the runtime config.
251
+ The Message gains the link variant Foldkit's routing asks for:
252
+
253
+ ```ts
254
+ import { Runtime } from 'foldkit'
255
+ import { UrlRequest } from 'foldkit/navigation'
256
+
257
+ const Message = defineMessageUnion({
258
+ ClickedLink: { request: UrlRequest },
259
+ UrlChanged: { url: Url },
260
+ })
261
+
262
+ const routed = Mirror.routing({
263
+ mirrors: [Filters],
264
+ urlChanged: 'UrlChanged',
265
+ init: (url: Url) => ({ model: initial }),
266
+ update: (model: Model, message: Message) => ({ model }),
267
+ routing: {
268
+ onUrlRequest: request => Message.ClickedLink({ request }),
269
+ onUrlChange: url => Message.UrlChanged({ url }),
270
+ },
271
+ })
272
+
273
+ Runtime.makeApplication({ Model, ...routed, view, subscriptions, container })
274
+ ```
275
+
276
+ What each piece does, and does not do:
277
+
278
+ - `init` calls the application's `init` and reads the starting URL into the
279
+ Model it returns. The application's Commands are its own; they were made
280
+ before the URL was read, so an `init` whose Commands depend on the slice
281
+ calls `Filters.reduce` itself.
282
+ - `update` reads a `UrlChanged` Message's URL into the Model, then hands the
283
+ Message to the application's `update`, which routes the path over slices the
284
+ mirrors have already read. Every other Message goes straight through.
285
+ - `routing` is the application's own: its links, its URL Message. Nothing is
286
+ intercepted or added.
287
+ - Writing the URL is still `Filters.subscriptions`, spread into the
288
+ application's Subscriptions as above.
289
+
290
+ `urlChanged` names the tag the mirrors read; it must be the Message
291
+ `onUrlChange` makes, and that Message must carry a `url`, or the call does not
292
+ compile. A `UrlChanged` for the URL the Model already shows (the mirror's own
293
+ write, answered by Foldkit) returns the Model it was given, provided the
294
+ application's `update` also returns its Model for a route that did not change.
295
+ `examples/foldkit-query-sync` is the full application.
296
+
239
297
  ## Add remembered local state with `Mirror.kv`
240
298
 
241
299
  For state that should survive reload but does not belong in the URL, use an
@@ -266,43 +324,59 @@ const Prefs = Mirror.kv(App, {
266
324
  })
267
325
  ```
268
326
 
269
- A key-value mirror restores through a Message, so include Mirror's cases in the
270
- application union:
327
+ A key-value mirror restores through a Message. Give it one variant of the
328
+ application's union, the way a Submodel gets one, and fold the mirror under it:
271
329
 
272
330
  ```ts
273
331
  const Message = defineMessageUnion({
274
- ...Mirror.messages,
332
+ GotPrefsMessage: { message: Mirror.Message },
275
333
  UrlChanged: { url: Url },
276
334
  })
335
+
336
+ const foldPrefs = Mirror.fold(Prefs, message => Message.GotPrefsMessage({ message }))
277
337
  ```
278
338
 
279
- Then reduce only its restore Message:
339
+ `update` then matches the whole union, and the mirror's answer arrives inside
340
+ its variant:
280
341
 
281
342
  ```ts
282
343
  function update(model: Model, message: Message): Return {
283
- if (Mirror.reduces(message)) {
284
- return {
285
- model: Prefs.reduce(model, message),
286
- }
287
- }
288
-
289
- switch (message._tag) {
290
- case 'UrlChanged':
291
- return {
292
- model: Filters.reduce(model, message.url),
293
- }
294
- }
344
+ return Message.match(message, {
345
+ GotPrefsMessage: ({ message }) => foldPrefs(model, message),
346
+ UrlChanged: ({ url }) => ({ model: Filters.reduce(model, url) }),
347
+ })
295
348
  }
296
349
  ```
297
350
 
298
- Ask the store for its representation at cold load:
351
+ Ask the store for its representation at cold load. `foldPrefs.init` runs the
352
+ mirror's `restore`, lifted to yield `GotPrefsMessage`:
353
+
354
+ ```ts
355
+ const init = (url: Url): Return =>
356
+ // URL wins first because startup already has it; the store answers later.
357
+ foldPrefs.init(Filters.reduce(initial, url))
358
+ ```
359
+
360
+ The lift is recorded on the Command, so a Story resolves `Prefs.restore` with
361
+ the keys the store would answer and sees the wrapped Message reach `update`.
362
+
363
+ The shorter path, for an `update` that only reduces, is to spread Mirror's
364
+ cases into the union and narrow by tag. It leaves the union with tags the
365
+ application never matches, so the rest of `update` is a partial match:
299
366
 
300
367
  ```ts
368
+ const Message = defineMessageUnion({ ...Mirror.messages, UrlChanged: { url: Url } })
369
+
370
+ function update(model: Model, message: Message): Return {
371
+ if (Mirror.reduces(message)) return { model: Prefs.reduce(model, message) }
372
+ return Match.value(message).pipe(
373
+ Match.tag('UrlChanged', ({ url }) => ({ model: Filters.reduce(model, url) })),
374
+ Match.orElse(() => ({ model })),
375
+ )
376
+ }
377
+
301
378
  const init = (url: Url): Return => ({
302
- // URL wins first because startup already has it.
303
379
  model: Filters.reduce(initial, url),
304
-
305
- // The store responds later with MirrorRestored.
306
380
  commands: [Prefs.restore],
307
381
  })
308
382
  ```
@@ -324,9 +398,59 @@ The important part is what did **not** change: `sidebar` and `draft` are still
324
398
  ordinary Model fields. The key-value store is merely how those fields are
325
399
  remembered between sessions.
326
400
 
401
+ ## Restore before the first render with bootstrap
402
+
403
+ A key-value mirror normally restores asynchronously: `restore` reads the store
404
+ and its `MirrorRestored` arrives later through `update`, leaving the first
405
+ render on defaults. When the store's keys are already in hand at boot — Flags
406
+ the server embedded in the page, a synchronous read, a test fixture — fold
407
+ them into the initial Model instead, with no Command and no flash:
408
+
409
+ ```ts
410
+ import type { Encoded } from 'foldkit-mirror'
411
+
412
+ const init = (flags: { prefs: Encoded }, url: Url): Return => ({
413
+ model: Mirror.bootstrap(
414
+ initial,
415
+ Prefs.bootstrap(flags.prefs),
416
+ model => Filters.reduce(model, url),
417
+ ),
418
+ })
419
+ ```
420
+
421
+ What each piece does, and does not do:
422
+
423
+ - `Prefs.bootstrap(keys)` is a pure step applying pre-read keys to the fields
424
+ still at their initial value — the same conservative read `reduce` applies
425
+ to a `MirrorRestored`, run before the first render instead of after a
426
+ Command. It sends no Message and runs no Effect.
427
+ - `model => Filters.reduce(model, url)` is the URL mirror's step: the starting
428
+ URL as the whole slice, the same call `Mirror.routing` folds into
429
+ `makeApplication`'s `init`.
430
+ - `Mirror.bootstrap(model, ...steps)` folds the steps in list order: stores
431
+ first, the URL last. Either order keeps URL > store > initial, but listing
432
+ the URL last states the precedence.
433
+
434
+ A step that changes nothing returns the Model it was given, so an empty store
435
+ renders nothing extra. Flags carry the store's keys as the store holds them
436
+ (`Encoded`: `Record<string, string>`), and the mirror decodes them with its
437
+ own codecs — the Flags schema does not repeat the text format.
438
+
439
+ When the store can only be read asynchronously, keep the `restore` Command
440
+ (`Prefs.wiring()`'s `init`, `foldPrefs.init`): bootstrapping needs the keys,
441
+ and `restore` is how they arrive. A bootstrapped value also wins over a later
442
+ `restore` for the fields it set, and the usual Subscription writes it outward
443
+ like any Model change — so bootstrapping from Flags while still running
444
+ `restore` is safe, not a conflict.
445
+
446
+ This is deliberately not part of `Wiring`: `Wiring.init` runs startup Commands
447
+ after the Model exists, while a bootstrap runs before it, inside `init`
448
+ itself. One is `Bootstrap` / Flags into the initial Model; the other is the
449
+ Model into Commands.
450
+
327
451
  ## One list per application with wiring
328
452
 
329
- The hand-wiring above — reduce by tag, restore at startup, spread the
453
+ The hand-wiring above — fold or reduce, restore at startup, spread the
330
454
  Subscriptions — is one value when the application uses `foldkit-bundle`:
331
455
 
332
456
  ```ts
@@ -341,9 +465,11 @@ const url = wiring.url(url => Message.UrlChanged({ url }))
341
465
 
342
466
  `Filters.wiring('UrlChanged')` routes the application's URL Message into
343
467
  `Filters.reduce` and reads the URL at startup; `Prefs.wiring()` routes its own
344
- `MirrorRestored` into `Prefs.reduce` and runs `Prefs.restore` at startup. Two
345
- key-value mirrors share the `MirrorRestored` tag, so each wiring routes only
346
- its own mirror's Message and the assembly accepts both.
468
+ `MirrorRestored` into `Prefs.reduce` and runs `Prefs.restore` at startup. Both
469
+ tags are shared: two key-value mirrors each read only their own
470
+ `MirrorRestored`, several URL mirrors each read their keys from one
471
+ `UrlChanged`, and the application's own `update` sees `UrlChanged` after them,
472
+ so it can route on the URL over the slices they have already read.
347
473
 
348
474
  ## Slice = field refs or a writable Projection
349
475
 
@@ -443,7 +569,7 @@ popstate
443
569
 
444
570
  ## How state changes here
445
571
 
446
- Ordinary edits use Message/`update`/`evo` like anywhere else; the mirror
572
+ Ordinary edits use Message/`update`/`modifyFields` like anywhere else; the mirror
447
573
  observes and represents. Restoration runs the other direction: the
448
574
  declared writable projection installs the URL/KV value into the Model on
449
575
  startup. The projection is declared up front, so restoration can only ever
@@ -501,6 +627,27 @@ current draft is no longer initial
501
627
  keep 'new text'
502
628
  ```
503
629
 
630
+ The write Subscription starts with the initial Model, before the store has
631
+ answered. Until the Model has taken in what the store holds, writing it would
632
+ replace the stored document with the initial slice, so a key-value mirror
633
+ holds each write until its slice is one the restore leaves unchanged:
634
+
635
+ ```text
636
+ cold load: Model at defaults, store holds { sidebar: 'closed' }
637
+
638
+ write (after the throttle) held: a restore would still change the Model
639
+ restore answers MirrorRestored -> reduce -> Model has sidebar 'closed'
640
+ write goes ahead: the Model holds what the store held
641
+ ```
642
+
643
+ The check is against the latest restore's answer, or, before any answer, the
644
+ store's own content at the first write, so a mirror nobody restores (a test
645
+ harness, a Model kept across a hot reload) writes once its slice agrees with
646
+ the store. An empty store holds back nothing. A read that fails answers as an empty store: `MirrorRestored`
647
+ carries no keys, and later writes replace whatever the store held. A second
648
+ `restore` holds writes again until its answer is taken in. The hold is per
649
+ runtime (per built `KeyValueStore`), so two runtimes never wait on each other.
650
+
504
651
  When URL and KV mirrors both represent one field, cold-load precedence is:
505
652
 
506
653
  ```text
@@ -600,6 +747,10 @@ MirrorStore.memory(...) test/in-memory representation
600
747
  `applyToHref(href, { set, remove })` is the pure URL transformation used by the
601
748
  URL store.
602
749
 
750
+ A kernel mirror holds its writes until the Model has taken in its `restore`,
751
+ as a key-value mirror does, with one store object as the session. A URL mirror
752
+ does not: startup reduces the URL before the first write.
753
+
603
754
  Most applications should use `Mirror.url` / `Mirror.kv` rather than starting at
604
755
  this kernel.
605
756
 
package/dist/index.d.mts CHANGED
@@ -1,8 +1,10 @@
1
1
  import { Duration, Effect, Schema } from "effect";
2
2
  import { KeyValueStore } from "effect/unstable/persistence";
3
+ import { Command } from "foldkit/command";
4
+ import * as Navigation from "foldkit/navigation";
3
5
  import { EntryWithoutKeepAlive } from "foldkit/subscription";
4
6
  import { Contract, FieldRef, Wiring, WritableProjection } from "foldkit-surface";
5
- import { Command } from "foldkit/command";
7
+ import { RoutingConfig } from "foldkit/runtime";
6
8
  import * as Update from "foldkit/update";
7
9
  import { Url } from "foldkit/url";
8
10
  //#region src/index.d.ts
@@ -125,6 +127,18 @@ export interface Decoded<Value> {
125
127
  readonly value: Partial<Value>;
126
128
  readonly issues: ReadonlyArray<DecodeIssue>;
127
129
  }
130
+ /**
131
+ * A synchronous pre-init step: `Bootstrap` / Flags into the initial Model.
132
+ * Pure: no Commands, no Messages, no Effects. It runs inside `init(flags, url)`
133
+ * before the first render, when the store's keys are already in hand (Flags the
134
+ * server embedded, a synchronous read, a test fixture). `Wiring.init` is the
135
+ * other lifecycle: startup Commands after the Model exists, such as the
136
+ * key-value mirror's `restore`, whose answer arrives later through `update`.
137
+ * Compose steps with `Mirror.bootstrap`; a step that changes nothing returns
138
+ * the Model it was given. Deliberately not part of `Wiring`, so the two
139
+ * lifecycles cannot be confused.
140
+ */
141
+ export type Bootstrap<AppModel> = (model: AppModel) => AppModel;
128
142
  /**
129
143
  * A Model slice kept in a store. `Value` is the slice's value type; the keys,
130
144
  * codecs, and intents are values on the mirror, not type parameters.
@@ -151,9 +165,21 @@ export interface Mirror<AppModel, Value extends Record<string, unknown>, R = nev
151
165
  * their initial value, so a change made before the store answered is kept.
152
166
  */
153
167
  readonly restoreKeys: (model: AppModel, keys: Encoded) => AppModel;
168
+ /**
169
+ * A pre-init step applying pre-read keys before the first render:
170
+ * `restoreKeys`, so a store step composed after a URL step (a `reduce` of
171
+ * the starting URL) keeps the URL's values. Takes the store's keys as the
172
+ * store holds them (`Encoded`), which is what Flags carry when the server
173
+ * embedded the store's document. A URL mirror inherits this too; its URL
174
+ * step is `(model) => reduce(model, url)`.
175
+ */
176
+ readonly bootstrap: (keys: Encoded) => Bootstrap<AppModel>;
154
177
  /** A link: the keys of `model` with `patch` applied, on `base` (default the current URL, else `/`). */
155
178
  readonly href: (model: AppModel, patch?: Partial<Value>, base?: string) => string;
156
- /** A Command that reads the store and yields `MirrorRestored` for this mirror. */
179
+ /**
180
+ * A Command that reads the store and yields `MirrorRestored` for this
181
+ * mirror. Until the Model holds what it answered, writes wait.
182
+ */
157
183
  readonly restore: Command<MirrorMessage, never, R>;
158
184
  /** One Subscription entry, `<name>.mirror`: writes the store when the encoded slice changes. */
159
185
  readonly subscriptions: { readonly [K in `${Name}.mirror`]: EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R>; };
@@ -179,9 +205,48 @@ export type UrlChangedMessage<Tag extends string> = {
179
205
  export type UrlMirrorWiring<AppModel, Tag extends string> = Wiring<AppModel, UrlChangedMessage<Tag>> & {
180
206
  readonly onUrl: (model: AppModel, url: Url) => AppModel;
181
207
  };
208
+ /** `Mirror.routing`'s config: the application's own `init`, `update` and routing, and the URL mirrors to read. */
209
+ export interface MirrorRoutingConfig<AppModel, Message extends {
210
+ readonly _tag: string;
211
+ }, Tag extends Message['_tag'], Args extends ReadonlyArray<unknown>, InitReturn extends {
212
+ readonly model: AppModel;
213
+ }, UpdateReturn extends {
214
+ readonly model: AppModel;
215
+ }> {
216
+ readonly mirrors: readonly [UrlMirror<AppModel, any, any>, ...UrlMirror<AppModel, any, any>[]];
217
+ /** The tag of the Message `routing.onUrlChange` makes. */
218
+ readonly urlChanged: Tag;
219
+ /** `(url) => …`, or `(flags, url) => …` for an application with flags. */
220
+ readonly init: (...args: [...Args, Url]) => InitReturn;
221
+ readonly update: (model: AppModel, message: Message) => UpdateReturn;
222
+ readonly routing: {
223
+ readonly onUrlRequest: (request: Navigation.UrlRequest) => Message;
224
+ readonly onUrlChange: (url: Url) => Extract<Message, UrlChangedMessage<Tag>>;
225
+ };
226
+ }
227
+ /** `init`, `update` and `routing` for `Runtime.makeApplication`, with the mirrors reading every URL. */
228
+ export interface MirrorRouting<AppModel, Message, Args extends ReadonlyArray<unknown>, InitReturn, UpdateReturn> {
229
+ readonly init: (...args: [...Args, Url]) => InitReturn;
230
+ readonly update: (model: AppModel, message: Message) => UpdateReturn;
231
+ readonly routing: RoutingConfig<Message>;
232
+ }
182
233
  export type KvMirrorWiring<AppModel> = Wiring<AppModel, MirrorRestored, KeyValueStore.KeyValueStore> & {
183
234
  readonly init: Update.Step<AppModel, MirrorRestored, KeyValueStore.KeyValueStore>;
184
235
  };
236
+ /**
237
+ * A key-value mirror folded under one of the application's own Message
238
+ * variants, from `Mirror.fold`. Calling it reduces the mirror's
239
+ * `MirrorRestored` into the Model; `restore` and `init` yield the wrapper
240
+ * Message instead of `MirrorRestored`, with the lift recorded so Story and
241
+ * Scene can resolve `restore` by the answer the store gives.
242
+ */
243
+ export interface MirrorFold<AppModel, ParentMessage> {
244
+ (model: AppModel, message: MirrorRestored): Update.Return<AppModel, ParentMessage>;
245
+ /** `restore`, lifted: yields the wrapper Message for this mirror's answer. */
246
+ readonly restore: Command<ParentMessage, never, KeyValueStore.KeyValueStore>;
247
+ /** A Step for `init`: the Model unchanged, and `restore` to run. */
248
+ readonly init: Update.Step<AppModel, ParentMessage, KeyValueStore.KeyValueStore>;
249
+ }
185
250
  /** A slice kept in Effect's `KeyValueStore`. */
186
251
  export interface KvMirror<AppModel, Value extends Record<string, unknown>, Name extends string = string> extends Mirror<AppModel, Value, KeyValueStore.KeyValueStore, Name> {
187
252
  readonly kind: 'kv';
@@ -208,12 +273,70 @@ export declare const Mirror: {
208
273
  keys: Schema.$Record<Schema.String, Schema.String>;
209
274
  };
210
275
  };
276
+ /**
277
+ * Mirror's Messages as one Schema, for a wrapper variant in the
278
+ * application's union: `GotPrefsMessage: { message: Mirror.Message }`. With
279
+ * a wrapper, `update` matches the application's union exhaustively and
280
+ * `Mirror.fold` reduces what arrives inside it.
281
+ */
282
+ Message: import("foldkit/message").MessageUnion<{
283
+ /** A store was read (`mirror.restore`); `keys` are what it held for the mirror named. */
284
+ MirrorRestored: {
285
+ name: Schema.String;
286
+ keys: Schema.$Record<Schema.String, Schema.String>;
287
+ };
288
+ }>;
289
+ /**
290
+ * A key-value mirror under one wrapper variant of the application's union,
291
+ * the same shape Foldkit gives a Submodel: `toParentMessage` wraps the
292
+ * mirror's `MirrorRestored`, the fold reduces it, and `fold.init` runs the
293
+ * lifted `restore` at startup. One wrapper per mirror: two mirrors that
294
+ * share a variant would each have to reduce the other's answer.
295
+ *
296
+ * @example
297
+ * ```ts
298
+ * const Message = defineMessageUnion({ GotPrefsMessage: { message: Mirror.Message } })
299
+ * const foldPrefs = Mirror.fold(Prefs, message => Message.GotPrefsMessage({ message }))
300
+ *
301
+ * const init = (): Return => foldPrefs.init(initial)
302
+ * const update = (model: Model, message: Message): Return =>
303
+ * Message.match(message, {
304
+ * GotPrefsMessage: ({ message }) => foldPrefs(model, message),
305
+ * })
306
+ * ```
307
+ */
308
+ fold: <AppModel, Value extends Record<string, unknown>, Name extends string, ParentMessage>(mirror: KvMirror<AppModel, Value, Name>, toParentMessage: (message: MirrorRestored) => ParentMessage) => MirrorFold<AppModel, ParentMessage>;
211
309
  /** Narrows the application's union to Mirror's cases, by tag. */
212
310
  reduces: <M extends {
213
311
  readonly _tag: string;
214
312
  }>(message: M) => message is Extract<M, {
215
313
  readonly _tag: "MirrorRestored";
216
314
  }>;
315
+ /**
316
+ * Folds pre-init steps into the initial Model, in list order: stores first,
317
+ * the URL last. Either order keeps URL > store > initial (a store bootstrap
318
+ * only fills fields still at their initial value, while a URL `reduce` sets
319
+ * its whole slice), but listing the URL last states the precedence. Among
320
+ * store bootstraps sharing a field, the first one wins.
321
+ *
322
+ * Use this when the keys are already in hand at boot: Flags the server
323
+ * embedded, a synchronous read, a test fixture. When the store can only be
324
+ * read asynchronously, use the `restore` Command (`wiring.init`,
325
+ * `fold.init`) instead: bootstrapping what the store holds needs the keys,
326
+ * and `restore` is how they arrive.
327
+ *
328
+ * @example
329
+ * ```ts
330
+ * const init = (flags: { prefs: Encoded }, url: Url): Return => ({
331
+ * model: Mirror.bootstrap(
332
+ * initial,
333
+ * Prefs.bootstrap(flags.prefs),
334
+ * model => Filters.reduce(model, url),
335
+ * ),
336
+ * })
337
+ * ```
338
+ */
339
+ bootstrap: <AppModel>(model: AppModel, ...steps: ReadonlyArray<Bootstrap<AppModel>>) => AppModel;
217
340
  /**
218
341
  * A slice kept in the URL: `Projection.pick(App.model.filter, App.model.q)`
219
342
  * as `?filter=…&q=…`, defaults elided, written when it changes (one history
@@ -221,13 +344,44 @@ export declare const Mirror: {
221
344
  * `onUrlChange` and on cold load.
222
345
  */
223
346
  url: <S extends Slice, Name extends string = string>(app: MirrorApp<SliceRoot<S>>, config: UrlMirrorConfig<S, Name>) => UrlMirror<SliceRoot<S>, SliceValue<S>, Name>;
347
+ /**
348
+ * URL mirrors plugged into `Runtime.makeApplication`: spread the result into
349
+ * its config. `init` reads the starting URL into the Model the application's
350
+ * `init` returns; `update` reads a `urlChanged` Message's URL into the Model
351
+ * before the application's `update` sees it, so a route handler finds the
352
+ * slices already read. `routing` is the application's own, passed through.
353
+ *
354
+ * @example
355
+ * ```ts
356
+ * Runtime.makeApplication({
357
+ * Model, view, subscriptions, container,
358
+ * ...Mirror.routing({
359
+ * mirrors: [Filters],
360
+ * urlChanged: 'ChangedUrl',
361
+ * init,
362
+ * update,
363
+ * routing: {
364
+ * onUrlRequest: request => Message.ClickedLink({ request }),
365
+ * onUrlChange: url => Message.ChangedUrl({ url }),
366
+ * },
367
+ * }),
368
+ * })
369
+ * ```
370
+ */
371
+ routing: <AppModel, Message extends {
372
+ readonly _tag: string;
373
+ }, const Tag extends Message["_tag"], Args extends ReadonlyArray<unknown>, InitReturn extends {
374
+ readonly model: AppModel;
375
+ }, UpdateReturn extends {
376
+ readonly model: AppModel;
377
+ }>(config: MirrorRoutingConfig<AppModel, Message, Tag, Args, InitReturn, UpdateReturn>) => MirrorRouting<AppModel, Message, Args, InitReturn, UpdateReturn>;
224
378
  /**
225
379
  * A slice kept in Effect's `KeyValueStore` under `key`, as one scoped,
226
380
  * versioned JSON document: written when it changes, read back by the
227
381
  * `restore` Command whose `MirrorRestored` `reduce` applies.
228
382
  */
229
383
  kv: <S extends Slice, Name extends string = string>(app: MirrorApp<SliceRoot<S>>, config: KvMirrorConfig<S, Name>) => KvMirror<SliceRoot<S>, SliceValue<S>, Name>;
230
- /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`. */
384
+ /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`, bootstrapped with `bootstrap`. */
231
385
  make: <S extends Slice, R, Name extends string = string>(app: MirrorApp<SliceRoot<S>>, store: MirrorStore<R>, config: MirrorConfig<S, Name>) => Mirror<SliceRoot<S>, SliceValue<S>, R, Name>;
232
386
  };
233
387
  //#endregion
@@ -1 +1 @@
1
- {"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":"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"}
1
+ {"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":"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"}
package/dist/index.mjs CHANGED
@@ -1,5 +1,7 @@
1
1
  import { Effect, Option, Result, Schema, Stream } from "effect";
2
2
  import { KeyValueStore } from "effect/unstable/persistence";
3
+ import { mapMessage } from "foldkit/command";
4
+ import { defineMessageUnion } from "foldkit/message";
3
5
  import * as Navigation from "foldkit/navigation";
4
6
  import * as Subscription from "foldkit/subscription";
5
7
  import { Projection } from "foldkit-surface";
@@ -194,7 +196,7 @@ const claim = (owner, location, keys, name) => {
194
196
  /** A Foldkit `Url` carries `search` and `hash` without their `?` and `#`; an href has them. */
195
197
  const withPrefix = (prefix, part) => part === "" || part.startsWith(prefix) ? part : `${prefix}${part}`;
196
198
  const hrefOf = (url) => typeof url === "string" ? url : `${url.pathname}${withPrefix("?", url.search._tag === "Some" ? url.search.value : "")}${withPrefix("#", url.hash._tag === "Some" ? url.hash.value : "")}`;
197
- const make = (app, kind, store, config, throttle) => {
199
+ const make = (app, kind, store, config, throttle, sessionKey) => {
198
200
  const fields = projectionOf(config.fields);
199
201
  const names = Object.keys(fields.schema.fields);
200
202
  const options = config.keys ?? {};
@@ -222,10 +224,21 @@ const make = (app, kind, store, config, throttle) => {
222
224
  const owned = names.map((field) => keyOf[field]);
223
225
  const name = nameOf(kind, owned, config.name);
224
226
  if (kind === "url") claim(app.owner, location, owned, name);
227
+ const texts = {};
228
+ for (const field of names) texts[field] = /* @__PURE__ */ new WeakMap();
229
+ const encodeField = (field, value) => {
230
+ if (typeof value !== "object" || value === null) return codecs[field].encode(value);
231
+ const known = texts[field].get(value);
232
+ if (known !== void 0) return known;
233
+ const text = codecs[field].encode(value);
234
+ texts[field].set(value, text);
235
+ return text;
236
+ };
237
+ const sameSlice = (current, next) => names.every((field) => Object.is(current[field], next[field]) || encodeField(field, current[field]) === encodeField(field, next[field]));
225
238
  const encodeSlice = (slice) => {
226
239
  const out = {};
227
240
  for (const field of names) {
228
- const text = codecs[field].encode(slice[field]);
241
+ const text = encodeField(field, slice[field]);
229
242
  if (!keep.has(field) && text === initialText[field]) continue;
230
243
  out[keyOf[field]] = text;
231
244
  }
@@ -257,20 +270,28 @@ const make = (app, kind, store, config, throttle) => {
257
270
  };
258
271
  const fromKeys = (model, keys) => {
259
272
  const decoded = decode(keys).value;
260
- return fields.set(model, {
273
+ const next = {
261
274
  ...initialSlice,
262
275
  ...decoded
263
- });
276
+ };
277
+ return sameSlice(fields.get(model), next) ? model : fields.set(model, next);
264
278
  };
265
- const restoreKeys = (model, keys) => {
266
- const current = fields.get(model);
267
- const restored = decode(keys).value;
268
- const next = { ...current };
279
+ const restorable = (textOf, keys) => {
280
+ const decoded = decode(keys).value;
281
+ const out = {};
269
282
  for (const field of names) {
270
- if (codecs[field].encode(current[field]) !== initialText[field]) continue;
271
- if (field in restored) next[field] = restored[field];
283
+ if (textOf(field) !== initialText[field] || !Object.hasOwn(decoded, field)) continue;
284
+ if (encodeField(field, decoded[field]) !== initialText[field]) out[field] = decoded[field];
272
285
  }
273
- return fields.set(model, next);
286
+ return out;
287
+ };
288
+ const restoreKeys = (model, keys) => {
289
+ const current = fields.get(model);
290
+ const restored = restorable((field) => encodeField(field, current[field]), keys);
291
+ return Object.keys(restored).length === 0 ? model : fields.set(model, {
292
+ ...current,
293
+ ...restored
294
+ });
274
295
  };
275
296
  const href = (model, patch, base) => {
276
297
  const slice = {
@@ -293,12 +314,53 @@ const make = (app, kind, store, config, throttle) => {
293
314
  messages: kind === "kv" ? ["MirrorRestored"] : [],
294
315
  metadata: []
295
316
  };
317
+ const sessions = /* @__PURE__ */ new WeakMap();
318
+ const sessionOf = (key, keys) => {
319
+ const known = sessions.get(key);
320
+ if (known !== void 0) return known;
321
+ const made = {
322
+ pending: Option.some(keys),
323
+ waiting: /* @__PURE__ */ new Set()
324
+ };
325
+ sessions.set(key, made);
326
+ return made;
327
+ };
328
+ const answered = (keys) => Option.match(sessionKey, {
329
+ onNone: () => Effect.void,
330
+ onSome: (key) => Effect.map(key, (key) => {
331
+ const session = sessionOf(key, keys);
332
+ session.pending = Option.some(keys);
333
+ for (const wake of [...session.waiting]) wake();
334
+ })
335
+ });
336
+ const settled = (encoded) => Option.match(sessionKey, {
337
+ onNone: () => Effect.void,
338
+ onSome: (key) => Effect.gen(function* () {
339
+ const at = yield* key;
340
+ const session = sessions.get(at) ?? sessionOf(at, (yield* store.read) ?? {});
341
+ const text = (field) => encoded[keyOf[field]] ?? initialText[field];
342
+ yield* Effect.callback((resume) => {
343
+ const check = () => {
344
+ if (!Option.match(session.pending, {
345
+ onNone: () => true,
346
+ onSome: (keys) => Object.keys(restorable(text, keys)).length === 0
347
+ })) return;
348
+ session.pending = Option.none();
349
+ session.waiting.delete(check);
350
+ resume(Effect.void);
351
+ };
352
+ session.waiting.add(check);
353
+ check();
354
+ return Effect.sync(() => session.waiting.delete(check));
355
+ });
356
+ })
357
+ });
296
358
  const restore = {
297
359
  name: `Mirror.restore(${name})`,
298
- effect: store.read.pipe(Effect.map((keys) => ({
360
+ effect: store.read.pipe(Effect.map((keys) => keys ?? {}), Effect.tap(answered), Effect.map((keys) => ({
299
361
  _tag: "MirrorRestored",
300
362
  name,
301
- keys: keys ?? {}
363
+ keys
302
364
  })))
303
365
  };
304
366
  const sync = (encoded) => Effect.gen(function* () {
@@ -316,7 +378,7 @@ const make = (app, kind, store, config, throttle) => {
316
378
  const entry = {
317
379
  dependenciesSchema: Schema.Struct({ keys: Schema.Record(Schema.String, Schema.String) }),
318
380
  modelToDependencies: (model) => ({ keys: encode(model) }),
319
- dependenciesToStream: ({ keys }) => Stream.fromEffect(sync(keys).pipe(Effect.delay(throttle))).pipe(Stream.drain)
381
+ dependenciesToStream: ({ keys }) => Stream.fromEffect(settled(keys).pipe(Effect.andThen(sync(keys)), Effect.delay(throttle))).pipe(Stream.drain)
320
382
  };
321
383
  return {
322
384
  mirror: {
@@ -328,6 +390,7 @@ const make = (app, kind, store, config, throttle) => {
328
390
  decode,
329
391
  fromKeys,
330
392
  restoreKeys,
393
+ bootstrap: (keys) => (model) => restoreKeys(model, keys),
331
394
  href,
332
395
  restore,
333
396
  subscriptions: { [`${name}.mirror`]: entry }
@@ -339,9 +402,71 @@ const brandEntries = (entries) => Subscription.make()(() => entries);
339
402
  const Mirror = {
340
403
  /** Mirror's Message cases, to spread into the application's union. */
341
404
  messages: mirrorMessageCases,
405
+ /**
406
+ * Mirror's Messages as one Schema, for a wrapper variant in the
407
+ * application's union: `GotPrefsMessage: { message: Mirror.Message }`. With
408
+ * a wrapper, `update` matches the application's union exhaustively and
409
+ * `Mirror.fold` reduces what arrives inside it.
410
+ */
411
+ Message: defineMessageUnion(mirrorMessageCases),
412
+ /**
413
+ * A key-value mirror under one wrapper variant of the application's union,
414
+ * the same shape Foldkit gives a Submodel: `toParentMessage` wraps the
415
+ * mirror's `MirrorRestored`, the fold reduces it, and `fold.init` runs the
416
+ * lifted `restore` at startup. One wrapper per mirror: two mirrors that
417
+ * share a variant would each have to reduce the other's answer.
418
+ *
419
+ * @example
420
+ * ```ts
421
+ * const Message = defineMessageUnion({ GotPrefsMessage: { message: Mirror.Message } })
422
+ * const foldPrefs = Mirror.fold(Prefs, message => Message.GotPrefsMessage({ message }))
423
+ *
424
+ * const init = (): Return => foldPrefs.init(initial)
425
+ * const update = (model: Model, message: Message): Return =>
426
+ * Message.match(message, {
427
+ * GotPrefsMessage: ({ message }) => foldPrefs(model, message),
428
+ * })
429
+ * ```
430
+ */
431
+ fold: (mirror, toParentMessage) => {
432
+ const restore = mapMessage(mirror.restore, toParentMessage);
433
+ const fold = (model, message) => ({ model: mirror.reduce(model, message) });
434
+ return Object.assign(fold, {
435
+ restore,
436
+ init: (model) => ({
437
+ model,
438
+ commands: [restore]
439
+ })
440
+ });
441
+ },
342
442
  /** Narrows the application's union to Mirror's cases, by tag. */
343
443
  reduces: (message) => Object.hasOwn(mirrorMessageCases, message._tag),
344
444
  /**
445
+ * Folds pre-init steps into the initial Model, in list order: stores first,
446
+ * the URL last. Either order keeps URL > store > initial (a store bootstrap
447
+ * only fills fields still at their initial value, while a URL `reduce` sets
448
+ * its whole slice), but listing the URL last states the precedence. Among
449
+ * store bootstraps sharing a field, the first one wins.
450
+ *
451
+ * Use this when the keys are already in hand at boot: Flags the server
452
+ * embedded, a synchronous read, a test fixture. When the store can only be
453
+ * read asynchronously, use the `restore` Command (`wiring.init`,
454
+ * `fold.init`) instead: bootstrapping what the store holds needs the keys,
455
+ * and `restore` is how they arrive.
456
+ *
457
+ * @example
458
+ * ```ts
459
+ * const init = (flags: { prefs: Encoded }, url: Url): Return => ({
460
+ * model: Mirror.bootstrap(
461
+ * initial,
462
+ * Prefs.bootstrap(flags.prefs),
463
+ * model => Filters.reduce(model, url),
464
+ * ),
465
+ * })
466
+ * ```
467
+ */
468
+ bootstrap: (model, ...steps) => steps.reduce((next, step) => step(next), model),
469
+ /**
345
470
  * A slice kept in the URL: `Projection.pick(App.model.filter, App.model.q)`
346
471
  * as `?filter=…&q=…`, defaults elided, written when it changes (one history
347
472
  * write per Model change) and read back with `reduce(model, url)` on
@@ -349,7 +474,7 @@ const Mirror = {
349
474
  */
350
475
  url: (app, config) => {
351
476
  const owned = Object.keys(projectionOf(config.fields).schema.fields).map((field) => config.keys?.[field]?.key ?? field);
352
- const { mirror, keysOfUrl } = make(app, "url", MirrorStore.url(owned, config.location ?? "search"), config, config.throttle ?? "50 millis");
477
+ const { mirror, keysOfUrl } = make(app, "url", MirrorStore.url(owned, config.location ?? "search"), config, config.throttle ?? "50 millis", Option.none());
353
478
  const reduce = (model, url) => mirror.fromKeys(model, keysOfUrl(url));
354
479
  return {
355
480
  ...mirror,
@@ -367,6 +492,45 @@ const Mirror = {
367
492
  };
368
493
  },
369
494
  /**
495
+ * URL mirrors plugged into `Runtime.makeApplication`: spread the result into
496
+ * its config. `init` reads the starting URL into the Model the application's
497
+ * `init` returns; `update` reads a `urlChanged` Message's URL into the Model
498
+ * before the application's `update` sees it, so a route handler finds the
499
+ * slices already read. `routing` is the application's own, passed through.
500
+ *
501
+ * @example
502
+ * ```ts
503
+ * Runtime.makeApplication({
504
+ * Model, view, subscriptions, container,
505
+ * ...Mirror.routing({
506
+ * mirrors: [Filters],
507
+ * urlChanged: 'ChangedUrl',
508
+ * init,
509
+ * update,
510
+ * routing: {
511
+ * onUrlRequest: request => Message.ClickedLink({ request }),
512
+ * onUrlChange: url => Message.ChangedUrl({ url }),
513
+ * },
514
+ * }),
515
+ * })
516
+ * ```
517
+ */
518
+ routing: (config) => {
519
+ const read = (model, url) => config.mirrors.reduce((next, mirror) => mirror.reduce(next, url), model);
520
+ const isUrlChanged = (message) => message._tag === config.urlChanged;
521
+ return {
522
+ init: (...args) => {
523
+ const started = config.init(...args);
524
+ return {
525
+ ...started,
526
+ model: read(started.model, args[args.length - 1])
527
+ };
528
+ },
529
+ update: (model, message) => config.update(isUrlChanged(message) ? read(model, message.url) : model, message),
530
+ routing: config.routing
531
+ };
532
+ },
533
+ /**
370
534
  * A slice kept in Effect's `KeyValueStore` under `key`, as one scoped,
371
535
  * versioned JSON document: written when it changes, read back by the
372
536
  * `restore` Command whose `MirrorRestored` `reduce` applies.
@@ -378,7 +542,7 @@ const Mirror = {
378
542
  }), {
379
543
  ...config,
380
544
  name: config.name ?? config.key
381
- }, config.throttle ?? "250 millis");
545
+ }, config.throttle ?? "250 millis", Option.some(Effect.service(KeyValueStore.KeyValueStore)));
382
546
  const reduce = (model, message) => message.name === mirror.name ? mirror.restoreKeys(model, message.keys) : model;
383
547
  return {
384
548
  ...mirror,
@@ -398,8 +562,8 @@ const Mirror = {
398
562
  })
399
563
  };
400
564
  },
401
- /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`. */
402
- make: (app, store, config) => make(app, "memory", store, config, config.throttle ?? 0).mirror
565
+ /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`, bootstrapped with `bootstrap`. */
566
+ make: (app, store, config) => make(app, "memory", store, config, config.throttle ?? 0, Option.some(Effect.succeed(store))).mirror
403
567
  };
404
568
  //#endregion
405
569
  export { Mirror, MirrorStore, applyToHref, mirrorMessageCases };
@@ -1 +1 @@
1
- {"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-mirror` — a Model slice kept in the URL or a key-value store.\n *\n * The Model is the only truth. A mirror names a slice of it (a writable\n * projection over field refs) and keeps an external keyed string store in\n * step with it: the slice is written to the store whenever it changes, and\n * read back into the Model on navigation or cold load. The URL query string\n * and Effect's `KeyValueStore` are the two stores; a mirror is not an owner,\n * and it is last-write-wins with no log, which is what separates it from\n * `foldkit-sync`. See `docs/design/MIRROR.md`.\n */\nimport { Duration, Effect, Option, Result, Schema, Stream } from 'effect'\nimport { KeyValueStore } from 'effect/unstable/persistence'\nimport type { Command } from 'foldkit/command'\nimport * as Navigation from 'foldkit/navigation'\nimport * as Subscription from 'foldkit/subscription'\nimport type { EntryWithoutKeepAlive } from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport type { Url } from 'foldkit/url'\nimport {\n Projection,\n type Contract,\n type FieldRef,\n type Wiring,\n type WritableProjection,\n} from 'foldkit-surface'\n\n// ---------------------------------------------------------------------------\n// Stores\n// ---------------------------------------------------------------------------\n\n/** The keys a mirror holds in a store, as the store holds them: strings. */\nexport type Encoded = Readonly<Record<string, string>>\n\n/** The read entry's dependencies: the encoded slice, as a Struct so Foldkit can compare it. */\nexport interface MirrorDependencies {\n readonly keys: Encoded\n}\n\n/** One write to a store: the keys to set, the keys to drop, and how the URL should record it. */\nexport interface MirrorWrite {\n readonly set: Encoded\n readonly remove: ReadonlyArray<string>\n /** `push` adds a history entry; `replace` does not. A store without history ignores it. */\n readonly intent: 'push' | 'replace'\n}\n\n/**\n * A keyed string store a mirror writes to and reads from. Errors are the\n * store's to absorb: a mirror is disposable state, and a failed write must\n * not fail the application.\n */\nexport interface MirrorStore<R = never> {\n readonly read: Effect.Effect<Encoded | undefined, never, R>\n readonly write: (write: MirrorWrite) => Effect.Effect<void, never, R>\n}\n\n/** `MirrorStore.url`: where in the URL the keys live. */\nexport type UrlLocation = 'search' | 'hash'\n\n/** Splits a same-origin href into its three parts; `search` and `hash` keep their leading `?`/`#`. */\nconst splitHref = (href: string): { pathname: string; search: string; hash: string } => {\n const hashAt = href.indexOf('#')\n const hash = hashAt < 0 ? '' : href.slice(hashAt)\n const rest = hashAt < 0 ? href : href.slice(0, hashAt)\n const searchAt = rest.indexOf('?')\n return {\n pathname: searchAt < 0 ? rest : rest.slice(0, searchAt),\n search: searchAt < 0 ? '' : rest.slice(searchAt),\n hash,\n }\n}\n\n/** The keys a query string holds among `owned`, in URL order. */\nconst readParams = (query: string, owned: ReadonlyArray<string>): Encoded => {\n const params = new URLSearchParams(\n query.startsWith('?') || query.startsWith('#') ? query.slice(1) : query,\n )\n const out: Record<string, string> = {}\n for (const key of owned) {\n const value = params.get(key)\n if (value !== null) out[key] = value\n }\n return out\n}\n\n/** `href` with the mirror's keys set and dropped in its location; every other key, the path, and the other part stay. */\nexport const applyToHref = (\n href: string,\n write: Pick<MirrorWrite, 'set' | 'remove'>,\n location: UrlLocation = 'search',\n): string => {\n const parts = splitHref(href)\n const current = location === 'search' ? parts.search : parts.hash\n const params = new URLSearchParams(current.slice(1))\n for (const key of write.remove) params.delete(key)\n for (const [key, value] of Object.entries(write.set)) params.set(key, value)\n const query = params.toString()\n const next = query === '' ? '' : `${location === 'search' ? '?' : '#'}${query}`\n return location === 'search'\n ? `${parts.pathname}${next}${parts.hash}`\n : `${parts.pathname}${parts.search}${next}`\n}\n\nconst currentHref = (): string | undefined => {\n const loc = (globalThis as { location?: Location }).location\n return loc === undefined ? undefined : `${loc.pathname}${loc.search}${loc.hash}`\n}\n\nconst urlStore = (owned: ReadonlyArray<string>, location: UrlLocation): MirrorStore => ({\n read: Effect.sync(() => {\n const href = currentHref()\n if (href === undefined) return undefined\n const parts = splitHref(href)\n return readParams(location === 'search' ? parts.search : parts.hash, owned)\n }),\n write: write =>\n Effect.suspend(() => {\n // Outside a browser (SSR, a test without a DOM) there is no URL to write.\n const href = currentHref()\n if (href === undefined) return Effect.void\n const next = applyToHref(href, write, location)\n if (next === href) return Effect.void\n return write.intent === 'push' ? Navigation.pushUrl(next) : Navigation.replaceUrl(next)\n }),\n})\n\nconst KV_VERSION = 1\n\nconst KvDocument = Schema.Struct({\n version: Schema.Number,\n scope: Schema.optional(Schema.String),\n keys: Schema.Record(Schema.String, Schema.String),\n})\n\nconst kvStore = (options: {\n readonly key: string\n readonly scope?: string | undefined\n}): MirrorStore<KeyValueStore.KeyValueStore> => {\n const decode = Schema.decodeUnknownResult(Schema.fromJsonString(KvDocument))\n const encode = Schema.encodeSync(Schema.fromJsonString(KvDocument))\n return {\n read: Effect.gen(function* () {\n const kv = yield* KeyValueStore.KeyValueStore\n const raw = yield* Effect.result(kv.get(options.key))\n if (Result.isFailure(raw)) {\n yield* Effect.logWarning(`Mirror: could not read \"${options.key}\"`, raw.failure)\n return undefined\n }\n if (raw.success === undefined) return undefined\n const document = decode(raw.success)\n // Another version, another scope, or malformed: disposable, so drop it and start clean.\n if (\n Result.isFailure(document) ||\n document.success.version !== KV_VERSION ||\n document.success.scope !== options.scope\n ) {\n yield* Effect.result(kv.remove(options.key))\n return undefined\n }\n return document.success.keys\n }),\n write: write =>\n Effect.gen(function* () {\n const kv = yield* KeyValueStore.KeyValueStore\n const text = encode({\n version: KV_VERSION,\n ...(options.scope === undefined ? {} : { scope: options.scope }),\n keys: write.set,\n })\n const outcome = yield* Effect.result(\n Object.keys(write.set).length === 0 ? kv.remove(options.key) : kv.set(options.key, text),\n )\n if (Result.isFailure(outcome)) {\n yield* Effect.logWarning(`Mirror: could not write \"${options.key}\"`, outcome.failure)\n }\n }),\n }\n}\n\n/** An in-memory store that records its writes, for tests and for a mirror with no host. */\nexport interface MemoryStore extends MirrorStore {\n /** What the store holds now. */\n readonly current: () => Encoded | undefined\n /** Every write, in order. */\n readonly writes: ReadonlyArray<MirrorWrite>\n}\n\nconst memoryStore = (initial?: Encoded): MemoryStore => {\n let held: Encoded | undefined = initial\n const writes: MirrorWrite[] = []\n return {\n read: Effect.sync(() => held),\n write: write =>\n Effect.sync(() => {\n writes.push(write)\n const next: Record<string, string> = { ...(held ?? {}) }\n for (const key of write.remove) delete next[key]\n Object.assign(next, write.set)\n held = next\n }),\n current: () => held,\n writes,\n }\n}\n\nexport const MirrorStore = {\n /** The URL's query string (or hash), through `foldkit/navigation`. `owned` are the keys the mirror may touch. */\n url: urlStore,\n /** One JSON document under `key` in Effect's `KeyValueStore`, scoped and versioned. */\n kv: kvStore,\n memory: memoryStore,\n}\n\n// ---------------------------------------------------------------------------\n// Messages\n// ---------------------------------------------------------------------------\n\n/** Mirror's Message cases, for `defineMessageUnion({ ...Mirror.messages, … })`. */\nexport const mirrorMessageCases = {\n /** A store was read (`mirror.restore`); `keys` are what it held for the mirror named. */\n MirrorRestored: { name: Schema.String, keys: Schema.Record(Schema.String, Schema.String) },\n} satisfies Record<string, Schema.Struct.Fields>\n\nexport interface MirrorRestored {\n readonly _tag: 'MirrorRestored'\n readonly name: string\n readonly keys: Encoded\n}\n\nexport type MirrorMessage = MirrorRestored\n\n// ---------------------------------------------------------------------------\n// Key codecs\n// ---------------------------------------------------------------------------\n\n/** A key's text form and back; the decode names what is wrong when it fails. */\ninterface KeyCodec {\n readonly decode: (text: string) => Result.Result<unknown, string>\n readonly encode: (value: unknown) => string\n}\n\nconst failure = (message: string): Result.Result<never, string> => Result.fail(message)\n\n/**\n * A key's codec, from an override or derived from the field: the field's\n * encoded form of the initial value says whether the key is text, a number,\n * a boolean, or JSON, and the field schema validates whatever was parsed.\n */\nconst codecFor = (\n field: Schema.Codec<unknown, unknown, never, never>,\n initial: unknown,\n override: Schema.Codec<unknown, string, never, never> | undefined,\n): KeyCodec => {\n if (override !== undefined) {\n const decode = Schema.decodeUnknownResult(override)\n const encode = Schema.encodeSync(override)\n return {\n decode: text => Result.mapError(decode(text), error => error.message),\n encode: value => encode(value),\n }\n }\n const encodeField = Schema.encodeSync(field)\n const decodeField = Schema.decodeUnknownResult(field)\n const shape = typeof encodeField(initial)\n const validate = (candidate: unknown) =>\n Result.mapError(decodeField(candidate), error => error.message)\n return {\n decode: text => {\n switch (shape) {\n case 'string':\n return validate(text)\n case 'number': {\n const value = text.trim() === '' ? Number.NaN : Number(text)\n return Number.isNaN(value) ? failure(`\"${text}\" is not a number`) : validate(value)\n }\n case 'boolean':\n return text === 'true' || text === 'false'\n ? validate(text === 'true')\n : failure(`\"${text}\" is not \"true\" or \"false\"`)\n default: {\n try {\n return validate(JSON.parse(text))\n } catch {\n return failure(`\"${text}\" is not JSON`)\n }\n }\n }\n },\n encode: value => {\n const encoded = encodeField(value)\n return shape === 'string' || shape === 'number' || shape === 'boolean'\n ? String(encoded)\n : JSON.stringify(encoded)\n },\n }\n}\n\n// ---------------------------------------------------------------------------\n// Mirrors\n// ---------------------------------------------------------------------------\n\n/** The value type of a field schema. */\ntype TypeOf<S> = S extends { readonly Type: infer T } ? T : never\n\n/**\n * The slice a mirror keeps: field refs straight from `App.model`, or a\n * writable projection over them (`Projection.pick`, `Projection.compose`),\n * the same object `foldkit-sync` replicates.\n */\nexport type Slice = WritableProjection<any, any> | readonly FieldRef<any, any, string>[]\n\n/** The Struct fields of a slice. */\nexport type SliceFields<S extends Slice> =\n S extends WritableProjection<any, infer Fields>\n ? Fields\n : S extends readonly FieldRef<any, any, string>[]\n ? { readonly [R in S[number] as R['key']]: R['Schema'] }\n : never\n\n/** The Model a slice is of. */\nexport type SliceRoot<S extends Slice> =\n S extends WritableProjection<infer Root, any>\n ? Root\n : S extends readonly FieldRef<infer Root, any, string>[]\n ? Root\n : never\n\n/** The value a slice reads. */\nexport type SliceValue<S extends Slice> = Schema.Struct.Type<SliceFields<S>>\n\nconst projectionOf = <S extends Slice>(\n slice: S,\n): WritableProjection<SliceRoot<S>, SliceFields<S>> =>\n (Array.isArray(slice)\n ? Projection.pick(...(slice as readonly FieldRef<any, any, string>[]))\n : slice) as WritableProjection<SliceRoot<S>, SliceFields<S>>\n\n/** How one field is kept: its store key, its history intent, whether its default is written, and its text codec. */\nexport interface KeyOptions<Value> {\n /** The store key; default the field name. */\n readonly key?: string | undefined\n /** Whether a change of this key adds a history entry; default `push`. Only the URL has history. */\n readonly history?: 'push' | 'replace' | undefined\n /** Write the key even when the value is the initial one; default false, so a default is elided. */\n readonly keep?: boolean | undefined\n /** The text codec; default derived from the field schema. */\n readonly codec?: Schema.Codec<Value, string, never, never> | undefined\n}\n\nexport interface MirrorConfig<S extends Slice, Name extends string = string> {\n /** Names the mirror in its contract and its Messages; default from the kind and keys. */\n readonly name?: Name | undefined\n /** The slice: field refs (`[App.model.filter, App.model.q]`) or a writable projection over them. */\n readonly fields: S\n readonly keys?:\n { readonly [K in keyof SliceFields<S>]?: KeyOptions<TypeOf<SliceFields<S>[K]>> } | undefined\n /** The Model's initial value, when the application was built without one; defaults are read from it. */\n readonly initial?: SliceRoot<S> | undefined\n /**\n * How long a changed slice waits before it is written; a newer change\n * supersedes a pending write. Browsers rate-limit history writes, so the\n * URL waits 50 ms by default; a store waits 250 ms.\n */\n readonly throttle?: Duration.Input | undefined\n}\n\nexport interface UrlMirrorConfig<\n S extends Slice,\n Name extends string = string,\n> extends MirrorConfig<S, Name> {\n /** Where in the URL the keys live; default the query string. */\n readonly location?: UrlLocation | undefined\n}\n\nexport interface KvMirrorConfig<S extends Slice, Name extends string = string> extends MirrorConfig<\n S,\n Name\n> {\n /** The store key the mirror's document lives under; also the mirror's name unless one is given. */\n readonly key: Name\n /** A user, a tenant: a document of another scope is discarded rather than restored. */\n readonly scope?: string | undefined\n}\n\n/** One key that failed to decode; the field keeps its initial value. */\nexport interface DecodeIssue {\n readonly key: string\n readonly message: string\n}\n\nexport interface Decoded<Value> {\n /** The fields the store named and decoded. */\n readonly value: Partial<Value>\n readonly issues: ReadonlyArray<DecodeIssue>\n}\n\n/**\n * A Model slice kept in a store. `Value` is the slice's value type; the keys,\n * codecs, and intents are values on the mirror, not type parameters.\n * `Mirror.url` and `Mirror.kv` add the `reduce` their store calls for.\n */\nexport interface Mirror<\n AppModel,\n Value extends Record<string, unknown>,\n R = never,\n Name extends string = string,\n> {\n readonly kind: 'url' | 'kv' | 'memory'\n readonly name: Name\n /** Store key per field. */\n readonly keys: Readonly<Record<keyof Value & string, string>>\n /** For `Module`: observes the slice, owns nothing. */\n readonly contract: Contract\n /** The store's keys for a Model, defaults elided unless a key is `keep`. */\n readonly encode: (model: AppModel) => Encoded\n /** The fields a store's keys name; a key that fails to decode is an issue, not a value. */\n readonly decode: (keys: Encoded) => Decoded<Value>\n /**\n * The Model with a store's keys as the whole slice: a key the store lacks,\n * or one that fails to decode, is the initial value.\n */\n readonly fromKeys: (model: AppModel, keys: Encoded) => AppModel\n /**\n * The Model with a store's keys applied to the fields it still holds at\n * their initial value, so a change made before the store answered is kept.\n */\n readonly restoreKeys: (model: AppModel, keys: Encoded) => AppModel\n /** A link: the keys of `model` with `patch` applied, on `base` (default the current URL, else `/`). */\n readonly href: (model: AppModel, patch?: Partial<Value>, base?: string) => string\n /** A Command that reads the store and yields `MirrorRestored` for this mirror. */\n readonly restore: Command<MirrorMessage, never, R>\n /** One Subscription entry, `<name>.mirror`: writes the store when the encoded slice changes. */\n readonly subscriptions: {\n readonly [K in `${Name}.mirror`]: EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R>\n }\n}\n\n/** A slice kept in the URL. */\nexport interface UrlMirror<\n AppModel,\n Value extends Record<string, unknown>,\n Name extends string = string,\n> extends Mirror<AppModel, Value, never, Name> {\n readonly kind: 'url'\n /** The Model with the URL's keys (a Foldkit `Url` or an href) as the whole slice: `fromKeys`. */\n readonly reduce: (model: AppModel, url: Url | string) => AppModel\n /**\n * How this mirror joins an assembly: it routes the application's URL Message\n * (a variant with a `url` field, tagged `tag`) into `reduce`, reads the URL at\n * startup, and brings its Subscriptions and contract. Several URL mirrors share\n * the URL Message.\n */\n readonly wiring: <const Tag extends string>(tag: Tag) => UrlMirrorWiring<AppModel, Tag>\n}\n\n/** The Message a URL mirror routes: the application's URL variant. */\nexport type UrlChangedMessage<Tag extends string> = {\n readonly _tag: Tag\n readonly url: Url\n}\n\nexport type UrlMirrorWiring<AppModel, Tag extends string> = Wiring<\n AppModel,\n UrlChangedMessage<Tag>\n> & {\n readonly onUrl: (model: AppModel, url: Url) => AppModel\n}\n\nexport type KvMirrorWiring<AppModel> = Wiring<\n AppModel,\n MirrorRestored,\n KeyValueStore.KeyValueStore\n> & {\n readonly init: Update.Step<AppModel, MirrorRestored, KeyValueStore.KeyValueStore>\n}\n\n/** A slice kept in Effect's `KeyValueStore`. */\nexport interface KvMirror<\n AppModel,\n Value extends Record<string, unknown>,\n Name extends string = string,\n> extends Mirror<AppModel, Value, KeyValueStore.KeyValueStore, Name> {\n readonly kind: 'kv'\n /** The Model with a `MirrorRestored` for this mirror applied: `restoreKeys`; another mirror's is ignored. */\n readonly reduce: (model: AppModel, message: MirrorRestored) => AppModel\n /**\n * How this mirror joins an assembly: it routes its own `MirrorRestored` into\n * `reduce`, runs `restore` at startup, and brings its Subscriptions and\n * contract. Other key-value mirrors share the `MirrorRestored` tag.\n */\n readonly wiring: () => KvMirrorWiring<AppModel>\n}\n\nconst nameOf = (\n kind: Mirror<unknown, Record<string, unknown>>['kind'],\n keys: ReadonlyArray<string>,\n given: string | undefined,\n): string => given ?? `${kind}(${keys.join(',')})`\n\n// A URL key belongs to one mirror per application; the same mirror may be\n// declared again (a module re-evaluated, a test), another may not take it.\nconst claimed = new WeakMap<object, Map<string, string>>()\n\nconst claim = (\n owner: object,\n location: UrlLocation,\n keys: ReadonlyArray<string>,\n name: string,\n): void => {\n let byKey = claimed.get(owner)\n if (byKey === undefined) {\n byKey = new Map()\n claimed.set(owner, byKey)\n }\n for (const key of keys) {\n const at = `${location}:${key}`\n const holder = byKey.get(at)\n if (holder !== undefined && holder !== name) {\n throw new Error(\n `Mirror.url: key \"${key}\" in the ${location} is already mirrored by \"${holder}\"; \"${name}\" cannot mirror it too`,\n )\n }\n byKey.set(at, name)\n }\n}\n\n/** An application a mirror is declared over: its identity token, and its initial Model when it has one. */\nexport interface MirrorApp<AppModel> {\n readonly owner: object\n readonly initial?: AppModel | undefined\n}\n\n/** A Foldkit `Url` carries `search` and `hash` without their `?` and `#`; an href has them. */\nconst withPrefix = (prefix: '?' | '#', part: string): string =>\n part === '' || part.startsWith(prefix) ? part : `${prefix}${part}`\n\nconst hrefOf = (url: Url | string): string =>\n typeof url === 'string'\n ? url\n : `${url.pathname}${withPrefix('?', url.search._tag === 'Some' ? url.search.value : '')}${withPrefix(\n '#',\n url.hash._tag === 'Some' ? url.hash.value : '',\n )}`\n\nconst make = <S extends Slice, R, Name extends string>(\n app: MirrorApp<SliceRoot<S>>,\n kind: Mirror<unknown, Record<string, unknown>>['kind'],\n store: MirrorStore<R>,\n config: MirrorConfig<S, Name> & { readonly location?: UrlLocation | undefined },\n throttle: Duration.Input,\n) => {\n type AppModel = SliceRoot<S>\n type Value = SliceValue<S>\n const fields = projectionOf(config.fields)\n const names = Object.keys(fields.schema.fields)\n const options = (config.keys ?? {}) as Readonly<Record<string, KeyOptions<unknown> | undefined>>\n const initial = config.initial ?? app.initial\n if (initial === undefined) {\n throw new Error(\n `Mirror.${kind}: defaults are read from the initial Model, so build the application with \\`initial\\` or pass \\`initial\\` in the config`,\n )\n }\n const initialSlice = fields.get(initial) as Readonly<Record<string, unknown>>\n const location = config.location ?? 'search'\n\n const keyOf: Record<string, string> = {}\n const fieldOf: Record<string, string> = {}\n const codecs: Record<string, KeyCodec> = {}\n const history: Record<string, 'push' | 'replace'> = {}\n const keep = new Set<string>()\n const initialText: Record<string, string> = {}\n for (const field of names) {\n const option = options[field]\n const key = option?.key ?? field\n if (fieldOf[key] !== undefined) {\n throw new Error(\n `Mirror: fields \"${fieldOf[key]}\" and \"${field}\" both use the key \"${key}\"; give one another key`,\n )\n }\n keyOf[field] = key\n fieldOf[key] = field\n codecs[field] = codecFor(\n fields.schema.fields[field] as Schema.Codec<unknown, unknown, never, never>,\n initialSlice[field],\n option?.codec as Schema.Codec<unknown, string, never, never> | undefined,\n )\n history[field] = option?.history ?? 'push'\n if (option?.keep === true) keep.add(field)\n initialText[field] = codecs[field].encode(initialSlice[field])\n }\n const owned = names.map(field => keyOf[field]!)\n const name = nameOf(kind, owned, config.name) as Name\n if (kind === 'url') claim(app.owner, location, owned, name)\n\n const encodeSlice = (slice: Readonly<Record<string, unknown>>): Encoded => {\n const out: Record<string, string> = {}\n for (const field of names) {\n const text = codecs[field]!.encode(slice[field])\n if (!keep.has(field) && text === initialText[field]) continue\n out[keyOf[field]!] = text\n }\n return out\n }\n const encode = (model: AppModel): Encoded =>\n encodeSlice(fields.get(model) as Readonly<Record<string, unknown>>)\n\n const decode = (keys: Encoded): Decoded<Value> => {\n const value: Record<string, unknown> = {}\n const issues: DecodeIssue[] = []\n for (const field of names) {\n const key = keyOf[field]!\n const text = keys[key]\n if (text === undefined) continue\n const decoded = codecs[field]!.decode(text)\n if (Result.isFailure(decoded)) issues.push({ key, message: decoded.failure })\n else value[field] = decoded.success\n }\n return { value: value as Partial<Value>, issues }\n }\n\n const keysOfUrl = (source: Url | string): Encoded => {\n const parts = splitHref(hrefOf(source))\n return readParams(location === 'search' ? parts.search : parts.hash, owned)\n }\n\n const fromKeys = (model: AppModel, keys: Encoded): AppModel => {\n const decoded = decode(keys).value as Readonly<Record<string, unknown>>\n return fields.set(model, { ...initialSlice, ...decoded } as never)\n }\n\n const restoreKeys = (model: AppModel, keys: Encoded): AppModel => {\n const current = fields.get(model) as Readonly<Record<string, unknown>>\n const restored = decode(keys).value as Readonly<Record<string, unknown>>\n const next: Record<string, unknown> = { ...current }\n for (const field of names) {\n // A change the user made before the store answered wins over the store.\n if (codecs[field]!.encode(current[field]) !== initialText[field]) continue\n if (field in restored) next[field] = restored[field]\n }\n return fields.set(model, next as never)\n }\n\n const href = (model: AppModel, patch?: Partial<Value>, base?: string): string => {\n const slice = { ...(fields.get(model) as Readonly<Record<string, unknown>>), ...patch }\n const set = encodeSlice(slice)\n const remove = owned.filter(key => !(key in set))\n return applyToHref(base ?? currentHref() ?? '/', { set, remove }, location)\n }\n\n const contract: Contract = {\n kind: 'mirror',\n name,\n owner: app.owner,\n owns: [],\n observes: fields.dependencies,\n messages: kind === 'kv' ? ['MirrorRestored'] : [],\n metadata: [],\n }\n\n const restore: Command<MirrorMessage, never, R> = {\n name: `Mirror.restore(${name})`,\n effect: store.read.pipe(\n Effect.map((keys): MirrorMessage => ({ _tag: 'MirrorRestored', name, keys: keys ?? {} })),\n ),\n }\n\n // Writes only what changed, and pushes only for a changed key that pushes:\n // a removal (a key back at its default) never adds a history entry.\n const sync = (encoded: Encoded): Effect.Effect<void, never, R> =>\n Effect.gen(function* () {\n const current = (yield* store.read) ?? {}\n const remove = owned.filter(key => !(key in encoded) && key in current)\n const changed = owned.filter(key => key in encoded && current[key] !== encoded[key])\n if (remove.length === 0 && changed.length === 0) return\n const intent = changed.some(key => history[fieldOf[key]!] === 'push') ? 'push' : 'replace'\n yield* store.write({ set: encoded, remove, intent })\n })\n\n const entry: EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R> = {\n dependenciesSchema: Schema.Struct({ keys: Schema.Record(Schema.String, Schema.String) }),\n modelToDependencies: model => ({ keys: encode(model) }),\n dependenciesToStream: ({ keys }) =>\n Stream.fromEffect(sync(keys).pipe(Effect.delay(throttle))).pipe(Stream.drain),\n }\n\n const mirror: Mirror<AppModel, Value, R, Name> = {\n kind,\n name,\n keys: keyOf as Readonly<Record<keyof Value & string, string>>,\n contract,\n encode,\n decode,\n fromKeys,\n restoreKeys,\n href,\n restore,\n subscriptions: { [`${name}.mirror`]: entry } as Mirror<\n AppModel,\n Value,\n R,\n Name\n >['subscriptions'],\n }\n return { mirror, keysOfUrl }\n}\n\n// A mirror's Subscription entries are unbranded so an application can spread them\n// into its own `Subscription.make`; wiring hands them over as a branded record.\nconst brandEntries = <AppModel, R>(\n entries: Readonly<Record<string, EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R>>>,\n): Subscription.Subscriptions<AppModel, never, R> =>\n Subscription.make<AppModel, never, R>()(() => entries)\n\nexport const Mirror = {\n /** Mirror's Message cases, to spread into the application's union. */\n messages: mirrorMessageCases,\n\n /** Narrows the application's union to Mirror's cases, by tag. */\n reduces: <M extends { readonly _tag: string }>(\n message: M,\n ): message is Extract<M, { readonly _tag: 'MirrorRestored' }> =>\n Object.hasOwn(mirrorMessageCases, message._tag),\n\n /**\n * A slice kept in the URL: `Projection.pick(App.model.filter, App.model.q)`\n * as `?filter=…&q=…`, defaults elided, written when it changes (one history\n * write per Model change) and read back with `reduce(model, url)` on\n * `onUrlChange` and on cold load.\n */\n url: <S extends Slice, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n config: UrlMirrorConfig<S, Name>,\n ): UrlMirror<SliceRoot<S>, SliceValue<S>, Name> => {\n const owned = Object.keys(projectionOf(config.fields).schema.fields).map(\n field =>\n (config.keys as Readonly<Record<string, KeyOptions<unknown> | undefined>> | undefined)?.[\n field\n ]?.key ?? field,\n )\n const { mirror, keysOfUrl } = make(\n app,\n 'url',\n MirrorStore.url(owned, config.location ?? 'search'),\n config,\n config.throttle ?? '50 millis',\n )\n const reduce = (model: SliceRoot<S>, url: Url | string) =>\n mirror.fromKeys(model, keysOfUrl(url))\n return {\n ...mirror,\n kind: 'url',\n reduce,\n wiring: tag => ({\n key: `mirror:${mirror.name}`,\n handles: [tag],\n shared: [tag],\n route: (model, message) =>\n message._tag === tag ? Option.some({ model: reduce(model, message.url) }) : Option.none(),\n onUrl: reduce,\n subscriptions: brandEntries(mirror.subscriptions),\n contract: mirror.contract,\n }),\n }\n },\n\n /**\n * A slice kept in Effect's `KeyValueStore` under `key`, as one scoped,\n * versioned JSON document: written when it changes, read back by the\n * `restore` Command whose `MirrorRestored` `reduce` applies.\n */\n kv: <S extends Slice, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n config: KvMirrorConfig<S, Name>,\n ): KvMirror<SliceRoot<S>, SliceValue<S>, Name> => {\n const { mirror } = make(\n app,\n 'kv',\n MirrorStore.kv({\n key: config.key,\n ...(config.scope === undefined ? {} : { scope: config.scope }),\n }),\n { ...config, name: config.name ?? config.key },\n config.throttle ?? '250 millis',\n )\n const reduce = (model: SliceRoot<S>, message: MirrorRestored) =>\n message.name === mirror.name ? mirror.restoreKeys(model, message.keys) : model\n return {\n ...mirror,\n kind: 'kv',\n reduce,\n wiring: () => ({\n key: `mirror:${mirror.name}`,\n handles: ['MirrorRestored'],\n shared: ['MirrorRestored'],\n // Another mirror's restore is not this one's: `None` lets the next mirror take it.\n route: (model, message) =>\n message._tag === 'MirrorRestored' && message.name === mirror.name\n ? Option.some({ model: reduce(model, message) })\n : Option.none(),\n init: model => ({ model, commands: [mirror.restore] }),\n subscriptions: brandEntries(mirror.subscriptions),\n contract: mirror.contract,\n }),\n }\n },\n\n /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`. */\n make: <S extends Slice, R, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n store: MirrorStore<R>,\n config: MirrorConfig<S, Name>,\n ): Mirror<SliceRoot<S>, SliceValue<S>, R, Name> =>\n make(app, 'memory', store, config, config.throttle ?? 0).mirror,\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-mirror` — a Model slice kept in the URL or a key-value store.\n *\n * The Model is the only truth. A mirror names a slice of it (a writable\n * projection over field refs) and keeps an external keyed string store in\n * step with it: the slice is written to the store whenever it changes, and\n * read back into the Model on navigation or cold load. The URL query string\n * and Effect's `KeyValueStore` are the two stores; a mirror is not an owner,\n * and it is last-write-wins with no log, which is what separates it from\n * `foldkit-sync`. See `docs/design/MIRROR.md`.\n */\nimport { Duration, Effect, Option, Result, Schema, Stream } from 'effect'\nimport { KeyValueStore } from 'effect/unstable/persistence'\nimport { mapMessage, type Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as Navigation from 'foldkit/navigation'\nimport type { RoutingConfig } from 'foldkit/runtime'\nimport * as Subscription from 'foldkit/subscription'\nimport type { EntryWithoutKeepAlive } from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport type { Url } from 'foldkit/url'\nimport {\n Projection,\n type Contract,\n type FieldRef,\n type Wiring,\n type WritableProjection,\n} from 'foldkit-surface'\n\n// ---------------------------------------------------------------------------\n// Stores\n// ---------------------------------------------------------------------------\n\n/** The keys a mirror holds in a store, as the store holds them: strings. */\nexport type Encoded = Readonly<Record<string, string>>\n\n/** The read entry's dependencies: the encoded slice, as a Struct so Foldkit can compare it. */\nexport interface MirrorDependencies {\n readonly keys: Encoded\n}\n\n/** One write to a store: the keys to set, the keys to drop, and how the URL should record it. */\nexport interface MirrorWrite {\n readonly set: Encoded\n readonly remove: ReadonlyArray<string>\n /** `push` adds a history entry; `replace` does not. A store without history ignores it. */\n readonly intent: 'push' | 'replace'\n}\n\n/**\n * A keyed string store a mirror writes to and reads from. Errors are the\n * store's to absorb: a mirror is disposable state, and a failed write must\n * not fail the application.\n */\nexport interface MirrorStore<R = never> {\n readonly read: Effect.Effect<Encoded | undefined, never, R>\n readonly write: (write: MirrorWrite) => Effect.Effect<void, never, R>\n}\n\n/** `MirrorStore.url`: where in the URL the keys live. */\nexport type UrlLocation = 'search' | 'hash'\n\n/** Splits a same-origin href into its three parts; `search` and `hash` keep their leading `?`/`#`. */\nconst splitHref = (href: string): { pathname: string; search: string; hash: string } => {\n const hashAt = href.indexOf('#')\n const hash = hashAt < 0 ? '' : href.slice(hashAt)\n const rest = hashAt < 0 ? href : href.slice(0, hashAt)\n const searchAt = rest.indexOf('?')\n return {\n pathname: searchAt < 0 ? rest : rest.slice(0, searchAt),\n search: searchAt < 0 ? '' : rest.slice(searchAt),\n hash,\n }\n}\n\n/** The keys a query string holds among `owned`, in URL order. */\nconst readParams = (query: string, owned: ReadonlyArray<string>): Encoded => {\n const params = new URLSearchParams(\n query.startsWith('?') || query.startsWith('#') ? query.slice(1) : query,\n )\n const out: Record<string, string> = {}\n for (const key of owned) {\n const value = params.get(key)\n if (value !== null) out[key] = value\n }\n return out\n}\n\n/** `href` with the mirror's keys set and dropped in its location; every other key, the path, and the other part stay. */\nexport const applyToHref = (\n href: string,\n write: Pick<MirrorWrite, 'set' | 'remove'>,\n location: UrlLocation = 'search',\n): string => {\n const parts = splitHref(href)\n const current = location === 'search' ? parts.search : parts.hash\n const params = new URLSearchParams(current.slice(1))\n for (const key of write.remove) params.delete(key)\n for (const [key, value] of Object.entries(write.set)) params.set(key, value)\n const query = params.toString()\n const next = query === '' ? '' : `${location === 'search' ? '?' : '#'}${query}`\n return location === 'search'\n ? `${parts.pathname}${next}${parts.hash}`\n : `${parts.pathname}${parts.search}${next}`\n}\n\nconst currentHref = (): string | undefined => {\n const loc = (globalThis as { location?: Location }).location\n return loc === undefined ? undefined : `${loc.pathname}${loc.search}${loc.hash}`\n}\n\nconst urlStore = (owned: ReadonlyArray<string>, location: UrlLocation): MirrorStore => ({\n read: Effect.sync(() => {\n const href = currentHref()\n if (href === undefined) return undefined\n const parts = splitHref(href)\n return readParams(location === 'search' ? parts.search : parts.hash, owned)\n }),\n write: write =>\n Effect.suspend(() => {\n // Outside a browser (SSR, a test without a DOM) there is no URL to write.\n const href = currentHref()\n if (href === undefined) return Effect.void\n const next = applyToHref(href, write, location)\n if (next === href) return Effect.void\n return write.intent === 'push' ? Navigation.pushUrl(next) : Navigation.replaceUrl(next)\n }),\n})\n\nconst KV_VERSION = 1\n\nconst KvDocument = Schema.Struct({\n version: Schema.Number,\n scope: Schema.optional(Schema.String),\n keys: Schema.Record(Schema.String, Schema.String),\n})\n\nconst kvStore = (options: {\n readonly key: string\n readonly scope?: string | undefined\n}): MirrorStore<KeyValueStore.KeyValueStore> => {\n const decode = Schema.decodeUnknownResult(Schema.fromJsonString(KvDocument))\n const encode = Schema.encodeSync(Schema.fromJsonString(KvDocument))\n return {\n read: Effect.gen(function* () {\n const kv = yield* KeyValueStore.KeyValueStore\n const raw = yield* Effect.result(kv.get(options.key))\n if (Result.isFailure(raw)) {\n yield* Effect.logWarning(`Mirror: could not read \"${options.key}\"`, raw.failure)\n return undefined\n }\n if (raw.success === undefined) return undefined\n const document = decode(raw.success)\n // Another version, another scope, or malformed: disposable, so drop it and start clean.\n if (\n Result.isFailure(document) ||\n document.success.version !== KV_VERSION ||\n document.success.scope !== options.scope\n ) {\n yield* Effect.result(kv.remove(options.key))\n return undefined\n }\n return document.success.keys\n }),\n write: write =>\n Effect.gen(function* () {\n const kv = yield* KeyValueStore.KeyValueStore\n const text = encode({\n version: KV_VERSION,\n ...(options.scope === undefined ? {} : { scope: options.scope }),\n keys: write.set,\n })\n const outcome = yield* Effect.result(\n Object.keys(write.set).length === 0 ? kv.remove(options.key) : kv.set(options.key, text),\n )\n if (Result.isFailure(outcome)) {\n yield* Effect.logWarning(`Mirror: could not write \"${options.key}\"`, outcome.failure)\n }\n }),\n }\n}\n\n/** An in-memory store that records its writes, for tests and for a mirror with no host. */\nexport interface MemoryStore extends MirrorStore {\n /** What the store holds now. */\n readonly current: () => Encoded | undefined\n /** Every write, in order. */\n readonly writes: ReadonlyArray<MirrorWrite>\n}\n\nconst memoryStore = (initial?: Encoded): MemoryStore => {\n let held: Encoded | undefined = initial\n const writes: MirrorWrite[] = []\n return {\n read: Effect.sync(() => held),\n write: write =>\n Effect.sync(() => {\n writes.push(write)\n const next: Record<string, string> = { ...(held ?? {}) }\n for (const key of write.remove) delete next[key]\n Object.assign(next, write.set)\n held = next\n }),\n current: () => held,\n writes,\n }\n}\n\nexport const MirrorStore = {\n /** The URL's query string (or hash), through `foldkit/navigation`. `owned` are the keys the mirror may touch. */\n url: urlStore,\n /** One JSON document under `key` in Effect's `KeyValueStore`, scoped and versioned. */\n kv: kvStore,\n memory: memoryStore,\n}\n\n// ---------------------------------------------------------------------------\n// Messages\n// ---------------------------------------------------------------------------\n\n/** Mirror's Message cases, for `defineMessageUnion({ ...Mirror.messages, … })`. */\nexport const mirrorMessageCases = {\n /** A store was read (`mirror.restore`); `keys` are what it held for the mirror named. */\n MirrorRestored: { name: Schema.String, keys: Schema.Record(Schema.String, Schema.String) },\n} satisfies Record<string, Schema.Struct.Fields>\n\nexport interface MirrorRestored {\n readonly _tag: 'MirrorRestored'\n readonly name: string\n readonly keys: Encoded\n}\n\nexport type MirrorMessage = MirrorRestored\n\n// ---------------------------------------------------------------------------\n// Key codecs\n// ---------------------------------------------------------------------------\n\n/** A key's text form and back; the decode names what is wrong when it fails. */\ninterface KeyCodec {\n readonly decode: (text: string) => Result.Result<unknown, string>\n readonly encode: (value: unknown) => string\n}\n\nconst failure = (message: string): Result.Result<never, string> => Result.fail(message)\n\n/**\n * A key's codec, from an override or derived from the field: the field's\n * encoded form of the initial value says whether the key is text, a number,\n * a boolean, or JSON, and the field schema validates whatever was parsed.\n */\nconst codecFor = (\n field: Schema.Codec<unknown, unknown, never, never>,\n initial: unknown,\n override: Schema.Codec<unknown, string, never, never> | undefined,\n): KeyCodec => {\n if (override !== undefined) {\n const decode = Schema.decodeUnknownResult(override)\n const encode = Schema.encodeSync(override)\n return {\n decode: text => Result.mapError(decode(text), error => error.message),\n encode: value => encode(value),\n }\n }\n const encodeField = Schema.encodeSync(field)\n const decodeField = Schema.decodeUnknownResult(field)\n const shape = typeof encodeField(initial)\n const validate = (candidate: unknown) =>\n Result.mapError(decodeField(candidate), error => error.message)\n return {\n decode: text => {\n switch (shape) {\n case 'string':\n return validate(text)\n case 'number': {\n const value = text.trim() === '' ? Number.NaN : Number(text)\n return Number.isNaN(value) ? failure(`\"${text}\" is not a number`) : validate(value)\n }\n case 'boolean':\n return text === 'true' || text === 'false'\n ? validate(text === 'true')\n : failure(`\"${text}\" is not \"true\" or \"false\"`)\n default: {\n try {\n return validate(JSON.parse(text))\n } catch {\n return failure(`\"${text}\" is not JSON`)\n }\n }\n }\n },\n encode: value => {\n const encoded = encodeField(value)\n return shape === 'string' || shape === 'number' || shape === 'boolean'\n ? String(encoded)\n : JSON.stringify(encoded)\n },\n }\n}\n\n// ---------------------------------------------------------------------------\n// Mirrors\n// ---------------------------------------------------------------------------\n\n/** The value type of a field schema. */\ntype TypeOf<S> = S extends { readonly Type: infer T } ? T : never\n\n/**\n * The slice a mirror keeps: field refs straight from `App.model`, or a\n * writable projection over them (`Projection.pick`, `Projection.compose`),\n * the same object `foldkit-sync` replicates.\n */\nexport type Slice = WritableProjection<any, any> | readonly FieldRef<any, any, string>[]\n\n/** The Struct fields of a slice. */\nexport type SliceFields<S extends Slice> =\n S extends WritableProjection<any, infer Fields>\n ? Fields\n : S extends readonly FieldRef<any, any, string>[]\n ? { readonly [R in S[number] as R['key']]: R['Schema'] }\n : never\n\n/** The Model a slice is of. */\nexport type SliceRoot<S extends Slice> =\n S extends WritableProjection<infer Root, any>\n ? Root\n : S extends readonly FieldRef<infer Root, any, string>[]\n ? Root\n : never\n\n/** The value a slice reads. */\nexport type SliceValue<S extends Slice> = Schema.Struct.Type<SliceFields<S>>\n\nconst projectionOf = <S extends Slice>(\n slice: S,\n): WritableProjection<SliceRoot<S>, SliceFields<S>> =>\n (Array.isArray(slice)\n ? Projection.pick(...(slice as readonly FieldRef<any, any, string>[]))\n : slice) as WritableProjection<SliceRoot<S>, SliceFields<S>>\n\n/** How one field is kept: its store key, its history intent, whether its default is written, and its text codec. */\nexport interface KeyOptions<Value> {\n /** The store key; default the field name. */\n readonly key?: string | undefined\n /** Whether a change of this key adds a history entry; default `push`. Only the URL has history. */\n readonly history?: 'push' | 'replace' | undefined\n /** Write the key even when the value is the initial one; default false, so a default is elided. */\n readonly keep?: boolean | undefined\n /** The text codec; default derived from the field schema. */\n readonly codec?: Schema.Codec<Value, string, never, never> | undefined\n}\n\nexport interface MirrorConfig<S extends Slice, Name extends string = string> {\n /** Names the mirror in its contract and its Messages; default from the kind and keys. */\n readonly name?: Name | undefined\n /** The slice: field refs (`[App.model.filter, App.model.q]`) or a writable projection over them. */\n readonly fields: S\n readonly keys?:\n { readonly [K in keyof SliceFields<S>]?: KeyOptions<TypeOf<SliceFields<S>[K]>> } | undefined\n /** The Model's initial value, when the application was built without one; defaults are read from it. */\n readonly initial?: SliceRoot<S> | undefined\n /**\n * How long a changed slice waits before it is written; a newer change\n * supersedes a pending write. Browsers rate-limit history writes, so the\n * URL waits 50 ms by default; a store waits 250 ms.\n */\n readonly throttle?: Duration.Input | undefined\n}\n\nexport interface UrlMirrorConfig<\n S extends Slice,\n Name extends string = string,\n> extends MirrorConfig<S, Name> {\n /** Where in the URL the keys live; default the query string. */\n readonly location?: UrlLocation | undefined\n}\n\nexport interface KvMirrorConfig<S extends Slice, Name extends string = string> extends MirrorConfig<\n S,\n Name\n> {\n /** The store key the mirror's document lives under; also the mirror's name unless one is given. */\n readonly key: Name\n /** A user, a tenant: a document of another scope is discarded rather than restored. */\n readonly scope?: string | undefined\n}\n\n/** One key that failed to decode; the field keeps its initial value. */\nexport interface DecodeIssue {\n readonly key: string\n readonly message: string\n}\n\nexport interface Decoded<Value> {\n /** The fields the store named and decoded. */\n readonly value: Partial<Value>\n readonly issues: ReadonlyArray<DecodeIssue>\n}\n\n/**\n * A synchronous pre-init step: `Bootstrap` / Flags into the initial Model.\n * Pure: no Commands, no Messages, no Effects. It runs inside `init(flags, url)`\n * before the first render, when the store's keys are already in hand (Flags the\n * server embedded, a synchronous read, a test fixture). `Wiring.init` is the\n * other lifecycle: startup Commands after the Model exists, such as the\n * key-value mirror's `restore`, whose answer arrives later through `update`.\n * Compose steps with `Mirror.bootstrap`; a step that changes nothing returns\n * the Model it was given. Deliberately not part of `Wiring`, so the two\n * lifecycles cannot be confused.\n */\nexport type Bootstrap<AppModel> = (model: AppModel) => AppModel\n\n/**\n * A Model slice kept in a store. `Value` is the slice's value type; the keys,\n * codecs, and intents are values on the mirror, not type parameters.\n * `Mirror.url` and `Mirror.kv` add the `reduce` their store calls for.\n */\nexport interface Mirror<\n AppModel,\n Value extends Record<string, unknown>,\n R = never,\n Name extends string = string,\n> {\n readonly kind: 'url' | 'kv' | 'memory'\n readonly name: Name\n /** Store key per field. */\n readonly keys: Readonly<Record<keyof Value & string, string>>\n /** For `Module`: observes the slice, owns nothing. */\n readonly contract: Contract\n /** The store's keys for a Model, defaults elided unless a key is `keep`. */\n readonly encode: (model: AppModel) => Encoded\n /** The fields a store's keys name; a key that fails to decode is an issue, not a value. */\n readonly decode: (keys: Encoded) => Decoded<Value>\n /**\n * The Model with a store's keys as the whole slice: a key the store lacks,\n * or one that fails to decode, is the initial value.\n */\n readonly fromKeys: (model: AppModel, keys: Encoded) => AppModel\n /**\n * The Model with a store's keys applied to the fields it still holds at\n * their initial value, so a change made before the store answered is kept.\n */\n readonly restoreKeys: (model: AppModel, keys: Encoded) => AppModel\n /**\n * A pre-init step applying pre-read keys before the first render:\n * `restoreKeys`, so a store step composed after a URL step (a `reduce` of\n * the starting URL) keeps the URL's values. Takes the store's keys as the\n * store holds them (`Encoded`), which is what Flags carry when the server\n * embedded the store's document. A URL mirror inherits this too; its URL\n * step is `(model) => reduce(model, url)`.\n */\n readonly bootstrap: (keys: Encoded) => Bootstrap<AppModel>\n /** A link: the keys of `model` with `patch` applied, on `base` (default the current URL, else `/`). */\n readonly href: (model: AppModel, patch?: Partial<Value>, base?: string) => string\n /**\n * A Command that reads the store and yields `MirrorRestored` for this\n * mirror. Until the Model holds what it answered, writes wait.\n */\n readonly restore: Command<MirrorMessage, never, R>\n /** One Subscription entry, `<name>.mirror`: writes the store when the encoded slice changes. */\n readonly subscriptions: {\n readonly [K in `${Name}.mirror`]: EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R>\n }\n}\n\n/** A slice kept in the URL. */\nexport interface UrlMirror<\n AppModel,\n Value extends Record<string, unknown>,\n Name extends string = string,\n> extends Mirror<AppModel, Value, never, Name> {\n readonly kind: 'url'\n /** The Model with the URL's keys (a Foldkit `Url` or an href) as the whole slice: `fromKeys`. */\n readonly reduce: (model: AppModel, url: Url | string) => AppModel\n /**\n * How this mirror joins an assembly: it routes the application's URL Message\n * (a variant with a `url` field, tagged `tag`) into `reduce`, reads the URL at\n * startup, and brings its Subscriptions and contract. Several URL mirrors share\n * the URL Message.\n */\n readonly wiring: <const Tag extends string>(tag: Tag) => UrlMirrorWiring<AppModel, Tag>\n}\n\n/** The Message a URL mirror routes: the application's URL variant. */\nexport type UrlChangedMessage<Tag extends string> = {\n readonly _tag: Tag\n readonly url: Url\n}\n\nexport type UrlMirrorWiring<AppModel, Tag extends string> = Wiring<\n AppModel,\n UrlChangedMessage<Tag>\n> & {\n readonly onUrl: (model: AppModel, url: Url) => AppModel\n}\n\n/** `Mirror.routing`'s config: the application's own `init`, `update` and routing, and the URL mirrors to read. */\nexport interface MirrorRoutingConfig<\n AppModel,\n Message extends { readonly _tag: string },\n Tag extends Message['_tag'],\n Args extends ReadonlyArray<unknown>,\n InitReturn extends { readonly model: AppModel },\n UpdateReturn extends { readonly model: AppModel },\n> {\n readonly mirrors: readonly [UrlMirror<AppModel, any, any>, ...UrlMirror<AppModel, any, any>[]]\n /** The tag of the Message `routing.onUrlChange` makes. */\n readonly urlChanged: Tag\n /** `(url) => …`, or `(flags, url) => …` for an application with flags. */\n readonly init: (...args: [...Args, Url]) => InitReturn\n readonly update: (model: AppModel, message: Message) => UpdateReturn\n readonly routing: {\n readonly onUrlRequest: (request: Navigation.UrlRequest) => Message\n readonly onUrlChange: (url: Url) => Extract<Message, UrlChangedMessage<Tag>>\n }\n}\n\n/** `init`, `update` and `routing` for `Runtime.makeApplication`, with the mirrors reading every URL. */\nexport interface MirrorRouting<\n AppModel,\n Message,\n Args extends ReadonlyArray<unknown>,\n InitReturn,\n UpdateReturn,\n> {\n readonly init: (...args: [...Args, Url]) => InitReturn\n readonly update: (model: AppModel, message: Message) => UpdateReturn\n readonly routing: RoutingConfig<Message>\n}\n\nexport type KvMirrorWiring<AppModel> = Wiring<\n AppModel,\n MirrorRestored,\n KeyValueStore.KeyValueStore\n> & {\n readonly init: Update.Step<AppModel, MirrorRestored, KeyValueStore.KeyValueStore>\n}\n\n/**\n * A key-value mirror folded under one of the application's own Message\n * variants, from `Mirror.fold`. Calling it reduces the mirror's\n * `MirrorRestored` into the Model; `restore` and `init` yield the wrapper\n * Message instead of `MirrorRestored`, with the lift recorded so Story and\n * Scene can resolve `restore` by the answer the store gives.\n */\nexport interface MirrorFold<AppModel, ParentMessage> {\n (model: AppModel, message: MirrorRestored): Update.Return<AppModel, ParentMessage>\n /** `restore`, lifted: yields the wrapper Message for this mirror's answer. */\n readonly restore: Command<ParentMessage, never, KeyValueStore.KeyValueStore>\n /** A Step for `init`: the Model unchanged, and `restore` to run. */\n readonly init: Update.Step<AppModel, ParentMessage, KeyValueStore.KeyValueStore>\n}\n\n/** A slice kept in Effect's `KeyValueStore`. */\nexport interface KvMirror<\n AppModel,\n Value extends Record<string, unknown>,\n Name extends string = string,\n> extends Mirror<AppModel, Value, KeyValueStore.KeyValueStore, Name> {\n readonly kind: 'kv'\n /** The Model with a `MirrorRestored` for this mirror applied: `restoreKeys`; another mirror's is ignored. */\n readonly reduce: (model: AppModel, message: MirrorRestored) => AppModel\n /**\n * How this mirror joins an assembly: it routes its own `MirrorRestored` into\n * `reduce`, runs `restore` at startup, and brings its Subscriptions and\n * contract. Other key-value mirrors share the `MirrorRestored` tag.\n */\n readonly wiring: () => KvMirrorWiring<AppModel>\n}\n\n/** One runtime's store, for a mirror's writes: the keys its Model has yet to take in, and the writes waiting on that. */\ninterface Session {\n pending: Option.Option<Encoded>\n readonly waiting: Set<() => void>\n}\n\nconst nameOf = (\n kind: Mirror<unknown, Record<string, unknown>>['kind'],\n keys: ReadonlyArray<string>,\n given: string | undefined,\n): string => given ?? `${kind}(${keys.join(',')})`\n\n// A URL key belongs to one mirror per application; the same mirror may be\n// declared again (a module re-evaluated, a test), another may not take it.\nconst claimed = new WeakMap<object, Map<string, string>>()\n\nconst claim = (\n owner: object,\n location: UrlLocation,\n keys: ReadonlyArray<string>,\n name: string,\n): void => {\n let byKey = claimed.get(owner)\n if (byKey === undefined) {\n byKey = new Map()\n claimed.set(owner, byKey)\n }\n for (const key of keys) {\n const at = `${location}:${key}`\n const holder = byKey.get(at)\n if (holder !== undefined && holder !== name) {\n throw new Error(\n `Mirror.url: key \"${key}\" in the ${location} is already mirrored by \"${holder}\"; \"${name}\" cannot mirror it too`,\n )\n }\n byKey.set(at, name)\n }\n}\n\n/** An application a mirror is declared over: its identity token, and its initial Model when it has one. */\nexport interface MirrorApp<AppModel> {\n readonly owner: object\n readonly initial?: AppModel | undefined\n}\n\n/** A Foldkit `Url` carries `search` and `hash` without their `?` and `#`; an href has them. */\nconst withPrefix = (prefix: '?' | '#', part: string): string =>\n part === '' || part.startsWith(prefix) ? part : `${prefix}${part}`\n\nconst hrefOf = (url: Url | string): string =>\n typeof url === 'string'\n ? url\n : `${url.pathname}${withPrefix('?', url.search._tag === 'Some' ? url.search.value : '')}${withPrefix(\n '#',\n url.hash._tag === 'Some' ? url.hash.value : '',\n )}`\n\nconst make = <S extends Slice, R, Name extends string>(\n app: MirrorApp<SliceRoot<S>>,\n kind: Mirror<unknown, Record<string, unknown>>['kind'],\n store: MirrorStore<R>,\n config: MirrorConfig<S, Name> & { readonly location?: UrlLocation | undefined },\n throttle: Duration.Input,\n // Names one runtime's store, so writes wait for that runtime's restore; none\n // for the URL, which startup reads before the first write.\n sessionKey: Option.Option<Effect.Effect<object, never, R>>,\n) => {\n type AppModel = SliceRoot<S>\n type Value = SliceValue<S>\n const fields = projectionOf(config.fields)\n const names = Object.keys(fields.schema.fields)\n const options = (config.keys ?? {}) as Readonly<Record<string, KeyOptions<unknown> | undefined>>\n const initial = config.initial ?? app.initial\n if (initial === undefined) {\n throw new Error(\n `Mirror.${kind}: defaults are read from the initial Model, so build the application with \\`initial\\` or pass \\`initial\\` in the config`,\n )\n }\n const initialSlice = fields.get(initial) as Readonly<Record<string, unknown>>\n const location = config.location ?? 'search'\n\n const keyOf: Record<string, string> = {}\n const fieldOf: Record<string, string> = {}\n const codecs: Record<string, KeyCodec> = {}\n const history: Record<string, 'push' | 'replace'> = {}\n const keep = new Set<string>()\n const initialText: Record<string, string> = {}\n for (const field of names) {\n const option = options[field]\n const key = option?.key ?? field\n if (fieldOf[key] !== undefined) {\n throw new Error(\n `Mirror: fields \"${fieldOf[key]}\" and \"${field}\" both use the key \"${key}\"; give one another key`,\n )\n }\n keyOf[field] = key\n fieldOf[key] = field\n codecs[field] = codecFor(\n fields.schema.fields[field] as Schema.Codec<unknown, unknown, never, never>,\n initialSlice[field],\n option?.codec as Schema.Codec<unknown, string, never, never> | undefined,\n )\n history[field] = option?.history ?? 'push'\n if (option?.keep === true) keep.add(field)\n initialText[field] = codecs[field].encode(initialSlice[field])\n }\n const owned = names.map(field => keyOf[field]!)\n const name = nameOf(kind, owned, config.name) as Name\n if (kind === 'url') claim(app.owner, location, owned, name)\n\n // A field's text, remembered by the value's identity: the write entry\n // encodes the slice on every Model change and `href` on every render, and a\n // structured field (JSON) costs a stringify each time. Primitives are cheap\n // and have no identity to remember.\n const texts: Record<string, WeakMap<object, string>> = {}\n for (const field of names) texts[field] = new WeakMap()\n const encodeField = (field: string, value: unknown): string => {\n if (typeof value !== 'object' || value === null) return codecs[field]!.encode(value)\n const known = texts[field]!.get(value)\n if (known !== undefined) return known\n const text = codecs[field]!.encode(value)\n texts[field]!.set(value, text)\n return text\n }\n\n // Two slices a store cannot tell apart are the same slice: a Model keeps\n // its identity when a store reads back what it holds, as it does after its\n // own write to the URL, so Foldkit does not render it again.\n const sameSlice = (\n current: Readonly<Record<string, unknown>>,\n next: Readonly<Record<string, unknown>>,\n ): boolean =>\n names.every(\n field =>\n Object.is(current[field], next[field]) ||\n encodeField(field, current[field]) === encodeField(field, next[field]),\n )\n\n const encodeSlice = (slice: Readonly<Record<string, unknown>>): Encoded => {\n const out: Record<string, string> = {}\n for (const field of names) {\n const text = encodeField(field, slice[field])\n if (!keep.has(field) && text === initialText[field]) continue\n out[keyOf[field]!] = text\n }\n return out\n }\n const encode = (model: AppModel): Encoded =>\n encodeSlice(fields.get(model) as Readonly<Record<string, unknown>>)\n\n const decode = (keys: Encoded): Decoded<Value> => {\n const value: Record<string, unknown> = {}\n const issues: DecodeIssue[] = []\n for (const field of names) {\n const key = keyOf[field]!\n const text = keys[key]\n if (text === undefined) continue\n const decoded = codecs[field]!.decode(text)\n if (Result.isFailure(decoded)) issues.push({ key, message: decoded.failure })\n else value[field] = decoded.success\n }\n return { value: value as Partial<Value>, issues }\n }\n\n const keysOfUrl = (source: Url | string): Encoded => {\n const parts = splitHref(hrefOf(source))\n return readParams(location === 'search' ? parts.search : parts.hash, owned)\n }\n\n const fromKeys = (model: AppModel, keys: Encoded): AppModel => {\n const decoded = decode(keys).value as Readonly<Record<string, unknown>>\n const next = { ...initialSlice, ...decoded }\n return sameSlice(fields.get(model) as Readonly<Record<string, unknown>>, next)\n ? model\n : fields.set(model, next as never)\n }\n\n // The fields a restore of `keys` would change in a slice whose text per\n // field is `textOf`: those still at their initial text, since a change the\n // user made before the store answered wins over the store.\n const restorable = (\n textOf: (field: string) => string,\n keys: Encoded,\n ): Readonly<Record<string, unknown>> => {\n const decoded = decode(keys).value as Readonly<Record<string, unknown>>\n const out: Record<string, unknown> = {}\n for (const field of names) {\n if (textOf(field) !== initialText[field] || !Object.hasOwn(decoded, field)) continue\n if (encodeField(field, decoded[field]) !== initialText[field]) out[field] = decoded[field]\n }\n return out\n }\n\n const restoreKeys = (model: AppModel, keys: Encoded): AppModel => {\n const current = fields.get(model) as Readonly<Record<string, unknown>>\n const restored = restorable(field => encodeField(field, current[field]), keys)\n return Object.keys(restored).length === 0\n ? model\n : fields.set(model, { ...current, ...restored } as never)\n }\n\n const href = (model: AppModel, patch?: Partial<Value>, base?: string): string => {\n const slice = { ...(fields.get(model) as Readonly<Record<string, unknown>>), ...patch }\n const set = encodeSlice(slice)\n const remove = owned.filter(key => !(key in set))\n return applyToHref(base ?? currentHref() ?? '/', { set, remove }, location)\n }\n\n const contract: Contract = {\n kind: 'mirror',\n name,\n owner: app.owner,\n owns: [],\n observes: fields.dependencies,\n messages: kind === 'kv' ? ['MirrorRestored'] : [],\n metadata: [],\n }\n\n // Until the Model has taken in what the store held, a write would replace\n // the stored slice with the initial one: the write Subscription starts with\n // the initial Model, before `restore` answers. So per session (one runtime's\n // store) a write waits until its slice is one a restore of the store's keys\n // leaves unchanged. The keys are the latest restore's answer, or, before any\n // answer, what the store holds at the first write, so a mirror nobody\n // restores (a test, a Model kept across a hot reload) writes once its slice\n // agrees with the store.\n const sessions = new WeakMap<object, Session>()\n const sessionOf = (key: object, keys: Encoded): Session => {\n const known = sessions.get(key)\n if (known !== undefined) return known\n const made: Session = { pending: Option.some(keys), waiting: new Set() }\n sessions.set(key, made)\n return made\n }\n const answered = (keys: Encoded): Effect.Effect<void, never, R> =>\n Option.match(sessionKey, {\n onNone: () => Effect.void,\n onSome: key =>\n Effect.map(key, key => {\n const session = sessionOf(key, keys)\n session.pending = Option.some(keys)\n for (const wake of [...session.waiting]) wake()\n }),\n })\n const settled = (encoded: Encoded): Effect.Effect<void, never, R> =>\n Option.match(sessionKey, {\n onNone: () => Effect.void,\n onSome: key =>\n Effect.gen(function* () {\n const at = yield* key\n const session = sessions.get(at) ?? sessionOf(at, (yield* store.read) ?? {})\n const text = (field: string) => encoded[keyOf[field]!] ?? initialText[field]!\n yield* Effect.callback<void>(resume => {\n const check = () => {\n const absorbed = Option.match(session.pending, {\n onNone: () => true,\n onSome: keys => Object.keys(restorable(text, keys)).length === 0,\n })\n if (!absorbed) return\n session.pending = Option.none()\n session.waiting.delete(check)\n resume(Effect.void)\n }\n session.waiting.add(check)\n check()\n // A newer slice interrupts this one before the Model took the keys in.\n return Effect.sync(() => session.waiting.delete(check))\n })\n }),\n })\n\n const restore: Command<MirrorMessage, never, R> = {\n name: `Mirror.restore(${name})`,\n effect: store.read.pipe(\n Effect.map(keys => keys ?? {}),\n Effect.tap(answered),\n Effect.map((keys): MirrorMessage => ({ _tag: 'MirrorRestored', name, keys })),\n ),\n }\n\n // Writes only what changed, and pushes only for a changed key that pushes:\n // a removal (a key back at its default) never adds a history entry.\n const sync = (encoded: Encoded): Effect.Effect<void, never, R> =>\n Effect.gen(function* () {\n const current = (yield* store.read) ?? {}\n const remove = owned.filter(key => !(key in encoded) && key in current)\n const changed = owned.filter(key => key in encoded && current[key] !== encoded[key])\n if (remove.length === 0 && changed.length === 0) return\n const intent = changed.some(key => history[fieldOf[key]!] === 'push') ? 'push' : 'replace'\n yield* store.write({ set: encoded, remove, intent })\n })\n\n const entry: EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R> = {\n dependenciesSchema: Schema.Struct({ keys: Schema.Record(Schema.String, Schema.String) }),\n modelToDependencies: model => ({ keys: encode(model) }),\n dependenciesToStream: ({ keys }) =>\n Stream.fromEffect(\n settled(keys).pipe(Effect.andThen(sync(keys)), Effect.delay(throttle)),\n ).pipe(Stream.drain),\n }\n\n const mirror: Mirror<AppModel, Value, R, Name> = {\n kind,\n name,\n keys: keyOf as Readonly<Record<keyof Value & string, string>>,\n contract,\n encode,\n decode,\n fromKeys,\n restoreKeys,\n bootstrap: keys => model => restoreKeys(model, keys),\n href,\n restore,\n subscriptions: { [`${name}.mirror`]: entry } as Mirror<\n AppModel,\n Value,\n R,\n Name\n >['subscriptions'],\n }\n return { mirror, keysOfUrl }\n}\n\n// A mirror's Subscription entries are unbranded so an application can spread them\n// into its own `Subscription.make`; wiring hands them over as a branded record.\nconst brandEntries = <AppModel, R>(\n entries: Readonly<Record<string, EntryWithoutKeepAlive<AppModel, never, MirrorDependencies, R>>>,\n): Subscription.Subscriptions<AppModel, never, R> =>\n Subscription.make<AppModel, never, R>()(() => entries)\n\nexport const Mirror = {\n /** Mirror's Message cases, to spread into the application's union. */\n messages: mirrorMessageCases,\n\n /**\n * Mirror's Messages as one Schema, for a wrapper variant in the\n * application's union: `GotPrefsMessage: { message: Mirror.Message }`. With\n * a wrapper, `update` matches the application's union exhaustively and\n * `Mirror.fold` reduces what arrives inside it.\n */\n Message: defineMessageUnion(mirrorMessageCases),\n\n /**\n * A key-value mirror under one wrapper variant of the application's union,\n * the same shape Foldkit gives a Submodel: `toParentMessage` wraps the\n * mirror's `MirrorRestored`, the fold reduces it, and `fold.init` runs the\n * lifted `restore` at startup. One wrapper per mirror: two mirrors that\n * share a variant would each have to reduce the other's answer.\n *\n * @example\n * ```ts\n * const Message = defineMessageUnion({ GotPrefsMessage: { message: Mirror.Message } })\n * const foldPrefs = Mirror.fold(Prefs, message => Message.GotPrefsMessage({ message }))\n *\n * const init = (): Return => foldPrefs.init(initial)\n * const update = (model: Model, message: Message): Return =>\n * Message.match(message, {\n * GotPrefsMessage: ({ message }) => foldPrefs(model, message),\n * })\n * ```\n */\n fold: <AppModel, Value extends Record<string, unknown>, Name extends string, ParentMessage>(\n mirror: KvMirror<AppModel, Value, Name>,\n toParentMessage: (message: MirrorRestored) => ParentMessage,\n ): MirrorFold<AppModel, ParentMessage> => {\n const restore = mapMessage(mirror.restore, toParentMessage)\n const fold = (model: AppModel, message: MirrorRestored) => ({\n model: mirror.reduce(model, message),\n })\n return Object.assign(fold, {\n restore,\n init: (model: AppModel) => ({ model, commands: [restore] }),\n })\n },\n\n /** Narrows the application's union to Mirror's cases, by tag. */\n reduces: <M extends { readonly _tag: string }>(\n message: M,\n ): message is Extract<M, { readonly _tag: 'MirrorRestored' }> =>\n Object.hasOwn(mirrorMessageCases, message._tag),\n\n /**\n * Folds pre-init steps into the initial Model, in list order: stores first,\n * the URL last. Either order keeps URL > store > initial (a store bootstrap\n * only fills fields still at their initial value, while a URL `reduce` sets\n * its whole slice), but listing the URL last states the precedence. Among\n * store bootstraps sharing a field, the first one wins.\n *\n * Use this when the keys are already in hand at boot: Flags the server\n * embedded, a synchronous read, a test fixture. When the store can only be\n * read asynchronously, use the `restore` Command (`wiring.init`,\n * `fold.init`) instead: bootstrapping what the store holds needs the keys,\n * and `restore` is how they arrive.\n *\n * @example\n * ```ts\n * const init = (flags: { prefs: Encoded }, url: Url): Return => ({\n * model: Mirror.bootstrap(\n * initial,\n * Prefs.bootstrap(flags.prefs),\n * model => Filters.reduce(model, url),\n * ),\n * })\n * ```\n */\n bootstrap: <AppModel>(model: AppModel, ...steps: ReadonlyArray<Bootstrap<AppModel>>): AppModel =>\n steps.reduce((next, step) => step(next), model),\n\n /**\n * A slice kept in the URL: `Projection.pick(App.model.filter, App.model.q)`\n * as `?filter=…&q=…`, defaults elided, written when it changes (one history\n * write per Model change) and read back with `reduce(model, url)` on\n * `onUrlChange` and on cold load.\n */\n url: <S extends Slice, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n config: UrlMirrorConfig<S, Name>,\n ): UrlMirror<SliceRoot<S>, SliceValue<S>, Name> => {\n const owned = Object.keys(projectionOf(config.fields).schema.fields).map(\n field =>\n (config.keys as Readonly<Record<string, KeyOptions<unknown> | undefined>> | undefined)?.[\n field\n ]?.key ?? field,\n )\n const { mirror, keysOfUrl } = make(\n app,\n 'url',\n MirrorStore.url(owned, config.location ?? 'search'),\n config,\n config.throttle ?? '50 millis',\n Option.none(),\n )\n const reduce = (model: SliceRoot<S>, url: Url | string) =>\n mirror.fromKeys(model, keysOfUrl(url))\n return {\n ...mirror,\n kind: 'url',\n reduce,\n wiring: tag => ({\n key: `mirror:${mirror.name}`,\n handles: [tag],\n shared: [tag],\n route: (model, message) =>\n // tag-check: open — `Tag` is the application's URL variant, generic here\n message._tag === tag ? Option.some({ model: reduce(model, message.url) }) : Option.none(),\n onUrl: reduce,\n subscriptions: brandEntries(mirror.subscriptions),\n contract: mirror.contract,\n }),\n }\n },\n\n /**\n * URL mirrors plugged into `Runtime.makeApplication`: spread the result into\n * its config. `init` reads the starting URL into the Model the application's\n * `init` returns; `update` reads a `urlChanged` Message's URL into the Model\n * before the application's `update` sees it, so a route handler finds the\n * slices already read. `routing` is the application's own, passed through.\n *\n * @example\n * ```ts\n * Runtime.makeApplication({\n * Model, view, subscriptions, container,\n * ...Mirror.routing({\n * mirrors: [Filters],\n * urlChanged: 'ChangedUrl',\n * init,\n * update,\n * routing: {\n * onUrlRequest: request => Message.ClickedLink({ request }),\n * onUrlChange: url => Message.ChangedUrl({ url }),\n * },\n * }),\n * })\n * ```\n */\n routing: <\n AppModel,\n Message extends { readonly _tag: string },\n const Tag extends Message['_tag'],\n Args extends ReadonlyArray<unknown>,\n InitReturn extends { readonly model: AppModel },\n UpdateReturn extends { readonly model: AppModel },\n >(\n config: MirrorRoutingConfig<AppModel, Message, Tag, Args, InitReturn, UpdateReturn>,\n ): MirrorRouting<AppModel, Message, Args, InitReturn, UpdateReturn> => {\n const read = (model: AppModel, url: Url): AppModel =>\n config.mirrors.reduce((next, mirror) => mirror.reduce(next, url), model)\n const isUrlChanged = (message: Message): message is Message & UrlChangedMessage<Tag> =>\n // tag-check: open — `Tag` is the application's URL variant, generic here\n message._tag === config.urlChanged\n return {\n init: (...args) => {\n const started = config.init(...args)\n return { ...started, model: read(started.model, args[args.length - 1] as Url) }\n },\n update: (model, message) =>\n config.update(isUrlChanged(message) ? read(model, message.url) : model, message),\n routing: config.routing,\n }\n },\n\n /**\n * A slice kept in Effect's `KeyValueStore` under `key`, as one scoped,\n * versioned JSON document: written when it changes, read back by the\n * `restore` Command whose `MirrorRestored` `reduce` applies.\n */\n kv: <S extends Slice, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n config: KvMirrorConfig<S, Name>,\n ): KvMirror<SliceRoot<S>, SliceValue<S>, Name> => {\n const { mirror } = make(\n app,\n 'kv',\n MirrorStore.kv({\n key: config.key,\n ...(config.scope === undefined ? {} : { scope: config.scope }),\n }),\n { ...config, name: config.name ?? config.key },\n config.throttle ?? '250 millis',\n // One runtime builds one KeyValueStore: the session is that service.\n Option.some(Effect.service(KeyValueStore.KeyValueStore)),\n )\n const reduce = (model: SliceRoot<S>, message: MirrorRestored) =>\n message.name === mirror.name ? mirror.restoreKeys(model, message.keys) : model\n return {\n ...mirror,\n kind: 'kv',\n reduce,\n wiring: () => ({\n key: `mirror:${mirror.name}`,\n handles: ['MirrorRestored'],\n shared: ['MirrorRestored'],\n // Another mirror's restore is not this one's: `None` lets the next mirror take it.\n route: (model, message) =>\n message._tag === 'MirrorRestored' && message.name === mirror.name\n ? Option.some({ model: reduce(model, message) })\n : Option.none(),\n init: model => ({ model, commands: [mirror.restore] }),\n subscriptions: brandEntries(mirror.subscriptions),\n contract: mirror.contract,\n }),\n }\n },\n\n /** The kernel form: a slice kept in any `MirrorStore`, read back with `fromKeys` or `restoreKeys`, bootstrapped with `bootstrap`. */\n make: <S extends Slice, R, Name extends string = string>(\n app: MirrorApp<SliceRoot<S>>,\n store: MirrorStore<R>,\n config: MirrorConfig<S, Name>,\n ): Mirror<SliceRoot<S>, SliceValue<S>, R, Name> =>\n make(app, 'memory', store, config, config.throttle ?? 0, Option.some(Effect.succeed(store)))\n .mirror,\n}\n"],"mappings":"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"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "foldkit-mirror",
3
- "version": "0.2.3",
3
+ "version": "0.4.0",
4
4
  "description": "A Foldkit Model slice kept in the URL or a key-value store: written when the slice changes, read back on navigation or cold load.",
5
5
  "keywords": [
6
6
  "foldkit",
@@ -28,6 +28,7 @@
28
28
  "sideEffects": false,
29
29
  "exports": {
30
30
  ".": {
31
+ "foldkit-plus:source": "./src/index.ts",
31
32
  "types": "./dist/index.d.mts",
32
33
  "import": "./dist/index.mjs"
33
34
  }
@@ -38,19 +39,20 @@
38
39
  "LICENSE"
39
40
  ],
40
41
  "dependencies": {
41
- "foldkit-surface": "0.4.1"
42
+ "foldkit-surface": "0.5.1"
42
43
  },
43
44
  "peerDependencies": {
44
- "effect": "^4.0.0-rc.112",
45
- "foldkit": "^0.158.2"
45
+ "effect": ">=4.0.0-rc.116 <4.0.0-rc.118",
46
+ "foldkit": "^0.163.0"
46
47
  },
47
48
  "devDependencies": {
48
- "effect": "4.0.0-rc.112",
49
- "foldkit": "0.158.2",
49
+ "@effect/platform-browser": "4.0.0-rc.116",
50
+ "effect": "4.0.0-rc.116",
51
+ "foldkit": "0.163.0",
50
52
  "jsdom": "26.1.0",
51
53
  "tsdown": "^0.23.0",
52
54
  "typescript": "5.9.3",
53
- "foldkit-bundle": "0.2.0"
55
+ "foldkit-bundle": "0.4.0"
54
56
  },
55
57
  "scripts": {
56
58
  "build": "tsdown",