@descix/platform-api 1.0.1 → 2.0.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/package.json +1 -1
- package/src/fabric/vocab.js +0 -79
- package/src/mcp-tools/nativeTools.js +70 -20
package/package.json
CHANGED
package/src/fabric/vocab.js
CHANGED
|
@@ -1099,81 +1099,6 @@ export const WATERMARK_FIELDS = Object.freeze([
|
|
|
1099
1099
|
'broadcast_seen', 'delivered', 'resolved', 'held', 'awaiting',
|
|
1100
1100
|
]);
|
|
1101
1101
|
|
|
1102
|
-
/**
|
|
1103
|
-
* THE LEDGER ENTRY — a delivery claim, and WHO made it.
|
|
1104
|
-
*
|
|
1105
|
-
* WHY PROVENANCE. A claim outlives the credibility of whoever made it. A secretary that was stopped
|
|
1106
|
-
* FOR CAUSE left a `delivered` claim on its seat's watermark that its successor could neither trust
|
|
1107
|
-
* nor safely discard, because nothing on the entry said who wrote it: dropping it risked re-handing
|
|
1108
|
-
* mail already delivered, keeping it risked never handing up mail that never was. Stamping the
|
|
1109
|
-
* writer makes that a decidable question, which is the whole point of R2 and the reason
|
|
1110
|
-
* `quarantine` can exist at all.
|
|
1111
|
-
*
|
|
1112
|
-
* ENCODING. An entry is JSON `{"key":…,"writer":…,"at":…}` in the flat string[] the store allows —
|
|
1113
|
-
* a nested object is neither filterable nor projectable here, exactly as the wake block is flat for
|
|
1114
|
-
* the same reason. A BARE STRING is a PRE-PROVENANCE entry: it is READ (so the live ledgers stay
|
|
1115
|
-
* legible) and it is MIGRATED, but it can no longer be WRITTEN.
|
|
1116
|
-
*/
|
|
1117
|
-
export const LEDGER_ENTRY_FIELDS = Object.freeze(['key', 'writer', 'at']);
|
|
1118
|
-
|
|
1119
|
-
/** The record key a ledger entry refers to, whichever encoding it is in. ONE owner of "what does
|
|
1120
|
-
* this entry point at", so dedupe, union and quarantine cannot disagree about identity. */
|
|
1121
|
-
export function ledgerEntryKey(entry) {
|
|
1122
|
-
if (typeof entry !== 'string') return null;
|
|
1123
|
-
if (!entry.startsWith('{')) return entry;
|
|
1124
|
-
try {
|
|
1125
|
-
const p = JSON.parse(entry);
|
|
1126
|
-
return typeof p?.key === 'string' ? p.key : entry;
|
|
1127
|
-
} catch { return entry; }
|
|
1128
|
-
}
|
|
1129
|
-
|
|
1130
|
-
/** The writer that made this claim, or null for a pre-provenance bare entry. */
|
|
1131
|
-
export function ledgerEntryWriter(entry) {
|
|
1132
|
-
if (typeof entry !== 'string' || !entry.startsWith('{')) return null;
|
|
1133
|
-
try {
|
|
1134
|
-
const p = JSON.parse(entry);
|
|
1135
|
-
return typeof p?.writer === 'string' ? p.writer : null;
|
|
1136
|
-
} catch { return null; }
|
|
1137
|
-
}
|
|
1138
|
-
|
|
1139
|
-
/** Stamp a key into a provenance-bearing entry. The clock is the SERVER's, passed in — never read
|
|
1140
|
-
* here — so a ledger entry cannot claim it was written at a time no write happened. */
|
|
1141
|
-
export function stampLedgerEntry(key, writer, at) {
|
|
1142
|
-
return JSON.stringify({ key: String(key), writer: String(writer), at: String(at) });
|
|
1143
|
-
}
|
|
1144
|
-
|
|
1145
|
-
/**
|
|
1146
|
-
* SERVER-SIDE SET-UNION of a ledger field, deduplicated BY KEY, first claim winning.
|
|
1147
|
-
*
|
|
1148
|
-
* This GENERALISES the union `fabric_broadcast_ack` already owned for `broadcast_seen` — it is not
|
|
1149
|
-
* a second owner. That verb computed a merge for exactly one of the five ledger fields and the
|
|
1150
|
-
* semantics were never lifted, which is why every other field was left to a client read-union-write
|
|
1151
|
-
* that a single racing patch could wipe (measured: one patch took a `delivered` ledger from 98
|
|
1152
|
-
* entries to 1).
|
|
1153
|
-
*
|
|
1154
|
-
* FIRST CLAIM WINS on a duplicate key, so the union is IDEMPOTENT and re-appending an entry does
|
|
1155
|
-
* not restamp it with a later writer's name — a delivery is a fact about when it FIRST happened.
|
|
1156
|
-
*/
|
|
1157
|
-
export function unionLedger(existing = [], incoming = []) {
|
|
1158
|
-
const out = [];
|
|
1159
|
-
const seen = new Set();
|
|
1160
|
-
for (const e of [...(existing || []), ...(incoming || [])]) {
|
|
1161
|
-
const k = ledgerEntryKey(e);
|
|
1162
|
-
if (k === null || seen.has(k)) continue;
|
|
1163
|
-
seen.add(k);
|
|
1164
|
-
out.push(e);
|
|
1165
|
-
}
|
|
1166
|
-
return out;
|
|
1167
|
-
}
|
|
1168
|
-
|
|
1169
|
-
/**
|
|
1170
|
-
* The write modes `fabric_watermark_put` accepts — the two generic ones PLUS the two the ledger
|
|
1171
|
-
* needs. It is its OWN set rather than an extension of WRITE_MODES because `append` and
|
|
1172
|
-
* `quarantine` are meaningless on every other record on this surface, and widening the shared enum
|
|
1173
|
-
* would advertise them on verbs that would then have to refuse them one by one.
|
|
1174
|
-
*/
|
|
1175
|
-
export const WATERMARK_WRITE_MODES = Object.freeze([...WRITE_MODES, 'append', 'quarantine']);
|
|
1176
|
-
|
|
1177
1102
|
// ── Predicates ───────────────────────────────────────────────────────────────────────────────
|
|
1178
1103
|
|
|
1179
1104
|
/** Case-folded membership. The fabric is written by shells, Python hooks and models alike; a
|
|
@@ -1331,10 +1256,6 @@ export function fabricVocabulary() {
|
|
|
1331
1256
|
// The lifecycle fields that SURVIVE a write that does not mention them, on both
|
|
1332
1257
|
// fabric_envelope_put and fabric_contract_put.
|
|
1333
1258
|
lifecycle_preserved_fields: [...LIFECYCLE_PRESERVED_FIELDS],
|
|
1334
|
-
// The ledger's provenance contract: the modes fabric_watermark_put accepts and the
|
|
1335
|
-
// fields every stamped entry carries.
|
|
1336
|
-
watermark_write_modes: [...WATERMARK_WRITE_MODES],
|
|
1337
|
-
ledger_entry_fields: [...LEDGER_ENTRY_FIELDS],
|
|
1338
1259
|
wake_record_field_names: [...WAKE_RECORD_FIELD_NAMES],
|
|
1339
1260
|
// The beat-clock contract, so the plugin reader GENERATES its copy of "which field is the
|
|
1340
1261
|
// model's clock" instead of hand-typing it — the exact mirror that made the two-writers
|
|
@@ -51,7 +51,7 @@ import { filterOperatorClause, SCALAR_FILTER_OPERATORS, ARRAY_FILTER_OPERATORS }
|
|
|
51
51
|
// zero-import leaf, so this import respects the infrastructure-free rule above.
|
|
52
52
|
import {
|
|
53
53
|
BEAT_STATUSES, LEGACY_WORKING_STATUSES, LEGACY_STOP_STATUSES, LIVENESS_VALUES,
|
|
54
|
-
WRITE_MODES,
|
|
54
|
+
WRITE_MODES, WAKE_EXEMPT_STATUSES, WATERMARK_FIELDS, ENVELOPE_STATUSES, ENVELOPE_STATUS_DEFAULT, TO_AGENT_SENTINELS,
|
|
55
55
|
ENVELOPE_SECTIONS, ENVELOPE_TEXT_SHAPE, ENVELOPE_PHASES, ENVELOPE_PHASE_DEFAULT, ENVELOPE_PHASE_TRANSITIONS,
|
|
56
56
|
FABRIC_RECORD_KINDS,
|
|
57
57
|
RETIRED_SENTINELS, BEAT_CLOCK_FIELDS, beatClockFieldFor, beatClockAgeField,
|
|
@@ -355,6 +355,73 @@ export const NATIVE_MCP_TOOLS = Object.freeze([
|
|
|
355
355
|
required: ['app_id', 'kb_id'],
|
|
356
356
|
},
|
|
357
357
|
},
|
|
358
|
+
{
|
|
359
|
+
name: 'app_record_entry_create',
|
|
360
|
+
description: 'Row-level CRUD on ONE entry of ONE top-level LIST field of ONE app record, performed SERVER-SIDE inside a transaction. Use these instead of read-modify-writing a list through app_records_put. That pattern is lossy in two directions at once: anything a concurrent writer appends between your read and your write is destroyed with no error (a delivery ledger was measured going from 98 entries to 1), and because the whole list travels through your process on every append, ONE bad character replaces the entire accumulated array while the put still answers success:true. Here the list NEVER travels — you name one entry by key and the reply carries a COUNT and a SHA of the resulting list, which you can recompute and compare. TWO LIST SHAPES ARE SUPPORTED and a list keeps the shape it has. A FLAT string[] — which is what every delivery ledger already is — needs NO migration: the string IS its own key, so you address it with entry_key alone and omit `entry`. A list of OBJECTS carries a server-stamped `entry_key` on each. Mixing shapes is refused rather than guessed. REFUSE-NEVER-COERCE: a missing field, a non-array target, an element that is neither a string nor a keyed object, a shape change, a 1MB overflow, and (on update) a field changing JSON type or a nested merge that would drop inner keys are each REFUSED BY NAME with nothing written. CREATE one entry. FIRST-CLAIM-WINS: if `entry_key` already exists it is REFUSED (APP_ENTRY_EXISTS) and never overwritten, so two racing creators cannot both believe they authored it.',
|
|
361
|
+
mutating: true,
|
|
362
|
+
inputSchema: {
|
|
363
|
+
type: 'object',
|
|
364
|
+
properties: {
|
|
365
|
+
app_id: { type: 'string', description: 'App ID that owns the record.' },
|
|
366
|
+
kb_id: { type: 'string', description: 'Record collection ID.' },
|
|
367
|
+
file_id: { type: 'string', description: 'The record whose list field is being addressed. The record must already exist — it is never created for you, because a typo would silently start a second record.' },
|
|
368
|
+
field: { type: 'string', description: 'The TOP-LEVEL field holding the list. It must already exist and already be an array; neither is created or converted for you.' },
|
|
369
|
+
entry_key: { type: 'string', description: 'Identity of the ONE entry addressed. Server-stamped into the stored entry as `entry_key`; a contradicting copy inside the entry body is refused rather than silently overridden.' },
|
|
370
|
+
entry: { type: 'object', description: 'OPTIONAL. The entry body for an OBJECT-shaped list; `entry_key` is stamped in by the server. OMIT it for a flat string[] list, where the stored element is the entry_key itself. Supplying it against a string-shaped list is REFUSED rather than silently converting the list, which would make the ledger unwritable through fabric_watermark_put.' },
|
|
371
|
+
},
|
|
372
|
+
required: ['app_id', 'kb_id', 'file_id', 'field', 'entry_key'],
|
|
373
|
+
},
|
|
374
|
+
},
|
|
375
|
+
{
|
|
376
|
+
name: 'app_record_entry_get',
|
|
377
|
+
description: 'Row-level CRUD on ONE entry of ONE top-level LIST field of ONE app record, performed SERVER-SIDE inside a transaction. Use these instead of read-modify-writing a list through app_records_put. That pattern is lossy in two directions at once: anything a concurrent writer appends between your read and your write is destroyed with no error (a delivery ledger was measured going from 98 entries to 1), and because the whole list travels through your process on every append, ONE bad character replaces the entire accumulated array while the put still answers success:true. Here the list NEVER travels — you name one entry by key and the reply carries a COUNT and a SHA of the resulting list, which you can recompute and compare. TWO LIST SHAPES ARE SUPPORTED and a list keeps the shape it has. A FLAT string[] — which is what every delivery ledger already is — needs NO migration: the string IS its own key, so you address it with entry_key alone and omit `entry`. A list of OBJECTS carries a server-stamped `entry_key` on each. Mixing shapes is refused rather than guessed. REFUSE-NEVER-COERCE: a missing field, a non-array target, an element that is neither a string nor a keyed object, a shape change, a 1MB overflow, and (on update) a field changing JSON type or a nested merge that would drop inner keys are each REFUSED BY NAME with nothing written. READ one entry, never the list. An ABSENT key is a SUCCESS with count 0 and a named `empty_reason` — an empty result is a success, never an error — so a get-after-delete truthfully returns 0. The three writing verbs still REFUSE an absent key: acting on nothing differs from looking at nothing.',
|
|
378
|
+
mutating: false,
|
|
379
|
+
inputSchema: {
|
|
380
|
+
type: 'object',
|
|
381
|
+
properties: {
|
|
382
|
+
app_id: { type: 'string', description: 'App ID that owns the record.' },
|
|
383
|
+
kb_id: { type: 'string', description: 'Record collection ID.' },
|
|
384
|
+
file_id: { type: 'string', description: 'The record whose list field is being addressed. The record must already exist — it is never created for you, because a typo would silently start a second record.' },
|
|
385
|
+
field: { type: 'string', description: 'The TOP-LEVEL field holding the list. It must already exist and already be an array; neither is created or converted for you.' },
|
|
386
|
+
entry_key: { type: 'string', description: 'Identity of the ONE entry addressed. Server-stamped into the stored entry as `entry_key`; a contradicting copy inside the entry body is refused rather than silently overridden.' },
|
|
387
|
+
fields: { type: 'array', items: { type: 'string' }, description: 'Optional projection of the returned entry. Omit or ["*"] for the whole entry.' },
|
|
388
|
+
},
|
|
389
|
+
required: ['app_id', 'kb_id', 'file_id', 'field', 'entry_key'],
|
|
390
|
+
},
|
|
391
|
+
},
|
|
392
|
+
{
|
|
393
|
+
name: 'app_record_entry_update',
|
|
394
|
+
description: 'Row-level CRUD on ONE entry of ONE top-level LIST field of ONE app record, performed SERVER-SIDE inside a transaction. Use these instead of read-modify-writing a list through app_records_put. That pattern is lossy in two directions at once: anything a concurrent writer appends between your read and your write is destroyed with no error (a delivery ledger was measured going from 98 entries to 1), and because the whole list travels through your process on every append, ONE bad character replaces the entire accumulated array while the put still answers success:true. Here the list NEVER travels — you name one entry by key and the reply carries a COUNT and a SHA of the resulting list, which you can recompute and compare. TWO LIST SHAPES ARE SUPPORTED and a list keeps the shape it has. A FLAT string[] — which is what every delivery ledger already is — needs NO migration: the string IS its own key, so you address it with entry_key alone and omit `entry`. A list of OBJECTS carries a server-stamped `entry_key` on each. Mixing shapes is refused rather than guessed. REFUSE-NEVER-COERCE: a missing field, a non-array target, an element that is neither a string nor a keyed object, a shape change, a 1MB overflow, and (on update) a field changing JSON type or a nested merge that would drop inner keys are each REFUSED BY NAME with nothing written. UPDATE one entry by merging `entry` into the stored one. REFUSES an absent key (APP_ENTRY_ABSENT) — it never creates, because a typo would otherwise add a second entry beside the one you meant to change — and REFUSES a field whose JSON type would change (APP_ENTRY_STORED_TYPE_DISAGREEMENT), which breaks every reader that already parsed it. A nested object is merged SHALLOWLY, so a merge that would drop inner keys is REFUSED (APP_ENTRY_NESTED_KEY_DROP) — send the whole sub-object, or delete and re-create the entry. A flat string[] entry has no body to merge and update is refused on it: its whole value is its key, so a rename is a delete plus a create.',
|
|
395
|
+
mutating: true,
|
|
396
|
+
inputSchema: {
|
|
397
|
+
type: 'object',
|
|
398
|
+
properties: {
|
|
399
|
+
app_id: { type: 'string', description: 'App ID that owns the record.' },
|
|
400
|
+
kb_id: { type: 'string', description: 'Record collection ID.' },
|
|
401
|
+
file_id: { type: 'string', description: 'The record whose list field is being addressed. The record must already exist — it is never created for you, because a typo would silently start a second record.' },
|
|
402
|
+
field: { type: 'string', description: 'The TOP-LEVEL field holding the list. It must already exist and already be an array; neither is created or converted for you.' },
|
|
403
|
+
entry_key: { type: 'string', description: 'Identity of the ONE entry addressed. Server-stamped into the stored entry as `entry_key`; a contradicting copy inside the entry body is refused rather than silently overridden.' },
|
|
404
|
+
entry: { type: 'object', description: 'Fields to merge into the stored entry. `entry_key` is server-owned.' },
|
|
405
|
+
},
|
|
406
|
+
required: ['app_id', 'kb_id', 'file_id', 'field', 'entry_key', 'entry'],
|
|
407
|
+
},
|
|
408
|
+
},
|
|
409
|
+
{
|
|
410
|
+
name: 'app_record_entry_delete',
|
|
411
|
+
description: 'Row-level CRUD on ONE entry of ONE top-level LIST field of ONE app record, performed SERVER-SIDE inside a transaction. Use these instead of read-modify-writing a list through app_records_put. That pattern is lossy in two directions at once: anything a concurrent writer appends between your read and your write is destroyed with no error (a delivery ledger was measured going from 98 entries to 1), and because the whole list travels through your process on every append, ONE bad character replaces the entire accumulated array while the put still answers success:true. Here the list NEVER travels — you name one entry by key and the reply carries a COUNT and a SHA of the resulting list, which you can recompute and compare. TWO LIST SHAPES ARE SUPPORTED and a list keeps the shape it has. A FLAT string[] — which is what every delivery ledger already is — needs NO migration: the string IS its own key, so you address it with entry_key alone and omit `entry`. A list of OBJECTS carries a server-stamped `entry_key` on each. Mixing shapes is refused rather than guessed. REFUSE-NEVER-COERCE: a missing field, a non-array target, an element that is neither a string nor a keyed object, a shape change, a 1MB overflow, and (on update) a field changing JSON type or a nested merge that would drop inner keys are each REFUSED BY NAME with nothing written. DELETE one entry. REFUSES an absent key (APP_ENTRY_ABSENT) rather than reporting a deletion that removed nothing, which is indistinguishable from a misspelled key.',
|
|
412
|
+
mutating: true,
|
|
413
|
+
inputSchema: {
|
|
414
|
+
type: 'object',
|
|
415
|
+
properties: {
|
|
416
|
+
app_id: { type: 'string', description: 'App ID that owns the record.' },
|
|
417
|
+
kb_id: { type: 'string', description: 'Record collection ID.' },
|
|
418
|
+
file_id: { type: 'string', description: 'The record whose list field is being addressed. The record must already exist — it is never created for you, because a typo would silently start a second record.' },
|
|
419
|
+
field: { type: 'string', description: 'The TOP-LEVEL field holding the list. It must already exist and already be an array; neither is created or converted for you.' },
|
|
420
|
+
entry_key: { type: 'string', description: 'Identity of the ONE entry addressed. Server-stamped into the stored entry as `entry_key`; a contradicting copy inside the entry body is refused rather than silently overridden.' },
|
|
421
|
+
},
|
|
422
|
+
required: ['app_id', 'kb_id', 'file_id', 'field', 'entry_key'],
|
|
423
|
+
},
|
|
424
|
+
},
|
|
358
425
|
// ─────────────────────────────────────────────────────────────────────────────────────────
|
|
359
426
|
// COORDINATION FABRIC — typed verbs over the app-records collection egpt-frqtl/coordination.
|
|
360
427
|
//
|
|
@@ -566,33 +633,16 @@ export const NATIVE_MCP_TOOLS = Object.freeze([
|
|
|
566
633
|
required: ['seat_label'],
|
|
567
634
|
},
|
|
568
635
|
},
|
|
569
|
-
{
|
|
570
|
-
name: 'fabric_watermark_migrate',
|
|
571
|
-
description: 'Migrate one seat\'s watermark onto the provenance-bearing ledger. IT REPORTS, IT NEVER DROPS: every entry gets exactly one of three NAMED fates — MOVED (a field that is not one of the five ledger fields, e.g. a `notes` paragraph that could only have arrived by a raw app_records_put; it is written onto seat-state-<LABEL> BEFORE it is cleared here), STAMPED (a pre-provenance bare entry, now attributed to you and marked as having no recorded original writer), or REFUSED (an entry that cannot be represented in the typed ledger — PROSE rather than a record key — which is LEFT EXACTLY WHERE IT IS for a human to re-file). A refusal is a BLOCK on that entry, never a warning that precedes a deletion. Run once per seat before switching that seat to mode:append.',
|
|
572
|
-
mutating: true,
|
|
573
|
-
inputSchema: {
|
|
574
|
-
type: 'object',
|
|
575
|
-
properties: {
|
|
576
|
-
seat_label: { type: 'string', description: 'The seat LABEL whose watermark is being migrated.' },
|
|
577
|
-
writer: { type: 'string', description: 'REQUIRED — the agent id running the migration. Pre-provenance entries are stamped with it and explicitly marked as having no recorded original writer, so a migrated claim is never mistaken for one this writer actually made.' },
|
|
578
|
-
},
|
|
579
|
-
required: ['seat_label', 'writer'],
|
|
580
|
-
additionalProperties: false,
|
|
581
|
-
},
|
|
582
|
-
},
|
|
583
636
|
{
|
|
584
637
|
name: 'fabric_watermark_put',
|
|
585
|
-
description: 'Write the delivery ledger "watermark-<LABEL>". `mode` is REQUIRED and has NO DEFAULT.
|
|
586
|
-
+ WATERMARK_FIELDS.length + ' fields: ' + WATERMARK_FIELDS.join(', ')
|
|
638
|
+
description: 'Write the delivery ledger "watermark-<LABEL>". `mode` is REQUIRED and has NO DEFAULT. \'patch\' merges the FIELDS you send and leaves the other ledger fields alone; \'replace\' additionally CLEARS every ledger field you omit. NEITHER MERGES WITHIN A FIELD: each array you send REPLACES that field\'s array wholesale, so you must send the WHOLE list you intend to be stored. To protect that, a write that would DROP an entry the ledger already holds is REFUSED BY NAME (FABRIC_WATERMARK_DESTRUCTIVE_WRITE) and nothing is written — a delivery claim that vanishes is indistinguishable afterwards from mail that never arrived, and the read-modify-write every caller performs here loses entries whenever a concurrent writer lands between the read and the write. Adding entries is always allowed; there is NO removal path on this verb, in either mode — withdrawing a claim is a different act from recording one and is not offered as a side effect of a routine put. The ledger has exactly ' + WATERMARK_FIELDS.length + ' fields: ' + WATERMARK_FIELDS.join(', ')
|
|
587
639
|
+ '. Any other field is REJECTED rather than stored, because a ledger field no reader consults is a delivery record that silently does nothing. broadcast_seen is the correct place to record that this seat has processed a broadcast — never flip the broadcast itself.',
|
|
588
640
|
mutating: true,
|
|
589
641
|
inputSchema: {
|
|
590
642
|
type: 'object',
|
|
591
643
|
properties: {
|
|
592
644
|
seat_label: { type: 'string', description: 'The seat LABEL.' },
|
|
593
|
-
mode: { type: 'string', enum: [...
|
|
594
|
-
writer: { type: 'string', description: 'REQUIRED on every write that touches the ledger — the agent id making the claim. Stamped onto every entry so a successor can decide WHOSE claims to trust.' },
|
|
595
|
-
quarantine_writer: { type: 'string', description: 'Required by mode \'quarantine\' and meaningless otherwise: the writer whose claims are being withdrawn. Without it a quarantine would be an untargeted delete of the whole ledger, so it is refused.' },
|
|
645
|
+
mode: { type: 'string', enum: [...WRITE_MODES], description: 'REQUIRED, no default. patch = merge these FIELDS, leaving other ledger fields untouched. replace = this call is the whole ledger; every field you omit is CLEARED. Within a field both write the array you send WHOLESALE — there is no server-side merge — and both REFUSE a write that would drop an entry already stored, whether by sending a shorter array or (under replace) by omitting a field that holds entries.' },
|
|
596
646
|
// AN ARRAY, because that is what the writer writes. fabric_broadcast_ack merges the
|
|
597
647
|
// acknowledged KEYS into this field as a list and re-reads it as a list; publishing
|
|
598
648
|
// it as a `string` "high-water mark" advertised a shape no code on either side ever
|