@mark1russell7/service 0.5.20 → 0.6.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/build/index.js CHANGED
@@ -5,6 +5,7 @@ import { n as operationProblems, t as mayReissue } from "./operation-DL5RxFds.js
5
5
  import { a as limiterProblems, i as limitRule, n as freeAt, o as longestRetryAfter, r as idleSpan, s as retryAfterSeconds, t as decide } from "./policy-CgS4y94U.js";
6
6
  import { a as lateHolds, l as takeOutside, n as countOf, r as millisecondsOf, s as ownStream, t as boundedMillisecondsOf } from "./knobs-D2ClI68I.js";
7
7
  import { backoffBand, backoffDelay, backoffProblems } from "./backoff.js";
8
+ import { DRAIN_RULES, O04, O09, O10, O16 } from "./rules.js";
8
9
  import { a as keyedLimiter, i as limiterStateOf, n as TOKEN_BUCKET_MACHINE, o as memoryStore, r as limiterMachine, t as SLIDING_WINDOW_MACHINE } from "./limiter-pkBZUp-t.js";
9
10
  import { convertExact, convertible, quantity, rationals, valueIn } from "@mark1russell7/quantity";
10
11
  import { replay } from "@mark1russell7/algebra/replay";
@@ -1193,23 +1194,13 @@ const retryOf = (knobs, owner) => {
1193
1194
  return backoff;
1194
1195
  };
1195
1196
  /**
1196
- * This function gives the problems of the bounds of a loop in a declaration. The close bound fits
1197
- * in the cap of `close transports`. The bound of a unit fits in the cap of `drain`, or the drain can cut a unit (S6 A10).
1197
+ * This function gives the problems of a loop in a declaration: each phase that the loop needs and
1198
+ * that the declaration does not give. A loop closes in `close transports`, and it ends its units in
1199
+ * `drain`. `lint()` compares the bounds with the caps of the phases (`BOUND_RULES`, S6 A10).
1198
1200
  */
1199
- const boundProblems = (owner, closeBound, unitBound, description) => {
1200
- const capOf = (name) => {
1201
- const phase = description.shutdown.phases.find((each) => each.name === name);
1202
- return phase === void 0 ? void 0 : valueIn(phase.cap, "ms");
1203
- };
1204
- const found = [];
1205
- const close = capOf("close transports");
1206
- if (close === void 0) found.push(`${owner} needs the phase "close transports" to close`);
1207
- else if (closeBound >= close) found.push(`the close_bound of ${owner}, ${closeBound} ms, does not fit in the cap of "close transports", ${close} ms`);
1208
- const drain = capOf("drain");
1209
- if (drain === void 0) found.push(`${owner} needs the phase "drain" to end its units`);
1210
- else if (!Number.isFinite(unitBound)) found.push(`the unit_processing_time of ${owner} has no bound, thus the drain can cut a unit at its cap of ${drain} ms`);
1211
- else if (unitBound >= drain) found.push(`the unit_processing_time of ${owner}, ${unitBound} ms, does not fit in the cap of "drain", ${drain} ms`);
1212
- return found;
1201
+ const boundProblems = (owner, description) => {
1202
+ const has = (name) => description.shutdown.phases.some((each) => each.name === name);
1203
+ return [...has("close transports") ? [] : [`${owner} needs the phase "close transports" to close`], ...has("drain") ? [] : [`${owner} needs the phase "drain" to end its units`]];
1213
1204
  };
1214
1205
  //#endregion
1215
1206
  //#region src/requests.ts
@@ -2694,6 +2685,12 @@ const serviceBindings = (svc, scenario) => {
2694
2685
  set("cooperative_window@process", boundOf(svc.shutdown.cooperativeWindow), "the declared cooperative window");
2695
2686
  const hold = svc.shutdown.phases.find((phase) => phase.name === "fail readiness");
2696
2687
  set("readiness_hold@process", hold === void 0 ? 0 : secondsOf(hold.cap), hold === void 0 ? "no fail readiness phase: the intake stops at once after the signal" : "the cap of the fail readiness phase, which holds while the endpoints update");
2688
+ const capOf = (name) => {
2689
+ const phase = svc.shutdown.phases.find((each) => each.name === name);
2690
+ return phase === void 0 ? void 0 : secondsOf(phase.cap);
2691
+ };
2692
+ set("drain_phase_cap@process", capOf("drain"), "the cap of the drain phase alone");
2693
+ set("close_phase_cap@process", capOf("close transports"), "the cap of the close transports phase alone");
2697
2694
  bindScenario(scenario.platform, (symbol) => symbol, bind, epochs);
2698
2695
  for (const [symbol, epoch] of Object.entries(epochs)) if (bind[symbol] === void 0) delete from[symbol];
2699
2696
  else from[symbol] = epoch === null ? "the scenario" : `the scenario, for ${epoch}`;
@@ -2716,16 +2713,19 @@ const dependencyBindings = (dependency, scenario) => {
2716
2713
  };
2717
2714
  /**
2718
2715
  * These are the hops of the law at which the knobs of a transport bind, by its kind. A worker does
2719
- * its units as a consumer does, thus both bind at `consumer` (O20). A server binds at no hop yet.
2716
+ * its units as a consumer does, thus both bind at `consumer` (O20). A server binds at `server`, in a
2717
+ * scope of its own. In the scope of a dependency, `@server` is the server of that dependency. Thus
2718
+ * the knobs of a server of the service do not bind there, or O19 pairs the wrong two sides.
2720
2719
  */
2721
2720
  const TRANSPORT_HOPS = {
2722
- server: null,
2721
+ server: "server",
2723
2722
  consumer: "consumer",
2724
2723
  worker: "consumer"
2725
2724
  };
2726
2725
  /**
2727
2726
  * This function gives the time knobs of a transport at the hop of its kind, and the values of the
2728
- * scenario for its source. A knob with a hop in its name binds at that hop. A count binds no symbol.
2727
+ * scenario for the transport. These values are of the source of a consumer, or of the clients of a
2728
+ * server. A knob with a hop in its name binds at that hop. A count binds no symbol.
2729
2729
  */
2730
2730
  const transportBindings = (transport, hop, scenario) => {
2731
2731
  const bind = {};
@@ -2760,6 +2760,7 @@ const limiterBindings = (limiter, scenario) => {
2760
2760
  };
2761
2761
  };
2762
2762
  const SCOPED = /@(client|dependency|server)$/;
2763
+ const SERVER_SCOPED = /@server$/;
2763
2764
  const TRANSPORT_SCOPED = /@consumer$/;
2764
2765
  const LIMITER_SCOPED = /@(limiter|caller)$/;
2765
2766
  /** This identifier is the rule of the findings about a field that the declaration does not give. */
@@ -2778,6 +2779,29 @@ const declarationFindings = (svc) => svc.shutdown.onRepeatSignal === void 0 ? [{
2778
2779
  evaluated: [],
2779
2780
  unbound: ["shutdown.onRepeatSignal"]
2780
2781
  }] : [];
2782
+ /** This identifier is the rule of the findings for two parts that have one name in the scopes of a rule. */
2783
+ const NAME_RULE = "unique-names";
2784
+ /**
2785
+ * This function gives a finding for each name that two parts share in one set of scopes. A rule
2786
+ * about a client applies to each dependency and each server transport. A rule about a consumer
2787
+ * applies to each consumer and each worker, and a rule about a limiter to each limiter. Two parts
2788
+ * with one name in a set give findings with one scope, thus a reader cannot tell them apart.
2789
+ */
2790
+ const nameFindings = (svc) => {
2791
+ return [
2792
+ ["the dependencies and the server transports", [...svc.dependencies.map((each) => each.name), ...svc.transports.filter((each) => each.kind === "server").map((each) => each.name)]],
2793
+ ["the consumers and the workers", svc.transports.filter((each) => each.kind !== "server").map((each) => each.name)],
2794
+ ["the limiters", (svc.limiters ?? []).map((each) => each.name)]
2795
+ ].flatMap(([set, names]) => [...new Set(names.filter((name, index) => names.indexOf(name) !== index))].map((name) => ({
2796
+ rule: NAME_RULE,
2797
+ scope: name,
2798
+ verdict: "violated",
2799
+ statement: `each of ${set} has a name of its own`,
2800
+ window: `two parts have the name ${name}, thus their findings have one scope`,
2801
+ evaluated: [],
2802
+ unbound: []
2803
+ })));
2804
+ };
2781
2805
  /** This identifier is the rule of the findings about the stall time of a progress check (`Check.marks`). */
2782
2806
  const PROGRESS_RULE = "progress";
2783
2807
  /**
@@ -2907,7 +2931,65 @@ const progressFindings = (svc) => {
2907
2931
  }
2908
2932
  return findings;
2909
2933
  };
2910
- /** This function gives the scopes of a rule that reads these symbols: the service, each client, each consumer and worker, or each limiter. */
2934
+ /** This identifier is the rule of the findings about the bound of a unit against the cap of the `drain` phase. */
2935
+ const UNIT_BOUND_RULE = "unit-bound";
2936
+ /** This identifier is the rule of the findings about the close bound against the cap of the `close transports` phase. */
2937
+ const CLOSE_BOUND_RULE = "close-bound";
2938
+ /**
2939
+ * These are the rules of the bounds of a loop. Each one applies one time for each consumer and
2940
+ * each worker (S6 A10, A11). `lint()` gives them, as it gives `PROGRESS_RULE`.
2941
+ * - unit-bound: `unit_processing_time` is less than the cap of the `drain` phase. Otherwise the
2942
+ * drain can cut a unit that ends in its bound. A unit without a bound violates the rule.
2943
+ * - close-bound: `close_bound` is less than the cap of the `close transports` phase. Otherwise the
2944
+ * phase can end before the loop closes.
2945
+ *
2946
+ * The corpus of the law (R3) does not have these rules, thus they have identifiers of the service,
2947
+ * not O-numbers. The symbols `drain_phase_cap@process` and `close_phase_cap@process` are the caps of
2948
+ * one phase. `process_drain_time@process` is the sum of the caps of all the phases. A phase that the
2949
+ * declaration does not give binds no symbol, thus its finding is `depends`.
2950
+ */
2951
+ const BOUND_RULES = [{
2952
+ id: UNIT_BOUND_RULE,
2953
+ rule: "the bound of one unit of a consumer or a worker is less than the cap of the drain phase",
2954
+ window: "the drain can cut a unit that ends in its bound",
2955
+ expr: {
2956
+ lhs: { terms: [{
2957
+ knob: "unit_processing_time",
2958
+ coef: 1,
2959
+ at: "consumer"
2960
+ }] },
2961
+ op: "<",
2962
+ rhs: { terms: [{
2963
+ knob: "drain_phase_cap",
2964
+ coef: 1,
2965
+ at: "process"
2966
+ }] },
2967
+ margin: 0
2968
+ }
2969
+ }, {
2970
+ id: CLOSE_BOUND_RULE,
2971
+ rule: "the close bound of a consumer or a worker is less than the cap of the close transports phase",
2972
+ window: "the phase can end before the loop closes",
2973
+ expr: {
2974
+ lhs: { terms: [{
2975
+ knob: "close_bound",
2976
+ coef: 1,
2977
+ at: "consumer"
2978
+ }] },
2979
+ op: "<",
2980
+ rhs: { terms: [{
2981
+ knob: "close_phase_cap",
2982
+ coef: 1,
2983
+ at: "process"
2984
+ }] },
2985
+ margin: 0
2986
+ }
2987
+ }];
2988
+ /**
2989
+ * This function gives the scopes of a rule that reads these symbols: the service, each client, each
2990
+ * consumer and worker, or each limiter. A rule that reads a symbol at `server` applies to each client
2991
+ * and to each server transport. In the scope of a server, the scenario gives the client side.
2992
+ */
2911
2993
  const scopesOf = (svc, scenario, service, symbols) => {
2912
2994
  const within = (name, scoped) => {
2913
2995
  const bind = {
@@ -2924,10 +3006,8 @@ const scopesOf = (svc, scenario, service, symbols) => {
2924
3006
  }
2925
3007
  ];
2926
3008
  };
2927
- return symbols.some((symbol) => LIMITER_SCOPED.test(symbol)) ? (svc.limiters ?? []).map((limiter) => within(limiter.name, limiterBindings(limiter, scenario))) : symbols.some((symbol) => TRANSPORT_SCOPED.test(symbol)) ? svc.transports.flatMap((transport) => {
2928
- const hop = TRANSPORT_HOPS[transport.kind];
2929
- return hop === null ? [] : [within(transport.name, transportBindings(transport, hop, scenario))];
2930
- }) : symbols.some((symbol) => SCOPED.test(symbol)) ? svc.dependencies.map((dependency) => within(dependency.name, dependencyBindings(dependency, scenario))) : [[
3009
+ const transports = (hop) => svc.transports.filter((transport) => TRANSPORT_HOPS[transport.kind] === hop).map((transport) => within(transport.name, transportBindings(transport, hop, scenario)));
3010
+ return symbols.some((symbol) => LIMITER_SCOPED.test(symbol)) ? (svc.limiters ?? []).map((limiter) => within(limiter.name, limiterBindings(limiter, scenario))) : symbols.some((symbol) => TRANSPORT_SCOPED.test(symbol)) ? transports("consumer") : symbols.some((symbol) => SCOPED.test(symbol)) ? [...svc.dependencies.map((dependency) => within(dependency.name, dependencyBindings(dependency, scenario))), ...symbols.some((symbol) => SERVER_SCOPED.test(symbol)) ? transports("server") : []] : [[
2931
3011
  svc.name,
2932
3012
  service.bind,
2933
3013
  service.epochs
@@ -2959,65 +3039,68 @@ const PLATFORM_MARKS = {
2959
3039
  * This function tells which findings of `lint` a compression by k changes (E10). It scales the
2960
3040
  * bindings of each scope by the marks. Thus a harness that runs the service k times faster learns
2961
3041
  * the orderings that its run breaks. The unmarked symbols are the symbols of the rules with no mark.
3042
+ * It reads the rules that `lint` applies with their bindings: the service rules and `BOUND_RULES`.
2962
3043
  */
2963
3044
  const compressionOf = (svc, scenario, rules, k, marks) => {
2964
3045
  const service = serviceBindings(svc, scenario);
2965
3046
  const changed = [];
2966
3047
  const unmarked = /* @__PURE__ */ new Set();
2967
- for (const rule of rules) {
2968
- if (!SERVICE_RULES.includes(rule.id)) continue;
2969
- for (const [scope, bind] of scopesOf(svc, scenario, service, symbolsOf(rule))) {
2970
- const result = compression([rule], bind, k, marks);
2971
- for (const change of result.changed) changed.push({
2972
- ...change,
2973
- scope
2974
- });
2975
- for (const symbol of result.unmarked) unmarked.add(symbol);
2976
- }
3048
+ for (const rule of [...rules.filter((each) => SERVICE_RULES.includes(each.id)), ...BOUND_RULES]) for (const [scope, bind] of scopesOf(svc, scenario, service, symbolsOf(rule))) {
3049
+ const result = compression([rule], bind, k, marks);
3050
+ for (const change of result.changed) changed.push({
3051
+ ...change,
3052
+ scope
3053
+ });
3054
+ for (const symbol of result.unmarked) unmarked.add(symbol);
2977
3055
  }
2978
3056
  return {
2979
3057
  changed,
2980
3058
  unmarked: [...unmarked]
2981
3059
  };
2982
3060
  };
3061
+ /** This function gives the findings of one rule, one for each scope of the rule. */
3062
+ const findingsOf = (svc, scenario, service, rule) => {
3063
+ const symbols = symbolsOf(rule);
3064
+ return scopesOf(svc, scenario, service, symbols).map(([scope, bind, all]) => {
3065
+ const evaluated = evaluate(rule, bind);
3066
+ const epochs = epochsOf(symbols, all);
3067
+ return {
3068
+ rule: rule.id,
3069
+ scope,
3070
+ verdict: verdictOf(rule, bind, evaluated),
3071
+ statement: rule.rule,
3072
+ ...rule.window !== void 0 ? { window: rule.window } : {},
3073
+ evaluated,
3074
+ unbound: symbols.filter((symbol) => bind[symbol] === void 0),
3075
+ ...Object.values(epochs).some((epoch) => epoch !== null) ? { epochs } : {}
3076
+ };
3077
+ });
3078
+ };
2983
3079
  /**
2984
3080
  * This function applies each service rule to a declaration and a scenario. A rule applies one time
2985
- * for the service, for each client, for each consumer and worker, or for each limiter. The function
2986
- * also gives a finding for each necessary field that the description does not give (`DECLARATION_RULE`).
2987
- * Each progress check that names its loops also gets its findings (`PROGRESS_RULE`).
3081
+ * for the service, for each client, for each consumer and worker, or for each limiter. It also
3082
+ * gives a finding for each necessary field that the description does not give (`DECLARATION_RULE`).
3083
+ * It gives a finding for each name that two parts share in the scopes of a rule (`NAME_RULE`). Each progress check
3084
+ * that names its loops also gets its findings (`PROGRESS_RULE`). The findings of the bounds of each
3085
+ * consumer and each worker come last (`BOUND_RULES`).
2988
3086
  */
2989
3087
  const lint = (svc, scenario, rules) => {
2990
3088
  const service = serviceBindings(svc, scenario);
2991
- const findings = [...declarationFindings(svc), ...progressFindings(svc)];
2992
- for (const rule of rules) {
2993
- if (!SERVICE_RULES.includes(rule.id)) continue;
2994
- const symbols = symbolsOf(rule);
2995
- for (const [scope, bind, all] of scopesOf(svc, scenario, service, symbols)) {
2996
- const evaluated = evaluate(rule, bind);
2997
- const epochs = epochsOf(symbols, all);
2998
- findings.push({
2999
- rule: rule.id,
3000
- scope,
3001
- verdict: verdictOf(rule, bind, evaluated),
3002
- statement: rule.rule,
3003
- ...rule.window !== void 0 ? { window: rule.window } : {},
3004
- evaluated,
3005
- unbound: symbols.filter((symbol) => bind[symbol] === void 0),
3006
- ...Object.values(epochs).some((epoch) => epoch !== null) ? { epochs } : {}
3007
- });
3008
- }
3009
- }
3010
- return findings;
3089
+ return [
3090
+ ...declarationFindings(svc),
3091
+ ...nameFindings(svc),
3092
+ ...progressFindings(svc),
3093
+ ...rules.filter((rule) => SERVICE_RULES.includes(rule.id)).flatMap((rule) => findingsOf(svc, scenario, service, rule)),
3094
+ ...BOUND_RULES.flatMap((rule) => findingsOf(svc, scenario, service, rule))
3095
+ ];
3011
3096
  };
3012
3097
  //#endregion
3013
3098
  //#region src/stops.ts
3014
- /** These are the rules of the drain. Each way of stopping applies only its own rules of this set. */
3015
- const DRAIN_RULE_IDS = [
3016
- "O04",
3017
- "O09",
3018
- "O10",
3019
- "O16"
3020
- ];
3099
+ /**
3100
+ * These are the identifiers of the rules of the drain, from the data of the entry `./rules`. Each
3101
+ * way that a pod stops applies only its own rules of this set.
3102
+ */
3103
+ const DRAIN_RULE_IDS = DRAIN_RULES.map((rule) => rule.id);
3021
3104
  /**
3022
3105
  * These are the four ways that a pod stops.
3023
3106
  * - A deletion runs the preStop hook, then SIGTERM. The endpoints drop the pod at its deletion,
@@ -3075,14 +3158,15 @@ const STOP_RULE = "stop";
3075
3158
  * This function applies the rules to a declaration for one way of stopping. A rule of the drain
3076
3159
  * applies only when it guards that way. The other rules apply as `lint()` applies them. A way with
3077
3160
  * no drain also gets a finding of `STOP_RULE` that depends. No rule bounds the time until the
3078
- * kubelet finds the exit, and the work in flight is lost.
3161
+ * kubelet finds the exit, and the work in flight is lost. Such a way starts no phase, thus it gets no
3162
+ * finding of `BOUND_RULES`.
3079
3163
  */
3080
3164
  const lintStop = (svc, scenario, rules, way) => {
3081
3165
  const stop = STOPS[way];
3082
3166
  const applies = rules.filter((rule) => !DRAIN_RULE_IDS.includes(rule.id) || stop.rules.includes(rule.id));
3083
3167
  const findings = lint(svc, scenario, applies);
3084
3168
  if (stop.drain) return findings;
3085
- return [...findings, {
3169
+ return [...findings.filter((finding) => !BOUND_RULES.some((rule) => rule.id === finding.rule)), {
3086
3170
  rule: STOP_RULE,
3087
3171
  scope: svc.name,
3088
3172
  verdict: "depends",
@@ -3352,7 +3436,7 @@ const workerLoop = (knobs, options) => {
3352
3436
  return closing;
3353
3437
  },
3354
3438
  problems(description) {
3355
- return boundProblems(OWNER$1, closeBound, bound, description);
3439
+ return boundProblems(OWNER$1, description);
3356
3440
  }
3357
3441
  };
3358
3442
  };
@@ -3625,7 +3709,7 @@ const queueDrain = (knobs, options) => {
3625
3709
  return closing;
3626
3710
  },
3627
3711
  problems(description) {
3628
- return boundProblems(OWNER, closeBound, bound, description);
3712
+ return boundProblems(OWNER, description);
3629
3713
  }
3630
3714
  };
3631
3715
  };
@@ -4079,6 +4163,6 @@ const MACHINES = {
4079
4163
  watchdog: WATCHDOG_MACHINE
4080
4164
  };
4081
4165
  //#endregion
4082
- export { DECLARATION_RULE, DRAIN_RULE_IDS, DURATION_FRACTIONS, EPISODES_KEPT, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LAW_STATISTIC, LIMITER_RULES, LOG_LEVELS, MACHINES, PLATFORM_MARKS, POLLER_MACHINE, PROCESS_TRIGGERS, PROGRESS_RULE, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, STOPS, STOP_RULE, TOKEN_BUCKET_MACHINE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, atLeast, backoffBand, backoffDelay, backoffProblems, capKnob, compress, compression, compressionOf, consoleLogger, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, lintStop, localDev, logEvents, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redact, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
4166
+ export { BOUND_RULES, CLOSE_BOUND_RULE, DECLARATION_RULE, DRAIN_RULES, DRAIN_RULE_IDS, DURATION_FRACTIONS, EPISODES_KEPT, EXIT_MACHINE, EXIT_SIGNALS, FORMAT, GATE_MACHINE, LATCH_MACHINE, LAW_STATISTIC, LIMITER_RULES, LOG_LEVELS, MACHINES, NAME_RULE, O04, O09, O10, O16, PLATFORM_MARKS, POLLER_MACHINE, PROCESS_TRIGGERS, PROGRESS_RULE, SERVICE_RULES, SLIDING_WINDOW_MACHINE, STAGES, STOPS, STOP_RULE, TOKEN_BUCKET_MACHINE, UNIT_BOUND_RULE, WATCHDOG_MACHINE, WINDOW_MACHINE, asDebounce, asWindow, atLeast, backoffBand, backoffDelay, backoffProblems, capKnob, compress, compression, compressionOf, consoleLogger, cooperativeAbortAt, daemon, decide, detectionTime, drainMachine, embeddedProcess, ephemeral, evaluate, failSpan, freeAt, heartbeat, heartbeatDetection, idleSpan, inequalities, isExitCode, isExitSignal, isMessageShape, keyedLimiter, kubernetes, limitRule, limiterMachine, limiterProblems, limiterStateOf, lint, lintStop, localDev, logEvents, longestRetryAfter, matchesMessage, mayReissue, memoryStore, nodeProcess, platformClock, processPortOf, queueDrain, realClock, recoverSpan, redact, redeliverOnce, replay, retryAfterSeconds, service, serviceBindings, stageRank, symbolsOf, verdictOf, watchdog, workerLoop };
4083
4167
 
4084
4168
  //# sourceMappingURL=index.js.map