@frondruntime/devtools 0.3.0 → 0.5.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/CHANGELOG.md +41 -1
- package/README.md +30 -0
- package/dist/chunk-tky04mfa.js +169 -0
- package/dist/chunk-tky04mfa.js.map +10 -0
- package/dist/index.d.ts +79 -10
- package/dist/index.js +84 -76
- package/dist/index.js.map +5 -5
- package/dist/node.js +4 -4
- package/dist/node.js.map +1 -1
- package/package.json +4 -4
- package/src/attach.ts +28 -3
- package/src/attachDevtools.ts +10 -2
- package/src/encode.ts +38 -1
- package/src/protocol.ts +40 -6
- package/dist/chunk-8xwbnbvs.js +0 -164
- package/dist/chunk-8xwbnbvs.js.map +0 -10
package/src/attach.ts
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import type { Runtime } from "@frondruntime/core";
|
|
2
2
|
import { Clock, Effect, Layer, Stream } from "effect";
|
|
3
|
-
import { RpcClient, RpcSerialization } from "effect/
|
|
4
|
-
import { Socket } from "effect/
|
|
3
|
+
import { RpcClient, RpcSerialization } from "effect/rpc";
|
|
4
|
+
import { Socket } from "effect/socket";
|
|
5
5
|
import { encodeRecord } from "./encode.ts";
|
|
6
6
|
import { type EncodePolicy, resolvePolicy } from "./policy.ts";
|
|
7
7
|
import {
|
|
@@ -79,6 +79,31 @@ export type AttachOptions = {
|
|
|
79
79
|
readonly include?: (record: Runtime.RuntimeEventRecord) => boolean;
|
|
80
80
|
};
|
|
81
81
|
|
|
82
|
+
/**
|
|
83
|
+
* Mints the id that identifies this runtime for the life of the process.
|
|
84
|
+
*
|
|
85
|
+
* Deliberately not `crypto.randomUUID`, which this used to be. That call is not
|
|
86
|
+
* available everywhere a Frond app runs — React Native has no global `crypto`
|
|
87
|
+
* until a polyfill installs one — and reaching for it meant either a startup
|
|
88
|
+
* crash on the runtime least able to explain it, or a guard, and a guard is a
|
|
89
|
+
* branch whose two halves nobody exercises together.
|
|
90
|
+
*
|
|
91
|
+
* The entropy was never the requirement. This id has to be unique among the
|
|
92
|
+
* handful of apps attached to one local hub at one time, and stable across that
|
|
93
|
+
* process's own reconnects. Nothing authenticates with it, nothing persists it,
|
|
94
|
+
* and it dies with the hub. A timestamp for cross-process separation and a short
|
|
95
|
+
* random suffix for anything started inside the same millisecond covers that
|
|
96
|
+
* with room to spare; the timestamp is the half that matters, because
|
|
97
|
+
* `Math.random` is seeded per process and two processes launched together is
|
|
98
|
+
* exactly where bare randomness is weakest.
|
|
99
|
+
*
|
|
100
|
+
* If this ever fronts something that is not a local devtools socket, it needs a
|
|
101
|
+
* real generator — but then it also needs a real identity, not this.
|
|
102
|
+
*/
|
|
103
|
+
export function newInstanceId(): string {
|
|
104
|
+
return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
|
|
105
|
+
}
|
|
106
|
+
|
|
82
107
|
/**
|
|
83
108
|
* Transport for one attachment.
|
|
84
109
|
*
|
|
@@ -138,7 +163,7 @@ export const attachRuntime = Effect.fnUntraced(function* (options: AttachOptions
|
|
|
138
163
|
|
|
139
164
|
const info: AttachmentInfo = {
|
|
140
165
|
protocolVersion: HUB_PROTOCOL_VERSION,
|
|
141
|
-
instanceId: options.instanceId ??
|
|
166
|
+
instanceId: options.instanceId ?? newInstanceId(),
|
|
142
167
|
runtimeId: options.runtime.getSnapshotSync().runtimeId,
|
|
143
168
|
generation: options.generation ?? 0,
|
|
144
169
|
name: options.name,
|
package/src/attachDevtools.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import type { Runtime } from "@frondruntime/core";
|
|
2
2
|
import { Cause, Data, Effect, Fiber } from "effect";
|
|
3
|
-
import { attachLayer, attachRuntime } from "./attach.ts";
|
|
3
|
+
import { attachLayer, attachRuntime, newInstanceId } from "./attach.ts";
|
|
4
4
|
import { HUB_DEFAULT_ATTACH_URL, HubRejection, type ValuePolicy } from "./protocol.ts";
|
|
5
5
|
|
|
6
6
|
/**
|
|
@@ -64,6 +64,14 @@ export type DevtoolsOptions = {
|
|
|
64
64
|
readonly platform?: string | undefined;
|
|
65
65
|
/** See {@link import("./attach.ts").AttachOptions.values}. Defaults to `"shape"`. */
|
|
66
66
|
readonly values?: ValuePolicy | undefined;
|
|
67
|
+
/**
|
|
68
|
+
* Stable identity for this app across reconnects. Generated when omitted.
|
|
69
|
+
*
|
|
70
|
+
* Worth setting to something recognisable when several apps attach at once,
|
|
71
|
+
* since this is what tells one from another after a hub restart. Any string
|
|
72
|
+
* does, so long as it is stable for the life of the process and distinct per
|
|
73
|
+
* running app.
|
|
74
|
+
*/
|
|
67
75
|
readonly instanceId?: string | undefined;
|
|
68
76
|
/** Return false to leave a record out of the stream entirely. */
|
|
69
77
|
readonly include?: ((record: Runtime.RuntimeEventRecord) => boolean) | undefined;
|
|
@@ -117,7 +125,7 @@ export function attachDevtools(options: DevtoolsOptions): () => void {
|
|
|
117
125
|
// Minted here rather than per attempt, so a hub restart underneath a running
|
|
118
126
|
// app brings back the same runtime instead of an apparent stranger. Paired
|
|
119
127
|
// with `generation` below, which is what says how many times that happened.
|
|
120
|
-
const instanceId = options.instanceId ??
|
|
128
|
+
const instanceId = options.instanceId ?? newInstanceId();
|
|
121
129
|
|
|
122
130
|
let generation = 0;
|
|
123
131
|
|
package/src/encode.ts
CHANGED
|
@@ -86,7 +86,9 @@ export function createValueEncoder(policy: EncodePolicy): ValueEncoder {
|
|
|
86
86
|
*
|
|
87
87
|
* Classification, work context, and node ids are metadata the runtime already
|
|
88
88
|
* owns and are copied verbatim — they are ids and enum members, never user
|
|
89
|
-
* data.
|
|
89
|
+
* data. A signal's channel and name join them, on the reasoning
|
|
90
|
+
* `EncodedEventRecord` gives for the two fields. Only the event body goes
|
|
91
|
+
* through the value encoder.
|
|
90
92
|
*/
|
|
91
93
|
export function encodeRecord(
|
|
92
94
|
record: Runtime.RuntimeEventRecord,
|
|
@@ -123,6 +125,12 @@ export function encodeRecord(
|
|
|
123
125
|
reason: record.work.reason,
|
|
124
126
|
priority: record.work.priority,
|
|
125
127
|
nodeIds: record.nodeIds,
|
|
128
|
+
// Unclamped, like every routing field above it. A signal's channel and name
|
|
129
|
+
// are how a reader addresses one — the filters `frond_read_events` exposes —
|
|
130
|
+
// and they are authored as constants next to the code that publishes, the
|
|
131
|
+
// same standing as `tag` and `nodeIds`. What the payload holds is the value,
|
|
132
|
+
// and that is what `fields` withholds a line below.
|
|
133
|
+
...signalIdentity(record.event),
|
|
126
134
|
fields: policy === "none" ? {} : describeFields(record.event, encodeField),
|
|
127
135
|
// Failures are causes, not results: their messages are what makes a
|
|
128
136
|
// devtools feed worth reading, so they are described rather than dropped —
|
|
@@ -136,6 +144,35 @@ export function encodeRecord(
|
|
|
136
144
|
};
|
|
137
145
|
}
|
|
138
146
|
|
|
147
|
+
/**
|
|
148
|
+
* Names the signal an event is about, where it is about one.
|
|
149
|
+
*
|
|
150
|
+
* Two tags, written out, rather than a rule the field walk could apply to any
|
|
151
|
+
* event: a general "promote a field called `channel`" would promote whatever an
|
|
152
|
+
* app happened to name that way, which is app data crossing the policy that was
|
|
153
|
+
* meant to clamp it. Only these two events have a channel the runtime itself put
|
|
154
|
+
* there, and `RuntimeSignalSubscriberFailureObserved` is here for the same
|
|
155
|
+
* reason as the publication — a subscriber failure that cannot say which signal
|
|
156
|
+
* it was handling is a failure with no subject.
|
|
157
|
+
*
|
|
158
|
+
* Absent rather than empty on everything else. `channel: ""` is a record
|
|
159
|
+
* claiming a channel it does not have, and a reader filtering on the field would
|
|
160
|
+
* have to know to treat one string as meaning "no".
|
|
161
|
+
*/
|
|
162
|
+
function signalIdentity(event: Runtime.RuntimeEvent): {
|
|
163
|
+
readonly channel?: string;
|
|
164
|
+
readonly name?: string;
|
|
165
|
+
} {
|
|
166
|
+
const signal =
|
|
167
|
+
event._tag === "RuntimeSignalPublished"
|
|
168
|
+
? event.record.signal
|
|
169
|
+
: event._tag === "RuntimeSignalSubscriberFailureObserved"
|
|
170
|
+
? event.signal.signal
|
|
171
|
+
: undefined;
|
|
172
|
+
|
|
173
|
+
return signal === undefined ? {} : { channel: signal.channel, name: signal.name };
|
|
174
|
+
}
|
|
175
|
+
|
|
139
176
|
function describeFields(
|
|
140
177
|
event: Runtime.RuntimeEvent,
|
|
141
178
|
encodeValue: (value: unknown) => unknown
|
package/src/protocol.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import { Schema } from "effect";
|
|
2
|
-
import { Rpc, RpcGroup } from "effect/
|
|
2
|
+
import { Rpc, RpcGroup } from "effect/rpc";
|
|
3
3
|
|
|
4
4
|
/**
|
|
5
5
|
* Wire contract between an attached Frond runtime and the hub.
|
|
@@ -30,8 +30,17 @@ import { Rpc, RpcGroup } from "effect/unstable/rpc";
|
|
|
30
30
|
* change inside one release moved nothing and let two builds that disagreed
|
|
31
31
|
* attach to each other. Starting at 1 with the first published hub, so what the
|
|
32
32
|
* number counts is generations anyone could have installed.
|
|
33
|
+
*
|
|
34
|
+
* Moved to 2 because {@link RuntimeEventCategory} gained `"signal"`. A literal
|
|
35
|
+
* union is not an excess property: a 0.3.x hub decoding `category: "signal"`
|
|
36
|
+
* fails with `SchemaError(Expected "command" | ... | "state", got "signal")`,
|
|
37
|
+
* and that failure takes the whole `Frond.Ingest` batch, non-signal records
|
|
38
|
+
* included. Both builds announce 1, so the attachment would succeed and the app
|
|
39
|
+
* would simply stop streaming — the exact failure the paragraph above refuses to
|
|
40
|
+
* ship. The optional `channel`/`name` fields really are two-way safe and would
|
|
41
|
+
* not have needed this; the category is what forced it.
|
|
33
42
|
*/
|
|
34
|
-
export const HUB_PROTOCOL_VERSION =
|
|
43
|
+
export const HUB_PROTOCOL_VERSION = 2;
|
|
35
44
|
|
|
36
45
|
/**
|
|
37
46
|
* Unregistered, and chosen for the band rather than the number.
|
|
@@ -71,6 +80,7 @@ export const RuntimeEventCategory = Schema.Literals([
|
|
|
71
80
|
"input",
|
|
72
81
|
"lifecycle",
|
|
73
82
|
"operation",
|
|
83
|
+
"signal",
|
|
74
84
|
"state",
|
|
75
85
|
]);
|
|
76
86
|
|
|
@@ -165,6 +175,31 @@ export const EncodedEventRecord = Schema.Struct({
|
|
|
165
175
|
reason: RuntimeWorkReason,
|
|
166
176
|
priority: RuntimeWorkPriority,
|
|
167
177
|
nodeIds: Schema.Array(Schema.String),
|
|
178
|
+
/**
|
|
179
|
+
* Which signal this is, on the two events that carry one.
|
|
180
|
+
*
|
|
181
|
+
* Lifted out of `fields` because that is where they used to die: the field
|
|
182
|
+
* walk treats every event body the same way, so a publication whose one field
|
|
183
|
+
* is a signal record arrived at the default `"shape"` policy as a key list of
|
|
184
|
+
* that record — a reader could tell that *a* signal fired and nothing about
|
|
185
|
+
* which one. A channel and an event name are routing structure rather than app
|
|
186
|
+
* data, which is the same argument `describeShape` makes for letting `_tag`
|
|
187
|
+
* cross verbatim, so these two cross at every policy. The `payload` stays in
|
|
188
|
+
* `fields` and stays clamped, because it is the half that really is data.
|
|
189
|
+
*
|
|
190
|
+
* Optional rather than required, which keeps these two fields compatible in
|
|
191
|
+
* both directions on their own: an old hub ignores the extra properties a new
|
|
192
|
+
* app sends, because effect Schema drops excess properties on decode and
|
|
193
|
+
* nothing here overrides `onExcessProperty`, and a new hub reads an old app's
|
|
194
|
+
* records as what they are — signals whose channel it was never told.
|
|
195
|
+
*
|
|
196
|
+
* That is a property of these fields and not of the release. The same release
|
|
197
|
+
* added `"signal"` to {@link RuntimeEventCategory}, which an old hub does
|
|
198
|
+
* reject, so {@link HUB_PROTOCOL_VERSION} moved to 2 regardless. Keeping these
|
|
199
|
+
* optional is still what makes a new hub able to read an old app at all.
|
|
200
|
+
*/
|
|
201
|
+
channel: Schema.optionalKey(Schema.String),
|
|
202
|
+
name: Schema.optionalKey(Schema.String),
|
|
168
203
|
/**
|
|
169
204
|
* Keyed by the event's own field names, minus `_tag`.
|
|
170
205
|
*
|
|
@@ -390,10 +425,9 @@ export type HubCommand = typeof HubCommand.Type;
|
|
|
390
425
|
* caller learns nothing here it could not learn by dialing and observing, and
|
|
391
426
|
* vagueness would cost only the developer who is actually trying to attach.
|
|
392
427
|
*/
|
|
393
|
-
export class HubRejection extends Schema.
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
) {}
|
|
428
|
+
export class HubRejection extends Schema.TaggedError<HubRejection>()("HubRejection", {
|
|
429
|
+
reason: Schema.String,
|
|
430
|
+
}) {}
|
|
397
431
|
|
|
398
432
|
/**
|
|
399
433
|
* Opens the attachment and holds it open.
|
package/dist/chunk-8xwbnbvs.js
DELETED
|
@@ -1,164 +0,0 @@
|
|
|
1
|
-
// src/protocol.ts
|
|
2
|
-
import { Schema } from "effect";
|
|
3
|
-
import { Rpc, RpcGroup } from "effect/unstable/rpc";
|
|
4
|
-
var HUB_PROTOCOL_VERSION = 1;
|
|
5
|
-
var HUB_DEFAULT_PORT = 17391;
|
|
6
|
-
var HUB_DEFAULT_HOST = "127.0.0.1";
|
|
7
|
-
var HUB_ATTACH_PATH = "/attach";
|
|
8
|
-
var HUB_DEFAULT_ATTACH_URL = `ws://${HUB_DEFAULT_HOST}:${HUB_DEFAULT_PORT}${HUB_ATTACH_PATH}`;
|
|
9
|
-
var ValuePolicy = Schema.Literals(["none", "shape", "full"]);
|
|
10
|
-
var RuntimeEventCategory = Schema.Literals([
|
|
11
|
-
"command",
|
|
12
|
-
"diagnostic",
|
|
13
|
-
"input",
|
|
14
|
-
"lifecycle",
|
|
15
|
-
"operation",
|
|
16
|
-
"state"
|
|
17
|
-
]);
|
|
18
|
-
var RuntimeEventSeverity = Schema.Literals(["debug", "error", "info", "warning"]);
|
|
19
|
-
var RuntimeEventTimeline = Schema.Literals(["live", "state", "system", "work"]);
|
|
20
|
-
var RuntimeWorkSource = Schema.Literals([
|
|
21
|
-
"react",
|
|
22
|
-
"mobx",
|
|
23
|
-
"node",
|
|
24
|
-
"manual",
|
|
25
|
-
"devtools",
|
|
26
|
-
"runtime",
|
|
27
|
-
"signal",
|
|
28
|
-
"test"
|
|
29
|
-
]);
|
|
30
|
-
var RuntimeWorkReason = Schema.Literals([
|
|
31
|
-
"start",
|
|
32
|
-
"stop",
|
|
33
|
-
"readiness",
|
|
34
|
-
"retry",
|
|
35
|
-
"preload",
|
|
36
|
-
"refresh",
|
|
37
|
-
"action",
|
|
38
|
-
"args-update",
|
|
39
|
-
"live",
|
|
40
|
-
"release",
|
|
41
|
-
"eviction",
|
|
42
|
-
"unsafe-update",
|
|
43
|
-
"input",
|
|
44
|
-
"signal"
|
|
45
|
-
]);
|
|
46
|
-
var RuntimeWorkPriority = Schema.Literals(["blocking", "visible", "background", "idle"]);
|
|
47
|
-
var AttachmentInfo = Schema.Struct({
|
|
48
|
-
protocolVersion: Schema.Number,
|
|
49
|
-
instanceId: Schema.String,
|
|
50
|
-
runtimeId: Schema.String,
|
|
51
|
-
generation: Schema.Number,
|
|
52
|
-
name: Schema.String,
|
|
53
|
-
platform: Schema.String,
|
|
54
|
-
startedAt: Schema.Number,
|
|
55
|
-
values: ValuePolicy
|
|
56
|
-
});
|
|
57
|
-
var EncodedEventRecord = Schema.Struct({
|
|
58
|
-
sequence: Schema.Number,
|
|
59
|
-
recordedAt: Schema.Number,
|
|
60
|
-
tag: Schema.String,
|
|
61
|
-
category: RuntimeEventCategory,
|
|
62
|
-
severity: RuntimeEventSeverity,
|
|
63
|
-
timeline: RuntimeEventTimeline,
|
|
64
|
-
reportable: Schema.Boolean,
|
|
65
|
-
workId: Schema.Number,
|
|
66
|
-
parentWorkId: Schema.optional(Schema.Number),
|
|
67
|
-
source: RuntimeWorkSource,
|
|
68
|
-
reason: RuntimeWorkReason,
|
|
69
|
-
priority: RuntimeWorkPriority,
|
|
70
|
-
nodeIds: Schema.Array(Schema.String),
|
|
71
|
-
fields: Schema.Record(Schema.String, Schema.Unknown),
|
|
72
|
-
failures: Schema.Array(Schema.Unknown)
|
|
73
|
-
});
|
|
74
|
-
var EncodedNodeSnapshot = Schema.Struct({
|
|
75
|
-
nodeId: Schema.String,
|
|
76
|
-
tag: Schema.String,
|
|
77
|
-
kind: Schema.String,
|
|
78
|
-
state: Schema.String,
|
|
79
|
-
revision: Schema.Number,
|
|
80
|
-
status: Schema.Unknown,
|
|
81
|
-
liveDemand: Schema.Unknown,
|
|
82
|
-
operation: Schema.Unknown,
|
|
83
|
-
resultValidity: Schema.optional(Schema.Unknown),
|
|
84
|
-
failure: Schema.optional(Schema.Unknown),
|
|
85
|
-
operationFailure: Schema.optional(Schema.Unknown),
|
|
86
|
-
liveFailure: Schema.optional(Schema.Unknown),
|
|
87
|
-
result: Schema.optional(Schema.Unknown)
|
|
88
|
-
});
|
|
89
|
-
var EncodedGraphEdge = Schema.Struct({
|
|
90
|
-
from: Schema.String,
|
|
91
|
-
to: Schema.String,
|
|
92
|
-
dependency: Schema.String
|
|
93
|
-
});
|
|
94
|
-
var GraphSnapshot = Schema.Struct({
|
|
95
|
-
capturedAt: Schema.Number,
|
|
96
|
-
sequence: Schema.optional(Schema.Number),
|
|
97
|
-
runtimeId: Schema.String,
|
|
98
|
-
runtimeStatus: Schema.String,
|
|
99
|
-
graphStatus: Schema.String,
|
|
100
|
-
observedInputs: Schema.Number,
|
|
101
|
-
values: ValuePolicy,
|
|
102
|
-
nodes: Schema.Array(EncodedNodeSnapshot),
|
|
103
|
-
edges: Schema.Array(EncodedGraphEdge)
|
|
104
|
-
});
|
|
105
|
-
var GraphQuery = Schema.Struct({ _tag: Schema.tag("Graph") });
|
|
106
|
-
var NodeQuery = Schema.Struct({
|
|
107
|
-
_tag: Schema.tag("Node"),
|
|
108
|
-
nodeId: Schema.String
|
|
109
|
-
});
|
|
110
|
-
var StateQuery = Schema.Union([GraphQuery, NodeQuery]);
|
|
111
|
-
var QueryOutcome = Schema.Union([
|
|
112
|
-
Schema.Struct({ _tag: Schema.tag("Snapshot"), snapshot: GraphSnapshot }),
|
|
113
|
-
Schema.Struct({ _tag: Schema.tag("Failed"), reason: Schema.String })
|
|
114
|
-
]);
|
|
115
|
-
var HubAttached = Schema.Struct({
|
|
116
|
-
_tag: Schema.tag("Attached"),
|
|
117
|
-
attachmentId: Schema.String,
|
|
118
|
-
values: ValuePolicy
|
|
119
|
-
});
|
|
120
|
-
var HubPing = Schema.Struct({
|
|
121
|
-
_tag: Schema.tag("Ping"),
|
|
122
|
-
at: Schema.Number
|
|
123
|
-
});
|
|
124
|
-
var HubQuery = Schema.Struct({
|
|
125
|
-
_tag: Schema.tag("Query"),
|
|
126
|
-
requestId: Schema.String,
|
|
127
|
-
query: StateQuery,
|
|
128
|
-
values: ValuePolicy
|
|
129
|
-
});
|
|
130
|
-
var HubCommand = Schema.Union([HubAttached, HubPing, HubQuery]);
|
|
131
|
-
|
|
132
|
-
class HubRejection extends Schema.TaggedErrorClass("HubRejection")("HubRejection", { reason: Schema.String }) {
|
|
133
|
-
}
|
|
134
|
-
|
|
135
|
-
class Attach extends Rpc.make("Frond.Attach", {
|
|
136
|
-
payload: { info: AttachmentInfo },
|
|
137
|
-
success: HubCommand,
|
|
138
|
-
error: HubRejection,
|
|
139
|
-
stream: true
|
|
140
|
-
}) {
|
|
141
|
-
}
|
|
142
|
-
|
|
143
|
-
class Ingest extends Rpc.make("Frond.Ingest", {
|
|
144
|
-
payload: {
|
|
145
|
-
attachmentId: Schema.String,
|
|
146
|
-
records: Schema.Array(EncodedEventRecord),
|
|
147
|
-
droppedSince: Schema.Number
|
|
148
|
-
}
|
|
149
|
-
}) {
|
|
150
|
-
}
|
|
151
|
-
|
|
152
|
-
class Reply extends Rpc.make("Frond.Reply", {
|
|
153
|
-
payload: {
|
|
154
|
-
attachmentId: Schema.String,
|
|
155
|
-
requestId: Schema.String,
|
|
156
|
-
outcome: QueryOutcome
|
|
157
|
-
}
|
|
158
|
-
}) {
|
|
159
|
-
}
|
|
160
|
-
var FrondHubRpcs = RpcGroup.make(Attach, Ingest, Reply);
|
|
161
|
-
|
|
162
|
-
export { HUB_PROTOCOL_VERSION, HUB_DEFAULT_PORT, HUB_DEFAULT_HOST, HUB_ATTACH_PATH, HUB_DEFAULT_ATTACH_URL, ValuePolicy, RuntimeEventCategory, RuntimeEventSeverity, RuntimeEventTimeline, RuntimeWorkSource, RuntimeWorkReason, RuntimeWorkPriority, AttachmentInfo, EncodedEventRecord, EncodedNodeSnapshot, EncodedGraphEdge, GraphSnapshot, GraphQuery, NodeQuery, StateQuery, QueryOutcome, HubAttached, HubPing, HubQuery, HubCommand, HubRejection, Attach, Ingest, Reply, FrondHubRpcs };
|
|
163
|
-
|
|
164
|
-
//# debugId=007FD883D686F65364756E2164756E21
|
|
@@ -1,10 +0,0 @@
|
|
|
1
|
-
{
|
|
2
|
-
"version": 3,
|
|
3
|
-
"sources": ["../src/protocol.ts"],
|
|
4
|
-
"sourcesContent": [
|
|
5
|
-
"import { Schema } from \"effect\";\nimport { Rpc, RpcGroup } from \"effect/unstable/rpc\";\n\n/**\n * Wire contract between an attached Frond runtime and the hub.\n *\n * Direction of the RPC roles is deliberate and inverted from who dials: the\n * hub listens and is the RPC *server*, the app dials out and is the RPC\n * *client*. That keeps the app free of any listening socket, and it is the only\n * arrangement both `RpcServer.layerHttp` and `RpcClient.layerProtocolSocket`\n * support without a hand-written socket adapter on either side.\n *\n * Hub-to-app work (state reads, and later refresh and action invocation)\n * therefore does not travel as a plain RPC call. It rides the `Attach` response\n * stream as a `Query` command, and the app answers with a separate unary\n * `Reply` correlated by `requestId`. `Attach` is the only long-lived call.\n *\n * Version equality is exact, on both sides, and there is no capability\n * negotiation. That is a deliberate choice rather than an omission: `HubCommand`\n * is a schema union, so an app one version behind would fail to decode a command\n * it has never heard of and drop its socket — presenting as \"the runtime stopped\n * emitting\", which is the most expensive way this can fail. Refusing the\n * attachment outright says the same thing immediately and in words.\n *\n * The number counts published generations of *this contract*, and moves on its\n * own schedule — it is not derived from, and does not track, the npm version of\n * any package. Tying the two was the earlier arrangement and it was wrong in\n * both directions: a release that touched nothing on the wire still moved the\n * number and refused every app that had not upgraded, while a genuine schema\n * change inside one release moved nothing and let two builds that disagreed\n * attach to each other. Starting at 1 with the first published hub, so what the\n * number counts is generations anyone could have installed.\n */\nexport const HUB_PROTOCOL_VERSION = 1;\n\n/**\n * Unregistered, and chosen for the band rather than the number.\n *\n * Above 9999 to clear the entire dev-server zone — Vite, Metro, Expo, CRA,\n * Django, Storybook, the node inspector — and below 32768 so it can never\n * collide with an ephemeral source port on Linux, whose range starts there.\n *\n * Stable on purpose. Apps hardcode it, so a hub that drifted to the next free\n * port on a collision would leave them dialing nothing, which presents as \"the\n * runtime is not emitting\" — the most expensive way to fail.\n */\nexport const HUB_DEFAULT_PORT = 17391;\n\nexport const HUB_DEFAULT_HOST = \"127.0.0.1\";\n\nexport const HUB_ATTACH_PATH = \"/attach\";\n\n/** Where an app dials when it was given no explicit URL. */\nexport const HUB_DEFAULT_ATTACH_URL = `ws://${HUB_DEFAULT_HOST}:${HUB_DEFAULT_PORT}${HUB_ATTACH_PATH}`;\n\n/**\n * How much of a value crosses the wire.\n *\n * Negotiated in one direction only: the hub asks, and the app answers with the\n * lesser of the request and its own ceiling. The ceiling defaults to `\"shape\"`,\n * so an app sends structure until someone deliberately decides otherwise — the\n * decision to put real values on a socket should be one somebody made, not one\n * that came with the default.\n */\nexport const ValuePolicy = Schema.Literals([\"none\", \"shape\", \"full\"]);\nexport type ValuePolicy = typeof ValuePolicy.Type;\n\nexport const RuntimeEventCategory = Schema.Literals([\n \"command\",\n \"diagnostic\",\n \"input\",\n \"lifecycle\",\n \"operation\",\n \"state\",\n]);\n\nexport const RuntimeEventSeverity = Schema.Literals([\"debug\", \"error\", \"info\", \"warning\"]);\n\nexport const RuntimeEventTimeline = Schema.Literals([\"live\", \"state\", \"system\", \"work\"]);\n\nexport const RuntimeWorkSource = Schema.Literals([\n \"react\",\n \"mobx\",\n \"node\",\n \"manual\",\n \"devtools\",\n \"runtime\",\n \"signal\",\n \"test\",\n]);\n\nexport const RuntimeWorkReason = Schema.Literals([\n \"start\",\n \"stop\",\n \"readiness\",\n \"retry\",\n \"preload\",\n \"refresh\",\n \"action\",\n \"args-update\",\n \"live\",\n \"release\",\n \"eviction\",\n \"unsafe-update\",\n \"input\",\n \"signal\",\n]);\n\nexport const RuntimeWorkPriority = Schema.Literals([\"blocking\", \"visible\", \"background\", \"idle\"]);\n\n/**\n * Who is attaching.\n *\n * `runtimeId` is the runtime's own `runtime-N` counter and collides freely\n * across tabs, reloads, and processes; `instanceId` is minted once per\n * `attachDevtools` call and is the only field safe to use as an identity key.\n */\nexport const AttachmentInfo = Schema.Struct({\n protocolVersion: Schema.Number,\n /** Stable for the life of the attaching runtime, including across reconnects. */\n instanceId: Schema.String,\n runtimeId: Schema.String,\n /**\n * How many times this runtime had already attached before this connection.\n *\n * Zero on a first attach; anything higher means the socket dropped and came\n * back, which is the same thing as saying the events in between are gone.\n * Devtools are not durable by design — nothing bridges that gap — so this\n * field exists to make the gap visible rather than to let anyone close it.\n */\n generation: Schema.Number,\n /** Human label for the CLI list, e.g. the host app's package name. */\n name: Schema.String,\n /** Free-form origin hint: \"bun\", \"browser\", \"expo-ios\", … */\n platform: Schema.String,\n startedAt: Schema.Number,\n /** The strongest value policy this app is willing to honor. */\n values: ValuePolicy,\n});\nexport type AttachmentInfo = typeof AttachmentInfo.Type;\n\n/**\n * A runtime event, flattened and already redacted by the sender.\n *\n * `fields` holds JSON-safe shape descriptors, not live values — encoding\n * happens at observe time, because a `RuntimeEventRecord` carries live\n * references that keep mutating after the record is handed out. The descriptor\n * vocabulary is written down once, in `descriptors.ts`, and what each policy\n * produces lives with the walk that produces it — `describeShape` in `shape.ts`,\n * `describeFull` in `full.ts`, `describeError` in `cause.ts`. Nothing on this\n * side should restate any of it and drift.\n */\nexport const EncodedEventRecord = Schema.Struct({\n sequence: Schema.Number,\n recordedAt: Schema.Number,\n /** The `RuntimeEvent` `_tag`, e.g. \"GraphNodeLiveDemandChanged\". */\n tag: Schema.String,\n category: RuntimeEventCategory,\n severity: RuntimeEventSeverity,\n timeline: RuntimeEventTimeline,\n reportable: Schema.Boolean,\n workId: Schema.Number,\n parentWorkId: Schema.optional(Schema.Number),\n source: RuntimeWorkSource,\n reason: RuntimeWorkReason,\n priority: RuntimeWorkPriority,\n nodeIds: Schema.Array(Schema.String),\n /**\n * Keyed by the event's own field names, minus `_tag`.\n *\n * A record rather than `Unknown`: every consumer — the UI, and shortly the\n * MCP reader — looks fields up by name, and typing the container as unknown\n * only moves that cast to each of them. The *values* stay unknown, which is\n * the honest part: what a field holds depends on the negotiated policy.\n */\n fields: Schema.Record(Schema.String, Schema.Unknown),\n /**\n * What went wrong, as chains of causes rather than as single errors.\n *\n * Each entry is `{_: \"error\", message, causes}`, outermost cause first. The\n * runtime lifts these off the event's own fields, so the same failure also\n * appears in `fields` — encoded identically, so one failure never reads as\n * two. Present at every policy: `\"none\"` is a statement about values, and a\n * feed that cannot say what is failing is not worth reading.\n */\n failures: Schema.Array(Schema.Unknown),\n});\nexport type EncodedEventRecord = typeof EncodedEventRecord.Type;\n\n/**\n * One node, as it is right now.\n *\n * Split the same way `EncodedEventRecord` is: the fields a reader filters and\n * branches on are typed, and anything that came out of the app's own data is\n * `Unknown`, because what it holds depends on the negotiated policy. Giving\n * `NodeStatus`, `NodeOperation` and the rest real schemas here would copy core's\n * type surface into the wire contract and guarantee the two drift apart.\n *\n * Every field here has to earn its place in *every row* of a graph read, which\n * is why core's `label` and `key` are not among them: `label` is a formatting of\n * `tag` and `key` is already inside `nodeId`, so both are the same fact charged\n * twice, a few hundred times per snapshot.\n */\nexport const EncodedNodeSnapshot = Schema.Struct({\n nodeId: Schema.String,\n /** The spec's tag, e.g. `\"orders\"`. Shared by every key; `nodeId` is the identity. */\n tag: Schema.String,\n /**\n * `\"node\"`, `\"service\"`, `\"resource\"` or `\"facade\"` — the one identity field\n * nothing else here implies.\n *\n * It says whether this row owns a release: a resource holds something the app\n * has to give back, and a reader deciding what a leak looks like cannot get\n * that from `tag` or `nodeId`.\n *\n * Carried as a string rather than a literal union so a hub can read an app\n * built against a core that has since grown a kind. Version equality already\n * gates the wire; making this field the second thing that can reject a\n * snapshot would buy nothing.\n */\n kind: Schema.String,\n /**\n * Which arm of core's `NodeSnapshot` this is: `Unwired`, `Idle`, `Pending`,\n * `Ready`, `ReadinessError`, `Releasing`, `Invalid`.\n *\n * Typed and hoisted because it is the one field every reader branches on.\n * Left inside the encoded `status` it would oblige an agent to understand this\n * encoder's descriptors before it could ask which nodes are broken.\n */\n state: Schema.String,\n /**\n * Core's per-node write counter, carried verbatim.\n *\n * The cheap way to tell \"still the value I saw last time\" from \"recomputed,\n * and happens to look the same\" — which no amount of comparing encoded\n * results can answer once a policy has redacted them.\n */\n revision: Schema.Number,\n status: Schema.Unknown,\n liveDemand: Schema.Unknown,\n operation: Schema.Unknown,\n resultValidity: Schema.optional(Schema.Unknown),\n /**\n * Why this node is not usable, as a chain of causes.\n *\n * Same encoding as `EncodedEventRecord.failures`, deliberately: a node failed\n * in the snapshot and the event that failed it should read identically.\n */\n failure: Schema.optional(Schema.Unknown),\n /**\n * The last operation that failed, as `{operationId, kind, at, error}`.\n *\n * Distinct from `failure`, and the difference is the whole point of keeping\n * it: a node can be `Ready` on a stale-but-valid result while its most recent\n * refresh failed. `failure` would be absent and everything would look fine.\n */\n operationFailure: Schema.optional(Schema.Unknown),\n /** Why live demand could not be served, as `{at, failures}`. */\n liveFailure: Schema.optional(Schema.Unknown),\n /**\n * The node's current value.\n *\n * Only ever present on a single-node query. A graph read of a few hundred\n * nodes is a topology question, and answering it with every result attached\n * would put the whole application state on the wire to draw a diagram.\n */\n result: Schema.optional(Schema.Unknown),\n});\nexport type EncodedNodeSnapshot = typeof EncodedNodeSnapshot.Type;\n\nexport const EncodedGraphEdge = Schema.Struct({\n from: Schema.String,\n to: Schema.String,\n /** The dependency name the dependent declared, not the target's tag. */\n dependency: Schema.String,\n});\nexport type EncodedGraphEdge = typeof EncodedGraphEdge.Type;\n\n/**\n * The graph at one instant.\n *\n * The counterpart to the event stream rather than a replacement for it: events\n * say what happened, this says what is true. `capturedAt` and `sequence` are\n * what let a reader hold both at once — a snapshot taken \"as of sequence 4412\"\n * can be lined up against the log the reader already has, instead of being a\n * second account of the same system with no way to relate them.\n */\nexport const GraphSnapshot = Schema.Struct({\n capturedAt: Schema.Number,\n /**\n * The last event sequence the runtime had recorded when this was taken.\n *\n * Absent on a runtime that has not emitted yet, which is the only honest\n * answer — zero would claim a position in a log that has none.\n */\n sequence: Schema.optional(Schema.Number),\n runtimeId: Schema.String,\n runtimeStatus: Schema.String,\n graphStatus: Schema.String,\n observedInputs: Schema.Number,\n /**\n * The policy the app actually applied, which may be less than was asked for.\n *\n * Stated per snapshot rather than inferred from the attachment: a reader that\n * finds no `result` on a node needs to tell \"redacted\" from \"not ready\", and\n * those are the same absence.\n */\n values: ValuePolicy,\n nodes: Schema.Array(EncodedNodeSnapshot),\n edges: Schema.Array(EncodedGraphEdge),\n});\nexport type GraphSnapshot = typeof GraphSnapshot.Type;\n\n/** Every node and edge, with statuses but without results. */\nexport const GraphQuery = Schema.Struct({ _tag: Schema.tag(\"Graph\") });\n\n/** One node, with its result and the edges incident on it. */\nexport const NodeQuery = Schema.Struct({\n _tag: Schema.tag(\"Node\"),\n nodeId: Schema.String,\n});\n\nexport const StateQuery = Schema.Union([GraphQuery, NodeQuery]);\nexport type StateQuery = typeof StateQuery.Type;\n\n/**\n * The app's answer to one query.\n *\n * `Failed` rather than an RPC error because the reply is a separate call from\n * the request: an error on this channel would fail the *reply*, which is not\n * the thing that went wrong, and would leave the hub waiting out its timeout\n * for an answer that already came back.\n */\nexport const QueryOutcome = Schema.Union([\n Schema.Struct({ _tag: Schema.tag(\"Snapshot\"), snapshot: GraphSnapshot }),\n Schema.Struct({ _tag: Schema.tag(\"Failed\"), reason: Schema.String }),\n]);\nexport type QueryOutcome = typeof QueryOutcome.Type;\n\n/** Hub accepted the attachment and assigned it an id. */\nexport const HubAttached = Schema.Struct({\n _tag: Schema.tag(\"Attached\"),\n attachmentId: Schema.String,\n /** What the hub is asking for. The app may downgrade, never upgrade. */\n values: ValuePolicy,\n});\n\n/** Liveness probe; the app answers by continuing to hold the stream open. */\nexport const HubPing = Schema.Struct({\n _tag: Schema.tag(\"Ping\"),\n at: Schema.Number,\n});\n\n/**\n * Asks the app what is true right now.\n *\n * Rides this stream because the hub has no way to call the app — it listens and\n * the app dials, so the only open channel in this direction is the `Attach`\n * response. The answer comes back as a separate `Reply` call rather than in\n * band, which is why `requestId` exists.\n *\n * `values` is requested per query, not per attachment. A stream of events and a\n * deliberate read of one node are different acts: the first is a firehose worth\n * keeping cheap, the second is someone asking a specific question. Both are\n * still clamped by the app's own ceiling, so this widens nothing the app has not\n * already agreed to.\n */\nexport const HubQuery = Schema.Struct({\n _tag: Schema.tag(\"Query\"),\n requestId: Schema.String,\n query: StateQuery,\n values: ValuePolicy,\n});\n\n/** Server-to-client commands. */\nexport const HubCommand = Schema.Union([HubAttached, HubPing, HubQuery]);\nexport type HubCommand = typeof HubCommand.Type;\n\n/**\n * The hub refused the attachment.\n *\n * `reason` is prose for a terminal, not a code to branch on. It is the last\n * thing said on a connection that is about to close, and the symptom on the\n * other end — devtools that quietly never appear — carries no information at\n * all, so the string has to carry the diagnosis and the next step instead. The\n * hub's version mismatch names both versions and which side to upgrade.\n *\n * Specific on purpose, where a rejection elsewhere would be deliberately vague:\n * there is no authentication on this call (see `Attach`), so an uninvited\n * caller learns nothing here it could not learn by dialing and observing, and\n * vagueness would cost only the developer who is actually trying to attach.\n */\nexport class HubRejection extends Schema.TaggedErrorClass<HubRejection>(\"HubRejection\")(\n \"HubRejection\",\n { reason: Schema.String }\n) {}\n\n/**\n * Opens the attachment and holds it open.\n *\n * The stream's lifetime *is* the attachment's lifetime: when the socket drops,\n * the handler is interrupted, which is how the hub learns about detachment.\n * There is no explicit detach call and there should not be one — a crashed app\n * cannot send it.\n *\n * Unauthenticated on purpose. Browsers do not apply CORS to WebSockets, so any\n * page a developer visits can dial a loopback port — but this direction only\n * carries data *into* the hub, so the worst an uninvited caller achieves is\n * putting junk in a dashboard. The direction where app data leaves is the MCP\n * endpoint, and a secret on this half while that one is open would buy nothing\n * and cost every host app a value to configure.\n *\n * The consequence, stated plainly because something downstream has to honour\n * it: records arriving here are not proof of their own origin, and a consumer\n * that feeds them to an agent is feeding it untrusted text.\n */\nexport class Attach extends Rpc.make(\"Frond.Attach\", {\n payload: { info: AttachmentInfo },\n success: HubCommand,\n error: HubRejection,\n stream: true,\n}) {}\n\n/**\n * Pushes a batch of events.\n *\n * `droppedSince` is the sender's count of records it could not buffer since the\n * previous batch. It is not optional and not a nicety: a devtools feed that\n * silently loses events is worse than one that admits to a gap, because an\n * agent reasoning over the stream cannot tell \"did not happen\" from \"was\n * dropped\".\n */\nexport class Ingest extends Rpc.make(\"Frond.Ingest\", {\n payload: {\n attachmentId: Schema.String,\n records: Schema.Array(EncodedEventRecord),\n droppedSince: Schema.Number,\n },\n}) {}\n\n/**\n * Answers one `Query`.\n *\n * A unary call in the app-to-hub direction, correlated by `requestId`, because\n * the RPC roles only run that way — see the note at the top of this file. The\n * consequence worth naming: a reply is not causally tied to the stream that\n * asked for it, so the hub has to time its requests out. An app that dies\n * mid-query simply never calls this.\n */\nexport class Reply extends Rpc.make(\"Frond.Reply\", {\n payload: {\n attachmentId: Schema.String,\n requestId: Schema.String,\n outcome: QueryOutcome,\n },\n}) {}\n\nexport const FrondHubRpcs = RpcGroup.make(Attach, Ingest, Reply);\n"
|
|
6
|
-
],
|
|
7
|
-
"mappings": "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",
|
|
8
|
-
"debugId": "007FD883D686F65364756E2164756E21",
|
|
9
|
-
"names": []
|
|
10
|
-
}
|