@tinyshed/tinystore 0.1.0 → 0.2.0-rc.1
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/dist/blobs.d.ts +1 -1
- package/dist/blobs.js +13 -5
- package/dist/cancel.d.ts +16 -2
- package/dist/cancel.js +36 -2
- package/dist/channels.js +20 -6
- package/dist/config.d.ts +49 -1
- package/dist/config.js +86 -7
- package/dist/connection.d.ts +52 -10
- package/dist/connection.js +305 -73
- package/dist/handles.d.ts +10 -1
- package/dist/handles.js +27 -4
- package/dist/index.d.ts +5 -5
- package/dist/jobs.d.ts +35 -1
- package/dist/jobs.js +46 -0
- package/dist/logger.d.ts +22 -10
- package/dist/logger.js +118 -28
- package/dist/metrics.d.ts +24 -1
- package/dist/metrics.js +24 -1
- package/dist/query.js +33 -9
- package/dist/records.d.ts +48 -7
- package/dist/records.js +22 -3
- package/dist/runtime/addon.js +3 -2
- package/dist/runtime/bun.js +33 -12
- package/dist/runtime/node.js +30 -8
- package/dist/runtime/pipe.d.ts +2 -0
- package/dist/runtime/pipe.js +45 -20
- package/dist/runtime/shared.d.ts +28 -4
- package/dist/runtime/shared.js +125 -13
- package/dist/runtime.d.ts +28 -6
- package/dist/session.d.ts +9 -5
- package/dist/session.js +113 -31
- package/dist/sql.d.ts +18 -5
- package/dist/sql.js +44 -11
- package/dist/store.d.ts +25 -11
- package/dist/store.js +67 -9
- package/dist/time.d.ts +2 -0
- package/dist/wire/codec.d.ts +5 -0
- package/dist/wire/codec.js +10 -0
- package/dist/wire/frame.d.ts +2 -0
- package/dist/wire/frame.js +4 -0
- package/dist/wire/msgpack.d.ts +7 -3
- package/dist/wire/msgpack.js +11 -4
- package/dist/wire/protocol.d.ts +280 -36
- package/dist/wire/protocol.js +510 -102
- package/package.json +9 -8
- package/src/blobs.ts +13 -5
- package/src/cancel.ts +44 -2
- package/src/channels.ts +21 -6
- package/src/config.ts +138 -12
- package/src/connection.ts +377 -77
- package/src/handles.ts +32 -4
- package/src/index.ts +6 -1
- package/src/jobs.ts +66 -0
- package/src/logger.ts +158 -40
- package/src/metrics.ts +53 -2
- package/src/query.ts +33 -13
- package/src/records.ts +73 -10
- package/src/runtime/addon.ts +3 -2
- package/src/runtime/bun.ts +44 -9
- package/src/runtime/node.ts +30 -5
- package/src/runtime/pipe.ts +49 -19
- package/src/runtime/shared.ts +137 -16
- package/src/runtime.ts +31 -6
- package/src/session.ts +129 -30
- package/src/sql.ts +48 -14
- package/src/store.ts +81 -14
- package/src/time.ts +3 -0
- package/src/wire/codec.ts +11 -0
- package/src/wire/frame.ts +5 -0
- package/src/wire/msgpack.ts +11 -4
- package/src/wire/protocol.ts +532 -104
package/dist/wire/protocol.js
CHANGED
|
@@ -97,6 +97,7 @@ export const methods = {
|
|
|
97
97
|
'metrics.delete': 0x060c,
|
|
98
98
|
'metrics.flush': 0x060d,
|
|
99
99
|
'metrics.instruments': 0x060e,
|
|
100
|
+
'metrics.ingestPrometheus': 0x060f,
|
|
100
101
|
'records.open': 0x0501,
|
|
101
102
|
'records.append': 0x0502,
|
|
102
103
|
'records.list': 0x0503,
|
|
@@ -1570,75 +1571,121 @@ export const ConfigOpen = message('config.Open', {
|
|
|
1570
1571
|
},
|
|
1571
1572
|
});
|
|
1572
1573
|
/**
|
|
1573
|
-
*
|
|
1574
|
+
* Where a value came from: its kind, and only the fields that kind names.
|
|
1574
1575
|
*/
|
|
1575
|
-
export const
|
|
1576
|
-
|
|
1577
|
-
|
|
1578
|
-
|
|
1579
|
-
|
|
1580
|
-
/**
|
|
1581
|
-
|
|
1576
|
+
export const ConfigOrigin = message('config.Origin', {
|
|
1577
|
+
/** declaration, layer, file, env or change */
|
|
1578
|
+
kind: [1, str],
|
|
1579
|
+
/** a layer's place in the list, the declaration 1 */
|
|
1580
|
+
place: [2, uint],
|
|
1581
|
+
/** a file's path */
|
|
1582
|
+
path: [3, str],
|
|
1583
|
+
/** an env's variable */
|
|
1584
|
+
variable: [4, str],
|
|
1585
|
+
/** the .env file that set the variable */
|
|
1586
|
+
dotenv: [5, str],
|
|
1587
|
+
/** the file a NAME_FILE variable named */
|
|
1588
|
+
file: [6, str],
|
|
1589
|
+
/** a change's version */
|
|
1590
|
+
version: [7, int],
|
|
1591
|
+
/** when a change was made */
|
|
1592
|
+
at: [8, int],
|
|
1582
1593
|
}, {
|
|
1583
1594
|
write(w, v) {
|
|
1584
1595
|
const head = w.openMap();
|
|
1585
1596
|
let n = 0;
|
|
1586
|
-
if (v.
|
|
1597
|
+
if (v.kind !== undefined) {
|
|
1587
1598
|
w.field(1);
|
|
1588
|
-
w.str(v.
|
|
1599
|
+
w.str(v.kind);
|
|
1589
1600
|
n++;
|
|
1590
1601
|
}
|
|
1591
|
-
if (v.
|
|
1602
|
+
if (v.place !== undefined) {
|
|
1592
1603
|
w.field(2);
|
|
1593
|
-
w.
|
|
1604
|
+
w.uint(v.place);
|
|
1594
1605
|
n++;
|
|
1595
1606
|
}
|
|
1596
|
-
if (v.
|
|
1607
|
+
if (v.path !== undefined) {
|
|
1597
1608
|
w.field(3);
|
|
1598
|
-
w.str(v.
|
|
1609
|
+
w.str(v.path);
|
|
1599
1610
|
n++;
|
|
1600
1611
|
}
|
|
1601
|
-
if (v.
|
|
1612
|
+
if (v.variable !== undefined) {
|
|
1602
1613
|
w.field(4);
|
|
1603
|
-
w.
|
|
1604
|
-
|
|
1605
|
-
|
|
1606
|
-
|
|
1614
|
+
w.str(v.variable);
|
|
1615
|
+
n++;
|
|
1616
|
+
}
|
|
1617
|
+
if (v.dotenv !== undefined) {
|
|
1618
|
+
w.field(5);
|
|
1619
|
+
w.str(v.dotenv);
|
|
1620
|
+
n++;
|
|
1621
|
+
}
|
|
1622
|
+
if (v.file !== undefined) {
|
|
1623
|
+
w.field(6);
|
|
1624
|
+
w.str(v.file);
|
|
1625
|
+
n++;
|
|
1626
|
+
}
|
|
1627
|
+
if (v.version !== undefined) {
|
|
1628
|
+
w.field(7);
|
|
1629
|
+
w.int(v.version);
|
|
1630
|
+
n++;
|
|
1631
|
+
}
|
|
1632
|
+
if (v.at !== undefined) {
|
|
1633
|
+
w.field(8);
|
|
1634
|
+
w.int(v.at);
|
|
1607
1635
|
n++;
|
|
1608
1636
|
}
|
|
1609
1637
|
w.closeMap(head, n);
|
|
1610
1638
|
},
|
|
1611
1639
|
read(r) {
|
|
1640
|
+
let $kind;
|
|
1641
|
+
let $place;
|
|
1612
1642
|
let $path;
|
|
1613
|
-
let $
|
|
1614
|
-
let $
|
|
1615
|
-
let $
|
|
1643
|
+
let $variable;
|
|
1644
|
+
let $dotenv;
|
|
1645
|
+
let $file;
|
|
1646
|
+
let $version;
|
|
1647
|
+
let $at;
|
|
1616
1648
|
for (let n = r.message(); n > 0; n--) {
|
|
1617
1649
|
switch (r.field()) {
|
|
1618
1650
|
case 1:
|
|
1619
|
-
$
|
|
1651
|
+
$kind = r.str();
|
|
1620
1652
|
break;
|
|
1621
1653
|
case 2:
|
|
1622
|
-
$
|
|
1654
|
+
$place = r.uint();
|
|
1623
1655
|
break;
|
|
1624
1656
|
case 3:
|
|
1625
|
-
$
|
|
1657
|
+
$path = r.str();
|
|
1626
1658
|
break;
|
|
1627
|
-
case 4:
|
|
1628
|
-
|
|
1629
|
-
|
|
1630
|
-
|
|
1631
|
-
|
|
1632
|
-
|
|
1633
|
-
|
|
1659
|
+
case 4:
|
|
1660
|
+
$variable = r.str();
|
|
1661
|
+
break;
|
|
1662
|
+
case 5:
|
|
1663
|
+
$dotenv = r.str();
|
|
1664
|
+
break;
|
|
1665
|
+
case 6:
|
|
1666
|
+
$file = r.str();
|
|
1667
|
+
break;
|
|
1668
|
+
case 7:
|
|
1669
|
+
$version = r.int();
|
|
1670
|
+
break;
|
|
1671
|
+
case 8:
|
|
1672
|
+
$at = r.int();
|
|
1634
1673
|
break;
|
|
1635
|
-
}
|
|
1636
1674
|
default:
|
|
1637
1675
|
r.skip();
|
|
1638
1676
|
}
|
|
1639
1677
|
}
|
|
1640
1678
|
r.leave();
|
|
1641
|
-
return {
|
|
1679
|
+
return {
|
|
1680
|
+
kind: $kind,
|
|
1681
|
+
place: $place,
|
|
1682
|
+
path: $path,
|
|
1683
|
+
variable: $variable,
|
|
1684
|
+
dotenv: $dotenv,
|
|
1685
|
+
file: $file,
|
|
1686
|
+
version: $version,
|
|
1687
|
+
at: $at,
|
|
1688
|
+
};
|
|
1642
1689
|
},
|
|
1643
1690
|
});
|
|
1644
1691
|
/**
|
|
@@ -2038,6 +2085,8 @@ export const StoreOptions = message('store.Options', {
|
|
|
2038
2085
|
selfMetrics: [13, bool],
|
|
2039
2086
|
/** with selfMetrics, leaves out the machine it runs on: its process's memory and processor, the system's */
|
|
2040
2087
|
withoutSystem: [14, bool],
|
|
2088
|
+
/** the metrics series the store holds at most; 100,000 when absent */
|
|
2089
|
+
maxSeries: [15, uint],
|
|
2041
2090
|
}, {
|
|
2042
2091
|
write(w, v) {
|
|
2043
2092
|
const head = w.openMap();
|
|
@@ -2121,6 +2170,11 @@ export const StoreOptions = message('store.Options', {
|
|
|
2121
2170
|
w.bool(v.withoutSystem);
|
|
2122
2171
|
n++;
|
|
2123
2172
|
}
|
|
2173
|
+
if (v.maxSeries !== undefined) {
|
|
2174
|
+
w.field(15);
|
|
2175
|
+
w.uint(v.maxSeries);
|
|
2176
|
+
n++;
|
|
2177
|
+
}
|
|
2124
2178
|
w.closeMap(head, n);
|
|
2125
2179
|
},
|
|
2126
2180
|
read(r) {
|
|
@@ -2138,6 +2192,7 @@ export const StoreOptions = message('store.Options', {
|
|
|
2138
2192
|
let $insecure;
|
|
2139
2193
|
let $selfMetrics;
|
|
2140
2194
|
let $withoutSystem;
|
|
2195
|
+
let $maxSeries;
|
|
2141
2196
|
for (let n = r.message(); n > 0; n--) {
|
|
2142
2197
|
switch (r.field()) {
|
|
2143
2198
|
case 1:
|
|
@@ -2200,6 +2255,9 @@ export const StoreOptions = message('store.Options', {
|
|
|
2200
2255
|
case 14:
|
|
2201
2256
|
$withoutSystem = r.bool();
|
|
2202
2257
|
break;
|
|
2258
|
+
case 15:
|
|
2259
|
+
$maxSeries = r.uint();
|
|
2260
|
+
break;
|
|
2203
2261
|
default:
|
|
2204
2262
|
r.skip();
|
|
2205
2263
|
}
|
|
@@ -2220,6 +2278,7 @@ export const StoreOptions = message('store.Options', {
|
|
|
2220
2278
|
insecure: $insecure,
|
|
2221
2279
|
selfMetrics: $selfMetrics,
|
|
2222
2280
|
withoutSystem: $withoutSystem,
|
|
2281
|
+
maxSeries: $maxSeries,
|
|
2223
2282
|
};
|
|
2224
2283
|
},
|
|
2225
2284
|
});
|
|
@@ -2510,6 +2569,8 @@ export const JobsQueueOpen = message('jobs.QueueOpen', {
|
|
|
2510
2569
|
maxWaiting: [9, uint],
|
|
2511
2570
|
/** a database's handle: the queue lives in its file; jobs.db when absent */
|
|
2512
2571
|
database: [10, uint],
|
|
2572
|
+
/** each group's starts, beside the queue's rate */
|
|
2573
|
+
groupRate: [11, JobsRate],
|
|
2513
2574
|
}, {
|
|
2514
2575
|
write(w, v) {
|
|
2515
2576
|
const head = w.openMap();
|
|
@@ -2564,6 +2625,11 @@ export const JobsQueueOpen = message('jobs.QueueOpen', {
|
|
|
2564
2625
|
w.uint(v.database);
|
|
2565
2626
|
n++;
|
|
2566
2627
|
}
|
|
2628
|
+
if (v.groupRate !== undefined) {
|
|
2629
|
+
w.field(11);
|
|
2630
|
+
JobsRate.write(w, v.groupRate);
|
|
2631
|
+
n++;
|
|
2632
|
+
}
|
|
2567
2633
|
w.closeMap(head, n);
|
|
2568
2634
|
},
|
|
2569
2635
|
read(r) {
|
|
@@ -2577,6 +2643,7 @@ export const JobsQueueOpen = message('jobs.QueueOpen', {
|
|
|
2577
2643
|
let $keep;
|
|
2578
2644
|
let $maxWaiting;
|
|
2579
2645
|
let $database;
|
|
2646
|
+
let $groupRate;
|
|
2580
2647
|
for (let n = r.message(); n > 0; n--) {
|
|
2581
2648
|
switch (r.field()) {
|
|
2582
2649
|
case 1:
|
|
@@ -2609,6 +2676,9 @@ export const JobsQueueOpen = message('jobs.QueueOpen', {
|
|
|
2609
2676
|
case 10:
|
|
2610
2677
|
$database = r.uint();
|
|
2611
2678
|
break;
|
|
2679
|
+
case 11:
|
|
2680
|
+
$groupRate = JobsRate.read(r);
|
|
2681
|
+
break;
|
|
2612
2682
|
default:
|
|
2613
2683
|
r.skip();
|
|
2614
2684
|
}
|
|
@@ -2625,6 +2695,7 @@ export const JobsQueueOpen = message('jobs.QueueOpen', {
|
|
|
2625
2695
|
keep: $keep,
|
|
2626
2696
|
maxWaiting: $maxWaiting,
|
|
2627
2697
|
database: $database,
|
|
2698
|
+
groupRate: $groupRate,
|
|
2628
2699
|
};
|
|
2629
2700
|
},
|
|
2630
2701
|
});
|
|
@@ -5625,6 +5696,10 @@ export const MetricsAggregateAsked = message('metrics.AggregateAsked', {
|
|
|
5625
5696
|
without: [5, list(str)],
|
|
5626
5697
|
/** a timer's percentile also gives a point between its bounds */
|
|
5627
5698
|
estimate: [6, bool],
|
|
5699
|
+
/** day, week or month: buckets of a calendar in timeZone, in place of every */
|
|
5700
|
+
calendar: [7, str],
|
|
5701
|
+
/** an IANA name, UTC among them, which calendar takes */
|
|
5702
|
+
timeZone: [8, str],
|
|
5628
5703
|
}, {
|
|
5629
5704
|
write(w, v) {
|
|
5630
5705
|
const head = w.openMap();
|
|
@@ -5665,6 +5740,16 @@ export const MetricsAggregateAsked = message('metrics.AggregateAsked', {
|
|
|
5665
5740
|
w.bool(v.estimate);
|
|
5666
5741
|
n++;
|
|
5667
5742
|
}
|
|
5743
|
+
if (v.calendar !== undefined) {
|
|
5744
|
+
w.field(7);
|
|
5745
|
+
w.str(v.calendar);
|
|
5746
|
+
n++;
|
|
5747
|
+
}
|
|
5748
|
+
if (v.timeZone !== undefined) {
|
|
5749
|
+
w.field(8);
|
|
5750
|
+
w.str(v.timeZone);
|
|
5751
|
+
n++;
|
|
5752
|
+
}
|
|
5668
5753
|
w.closeMap(head, n);
|
|
5669
5754
|
},
|
|
5670
5755
|
read(r) {
|
|
@@ -5674,6 +5759,8 @@ export const MetricsAggregateAsked = message('metrics.AggregateAsked', {
|
|
|
5674
5759
|
let $by;
|
|
5675
5760
|
let $without;
|
|
5676
5761
|
let $estimate;
|
|
5762
|
+
let $calendar;
|
|
5763
|
+
let $timeZone;
|
|
5677
5764
|
for (let n = r.message(); n > 0; n--) {
|
|
5678
5765
|
switch (r.field()) {
|
|
5679
5766
|
case 1:
|
|
@@ -5706,6 +5793,12 @@ export const MetricsAggregateAsked = message('metrics.AggregateAsked', {
|
|
|
5706
5793
|
case 6:
|
|
5707
5794
|
$estimate = r.bool();
|
|
5708
5795
|
break;
|
|
5796
|
+
case 7:
|
|
5797
|
+
$calendar = r.str();
|
|
5798
|
+
break;
|
|
5799
|
+
case 8:
|
|
5800
|
+
$timeZone = r.str();
|
|
5801
|
+
break;
|
|
5709
5802
|
default:
|
|
5710
5803
|
r.skip();
|
|
5711
5804
|
}
|
|
@@ -5718,6 +5811,8 @@ export const MetricsAggregateAsked = message('metrics.AggregateAsked', {
|
|
|
5718
5811
|
by: $by,
|
|
5719
5812
|
without: $without,
|
|
5720
5813
|
estimate: $estimate,
|
|
5814
|
+
calendar: $calendar,
|
|
5815
|
+
timeZone: $timeZone,
|
|
5721
5816
|
};
|
|
5722
5817
|
},
|
|
5723
5818
|
});
|
|
@@ -5956,7 +6051,7 @@ export const MetricsAggregates = message('metrics.Aggregates', {
|
|
|
5956
6051
|
},
|
|
5957
6052
|
});
|
|
5958
6053
|
export const MetricsExceeds = message('metrics.Exceeds', {
|
|
5959
|
-
/** series, bytes read
|
|
6054
|
+
/** series, bytes read, samples decoded or answer */
|
|
5960
6055
|
limit: [1, str],
|
|
5961
6056
|
wanted: [2, uint],
|
|
5962
6057
|
bound: [3, uint],
|
|
@@ -6136,6 +6231,71 @@ export const MetricsIngest = message('metrics.Ingest', {
|
|
|
6136
6231
|
return { series: $series };
|
|
6137
6232
|
},
|
|
6138
6233
|
});
|
|
6234
|
+
/**
|
|
6235
|
+
* A text an exporter serves, in Prometheus' format or OpenMetrics', whose
|
|
6236
|
+
* series the store writes every one or none, each with labels beside its own.
|
|
6237
|
+
*/
|
|
6238
|
+
export const MetricsExposition = message('metrics.Exposition', {
|
|
6239
|
+
/** UTF-8, read a line at a time, so that an error names its line */
|
|
6240
|
+
text: [1, bin],
|
|
6241
|
+
labels: [2, names(str)],
|
|
6242
|
+
/** of a sample the text gives no time; now unless given */
|
|
6243
|
+
at: [3, int],
|
|
6244
|
+
/** how long each name of the text keeps its samples */
|
|
6245
|
+
keep: [4, uint],
|
|
6246
|
+
}, {
|
|
6247
|
+
write(w, v) {
|
|
6248
|
+
const head = w.openMap();
|
|
6249
|
+
let n = 0;
|
|
6250
|
+
if (v.text !== undefined) {
|
|
6251
|
+
w.field(1);
|
|
6252
|
+
w.bin(v.text);
|
|
6253
|
+
n++;
|
|
6254
|
+
}
|
|
6255
|
+
if (v.labels !== undefined) {
|
|
6256
|
+
w.field(2);
|
|
6257
|
+
writeNames(w, v.labels, str.write);
|
|
6258
|
+
n++;
|
|
6259
|
+
}
|
|
6260
|
+
if (v.at !== undefined) {
|
|
6261
|
+
w.field(3);
|
|
6262
|
+
w.int(v.at);
|
|
6263
|
+
n++;
|
|
6264
|
+
}
|
|
6265
|
+
if (v.keep !== undefined) {
|
|
6266
|
+
w.field(4);
|
|
6267
|
+
w.uint(v.keep);
|
|
6268
|
+
n++;
|
|
6269
|
+
}
|
|
6270
|
+
w.closeMap(head, n);
|
|
6271
|
+
},
|
|
6272
|
+
read(r) {
|
|
6273
|
+
let $text;
|
|
6274
|
+
let $labels;
|
|
6275
|
+
let $at;
|
|
6276
|
+
let $keep;
|
|
6277
|
+
for (let n = r.message(); n > 0; n--) {
|
|
6278
|
+
switch (r.field()) {
|
|
6279
|
+
case 1:
|
|
6280
|
+
$text = r.bytes();
|
|
6281
|
+
break;
|
|
6282
|
+
case 2:
|
|
6283
|
+
$labels = readNames(r, str.read);
|
|
6284
|
+
break;
|
|
6285
|
+
case 3:
|
|
6286
|
+
$at = r.int();
|
|
6287
|
+
break;
|
|
6288
|
+
case 4:
|
|
6289
|
+
$keep = r.uint();
|
|
6290
|
+
break;
|
|
6291
|
+
default:
|
|
6292
|
+
r.skip();
|
|
6293
|
+
}
|
|
6294
|
+
}
|
|
6295
|
+
r.leave();
|
|
6296
|
+
return { text: $text, labels: $labels, at: $at, keep: $keep };
|
|
6297
|
+
},
|
|
6298
|
+
});
|
|
6139
6299
|
/**
|
|
6140
6300
|
* A page of names, of a name's labels or of a label's values.
|
|
6141
6301
|
*/
|
|
@@ -7274,6 +7434,8 @@ export const RecordsNewEvent = message('records.NewEvent', {
|
|
|
7274
7434
|
traceId: [7, bin],
|
|
7275
7435
|
/** 8 bytes */
|
|
7276
7436
|
spanId: [8, bin],
|
|
7437
|
+
/** 1 to 128 bytes: an event of an id its stream holds is written as nothing */
|
|
7438
|
+
id: [9, str],
|
|
7277
7439
|
}, {
|
|
7278
7440
|
write(w, v) {
|
|
7279
7441
|
const head = w.openMap();
|
|
@@ -7318,6 +7480,11 @@ export const RecordsNewEvent = message('records.NewEvent', {
|
|
|
7318
7480
|
w.bin(v.spanId);
|
|
7319
7481
|
n++;
|
|
7320
7482
|
}
|
|
7483
|
+
if (v.id !== undefined) {
|
|
7484
|
+
w.field(9);
|
|
7485
|
+
w.str(v.id);
|
|
7486
|
+
n++;
|
|
7487
|
+
}
|
|
7321
7488
|
w.closeMap(head, n);
|
|
7322
7489
|
},
|
|
7323
7490
|
read(r) {
|
|
@@ -7329,6 +7496,7 @@ export const RecordsNewEvent = message('records.NewEvent', {
|
|
|
7329
7496
|
let $context;
|
|
7330
7497
|
let $traceId;
|
|
7331
7498
|
let $spanId;
|
|
7499
|
+
let $id;
|
|
7332
7500
|
for (let n = r.message(); n > 0; n--) {
|
|
7333
7501
|
switch (r.field()) {
|
|
7334
7502
|
case 1:
|
|
@@ -7355,6 +7523,9 @@ export const RecordsNewEvent = message('records.NewEvent', {
|
|
|
7355
7523
|
case 8:
|
|
7356
7524
|
$spanId = r.bytes();
|
|
7357
7525
|
break;
|
|
7526
|
+
case 9:
|
|
7527
|
+
$id = r.str();
|
|
7528
|
+
break;
|
|
7358
7529
|
default:
|
|
7359
7530
|
r.skip();
|
|
7360
7531
|
}
|
|
@@ -7369,6 +7540,7 @@ export const RecordsNewEvent = message('records.NewEvent', {
|
|
|
7369
7540
|
context: $context,
|
|
7370
7541
|
traceId: $traceId,
|
|
7371
7542
|
spanId: $spanId,
|
|
7543
|
+
id: $id,
|
|
7372
7544
|
};
|
|
7373
7545
|
},
|
|
7374
7546
|
});
|
|
@@ -7422,6 +7594,39 @@ export const RecordsAppend = message('records.Append', {
|
|
|
7422
7594
|
return { handle: $handle, events: $events };
|
|
7423
7595
|
},
|
|
7424
7596
|
});
|
|
7597
|
+
/**
|
|
7598
|
+
* What an append wrote: none of an event whose id its stream held, or an
|
|
7599
|
+
* earlier event of the append held.
|
|
7600
|
+
*/
|
|
7601
|
+
export const RecordsAppended = message('records.Appended', {
|
|
7602
|
+
/** the events written as nothing */
|
|
7603
|
+
held: [1, uint],
|
|
7604
|
+
}, {
|
|
7605
|
+
write(w, v) {
|
|
7606
|
+
const head = w.openMap();
|
|
7607
|
+
let n = 0;
|
|
7608
|
+
if (v.held !== undefined) {
|
|
7609
|
+
w.field(1);
|
|
7610
|
+
w.uint(v.held);
|
|
7611
|
+
n++;
|
|
7612
|
+
}
|
|
7613
|
+
w.closeMap(head, n);
|
|
7614
|
+
},
|
|
7615
|
+
read(r) {
|
|
7616
|
+
let $held;
|
|
7617
|
+
for (let n = r.message(); n > 0; n--) {
|
|
7618
|
+
switch (r.field()) {
|
|
7619
|
+
case 1:
|
|
7620
|
+
$held = r.uint();
|
|
7621
|
+
break;
|
|
7622
|
+
default:
|
|
7623
|
+
r.skip();
|
|
7624
|
+
}
|
|
7625
|
+
}
|
|
7626
|
+
r.leave();
|
|
7627
|
+
return { held: $held };
|
|
7628
|
+
},
|
|
7629
|
+
});
|
|
7425
7630
|
/**
|
|
7426
7631
|
* An event as a read gives it.
|
|
7427
7632
|
*/
|
|
@@ -7436,6 +7641,7 @@ export const RecordsEvent = message('records.Event', {
|
|
|
7436
7641
|
context: [7, str],
|
|
7437
7642
|
traceId: [8, bin],
|
|
7438
7643
|
spanId: [9, bin],
|
|
7644
|
+
id: [10, str],
|
|
7439
7645
|
}, {
|
|
7440
7646
|
write(w, v) {
|
|
7441
7647
|
const head = w.openMap();
|
|
@@ -7485,6 +7691,11 @@ export const RecordsEvent = message('records.Event', {
|
|
|
7485
7691
|
w.bin(v.spanId);
|
|
7486
7692
|
n++;
|
|
7487
7693
|
}
|
|
7694
|
+
if (v.id !== undefined) {
|
|
7695
|
+
w.field(10);
|
|
7696
|
+
w.str(v.id);
|
|
7697
|
+
n++;
|
|
7698
|
+
}
|
|
7488
7699
|
w.closeMap(head, n);
|
|
7489
7700
|
},
|
|
7490
7701
|
read(r) {
|
|
@@ -7497,6 +7708,7 @@ export const RecordsEvent = message('records.Event', {
|
|
|
7497
7708
|
let $context;
|
|
7498
7709
|
let $traceId;
|
|
7499
7710
|
let $spanId;
|
|
7711
|
+
let $id;
|
|
7500
7712
|
for (let n = r.message(); n > 0; n--) {
|
|
7501
7713
|
switch (r.field()) {
|
|
7502
7714
|
case 1:
|
|
@@ -7526,6 +7738,9 @@ export const RecordsEvent = message('records.Event', {
|
|
|
7526
7738
|
case 9:
|
|
7527
7739
|
$spanId = r.bytes();
|
|
7528
7740
|
break;
|
|
7741
|
+
case 10:
|
|
7742
|
+
$id = r.str();
|
|
7743
|
+
break;
|
|
7529
7744
|
default:
|
|
7530
7745
|
r.skip();
|
|
7531
7746
|
}
|
|
@@ -7541,6 +7756,7 @@ export const RecordsEvent = message('records.Event', {
|
|
|
7541
7756
|
context: $context,
|
|
7542
7757
|
traceId: $traceId,
|
|
7543
7758
|
spanId: $spanId,
|
|
7759
|
+
id: $id,
|
|
7544
7760
|
};
|
|
7545
7761
|
},
|
|
7546
7762
|
});
|
|
@@ -7934,6 +8150,10 @@ export const RecordsAggregateAsked = message('records.AggregateAsked', {
|
|
|
7934
8150
|
by: [3, list(str)],
|
|
7935
8151
|
stats: [4, list(str)],
|
|
7936
8152
|
distinct: [5, list(str)],
|
|
8153
|
+
/** day, week or month: rows of a calendar in timeZone, in place of every */
|
|
8154
|
+
calendar: [6, str],
|
|
8155
|
+
/** an IANA name, UTC among them, which calendar takes */
|
|
8156
|
+
timeZone: [7, str],
|
|
7937
8157
|
}, {
|
|
7938
8158
|
write(w, v) {
|
|
7939
8159
|
const head = w.openMap();
|
|
@@ -7972,6 +8192,16 @@ export const RecordsAggregateAsked = message('records.AggregateAsked', {
|
|
|
7972
8192
|
}
|
|
7973
8193
|
n++;
|
|
7974
8194
|
}
|
|
8195
|
+
if (v.calendar !== undefined) {
|
|
8196
|
+
w.field(6);
|
|
8197
|
+
w.str(v.calendar);
|
|
8198
|
+
n++;
|
|
8199
|
+
}
|
|
8200
|
+
if (v.timeZone !== undefined) {
|
|
8201
|
+
w.field(7);
|
|
8202
|
+
w.str(v.timeZone);
|
|
8203
|
+
n++;
|
|
8204
|
+
}
|
|
7975
8205
|
w.closeMap(head, n);
|
|
7976
8206
|
},
|
|
7977
8207
|
read(r) {
|
|
@@ -7980,6 +8210,8 @@ export const RecordsAggregateAsked = message('records.AggregateAsked', {
|
|
|
7980
8210
|
let $by;
|
|
7981
8211
|
let $stats;
|
|
7982
8212
|
let $distinct;
|
|
8213
|
+
let $calendar;
|
|
8214
|
+
let $timeZone;
|
|
7983
8215
|
for (let n = r.message(); n > 0; n--) {
|
|
7984
8216
|
switch (r.field()) {
|
|
7985
8217
|
case 1:
|
|
@@ -8015,12 +8247,26 @@ export const RecordsAggregateAsked = message('records.AggregateAsked', {
|
|
|
8015
8247
|
$distinct = items0;
|
|
8016
8248
|
break;
|
|
8017
8249
|
}
|
|
8250
|
+
case 6:
|
|
8251
|
+
$calendar = r.str();
|
|
8252
|
+
break;
|
|
8253
|
+
case 7:
|
|
8254
|
+
$timeZone = r.str();
|
|
8255
|
+
break;
|
|
8018
8256
|
default:
|
|
8019
8257
|
r.skip();
|
|
8020
8258
|
}
|
|
8021
8259
|
}
|
|
8022
8260
|
r.leave();
|
|
8023
|
-
return {
|
|
8261
|
+
return {
|
|
8262
|
+
query: $query,
|
|
8263
|
+
every: $every,
|
|
8264
|
+
by: $by,
|
|
8265
|
+
stats: $stats,
|
|
8266
|
+
distinct: $distinct,
|
|
8267
|
+
calendar: $calendar,
|
|
8268
|
+
timeZone: $timeZone,
|
|
8269
|
+
};
|
|
8024
8270
|
},
|
|
8025
8271
|
});
|
|
8026
8272
|
/**
|
|
@@ -9651,11 +9897,16 @@ export const SqlOpen = message('sql.Open', {
|
|
|
9651
9897
|
},
|
|
9652
9898
|
});
|
|
9653
9899
|
/**
|
|
9654
|
-
* A statement's text and the values of its ?s, in order.
|
|
9900
|
+
* A statement's text and the values of its ?s, in order. In a batch it may
|
|
9901
|
+
* be a call of jobs on a queue kept in the database's file instead, jobs.add
|
|
9902
|
+
* with its request in body and no text, which commits with the batch's rows.
|
|
9655
9903
|
*/
|
|
9656
9904
|
export const SqlText = message('sql.Text', {
|
|
9657
9905
|
text: [1, str],
|
|
9658
9906
|
values: [2, list(sqlValue)],
|
|
9907
|
+
/** in a batch, jobs.add: the call in body */
|
|
9908
|
+
method: [3, uint],
|
|
9909
|
+
body: [4, bin],
|
|
9659
9910
|
}, {
|
|
9660
9911
|
write(w, v) {
|
|
9661
9912
|
const head = w.openMap();
|
|
@@ -9673,11 +9924,23 @@ export const SqlText = message('sql.Text', {
|
|
|
9673
9924
|
}
|
|
9674
9925
|
n++;
|
|
9675
9926
|
}
|
|
9927
|
+
if (v.method !== undefined) {
|
|
9928
|
+
w.field(3);
|
|
9929
|
+
w.uint(v.method);
|
|
9930
|
+
n++;
|
|
9931
|
+
}
|
|
9932
|
+
if (v.body !== undefined) {
|
|
9933
|
+
w.field(4);
|
|
9934
|
+
w.bin(v.body);
|
|
9935
|
+
n++;
|
|
9936
|
+
}
|
|
9676
9937
|
w.closeMap(head, n);
|
|
9677
9938
|
},
|
|
9678
9939
|
read(r) {
|
|
9679
9940
|
let $text;
|
|
9680
9941
|
let $values;
|
|
9942
|
+
let $method;
|
|
9943
|
+
let $body;
|
|
9681
9944
|
for (let n = r.message(); n > 0; n--) {
|
|
9682
9945
|
switch (r.field()) {
|
|
9683
9946
|
case 1:
|
|
@@ -9692,12 +9955,18 @@ export const SqlText = message('sql.Text', {
|
|
|
9692
9955
|
$values = items0;
|
|
9693
9956
|
break;
|
|
9694
9957
|
}
|
|
9958
|
+
case 3:
|
|
9959
|
+
$method = r.uint();
|
|
9960
|
+
break;
|
|
9961
|
+
case 4:
|
|
9962
|
+
$body = r.bytes();
|
|
9963
|
+
break;
|
|
9695
9964
|
default:
|
|
9696
9965
|
r.skip();
|
|
9697
9966
|
}
|
|
9698
9967
|
}
|
|
9699
9968
|
r.leave();
|
|
9700
|
-
return { text: $text, values: $values };
|
|
9969
|
+
return { text: $text, values: $values, method: $method, body: $body };
|
|
9701
9970
|
},
|
|
9702
9971
|
});
|
|
9703
9972
|
/**
|
|
@@ -10095,7 +10364,8 @@ export const SqlDone = message('sql.Done', {
|
|
|
10095
10364
|
},
|
|
10096
10365
|
});
|
|
10097
10366
|
/**
|
|
10098
|
-
*
|
|
10367
|
+
* Writes known before they run, written as one in a shared commit: its
|
|
10368
|
+
* statements, and the adds of a queue kept in the database's file.
|
|
10099
10369
|
*/
|
|
10100
10370
|
export const SqlBatch = message('sql.Batch', {
|
|
10101
10371
|
handle: [1, uint],
|
|
@@ -10144,6 +10414,10 @@ export const SqlBatch = message('sql.Batch', {
|
|
|
10144
10414
|
return { handle: $handle, statements: $statements };
|
|
10145
10415
|
},
|
|
10146
10416
|
});
|
|
10417
|
+
/**
|
|
10418
|
+
* What each write of a batch did, in their order: a job's add changed one
|
|
10419
|
+
* job, or none when its id was taken.
|
|
10420
|
+
*/
|
|
10147
10421
|
export const SqlBatched = message('sql.Batched', {
|
|
10148
10422
|
done: [1, list(SqlDone)],
|
|
10149
10423
|
}, {
|
|
@@ -10432,95 +10706,45 @@ export const ChannelsBatch = message('channels.Batch', {
|
|
|
10432
10706
|
},
|
|
10433
10707
|
});
|
|
10434
10708
|
/**
|
|
10435
|
-
* A
|
|
10436
|
-
* value came from.
|
|
10709
|
+
* A value a setting was given, and where it came from.
|
|
10437
10710
|
*/
|
|
10438
|
-
export const
|
|
10439
|
-
|
|
10440
|
-
|
|
10441
|
-
|
|
10442
|
-
value: [3, str],
|
|
10443
|
-
lines: [4, list(ConfigLine)],
|
|
10444
|
-
/** what was read and not used, each with why */
|
|
10445
|
-
notes: [5, list(str)],
|
|
10711
|
+
export const ConfigGiven = message('config.Given', {
|
|
10712
|
+
/** as JSON, a span spelled, a secret as *** */
|
|
10713
|
+
value: [1, str],
|
|
10714
|
+
from: [2, ConfigOrigin],
|
|
10446
10715
|
}, {
|
|
10447
10716
|
write(w, v) {
|
|
10448
10717
|
const head = w.openMap();
|
|
10449
10718
|
let n = 0;
|
|
10450
|
-
if (v.handle !== undefined) {
|
|
10451
|
-
w.field(1);
|
|
10452
|
-
w.uint(v.handle);
|
|
10453
|
-
n++;
|
|
10454
|
-
}
|
|
10455
|
-
if (v.version !== undefined) {
|
|
10456
|
-
w.field(2);
|
|
10457
|
-
w.int(v.version);
|
|
10458
|
-
n++;
|
|
10459
|
-
}
|
|
10460
10719
|
if (v.value !== undefined) {
|
|
10461
|
-
w.field(
|
|
10720
|
+
w.field(1);
|
|
10462
10721
|
w.str(v.value);
|
|
10463
10722
|
n++;
|
|
10464
10723
|
}
|
|
10465
|
-
if (v.
|
|
10466
|
-
w.field(
|
|
10467
|
-
|
|
10468
|
-
for (const item0 of v.lines) {
|
|
10469
|
-
ConfigLine.write(w, item0);
|
|
10470
|
-
}
|
|
10471
|
-
n++;
|
|
10472
|
-
}
|
|
10473
|
-
if (v.notes !== undefined) {
|
|
10474
|
-
w.field(5);
|
|
10475
|
-
w.array(v.notes.length);
|
|
10476
|
-
for (const item0 of v.notes) {
|
|
10477
|
-
w.str(item0);
|
|
10478
|
-
}
|
|
10724
|
+
if (v.from !== undefined) {
|
|
10725
|
+
w.field(2);
|
|
10726
|
+
ConfigOrigin.write(w, v.from);
|
|
10479
10727
|
n++;
|
|
10480
10728
|
}
|
|
10481
10729
|
w.closeMap(head, n);
|
|
10482
10730
|
},
|
|
10483
10731
|
read(r) {
|
|
10484
|
-
let $handle;
|
|
10485
|
-
let $version;
|
|
10486
10732
|
let $value;
|
|
10487
|
-
let $
|
|
10488
|
-
let $notes;
|
|
10733
|
+
let $from;
|
|
10489
10734
|
for (let n = r.message(); n > 0; n--) {
|
|
10490
10735
|
switch (r.field()) {
|
|
10491
10736
|
case 1:
|
|
10492
|
-
$handle = r.uint();
|
|
10493
|
-
break;
|
|
10494
|
-
case 2:
|
|
10495
|
-
$version = r.int();
|
|
10496
|
-
break;
|
|
10497
|
-
case 3:
|
|
10498
10737
|
$value = r.str();
|
|
10499
10738
|
break;
|
|
10500
|
-
case
|
|
10501
|
-
|
|
10502
|
-
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
10503
|
-
items0.push(ConfigLine.read(r));
|
|
10504
|
-
}
|
|
10505
|
-
r.leave();
|
|
10506
|
-
$lines = items0;
|
|
10507
|
-
break;
|
|
10508
|
-
}
|
|
10509
|
-
case 5: {
|
|
10510
|
-
const items0 = [];
|
|
10511
|
-
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
10512
|
-
items0.push(r.str());
|
|
10513
|
-
}
|
|
10514
|
-
r.leave();
|
|
10515
|
-
$notes = items0;
|
|
10739
|
+
case 2:
|
|
10740
|
+
$from = ConfigOrigin.read(r);
|
|
10516
10741
|
break;
|
|
10517
|
-
}
|
|
10518
10742
|
default:
|
|
10519
10743
|
r.skip();
|
|
10520
10744
|
}
|
|
10521
10745
|
}
|
|
10522
10746
|
r.leave();
|
|
10523
|
-
return {
|
|
10747
|
+
return { value: $value, from: $from };
|
|
10524
10748
|
},
|
|
10525
10749
|
});
|
|
10526
10750
|
/**
|
|
@@ -10844,3 +11068,187 @@ export const SearchSetMany = message('search.SetMany', {
|
|
|
10844
11068
|
return { handle: $handle, documents: $documents };
|
|
10845
11069
|
},
|
|
10846
11070
|
});
|
|
11071
|
+
/**
|
|
11072
|
+
* A setting's line of explain.
|
|
11073
|
+
*/
|
|
11074
|
+
export const ConfigLine = message('config.Line', {
|
|
11075
|
+
path: [1, str],
|
|
11076
|
+
/** as JSON, a span spelled, a secret as *** */
|
|
11077
|
+
value: [2, str],
|
|
11078
|
+
from: [3, str],
|
|
11079
|
+
/** the values it went over, newest first */
|
|
11080
|
+
over: [4, list(str)],
|
|
11081
|
+
/** every value it was given, newest first: its own, then the ones it went over */
|
|
11082
|
+
given: [5, list(ConfigGiven)],
|
|
11083
|
+
}, {
|
|
11084
|
+
write(w, v) {
|
|
11085
|
+
const head = w.openMap();
|
|
11086
|
+
let n = 0;
|
|
11087
|
+
if (v.path !== undefined) {
|
|
11088
|
+
w.field(1);
|
|
11089
|
+
w.str(v.path);
|
|
11090
|
+
n++;
|
|
11091
|
+
}
|
|
11092
|
+
if (v.value !== undefined) {
|
|
11093
|
+
w.field(2);
|
|
11094
|
+
w.str(v.value);
|
|
11095
|
+
n++;
|
|
11096
|
+
}
|
|
11097
|
+
if (v.from !== undefined) {
|
|
11098
|
+
w.field(3);
|
|
11099
|
+
w.str(v.from);
|
|
11100
|
+
n++;
|
|
11101
|
+
}
|
|
11102
|
+
if (v.over !== undefined) {
|
|
11103
|
+
w.field(4);
|
|
11104
|
+
w.array(v.over.length);
|
|
11105
|
+
for (const item0 of v.over) {
|
|
11106
|
+
w.str(item0);
|
|
11107
|
+
}
|
|
11108
|
+
n++;
|
|
11109
|
+
}
|
|
11110
|
+
if (v.given !== undefined) {
|
|
11111
|
+
w.field(5);
|
|
11112
|
+
w.array(v.given.length);
|
|
11113
|
+
for (const item0 of v.given) {
|
|
11114
|
+
ConfigGiven.write(w, item0);
|
|
11115
|
+
}
|
|
11116
|
+
n++;
|
|
11117
|
+
}
|
|
11118
|
+
w.closeMap(head, n);
|
|
11119
|
+
},
|
|
11120
|
+
read(r) {
|
|
11121
|
+
let $path;
|
|
11122
|
+
let $value;
|
|
11123
|
+
let $from;
|
|
11124
|
+
let $over;
|
|
11125
|
+
let $given;
|
|
11126
|
+
for (let n = r.message(); n > 0; n--) {
|
|
11127
|
+
switch (r.field()) {
|
|
11128
|
+
case 1:
|
|
11129
|
+
$path = r.str();
|
|
11130
|
+
break;
|
|
11131
|
+
case 2:
|
|
11132
|
+
$value = r.str();
|
|
11133
|
+
break;
|
|
11134
|
+
case 3:
|
|
11135
|
+
$from = r.str();
|
|
11136
|
+
break;
|
|
11137
|
+
case 4: {
|
|
11138
|
+
const items0 = [];
|
|
11139
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
11140
|
+
items0.push(r.str());
|
|
11141
|
+
}
|
|
11142
|
+
r.leave();
|
|
11143
|
+
$over = items0;
|
|
11144
|
+
break;
|
|
11145
|
+
}
|
|
11146
|
+
case 5: {
|
|
11147
|
+
const items0 = [];
|
|
11148
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
11149
|
+
items0.push(ConfigGiven.read(r));
|
|
11150
|
+
}
|
|
11151
|
+
r.leave();
|
|
11152
|
+
$given = items0;
|
|
11153
|
+
break;
|
|
11154
|
+
}
|
|
11155
|
+
default:
|
|
11156
|
+
r.skip();
|
|
11157
|
+
}
|
|
11158
|
+
}
|
|
11159
|
+
r.leave();
|
|
11160
|
+
return { path: $path, value: $value, from: $from, over: $over, given: $given };
|
|
11161
|
+
},
|
|
11162
|
+
});
|
|
11163
|
+
/**
|
|
11164
|
+
* A config's value at a version of its changes, and where each setting's
|
|
11165
|
+
* value came from.
|
|
11166
|
+
*/
|
|
11167
|
+
export const ConfigValue = message('config.Value', {
|
|
11168
|
+
handle: [1, uint],
|
|
11169
|
+
version: [2, int],
|
|
11170
|
+
/** the settings, each span its milliseconds, each secret its text */
|
|
11171
|
+
value: [3, str],
|
|
11172
|
+
lines: [4, list(ConfigLine)],
|
|
11173
|
+
/** what was read and not used, each with why */
|
|
11174
|
+
notes: [5, list(str)],
|
|
11175
|
+
}, {
|
|
11176
|
+
write(w, v) {
|
|
11177
|
+
const head = w.openMap();
|
|
11178
|
+
let n = 0;
|
|
11179
|
+
if (v.handle !== undefined) {
|
|
11180
|
+
w.field(1);
|
|
11181
|
+
w.uint(v.handle);
|
|
11182
|
+
n++;
|
|
11183
|
+
}
|
|
11184
|
+
if (v.version !== undefined) {
|
|
11185
|
+
w.field(2);
|
|
11186
|
+
w.int(v.version);
|
|
11187
|
+
n++;
|
|
11188
|
+
}
|
|
11189
|
+
if (v.value !== undefined) {
|
|
11190
|
+
w.field(3);
|
|
11191
|
+
w.str(v.value);
|
|
11192
|
+
n++;
|
|
11193
|
+
}
|
|
11194
|
+
if (v.lines !== undefined) {
|
|
11195
|
+
w.field(4);
|
|
11196
|
+
w.array(v.lines.length);
|
|
11197
|
+
for (const item0 of v.lines) {
|
|
11198
|
+
ConfigLine.write(w, item0);
|
|
11199
|
+
}
|
|
11200
|
+
n++;
|
|
11201
|
+
}
|
|
11202
|
+
if (v.notes !== undefined) {
|
|
11203
|
+
w.field(5);
|
|
11204
|
+
w.array(v.notes.length);
|
|
11205
|
+
for (const item0 of v.notes) {
|
|
11206
|
+
w.str(item0);
|
|
11207
|
+
}
|
|
11208
|
+
n++;
|
|
11209
|
+
}
|
|
11210
|
+
w.closeMap(head, n);
|
|
11211
|
+
},
|
|
11212
|
+
read(r) {
|
|
11213
|
+
let $handle;
|
|
11214
|
+
let $version;
|
|
11215
|
+
let $value;
|
|
11216
|
+
let $lines;
|
|
11217
|
+
let $notes;
|
|
11218
|
+
for (let n = r.message(); n > 0; n--) {
|
|
11219
|
+
switch (r.field()) {
|
|
11220
|
+
case 1:
|
|
11221
|
+
$handle = r.uint();
|
|
11222
|
+
break;
|
|
11223
|
+
case 2:
|
|
11224
|
+
$version = r.int();
|
|
11225
|
+
break;
|
|
11226
|
+
case 3:
|
|
11227
|
+
$value = r.str();
|
|
11228
|
+
break;
|
|
11229
|
+
case 4: {
|
|
11230
|
+
const items0 = [];
|
|
11231
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
11232
|
+
items0.push(ConfigLine.read(r));
|
|
11233
|
+
}
|
|
11234
|
+
r.leave();
|
|
11235
|
+
$lines = items0;
|
|
11236
|
+
break;
|
|
11237
|
+
}
|
|
11238
|
+
case 5: {
|
|
11239
|
+
const items0 = [];
|
|
11240
|
+
for (let i0 = r.array(); i0 > 0; i0--) {
|
|
11241
|
+
items0.push(r.str());
|
|
11242
|
+
}
|
|
11243
|
+
r.leave();
|
|
11244
|
+
$notes = items0;
|
|
11245
|
+
break;
|
|
11246
|
+
}
|
|
11247
|
+
default:
|
|
11248
|
+
r.skip();
|
|
11249
|
+
}
|
|
11250
|
+
}
|
|
11251
|
+
r.leave();
|
|
11252
|
+
return { handle: $handle, version: $version, value: $value, lines: $lines, notes: $notes };
|
|
11253
|
+
},
|
|
11254
|
+
});
|