@mark1russell7/service 0.6.0 → 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/README.md +16 -0
- package/build/index.d.ts +6 -126
- package/build/index.js +7 -8
- package/build/index.js.map +1 -1
- package/build/rules-BBRopO1e.d.ts +145 -0
- package/build/rules.d.ts +2 -0
- package/build/rules.js +128 -0
- package/build/rules.js.map +1 -0
- package/package.json +6 -2
|
@@ -0,0 +1,145 @@
|
|
|
1
|
+
//#region src/law.d.ts
|
|
2
|
+
/**
|
|
3
|
+
* This module is the evaluator of the timer-ordering law. Its decisions are the same as the
|
|
4
|
+
* decisions of the research evaluator, except when absent timers leave no order (`evaluate`). The
|
|
5
|
+
* rules are data, and the caller gives them. Each rule
|
|
6
|
+
* is one or more linear inequalities over symbols at a hop (`readiness_detection_window@pod`),
|
|
7
|
+
* with a margin. A binding maps `symbol@hop` to seconds, or to "inf" for a timer that is absent.
|
|
8
|
+
*/
|
|
9
|
+
/** A term is a coefficient times one symbol, at a hop when it has one. */
|
|
10
|
+
interface Term {
|
|
11
|
+
readonly knob: string;
|
|
12
|
+
readonly coef: number;
|
|
13
|
+
readonly at?: string | undefined;
|
|
14
|
+
}
|
|
15
|
+
/** A side is a sum of terms, plus a constant. */
|
|
16
|
+
interface Side {
|
|
17
|
+
readonly terms: readonly Term[];
|
|
18
|
+
readonly const?: number | undefined;
|
|
19
|
+
}
|
|
20
|
+
/** An inequality compares two sides, with a margin. */
|
|
21
|
+
interface Inequality {
|
|
22
|
+
readonly lhs: Side;
|
|
23
|
+
readonly op: "<" | "<=" | ">" | ">=";
|
|
24
|
+
readonly rhs: Side;
|
|
25
|
+
/** The margin is in seconds, or it is words for a margin that no binding gives ("a factor of several"). Words count as 0. */
|
|
26
|
+
readonly margin?: number | string | undefined;
|
|
27
|
+
}
|
|
28
|
+
/** A rule is one or more inequalities, with their statement in words. */
|
|
29
|
+
interface Rule {
|
|
30
|
+
readonly id: string;
|
|
31
|
+
/** This text is the rule in words. */
|
|
32
|
+
readonly rule: string;
|
|
33
|
+
/** This text is the window that a violation opens. */
|
|
34
|
+
readonly window?: string | undefined;
|
|
35
|
+
readonly expr: Inequality;
|
|
36
|
+
readonly expr_more?: readonly Inequality[] | undefined;
|
|
37
|
+
}
|
|
38
|
+
/** A bound is in seconds, or it is "inf" for an absent timer, or "off" for a disabled feature. The last two have no limit. */
|
|
39
|
+
type Bound = number | "inf" | "off";
|
|
40
|
+
/**
|
|
41
|
+
* A binding maps `symbol@hop` to its bound. Its "margin" replaces the margin of each inequality.
|
|
42
|
+
* Its "margins" replace them one by one, in sequence, as the binding of a chain can.
|
|
43
|
+
*/
|
|
44
|
+
type Binding = Readonly<Record<string, Bound | readonly number[] | undefined>> & {
|
|
45
|
+
readonly margin?: number | undefined;
|
|
46
|
+
readonly margins?: readonly number[] | undefined;
|
|
47
|
+
};
|
|
48
|
+
/** A verdict is "holds", "violated", "unbounded" (it holds only because a timer is absent) or "depends" (nothing is bound). */
|
|
49
|
+
type Verdict = "holds" | "violated" | "unbounded" | "depends";
|
|
50
|
+
/** An evaluation is the value of each side of one inequality, its margin, and if it holds. */
|
|
51
|
+
interface Evaluated {
|
|
52
|
+
readonly lhs: number | null;
|
|
53
|
+
readonly rhs: number | null;
|
|
54
|
+
readonly margin: number;
|
|
55
|
+
readonly holds: boolean | null;
|
|
56
|
+
}
|
|
57
|
+
/** This function gives the inequalities of a rule: its expr, then the others. */
|
|
58
|
+
declare const inequalities: (rule: Rule) => readonly Inequality[];
|
|
59
|
+
/** This function gives the symbols that a rule reads, as `symbol@hop`. */
|
|
60
|
+
declare const symbolsOf: (rule: Rule) => string[];
|
|
61
|
+
/**
|
|
62
|
+
* This function evaluates each inequality on one binding. "<" holds when lhs + margin < rhs, and
|
|
63
|
+
* ">" holds when lhs > rhs + margin. Only the inequalities with all their symbols bound apply.
|
|
64
|
+
* The others are null. Absent timers can leave no order: the same infinity on each side, or both
|
|
65
|
+
* signs of infinity on one side. Then the inequality holds only because a timer is absent.
|
|
66
|
+
*/
|
|
67
|
+
declare const evaluate: (rule: Rule, bind: Binding) => Evaluated[];
|
|
68
|
+
/**
|
|
69
|
+
* This function gives the verdict of an evaluation. When an applicable inequality fails, the
|
|
70
|
+
* verdict is "violated". When all hold only because a timer is absent, the verdict is "unbounded",
|
|
71
|
+
* because nothing then limits the window. Otherwise the verdict is "holds". When no inequality
|
|
72
|
+
* applies, the arithmetic cannot decide, and the verdict is "depends".
|
|
73
|
+
*/
|
|
74
|
+
declare const verdictOf: (rule: Rule, bind: Binding, evaluated: readonly Evaluated[]) => Verdict;
|
|
75
|
+
/**
|
|
76
|
+
* A mark tells how a timer moves when a compression scales time by k (E10). A "scalable" timer
|
|
77
|
+
* becomes k times its value. A "fixed" timer keeps its value. A "stepped" timer takes only
|
|
78
|
+
* multiples of its step, thus it rounds up. A "floored" timer has a floor that a peer sets, for
|
|
79
|
+
* example the minimum retransmission timeout of the kernel. The step and the floor are in seconds.
|
|
80
|
+
*/
|
|
81
|
+
type TimerMark = {
|
|
82
|
+
readonly kind: "scalable";
|
|
83
|
+
} | {
|
|
84
|
+
readonly kind: "fixed";
|
|
85
|
+
} | {
|
|
86
|
+
readonly kind: "stepped";
|
|
87
|
+
readonly step: number;
|
|
88
|
+
} | {
|
|
89
|
+
readonly kind: "floored";
|
|
90
|
+
readonly floor: number;
|
|
91
|
+
readonly by: string;
|
|
92
|
+
};
|
|
93
|
+
/** The marks map `symbol@hop` to a mark. A bare symbol marks the symbol at each hop. */
|
|
94
|
+
type TimerMarks = Readonly<Record<string, TimerMark | undefined>>;
|
|
95
|
+
/** A compressed binding, and the symbols that have no mark. */
|
|
96
|
+
interface Compressed {
|
|
97
|
+
readonly bind: Binding;
|
|
98
|
+
/** These symbols have no mark. They keep their values, thus the compression proves nothing about them. */
|
|
99
|
+
readonly unmarked: readonly string[];
|
|
100
|
+
}
|
|
101
|
+
/** A change is a rule whose verdict a compression changes. */
|
|
102
|
+
interface Change {
|
|
103
|
+
readonly rule: string;
|
|
104
|
+
readonly before: Verdict;
|
|
105
|
+
readonly after: Verdict;
|
|
106
|
+
}
|
|
107
|
+
/** The result of a compression: the rules whose verdict it changes, and the symbols of the rules that have no mark. */
|
|
108
|
+
interface Compression {
|
|
109
|
+
readonly changed: readonly Change[];
|
|
110
|
+
readonly unmarked: readonly string[];
|
|
111
|
+
}
|
|
112
|
+
/**
|
|
113
|
+
* This function scales each timer of a binding by k, by its mark (E10). An absent timer ("inf" or
|
|
114
|
+
* "off") stays absent. A chain scales each value. The margins of the binding and the constants of
|
|
115
|
+
* the rules do not scale: they are tolerances, not timers. A symbol with no mark keeps its value.
|
|
116
|
+
*/
|
|
117
|
+
declare const compress: (bind: Binding, k: number, marks: TimerMarks) => Compressed;
|
|
118
|
+
/**
|
|
119
|
+
* This function tells which rules a compression by k changes. A compression keeps each ordering
|
|
120
|
+
* when no verdict changes. A change in either direction counts: a violation that the compression
|
|
121
|
+
* hides is as wrong as one that it makes. The unmarked symbols are the symbols that the rules read.
|
|
122
|
+
*/
|
|
123
|
+
declare const compression: (rules: readonly Rule[], bind: Binding, k: number, marks: TimerMarks) => Compression;
|
|
124
|
+
//#endregion
|
|
125
|
+
//#region src/rules.d.ts
|
|
126
|
+
/**
|
|
127
|
+
* O04 with the hold of the service. The listener of a pod stays open through the preStop sleep and
|
|
128
|
+
* then through the hold of `fail readiness`. Thus the sum of the two must cover the propagation of
|
|
129
|
+
* the endpoints. The rule of the research is the case without a hold.
|
|
130
|
+
*/
|
|
131
|
+
declare const O04: Rule;
|
|
132
|
+
/** O09 is W8: readiness detection plus propagation is no longer than liveness detection plus the preStop sleep. */
|
|
133
|
+
declare const O09: Rule;
|
|
134
|
+
/** O10: the preStop sleep plus the drain of the process fits in the grace period. */
|
|
135
|
+
declare const O10: Rule;
|
|
136
|
+
/** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */
|
|
137
|
+
declare const O16: Rule;
|
|
138
|
+
/**
|
|
139
|
+
* These are the rules of the drain. For each way that a pod stops, `lintStop()` applies only the
|
|
140
|
+
* rules of this set that guard that way. `DRAIN_RULE_IDS` gives their identifiers.
|
|
141
|
+
*/
|
|
142
|
+
declare const DRAIN_RULES: readonly Rule[];
|
|
143
|
+
//#endregion
|
|
144
|
+
export { symbolsOf as C, inequalities as S, TimerMarks as _, O16 as a, compression as b, Change as c, Evaluated as d, Inequality as f, TimerMark as g, Term as h, O10 as i, Compressed as l, Side as m, O04 as n, Binding as o, Rule as p, O09 as r, Bound as s, DRAIN_RULES as t, Compression as u, Verdict as v, verdictOf as w, evaluate as x, compress as y };
|
|
145
|
+
//# sourceMappingURL=rules-BBRopO1e.d.ts.map
|
package/build/rules.d.ts
ADDED
package/build/rules.js
ADDED
|
@@ -0,0 +1,128 @@
|
|
|
1
|
+
//#region src/rules.ts
|
|
2
|
+
/**
|
|
3
|
+
* O04 with the hold of the service. The listener of a pod stays open through the preStop sleep and
|
|
4
|
+
* then through the hold of `fail readiness`. Thus the sum of the two must cover the propagation of
|
|
5
|
+
* the endpoints. The rule of the research is the case without a hold.
|
|
6
|
+
*/
|
|
7
|
+
const O04 = {
|
|
8
|
+
id: "O04",
|
|
9
|
+
rule: "the preStop sleep plus the hold of fail readiness is at least the endpoint propagation",
|
|
10
|
+
window: "new connections reach a pod whose listener is closed",
|
|
11
|
+
expr: {
|
|
12
|
+
lhs: { terms: [{
|
|
13
|
+
knob: "prestop_sleep",
|
|
14
|
+
coef: 1,
|
|
15
|
+
at: "pod"
|
|
16
|
+
}, {
|
|
17
|
+
knob: "readiness_hold",
|
|
18
|
+
coef: 1,
|
|
19
|
+
at: "process"
|
|
20
|
+
}] },
|
|
21
|
+
op: ">=",
|
|
22
|
+
rhs: { terms: [{
|
|
23
|
+
knob: "propagation_bound",
|
|
24
|
+
coef: 1,
|
|
25
|
+
at: "cluster"
|
|
26
|
+
}] }
|
|
27
|
+
}
|
|
28
|
+
};
|
|
29
|
+
/** O09 is W8: readiness detection plus propagation is no longer than liveness detection plus the preStop sleep. */
|
|
30
|
+
const O09 = {
|
|
31
|
+
id: "O09",
|
|
32
|
+
rule: "readiness detection plus endpoint propagation is no longer than liveness detection plus the preStop sleep",
|
|
33
|
+
window: "traffic reaches a container that its liveness probe kills",
|
|
34
|
+
expr: {
|
|
35
|
+
lhs: { terms: [{
|
|
36
|
+
knob: "readiness_detection_window",
|
|
37
|
+
coef: 1,
|
|
38
|
+
at: "pod"
|
|
39
|
+
}, {
|
|
40
|
+
knob: "propagation_bound",
|
|
41
|
+
coef: 1,
|
|
42
|
+
at: "cluster"
|
|
43
|
+
}] },
|
|
44
|
+
op: "<=",
|
|
45
|
+
rhs: { terms: [{
|
|
46
|
+
knob: "liveness_detection_window",
|
|
47
|
+
coef: 1,
|
|
48
|
+
at: "pod"
|
|
49
|
+
}, {
|
|
50
|
+
knob: "prestop_sleep",
|
|
51
|
+
coef: 1,
|
|
52
|
+
at: "pod"
|
|
53
|
+
}] }
|
|
54
|
+
}
|
|
55
|
+
};
|
|
56
|
+
/** O10: the preStop sleep plus the drain of the process fits in the grace period. */
|
|
57
|
+
const O10 = {
|
|
58
|
+
id: "O10",
|
|
59
|
+
rule: "the preStop sleep plus the shutdown of the process fits in the grace period",
|
|
60
|
+
window: "work in flight at SIGKILL is cut, and each connection closes at once",
|
|
61
|
+
expr: {
|
|
62
|
+
lhs: { terms: [{
|
|
63
|
+
knob: "prestop_sleep",
|
|
64
|
+
coef: 1,
|
|
65
|
+
at: "pod"
|
|
66
|
+
}, {
|
|
67
|
+
knob: "process_drain_time",
|
|
68
|
+
coef: 1,
|
|
69
|
+
at: "process"
|
|
70
|
+
}] },
|
|
71
|
+
op: "<=",
|
|
72
|
+
rhs: { terms: [{
|
|
73
|
+
knob: "termination_grace",
|
|
74
|
+
coef: 1,
|
|
75
|
+
at: "pod"
|
|
76
|
+
}] }
|
|
77
|
+
}
|
|
78
|
+
};
|
|
79
|
+
/** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */
|
|
80
|
+
const O16 = {
|
|
81
|
+
id: "O16",
|
|
82
|
+
rule: "the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep",
|
|
83
|
+
window: "handlers are cut before they answer, or the drain itself gets SIGKILL",
|
|
84
|
+
expr: {
|
|
85
|
+
lhs: { terms: [{
|
|
86
|
+
knob: "cooperative_window",
|
|
87
|
+
coef: 1,
|
|
88
|
+
at: "process"
|
|
89
|
+
}] },
|
|
90
|
+
op: "<",
|
|
91
|
+
rhs: { terms: [{
|
|
92
|
+
knob: "process_drain_time",
|
|
93
|
+
coef: 1,
|
|
94
|
+
at: "process"
|
|
95
|
+
}] }
|
|
96
|
+
},
|
|
97
|
+
expr_more: [{
|
|
98
|
+
lhs: { terms: [{
|
|
99
|
+
knob: "process_drain_time",
|
|
100
|
+
coef: 1,
|
|
101
|
+
at: "process"
|
|
102
|
+
}] },
|
|
103
|
+
op: "<",
|
|
104
|
+
rhs: { terms: [{
|
|
105
|
+
knob: "termination_grace",
|
|
106
|
+
coef: 1,
|
|
107
|
+
at: "pod"
|
|
108
|
+
}, {
|
|
109
|
+
knob: "prestop_sleep",
|
|
110
|
+
coef: -1,
|
|
111
|
+
at: "pod"
|
|
112
|
+
}] }
|
|
113
|
+
}]
|
|
114
|
+
};
|
|
115
|
+
/**
|
|
116
|
+
* These are the rules of the drain. For each way that a pod stops, `lintStop()` applies only the
|
|
117
|
+
* rules of this set that guard that way. `DRAIN_RULE_IDS` gives their identifiers.
|
|
118
|
+
*/
|
|
119
|
+
const DRAIN_RULES = [
|
|
120
|
+
O04,
|
|
121
|
+
O09,
|
|
122
|
+
O10,
|
|
123
|
+
O16
|
|
124
|
+
];
|
|
125
|
+
//#endregion
|
|
126
|
+
export { DRAIN_RULES, O04, O09, O10, O16 };
|
|
127
|
+
|
|
128
|
+
//# sourceMappingURL=rules.js.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"rules.js","names":[],"sources":["../src/rules.ts"],"sourcesContent":["// @mark1russell7/service/rules: the rules of the ordering law that a drain in Kubernetes meets, as\n// data (SYS-32). The caller of `lint()` gives the rules. This entry gives the drain rules from one\n// source, thus a service does not copy them into its tests. It loads no module at run time: only the\n// type of a rule comes from the law. Thus it loads no Testcontainers, no `node:` module and no zod.\n\nimport type { Rule } from \"./law.ts\";\n\nexport type { Rule } from \"./law.ts\";\n\n/**\n * O04 with the hold of the service. The listener of a pod stays open through the preStop sleep and\n * then through the hold of `fail readiness`. Thus the sum of the two must cover the propagation of\n * the endpoints. The rule of the research is the case without a hold.\n */\nexport const O04: Rule = {\n id: \"O04\",\n rule: \"the preStop sleep plus the hold of fail readiness is at least the endpoint propagation\",\n window: \"new connections reach a pod whose listener is closed\",\n expr: {\n lhs: {\n terms: [\n { knob: \"prestop_sleep\", coef: 1, at: \"pod\" },\n { knob: \"readiness_hold\", coef: 1, at: \"process\" },\n ],\n },\n op: \">=\",\n rhs: { terms: [{ knob: \"propagation_bound\", coef: 1, at: \"cluster\" }] },\n },\n};\n\n/** O09 is W8: readiness detection plus propagation is no longer than liveness detection plus the preStop sleep. */\nexport const O09: Rule = {\n id: \"O09\",\n rule: \"readiness detection plus endpoint propagation is no longer than liveness detection plus the preStop sleep\",\n window: \"traffic reaches a container that its liveness probe kills\",\n expr: {\n lhs: {\n terms: [\n { knob: \"readiness_detection_window\", coef: 1, at: \"pod\" },\n { knob: \"propagation_bound\", coef: 1, at: \"cluster\" },\n ],\n },\n op: \"<=\",\n rhs: {\n terms: [\n { knob: \"liveness_detection_window\", coef: 1, at: \"pod\" },\n { knob: \"prestop_sleep\", coef: 1, at: \"pod\" },\n ],\n },\n },\n};\n\n/** O10: the preStop sleep plus the drain of the process fits in the grace period. */\nexport const O10: Rule = {\n id: \"O10\",\n rule: \"the preStop sleep plus the shutdown of the process fits in the grace period\",\n window: \"work in flight at SIGKILL is cut, and each connection closes at once\",\n expr: {\n lhs: {\n terms: [\n { knob: \"prestop_sleep\", coef: 1, at: \"pod\" },\n { knob: \"process_drain_time\", coef: 1, at: \"process\" },\n ],\n },\n op: \"<=\",\n rhs: { terms: [{ knob: \"termination_grace\", coef: 1, at: \"pod\" }] },\n },\n};\n\n/** O16: the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep. */\nexport const O16: Rule = {\n id: \"O16\",\n rule: \"the cooperative window is shorter than the drain, which is shorter than the grace less the preStop sleep\",\n window: \"handlers are cut before they answer, or the drain itself gets SIGKILL\",\n expr: {\n lhs: { terms: [{ knob: \"cooperative_window\", coef: 1, at: \"process\" }] },\n op: \"<\",\n rhs: { terms: [{ knob: \"process_drain_time\", coef: 1, at: \"process\" }] },\n },\n expr_more: [\n {\n lhs: { terms: [{ knob: \"process_drain_time\", coef: 1, at: \"process\" }] },\n op: \"<\",\n rhs: {\n terms: [\n { knob: \"termination_grace\", coef: 1, at: \"pod\" },\n { knob: \"prestop_sleep\", coef: -1, at: \"pod\" },\n ],\n },\n },\n ],\n};\n\n/**\n * These are the rules of the drain. For each way that a pod stops, `lintStop()` applies only the\n * rules of this set that guard that way. `DRAIN_RULE_IDS` gives their identifiers.\n */\nexport const DRAIN_RULES: readonly Rule[] = [O04, O09, O10, O16];\n"],"mappings":";;;;;;AAcA,MAAa,MAAY;CACvB,IAAI;CACJ,MAAM;CACN,QAAQ;CACR,MAAM;EACJ,KAAK,EACH,OAAO,CACL;GAAE,MAAM;GAAiB,MAAM;GAAG,IAAI;EAAM,GAC5C;GAAE,MAAM;GAAkB,MAAM;GAAG,IAAI;EAAU,CACnD,EACF;EACA,IAAI;EACJ,KAAK,EAAE,OAAO,CAAC;GAAE,MAAM;GAAqB,MAAM;GAAG,IAAI;EAAU,CAAC,EAAE;CACxE;AACF;;AAGA,MAAa,MAAY;CACvB,IAAI;CACJ,MAAM;CACN,QAAQ;CACR,MAAM;EACJ,KAAK,EACH,OAAO,CACL;GAAE,MAAM;GAA8B,MAAM;GAAG,IAAI;EAAM,GACzD;GAAE,MAAM;GAAqB,MAAM;GAAG,IAAI;EAAU,CACtD,EACF;EACA,IAAI;EACJ,KAAK,EACH,OAAO,CACL;GAAE,MAAM;GAA6B,MAAM;GAAG,IAAI;EAAM,GACxD;GAAE,MAAM;GAAiB,MAAM;GAAG,IAAI;EAAM,CAC9C,EACF;CACF;AACF;;AAGA,MAAa,MAAY;CACvB,IAAI;CACJ,MAAM;CACN,QAAQ;CACR,MAAM;EACJ,KAAK,EACH,OAAO,CACL;GAAE,MAAM;GAAiB,MAAM;GAAG,IAAI;EAAM,GAC5C;GAAE,MAAM;GAAsB,MAAM;GAAG,IAAI;EAAU,CACvD,EACF;EACA,IAAI;EACJ,KAAK,EAAE,OAAO,CAAC;GAAE,MAAM;GAAqB,MAAM;GAAG,IAAI;EAAM,CAAC,EAAE;CACpE;AACF;;AAGA,MAAa,MAAY;CACvB,IAAI;CACJ,MAAM;CACN,QAAQ;CACR,MAAM;EACJ,KAAK,EAAE,OAAO,CAAC;GAAE,MAAM;GAAsB,MAAM;GAAG,IAAI;EAAU,CAAC,EAAE;EACvE,IAAI;EACJ,KAAK,EAAE,OAAO,CAAC;GAAE,MAAM;GAAsB,MAAM;GAAG,IAAI;EAAU,CAAC,EAAE;CACzE;CACA,WAAW,CACT;EACE,KAAK,EAAE,OAAO,CAAC;GAAE,MAAM;GAAsB,MAAM;GAAG,IAAI;EAAU,CAAC,EAAE;EACvE,IAAI;EACJ,KAAK,EACH,OAAO,CACL;GAAE,MAAM;GAAqB,MAAM;GAAG,IAAI;EAAM,GAChD;GAAE,MAAM;GAAiB,MAAM;GAAI,IAAI;EAAM,CAC/C,EACF;CACF,CACF;AACF;;;;;AAMA,MAAa,cAA+B;CAAC;CAAK;CAAK;CAAK;AAAG"}
|
package/package.json
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
{
|
|
2
2
|
"$schema": "https://json.schemastore.org/package",
|
|
3
3
|
"name": "@mark1russell7/service",
|
|
4
|
-
"version": "0.6.
|
|
4
|
+
"version": "0.6.1",
|
|
5
5
|
"description": "A service declared as data before it starts, and its runtime: checks on jittered loops, a latch for each policy, probes from the cache, the startup in its sequence, and a staged, capped drain. The timer-ordering law checks the declaration. Its clock, heartbeat and backoff also work alone, in a browser too.",
|
|
6
6
|
"keywords": [
|
|
7
7
|
"service",
|
|
@@ -86,6 +86,10 @@
|
|
|
86
86
|
"types": "./build/limiter.d.ts",
|
|
87
87
|
"default": "./build/limiter.js"
|
|
88
88
|
},
|
|
89
|
+
"./rules": {
|
|
90
|
+
"types": "./build/rules.d.ts",
|
|
91
|
+
"default": "./build/rules.js"
|
|
92
|
+
},
|
|
89
93
|
"./package.json": "./package.json"
|
|
90
94
|
},
|
|
91
95
|
"files": [
|
|
@@ -97,7 +101,7 @@
|
|
|
97
101
|
"node": ">=22.19"
|
|
98
102
|
},
|
|
99
103
|
"dependencies": {
|
|
100
|
-
"@mark1russell7/algebra": "^0.
|
|
104
|
+
"@mark1russell7/algebra": "^0.8.0",
|
|
101
105
|
"@mark1russell7/quantity": "^0.2.0"
|
|
102
106
|
},
|
|
103
107
|
"peerDependencies": {
|