foldkit-surface 0.1.1 → 0.3.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
@@ -75,6 +75,191 @@ reads purely (`Surface.read(TodoList, model)`), binds a renderer
75
75
  `foldkit-agent` derive their work from. `Projection.pick(App.fields.todos)` is
76
76
  a writable projection of the same field for a replicator.
77
77
 
78
+ ## How this relates to Optics and Submodels
79
+
80
+ Surface sits near two existing ideas in Effect and Foldkit, so the overlap is
81
+ intentional. They operate at different levels:
82
+
83
+ | Concept | What it answers |
84
+ | --- | --- |
85
+ | **Effect Optic** | "How do I focus, read, or replace this value inside another value?" |
86
+ | **`ModelRef` / `Projection`** | "What application data is this focus or derived value made from?" |
87
+ | **Surface** | "What may this feature observe, and which application Messages may it cause?" |
88
+ | **Foldkit Submodel** | "Which state machine owns this state and these transitions?" |
89
+
90
+ A useful shorthand is:
91
+
92
+ ```text
93
+ evo = evolve application data inside update
94
+ Optic / ModelRef = locate a value structurally
95
+ Projection = describe/read/write a known Model slice
96
+ Surface = observation + capability contract
97
+ Submodel = state-machine ownership boundary
98
+ ```
99
+
100
+ They compose; none replaces the others. The same field plays each role in
101
+ turn:
102
+
103
+ ```ts
104
+ // application transition
105
+ evo(model, { filter: () => 'active' })
106
+
107
+ // structural addressing
108
+ App.fields.filter.get(model)
109
+
110
+ // infrastructure installation
111
+ App.fields.filter.set(model, restoredFilter)
112
+ ```
113
+
114
+ ### Surface builds on Optics rather than replacing them
115
+
116
+ Every generated `ModelRef` contains an Effect `Optic.Optional` underneath it.
117
+ The optic supplies the structural focus. Surface enriches that focus with the
118
+ information the rest of an application architecture needs:
119
+
120
+ ```text
121
+ Effect Optic
122
+ + Schema
123
+ + dependency path
124
+ + application identity
125
+ + get / set
126
+ ↓
127
+ ModelRef
128
+ ↓
129
+ Projection
130
+ + metadata (Remote's requirements, …)
131
+ ↓
132
+ Surface
133
+ + name / params
134
+ + allowed Messages
135
+ ```
136
+
137
+ For example, `App.fields.todos` is not an alternative to an optic. It is an
138
+ optic-backed reference that also knows that the value is the `todos` field of
139
+ *this* application, how it is encoded, and that a consumer depending on it
140
+ depends on the `todos` Model path. `ModelRef.fromOptic` is the escape hatch when
141
+ you already have an optic and want to add that metadata yourself.
142
+
143
+ That extra metadata is the reason Surface exists. An optic can focus
144
+ `model.todos`; by itself it cannot tell `foldkit-sync` that `todos` is the slice
145
+ to replicate, `Module` that another contract claims the same path, or
146
+ `foldkit-remote` that a derived projection needs server data. Surface carries
147
+ that last fact as opaque metadata: `foldkit-remote` attaches its requirements
148
+ under its own `Metadata.key` and reads them back, and Surface only merges them.
149
+
150
+ A `Projection` also need not correspond to one structural focus. It can combine
151
+ several refs or derived values into one read model while preserving the
152
+ dependencies and metadata of every part.
153
+
154
+ ### Surface and Submodels solve different decompositions
155
+
156
+ A [Foldkit Submodel](https://foldkit.dev/core/submodel) is for a part of the
157
+ application that **owns a state machine**. It has its own Model, Message, update,
158
+ view, and Commands. The parent stores the child Model, routes child Messages,
159
+ and delegates transitions to the child's update.
160
+
161
+ A Surface owns none of those things. It has no private state, no child update,
162
+ no runtime boundary, no Message wrapping, and no Command lifting. It describes
163
+ a restricted interface to state and Messages that already belong to the
164
+ application.
165
+
166
+ ```text
167
+ Submodel
168
+ "This child owns how this state changes."
169
+
170
+ Surface
171
+ "This consumer may see these values and cause these application Messages."
172
+ ```
173
+
174
+ The most useful way to distinguish them is by the decomposition they create:
175
+
176
+ ```text
177
+ Submodels divide the application by ownership:
178
+ who owns this state and these transitions?
179
+
180
+ Surfaces divide the application by consumer needs:
181
+ what does this screen / agent / subsystem need to observe and cause?
182
+ ```
183
+
184
+ Those boundaries do not need to line up. In fact, a Surface can deliberately
185
+ span several Submodels because observation is not ownership. A page that reads
186
+ the route, a theme owned by `Settings`, and the signed-in user owned by
187
+ `Session` does not need to become a third state machine just to assemble those
188
+ values:
189
+
190
+ ```ts
191
+ const Model = Schema.Struct({
192
+ route: Route,
193
+ settings: Settings.Model,
194
+ session: Session.Model,
195
+ })
196
+
197
+ const App = Surface.application({ Model, Message, initial, update })
198
+
199
+ const AccountPage = App.surface('AccountPage', {
200
+ model: ({ model }) => ({
201
+ route: model.route, // parent-owned
202
+ theme: model.settings.theme, // Settings Submodel
203
+ user: model.session.user, // Session Submodel
204
+ }),
205
+ })
206
+ ```
207
+
208
+ Conceptually:
209
+
210
+ ```text
211
+ Root application
212
+ ├── route parent-owned
213
+ ├── settings: Settings.Model Settings owns transitions
214
+ └── session: Session.Model Session owns transitions
215
+ │ │
216
+ └───────┬───────┘
217
+ │ observed by
218
+ AccountPage Surface
219
+ (+ parent-owned route)
220
+ ```
221
+
222
+ This is a feature of the model, not a leak in it: **Submodels partition
223
+ transition ownership; Surfaces may cut across those partitions to describe a
224
+ consumer-facing read/capability boundary.** A screen, an agent context, or
225
+ another interpreter often needs a coherent read model assembled from several
226
+ owners.
227
+
228
+ The Surface does **not** weaken any of those Submodel boundaries. Reading
229
+ `model.settings.theme` through a `ModelRef` does not grant permission to change
230
+ it directly. If `Settings` owns that state, changes must still go through the
231
+ Settings state machine: its child Message and update, routed through the normal
232
+ parent/child path (`Update.foldChild`, an exported child helper, or the wrapped
233
+ Message path used by the application).
234
+
235
+ The same rule applies to Surface capabilities. If `AccountPage` may cause a
236
+ Settings transition, expose the **root application Message constructor that
237
+ routes to Settings** in the Surface's `messages`; do not use the underlying
238
+ optic/setter as a shortcut around the child update.
239
+
240
+ `FieldRef.set` and writable `Projection`s are structural/infrastructure tools.
241
+ Their existence does not imply ownership of the focused state. A Submodel's
242
+ invariants still belong to its update.
243
+
244
+ Likewise, Surface does not replace `h.submodel`: `h.submodel` creates the runtime
245
+ child boundary and routes child Messages. A Surface is pure, inspectable data
246
+ that may observe across those runtime boundaries without creating another one.
247
+
248
+ ### Which one should I reach for?
249
+
250
+ - **You need to focus or update nested immutable data:** start with an Effect
251
+ Optic; use `ModelRef.fromOptic` if that focus must participate in Surface
252
+ metadata.
253
+ - **A feature needs its own state, Message vocabulary, update logic, Commands,
254
+ or reusable stateful lifecycle:** use a Foldkit Submodel.
255
+ - **Something needs an inspectable declaration of what existing application
256
+ state a feature reads or which existing Messages it may cause:** use a
257
+ Surface.
258
+ - **A screen or subsystem reads across several Submodels:** use one Surface over
259
+ those child fields; do not invent a new Submodel merely to aggregate them.
260
+ - **You need both:** keep transition ownership in each Submodel and describe the
261
+ consumer-facing observation/capability boundary with Surface.
262
+
78
263
  ## Field references
79
264
 
80
265
  `Surface.application` generates a reference tree from the Model Schema, one node
@@ -115,10 +300,10 @@ have.
115
300
 
116
301
  ## Projections
117
302
 
118
- A `Projection<Root, Value>` is three things: a `Model` codec for `Value`, a pure
119
- `read(root) => Value`, and what it needs: its `dependencies` (Model paths), its
120
- `requirements` (remote entity fields), and its `connections` (remote query
121
- connections, with what they select of each item). Reading never performs I/O.
303
+ A `Projection<Root, Value>` is a `Model` codec for `Value`, a pure
304
+ `read(root) => Value`, its `dependencies` (Model paths), and its `metadata`:
305
+ facts other packages attach and interpret, such as the server data a
306
+ `foldkit-remote` selection needs. Reading never performs I/O.
122
307
 
123
308
  ```ts
124
309
  Projection.struct({ todos: model.todos, selectedTodoId: model.selectedTodoId })
@@ -130,8 +315,30 @@ Projection.fromReader(codec, read) // escape hatch for a non-ModelRef value
130
315
 
131
316
  `Projection.struct` accepts `ModelRef`s and nested `Projection`s, so a Surface can
132
317
  mix local fields with remote or replicated values. A nested projection
133
- contributes its dependencies, requirements, and connections to the parent
134
- (`Requirement.merge` and `Requirement.mergeConnections` union them).
318
+ contributes its dependencies and metadata to the parent.
319
+
320
+ ### Metadata
321
+
322
+ `Metadata` is [`foldkit-metadata`](../metadata/README.md), re-exported so an
323
+ application needs one import. A package declares its own slot once and reads back only its own entries:
324
+
325
+ ```ts
326
+ const Flags = Metadata.key<string>('flags', {
327
+ merge: flags => [...new Set(flags)],
328
+ summarize: flag => flag,
329
+ })
330
+
331
+ const beta = Projection.fromReader(Schema.Boolean, readBeta, { metadata: Flags.of('beta') })
332
+ Flags.get(Projection.struct({ beta, todos: model.todos }).metadata) // ['beta']
333
+ ```
334
+
335
+ Entries are combined per key with that key's `merge` as projections compose, and
336
+ looked up by the key object, never by its name, so two packages cannot collide.
337
+ The flip side: two copies of one package (a duplicated install, a reloaded
338
+ module) declare two keys and do not see each other's entries. `Metadata` is
339
+ opaque and its entries frozen; only a key's `of` and composition make one.
340
+ Surface never interprets them; `Surface.inspect` and `Module` show them through
341
+ `summarize`.
135
342
 
136
343
  ## Applications
137
344
 
@@ -244,8 +451,8 @@ modules can contribute their contracts independently.
244
451
 
245
452
  - Reference-based Model selection (`App.fields`, `Projection.pick`,
246
453
  `Projection.compose`).
247
- - Pure `Projection` values with their codec, reader, dependencies, and remote
248
- requirements.
454
+ - Pure `Projection` values with their codec, reader, dependencies, and opaque
455
+ interpreter metadata (`Metadata.key`).
249
456
  - Application scopes (`Surface.application`) and their identity token.
250
457
  - Typed Message subsets (`MessageSet.make`, `MessageSet.union`).
251
458
  - Named Surfaces and their renderer binding.
@@ -258,7 +465,8 @@ modules can contribute their contracts independently.
258
465
  [`foldkit-sync`](https://github.com/doeixd/foldkit-plus/tree/main/packages/sync).
259
466
  - `Model` codecs are pure by construction: Foldkit Model fields carry no decoding
260
467
  or encoding services.
261
- - A projection declares dependencies and requirements but does not resolve them.
468
+ - A projection declares dependencies and carries metadata but does not act on
469
+ either; an interpreter such as `foldkit-remote` reads the metadata it owns.
262
470
 
263
471
  ## See also
264
472
 
@@ -269,4 +477,4 @@ modules can contribute their contracts independently.
269
477
  - [Server-derived state](https://github.com/doeixd/foldkit-plus/blob/main/docs/remote.md) — the guide that covers
270
478
  this boundary and the Remote Submodel above it.
271
479
  - [`examples/todo-app`](https://github.com/doeixd/foldkit-plus/tree/main/examples/todo-app) — five feature Surfaces, a Module, and every contract in one
272
- application.
480
+ application.
package/dist/index.d.mts CHANGED
@@ -1,7 +1,11 @@
1
1
  import { Optic, Option, Schema } from "effect";
2
+ import { Metadata, Metadata as Metadata$1, MetadataKey, MetadataSummary, MetadataSummary as MetadataSummary$1, MetadataTypeId } from "foldkit-metadata";
2
3
  import { Html, HtmlBuilder } from "foldkit/html";
3
4
  import { MessageUnion } from "foldkit/message";
5
+ import { Entry } from "foldkit/managedResource";
6
+ import { Subscriptions } from "foldkit/subscription";
4
7
  import * as Update from "foldkit/update";
8
+ import { Url } from "foldkit/url";
5
9
  //#region src/index.d.ts
6
10
  export interface ModelRef<Root, Value, Encoded = unknown> {
7
11
  /** A pure codec: Foldkit Model fields carry no decoding or encoding services. */
@@ -10,6 +14,13 @@ export interface ModelRef<Root, Value, Encoded = unknown> {
10
14
  readonly dependency: readonly string[];
11
15
  readonly get: (root: Root) => Value;
12
16
  readonly set: (root: Root, value: Value) => Root;
17
+ /**
18
+ * Focused structural replacement: `set` of `fn` applied to `get`. This
19
+ * delegates through the ref's own `set`, so container-aware setters
20
+ * (`.at`/`.index` insertion and removal) keep working — never `optic`
21
+ * calls directly. Infrastructure seam, not an application transition.
22
+ */
23
+ readonly modify: (root: Root, fn: (value: Value) => Value) => Root;
13
24
  }
14
25
  /**
15
26
  * A `ModelRef` generated for a named Model field. `key` is the literal field
@@ -50,68 +61,11 @@ type RefNode<Root, S, Key extends string> = S extends Schema.Codec<infer A, infe
50
61
  readonly at: (key: K) => OptionalRef<Root, Option.Option<V>>;
51
62
  } : Selectable<Root, A, Key, Encoded> : never;
52
63
  export type DependencyTree = readonly (readonly string[])[];
53
- /**
54
- * A required slice of a remote entity, contributed by a remote `Projection`
55
- * node. This is dependency metadata, so it lives in Surface; Remote consumes it.
56
- * `windows` carries a pagination window per relation field (Remote's
57
- * `QueryWindow` is not visible here, so the shape is declared locally), and
58
- * `relations` carries the slice required of each relation's target, so one
59
- * requirement describes a whole selection graph.
60
- */
61
- export interface Window {
62
- readonly first?: number | undefined;
63
- readonly last?: number | undefined;
64
- readonly after?: string | undefined;
65
- readonly before?: string | undefined;
66
- }
67
- /** The slice required of a relation's target; its ids come from the refs. */
68
- export interface RelationRequirement {
69
- readonly entity: string;
70
- readonly fields: readonly string[];
71
- readonly windows?: Readonly<Record<string, Window>> | undefined;
72
- readonly relations?: Readonly<Record<string, RelationRequirement>> | undefined;
73
- }
74
- export interface Requirement extends RelationRequirement {
75
- readonly id: string;
76
- /** The projection also subscribes to changes of this entity (`Data.live`). */
77
- readonly live?: boolean | undefined;
78
- }
79
- /**
80
- * A query connection a projection reads: the page it first asks for and the
81
- * slice it selects of each item. `identity` is the connection's (query plus
82
- * canonical input, excluding the window); the packages that run queries
83
- * carry what they need to run it on the same object.
84
- */
85
- export interface ConnectionRequirement {
86
- readonly identity: string;
87
- readonly window: Window;
88
- readonly select: RelationRequirement;
89
- }
90
- /**
91
- * Merges connection requirements for the same connection and window into one,
92
- * unioning what they select of each item; the first keeps its other properties.
93
- */
94
- declare function mergeConnections(connections: readonly ConnectionRequirement[]): readonly ConnectionRequirement[];
95
- /** Unions two relation slices for the same target: fields, windows, and nested relations. */
96
- declare function mergeRelation(current: RelationRequirement, next: RelationRequirement): RelationRequirement;
97
- /** Unions requirements for the same entity + id, dropping duplicate fields. */
98
- declare function mergeRequirements(requirements: readonly Requirement[]): readonly Requirement[];
99
- /**
100
- * Requirement helpers, for the packages that plan and serve requirements.
101
- * `merge` unions same-entity+id requirements; `mergeRelation` unions two
102
- * slices of one target (fields, windows, nested relations).
103
- */
104
- export declare const Requirement: {
105
- merge: typeof mergeRequirements;
106
- mergeRelation: typeof mergeRelation;
107
- mergeConnections: typeof mergeConnections;
108
- };
109
64
  export interface Projection<Root, Value> {
110
- readonly Model: Schema.Schema<Value>;
65
+ readonly Model: Schema.Codec<Value, unknown>;
111
66
  readonly dependencies: DependencyTree;
112
- readonly requirements: readonly Requirement[];
113
- /** The query connections the projection reads; `[]` for most projections. */
114
- readonly connections: readonly ConnectionRequirement[];
67
+ /** Interpreter-owned facts about this node and everything it composes. */
68
+ readonly metadata: Metadata$1;
115
69
  readonly read: (root: Root) => Value;
116
70
  }
117
71
  /**
@@ -151,10 +105,9 @@ export declare const Projection: {
151
105
  * projections not derived from ModelRefs (agent context, adapters). Prefer
152
106
  * `of`/`struct`/`select`; dependencies default to empty.
153
107
  */
154
- fromReader: <Root, Value>(Model: Schema.Schema<Value>, read: (root: Root) => Value, options?: {
108
+ fromReader: <Root, Value>(Model: Schema.Codec<Value, unknown>, read: (root: Root) => Value, options?: {
155
109
  readonly dependencies?: DependencyTree;
156
- readonly requirements?: readonly Requirement[];
157
- readonly connections?: readonly ConnectionRequirement[];
110
+ readonly metadata?: Metadata$1;
158
111
  }) => Projection<Root, Value>;
159
112
  /**
160
113
  * Derives a writable projection from generated Model field references:
@@ -182,14 +135,22 @@ export interface AppScope<Root, F extends Schema.Struct.Fields, Cases extends Re
182
135
  export interface SurfaceInspection {
183
136
  readonly name: string;
184
137
  readonly dependencies: DependencyTree;
185
- readonly requirements: readonly Requirement[];
138
+ readonly metadata: readonly MetadataSummary$1[];
186
139
  readonly emits: readonly unknown[];
187
140
  }
141
+ /**
142
+ * A Surface's params codec: present when the Surface declares params, absent
143
+ * when `Params` is `void`, and possibly either when `Params` is `any`/`unknown`
144
+ * so a params Surface still fits a `Surface<…, any>` position.
145
+ */
146
+ export type ParamsSchema<Params> = unknown extends Params ? Schema.Codec<Params, unknown> | undefined : [Params] extends [void] ? [void] extends [Params] ? undefined // `undefined` also extends `void`, but a Surface may still declare its schema.
147
+ : Schema.Codec<Params, unknown> | undefined : [void] extends [Params] // `void | X`: the schema is optional.
148
+ ? Schema.Codec<Params, unknown> | undefined : Schema.Codec<Params, unknown>;
188
149
  export interface Surface<Root, Model, Message, Params> {
189
150
  readonly name: string;
190
151
  /** Identity token of the application this Surface belongs to. */
191
152
  readonly owner: object;
192
- readonly Params: Schema.Schema<Params> | undefined;
153
+ readonly Params: ParamsSchema<Params>;
193
154
  readonly Message: Schema.Schema<Message>;
194
155
  readonly messages: readonly unknown[];
195
156
  readonly projection: (params: Params) => Projection<Root, Model>;
@@ -353,7 +314,7 @@ export declare const Surface: {
353
314
  */
354
315
  at: <Root, Model, Message, Params>(surface: Surface<Root, Model, Message, Params>, params: Params | ((model: Root) => Params | undefined)) => ActiveSurface<Root>;
355
316
  make: <Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>, Params = void, Model = unknown, const Ms extends readonly MessageConstructor<Cases>[] = readonly []>(app: AppScope<Root, F, Cases>, name: string, config: {
356
- readonly Params?: Schema.Schema<Params>;
317
+ readonly Params?: Schema.Codec<Params, unknown>;
357
318
  readonly model: (context: {
358
319
  readonly model: RefTree<Root, F>;
359
320
  readonly params: Params;
@@ -405,7 +366,38 @@ export interface Contract {
405
366
  readonly observes: DependencyTree;
406
367
  /** Message tags the contract may cause, expose, or record. */
407
368
  readonly messages: readonly string[];
408
- readonly requirements: readonly Requirement[];
369
+ /** What interpreters attached to the contract's reads, as text. */
370
+ readonly metadata: readonly MetadataSummary$1[];
371
+ }
372
+ /**
373
+ * How one integration joins an application, as data and pure functions: the
374
+ * Messages it routes, what it runs at startup and on a URL change, its
375
+ * Subscriptions and Managed Resources, and its contract. Remote, Mirror, Sync,
376
+ * and Agent produce one; `foldkit-bundle`'s assembly derives the application's
377
+ * `update`, initial state, runtime config, and Module from a list of them.
378
+ * `R` is the services its Commands and Subscriptions need.
379
+ */
380
+ export interface Wiring<Model, Message, R = never> {
381
+ /** Names the integration in errors and the Module: `remote:Board`, `mirror:filters`. */
382
+ readonly key: string;
383
+ /** Message tags `route` handles. Two integrations handling one tag is an error unless it is `shared`. */
384
+ readonly handles: readonly string[];
385
+ /** Tags several integrations may handle, each for its own values (Mirror's `MirrorRestored`, by name). */
386
+ readonly shared?: readonly string[] | undefined;
387
+ /**
388
+ * Folds a Message this integration handles; `None` for any other. A method, so
389
+ * a wiring that routes only its own variants fits an assembly over the whole
390
+ * application union.
391
+ */
392
+ route?(model: Model, message: Message): Option.Option<Update.Return<Model, Message, R>>;
393
+ /** Runs once when the application starts, after placements: a restore Command, a warm-up. */
394
+ readonly init?: Update.Step<Model, Message, R> | undefined;
395
+ /** Applies the URL to the Model, at startup and whenever the URL changes. */
396
+ readonly onUrl?: ((model: Model, url: Url) => Model) | undefined;
397
+ readonly subscriptions?: Subscriptions<Model, Message, R> | undefined;
398
+ readonly resources?: Readonly<Record<string, Entry<Model, Message, any, any, any>>> | undefined;
399
+ /** Its Module contract; absent for wiring that owns and observes nothing. */
400
+ readonly contract?: Contract | undefined;
409
401
  }
410
402
  /** Contracts of one application, in declaration order. Data, not a runtime. */
411
403
  export interface Module<Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>> {
@@ -473,4 +465,5 @@ export declare const Module: {
473
465
  toMermaid: (module: Module<any, any, any>) => string;
474
466
  };
475
467
  //#endregion
468
+ export { Metadata, type MetadataKey, type MetadataSummary, MetadataTypeId };
476
469
  //# sourceMappingURL=index.d.mts.map
@@ -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,4 +1,5 @@
1
1
  import { Optic, Option, Result, Schema } from "effect";
2
+ import { Metadata, Metadata as Metadata$1, MetadataTypeId } from "foldkit-metadata";
2
3
  //#region src/index.ts
3
4
  /**
4
5
  * `foldkit-surface` — the observation boundary for a Foldkit application.
@@ -16,13 +17,18 @@ import { Optic, Option, Result, Schema } from "effect";
16
17
  * Low-level escape hatch for a focus with no Model path of its own. Prefer the
17
18
  * `App.model` tree; use this for an optic that is not part of the Model.
18
19
  */
19
- const ModelRef = { fromOptic: (Schema, optic, dependency = []) => ({
20
- Schema,
21
- optic,
22
- dependency,
23
- get: (root) => Result.getOrThrow(optic.getResult(root)),
24
- set: (root, value) => optic.replace(value, root)
25
- }) };
20
+ const ModelRef = { fromOptic: (Schema, optic, dependency = []) => {
21
+ const get = (root) => Result.getOrThrow(optic.getResult(root));
22
+ const set = (root, value) => optic.replace(value, root);
23
+ return {
24
+ Schema,
25
+ optic,
26
+ dependency,
27
+ get,
28
+ set,
29
+ modify: (root, fn) => set(root, fn(get(root)))
30
+ };
31
+ } };
26
32
  /**
27
33
  * Names that belong to the ModelRef surface. A Struct field with one of these
28
34
  * names would silently shadow a method, so building the tree rejects it.
@@ -60,7 +66,8 @@ function makeTree(schema, path, optic, get, optional = false, set, owner) {
60
66
  key: path[path.length - 1] ?? "",
61
67
  owner,
62
68
  get,
63
- set: setFocus
69
+ set: setFocus,
70
+ modify: (root, fn) => setFocus(root, fn(get(root)))
64
71
  };
65
72
  const fields = schema.fields;
66
73
  if (fields !== void 0) for (const key of Object.keys(fields)) {
@@ -85,7 +92,7 @@ function makeTree(schema, path, optic, get, optional = false, set, owner) {
85
92
  }, owner);
86
93
  node.select = (projection) => {
87
94
  const dependencies = mergeDependencies([path, ...projection.dependencies]);
88
- return optional ? makeProjection(Schema.Option(projection.Model), dependencies, projection.requirements, (root) => Option.map(get(root), (value) => projection.read(value)), projection.connections) : makeProjection(projection.Model, dependencies, projection.requirements, (root) => projection.read(get(root)), projection.connections);
95
+ return optional ? makeProjection(Schema.Option(projection.Model), dependencies, (root) => Option.map(get(root), (value) => projection.read(value)), projection.metadata) : makeProjection(projection.Model, dependencies, (root) => projection.read(get(root)), projection.metadata);
89
96
  };
90
97
  return node;
91
98
  }
@@ -101,94 +108,11 @@ function mergeDependencies(dependencies) {
101
108
  }
102
109
  return merged;
103
110
  }
104
- const windowKey = (window) => JSON.stringify([
105
- window.first ?? null,
106
- window.last ?? null,
107
- window.after ?? null,
108
- window.before ?? null
109
- ]);
110
- /**
111
- * Merges connection requirements for the same connection and window into one,
112
- * unioning what they select of each item; the first keeps its other properties.
113
- */
114
- function mergeConnections(connections) {
115
- const merged = /* @__PURE__ */ new Map();
116
- for (const connection of connections) {
117
- const key = `${connection.identity}\u0000${windowKey(connection.window)}`;
118
- const current = merged.get(key);
119
- merged.set(key, current === void 0 ? connection : {
120
- ...current,
121
- select: mergeRelation(current.select, connection.select)
122
- });
123
- }
124
- return [...merged.values()];
125
- }
126
- /** Unions two relation slices for the same target: fields, windows, and nested relations. */
127
- function mergeRelation(current, next) {
128
- const fields = [...current.fields];
129
- const seen = new Set(fields);
130
- for (const field of next.fields) {
131
- if (seen.has(field)) continue;
132
- seen.add(field);
133
- fields.push(field);
134
- }
135
- const windows = {
136
- ...current.windows,
137
- ...next.windows
138
- };
139
- const relations = mergeRelations(current.relations, next.relations);
140
- return {
141
- entity: current.entity,
142
- fields,
143
- ...Object.keys(windows).length === 0 ? {} : { windows },
144
- ...relations === void 0 ? {} : { relations }
145
- };
146
- }
147
- /** Unions two relation maps field by field; a field in both merges recursively. */
148
- function mergeRelations(current, next) {
149
- if (current === void 0) return next;
150
- if (next === void 0) return current;
151
- const merged = { ...current };
152
- for (const [field, relation] of Object.entries(next)) {
153
- const existing = merged[field];
154
- merged[field] = existing === void 0 ? relation : mergeRelation(existing, relation);
155
- }
156
- return merged;
157
- }
158
- /** Unions requirements for the same entity + id, dropping duplicate fields. */
159
- function mergeRequirements(requirements) {
160
- const grouped = /* @__PURE__ */ new Map();
161
- for (const requirement of requirements) {
162
- const key = `${requirement.entity}\u0000${requirement.id}`;
163
- const group = grouped.get(key);
164
- const live = group?.live === true || requirement.live === true;
165
- grouped.set(key, {
166
- ...mergeRelation(group ?? {
167
- entity: requirement.entity,
168
- fields: []
169
- }, requirement),
170
- id: requirement.id,
171
- ...live ? { live } : {}
172
- });
173
- }
174
- return [...grouped.values()];
175
- }
176
- /**
177
- * Requirement helpers, for the packages that plan and serve requirements.
178
- * `merge` unions same-entity+id requirements; `mergeRelation` unions two
179
- * slices of one target (fields, windows, nested relations).
180
- */
181
- const Requirement = {
182
- merge: mergeRequirements,
183
- mergeRelation,
184
- mergeConnections
185
- };
186
- function makeProjection(Model, dependencies, requirements, read, connections = []) {
111
+ function makeProjection(Model, dependencies, read, metadata = Metadata$1.empty) {
187
112
  return {
188
113
  Model,
189
114
  dependencies,
190
- requirements,
191
- connections,
115
+ metadata,
192
116
  read
193
117
  };
194
118
  }
@@ -204,8 +128,7 @@ const Projection = {
204
128
  of: (schema) => (selection) => {
205
129
  const picked = {};
206
130
  const dependencies = [];
207
- const requirements = [];
208
- const connections = [];
131
+ const metadata = [];
209
132
  const readers = [];
210
133
  for (const key of Object.keys(selection)) {
211
134
  const choice = selection[key];
@@ -216,8 +139,7 @@ const Projection = {
216
139
  const nested = choice;
217
140
  picked[key] = nested.Model;
218
141
  dependencies.push(...nested.dependencies);
219
- requirements.push(...nested.requirements);
220
- connections.push(...nested.connections);
142
+ metadata.push(nested.metadata);
221
143
  readers.push([key, (root) => nested.read(propertyReader(root, key))]);
222
144
  }
223
145
  }
@@ -226,21 +148,19 @@ const Projection = {
226
148
  for (const [key, reader] of readers) out[key] = reader(root);
227
149
  return out;
228
150
  };
229
- return makeProjection(objectSchema(picked), mergeDependencies(dependencies), mergeRequirements(requirements), read, mergeConnections(connections));
151
+ return makeProjection(objectSchema(picked), mergeDependencies(dependencies), read, Metadata$1.combine(metadata));
230
152
  },
231
153
  struct: (entries) => {
232
154
  const picked = {};
233
155
  const dependencies = [];
234
- const requirements = [];
235
- const connections = [];
156
+ const metadata = [];
236
157
  const readers = [];
237
158
  for (const key of Object.keys(entries)) {
238
159
  const entry = entries[key];
239
160
  if ("dependencies" in entry) {
240
161
  picked[key] = entry.Model;
241
162
  dependencies.push(...entry.dependencies);
242
- requirements.push(...entry.requirements);
243
- connections.push(...entry.connections);
163
+ metadata.push(entry.metadata);
244
164
  readers.push([key, entry.read]);
245
165
  } else {
246
166
  picked[key] = entry.Schema;
@@ -253,7 +173,7 @@ const Projection = {
253
173
  for (const [key, reader] of readers) out[key] = reader(root);
254
174
  return out;
255
175
  };
256
- return makeProjection(objectSchema(picked), mergeDependencies(dependencies), mergeRequirements(requirements), read, mergeConnections(connections));
176
+ return makeProjection(objectSchema(picked), mergeDependencies(dependencies), read, Metadata$1.combine(metadata));
257
177
  },
258
178
  /**
259
179
  * Maps a Projection over an array: `array(p): Projection<ReadonlyArray<Root>,
@@ -263,16 +183,14 @@ const Projection = {
263
183
  array: (projection) => ({
264
184
  Model: Schema.Array(projection.Model),
265
185
  dependencies: projection.dependencies,
266
- requirements: projection.requirements,
267
- connections: projection.connections,
186
+ metadata: projection.metadata,
268
187
  read: (root) => root.map((value) => projection.read(value))
269
188
  }),
270
189
  /** Maps a Projection inside an Option, preserving absence. */
271
190
  option: (projection) => ({
272
191
  Model: Schema.Option(projection.Model),
273
192
  dependencies: projection.dependencies,
274
- requirements: projection.requirements,
275
- connections: projection.connections,
193
+ metadata: projection.metadata,
276
194
  read: (root) => Option.map(root, (value) => projection.read(value))
277
195
  }),
278
196
  read: (projection, root) => projection.read(root),
@@ -284,8 +202,7 @@ const Projection = {
284
202
  fromReader: (Model, read, options) => ({
285
203
  Model,
286
204
  dependencies: options?.dependencies ?? [],
287
- requirements: options?.requirements ?? [],
288
- connections: options?.connections ?? [],
205
+ metadata: options?.metadata ?? Metadata$1.empty,
289
206
  read
290
207
  }),
291
208
  /**
@@ -356,7 +273,7 @@ const Projection = {
356
273
  };
357
274
  }
358
275
  };
359
- const isProjection = (value) => typeof value === "object" && value !== null && "read" in value && "requirements" in value;
276
+ const isProjection = (value) => typeof value === "object" && value !== null && typeof value.read === "function" && Metadata$1.is(value.metadata);
360
277
  const makeScope = (config) => {
361
278
  const owner = {};
362
279
  return {
@@ -502,7 +419,7 @@ const Surface = {
502
419
  owns: [],
503
420
  observes: projection.dependencies,
504
421
  messages: surface.messages.map(messageTag).filter((tag) => tag !== void 0),
505
- requirements: projection.requirements
422
+ metadata: Metadata$1.summarize(projection.metadata)
506
423
  };
507
424
  },
508
425
  /**
@@ -514,12 +431,14 @@ const Surface = {
514
431
  return {
515
432
  name: surface.name,
516
433
  dependencies: projection.dependencies,
517
- requirements: projection.requirements,
434
+ metadata: Metadata$1.summarize(projection.metadata),
518
435
  emits: surface.messages
519
436
  };
520
437
  }
521
438
  };
522
439
  const label = (contract) => `${contract.kind}:${contract.name}`;
440
+ /** Metadata summaries are application data (a query's input), so they cannot break the table. */
441
+ const tableCell = (text) => text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/\r\n?|\n/g, " ");
523
442
  const pathKey = (path) => path.join(".");
524
443
  const isPrefix = (prefix, path) => prefix.length <= path.length && prefix.every((segment, index) => segment === path[index]);
525
444
  const toContract = (item) => "contract" in item ? item.contract : "projection" in item ? Surface.contract(item, void 0) : item;
@@ -651,8 +570,8 @@ const Module = {
651
570
  const owner = row.owner === void 0 ? "LOCAL" : `${row.owner.kind.toUpperCase()} ${row.owner.name}`;
652
571
  lines.push(`${last ? "└── " : "├── "}${pathKey(row.path).padEnd(width)} ${owner}`);
653
572
  });
654
- lines.push("```", "", "| Contract | Owns | Observes | Messages | Requirements |", "| --- | --- | --- | --- | --- |");
655
- for (const contract of manifest.contracts) lines.push(`| ${contract.kind}:${contract.name} | ${contract.owns.map(pathKey).join(", ")} | ${contract.observes.map(pathKey).join(", ")} | ${contract.messages.join(", ")} | ${contract.requirements.map((r) => `${r.entity}:${r.id}`).join(", ")} |`);
573
+ lines.push("```", "", "| Contract | Owns | Observes | Messages | Metadata |", "| --- | --- | --- | --- | --- |");
574
+ for (const contract of manifest.contracts) lines.push(`| ${contract.kind}:${contract.name} | ${contract.owns.map(pathKey).join(", ")} | ${contract.observes.map(pathKey).join(", ")} | ${contract.messages.join(", ")} | ${tableCell(contract.metadata.map((summary) => `${summary.name}: ${summary.entries.join(", ")}`).join("; "))} |`);
656
575
  if (manifest.findings.length > 0) {
657
576
  lines.push("", "## Findings", "");
658
577
  for (const finding of manifest.findings) lines.push(`- **${finding.rule}** ${finding.message}`);
@@ -687,6 +606,6 @@ const Module = {
687
606
  }
688
607
  };
689
608
  //#endregion
690
- export { MessageSet, ModelRef, Module, Projection, Requirement, Surface };
609
+ export { MessageSet, Metadata, MetadataTypeId, ModelRef, Module, Projection, Surface };
691
610
 
692
611
  //# sourceMappingURL=index.mjs.map
@@ -1 +1 @@
1
- {"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-surface` — the observation boundary for a Foldkit application.\n *\n * A Surface is a pure projection of the Model: it declares which fields a\n * feature reads and which Messages it may construct, from the application's\n * own Schema rather than a second hand-written interface. `foldkit-remote`,\n * `foldkit-sync`, `foldkit-agent`, and `foldkit-mirror` all read this boundary,\n * and `Module` validates that each Model path has one owner.\n *\n * Nothing here runs: the deliverable is the type surface, pinned by\n * `test/inference.test-d.ts`.\n */\nimport { Optic, Option, Result, Schema } from 'effect'\nimport type { Html, HtmlBuilder } from 'foldkit/html'\nimport type { MessageUnion } from 'foldkit/message'\nimport type * as Update from 'foldkit/update'\n\n// ===========================================================================\n// ModelRef and the typed Model tree (Phase 0 cases 1)\n// ===========================================================================\n\nexport interface ModelRef<Root, Value, Encoded = unknown> {\n /** A pure codec: Foldkit Model fields carry no decoding or encoding services. */\n readonly Schema: Schema.Codec<Value, Encoded, never, never>\n readonly optic: Optic.Optional<Root, Value>\n readonly dependency: readonly string[]\n readonly get: (root: Root) => Value\n readonly set: (root: Root, value: Value) => Root\n}\n\n/**\n * A `ModelRef` generated for a named Model field. `key` is the literal field\n * name, so a reference-based selection can infer its output keys without a\n * parallel field registry or string paths.\n */\nexport interface FieldRef<\n Root,\n Value,\n Key extends string = string,\n Encoded = unknown,\n> extends ModelRef<Root, Value, Encoded> {\n readonly key: Key\n /** The application definition this field was generated from. */\n readonly owner: object\n}\n\n/**\n * Low-level escape hatch for a focus with no Model path of its own. Prefer the\n * `App.model` tree; use this for an optic that is not part of the Model.\n */\nexport const ModelRef = {\n fromOptic: <Root, Value>(\n Schema: Schema.Schema<Value>,\n optic: Optic.Optional<Root, Value>,\n dependency: readonly string[] = [],\n ): ModelRef<Root, Value> => ({\n Schema: Schema as unknown as ModelRef<Root, Value>['Schema'],\n optic,\n dependency,\n get: root => Result.getOrThrow(optic.getResult(root)),\n set: (root, value) => optic.replace(value, root),\n }),\n}\n\nexport type RefTree<Root, F extends Schema.Struct.Fields> = {\n readonly [K in keyof F & string]: RefNode<Root, F[K], K>\n}\n\n// Tuple-wrapped so the conditional is *non-distributive*: without it,\n// `Value = Option<V>` distributes over `None | Some<V>` and `.at()` would return\n// a union of two unrelated `ModelRef`s.\ntype Selectable<Root, Value, Key extends string, Encoded = unknown> = [Value] extends [\n Option.Option<infer Inner>,\n]\n ? FieldRef<Root, Value, Key, Encoded> & {\n readonly select: <P>(projection: Projection<Inner, P>) => Projection<Root, Option.Option<P>>\n }\n : FieldRef<Root, Value, Key, Encoded> & {\n readonly select: <P>(projection: Projection<Value, P>) => Projection<Root, P>\n }\n\n/**\n * A dynamic focus from `.at`/`.index`. Deliberately not a `FieldRef`: its key is\n * a record key or index, not a Model field, so a static `Projection.pick` cannot\n * infer a field name from it.\n */\ntype OptionalRef<Root, Value> = [Value] extends [Option.Option<infer Inner>]\n ? ModelRef<Root, Value> & {\n readonly select: <P>(projection: Projection<Inner, P>) => Projection<Root, Option.Option<P>>\n }\n : ModelRef<Root, Value> & {\n readonly select: <P>(projection: Projection<Value, P>) => Projection<Root, P>\n }\n\ntype RefNode<Root, S, Key extends string> =\n S extends Schema.Codec<infer A, infer Encoded, any, any>\n ? S extends Schema.Struct<infer F>\n ? Selectable<Root, A, Key, Encoded> & RefTree<Root, F>\n : A extends ReadonlyArray<infer E>\n ? Selectable<Root, A, Key, Encoded> & {\n readonly index: (index: number) => OptionalRef<Root, Option.Option<E>>\n }\n : A extends Readonly<Record<infer K extends string, infer V>>\n ? Selectable<Root, A, Key, Encoded> & {\n readonly at: (key: K) => OptionalRef<Root, Option.Option<V>>\n }\n : Selectable<Root, A, Key, Encoded>\n : never\n\ntype AnySchema = Schema.Schema<unknown>\n\n/**\n * Names that belong to the ModelRef surface. A Struct field with one of these\n * names would silently shadow a method, so building the tree rejects it.\n */\nconst RESERVED_REF_NAMES = new Set([\n 'Schema',\n 'optic',\n 'dependency',\n 'key',\n 'read',\n 'get',\n 'set',\n 'at',\n 'index',\n 'select',\n])\n\nfunction propertyReader(root: unknown, key: string): unknown {\n return root === null || root === undefined ? undefined : (root as Record<string, unknown>)[key]\n}\n\nfunction optionalReader(value: unknown): Option.Option<unknown> {\n return value === undefined ? Option.none() : Option.some(value)\n}\n\n/** Reads the tag off a Foldkit Message constructor without constructing one. */\nconst messageTag = (constructor: unknown): string | undefined => {\n const literal = (constructor as { fields?: { _tag?: { ast?: { literal?: unknown } } } }).fields\n ?._tag?.ast?.literal\n return typeof literal === 'string' ? literal : undefined\n}\n\nfunction makeTree(\n schema: AnySchema,\n path: readonly string[],\n optic: Optic.Optional<unknown, unknown>,\n get: (root: unknown) => unknown,\n optional = false,\n set: ((root: unknown, value: unknown) => unknown) | undefined,\n owner: object,\n): Record<string, unknown> {\n const erasedOptic = optic as {\n key(key: string): Optic.Optional<unknown, unknown>\n at(key: string): Optic.Optional<unknown, unknown>\n }\n // `Optic.at` cannot *insert* or *remove* an absent key (`replace` is a no-op\n // when the prism fails), so optional foci get container-aware setters below.\n const setFocus = set ?? ((root: unknown, value: unknown): unknown => optic.replace(value, root))\n const node: Record<string, unknown> = {\n Schema: schema,\n optic,\n dependency: path,\n key: path[path.length - 1] ?? '',\n owner,\n get,\n set: setFocus,\n }\n\n const fields = (schema as { readonly fields?: Schema.Struct.Fields }).fields\n if (fields !== undefined) {\n for (const key of Object.keys(fields)) {\n if (RESERVED_REF_NAMES.has(key)) {\n throw new Error(`Model field \"${key}\" is reserved by ModelRef`)\n }\n node[key] = makeTree(\n fields[key] as AnySchema,\n [...path, key],\n erasedOptic.key(key),\n root => propertyReader(get(root), key),\n false,\n undefined,\n owner,\n )\n }\n }\n\n node.at = (key: string) =>\n makeTree(\n schema,\n [...path, key],\n erasedOptic.at(key),\n root => optionalReader(propertyReader(get(root), key)),\n true,\n (root, value) => {\n const container = get(root) as Record<string, unknown>\n const option = value as Option.Option<unknown>\n if (Option.isSome(option)) {\n return setFocus(root, { ...container, [key]: option.value })\n }\n const { [key]: _removed, ...rest } = container\n return setFocus(root, rest)\n },\n owner,\n )\n node.index = (index: number) =>\n makeTree(\n schema,\n [...path, String(index)],\n optic,\n root =>\n optionalReader(\n Array.isArray(get(root)) ? (get(root) as ReadonlyArray<unknown>)[index] : undefined,\n ),\n true,\n (root, value) => {\n const array = (Array.isArray(get(root)) ? get(root) : []) as ReadonlyArray<unknown>\n const option = value as Option.Option<unknown>\n const next = Option.isSome(option)\n ? array.map((item, i) => (i === index ? option.value : item))\n : array.filter((_, i) => i !== index)\n return setFocus(root, next)\n },\n owner,\n )\n node.select = (projection: Projection<unknown, unknown>) => {\n const dependencies = mergeDependencies([path, ...projection.dependencies])\n return optional\n ? makeProjection(\n Schema.Option(projection.Model),\n dependencies,\n projection.requirements,\n root => Option.map(get(root) as Option.Option<unknown>, value => projection.read(value)),\n projection.connections,\n )\n : makeProjection(\n projection.Model,\n dependencies,\n projection.requirements,\n root => projection.read(get(root)),\n projection.connections,\n )\n }\n return node\n}\n\n// ===========================================================================\n// Projection (Phase 0 case 2)\n// ===========================================================================\n\nexport type DependencyTree = readonly (readonly string[])[]\n\n/** Unions dependency trees, dropping duplicates; the result is a set. */\nfunction mergeDependencies(dependencies: DependencyTree): DependencyTree {\n const seen = new Set<string>()\n const merged: (readonly string[])[] = []\n for (const dependency of dependencies) {\n const key = dependency.join('\\u0000')\n if (seen.has(key)) continue\n seen.add(key)\n merged.push(dependency)\n }\n return merged\n}\n\n/**\n * A required slice of a remote entity, contributed by a remote `Projection`\n * node. This is dependency metadata, so it lives in Surface; Remote consumes it.\n * `windows` carries a pagination window per relation field (Remote's\n * `QueryWindow` is not visible here, so the shape is declared locally), and\n * `relations` carries the slice required of each relation's target, so one\n * requirement describes a whole selection graph.\n */\nexport interface Window {\n readonly first?: number | undefined\n readonly last?: number | undefined\n readonly after?: string | undefined\n readonly before?: string | undefined\n}\n\n/** The slice required of a relation's target; its ids come from the refs. */\nexport interface RelationRequirement {\n readonly entity: string\n readonly fields: readonly string[]\n readonly windows?: Readonly<Record<string, Window>> | undefined\n readonly relations?: Readonly<Record<string, RelationRequirement>> | undefined\n}\n\nexport interface Requirement extends RelationRequirement {\n readonly id: string\n /** The projection also subscribes to changes of this entity (`Data.live`). */\n readonly live?: boolean | undefined\n}\n\n/**\n * A query connection a projection reads: the page it first asks for and the\n * slice it selects of each item. `identity` is the connection's (query plus\n * canonical input, excluding the window); the packages that run queries\n * carry what they need to run it on the same object.\n */\nexport interface ConnectionRequirement {\n readonly identity: string\n readonly window: Window\n readonly select: RelationRequirement\n}\n\nconst windowKey = (window: Window): string =>\n JSON.stringify([\n window.first ?? null,\n window.last ?? null,\n window.after ?? null,\n window.before ?? null,\n ])\n\n/**\n * Merges connection requirements for the same connection and window into one,\n * unioning what they select of each item; the first keeps its other properties.\n */\nfunction mergeConnections(\n connections: readonly ConnectionRequirement[],\n): readonly ConnectionRequirement[] {\n const merged = new Map<string, ConnectionRequirement>()\n for (const connection of connections) {\n const key = `${connection.identity}\\u0000${windowKey(connection.window)}`\n const current = merged.get(key)\n merged.set(\n key,\n current === undefined\n ? connection\n : { ...current, select: mergeRelation(current.select, connection.select) },\n )\n }\n return [...merged.values()]\n}\n\n/** Unions two relation slices for the same target: fields, windows, and nested relations. */\nfunction mergeRelation(\n current: RelationRequirement,\n next: RelationRequirement,\n): RelationRequirement {\n const fields = [...current.fields]\n const seen = new Set(fields)\n for (const field of next.fields) {\n if (seen.has(field)) continue\n seen.add(field)\n fields.push(field)\n }\n const windows = { ...current.windows, ...next.windows }\n const relations = mergeRelations(current.relations, next.relations)\n return {\n entity: current.entity,\n fields,\n ...(Object.keys(windows).length === 0 ? {} : { windows }),\n ...(relations === undefined ? {} : { relations }),\n }\n}\n\n/** Unions two relation maps field by field; a field in both merges recursively. */\nfunction mergeRelations(\n current: Readonly<Record<string, RelationRequirement>> | undefined,\n next: Readonly<Record<string, RelationRequirement>> | undefined,\n): Readonly<Record<string, RelationRequirement>> | undefined {\n if (current === undefined) return next\n if (next === undefined) return current\n const merged: Record<string, RelationRequirement> = { ...current }\n for (const [field, relation] of Object.entries(next)) {\n const existing = merged[field]\n merged[field] = existing === undefined ? relation : mergeRelation(existing, relation)\n }\n return merged\n}\n\n/** Unions requirements for the same entity + id, dropping duplicate fields. */\nfunction mergeRequirements(requirements: readonly Requirement[]): readonly Requirement[] {\n const grouped = new Map<string, Requirement>()\n for (const requirement of requirements) {\n const key = `${requirement.entity}\\u0000${requirement.id}`\n // Later windows win; a duplicate is a caller bug, not a merge policy.\n const group = grouped.get(key)\n const live = group?.live === true || requirement.live === true\n grouped.set(key, {\n ...mergeRelation(group ?? { entity: requirement.entity, fields: [] }, requirement),\n id: requirement.id,\n ...(live ? { live } : {}),\n })\n }\n return [...grouped.values()]\n}\n\n/**\n * Requirement helpers, for the packages that plan and serve requirements.\n * `merge` unions same-entity+id requirements; `mergeRelation` unions two\n * slices of one target (fields, windows, nested relations).\n */\nexport const Requirement = {\n merge: mergeRequirements,\n mergeRelation,\n mergeConnections,\n}\n\nexport interface Projection<Root, Value> {\n readonly Model: Schema.Schema<Value>\n readonly dependencies: DependencyTree\n readonly requirements: readonly Requirement[]\n /** The query connections the projection reads; `[]` for most projections. */\n readonly connections: readonly ConnectionRequirement[]\n readonly read: (root: Root) => Value\n}\n\n/**\n * A projection Surface can install back into a Model. Public reads use the\n * read-only `Projection`; only a writable selection carries installation.\n * `set` writes exactly the declared fields, so an excess field in an untrusted\n * value cannot reach local state.\n */\nexport interface WritableProjection<Model, Fields extends Schema.Struct.Fields> {\n readonly schema: Schema.Struct<Fields>\n readonly dependencies: DependencyTree\n readonly get: (model: Model) => Schema.Struct.Type<Fields>\n readonly set: (model: Model, shared: Schema.Struct.Type<Fields>) => Model\n}\n\nfunction makeProjection<Value>(\n Model: Schema.Schema<Value>,\n dependencies: DependencyTree,\n requirements: readonly Requirement[],\n read: (root: unknown) => Value,\n connections: readonly ConnectionRequirement[] = [],\n): Projection<unknown, Value> {\n return { Model, dependencies, requirements, connections, read }\n}\n\n/**\n * `Schema.Struct({})` is not an empty-object schema: it accepts `{foo:1}`, `[]`,\n * and `\"str\"` even with `onExcessProperty: 'error'`. A genuinely empty selection\n * needs a `never`-valued record.\n */\nfunction objectSchema(fields: Record<string, AnySchema>): AnySchema {\n return Object.keys(fields).length === 0\n ? Schema.Record(Schema.String, Schema.Never)\n : Schema.Struct(fields)\n}\n\ntype OfSelection<F extends Schema.Struct.Fields> = {\n readonly [K in keyof F]?: true | Projection<Schema.Schema.Type<F[K]>, unknown>\n}\n\ntype OfValue<F extends Schema.Struct.Fields, Sel> = {\n readonly [K in keyof Sel & keyof F]: Sel[K] extends true\n ? Schema.Schema.Type<F[K]>\n : Sel[K] extends Projection<any, infer V>\n ? V\n : never\n}\n\ntype EntryValue<E> =\n E extends Projection<any, infer V> ? V : E extends ModelRef<any, infer V> ? V : never\n\ntype EntryRoot<E> =\n E extends Projection<infer R, any> ? R : E extends ModelRef<infer R, any> ? R : never\n\ntype EntryRoots<Entries> = { readonly [K in keyof Entries]: EntryRoot<Entries[K]> }\n\n/** `true` when the union has more than one member. Used to reject mixed roots. */\ntype IsUnion<T, U = T> = [T] extends [never]\n ? false\n : T extends unknown\n ? [U] extends [T]\n ? false\n : true\n : never\n\ntype StructValue<Entries> = {\n readonly [K in keyof Entries]: EntryValue<Entries[K]>\n} extends infer Value\n ? { readonly [K in keyof Value]: Value[K] }\n : never\n\nexport const Projection = {\n of:\n <F extends Schema.Struct.Fields>(schema: Schema.Struct<F>) =>\n <const Sel extends OfSelection<F>>(\n selection: Sel,\n ): Projection<Schema.Struct.Type<F>, OfValue<F, Sel>> => {\n const picked: Record<string, AnySchema> = {}\n const dependencies: (readonly string[])[] = []\n const requirements: Requirement[] = []\n const connections: ConnectionRequirement[] = []\n const readers: (readonly [string, (root: unknown) => unknown])[] = []\n\n for (const key of Object.keys(selection)) {\n const choice = (selection as Record<string, unknown>)[key]\n if (choice === true) {\n picked[key] = schema.fields[key] as AnySchema\n readers.push([key, root => propertyReader(root, key)])\n } else {\n const nested = choice as Projection<unknown, unknown>\n picked[key] = nested.Model\n dependencies.push(...nested.dependencies)\n requirements.push(...nested.requirements)\n connections.push(...nested.connections)\n readers.push([key, root => nested.read(propertyReader(root, key))])\n }\n }\n\n const read = (root: unknown): unknown => {\n const out: Record<string, unknown> = {}\n for (const [key, reader] of readers) out[key] = reader(root)\n return out\n }\n return makeProjection(\n objectSchema(picked),\n mergeDependencies(dependencies),\n mergeRequirements(requirements),\n read,\n mergeConnections(connections),\n ) as unknown as Projection<Schema.Struct.Type<F>, OfValue<F, Sel>>\n },\n\n struct: <const Entries extends Record<string, Projection<any, any> | ModelRef<any, any>>>(\n entries: Entries & (IsUnion<EntryRoots<Entries>[keyof Entries]> extends true ? never : unknown),\n ): Projection<EntryRoot<Entries[keyof Entries]>, StructValue<Entries>> => {\n const picked: Record<string, AnySchema> = {}\n const dependencies: (readonly string[])[] = []\n const requirements: Requirement[] = []\n const connections: ConnectionRequirement[] = []\n const readers: (readonly [string, (root: unknown) => unknown])[] = []\n\n for (const key of Object.keys(entries)) {\n const entry = entries[key] as Projection<unknown, unknown> | ModelRef<unknown, unknown>\n if ('dependencies' in entry) {\n picked[key] = entry.Model\n dependencies.push(...entry.dependencies)\n requirements.push(...entry.requirements)\n connections.push(...entry.connections)\n readers.push([key, entry.read])\n } else {\n picked[key] = entry.Schema\n dependencies.push(entry.dependency)\n readers.push([key, entry.get])\n }\n }\n\n const read = (root: unknown): unknown => {\n const out: Record<string, unknown> = {}\n for (const [key, reader] of readers) out[key] = reader(root)\n return out\n }\n return makeProjection(\n objectSchema(picked),\n mergeDependencies(dependencies),\n mergeRequirements(requirements),\n read,\n mergeConnections(connections),\n ) as unknown as Projection<EntryRoot<Entries[keyof Entries]>, StructValue<Entries>>\n },\n\n /**\n * Maps a Projection over an array: `array(p): Projection<ReadonlyArray<Root>,\n * ReadonlyArray<Value>>`. Nesting is explicit (an array of arrays stays an\n * array of arrays); there is no flatten or double-wrap.\n */\n array: <Root, Value>(\n projection: Projection<Root, Value>,\n ): Projection<ReadonlyArray<Root>, ReadonlyArray<Value>> => ({\n Model: Schema.Array(projection.Model),\n dependencies: projection.dependencies,\n requirements: projection.requirements,\n connections: projection.connections,\n read: root => root.map(value => projection.read(value)),\n }),\n\n /** Maps a Projection inside an Option, preserving absence. */\n option: <Root, Value>(\n projection: Projection<Root, Value>,\n ): Projection<Option.Option<Root>, Option.Option<Value>> => ({\n Model: Schema.Option(projection.Model),\n dependencies: projection.dependencies,\n requirements: projection.requirements,\n connections: projection.connections,\n read: root => Option.map(root, value => projection.read(value)),\n }),\n\n read: <Root, Value>(projection: Projection<Root, Value>, root: Root): Value =>\n projection.read(root),\n\n /**\n * Low-level escape hatch: a Projection from a Schema and a reader, for\n * projections not derived from ModelRefs (agent context, adapters). Prefer\n * `of`/`struct`/`select`; dependencies default to empty.\n */\n fromReader: <Root, Value>(\n Model: Schema.Schema<Value>,\n read: (root: Root) => Value,\n options?: {\n readonly dependencies?: DependencyTree\n readonly requirements?: readonly Requirement[]\n readonly connections?: readonly ConnectionRequirement[]\n },\n ): Projection<Root, Value> => ({\n Model,\n dependencies: options?.dependencies ?? [],\n requirements: options?.requirements ?? [],\n connections: options?.connections ?? [],\n read,\n }),\n\n /**\n * Derives a writable projection from generated Model field references:\n * `Projection.pick(App.model.todos, App.model.selectedTodoId)` infers\n * `{ todos, selectedTodoId }` and its codec. Every reference must share one\n * Root; a raw optic or an unrelated application is rejected. Repeated\n * identical members deduplicate; a conflicting definition throws.\n */\n pick: <const Refs extends readonly FieldRef<any, any, string>[]>(\n ...refs: Refs & (IsUnion<RefRoots<Refs>[number]> extends true ? never : unknown)\n ): WritableProjection<RefRoots<Refs>[number], PickFields<Refs>> => {\n const selected = [...refs]\n // Two applications can have structurally identical Models, so the root type\n // check cannot separate them; the owner token can.\n const owner = selected[0]?.owner\n for (const ref of selected) {\n if (ref.owner !== owner) {\n throw new Error('Projection.pick: references from different applications')\n }\n }\n const fields: Record<string, AnySchema> = {}\n for (const ref of selected) {\n const existing = fields[ref.key]\n if (existing !== undefined) {\n if (existing === ref.Schema) continue\n throw new Error(`Projection.pick: conflicting definitions for \"${ref.key}\"`)\n }\n fields[ref.key] = ref.Schema\n }\n return {\n schema: objectSchema(fields) as never,\n dependencies: mergeDependencies(selected.map(ref => ref.dependency)),\n get: model => {\n const out: Record<string, unknown> = {}\n for (const ref of selected) out[ref.key] = ref.get(model as never)\n return out as never\n },\n set: (model, shared) => {\n let next = model\n for (const ref of selected)\n next = ref.set(next as never, (shared as Record<string, unknown>)[ref.key] as never)\n return next\n },\n }\n },\n\n /**\n * Merges disjoint writable projections into one: `Projection.compose(Todos,\n * Selection)`. Every projection must own the same Model; a field defined twice\n * with a different codec throws, while an identical definition deduplicates.\n * `set` installs each part, so composed fields keep their own write behaviour.\n */\n compose: <const Ps extends readonly WritableProjection<any, any>[]>(\n ...projections: Ps & (IsUnion<ProjectionModel<Ps[number]>> extends true ? never : unknown)\n ): WritableProjection<ProjectionModel<Ps[number]>, MergeFields<Ps>> => {\n const parts = [...projections]\n const fields: Record<string, AnySchema> = {}\n for (const part of parts) {\n for (const [key, codec] of Object.entries(part.schema.fields)) {\n const existing = fields[key]\n if (existing !== undefined) {\n if (existing === codec) continue\n throw new Error(`Projection.compose: conflicting definitions for \"${key}\"`)\n }\n fields[key] = codec as AnySchema\n }\n }\n return {\n schema: objectSchema(fields) as never,\n dependencies: mergeDependencies(parts.flatMap(part => [...part.dependencies])),\n get: model => {\n const out: Record<string, unknown> = {}\n for (const part of parts) Object.assign(out, part.get(model as never))\n return out as never\n },\n set: (model, shared) => {\n let next = model\n // Each part reads only its own fields from the merged value.\n for (const part of parts) next = part.set(next as never, shared as never)\n return next\n },\n }\n },\n}\n\n// ===========================================================================\n// Surface (Phase 0 case 3)\n// ===========================================================================\n\nexport interface AppScope<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n readonly model: RefTree<Root, F>\n /** Identity token shared by this application's references and subsets. */\n readonly owner: object\n}\n\nexport interface SurfaceInspection {\n readonly name: string\n readonly dependencies: DependencyTree\n readonly requirements: readonly Requirement[]\n readonly emits: readonly unknown[]\n}\n\nexport interface Surface<Root, Model, Message, Params> {\n readonly name: string\n /** Identity token of the application this Surface belongs to. */\n readonly owner: object\n readonly Params: Schema.Schema<Params> | undefined\n readonly Message: Schema.Schema<Message>\n readonly messages: readonly unknown[]\n readonly projection: (params: Params) => Projection<Root, Model>\n}\n\n/**\n * A Surface as the Model activates it: its params are a function of the Model\n * (`undefined` while inactive), so its requirements are too. `Surface.at`\n * builds one; a Subscription derives what to fetch, subscribe, and retain\n * from a list of them.\n */\nexport interface ActiveSurface<Root> {\n readonly name: string\n /** Identity token of the application the Surface belongs to. */\n readonly owner: object\n /** The projection for the params the Model gives, or `undefined` while inactive. */\n readonly projectionOf: (model: Root) => Projection<Root, unknown> | undefined\n}\n\ndeclare const invalid: unique symbol\n\n/**\n * A compile-time failure that names its cause. Intersected onto a parameter\n * type when a type-level check fails, so the error reads as one line\n * (`Property '[invalid]' is missing … required in type 'Invalid<\"…\">'`)\n * naming the descriptor, instead of a wall of structural mismatch.\n */\nexport interface Invalid<Message extends string> {\n readonly [invalid]: Message\n}\n\n/** The fields of a `Schema.Struct`, or a schema, where params are declared. */\ntype ParamsShape = Schema.Struct.Fields | Schema.Top\n\ntype ParamsOf<P> = P extends Schema.Top\n ? Schema.Schema.Type<P>\n : P extends Schema.Struct.Fields\n ? Schema.Struct.Type<P>\n : void\n\n/** What a Surface's `model` may return: a Projection, or an object of Projections and refs to lift. */\ntype ModelShape<Root> =\n Projection<Root, unknown> | Record<string, Projection<Root, any> | ModelRef<Root, any>>\n\ntype ModelOf<Root, R> = R extends Projection<Root, infer M> ? M : StructValue<R>\n\nconst isProjection = (value: unknown): value is Projection<unknown, unknown> =>\n typeof value === 'object' && value !== null && 'read' in value && 'requirements' in value\n\ntype MsgOf<Ms extends readonly unknown[]> = {\n readonly [K in keyof Ms]: Ms[K] extends (...args: never[]) => infer M ? M : never\n}[number]\n\n/** The union of Messages a tuple of constructors produces. */\ntype SubsetOf<Ms extends readonly unknown[]> = Ms[number] extends (...args: never[]) => infer M\n ? M\n : never\n\ntype AppMessage<Cases extends Record<string, Schema.Struct.Fields>> = Schema.Schema.Type<\n MessageUnion<Cases>\n>\n\n/** A Message constructor whose produced Message belongs to the App's universe. */\ntype MessageConstructor<Cases extends Record<string, Schema.Struct.Fields>> = (\n ...args: never[]\n) => AppMessage<Cases>\n\n/**\n * The renderer's builder: the real `HtmlBuilder` with its private\n * `MessageUniverse` phantom removed, so the renderer's `OnClick` accepts only\n * the Surface's Message subset. `HtmlBuilder<M>` stays invariant even without\n * the phantom (`OnClick` returns `{ message: M }`), so a superset builder is\n * not assignable to this; `Surface.view` casts, which is sound because the\n * renderer can only construct subset Messages and the real builder accepts the\n * superset.\n */\ntype ViewBuilder<Message> = Omit<HtmlBuilder<Message>, keyof HtmlBuilder<never> & symbol>\n\n/** A renderer for a Surface's projected Model, with its Message set narrowed. */\nexport type Renderer<Model, Message> = (model: Model, h: ViewBuilder<Message>) => Html\n\n/** `unknown` when `Sub` is a subtype of `Super`, `never` otherwise. */\ntype Subset<Sub, Super> = [Sub] extends [Super] ? unknown : never\n\ntype RefRoot<R> = R extends ModelRef<infer Root, any> ? Root : never\n\ntype RefRoots<Refs extends readonly unknown[]> = {\n readonly [K in keyof Refs]: RefRoot<Refs[K]>\n}\n\n/** The struct fields a reference selection produces, keyed by each ref's field. */\ntype PickFields<Refs extends readonly FieldRef<any, any, string>[]> = {\n readonly [R in Refs[number] as R['key']]: R['Schema']\n}\n\ntype ProjectionModel<P> = P extends WritableProjection<infer M, any> ? M : never\n\ntype ProjectionFields<P> = P extends WritableProjection<any, infer F> ? F : never\n\ntype Merge2<A, B> = {\n readonly [K in keyof A | keyof B]: K extends keyof A ? A[K] : K extends keyof B ? B[K] : never\n}\n\n/** Merges the fields of several projections; an overlapping key is rejected at runtime. */\nexport type MergeFields<Ps extends readonly WritableProjection<any, any>[]> = Ps extends readonly [\n infer Head extends WritableProjection<any, any>,\n ...infer Tail extends readonly WritableProjection<any, any>[],\n]\n ? Merge2<ProjectionFields<Head>, MergeFields<Tail>>\n : {}\n\n/**\n * An application definition: the Model and Message schemas and the generated\n * field references. It is data, not a running instance, so it can be inspected\n * without mounting anything. Context, replication, and validation all read the\n * same `App.fields` references.\n */\nexport interface Application<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> extends AppScope<Root, F, Cases> {\n /** Reference-based field selection: `App.fields.todos`. */\n readonly fields: RefTree<Root, F>\n /**\n * `Surface.make` with the mechanical wrappers lifted: `params` are the\n * fields of a `Schema.Struct` (or a schema), and `model` may return an\n * object of Projections and refs, which becomes `Projection.struct`.\n */\n readonly surface: <\n const Params extends ParamsShape | undefined = undefined,\n Shape extends ModelShape<Root> = Projection<Root, unknown>,\n const Ms extends readonly MessageConstructor<Cases>[] = readonly [],\n >(\n name: string,\n config: {\n readonly params?: Params\n readonly model: (context: {\n readonly model: RefTree<Root, F>\n readonly params: ParamsOf<Params>\n }) => Shape\n readonly messages?: Ms\n },\n ) => Surface<Root, ModelOf<Root, Shape>, MsgOf<Ms>, ParamsOf<Params>>\n}\n\n/**\n * An `Application` that also carries the initial Model and the transition\n * function, so a replicator can derive the initial shared value and replay.\n * `Resources` is whatever `update`'s Commands need.\n */\nexport interface RunnableApplication<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Resources = never,\n> extends Application<Root, F, Cases> {\n readonly initial: Root\n readonly update: (\n model: Root,\n message: Schema.Schema.Type<MessageUnion<Cases>>,\n ) => Update.Return<Root, Schema.Schema.Type<MessageUnion<Cases>>, Resources>\n}\n\ndeclare const messageSubsetRoot: unique symbol\n\n/**\n * A typed subset of one application's Messages: the selected constructors, a\n * codec for exactly those variants, and a runtime membership test. Surface does\n * not label a subset agent-visible, durable, or presence; `Agent` and `Sync`\n * attach their own policy to the same value.\n */\n/** The union of encoded types a tuple of constructor schemas produces. */\ntype SubsetEncoded<Ms extends readonly unknown[]> =\n Ms[number] extends Schema.Codec<any, infer Encoded, any, any> ? Encoded : never\n\nexport interface MessageSet<\n Root,\n Message,\n Subset extends Message,\n Ms extends readonly ((...args: never[]) => Message)[],\n Cases extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>,\n Encoded = unknown,\n> {\n /** Phantom owner, so a subset cannot be crossed between applications. */\n readonly [messageSubsetRoot]?: Root\n /** The application identity token, checked when subsets compose. */\n readonly owner: object\n readonly constructors: Ms\n /** A pure codec for exactly the selected variants. */\n readonly schema: Schema.Codec<Subset, Encoded, never, never>\n readonly tags: ReadonlySet<string>\n readonly includes: (message: Message) => message is Subset\n}\n\nconst makeScope = <\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n}): AppScope<Schema.Struct.Type<F>, F, Cases> => {\n // One token per application, so a selection cannot silently mix two\n // applications whose Models happen to be structurally identical.\n const owner: object = {}\n return {\n Model: config.Model,\n Message: config.Message,\n owner,\n model: makeTree(\n config.Model,\n [],\n Optic.id(),\n root => root,\n false,\n undefined,\n owner,\n ) as unknown as RefTree<Schema.Struct.Type<F>, F>,\n }\n}\n\n/**\n * Captures an application's pure references once. `initial` and `update` are\n * optional: an agent needs only the Model, Message, and field references, while\n * a replicator needs them to derive the initial shared value and replay. A\n * `RunnableApplication` is returned when both are supplied.\n */\nfunction application<\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Resources = never,\n ManagedResourceServices = never,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n readonly initial: Schema.Struct.Type<F>\n readonly update: (\n model: Schema.Struct.Type<F>,\n message: Schema.Schema.Type<MessageUnion<Cases>>,\n ) => Update.Return<\n Schema.Struct.Type<F>,\n Schema.Schema.Type<MessageUnion<Cases>>,\n Resources | ManagedResourceServices\n >\n}): RunnableApplication<Schema.Struct.Type<F>, F, Cases, Resources | ManagedResourceServices>\nfunction application<\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n}): Application<Schema.Struct.Type<F>, F, Cases>\nfunction application(config: any): any {\n const scope = makeScope(config)\n const surface = (\n name: string,\n surfaceConfig: {\n readonly params?: ParamsShape | undefined\n readonly model: (context: { readonly model: unknown; readonly params: unknown }) => unknown\n readonly messages?: readonly unknown[]\n },\n ) =>\n Surface.make(scope, name, {\n ...(surfaceConfig.params === undefined\n ? {}\n : {\n Params: Schema.isSchema(surfaceConfig.params)\n ? surfaceConfig.params\n : Schema.Struct(surfaceConfig.params),\n }),\n model: (context: { readonly model: unknown; readonly params: unknown }) => {\n const shape = surfaceConfig.model(context)\n return isProjection(shape) ? shape : Projection.struct(shape as never)\n },\n messages: surfaceConfig.messages,\n } as never)\n return { ...scope, initial: config.initial, fields: scope.model, update: config.update, surface }\n}\n\ntype ConstructorOfSubset<S> = S extends MessageSet<any, any, any, infer Ms, any> ? Ms : never\ntype ValueOfSubset<S> = S extends MessageSet<any, any, infer V, any, any> ? V : never\ntype RootOfSubset<S> = S extends MessageSet<infer R, any, any, any, any> ? R : never\ntype MessageOfSubset<S> = S extends MessageSet<any, infer M, any, any, any> ? M : never\ntype CasesOfSubset<S> = S extends MessageSet<any, any, any, any, infer C> ? C : never\n\ntype Concat<A extends readonly unknown[], B extends readonly unknown[]> = [...A, ...B]\n\n/** Concatenates the constructor tuples of several subsets, preserving each. */\nexport type MergeConstructors<Subs extends readonly MessageSet<any, any, any, any, any>[]> =\n Subs extends readonly [\n infer Head extends MessageSet<any, any, any, any, any>,\n ...infer Tail extends readonly MessageSet<any, any, any, any, any>[],\n ]\n ? Concat<ConstructorOfSubset<Head>, MergeConstructors<Tail>>\n : []\n\n/** Typed Message subsets of one application, by constructor reference. */\nexport const MessageSet = {\n /**\n * Selects a typed Message subset by constructor reference:\n * `MessageSet.make(App, [Message.CreatedTodo, Message.RenamedTodo])`. Each\n * constructor must be this application's own variant; a duplicate or a variant\n * from another union throws.\n */\n make: <\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n const Ms extends readonly MessageConstructor<Cases>[],\n >(\n app: AppScope<Root, F, Cases>,\n messages: Ms,\n ): MessageSet<\n Root,\n Schema.Schema.Type<MessageUnion<Cases>>,\n SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>>,\n Ms,\n Cases,\n SubsetEncoded<Ms>\n > => {\n const tags = new Set<string>()\n for (const constructor of messages) {\n const tag = messageTag(constructor)\n if (tag === undefined) {\n throw new Error('MessageSet.make: expected Message constructors')\n }\n if ((app.Message as unknown as Record<string, unknown>)[tag] !== constructor) {\n throw new Error(\n `MessageSet.make: \"${tag}\" is not a variant of this application's Message union`,\n )\n }\n if (tags.has(tag)) throw new Error(`MessageSet.make: duplicate \"${tag}\"`)\n tags.add(tag)\n }\n return {\n owner: app.owner,\n constructors: messages,\n schema: Schema.Union([...messages] as unknown as ReadonlyArray<\n Schema.Schema<unknown>\n >) as unknown as Schema.Codec<\n SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>>,\n SubsetEncoded<Ms>,\n never,\n never\n >,\n tags,\n includes: (message): message is SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>> =>\n tags.has((message as { readonly _tag?: string })._tag ?? ''),\n }\n },\n\n /**\n * Unions several Message subsets into one. Every subset must belong to the\n * same application; a tag declared twice throws. Disjoint feature modules can\n * each declare their own subset and compose them here.\n */\n union: <const Subs extends readonly MessageSet<any, any, any, any, any>[]>(\n ...subsets: Subs\n ): MessageSet<\n RootOfSubset<Subs[number]>,\n MessageOfSubset<Subs[number]>,\n ValueOfSubset<Subs[number]>,\n MergeConstructors<Subs>,\n CasesOfSubset<Subs[number]>,\n SubsetEncoded<MergeConstructors<Subs>>\n > => {\n const parts = [...subsets]\n const owner = parts[0]?.owner\n const tags = new Set<string>()\n const constructors: Array<Schema.Schema<unknown>> = []\n for (const part of parts) {\n if (part.owner !== owner) {\n throw new Error('MessageSet.union: subsets from different applications')\n }\n for (const constructor of part.constructors) {\n const tag = messageTag(constructor)\n if (tag === undefined) continue\n if (tags.has(tag)) throw new Error(`MessageSet.union: duplicate \"${tag}\"`)\n tags.add(tag)\n constructors.push(constructor as Schema.Schema<unknown>)\n }\n }\n return {\n owner: owner as object,\n constructors: constructors as never,\n schema: Schema.Union(constructors) as unknown as Schema.Codec<\n ValueOfSubset<Subs[number]>,\n SubsetEncoded<MergeConstructors<Subs>>,\n never,\n never\n >,\n tags,\n includes: (message): message is ValueOfSubset<Subs[number]> =>\n tags.has((message as { readonly _tag?: string })._tag ?? ''),\n }\n },\n}\n\nexport const Surface = {\n application,\n\n /**\n * A Surface as the Model activates it. `params` is the value, or a function\n * of the Model returning it (`undefined` while the Surface is inactive, e.g.\n * on another route); the Surface's requirements then follow the Model.\n */\n at: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params | ((model: Root) => Params | undefined),\n ): ActiveSurface<Root> => ({\n name: surface.name,\n owner: surface.owner,\n projectionOf: model => {\n const resolved =\n typeof params === 'function'\n ? (params as (model: Root) => Params | undefined)(model)\n : params\n return resolved === undefined && surface.Params !== undefined\n ? undefined\n : surface.projection(resolved as Params)\n },\n }),\n\n make: <\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Params = void,\n Model = unknown,\n const Ms extends readonly MessageConstructor<Cases>[] = readonly [],\n >(\n app: AppScope<Root, F, Cases>,\n name: string,\n config: {\n readonly Params?: Schema.Schema<Params>\n readonly model: (context: {\n readonly model: RefTree<Root, F>\n readonly params: Params\n }) => Projection<Root, Model>\n readonly messages?: Ms\n },\n ): Surface<Root, Model, MsgOf<Ms>, Params> => {\n // Deliberately no eager `projection(undefined)`: a parameterized Surface's\n // projection may read `params`.\n const projection = (params: Params): Projection<Root, Model> =>\n config.model({ model: app.model, params })\n return {\n name,\n owner: app.owner,\n Params: config.Params,\n Message: Schema.Never as unknown as Schema.Schema<MsgOf<Ms>>,\n messages: config.messages ?? [],\n projection,\n }\n },\n\n read: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n root: Root,\n params?: Params,\n ): Model => surface.projection(params as Params).read(root),\n\n /**\n * Binds a renderer to a Surface's projected Model and Message set. A\n * type-level binder: the renderer already has this shape, but `Model` and\n * `Message` are derived from the Surface instead of written by hand.\n */\n view: <Root, Model, Message, Params>(\n _surface: Surface<Root, Model, Message, Params>,\n render: Renderer<Model, Message>,\n ): Renderer<Model, Message> => render,\n\n /**\n * The application boundary: consume the Root Model, project it, and hand the\n * projected Model to the renderer. `Subset` rejects a Surface whose Messages\n * the application builder cannot route.\n */\n rootView: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n render: Renderer<Model, Message>,\n ): (<AppMessage>(\n root: Root,\n h: HtmlBuilder<AppMessage> & Subset<Message, AppMessage>,\n ) => Html) => {\n const projection = surface.projection(params)\n // Sound narrowing: the renderer can only construct this Surface's Messages,\n // and `Subset` guarantees the application builder accepts them.\n return <AppMessage>(\n root: Root,\n h: HtmlBuilder<AppMessage> & Subset<Message, AppMessage>,\n ): Html => render(projection.read(root), h as unknown as ViewBuilder<Message>)\n },\n\n /**\n * Embeds a child renderer in a parent view. `ParentModel extends ChildModel`\n * enforces \"child Model requirement ⊆ parent projected Model\"; `Subset`\n * enforces \"child Message set ⊆ parent Message set\".\n */\n embed:\n <ChildModel, ChildMessage>(child: Renderer<ChildModel, ChildMessage>) =>\n <ParentModel extends ChildModel, ParentMessage>(\n model: ParentModel,\n h: ViewBuilder<ParentMessage> & Subset<ChildMessage, ParentMessage>,\n ): Html =>\n child(model, h as unknown as ViewBuilder<ChildMessage>),\n\n /**\n * A Surface as a `Contract` for `Module`: what it observes, requires, and may\n * emit. A parameterized Surface needs its `params` to build the projection.\n */\n contract: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n ): Contract => {\n const projection = surface.projection(params)\n return {\n kind: 'surface',\n name: surface.name,\n owner: surface.owner,\n owns: [],\n observes: projection.dependencies,\n messages: surface.messages.map(messageTag).filter((tag): tag is string => tag !== undefined),\n requirements: projection.requirements,\n }\n },\n\n /**\n * Pure introspection for DevTools: what a Surface observes (dependencies,\n * requirements) and what it may emit. No behavior change, no I/O.\n */\n inspect: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n ): SurfaceInspection => {\n const projection = surface.projection(params)\n return {\n name: surface.name,\n dependencies: projection.dependencies,\n requirements: projection.requirements,\n emits: surface.messages,\n }\n },\n}\n\n// ===========================================================================\n// Entity, Selection, Remote moved to `foldkit-remote` (Phase 3).\n// ===========================================================================\n\n// ===========================================================================\n// Module: the pure composition root\n// ===========================================================================\n\n/**\n * What one contract claims about an application, as data. Sync, Remote, and\n * Agent attach one to the values they produce; `Surface.contract` derives one\n * from a Surface. `owns` are the Model paths the contract is the authority for\n * (a replicated projection, a remote store); `observes` are the paths it reads.\n */\nexport interface Contract {\n readonly kind: string\n readonly name: string\n /** The application's identity token; absent when the value cannot know it. */\n readonly owner?: object | undefined\n readonly owns: DependencyTree\n readonly observes: DependencyTree\n /** Message tags the contract may cause, expose, or record. */\n readonly messages: readonly string[]\n readonly requirements: readonly Requirement[]\n}\n\n/** Contracts of one application, in declaration order. Data, not a runtime. */\nexport interface Module<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> {\n readonly app: AppScope<Root, F, Cases>\n readonly contracts: readonly Contract[]\n}\n\nexport interface Finding {\n readonly rule:\n | 'foreign-contract'\n | 'duplicate-name'\n | 'ownership-overlap'\n | 'message-claimed-twice'\n | 'unknown-path'\n | 'unknown-message'\n /** `kind:name` of each contract involved. */\n readonly contracts: readonly string[]\n readonly message: string\n}\n\n/** Who owns a Model path; `undefined` is local state. */\nexport interface Ownership {\n readonly path: readonly string[]\n readonly owner: { readonly kind: string; readonly name: string } | undefined\n}\n\nexport interface ModuleManifest {\n readonly fields: readonly string[]\n readonly messages: readonly string[]\n readonly ownership: readonly Ownership[]\n readonly contracts: readonly Omit<Contract, 'owner'>[]\n readonly findings: readonly Finding[]\n}\n\n/** A value `Module.make` accepts: a contract, a value carrying one, or a Surface without params. */\nexport type ModuleItem<Root> =\n Contract | { readonly contract: Contract } | Surface<Root, any, any, void>\n\nconst label = (contract: Contract): string => `${contract.kind}:${contract.name}`\nconst pathKey = (path: readonly string[]): string => path.join('.')\nconst isPrefix = (prefix: readonly string[], path: readonly string[]): boolean =>\n prefix.length <= path.length && prefix.every((segment, index) => segment === path[index])\n\n// A carried contract wins: a sync contract also has a `projection` (writable, not a function).\nconst toContract = <Root>(item: ModuleItem<Root>): Contract =>\n 'contract' in item\n ? item.contract\n : 'projection' in item\n ? Surface.contract(item, undefined)\n : item\n\nconst applicationTags = (app: AppScope<any, any, any>): readonly string[] =>\n Object.entries(app.Message as unknown as Record<string, unknown>)\n .filter(([key, value]) => messageTag(value) === key)\n .map(([key]) => key)\n\n/** Contracts that own at least one path, with a stable label. */\nconst owners = (module: Module<any, any, any>) =>\n module.contracts.filter(contract => contract.owns.length > 0)\n\n/**\n * Collects an application's contracts as pure data so their relationships can\n * be validated and inspected without starting a runtime.\n *\n * ```ts\n * const Project = Module.make(App, [BoardSurface, ProjectSync, ProjectRemote, ProjectAgent])\n * Module.validate(Project) // findings, or []\n * Module.toMarkdown(Project)\n * ```\n */\nexport const Module = {\n make: <Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>>(\n app: AppScope<Root, F, Cases>,\n items: readonly ModuleItem<Root>[] = [],\n ): Module<Root, F, Cases> => ({ app, contracts: items.map(toContract) }),\n\n /** A new Module with more contracts; the input is unchanged. */\n add: <Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>>(\n module: Module<Root, F, Cases>,\n ...items: readonly ModuleItem<Root>[]\n ): Module<Root, F, Cases> => ({\n app: module.app,\n contracts: [...module.contracts, ...items.map(toContract)],\n }),\n\n /**\n * Cross-contract invariants the types cannot express: a contract from another\n * application, a duplicate `kind:name`, two owners of overlapping Model paths,\n * a Message recorded by two replication contracts, and a path or Message the\n * application does not declare.\n */\n validate: (module: Module<any, any, any>): readonly Finding[] => {\n const findings: Finding[] = []\n const fields = new Set(Object.keys(module.app.Model.fields))\n const tags = new Set(applicationTags(module.app))\n const seen = new Map<string, Contract>()\n\n for (const contract of module.contracts) {\n const name = label(contract)\n if (contract.owner !== undefined && contract.owner !== module.app.owner)\n findings.push({\n rule: 'foreign-contract',\n contracts: [name],\n message: `${name} belongs to a different application`,\n })\n const duplicate = seen.get(name)\n if (duplicate !== undefined && duplicate !== contract)\n findings.push({\n rule: 'duplicate-name',\n contracts: [name],\n message: `${name} is declared twice`,\n })\n seen.set(name, contract)\n for (const path of [...contract.owns, ...contract.observes]) {\n const head = path[0]\n if (head === undefined || !fields.has(head))\n findings.push({\n rule: 'unknown-path',\n contracts: [name],\n message: `${name} references \"${pathKey(path)}\", which is not a Model field`,\n })\n }\n for (const tag of contract.messages)\n if (!tags.has(tag))\n findings.push({\n rule: 'unknown-message',\n contracts: [name],\n message: `${name} names \"${tag}\", which is not a Message of this application`,\n })\n }\n\n // The same value listed twice is one owner, as `duplicate-name` treats it.\n const owning = [...new Set(owners(module))]\n for (let i = 0; i < owning.length; i += 1)\n for (let j = i + 1; j < owning.length; j += 1) {\n const a = owning[i]!\n const b = owning[j]!\n for (const pa of a.owns)\n for (const pb of b.owns)\n // An empty path is reported as `unknown-path`, not as owning everything.\n if (pa.length > 0 && pb.length > 0 && (isPrefix(pa, pb) || isPrefix(pb, pa)))\n findings.push({\n rule: 'ownership-overlap',\n contracts: [label(a), label(b)],\n message: `${label(a)} owns \"${pathKey(pa)}\" and ${label(b)} owns \"${pathKey(pb)}\"`,\n })\n }\n\n const recorded = new Map<string, Contract>()\n for (const contract of module.contracts.filter(contract => contract.kind === 'sync'))\n for (const tag of contract.messages) {\n const other = recorded.get(tag)\n if (other !== undefined && other !== contract)\n findings.push({\n rule: 'message-claimed-twice',\n contracts: [label(other), label(contract)],\n message: `\"${tag}\" is durable in both ${label(other)} and ${label(contract)}`,\n })\n else recorded.set(tag, contract)\n }\n\n return findings\n },\n\n /**\n * The application's fields and Messages, who owns each Model path (local when\n * no contract does), every contract, and the findings. Reproducible for a\n * given Module, so it can be committed and diffed.\n */\n manifest: (module: Module<any, any, any>): ModuleManifest => {\n const ownership: Ownership[] = []\n const owning = owners(module)\n for (const field of Object.keys(module.app.Model.fields)) {\n const claims = owning.flatMap(contract =>\n contract.owns\n .filter(path => path[0] === field)\n .map(path => ({ path, owner: { kind: contract.kind, name: contract.name } })),\n )\n const whole = claims.find(claim => claim.path.length === 1)\n if (whole !== undefined) ownership.push(whole)\n else {\n ownership.push({ path: [field], owner: undefined })\n ownership.push(...claims.sort((a, b) => pathKey(a.path).localeCompare(pathKey(b.path))))\n }\n }\n return {\n fields: Object.keys(module.app.Model.fields),\n messages: applicationTags(module.app),\n ownership,\n contracts: module.contracts.map(({ owner: _owner, ...rest }) => rest),\n findings: Module.validate(module),\n }\n },\n\n /** The manifest as Markdown: the ownership tree, a table of contracts, and findings. */\n toMarkdown: (module: Module<any, any, any>): string => {\n const manifest = Module.manifest(module)\n const lines: string[] = ['```text', 'Model']\n const width = Math.max(0, ...manifest.ownership.map(row => pathKey(row.path).length))\n manifest.ownership.forEach((row, index) => {\n const last = index === manifest.ownership.length - 1\n const owner =\n row.owner === undefined ? 'LOCAL' : `${row.owner.kind.toUpperCase()} ${row.owner.name}`\n lines.push(`${last ? '└── ' : '├── '}${pathKey(row.path).padEnd(width)} ${owner}`)\n })\n lines.push(\n '```',\n '',\n '| Contract | Owns | Observes | Messages | Requirements |',\n '| --- | --- | --- | --- | --- |',\n )\n for (const contract of manifest.contracts)\n lines.push(\n `| ${contract.kind}:${contract.name} | ${contract.owns.map(pathKey).join(', ')} | ${contract.observes.map(pathKey).join(', ')} | ${contract.messages.join(', ')} | ${contract.requirements.map(r => `${r.entity}:${r.id}`).join(', ')} |`,\n )\n if (manifest.findings.length > 0) {\n lines.push('', '## Findings', '')\n for (const finding of manifest.findings)\n lines.push(`- **${finding.rule}** ${finding.message}`)\n }\n return lines.join('\\n')\n },\n\n /**\n * The manifest as a Mermaid flowchart: Model fields in a subgraph, one node\n * per contract, a solid edge for ownership and a dotted edge for observation.\n */\n toMermaid: (module: Module<any, any, any>): string => {\n const manifest = Module.manifest(module)\n const lines = ['flowchart LR', ' subgraph Model']\n manifest.fields.forEach((field, index) => lines.push(` f${index}[\"${field}\"]`))\n lines.push(' end')\n // A path outside the Model (reported by `validate`) draws no edge.\n const fieldId = (path: readonly string[]): string | undefined => {\n const index = path.length === 0 ? -1 : manifest.fields.indexOf(path[0]!)\n return index < 0 ? undefined : `f${index}`\n }\n manifest.contracts.forEach((contract, index) => {\n lines.push(` c${index}[\"${contract.kind}:${contract.name}\"]`)\n for (const path of contract.owns) {\n const field = fieldId(path)\n if (field !== undefined) lines.push(` c${index} -->|owns| ${field}`)\n }\n for (const path of contract.observes) {\n const field = fieldId(path)\n if (field !== undefined && !contract.owns.some(owned => pathKey(owned) === pathKey(path)))\n lines.push(` c${index} -.-> ${field}`)\n }\n })\n return lines.join('\\n')\n },\n}\n"],"mappings":"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"}
1
+ {"version":3,"file":"index.mjs","names":["Metadata"],"sources":["../src/index.ts"],"sourcesContent":["/**\n * `foldkit-surface` — the observation boundary for a Foldkit application.\n *\n * A Surface is a pure projection of the Model: it declares which fields a\n * feature reads and which Messages it may construct, from the application's\n * own Schema rather than a second hand-written interface. `foldkit-remote`,\n * `foldkit-sync`, `foldkit-agent`, and `foldkit-mirror` all read this boundary,\n * and `Module` validates that each Model path has one owner.\n *\n * Nothing here runs: the deliverable is the type surface, pinned by\n * `test/inference.test-d.ts`.\n */\nimport { Optic, Option, Result, Schema } from 'effect'\nimport type { Html, HtmlBuilder } from 'foldkit/html'\nimport type { MessageUnion } from 'foldkit/message'\nimport type { Entry as ManagedResourceEntry } from 'foldkit/managedResource'\nimport type { Subscriptions } from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport type { Url } from 'foldkit/url'\nimport { Metadata, type MetadataSummary } from 'foldkit-metadata'\n\nexport { Metadata, MetadataTypeId, type MetadataKey, type MetadataSummary } from 'foldkit-metadata'\n\n// ===========================================================================\n// ModelRef and the typed Model tree (Phase 0 cases 1)\n// ===========================================================================\n\nexport interface ModelRef<Root, Value, Encoded = unknown> {\n /** A pure codec: Foldkit Model fields carry no decoding or encoding services. */\n readonly Schema: Schema.Codec<Value, Encoded, never, never>\n readonly optic: Optic.Optional<Root, Value>\n readonly dependency: readonly string[]\n readonly get: (root: Root) => Value\n readonly set: (root: Root, value: Value) => Root\n /**\n * Focused structural replacement: `set` of `fn` applied to `get`. This\n * delegates through the ref's own `set`, so container-aware setters\n * (`.at`/`.index` insertion and removal) keep working — never `optic`\n * calls directly. Infrastructure seam, not an application transition.\n */\n readonly modify: (root: Root, fn: (value: Value) => Value) => Root\n}\n\n/**\n * A `ModelRef` generated for a named Model field. `key` is the literal field\n * name, so a reference-based selection can infer its output keys without a\n * parallel field registry or string paths.\n */\nexport interface FieldRef<\n Root,\n Value,\n Key extends string = string,\n Encoded = unknown,\n> extends ModelRef<Root, Value, Encoded> {\n readonly key: Key\n /** The application definition this field was generated from. */\n readonly owner: object\n}\n\n/**\n * Low-level escape hatch for a focus with no Model path of its own. Prefer the\n * `App.model` tree; use this for an optic that is not part of the Model.\n */\nexport const ModelRef = {\n fromOptic: <Root, Value>(\n Schema: Schema.Schema<Value>,\n optic: Optic.Optional<Root, Value>,\n dependency: readonly string[] = [],\n ): ModelRef<Root, Value> => {\n const get: (root: Root) => Value = root => Result.getOrThrow(optic.getResult(root))\n const set = (root: Root, value: Value): Root => optic.replace(value, root)\n return {\n Schema: Schema as unknown as ModelRef<Root, Value>['Schema'],\n optic,\n dependency,\n get,\n set,\n modify: (root, fn) => set(root, fn(get(root))),\n }\n },\n}\n\nexport type RefTree<Root, F extends Schema.Struct.Fields> = {\n readonly [K in keyof F & string]: RefNode<Root, F[K], K>\n}\n\n// Tuple-wrapped so the conditional is *non-distributive*: without it,\n// `Value = Option<V>` distributes over `None | Some<V>` and `.at()` would return\n// a union of two unrelated `ModelRef`s.\ntype Selectable<Root, Value, Key extends string, Encoded = unknown> = [Value] extends [\n Option.Option<infer Inner>,\n]\n ? FieldRef<Root, Value, Key, Encoded> & {\n readonly select: <P>(projection: Projection<Inner, P>) => Projection<Root, Option.Option<P>>\n }\n : FieldRef<Root, Value, Key, Encoded> & {\n readonly select: <P>(projection: Projection<Value, P>) => Projection<Root, P>\n }\n\n/**\n * A dynamic focus from `.at`/`.index`. Deliberately not a `FieldRef`: its key is\n * a record key or index, not a Model field, so a static `Projection.pick` cannot\n * infer a field name from it.\n */\ntype OptionalRef<Root, Value> = [Value] extends [Option.Option<infer Inner>]\n ? ModelRef<Root, Value> & {\n readonly select: <P>(projection: Projection<Inner, P>) => Projection<Root, Option.Option<P>>\n }\n : ModelRef<Root, Value> & {\n readonly select: <P>(projection: Projection<Value, P>) => Projection<Root, P>\n }\n\ntype RefNode<Root, S, Key extends string> =\n S extends Schema.Codec<infer A, infer Encoded, any, any>\n ? S extends Schema.Struct<infer F>\n ? Selectable<Root, A, Key, Encoded> & RefTree<Root, F>\n : A extends ReadonlyArray<infer E>\n ? Selectable<Root, A, Key, Encoded> & {\n readonly index: (index: number) => OptionalRef<Root, Option.Option<E>>\n }\n : A extends Readonly<Record<infer K extends string, infer V>>\n ? Selectable<Root, A, Key, Encoded> & {\n readonly at: (key: K) => OptionalRef<Root, Option.Option<V>>\n }\n : Selectable<Root, A, Key, Encoded>\n : never\n\ntype AnySchema = Schema.Codec<unknown, unknown>\n\n/**\n * Names that belong to the ModelRef surface. A Struct field with one of these\n * names would silently shadow a method, so building the tree rejects it.\n */\nconst RESERVED_REF_NAMES = new Set([\n 'Schema',\n 'optic',\n 'dependency',\n 'key',\n 'read',\n 'get',\n 'set',\n 'at',\n 'index',\n 'select',\n])\n\nfunction propertyReader(root: unknown, key: string): unknown {\n return root === null || root === undefined ? undefined : (root as Record<string, unknown>)[key]\n}\n\nfunction optionalReader(value: unknown): Option.Option<unknown> {\n return value === undefined ? Option.none() : Option.some(value)\n}\n\n/** Reads the tag off a Foldkit Message constructor without constructing one. */\nconst messageTag = (constructor: unknown): string | undefined => {\n const literal = (constructor as { fields?: { _tag?: { ast?: { literal?: unknown } } } }).fields\n ?._tag?.ast?.literal\n return typeof literal === 'string' ? literal : undefined\n}\n\nfunction makeTree(\n schema: AnySchema,\n path: readonly string[],\n optic: Optic.Optional<unknown, unknown>,\n get: (root: unknown) => unknown,\n optional = false,\n set: ((root: unknown, value: unknown) => unknown) | undefined,\n owner: object,\n): Record<string, unknown> {\n const erasedOptic = optic as {\n key(key: string): Optic.Optional<unknown, unknown>\n at(key: string): Optic.Optional<unknown, unknown>\n }\n // `Optic.at` cannot *insert* or *remove* an absent key (`replace` is a no-op\n // when the prism fails), so optional foci get container-aware setters below.\n const setFocus = set ?? ((root: unknown, value: unknown): unknown => optic.replace(value, root))\n const node: Record<string, unknown> = {\n Schema: schema,\n optic,\n dependency: path,\n key: path[path.length - 1] ?? '',\n owner,\n get,\n set: setFocus,\n modify: (root: unknown, fn: (value: unknown) => unknown) => setFocus(root, fn(get(root))),\n }\n\n const fields = (schema as { readonly fields?: Schema.Struct.Fields }).fields\n if (fields !== undefined) {\n for (const key of Object.keys(fields)) {\n if (RESERVED_REF_NAMES.has(key)) {\n throw new Error(`Model field \"${key}\" is reserved by ModelRef`)\n }\n node[key] = makeTree(\n fields[key] as AnySchema,\n [...path, key],\n erasedOptic.key(key),\n root => propertyReader(get(root), key),\n false,\n undefined,\n owner,\n )\n }\n }\n\n node.at = (key: string) =>\n makeTree(\n schema,\n [...path, key],\n erasedOptic.at(key),\n root => optionalReader(propertyReader(get(root), key)),\n true,\n (root, value) => {\n const container = get(root) as Record<string, unknown>\n const option = value as Option.Option<unknown>\n if (Option.isSome(option)) {\n return setFocus(root, { ...container, [key]: option.value })\n }\n const { [key]: _removed, ...rest } = container\n return setFocus(root, rest)\n },\n owner,\n )\n node.index = (index: number) =>\n makeTree(\n schema,\n [...path, String(index)],\n optic,\n root =>\n optionalReader(\n Array.isArray(get(root)) ? (get(root) as ReadonlyArray<unknown>)[index] : undefined,\n ),\n true,\n (root, value) => {\n const array = (Array.isArray(get(root)) ? get(root) : []) as ReadonlyArray<unknown>\n const option = value as Option.Option<unknown>\n const next = Option.isSome(option)\n ? array.map((item, i) => (i === index ? option.value : item))\n : array.filter((_, i) => i !== index)\n return setFocus(root, next)\n },\n owner,\n )\n node.select = (projection: Projection<unknown, unknown>) => {\n const dependencies = mergeDependencies([path, ...projection.dependencies])\n return optional\n ? makeProjection(\n Schema.Option(projection.Model),\n dependencies,\n root => Option.map(get(root) as Option.Option<unknown>, value => projection.read(value)),\n projection.metadata,\n )\n : makeProjection(\n projection.Model,\n dependencies,\n root => projection.read(get(root)),\n projection.metadata,\n )\n }\n return node\n}\n\n// ===========================================================================\n// Projection (Phase 0 case 2)\n// ===========================================================================\n\nexport type DependencyTree = readonly (readonly string[])[]\n\n/** Unions dependency trees, dropping duplicates; the result is a set. */\nfunction mergeDependencies(dependencies: DependencyTree): DependencyTree {\n const seen = new Set<string>()\n const merged: (readonly string[])[] = []\n for (const dependency of dependencies) {\n const key = dependency.join('\\u0000')\n if (seen.has(key)) continue\n seen.add(key)\n merged.push(dependency)\n }\n return merged\n}\n\nexport interface Projection<Root, Value> {\n readonly Model: Schema.Codec<Value, unknown>\n readonly dependencies: DependencyTree\n /** Interpreter-owned facts about this node and everything it composes. */\n readonly metadata: Metadata\n readonly read: (root: Root) => Value\n}\n\n/**\n * A projection Surface can install back into a Model. Public reads use the\n * read-only `Projection`; only a writable selection carries installation.\n * `set` writes exactly the declared fields, so an excess field in an untrusted\n * value cannot reach local state.\n */\nexport interface WritableProjection<Model, Fields extends Schema.Struct.Fields> {\n readonly schema: Schema.Struct<Fields>\n readonly dependencies: DependencyTree\n readonly get: (model: Model) => Schema.Struct.Type<Fields>\n readonly set: (model: Model, shared: Schema.Struct.Type<Fields>) => Model\n}\n\nfunction makeProjection<Value>(\n Model: Schema.Codec<Value, unknown>,\n dependencies: DependencyTree,\n read: (root: unknown) => Value,\n metadata: Metadata = Metadata.empty,\n): Projection<unknown, Value> {\n return { Model, dependencies, metadata, read }\n}\n\n/**\n * `Schema.Struct({})` is not an empty-object schema: it accepts `{foo:1}`, `[]`,\n * and `\"str\"` even with `onExcessProperty: 'error'`. A genuinely empty selection\n * needs a `never`-valued record.\n */\nfunction objectSchema(fields: Record<string, AnySchema>): AnySchema {\n return Object.keys(fields).length === 0\n ? Schema.Record(Schema.String, Schema.Never)\n : Schema.Struct(fields)\n}\n\ntype OfSelection<F extends Schema.Struct.Fields> = {\n readonly [K in keyof F]?: true | Projection<Schema.Schema.Type<F[K]>, unknown>\n}\n\ntype OfValue<F extends Schema.Struct.Fields, Sel> = {\n readonly [K in keyof Sel & keyof F]: Sel[K] extends true\n ? Schema.Schema.Type<F[K]>\n : Sel[K] extends Projection<any, infer V>\n ? V\n : never\n}\n\ntype EntryValue<E> =\n E extends Projection<any, infer V> ? V : E extends ModelRef<any, infer V> ? V : never\n\ntype EntryRoot<E> =\n E extends Projection<infer R, any> ? R : E extends ModelRef<infer R, any> ? R : never\n\ntype EntryRoots<Entries> = { readonly [K in keyof Entries]: EntryRoot<Entries[K]> }\n\n/** `true` when the union has more than one member. Used to reject mixed roots. */\ntype IsUnion<T, U = T> = [T] extends [never]\n ? false\n : T extends unknown\n ? [U] extends [T]\n ? false\n : true\n : never\n\ntype StructValue<Entries> = {\n readonly [K in keyof Entries]: EntryValue<Entries[K]>\n} extends infer Value\n ? { readonly [K in keyof Value]: Value[K] }\n : never\n\nexport const Projection = {\n of:\n <F extends Schema.Struct.Fields>(schema: Schema.Struct<F>) =>\n <const Sel extends OfSelection<F>>(\n selection: Sel,\n ): Projection<Schema.Struct.Type<F>, OfValue<F, Sel>> => {\n const picked: Record<string, AnySchema> = {}\n const dependencies: (readonly string[])[] = []\n const metadata: Metadata[] = []\n const readers: (readonly [string, (root: unknown) => unknown])[] = []\n\n for (const key of Object.keys(selection)) {\n const choice = (selection as Record<string, unknown>)[key]\n if (choice === true) {\n picked[key] = schema.fields[key] as AnySchema\n readers.push([key, root => propertyReader(root, key)])\n } else {\n const nested = choice as Projection<unknown, unknown>\n picked[key] = nested.Model\n dependencies.push(...nested.dependencies)\n metadata.push(nested.metadata)\n readers.push([key, root => nested.read(propertyReader(root, key))])\n }\n }\n\n const read = (root: unknown): unknown => {\n const out: Record<string, unknown> = {}\n for (const [key, reader] of readers) out[key] = reader(root)\n return out\n }\n return makeProjection(\n objectSchema(picked),\n mergeDependencies(dependencies),\n read,\n Metadata.combine(metadata),\n ) as unknown as Projection<Schema.Struct.Type<F>, OfValue<F, Sel>>\n },\n\n struct: <const Entries extends Record<string, Projection<any, any> | ModelRef<any, any>>>(\n entries: Entries & (IsUnion<EntryRoots<Entries>[keyof Entries]> extends true ? never : unknown),\n ): Projection<EntryRoot<Entries[keyof Entries]>, StructValue<Entries>> => {\n const picked: Record<string, AnySchema> = {}\n const dependencies: (readonly string[])[] = []\n const metadata: Metadata[] = []\n const readers: (readonly [string, (root: unknown) => unknown])[] = []\n\n for (const key of Object.keys(entries)) {\n const entry = entries[key] as Projection<unknown, unknown> | ModelRef<unknown, unknown>\n if ('dependencies' in entry) {\n picked[key] = entry.Model\n dependencies.push(...entry.dependencies)\n metadata.push(entry.metadata)\n readers.push([key, entry.read])\n } else {\n picked[key] = entry.Schema\n dependencies.push(entry.dependency)\n readers.push([key, entry.get])\n }\n }\n\n const read = (root: unknown): unknown => {\n const out: Record<string, unknown> = {}\n for (const [key, reader] of readers) out[key] = reader(root)\n return out\n }\n return makeProjection(\n objectSchema(picked),\n mergeDependencies(dependencies),\n read,\n Metadata.combine(metadata),\n ) as unknown as Projection<EntryRoot<Entries[keyof Entries]>, StructValue<Entries>>\n },\n\n /**\n * Maps a Projection over an array: `array(p): Projection<ReadonlyArray<Root>,\n * ReadonlyArray<Value>>`. Nesting is explicit (an array of arrays stays an\n * array of arrays); there is no flatten or double-wrap.\n */\n array: <Root, Value>(\n projection: Projection<Root, Value>,\n ): Projection<ReadonlyArray<Root>, ReadonlyArray<Value>> => ({\n Model: Schema.Array(projection.Model),\n dependencies: projection.dependencies,\n metadata: projection.metadata,\n read: root => root.map(value => projection.read(value)),\n }),\n\n /** Maps a Projection inside an Option, preserving absence. */\n option: <Root, Value>(\n projection: Projection<Root, Value>,\n ): Projection<Option.Option<Root>, Option.Option<Value>> => ({\n Model: Schema.Option(projection.Model),\n dependencies: projection.dependencies,\n metadata: projection.metadata,\n read: root => Option.map(root, value => projection.read(value)),\n }),\n\n read: <Root, Value>(projection: Projection<Root, Value>, root: Root): Value =>\n projection.read(root),\n\n /**\n * Low-level escape hatch: a Projection from a Schema and a reader, for\n * projections not derived from ModelRefs (agent context, adapters). Prefer\n * `of`/`struct`/`select`; dependencies default to empty.\n */\n fromReader: <Root, Value>(\n Model: Schema.Codec<Value, unknown>,\n read: (root: Root) => Value,\n options?: {\n readonly dependencies?: DependencyTree\n readonly metadata?: Metadata\n },\n ): Projection<Root, Value> => ({\n Model,\n dependencies: options?.dependencies ?? [],\n metadata: options?.metadata ?? Metadata.empty,\n read,\n }),\n\n /**\n * Derives a writable projection from generated Model field references:\n * `Projection.pick(App.model.todos, App.model.selectedTodoId)` infers\n * `{ todos, selectedTodoId }` and its codec. Every reference must share one\n * Root; a raw optic or an unrelated application is rejected. Repeated\n * identical members deduplicate; a conflicting definition throws.\n */\n pick: <const Refs extends readonly FieldRef<any, any, string>[]>(\n ...refs: Refs & (IsUnion<RefRoots<Refs>[number]> extends true ? never : unknown)\n ): WritableProjection<RefRoots<Refs>[number], PickFields<Refs>> => {\n const selected = [...refs]\n // Two applications can have structurally identical Models, so the root type\n // check cannot separate them; the owner token can.\n const owner = selected[0]?.owner\n for (const ref of selected) {\n if (ref.owner !== owner) {\n throw new Error('Projection.pick: references from different applications')\n }\n }\n const fields: Record<string, AnySchema> = {}\n for (const ref of selected) {\n const existing = fields[ref.key]\n if (existing !== undefined) {\n if (existing === ref.Schema) continue\n throw new Error(`Projection.pick: conflicting definitions for \"${ref.key}\"`)\n }\n fields[ref.key] = ref.Schema\n }\n return {\n schema: objectSchema(fields) as never,\n dependencies: mergeDependencies(selected.map(ref => ref.dependency)),\n get: model => {\n const out: Record<string, unknown> = {}\n for (const ref of selected) out[ref.key] = ref.get(model as never)\n return out as never\n },\n set: (model, shared) => {\n let next = model\n for (const ref of selected)\n next = ref.set(next as never, (shared as Record<string, unknown>)[ref.key] as never)\n return next\n },\n }\n },\n\n /**\n * Merges disjoint writable projections into one: `Projection.compose(Todos,\n * Selection)`. Every projection must own the same Model; a field defined twice\n * with a different codec throws, while an identical definition deduplicates.\n * `set` installs each part, so composed fields keep their own write behaviour.\n */\n compose: <const Ps extends readonly WritableProjection<any, any>[]>(\n ...projections: Ps & (IsUnion<ProjectionModel<Ps[number]>> extends true ? never : unknown)\n ): WritableProjection<ProjectionModel<Ps[number]>, MergeFields<Ps>> => {\n const parts = [...projections]\n const fields: Record<string, AnySchema> = {}\n for (const part of parts) {\n for (const [key, codec] of Object.entries(part.schema.fields)) {\n const existing = fields[key]\n if (existing !== undefined) {\n if (existing === codec) continue\n throw new Error(`Projection.compose: conflicting definitions for \"${key}\"`)\n }\n fields[key] = codec as AnySchema\n }\n }\n return {\n schema: objectSchema(fields) as never,\n dependencies: mergeDependencies(parts.flatMap(part => [...part.dependencies])),\n get: model => {\n const out: Record<string, unknown> = {}\n for (const part of parts) Object.assign(out, part.get(model as never))\n return out as never\n },\n set: (model, shared) => {\n let next = model\n // Each part reads only its own fields from the merged value.\n for (const part of parts) next = part.set(next as never, shared as never)\n return next\n },\n }\n },\n}\n\n// ===========================================================================\n// Surface (Phase 0 case 3)\n// ===========================================================================\n\nexport interface AppScope<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n readonly model: RefTree<Root, F>\n /** Identity token shared by this application's references and subsets. */\n readonly owner: object\n}\n\nexport interface SurfaceInspection {\n readonly name: string\n readonly dependencies: DependencyTree\n readonly metadata: readonly MetadataSummary[]\n readonly emits: readonly unknown[]\n}\n\n/**\n * A Surface's params codec: present when the Surface declares params, absent\n * when `Params` is `void`, and possibly either when `Params` is `any`/`unknown`\n * so a params Surface still fits a `Surface<…, any>` position.\n */\nexport type ParamsSchema<Params> = unknown extends Params\n ? Schema.Codec<Params, unknown> | undefined\n : [Params] extends [void]\n ? [void] extends [Params]\n ? // Exactly `void`: no params, no schema.\n undefined\n : // `undefined` also extends `void`, but a Surface may still declare its schema.\n Schema.Codec<Params, unknown> | undefined\n : [void] extends [Params]\n ? // `void | X`: the schema is optional.\n Schema.Codec<Params, unknown> | undefined\n : Schema.Codec<Params, unknown>\n\nexport interface Surface<Root, Model, Message, Params> {\n readonly name: string\n /** Identity token of the application this Surface belongs to. */\n readonly owner: object\n readonly Params: ParamsSchema<Params>\n readonly Message: Schema.Schema<Message>\n readonly messages: readonly unknown[]\n readonly projection: (params: Params) => Projection<Root, Model>\n}\n\n/**\n * A Surface as the Model activates it: its params are a function of the Model\n * (`undefined` while inactive), so its requirements are too. `Surface.at`\n * builds one; a Subscription derives what to fetch, subscribe, and retain\n * from a list of them.\n */\nexport interface ActiveSurface<Root> {\n readonly name: string\n /** Identity token of the application the Surface belongs to. */\n readonly owner: object\n /** The projection for the params the Model gives, or `undefined` while inactive. */\n readonly projectionOf: (model: Root) => Projection<Root, unknown> | undefined\n}\n\ndeclare const invalid: unique symbol\n\n/**\n * A compile-time failure that names its cause. Intersected onto a parameter\n * type when a type-level check fails, so the error reads as one line\n * (`Property '[invalid]' is missing … required in type 'Invalid<\"…\">'`)\n * naming the descriptor, instead of a wall of structural mismatch.\n */\nexport interface Invalid<Message extends string> {\n readonly [invalid]: Message\n}\n\n/** The fields of a `Schema.Struct`, or a schema, where params are declared. */\ntype ParamsShape = Schema.Struct.Fields | Schema.Top\n\ntype ParamsOf<P> = P extends Schema.Top\n ? Schema.Schema.Type<P>\n : P extends Schema.Struct.Fields\n ? Schema.Struct.Type<P>\n : void\n\n/** What a Surface's `model` may return: a Projection, or an object of Projections and refs to lift. */\ntype ModelShape<Root> =\n Projection<Root, unknown> | Record<string, Projection<Root, any> | ModelRef<Root, any>>\n\ntype ModelOf<Root, R> = R extends Projection<Root, infer M> ? M : StructValue<R>\n\nconst isProjection = (value: unknown): value is Projection<unknown, unknown> =>\n typeof value === 'object' &&\n value !== null &&\n typeof (value as { read?: unknown }).read === 'function' &&\n Metadata.is((value as { metadata?: unknown }).metadata)\n\ntype MsgOf<Ms extends readonly unknown[]> = {\n readonly [K in keyof Ms]: Ms[K] extends (...args: never[]) => infer M ? M : never\n}[number]\n\n/** The union of Messages a tuple of constructors produces. */\ntype SubsetOf<Ms extends readonly unknown[]> = Ms[number] extends (...args: never[]) => infer M\n ? M\n : never\n\ntype AppMessage<Cases extends Record<string, Schema.Struct.Fields>> = Schema.Schema.Type<\n MessageUnion<Cases>\n>\n\n/** A Message constructor whose produced Message belongs to the App's universe. */\ntype MessageConstructor<Cases extends Record<string, Schema.Struct.Fields>> = (\n ...args: never[]\n) => AppMessage<Cases>\n\n/**\n * The renderer's builder: the real `HtmlBuilder` with its private\n * `MessageUniverse` phantom removed, so the renderer's `OnClick` accepts only\n * the Surface's Message subset. `HtmlBuilder<M>` stays invariant even without\n * the phantom (`OnClick` returns `{ message: M }`), so a superset builder is\n * not assignable to this; `Surface.view` casts, which is sound because the\n * renderer can only construct subset Messages and the real builder accepts the\n * superset.\n */\ntype ViewBuilder<Message> = Omit<HtmlBuilder<Message>, keyof HtmlBuilder<never> & symbol>\n\n/** A renderer for a Surface's projected Model, with its Message set narrowed. */\nexport type Renderer<Model, Message> = (model: Model, h: ViewBuilder<Message>) => Html\n\n/** `unknown` when `Sub` is a subtype of `Super`, `never` otherwise. */\ntype Subset<Sub, Super> = [Sub] extends [Super] ? unknown : never\n\ntype RefRoot<R> = R extends ModelRef<infer Root, any> ? Root : never\n\ntype RefRoots<Refs extends readonly unknown[]> = {\n readonly [K in keyof Refs]: RefRoot<Refs[K]>\n}\n\n/** The struct fields a reference selection produces, keyed by each ref's field. */\ntype PickFields<Refs extends readonly FieldRef<any, any, string>[]> = {\n readonly [R in Refs[number] as R['key']]: R['Schema']\n}\n\ntype ProjectionModel<P> = P extends WritableProjection<infer M, any> ? M : never\n\ntype ProjectionFields<P> = P extends WritableProjection<any, infer F> ? F : never\n\ntype Merge2<A, B> = {\n readonly [K in keyof A | keyof B]: K extends keyof A ? A[K] : K extends keyof B ? B[K] : never\n}\n\n/** Merges the fields of several projections; an overlapping key is rejected at runtime. */\nexport type MergeFields<Ps extends readonly WritableProjection<any, any>[]> = Ps extends readonly [\n infer Head extends WritableProjection<any, any>,\n ...infer Tail extends readonly WritableProjection<any, any>[],\n]\n ? Merge2<ProjectionFields<Head>, MergeFields<Tail>>\n : {}\n\n/**\n * An application definition: the Model and Message schemas and the generated\n * field references. It is data, not a running instance, so it can be inspected\n * without mounting anything. Context, replication, and validation all read the\n * same `App.fields` references.\n */\nexport interface Application<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> extends AppScope<Root, F, Cases> {\n /** Reference-based field selection: `App.fields.todos`. */\n readonly fields: RefTree<Root, F>\n /**\n * `Surface.make` with the mechanical wrappers lifted: `params` are the\n * fields of a `Schema.Struct` (or a schema), and `model` may return an\n * object of Projections and refs, which becomes `Projection.struct`.\n */\n readonly surface: <\n const Params extends ParamsShape | undefined = undefined,\n Shape extends ModelShape<Root> = Projection<Root, unknown>,\n const Ms extends readonly MessageConstructor<Cases>[] = readonly [],\n >(\n name: string,\n config: {\n readonly params?: Params\n readonly model: (context: {\n readonly model: RefTree<Root, F>\n readonly params: ParamsOf<Params>\n }) => Shape\n readonly messages?: Ms\n },\n ) => Surface<Root, ModelOf<Root, Shape>, MsgOf<Ms>, ParamsOf<Params>>\n}\n\n/**\n * An `Application` that also carries the initial Model and the transition\n * function, so a replicator can derive the initial shared value and replay.\n * `Resources` is whatever `update`'s Commands need.\n */\nexport interface RunnableApplication<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Resources = never,\n> extends Application<Root, F, Cases> {\n readonly initial: Root\n readonly update: (\n model: Root,\n message: Schema.Schema.Type<MessageUnion<Cases>>,\n ) => Update.Return<Root, Schema.Schema.Type<MessageUnion<Cases>>, Resources>\n}\n\ndeclare const messageSubsetRoot: unique symbol\n\n/**\n * A typed subset of one application's Messages: the selected constructors, a\n * codec for exactly those variants, and a runtime membership test. Surface does\n * not label a subset agent-visible, durable, or presence; `Agent` and `Sync`\n * attach their own policy to the same value.\n */\n/** The union of encoded types a tuple of constructor schemas produces. */\ntype SubsetEncoded<Ms extends readonly unknown[]> =\n Ms[number] extends Schema.Codec<any, infer Encoded, any, any> ? Encoded : never\n\nexport interface MessageSet<\n Root,\n Message,\n Subset extends Message,\n Ms extends readonly ((...args: never[]) => Message)[],\n Cases extends Record<string, Schema.Struct.Fields> = Record<string, Schema.Struct.Fields>,\n Encoded = unknown,\n> {\n /** Phantom owner, so a subset cannot be crossed between applications. */\n readonly [messageSubsetRoot]?: Root\n /** The application identity token, checked when subsets compose. */\n readonly owner: object\n readonly constructors: Ms\n /** A pure codec for exactly the selected variants. */\n readonly schema: Schema.Codec<Subset, Encoded, never, never>\n readonly tags: ReadonlySet<string>\n readonly includes: (message: Message) => message is Subset\n}\n\nconst makeScope = <\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n}): AppScope<Schema.Struct.Type<F>, F, Cases> => {\n // One token per application, so a selection cannot silently mix two\n // applications whose Models happen to be structurally identical.\n const owner: object = {}\n return {\n Model: config.Model,\n Message: config.Message,\n owner,\n model: makeTree(\n // A generic `F` hides the Struct's services; a Foldkit Model is pure.\n config.Model as unknown as AnySchema,\n [],\n Optic.id(),\n root => root,\n false,\n undefined,\n owner,\n ) as unknown as RefTree<Schema.Struct.Type<F>, F>,\n }\n}\n\n/**\n * Captures an application's pure references once. `initial` and `update` are\n * optional: an agent needs only the Model, Message, and field references, while\n * a replicator needs them to derive the initial shared value and replay. A\n * `RunnableApplication` is returned when both are supplied.\n */\nfunction application<\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Resources = never,\n ManagedResourceServices = never,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n readonly initial: Schema.Struct.Type<F>\n readonly update: (\n model: Schema.Struct.Type<F>,\n message: Schema.Schema.Type<MessageUnion<Cases>>,\n ) => Update.Return<\n Schema.Struct.Type<F>,\n Schema.Schema.Type<MessageUnion<Cases>>,\n Resources | ManagedResourceServices\n >\n}): RunnableApplication<Schema.Struct.Type<F>, F, Cases, Resources | ManagedResourceServices>\nfunction application<\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n>(config: {\n readonly Model: Schema.Struct<F>\n readonly Message: MessageUnion<Cases>\n}): Application<Schema.Struct.Type<F>, F, Cases>\nfunction application(config: any): any {\n const scope = makeScope(config)\n const surface = (\n name: string,\n surfaceConfig: {\n readonly params?: ParamsShape | undefined\n readonly model: (context: { readonly model: unknown; readonly params: unknown }) => unknown\n readonly messages?: readonly unknown[]\n },\n ) =>\n Surface.make(scope, name, {\n ...(surfaceConfig.params === undefined\n ? {}\n : {\n Params: Schema.isSchema(surfaceConfig.params)\n ? surfaceConfig.params\n : Schema.Struct(surfaceConfig.params),\n }),\n model: (context: { readonly model: unknown; readonly params: unknown }) => {\n const shape = surfaceConfig.model(context)\n return isProjection(shape) ? shape : Projection.struct(shape as never)\n },\n messages: surfaceConfig.messages,\n } as never)\n return { ...scope, initial: config.initial, fields: scope.model, update: config.update, surface }\n}\n\ntype ConstructorOfSubset<S> = S extends MessageSet<any, any, any, infer Ms, any> ? Ms : never\ntype ValueOfSubset<S> = S extends MessageSet<any, any, infer V, any, any> ? V : never\ntype RootOfSubset<S> = S extends MessageSet<infer R, any, any, any, any> ? R : never\ntype MessageOfSubset<S> = S extends MessageSet<any, infer M, any, any, any> ? M : never\ntype CasesOfSubset<S> = S extends MessageSet<any, any, any, any, infer C> ? C : never\n\ntype Concat<A extends readonly unknown[], B extends readonly unknown[]> = [...A, ...B]\n\n/** Concatenates the constructor tuples of several subsets, preserving each. */\nexport type MergeConstructors<Subs extends readonly MessageSet<any, any, any, any, any>[]> =\n Subs extends readonly [\n infer Head extends MessageSet<any, any, any, any, any>,\n ...infer Tail extends readonly MessageSet<any, any, any, any, any>[],\n ]\n ? Concat<ConstructorOfSubset<Head>, MergeConstructors<Tail>>\n : []\n\n/** Typed Message subsets of one application, by constructor reference. */\nexport const MessageSet = {\n /**\n * Selects a typed Message subset by constructor reference:\n * `MessageSet.make(App, [Message.CreatedTodo, Message.RenamedTodo])`. Each\n * constructor must be this application's own variant; a duplicate or a variant\n * from another union throws.\n */\n make: <\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n const Ms extends readonly MessageConstructor<Cases>[],\n >(\n app: AppScope<Root, F, Cases>,\n messages: Ms,\n ): MessageSet<\n Root,\n Schema.Schema.Type<MessageUnion<Cases>>,\n SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>>,\n Ms,\n Cases,\n SubsetEncoded<Ms>\n > => {\n const tags = new Set<string>()\n for (const constructor of messages) {\n const tag = messageTag(constructor)\n if (tag === undefined) {\n throw new Error('MessageSet.make: expected Message constructors')\n }\n if ((app.Message as unknown as Record<string, unknown>)[tag] !== constructor) {\n throw new Error(\n `MessageSet.make: \"${tag}\" is not a variant of this application's Message union`,\n )\n }\n if (tags.has(tag)) throw new Error(`MessageSet.make: duplicate \"${tag}\"`)\n tags.add(tag)\n }\n return {\n owner: app.owner,\n constructors: messages,\n schema: Schema.Union([...messages] as unknown as ReadonlyArray<\n Schema.Schema<unknown>\n >) as unknown as Schema.Codec<\n SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>>,\n SubsetEncoded<Ms>,\n never,\n never\n >,\n tags,\n includes: (message): message is SubsetOf<Ms> & Schema.Schema.Type<MessageUnion<Cases>> =>\n tags.has((message as { readonly _tag?: string })._tag ?? ''),\n }\n },\n\n /**\n * Unions several Message subsets into one. Every subset must belong to the\n * same application; a tag declared twice throws. Disjoint feature modules can\n * each declare their own subset and compose them here.\n */\n union: <const Subs extends readonly MessageSet<any, any, any, any, any>[]>(\n ...subsets: Subs\n ): MessageSet<\n RootOfSubset<Subs[number]>,\n MessageOfSubset<Subs[number]>,\n ValueOfSubset<Subs[number]>,\n MergeConstructors<Subs>,\n CasesOfSubset<Subs[number]>,\n SubsetEncoded<MergeConstructors<Subs>>\n > => {\n const parts = [...subsets]\n const owner = parts[0]?.owner\n const tags = new Set<string>()\n const constructors: Array<Schema.Schema<unknown>> = []\n for (const part of parts) {\n if (part.owner !== owner) {\n throw new Error('MessageSet.union: subsets from different applications')\n }\n for (const constructor of part.constructors) {\n const tag = messageTag(constructor)\n if (tag === undefined) continue\n if (tags.has(tag)) throw new Error(`MessageSet.union: duplicate \"${tag}\"`)\n tags.add(tag)\n constructors.push(constructor as Schema.Schema<unknown>)\n }\n }\n return {\n owner: owner as object,\n constructors: constructors as never,\n schema: Schema.Union(constructors) as unknown as Schema.Codec<\n ValueOfSubset<Subs[number]>,\n SubsetEncoded<MergeConstructors<Subs>>,\n never,\n never\n >,\n tags,\n includes: (message): message is ValueOfSubset<Subs[number]> =>\n tags.has((message as { readonly _tag?: string })._tag ?? ''),\n }\n },\n}\n\nexport const Surface = {\n application,\n\n /**\n * A Surface as the Model activates it. `params` is the value, or a function\n * of the Model returning it (`undefined` while the Surface is inactive, e.g.\n * on another route); the Surface's requirements then follow the Model.\n */\n at: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params | ((model: Root) => Params | undefined),\n ): ActiveSurface<Root> => ({\n name: surface.name,\n owner: surface.owner,\n projectionOf: model => {\n const resolved =\n typeof params === 'function'\n ? (params as (model: Root) => Params | undefined)(model)\n : params\n return resolved === undefined && surface.Params !== undefined\n ? undefined\n : surface.projection(resolved as Params)\n },\n }),\n\n make: <\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n Params = void,\n Model = unknown,\n const Ms extends readonly MessageConstructor<Cases>[] = readonly [],\n >(\n app: AppScope<Root, F, Cases>,\n name: string,\n config: {\n readonly Params?: Schema.Codec<Params, unknown>\n readonly model: (context: {\n readonly model: RefTree<Root, F>\n readonly params: Params\n }) => Projection<Root, Model>\n readonly messages?: Ms\n },\n ): Surface<Root, Model, MsgOf<Ms>, Params> => {\n // Deliberately no eager `projection(undefined)`: a parameterized Surface's\n // projection may read `params`.\n const projection = (params: Params): Projection<Root, Model> =>\n config.model({ model: app.model, params })\n return {\n name,\n owner: app.owner,\n // Absent only when `Params` is exactly `void`; `ParamsSchema` keeps it optional otherwise.\n Params: config.Params as ParamsSchema<Params>,\n Message: Schema.Never as unknown as Schema.Schema<MsgOf<Ms>>,\n messages: config.messages ?? [],\n projection,\n }\n },\n\n read: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n root: Root,\n params?: Params,\n ): Model => surface.projection(params as Params).read(root),\n\n /**\n * Binds a renderer to a Surface's projected Model and Message set. A\n * type-level binder: the renderer already has this shape, but `Model` and\n * `Message` are derived from the Surface instead of written by hand.\n */\n view: <Root, Model, Message, Params>(\n _surface: Surface<Root, Model, Message, Params>,\n render: Renderer<Model, Message>,\n ): Renderer<Model, Message> => render,\n\n /**\n * The application boundary: consume the Root Model, project it, and hand the\n * projected Model to the renderer. `Subset` rejects a Surface whose Messages\n * the application builder cannot route.\n */\n rootView: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n render: Renderer<Model, Message>,\n ): (<AppMessage>(\n root: Root,\n h: HtmlBuilder<AppMessage> & Subset<Message, AppMessage>,\n ) => Html) => {\n const projection = surface.projection(params)\n // Sound narrowing: the renderer can only construct this Surface's Messages,\n // and `Subset` guarantees the application builder accepts them.\n return <AppMessage>(\n root: Root,\n h: HtmlBuilder<AppMessage> & Subset<Message, AppMessage>,\n ): Html => render(projection.read(root), h as unknown as ViewBuilder<Message>)\n },\n\n /**\n * Embeds a child renderer in a parent view. `ParentModel extends ChildModel`\n * enforces \"child Model requirement ⊆ parent projected Model\"; `Subset`\n * enforces \"child Message set ⊆ parent Message set\".\n */\n embed:\n <ChildModel, ChildMessage>(child: Renderer<ChildModel, ChildMessage>) =>\n <ParentModel extends ChildModel, ParentMessage>(\n model: ParentModel,\n h: ViewBuilder<ParentMessage> & Subset<ChildMessage, ParentMessage>,\n ): Html =>\n child(model, h as unknown as ViewBuilder<ChildMessage>),\n\n /**\n * A Surface as a `Contract` for `Module`: what it observes, requires, and may\n * emit. A parameterized Surface needs its `params` to build the projection.\n */\n contract: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n ): Contract => {\n const projection = surface.projection(params)\n return {\n kind: 'surface',\n name: surface.name,\n owner: surface.owner,\n owns: [],\n observes: projection.dependencies,\n messages: surface.messages.map(messageTag).filter((tag): tag is string => tag !== undefined),\n metadata: Metadata.summarize(projection.metadata),\n }\n },\n\n /**\n * Pure introspection for DevTools: what a Surface observes (dependencies,\n * requirements) and what it may emit. No behavior change, no I/O.\n */\n inspect: <Root, Model, Message, Params>(\n surface: Surface<Root, Model, Message, Params>,\n params: Params,\n ): SurfaceInspection => {\n const projection = surface.projection(params)\n return {\n name: surface.name,\n dependencies: projection.dependencies,\n metadata: Metadata.summarize(projection.metadata),\n emits: surface.messages,\n }\n },\n}\n\n// ===========================================================================\n// Entity, Selection, Remote moved to `foldkit-remote` (Phase 3).\n// ===========================================================================\n\n// ===========================================================================\n// Module: the pure composition root\n// ===========================================================================\n\n/**\n * What one contract claims about an application, as data. Sync, Remote, and\n * Agent attach one to the values they produce; `Surface.contract` derives one\n * from a Surface. `owns` are the Model paths the contract is the authority for\n * (a replicated projection, a remote store); `observes` are the paths it reads.\n */\nexport interface Contract {\n readonly kind: string\n readonly name: string\n /** The application's identity token; absent when the value cannot know it. */\n readonly owner?: object | undefined\n readonly owns: DependencyTree\n readonly observes: DependencyTree\n /** Message tags the contract may cause, expose, or record. */\n readonly messages: readonly string[]\n /** What interpreters attached to the contract's reads, as text. */\n readonly metadata: readonly MetadataSummary[]\n}\n\n/**\n * How one integration joins an application, as data and pure functions: the\n * Messages it routes, what it runs at startup and on a URL change, its\n * Subscriptions and Managed Resources, and its contract. Remote, Mirror, Sync,\n * and Agent produce one; `foldkit-bundle`'s assembly derives the application's\n * `update`, initial state, runtime config, and Module from a list of them.\n * `R` is the services its Commands and Subscriptions need.\n */\nexport interface Wiring<Model, Message, R = never> {\n /** Names the integration in errors and the Module: `remote:Board`, `mirror:filters`. */\n readonly key: string\n /** Message tags `route` handles. Two integrations handling one tag is an error unless it is `shared`. */\n readonly handles: readonly string[]\n /** Tags several integrations may handle, each for its own values (Mirror's `MirrorRestored`, by name). */\n readonly shared?: readonly string[] | undefined\n /**\n * Folds a Message this integration handles; `None` for any other. A method, so\n * a wiring that routes only its own variants fits an assembly over the whole\n * application union.\n */\n route?(model: Model, message: Message): Option.Option<Update.Return<Model, Message, R>>\n /** Runs once when the application starts, after placements: a restore Command, a warm-up. */\n readonly init?: Update.Step<Model, Message, R> | undefined\n /** Applies the URL to the Model, at startup and whenever the URL changes. */\n readonly onUrl?: ((model: Model, url: Url) => Model) | undefined\n readonly subscriptions?: Subscriptions<Model, Message, R> | undefined\n readonly resources?:\n Readonly<Record<string, ManagedResourceEntry<Model, Message, any, any, any>>> | undefined\n /** Its Module contract; absent for wiring that owns and observes nothing. */\n readonly contract?: Contract | undefined\n}\n\n/** Contracts of one application, in declaration order. Data, not a runtime. */\nexport interface Module<\n Root,\n F extends Schema.Struct.Fields,\n Cases extends Record<string, Schema.Struct.Fields>,\n> {\n readonly app: AppScope<Root, F, Cases>\n readonly contracts: readonly Contract[]\n}\n\nexport interface Finding {\n readonly rule:\n | 'foreign-contract'\n | 'duplicate-name'\n | 'ownership-overlap'\n | 'message-claimed-twice'\n | 'unknown-path'\n | 'unknown-message'\n /** `kind:name` of each contract involved. */\n readonly contracts: readonly string[]\n readonly message: string\n}\n\n/** Who owns a Model path; `undefined` is local state. */\nexport interface Ownership {\n readonly path: readonly string[]\n readonly owner: { readonly kind: string; readonly name: string } | undefined\n}\n\nexport interface ModuleManifest {\n readonly fields: readonly string[]\n readonly messages: readonly string[]\n readonly ownership: readonly Ownership[]\n readonly contracts: readonly Omit<Contract, 'owner'>[]\n readonly findings: readonly Finding[]\n}\n\n/** A value `Module.make` accepts: a contract, a value carrying one, or a Surface without params. */\nexport type ModuleItem<Root> =\n Contract | { readonly contract: Contract } | Surface<Root, any, any, void>\n\nconst label = (contract: Contract): string => `${contract.kind}:${contract.name}`\n/** Metadata summaries are application data (a query's input), so they cannot break the table. */\nconst tableCell = (text: string): string =>\n text\n .replace(/\\\\/g, '\\\\\\\\')\n .replace(/\\|/g, '\\\\|')\n .replace(/\\r\\n?|\\n/g, ' ')\nconst pathKey = (path: readonly string[]): string => path.join('.')\nconst isPrefix = (prefix: readonly string[], path: readonly string[]): boolean =>\n prefix.length <= path.length && prefix.every((segment, index) => segment === path[index])\n\n// A carried contract wins: a sync contract also has a `projection` (writable, not a function).\nconst toContract = <Root>(item: ModuleItem<Root>): Contract =>\n 'contract' in item\n ? item.contract\n : 'projection' in item\n ? Surface.contract(item, undefined)\n : item\n\nconst applicationTags = (app: AppScope<any, any, any>): readonly string[] =>\n Object.entries(app.Message as unknown as Record<string, unknown>)\n .filter(([key, value]) => messageTag(value) === key)\n .map(([key]) => key)\n\n/** Contracts that own at least one path, with a stable label. */\nconst owners = (module: Module<any, any, any>) =>\n module.contracts.filter(contract => contract.owns.length > 0)\n\n/**\n * Collects an application's contracts as pure data so their relationships can\n * be validated and inspected without starting a runtime.\n *\n * ```ts\n * const Project = Module.make(App, [BoardSurface, ProjectSync, ProjectRemote, ProjectAgent])\n * Module.validate(Project) // findings, or []\n * Module.toMarkdown(Project)\n * ```\n */\nexport const Module = {\n make: <Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>>(\n app: AppScope<Root, F, Cases>,\n items: readonly ModuleItem<Root>[] = [],\n ): Module<Root, F, Cases> => ({ app, contracts: items.map(toContract) }),\n\n /** A new Module with more contracts; the input is unchanged. */\n add: <Root, F extends Schema.Struct.Fields, Cases extends Record<string, Schema.Struct.Fields>>(\n module: Module<Root, F, Cases>,\n ...items: readonly ModuleItem<Root>[]\n ): Module<Root, F, Cases> => ({\n app: module.app,\n contracts: [...module.contracts, ...items.map(toContract)],\n }),\n\n /**\n * Cross-contract invariants the types cannot express: a contract from another\n * application, a duplicate `kind:name`, two owners of overlapping Model paths,\n * a Message recorded by two replication contracts, and a path or Message the\n * application does not declare.\n */\n validate: (module: Module<any, any, any>): readonly Finding[] => {\n const findings: Finding[] = []\n const fields = new Set(Object.keys(module.app.Model.fields))\n const tags = new Set(applicationTags(module.app))\n const seen = new Map<string, Contract>()\n\n for (const contract of module.contracts) {\n const name = label(contract)\n if (contract.owner !== undefined && contract.owner !== module.app.owner)\n findings.push({\n rule: 'foreign-contract',\n contracts: [name],\n message: `${name} belongs to a different application`,\n })\n const duplicate = seen.get(name)\n if (duplicate !== undefined && duplicate !== contract)\n findings.push({\n rule: 'duplicate-name',\n contracts: [name],\n message: `${name} is declared twice`,\n })\n seen.set(name, contract)\n for (const path of [...contract.owns, ...contract.observes]) {\n const head = path[0]\n if (head === undefined || !fields.has(head))\n findings.push({\n rule: 'unknown-path',\n contracts: [name],\n message: `${name} references \"${pathKey(path)}\", which is not a Model field`,\n })\n }\n for (const tag of contract.messages)\n if (!tags.has(tag))\n findings.push({\n rule: 'unknown-message',\n contracts: [name],\n message: `${name} names \"${tag}\", which is not a Message of this application`,\n })\n }\n\n // The same value listed twice is one owner, as `duplicate-name` treats it.\n const owning = [...new Set(owners(module))]\n for (let i = 0; i < owning.length; i += 1)\n for (let j = i + 1; j < owning.length; j += 1) {\n const a = owning[i]!\n const b = owning[j]!\n for (const pa of a.owns)\n for (const pb of b.owns)\n // An empty path is reported as `unknown-path`, not as owning everything.\n if (pa.length > 0 && pb.length > 0 && (isPrefix(pa, pb) || isPrefix(pb, pa)))\n findings.push({\n rule: 'ownership-overlap',\n contracts: [label(a), label(b)],\n message: `${label(a)} owns \"${pathKey(pa)}\" and ${label(b)} owns \"${pathKey(pb)}\"`,\n })\n }\n\n const recorded = new Map<string, Contract>()\n for (const contract of module.contracts.filter(contract => contract.kind === 'sync'))\n for (const tag of contract.messages) {\n const other = recorded.get(tag)\n if (other !== undefined && other !== contract)\n findings.push({\n rule: 'message-claimed-twice',\n contracts: [label(other), label(contract)],\n message: `\"${tag}\" is durable in both ${label(other)} and ${label(contract)}`,\n })\n else recorded.set(tag, contract)\n }\n\n return findings\n },\n\n /**\n * The application's fields and Messages, who owns each Model path (local when\n * no contract does), every contract, and the findings. Reproducible for a\n * given Module, so it can be committed and diffed.\n */\n manifest: (module: Module<any, any, any>): ModuleManifest => {\n const ownership: Ownership[] = []\n const owning = owners(module)\n for (const field of Object.keys(module.app.Model.fields)) {\n const claims = owning.flatMap(contract =>\n contract.owns\n .filter(path => path[0] === field)\n .map(path => ({ path, owner: { kind: contract.kind, name: contract.name } })),\n )\n const whole = claims.find(claim => claim.path.length === 1)\n if (whole !== undefined) ownership.push(whole)\n else {\n ownership.push({ path: [field], owner: undefined })\n ownership.push(...claims.sort((a, b) => pathKey(a.path).localeCompare(pathKey(b.path))))\n }\n }\n return {\n fields: Object.keys(module.app.Model.fields),\n messages: applicationTags(module.app),\n ownership,\n contracts: module.contracts.map(({ owner: _owner, ...rest }) => rest),\n findings: Module.validate(module),\n }\n },\n\n /** The manifest as Markdown: the ownership tree, a table of contracts, and findings. */\n toMarkdown: (module: Module<any, any, any>): string => {\n const manifest = Module.manifest(module)\n const lines: string[] = ['```text', 'Model']\n const width = Math.max(0, ...manifest.ownership.map(row => pathKey(row.path).length))\n manifest.ownership.forEach((row, index) => {\n const last = index === manifest.ownership.length - 1\n const owner =\n row.owner === undefined ? 'LOCAL' : `${row.owner.kind.toUpperCase()} ${row.owner.name}`\n lines.push(`${last ? '└── ' : '├── '}${pathKey(row.path).padEnd(width)} ${owner}`)\n })\n lines.push(\n '```',\n '',\n '| Contract | Owns | Observes | Messages | Metadata |',\n '| --- | --- | --- | --- | --- |',\n )\n for (const contract of manifest.contracts)\n lines.push(\n `| ${contract.kind}:${contract.name} | ${contract.owns.map(pathKey).join(', ')} | ${contract.observes.map(pathKey).join(', ')} | ${contract.messages.join(', ')} | ${tableCell(contract.metadata.map(summary => `${summary.name}: ${summary.entries.join(', ')}`).join('; '))} |`,\n )\n if (manifest.findings.length > 0) {\n lines.push('', '## Findings', '')\n for (const finding of manifest.findings)\n lines.push(`- **${finding.rule}** ${finding.message}`)\n }\n return lines.join('\\n')\n },\n\n /**\n * The manifest as a Mermaid flowchart: Model fields in a subgraph, one node\n * per contract, a solid edge for ownership and a dotted edge for observation.\n */\n toMermaid: (module: Module<any, any, any>): string => {\n const manifest = Module.manifest(module)\n const lines = ['flowchart LR', ' subgraph Model']\n manifest.fields.forEach((field, index) => lines.push(` f${index}[\"${field}\"]`))\n lines.push(' end')\n // A path outside the Model (reported by `validate`) draws no edge.\n const fieldId = (path: readonly string[]): string | undefined => {\n const index = path.length === 0 ? -1 : manifest.fields.indexOf(path[0]!)\n return index < 0 ? undefined : `f${index}`\n }\n manifest.contracts.forEach((contract, index) => {\n lines.push(` c${index}[\"${contract.kind}:${contract.name}\"]`)\n for (const path of contract.owns) {\n const field = fieldId(path)\n if (field !== undefined) lines.push(` c${index} -->|owns| ${field}`)\n }\n for (const path of contract.observes) {\n const field = fieldId(path)\n if (field !== undefined && !contract.owns.some(owned => pathKey(owned) === pathKey(path)))\n lines.push(` c${index} -.-> ${field}`)\n }\n })\n return lines.join('\\n')\n },\n}\n"],"mappings":"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"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "foldkit-surface",
3
- "version": "0.1.1",
3
+ "version": "0.3.0",
4
4
  "description": "Typed observation and capability boundaries for Foldkit: ModelRef, Projection, and Surface.",
5
5
  "keywords": [
6
6
  "foldkit",
@@ -37,6 +37,9 @@
37
37
  "README.md",
38
38
  "LICENSE"
39
39
  ],
40
+ "dependencies": {
41
+ "foldkit-metadata": "0.1.0"
42
+ },
40
43
  "peerDependencies": {
41
44
  "effect": "^4.0.0-rc.112",
42
45
  "foldkit": "^0.158.2"
@@ -45,7 +48,7 @@
45
48
  "effect": "4.0.0-rc.112",
46
49
  "foldkit": "0.158.2",
47
50
  "tsdown": "^0.23.0",
48
- "typescript": "^5.7.2"
51
+ "typescript": "5.9.3"
49
52
  },
50
53
  "scripts": {
51
54
  "build": "tsdown",