@kya-os/checkpoint-shared 1.2.0 → 1.3.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/README.md +1 -1
- package/dist/beacon-types/index.d.mts +10 -1
- package/dist/beacon-types/index.d.ts +10 -1
- package/dist/beacon-types/index.js +20 -1
- package/dist/beacon-types/index.mjs +20 -2
- package/dist/browser.d.mts +6 -1
- package/dist/browser.d.ts +6 -1
- package/dist/browser.js +1 -1
- package/dist/browser.mjs +1 -1
- package/dist/canonical-signer/index.js +31 -2
- package/dist/canonical-signer/index.mjs +31 -2
- package/dist/deploy/index.d.mts +827 -0
- package/dist/deploy/index.d.ts +827 -0
- package/dist/deploy/index.js +458 -0
- package/dist/deploy/index.mjs +433 -0
- package/dist/gateway/index.d.mts +575 -0
- package/dist/gateway/index.d.ts +575 -0
- package/dist/gateway/index.js +98 -0
- package/dist/gateway/index.mjs +88 -0
- package/dist/index.d.mts +3071 -871
- package/dist/index.d.ts +3071 -871
- package/dist/index.js +3344 -1308
- package/dist/index.mjs +4593 -2667
- package/dist/mcpi/agentshield-api/index.d.mts +47 -0
- package/dist/mcpi/agentshield-api/index.d.ts +47 -0
- package/dist/mcpi/agentshield-api/index.js +2 -0
- package/dist/mcpi/agentshield-api/index.mjs +1 -0
- package/dist/mcpi/approval-grant/index.d.mts +79 -0
- package/dist/mcpi/approval-grant/index.d.ts +79 -0
- package/dist/mcpi/approval-grant/index.js +157 -0
- package/dist/mcpi/approval-grant/index.mjs +150 -0
- package/dist/mcpi/dashboard-config/index.d.mts +14075 -0
- package/dist/mcpi/dashboard-config/index.d.ts +14075 -0
- package/dist/mcpi/dashboard-config/index.js +517 -0
- package/dist/mcpi/dashboard-config/index.mjs +492 -0
- package/dist/mcpi/multibase-ed25519.d.mts +8 -0
- package/dist/mcpi/multibase-ed25519.d.ts +8 -0
- package/dist/mcpi/multibase-ed25519.js +125 -0
- package/dist/mcpi/multibase-ed25519.mjs +119 -0
- package/dist/signals/index.d.mts +158 -0
- package/dist/signals/index.d.ts +158 -0
- package/dist/signals/index.js +1574 -0
- package/dist/signals/index.mjs +1544 -0
- package/dist/test-fixtures/index.d.mts +53 -8
- package/dist/test-fixtures/index.d.ts +53 -8
- package/dist/test-fixtures/index.js +164 -7
- package/dist/test-fixtures/index.mjs +158 -8
- package/dist/tool-protection/index.d.mts +1120 -0
- package/dist/tool-protection/index.d.ts +1120 -0
- package/dist/tool-protection/index.js +370 -0
- package/dist/tool-protection/index.mjs +338 -0
- package/package.json +54 -8
- package/src/data/compiled/merged-rules.json +8 -2
|
@@ -0,0 +1,1574 @@
|
|
|
1
|
+
'use strict';
|
|
2
|
+
|
|
3
|
+
var sha2_js = require('@noble/hashes/sha2.js');
|
|
4
|
+
var utils_js = require('@noble/hashes/utils.js');
|
|
5
|
+
|
|
6
|
+
// src/signals/types.ts
|
|
7
|
+
var REGISTRY_VERSIONS = ["v1", "v2"];
|
|
8
|
+
var CURRENT_REGISTRY_VERSION = REGISTRY_VERSIONS[REGISTRY_VERSIONS.length - 1];
|
|
9
|
+
var FROZEN_FIELDS = ["id", "addedVersion", "denoise", "mode", "plane", "group"];
|
|
10
|
+
var TIER_LOCKED_FIELDS = ["tier"];
|
|
11
|
+
|
|
12
|
+
// src/signals/sensitive-attributes.ts
|
|
13
|
+
var SENSITIVE_REJECTION_LIST_VERSIONS = ["v1"];
|
|
14
|
+
var CURRENT_SENSITIVE_REJECTION_LIST_VERSION = SENSITIVE_REJECTION_LIST_VERSIONS[SENSITIVE_REJECTION_LIST_VERSIONS.length - 1];
|
|
15
|
+
var SENSITIVE_ATTRIBUTE_REJECTION_LIST = {
|
|
16
|
+
v1: [
|
|
17
|
+
{
|
|
18
|
+
category: "racial-or-ethnic-origin",
|
|
19
|
+
description: "Inference indicating racial or ethnic origin.",
|
|
20
|
+
regimes: ["CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)"],
|
|
21
|
+
keywords: ["racial origin", "ethnic origin", "race indicator", "ethnicity indicator"]
|
|
22
|
+
},
|
|
23
|
+
{
|
|
24
|
+
category: "religious-or-philosophical-beliefs",
|
|
25
|
+
description: "Inference indicating religious or philosophical beliefs.",
|
|
26
|
+
regimes: ["CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)"],
|
|
27
|
+
keywords: [
|
|
28
|
+
"religious belief",
|
|
29
|
+
"religious observance",
|
|
30
|
+
"philosophical belief",
|
|
31
|
+
"faith affiliation"
|
|
32
|
+
]
|
|
33
|
+
},
|
|
34
|
+
{
|
|
35
|
+
category: "mental-or-physical-health-condition-or-diagnosis",
|
|
36
|
+
description: "Inference indicating a mental or physical health condition or diagnosis.",
|
|
37
|
+
regimes: [
|
|
38
|
+
"CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)",
|
|
39
|
+
"WA My Health My Data Act (RCW 19.373)",
|
|
40
|
+
"NV SB 370 (consumer health data)"
|
|
41
|
+
],
|
|
42
|
+
keywords: [
|
|
43
|
+
"health condition",
|
|
44
|
+
"medical condition",
|
|
45
|
+
"health diagnosis",
|
|
46
|
+
"mental health condition",
|
|
47
|
+
"mental health diagnosis",
|
|
48
|
+
"physical health condition",
|
|
49
|
+
"disability status",
|
|
50
|
+
"disease indicator",
|
|
51
|
+
"illness indicator"
|
|
52
|
+
]
|
|
53
|
+
},
|
|
54
|
+
{
|
|
55
|
+
category: "sex-life-or-sexual-orientation",
|
|
56
|
+
description: "Inference indicating sex life or sexual orientation.",
|
|
57
|
+
regimes: ["CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)"],
|
|
58
|
+
keywords: ["sexual orientation", "sex life", "gender identity inferred"]
|
|
59
|
+
},
|
|
60
|
+
{
|
|
61
|
+
category: "citizenship-or-immigration-status",
|
|
62
|
+
description: "Inference indicating citizenship or citizenship status.",
|
|
63
|
+
regimes: ["CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)"],
|
|
64
|
+
keywords: [
|
|
65
|
+
"citizenship status",
|
|
66
|
+
"immigration status",
|
|
67
|
+
"visa status",
|
|
68
|
+
"national origin status",
|
|
69
|
+
"resident alien status"
|
|
70
|
+
]
|
|
71
|
+
},
|
|
72
|
+
{
|
|
73
|
+
category: "biometric-identifier-or-derivative",
|
|
74
|
+
description: "A biometric identifier, or a derivative of one, used to identify an individual.",
|
|
75
|
+
regimes: ["CT Data Privacy Act (Public Act 22-15)"],
|
|
76
|
+
keywords: [
|
|
77
|
+
"voiceprint",
|
|
78
|
+
"faceprint",
|
|
79
|
+
"iris scan",
|
|
80
|
+
"retina scan",
|
|
81
|
+
"facial geometry",
|
|
82
|
+
"gait analysis",
|
|
83
|
+
"palm print",
|
|
84
|
+
"dna profile",
|
|
85
|
+
"genetic marker"
|
|
86
|
+
]
|
|
87
|
+
},
|
|
88
|
+
{
|
|
89
|
+
category: "government-identification-number",
|
|
90
|
+
description: "A government-issued identification number.",
|
|
91
|
+
regimes: ["CT Data Privacy Act (Public Act 22-15)"],
|
|
92
|
+
keywords: [
|
|
93
|
+
"social security number",
|
|
94
|
+
"ssn",
|
|
95
|
+
"passport number",
|
|
96
|
+
"driver's license number",
|
|
97
|
+
"driver license number",
|
|
98
|
+
"national id number",
|
|
99
|
+
"government id number",
|
|
100
|
+
"tax id number"
|
|
101
|
+
]
|
|
102
|
+
}
|
|
103
|
+
]
|
|
104
|
+
};
|
|
105
|
+
var COMPOSITION_RISK_RULES = [
|
|
106
|
+
{
|
|
107
|
+
id: "accessibility-preference-composite",
|
|
108
|
+
category: "mental-or-physical-health-condition-or-diagnosis",
|
|
109
|
+
signalIds: [
|
|
110
|
+
"platform.reducedMotion",
|
|
111
|
+
"platform.invertedColors",
|
|
112
|
+
"platform.contrast",
|
|
113
|
+
"platform.forcedColors",
|
|
114
|
+
"platform.reducedTransparency"
|
|
115
|
+
],
|
|
116
|
+
minMatches: 2,
|
|
117
|
+
regimes: [
|
|
118
|
+
"CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)",
|
|
119
|
+
"WA My Health My Data Act (RCW 19.373)",
|
|
120
|
+
"NV SB 370 (consumer health data)"
|
|
121
|
+
],
|
|
122
|
+
rationale: "Two or more OS-level accessibility-preference reads (reduced motion, inverted colors, forced colors, reduced contrast, reduced transparency), combined into one derived feature, reliably identify a disability/health accommodation (e.g. vestibular disorder, low vision, photosensitivity), even though each individual CSS media-feature probe is, alone, a consent-gated, near-zero-weight contradiction signal."
|
|
123
|
+
},
|
|
124
|
+
{
|
|
125
|
+
id: "locale-cluster-national-origin-composite",
|
|
126
|
+
category: "citizenship-or-immigration-status",
|
|
127
|
+
signalIds: ["platform.languages", "platform.timezone", "platform.dateTimeLocale"],
|
|
128
|
+
minMatches: 3,
|
|
129
|
+
regimes: [
|
|
130
|
+
"CO Privacy Act Rules, 4 CCR 904-3 \xA72.02 (Sensitive Data Inferences)",
|
|
131
|
+
"CT Data Privacy Act (Public Act 22-15)"
|
|
132
|
+
],
|
|
133
|
+
rationale: `Combining accepted-languages, IANA timezone, and resolved locale into one derived "origin" feature moves from three individually benign, user-configurable locale reads into a feature whose purpose is inferring likely national origin/immigration status: the "alone or combined" inference Colorado's rule targets.`
|
|
134
|
+
}
|
|
135
|
+
];
|
|
136
|
+
function tokenizeIdentifier(text) {
|
|
137
|
+
return text.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[._-]+/g, " ");
|
|
138
|
+
}
|
|
139
|
+
function scanTexts(signal) {
|
|
140
|
+
const raw = `${signal.id} ${signal.description} ${signal.group}`.toLowerCase();
|
|
141
|
+
const tokenized = `${tokenizeIdentifier(signal.id)} ${tokenizeIdentifier(signal.description)} ${tokenizeIdentifier(signal.group)}`.toLowerCase();
|
|
142
|
+
return [raw, tokenized];
|
|
143
|
+
}
|
|
144
|
+
function checkDirectMatch(signal, version = CURRENT_SENSITIVE_REJECTION_LIST_VERSION) {
|
|
145
|
+
const texts = scanTexts(signal);
|
|
146
|
+
const rules = SENSITIVE_ATTRIBUTE_REJECTION_LIST[version];
|
|
147
|
+
const violations = [];
|
|
148
|
+
for (const rule of rules) {
|
|
149
|
+
const hit = rule.keywords.find((keyword) => texts.some((text) => text.includes(keyword)));
|
|
150
|
+
if (hit) {
|
|
151
|
+
violations.push({
|
|
152
|
+
kind: "direct",
|
|
153
|
+
category: rule.category,
|
|
154
|
+
ruleId: rule.category,
|
|
155
|
+
regimes: rule.regimes,
|
|
156
|
+
message: `derives "${rule.category}" (matched "${hit}"): a direct Sensitive Data Inference per ${rule.regimes.join("; ")}.`
|
|
157
|
+
});
|
|
158
|
+
}
|
|
159
|
+
}
|
|
160
|
+
return violations;
|
|
161
|
+
}
|
|
162
|
+
function checkCompositionRisk(signalId, combinesWith) {
|
|
163
|
+
if (combinesWith.length === 0) return [];
|
|
164
|
+
const combinationSet = /* @__PURE__ */ new Set([signalId, ...combinesWith]);
|
|
165
|
+
const violations = [];
|
|
166
|
+
for (const rule of COMPOSITION_RISK_RULES) {
|
|
167
|
+
const matches = rule.signalIds.filter((id) => combinationSet.has(id));
|
|
168
|
+
if (matches.length >= rule.minMatches) {
|
|
169
|
+
violations.push({
|
|
170
|
+
kind: "composition",
|
|
171
|
+
category: rule.category,
|
|
172
|
+
ruleId: rule.id,
|
|
173
|
+
regimes: rule.regimes,
|
|
174
|
+
message: `combination rule "${rule.id}" fired: [${matches.join(", ")}] combine into "${rule.category}" per ${rule.regimes.join("; ")}. ${rule.rationale}`
|
|
175
|
+
});
|
|
176
|
+
}
|
|
177
|
+
}
|
|
178
|
+
return violations;
|
|
179
|
+
}
|
|
180
|
+
function checkDeclaredCategory(review, version = CURRENT_SENSITIVE_REJECTION_LIST_VERSION) {
|
|
181
|
+
if (review.derivesCategory === null) return [];
|
|
182
|
+
const rule = SENSITIVE_ATTRIBUTE_REJECTION_LIST[version].find(
|
|
183
|
+
(r) => r.category === review.derivesCategory
|
|
184
|
+
);
|
|
185
|
+
const regimes = rule?.regimes ?? [];
|
|
186
|
+
return [
|
|
187
|
+
{
|
|
188
|
+
kind: "declared",
|
|
189
|
+
category: review.derivesCategory,
|
|
190
|
+
ruleId: review.derivesCategory,
|
|
191
|
+
regimes,
|
|
192
|
+
message: `reviewer declared this feature derives "${review.derivesCategory}"${regimes.length ? ` (${regimes.join("; ")})` : ""}.`
|
|
193
|
+
}
|
|
194
|
+
];
|
|
195
|
+
}
|
|
196
|
+
function checkReviewRecordIntegrity(review, currentVersion = CURRENT_SENSITIVE_REJECTION_LIST_VERSION) {
|
|
197
|
+
if (!review) {
|
|
198
|
+
return [
|
|
199
|
+
{
|
|
200
|
+
kind: "stale-review",
|
|
201
|
+
category: null,
|
|
202
|
+
ruleId: "missing-review",
|
|
203
|
+
regimes: [],
|
|
204
|
+
message: "has no sensitiveAttributeReview record: every registered signal requires one."
|
|
205
|
+
}
|
|
206
|
+
];
|
|
207
|
+
}
|
|
208
|
+
if (!review.reviewedBy || !review.reviewedAt || !review.rationale) {
|
|
209
|
+
return [
|
|
210
|
+
{
|
|
211
|
+
kind: "stale-review",
|
|
212
|
+
category: null,
|
|
213
|
+
ruleId: "incomplete-review",
|
|
214
|
+
regimes: [],
|
|
215
|
+
message: "has an incomplete review record (reviewedBy/reviewedAt/rationale required)."
|
|
216
|
+
}
|
|
217
|
+
];
|
|
218
|
+
}
|
|
219
|
+
if (review.listVersion !== currentVersion) {
|
|
220
|
+
return [
|
|
221
|
+
{
|
|
222
|
+
kind: "stale-review",
|
|
223
|
+
category: null,
|
|
224
|
+
ruleId: "stale-list-version",
|
|
225
|
+
regimes: [],
|
|
226
|
+
message: `was reviewed against rejection-list version "${review.listVersion}", but the current version is "${currentVersion}": re-evaluation required. See findSignalsNeedingReevaluation().`
|
|
227
|
+
}
|
|
228
|
+
];
|
|
229
|
+
}
|
|
230
|
+
return [];
|
|
231
|
+
}
|
|
232
|
+
function evaluateSensitiveAttributeCompliance(signal) {
|
|
233
|
+
return [
|
|
234
|
+
...checkDirectMatch(signal),
|
|
235
|
+
...checkCompositionRisk(signal.id, signal.review?.combinesWith ?? []),
|
|
236
|
+
...signal.review ? checkDeclaredCategory(signal.review) : [],
|
|
237
|
+
...checkReviewRecordIntegrity(signal.review)
|
|
238
|
+
];
|
|
239
|
+
}
|
|
240
|
+
function formatViolation(v) {
|
|
241
|
+
return ` - [${v.kind}] ${v.message}`;
|
|
242
|
+
}
|
|
243
|
+
var SensitiveAttributeRejectionError = class extends Error {
|
|
244
|
+
signalId;
|
|
245
|
+
violations;
|
|
246
|
+
constructor(signalId, violations) {
|
|
247
|
+
const lines = [
|
|
248
|
+
`Feature registration rejected for "${signalId}": Sensitive Data Inference constraint(s) fired.`,
|
|
249
|
+
...violations.map(formatViolation),
|
|
250
|
+
"This is a legal boundary (see CO Privacy Act Rules Sensitive Data Inferences; WA My Health My Data Act; NV SB 370; CT Data Privacy Act) enforced in code, not documentation.",
|
|
251
|
+
"To register this feature: resolve the conflict (drop the derivation, or narrow combinesWith) and route the change through the sensitive-attribute review process (see docs/governance/sensitive-attribute-rejection-list.md) before re-registering. Do not bypass by editing SIGNAL_REGISTRY directly: validateRegistry() enforces the same check."
|
|
252
|
+
];
|
|
253
|
+
super(lines.join("\n"));
|
|
254
|
+
this.name = "SensitiveAttributeRejectionError";
|
|
255
|
+
this.signalId = signalId;
|
|
256
|
+
this.violations = violations;
|
|
257
|
+
}
|
|
258
|
+
};
|
|
259
|
+
function registerSignal(definition) {
|
|
260
|
+
const violations = evaluateSensitiveAttributeCompliance(definition);
|
|
261
|
+
if (violations.length > 0) {
|
|
262
|
+
throw new SensitiveAttributeRejectionError(definition.id, violations);
|
|
263
|
+
}
|
|
264
|
+
return definition;
|
|
265
|
+
}
|
|
266
|
+
function checkSensitiveAttributeCompliance(signal) {
|
|
267
|
+
const violations = evaluateSensitiveAttributeCompliance(signal);
|
|
268
|
+
return { ok: violations.length === 0, violations };
|
|
269
|
+
}
|
|
270
|
+
function findSignalsNeedingReevaluation(signals, currentVersion = CURRENT_SENSITIVE_REJECTION_LIST_VERSION) {
|
|
271
|
+
return signals.filter((s) => !s.review || s.review.listVersion !== currentVersion);
|
|
272
|
+
}
|
|
273
|
+
|
|
274
|
+
// src/signals/registry.ts
|
|
275
|
+
function provisional(notes) {
|
|
276
|
+
return {
|
|
277
|
+
agreementRate: null,
|
|
278
|
+
sampleSize: 0,
|
|
279
|
+
browsers: [],
|
|
280
|
+
measuredAt: null,
|
|
281
|
+
provisional: true,
|
|
282
|
+
notes
|
|
283
|
+
};
|
|
284
|
+
}
|
|
285
|
+
function compliantReview() {
|
|
286
|
+
return {
|
|
287
|
+
listVersion: CURRENT_SENSITIVE_REJECTION_LIST_VERSION,
|
|
288
|
+
reviewedBy: "privacy-review@kya-os.example",
|
|
289
|
+
reviewedAt: "2026-08-19",
|
|
290
|
+
combinesWith: [],
|
|
291
|
+
derivesCategory: null,
|
|
292
|
+
rationale: "Raw device/browser entropy read; no plausible link to a Sensitive Data Inference category, individually or via a known composition-risk rule."
|
|
293
|
+
};
|
|
294
|
+
}
|
|
295
|
+
var SIGNAL_REGISTRY = [
|
|
296
|
+
// --- rendering plane ---------------------------------------------------
|
|
297
|
+
{
|
|
298
|
+
id: "canvas.geometry",
|
|
299
|
+
addedVersion: "v1",
|
|
300
|
+
removedVersion: "v2",
|
|
301
|
+
tier: "medium",
|
|
302
|
+
measurement: provisional(
|
|
303
|
+
"Canvas 2D geometry rasterisation is GPU/driver dependent; expected to move on driver updates, stable otherwise. No modal() de-noising applied yet, so privacy-browser farbling is expected to reduce agreement \u2014 this is exactly what the v2 fork below addresses."
|
|
304
|
+
),
|
|
305
|
+
denoise: { kind: "none" },
|
|
306
|
+
mode: "consent",
|
|
307
|
+
plane: "rendering",
|
|
308
|
+
group: "canvas",
|
|
309
|
+
u: null,
|
|
310
|
+
supersedes: null,
|
|
311
|
+
description: "Hash of a rendered 2D canvas shape/text scene. Single-read today; superseded by canvas.geometry.v2 once modal(3) de-noising lands (prompt 2).",
|
|
312
|
+
review: compliantReview()
|
|
313
|
+
},
|
|
314
|
+
{
|
|
315
|
+
id: "canvas.geometry.v2",
|
|
316
|
+
addedVersion: "v2",
|
|
317
|
+
removedVersion: null,
|
|
318
|
+
tier: "medium",
|
|
319
|
+
measurement: provisional(
|
|
320
|
+
"Same read as canvas.geometry, sampled 3x and reduced by mode to recover the deterministic render under per-session farbling noise (Brave/Firefox/Safari). Originally a worked fork example proving the versioning mechanism ahead of the real collector; #4256 has since landed the real geometry-only collector (packages/checkpoint-beacon/.../entropy/canvas.ts) with these exact frozen fields (modal(3), consent, rendering/canvas), so this entry is now that signal for real, not just the demo."
|
|
321
|
+
),
|
|
322
|
+
denoise: { kind: "modal", runs: 3 },
|
|
323
|
+
mode: "consent",
|
|
324
|
+
plane: "rendering",
|
|
325
|
+
group: "canvas",
|
|
326
|
+
u: null,
|
|
327
|
+
supersedes: "canvas.geometry",
|
|
328
|
+
description: "Hash of a rendered 2D canvas GEOMETRY-ONLY scene (overlapping shapes, a bezier stroke); no text is drawn into this read. Forked from canvas.geometry (which conflated shape and text in one read) to apply modal(3) de-noising instead of editing the shipped v1 definition in place. As of #4256/P10, geometry and text are collected and hashed as two fully independent signals (see canvas.text): a font-stack change moves canvas.text and leaves this one untouched, and vice versa for a GPU/driver change.",
|
|
329
|
+
review: compliantReview()
|
|
330
|
+
},
|
|
331
|
+
{
|
|
332
|
+
id: "canvas.text",
|
|
333
|
+
addedVersion: "v2",
|
|
334
|
+
removedVersion: null,
|
|
335
|
+
tier: "low",
|
|
336
|
+
measurement: provisional(
|
|
337
|
+
"Canvas 2D text rasterisation (mixed fonts, emoji) is materially less stable than canvas geometry: it moves on font-stack changes, emoji font updates, and subpixel antialiasing changes, none of which touch canvas.geometry.v2's arcs/bezier stroke. Hashing geometry and text together (as the pre-#4256 client-side detector did, with a 32-bit DJB2 digest with nowhere near enough entropy to separate devices in the first place) meant any text drift destroyed the geometry evidence too; kept as an independent signal with its own, lower tier instead."
|
|
338
|
+
),
|
|
339
|
+
denoise: { kind: "modal", runs: 3 },
|
|
340
|
+
mode: "consent",
|
|
341
|
+
plane: "rendering",
|
|
342
|
+
group: "canvas",
|
|
343
|
+
u: null,
|
|
344
|
+
supersedes: null,
|
|
345
|
+
description: "Hash of a rendered 2D canvas TEXT-ONLY scene (mixed fonts, emoji); no geometry primitives are drawn into this read. Collected and hashed independently of canvas.geometry.v2 by the same collector module (packages/checkpoint-beacon/.../entropy/canvas.ts), so a font-stack or emoji-font change moves this signal without disturbing the geometry one.",
|
|
346
|
+
review: compliantReview()
|
|
347
|
+
},
|
|
348
|
+
{
|
|
349
|
+
id: "webgl.render",
|
|
350
|
+
addedVersion: "v1",
|
|
351
|
+
removedVersion: null,
|
|
352
|
+
tier: "medium",
|
|
353
|
+
measurement: provisional(
|
|
354
|
+
"WebGL renderer/parameter fingerprint. Moves on GPU driver updates; stable within a driver version. Farbling affects some browsers (notably Samsung Internet)."
|
|
355
|
+
),
|
|
356
|
+
denoise: { kind: "none" },
|
|
357
|
+
mode: "consent",
|
|
358
|
+
plane: "rendering",
|
|
359
|
+
group: "webgl",
|
|
360
|
+
u: null,
|
|
361
|
+
supersedes: null,
|
|
362
|
+
description: "Hash of WebGL renderer info and a rendered scene.",
|
|
363
|
+
review: compliantReview()
|
|
364
|
+
},
|
|
365
|
+
{
|
|
366
|
+
id: "audio.digest",
|
|
367
|
+
addedVersion: "v1",
|
|
368
|
+
removedVersion: null,
|
|
369
|
+
tier: "medium",
|
|
370
|
+
measurement: provisional(
|
|
371
|
+
"AudioContext oscillator/compressor output digest. Deterministic per audio stack; moves on driver/OS audio-subsystem updates."
|
|
372
|
+
),
|
|
373
|
+
denoise: { kind: "none" },
|
|
374
|
+
mode: "consent",
|
|
375
|
+
plane: "rendering",
|
|
376
|
+
group: "audio",
|
|
377
|
+
u: null,
|
|
378
|
+
supersedes: null,
|
|
379
|
+
description: "Digest of a rendered AudioContext sample buffer.",
|
|
380
|
+
review: compliantReview()
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
id: "rendering.fonts",
|
|
384
|
+
addedVersion: "v1",
|
|
385
|
+
removedVersion: null,
|
|
386
|
+
tier: "medium",
|
|
387
|
+
measurement: provisional(
|
|
388
|
+
"Enumerated available font list. High entropy but moves whenever the OS font stack changes (OS updates, new app installs)."
|
|
389
|
+
),
|
|
390
|
+
denoise: { kind: "none" },
|
|
391
|
+
mode: "consent",
|
|
392
|
+
plane: "rendering",
|
|
393
|
+
group: "fonts",
|
|
394
|
+
u: null,
|
|
395
|
+
supersedes: null,
|
|
396
|
+
description: "Set of locally-available fonts detected via width-probing.",
|
|
397
|
+
review: compliantReview()
|
|
398
|
+
},
|
|
399
|
+
{
|
|
400
|
+
id: "rendering.mathFingerprint",
|
|
401
|
+
addedVersion: "v1",
|
|
402
|
+
removedVersion: null,
|
|
403
|
+
tier: "high",
|
|
404
|
+
measurement: provisional(
|
|
405
|
+
"Floating-point transcendental function results depend on the JS engine and CPU FPU implementation, not on user state or GPU driver \u2014 expected to be stable across sessions and survive most updates, per FingerprintJS/ThumbmarkJS prior art."
|
|
406
|
+
),
|
|
407
|
+
denoise: { kind: "none" },
|
|
408
|
+
mode: "open",
|
|
409
|
+
plane: "rendering",
|
|
410
|
+
group: "math",
|
|
411
|
+
u: null,
|
|
412
|
+
supersedes: null,
|
|
413
|
+
description: "Hash of a battery of Math.* transcendental function results.",
|
|
414
|
+
review: compliantReview()
|
|
415
|
+
},
|
|
416
|
+
// --- platform plane ------------------------------------------------------
|
|
417
|
+
{
|
|
418
|
+
id: "platform.hardwareConcurrency",
|
|
419
|
+
addedVersion: "v1",
|
|
420
|
+
removedVersion: null,
|
|
421
|
+
tier: "high",
|
|
422
|
+
measurement: provisional(
|
|
423
|
+
"navigator.hardwareConcurrency reflects physical core count, effectively constant for a given device."
|
|
424
|
+
),
|
|
425
|
+
denoise: { kind: "none" },
|
|
426
|
+
mode: "open",
|
|
427
|
+
plane: "platform",
|
|
428
|
+
group: "hardware",
|
|
429
|
+
u: null,
|
|
430
|
+
supersedes: null,
|
|
431
|
+
description: "Reported logical CPU core count.",
|
|
432
|
+
review: compliantReview()
|
|
433
|
+
},
|
|
434
|
+
{
|
|
435
|
+
id: "platform.deviceMemory",
|
|
436
|
+
addedVersion: "v1",
|
|
437
|
+
removedVersion: null,
|
|
438
|
+
tier: "high",
|
|
439
|
+
measurement: provisional(
|
|
440
|
+
"navigator.deviceMemory is a coarse, bucketed value tied to physical RAM; effectively constant for a given device."
|
|
441
|
+
),
|
|
442
|
+
denoise: { kind: "none" },
|
|
443
|
+
mode: "open",
|
|
444
|
+
plane: "platform",
|
|
445
|
+
group: "hardware",
|
|
446
|
+
u: null,
|
|
447
|
+
supersedes: null,
|
|
448
|
+
description: "Reported device memory in GB, bucketed by the browser.",
|
|
449
|
+
review: compliantReview()
|
|
450
|
+
},
|
|
451
|
+
{
|
|
452
|
+
id: "platform.screenResolution",
|
|
453
|
+
addedVersion: "v1",
|
|
454
|
+
removedVersion: null,
|
|
455
|
+
tier: "medium",
|
|
456
|
+
measurement: provisional(
|
|
457
|
+
"Screen resolution is stable per device but changes on external-monitor connect/disconnect or OS display scaling changes."
|
|
458
|
+
),
|
|
459
|
+
denoise: { kind: "none" },
|
|
460
|
+
mode: "open",
|
|
461
|
+
plane: "platform",
|
|
462
|
+
group: "display",
|
|
463
|
+
u: null,
|
|
464
|
+
supersedes: null,
|
|
465
|
+
description: "screen.width/height and color depth.",
|
|
466
|
+
review: compliantReview()
|
|
467
|
+
},
|
|
468
|
+
{
|
|
469
|
+
id: "platform.timezone",
|
|
470
|
+
addedVersion: "v1",
|
|
471
|
+
removedVersion: null,
|
|
472
|
+
tier: "medium",
|
|
473
|
+
measurement: provisional(
|
|
474
|
+
"IANA timezone name. Stable per device/user but changes on travel or explicit user change \u2014 a trivial, legitimate user action, so capped at medium rather than high."
|
|
475
|
+
),
|
|
476
|
+
denoise: { kind: "none" },
|
|
477
|
+
mode: "open",
|
|
478
|
+
plane: "platform",
|
|
479
|
+
group: "locale",
|
|
480
|
+
u: null,
|
|
481
|
+
supersedes: null,
|
|
482
|
+
description: "Intl-resolved IANA timezone.",
|
|
483
|
+
review: compliantReview()
|
|
484
|
+
},
|
|
485
|
+
{
|
|
486
|
+
id: "platform.languages",
|
|
487
|
+
addedVersion: "v1",
|
|
488
|
+
removedVersion: null,
|
|
489
|
+
tier: "medium",
|
|
490
|
+
measurement: provisional(
|
|
491
|
+
"navigator.languages ordering/content is stable per device but is user-configurable, a trivial action."
|
|
492
|
+
),
|
|
493
|
+
denoise: { kind: "none" },
|
|
494
|
+
mode: "open",
|
|
495
|
+
plane: "platform",
|
|
496
|
+
group: "locale",
|
|
497
|
+
u: null,
|
|
498
|
+
supersedes: null,
|
|
499
|
+
description: "Ordered list of accepted languages.",
|
|
500
|
+
review: compliantReview()
|
|
501
|
+
},
|
|
502
|
+
{
|
|
503
|
+
id: "platform.permissions",
|
|
504
|
+
addedVersion: "v1",
|
|
505
|
+
removedVersion: null,
|
|
506
|
+
tier: "low",
|
|
507
|
+
measurement: provisional(
|
|
508
|
+
"Permission grant states (geolocation, notifications, camera, microphone) change whenever the user grants/revokes a permission \u2014 moves within a session on a trivial user action. Collected for contradiction detection, weighted near zero for identity."
|
|
509
|
+
),
|
|
510
|
+
denoise: { kind: "modal", runs: 3 },
|
|
511
|
+
mode: "consent",
|
|
512
|
+
plane: "platform",
|
|
513
|
+
group: "permissions",
|
|
514
|
+
u: null,
|
|
515
|
+
supersedes: null,
|
|
516
|
+
description: "Modal permission state per permission name (Permissions API).",
|
|
517
|
+
review: compliantReview()
|
|
518
|
+
},
|
|
519
|
+
// --- vendored FingerprintJS sources (prompt 9) ---------------------------
|
|
520
|
+
// See packages/checkpoint-beacon/src/vendor/fingerprintjs/VENDORING.md for
|
|
521
|
+
// the pinned commit and the full included/excluded source reasoning.
|
|
522
|
+
{
|
|
523
|
+
id: "platform.userAgentData",
|
|
524
|
+
addedVersion: "v1",
|
|
525
|
+
removedVersion: null,
|
|
526
|
+
tier: "high",
|
|
527
|
+
measurement: provisional(
|
|
528
|
+
"User-Agent Client Hints high-entropy values (architecture, bitness, model, platformVersion), Chromium-only. Device model in particular is highly identifying: the same sensitivity Chromium itself recognises by gating getHighEntropyValues() behind a Permissions-Policy check. Effectively device-constant when available."
|
|
529
|
+
),
|
|
530
|
+
denoise: { kind: "none" },
|
|
531
|
+
mode: "consent",
|
|
532
|
+
plane: "platform",
|
|
533
|
+
group: "identity",
|
|
534
|
+
u: null,
|
|
535
|
+
supersedes: null,
|
|
536
|
+
description: "UA-CH brands/mobile/platform plus high-entropy architecture/bitness/model/platformVersion.",
|
|
537
|
+
review: compliantReview()
|
|
538
|
+
},
|
|
539
|
+
{
|
|
540
|
+
id: "rendering.fontPreferences",
|
|
541
|
+
addedVersion: "v1",
|
|
542
|
+
removedVersion: null,
|
|
543
|
+
tier: "medium",
|
|
544
|
+
measurement: provisional(
|
|
545
|
+
"Measured widths of a fixed set of font-preset text samples inside an iframe. Stable per OS/browser install; the upstream source itself documents floating-point measurement noise across zoom levels on some browsers, hence medium rather than high pending real measurement."
|
|
546
|
+
),
|
|
547
|
+
denoise: { kind: "none" },
|
|
548
|
+
mode: "consent",
|
|
549
|
+
plane: "rendering",
|
|
550
|
+
group: "fonts",
|
|
551
|
+
u: null,
|
|
552
|
+
supersedes: null,
|
|
553
|
+
description: "Dictionary of measured text-sample widths under a fixed set of font/style presets.",
|
|
554
|
+
review: compliantReview()
|
|
555
|
+
},
|
|
556
|
+
{
|
|
557
|
+
id: "platform.osCpu",
|
|
558
|
+
addedVersion: "v1",
|
|
559
|
+
removedVersion: null,
|
|
560
|
+
tier: "low",
|
|
561
|
+
measurement: provisional(
|
|
562
|
+
"navigator.oscpu, Firefox-only and largely redundant with the platform/UA family. Shared by every user of a given Firefox+OS combination, so low uniqueness on its own: contradiction-detection value only."
|
|
563
|
+
),
|
|
564
|
+
denoise: { kind: "none" },
|
|
565
|
+
mode: "open",
|
|
566
|
+
plane: "platform",
|
|
567
|
+
group: "identity",
|
|
568
|
+
u: null,
|
|
569
|
+
supersedes: null,
|
|
570
|
+
description: "navigator.oscpu, when present.",
|
|
571
|
+
review: compliantReview()
|
|
572
|
+
},
|
|
573
|
+
{
|
|
574
|
+
id: "platform.colorDepth",
|
|
575
|
+
addedVersion: "v1",
|
|
576
|
+
removedVersion: null,
|
|
577
|
+
tier: "low",
|
|
578
|
+
measurement: provisional(
|
|
579
|
+
"window.screen.colorDepth is effectively constant (24, occasionally 30) across nearly all modern displays. Very low entropy by itself."
|
|
580
|
+
),
|
|
581
|
+
denoise: { kind: "none" },
|
|
582
|
+
mode: "open",
|
|
583
|
+
plane: "platform",
|
|
584
|
+
group: "display",
|
|
585
|
+
u: null,
|
|
586
|
+
supersedes: null,
|
|
587
|
+
description: "Reported screen color depth in bits.",
|
|
588
|
+
review: compliantReview()
|
|
589
|
+
},
|
|
590
|
+
{
|
|
591
|
+
id: "platform.sessionStorage",
|
|
592
|
+
addedVersion: "v1",
|
|
593
|
+
removedVersion: null,
|
|
594
|
+
tier: "low",
|
|
595
|
+
measurement: provisional(
|
|
596
|
+
"Boolean availability of window.sessionStorage. Near-universally true; moves only under specific privacy configurations. Contradiction-detection value only."
|
|
597
|
+
),
|
|
598
|
+
denoise: { kind: "none" },
|
|
599
|
+
mode: "open",
|
|
600
|
+
plane: "platform",
|
|
601
|
+
group: "storage",
|
|
602
|
+
u: null,
|
|
603
|
+
supersedes: null,
|
|
604
|
+
description: "Whether window.sessionStorage is available.",
|
|
605
|
+
review: compliantReview()
|
|
606
|
+
},
|
|
607
|
+
{
|
|
608
|
+
id: "platform.localStorage",
|
|
609
|
+
addedVersion: "v1",
|
|
610
|
+
removedVersion: null,
|
|
611
|
+
tier: "low",
|
|
612
|
+
measurement: provisional(
|
|
613
|
+
"Boolean availability of window.localStorage. Near-universally true; moves only under specific privacy configurations. Contradiction-detection value only."
|
|
614
|
+
),
|
|
615
|
+
denoise: { kind: "none" },
|
|
616
|
+
mode: "open",
|
|
617
|
+
plane: "platform",
|
|
618
|
+
group: "storage",
|
|
619
|
+
u: null,
|
|
620
|
+
supersedes: null,
|
|
621
|
+
description: "Whether window.localStorage is available.",
|
|
622
|
+
review: compliantReview()
|
|
623
|
+
},
|
|
624
|
+
{
|
|
625
|
+
id: "platform.indexedDB",
|
|
626
|
+
addedVersion: "v1",
|
|
627
|
+
removedVersion: null,
|
|
628
|
+
tier: "low",
|
|
629
|
+
measurement: provisional(
|
|
630
|
+
"Boolean availability of window.indexedDB (undefined on IE/Edge in private mode by design, per upstream source comment). Near-universally true elsewhere. Contradiction-detection value only."
|
|
631
|
+
),
|
|
632
|
+
denoise: { kind: "none" },
|
|
633
|
+
mode: "open",
|
|
634
|
+
plane: "platform",
|
|
635
|
+
group: "storage",
|
|
636
|
+
u: null,
|
|
637
|
+
supersedes: null,
|
|
638
|
+
description: "Whether window.indexedDB is available.",
|
|
639
|
+
review: compliantReview()
|
|
640
|
+
},
|
|
641
|
+
{
|
|
642
|
+
id: "platform.navigatorPlatform",
|
|
643
|
+
addedVersion: "v1",
|
|
644
|
+
removedVersion: null,
|
|
645
|
+
tier: "low",
|
|
646
|
+
measurement: provisional(
|
|
647
|
+
"navigator.platform (with the iPad/iPhone WebKit correction upstream applies). Shared by every user of a given OS+browser-mode combination, so low uniqueness alone."
|
|
648
|
+
),
|
|
649
|
+
denoise: { kind: "none" },
|
|
650
|
+
mode: "open",
|
|
651
|
+
plane: "platform",
|
|
652
|
+
group: "identity",
|
|
653
|
+
u: null,
|
|
654
|
+
supersedes: null,
|
|
655
|
+
description: "Reported navigator.platform, WebKit iPad/iPhone-corrected.",
|
|
656
|
+
review: compliantReview()
|
|
657
|
+
},
|
|
658
|
+
{
|
|
659
|
+
id: "platform.touchSupport",
|
|
660
|
+
addedVersion: "v1",
|
|
661
|
+
removedVersion: null,
|
|
662
|
+
tier: "medium",
|
|
663
|
+
measurement: provisional(
|
|
664
|
+
"maxTouchPoints + TouchEvent/ontouchstart feature detection. Stable per device and useful for separating phone/tablet from desktop form factors, but shared by every device of the same model."
|
|
665
|
+
),
|
|
666
|
+
denoise: { kind: "none" },
|
|
667
|
+
mode: "open",
|
|
668
|
+
plane: "platform",
|
|
669
|
+
group: "hardware",
|
|
670
|
+
u: null,
|
|
671
|
+
supersedes: null,
|
|
672
|
+
description: "maxTouchPoints plus TouchEvent/ontouchstart availability.",
|
|
673
|
+
review: compliantReview()
|
|
674
|
+
},
|
|
675
|
+
{
|
|
676
|
+
id: "platform.vendor",
|
|
677
|
+
addedVersion: "v1",
|
|
678
|
+
removedVersion: null,
|
|
679
|
+
tier: "low",
|
|
680
|
+
measurement: provisional(
|
|
681
|
+
'navigator.vendor. A handful of possible values shared by huge populations (e.g. every Chromium user reads "Google Inc."). Contradiction-detection value only.'
|
|
682
|
+
),
|
|
683
|
+
denoise: { kind: "none" },
|
|
684
|
+
mode: "open",
|
|
685
|
+
plane: "platform",
|
|
686
|
+
group: "identity",
|
|
687
|
+
u: null,
|
|
688
|
+
supersedes: null,
|
|
689
|
+
description: "Reported navigator.vendor.",
|
|
690
|
+
review: compliantReview()
|
|
691
|
+
},
|
|
692
|
+
{
|
|
693
|
+
id: "platform.vendorFlavors",
|
|
694
|
+
addedVersion: "v1",
|
|
695
|
+
removedVersion: null,
|
|
696
|
+
tier: "low",
|
|
697
|
+
measurement: provisional(
|
|
698
|
+
"Presence of browser-specific (not engine-specific) global variables (e.g. window.chrome, window.__firefox__). Distinguishes browser flavor within an engine family; still shared by every install of that browser."
|
|
699
|
+
),
|
|
700
|
+
denoise: { kind: "none" },
|
|
701
|
+
mode: "open",
|
|
702
|
+
plane: "platform",
|
|
703
|
+
group: "identity",
|
|
704
|
+
u: null,
|
|
705
|
+
supersedes: null,
|
|
706
|
+
description: "Sorted list of detected browser-specific global variable names.",
|
|
707
|
+
review: compliantReview()
|
|
708
|
+
},
|
|
709
|
+
{
|
|
710
|
+
id: "platform.cookiesEnabled",
|
|
711
|
+
addedVersion: "v1",
|
|
712
|
+
removedVersion: null,
|
|
713
|
+
tier: "low",
|
|
714
|
+
measurement: provisional(
|
|
715
|
+
"Live cookie-write/read probe. Near-universally true; moves whenever the user or a privacy extension blocks cookies, a trivial, legitimate action. Contradiction-detection value only."
|
|
716
|
+
),
|
|
717
|
+
denoise: { kind: "none" },
|
|
718
|
+
mode: "open",
|
|
719
|
+
plane: "platform",
|
|
720
|
+
group: "storage",
|
|
721
|
+
u: null,
|
|
722
|
+
supersedes: null,
|
|
723
|
+
description: "Whether a test cookie can be written and read back.",
|
|
724
|
+
review: compliantReview()
|
|
725
|
+
},
|
|
726
|
+
{
|
|
727
|
+
id: "platform.colorGamut",
|
|
728
|
+
addedVersion: "v1",
|
|
729
|
+
removedVersion: null,
|
|
730
|
+
tier: "medium",
|
|
731
|
+
measurement: provisional(
|
|
732
|
+
"CSS color-gamut media-feature probe (srgb/p3/rec2020). Reflects the physical display panel, stable until an external-monitor change."
|
|
733
|
+
),
|
|
734
|
+
denoise: { kind: "none" },
|
|
735
|
+
mode: "open",
|
|
736
|
+
plane: "platform",
|
|
737
|
+
group: "display",
|
|
738
|
+
u: null,
|
|
739
|
+
supersedes: null,
|
|
740
|
+
description: "Widest supported color gamut per the CSS color-gamut media feature.",
|
|
741
|
+
review: compliantReview()
|
|
742
|
+
},
|
|
743
|
+
{
|
|
744
|
+
id: "platform.invertedColors",
|
|
745
|
+
addedVersion: "v1",
|
|
746
|
+
removedVersion: null,
|
|
747
|
+
tier: "low",
|
|
748
|
+
measurement: provisional(
|
|
749
|
+
"CSS inverted-colors media-feature probe: an OS-level accessibility preference, not a display capability. Consent-gated like platform.permissions, since it can correlate with a vision-related accessibility need, so it is collected for contradiction detection only and weighted near zero for identity."
|
|
750
|
+
),
|
|
751
|
+
denoise: { kind: "none" },
|
|
752
|
+
mode: "consent",
|
|
753
|
+
plane: "platform",
|
|
754
|
+
group: "display",
|
|
755
|
+
u: null,
|
|
756
|
+
supersedes: null,
|
|
757
|
+
description: 'Whether the OS-level "invert colors" accessibility preference is active.',
|
|
758
|
+
review: compliantReview()
|
|
759
|
+
},
|
|
760
|
+
{
|
|
761
|
+
id: "platform.forcedColors",
|
|
762
|
+
addedVersion: "v1",
|
|
763
|
+
removedVersion: null,
|
|
764
|
+
tier: "low",
|
|
765
|
+
measurement: provisional(
|
|
766
|
+
"CSS forced-colors media-feature probe: an OS-level accessibility preference (Windows High Contrast and similar). Consent-gated for the same reason as platform.invertedColors."
|
|
767
|
+
),
|
|
768
|
+
denoise: { kind: "none" },
|
|
769
|
+
mode: "consent",
|
|
770
|
+
plane: "platform",
|
|
771
|
+
group: "display",
|
|
772
|
+
u: null,
|
|
773
|
+
supersedes: null,
|
|
774
|
+
description: "Whether an OS-level forced-colors accessibility mode is active.",
|
|
775
|
+
review: compliantReview()
|
|
776
|
+
},
|
|
777
|
+
{
|
|
778
|
+
id: "platform.monochrome",
|
|
779
|
+
addedVersion: "v1",
|
|
780
|
+
removedVersion: null,
|
|
781
|
+
tier: "low",
|
|
782
|
+
measurement: provisional(
|
|
783
|
+
"CSS monochrome media-feature probe (bits per pixel on a non-color/e-ink-style display, or 0). Reflects display hardware, not a user preference, unlike the accessibility-preference probes above."
|
|
784
|
+
),
|
|
785
|
+
denoise: { kind: "none" },
|
|
786
|
+
mode: "open",
|
|
787
|
+
plane: "platform",
|
|
788
|
+
group: "display",
|
|
789
|
+
u: null,
|
|
790
|
+
supersedes: null,
|
|
791
|
+
description: "Monochrome display bit depth per the CSS monochrome media feature, or undefined if unsupported.",
|
|
792
|
+
review: compliantReview()
|
|
793
|
+
},
|
|
794
|
+
{
|
|
795
|
+
id: "platform.contrast",
|
|
796
|
+
addedVersion: "v1",
|
|
797
|
+
removedVersion: null,
|
|
798
|
+
tier: "low",
|
|
799
|
+
measurement: provisional(
|
|
800
|
+
"CSS prefers-contrast media-feature probe: an OS-level accessibility preference. Consent-gated for the same reason as platform.invertedColors/platform.forcedColors."
|
|
801
|
+
),
|
|
802
|
+
denoise: { kind: "none" },
|
|
803
|
+
mode: "consent",
|
|
804
|
+
plane: "platform",
|
|
805
|
+
group: "display",
|
|
806
|
+
u: null,
|
|
807
|
+
supersedes: null,
|
|
808
|
+
description: "OS-level contrast preference per the CSS prefers-contrast media feature.",
|
|
809
|
+
review: compliantReview()
|
|
810
|
+
},
|
|
811
|
+
{
|
|
812
|
+
id: "platform.reducedMotion",
|
|
813
|
+
addedVersion: "v1",
|
|
814
|
+
removedVersion: null,
|
|
815
|
+
tier: "low",
|
|
816
|
+
measurement: provisional(
|
|
817
|
+
"CSS prefers-reduced-motion media-feature probe: an OS-level accessibility preference that can correlate with a vestibular-disorder accommodation. Consent-gated, contradiction-detection only."
|
|
818
|
+
),
|
|
819
|
+
denoise: { kind: "none" },
|
|
820
|
+
mode: "consent",
|
|
821
|
+
plane: "platform",
|
|
822
|
+
group: "display",
|
|
823
|
+
u: null,
|
|
824
|
+
supersedes: null,
|
|
825
|
+
description: 'Whether the OS-level "reduce motion" accessibility preference is active.',
|
|
826
|
+
review: compliantReview()
|
|
827
|
+
},
|
|
828
|
+
{
|
|
829
|
+
id: "platform.reducedTransparency",
|
|
830
|
+
addedVersion: "v1",
|
|
831
|
+
removedVersion: null,
|
|
832
|
+
tier: "low",
|
|
833
|
+
measurement: provisional(
|
|
834
|
+
"CSS prefers-reduced-transparency media-feature probe: an OS-level accessibility preference. Consent-gated for the same reason as platform.reducedMotion."
|
|
835
|
+
),
|
|
836
|
+
denoise: { kind: "none" },
|
|
837
|
+
mode: "consent",
|
|
838
|
+
plane: "platform",
|
|
839
|
+
group: "display",
|
|
840
|
+
u: null,
|
|
841
|
+
supersedes: null,
|
|
842
|
+
description: 'Whether the OS-level "reduce transparency" accessibility preference is active.',
|
|
843
|
+
review: compliantReview()
|
|
844
|
+
},
|
|
845
|
+
{
|
|
846
|
+
id: "platform.hdr",
|
|
847
|
+
addedVersion: "v1",
|
|
848
|
+
removedVersion: null,
|
|
849
|
+
tier: "medium",
|
|
850
|
+
measurement: provisional(
|
|
851
|
+
"CSS dynamic-range media-feature probe (high vs standard). Reflects display hardware capability, stable until an external-monitor change."
|
|
852
|
+
),
|
|
853
|
+
denoise: { kind: "none" },
|
|
854
|
+
mode: "open",
|
|
855
|
+
plane: "platform",
|
|
856
|
+
group: "display",
|
|
857
|
+
u: null,
|
|
858
|
+
supersedes: null,
|
|
859
|
+
description: "Whether the display supports high dynamic range per the CSS dynamic-range media feature.",
|
|
860
|
+
review: compliantReview()
|
|
861
|
+
},
|
|
862
|
+
{
|
|
863
|
+
id: "platform.pdfViewerEnabled",
|
|
864
|
+
addedVersion: "v1",
|
|
865
|
+
removedVersion: null,
|
|
866
|
+
tier: "low",
|
|
867
|
+
measurement: provisional(
|
|
868
|
+
"navigator.pdfViewerEnabled, Chromium-only. Near-constant true across recent Chromium installs. Contradiction-detection value only."
|
|
869
|
+
),
|
|
870
|
+
denoise: { kind: "none" },
|
|
871
|
+
mode: "open",
|
|
872
|
+
plane: "platform",
|
|
873
|
+
group: "capabilities",
|
|
874
|
+
u: null,
|
|
875
|
+
supersedes: null,
|
|
876
|
+
description: "Reported navigator.pdfViewerEnabled.",
|
|
877
|
+
review: compliantReview()
|
|
878
|
+
},
|
|
879
|
+
{
|
|
880
|
+
id: "platform.architecture",
|
|
881
|
+
addedVersion: "v1",
|
|
882
|
+
removedVersion: null,
|
|
883
|
+
tier: "high",
|
|
884
|
+
measurement: provisional(
|
|
885
|
+
"Distinguishes x86/x86-64 from other CPU architectures via IEEE 754 NaN sign-bit behaviour on infinity subtraction. Depends on CPU architecture only, effectively device-constant like hardwareConcurrency/deviceMemory."
|
|
886
|
+
),
|
|
887
|
+
denoise: { kind: "none" },
|
|
888
|
+
mode: "open",
|
|
889
|
+
plane: "platform",
|
|
890
|
+
group: "hardware",
|
|
891
|
+
u: null,
|
|
892
|
+
supersedes: null,
|
|
893
|
+
description: "Single byte distinguishing CPU architecture via a floating-point NaN sign-bit probe.",
|
|
894
|
+
review: compliantReview()
|
|
895
|
+
},
|
|
896
|
+
{
|
|
897
|
+
id: "platform.applePay",
|
|
898
|
+
addedVersion: "v1",
|
|
899
|
+
removedVersion: null,
|
|
900
|
+
tier: "low",
|
|
901
|
+
measurement: provisional(
|
|
902
|
+
"ApplePaySession.canMakePayments() state, Safari-only. Depends on device wallet configuration, which can change independently of the fingerprint; mostly useful for Safari-family detection."
|
|
903
|
+
),
|
|
904
|
+
denoise: { kind: "none" },
|
|
905
|
+
mode: "open",
|
|
906
|
+
plane: "platform",
|
|
907
|
+
group: "capabilities",
|
|
908
|
+
u: null,
|
|
909
|
+
supersedes: null,
|
|
910
|
+
description: "Apple Pay availability/enabled state (Safari only).",
|
|
911
|
+
review: compliantReview()
|
|
912
|
+
},
|
|
913
|
+
{
|
|
914
|
+
id: "platform.privateClickMeasurement",
|
|
915
|
+
addedVersion: "v1",
|
|
916
|
+
removedVersion: null,
|
|
917
|
+
tier: "low",
|
|
918
|
+
measurement: provisional(
|
|
919
|
+
"Presence of Safari's Privacy-Preserving Ad Measurement attribution-source attribute. Safari-only, mostly stable across recent versions."
|
|
920
|
+
),
|
|
921
|
+
denoise: { kind: "none" },
|
|
922
|
+
mode: "open",
|
|
923
|
+
plane: "platform",
|
|
924
|
+
group: "capabilities",
|
|
925
|
+
u: null,
|
|
926
|
+
supersedes: null,
|
|
927
|
+
description: "Whether Safari's private click measurement attribution attribute is present.",
|
|
928
|
+
review: compliantReview()
|
|
929
|
+
},
|
|
930
|
+
{
|
|
931
|
+
id: "rendering.audioBaseLatency",
|
|
932
|
+
addedVersion: "v1",
|
|
933
|
+
removedVersion: null,
|
|
934
|
+
tier: "medium",
|
|
935
|
+
measurement: provisional(
|
|
936
|
+
"AudioContext.baseLatency, a scalar tied to the audio hardware/OS audio stack. Distinct collection mechanism from audio.digest (no oscillator rendering, no shared context), so this does not duplicate that signal."
|
|
937
|
+
),
|
|
938
|
+
denoise: { kind: "none" },
|
|
939
|
+
mode: "open",
|
|
940
|
+
plane: "rendering",
|
|
941
|
+
group: "audio",
|
|
942
|
+
u: null,
|
|
943
|
+
supersedes: null,
|
|
944
|
+
description: "Reported AudioContext.baseLatency, or a negative status code when unsupported/disabled.",
|
|
945
|
+
review: compliantReview()
|
|
946
|
+
},
|
|
947
|
+
{
|
|
948
|
+
id: "platform.dateTimeLocale",
|
|
949
|
+
addedVersion: "v1",
|
|
950
|
+
removedVersion: null,
|
|
951
|
+
tier: "medium",
|
|
952
|
+
measurement: provisional(
|
|
953
|
+
"Intl.DateTimeFormat().resolvedOptions().locale. Stable per device/user but trivially user-configurable, same rationale as platform.timezone/platform.languages."
|
|
954
|
+
),
|
|
955
|
+
denoise: { kind: "none" },
|
|
956
|
+
mode: "open",
|
|
957
|
+
plane: "platform",
|
|
958
|
+
group: "locale",
|
|
959
|
+
u: null,
|
|
960
|
+
supersedes: null,
|
|
961
|
+
description: "Intl-resolved locale string, or a negative status code when unsupported.",
|
|
962
|
+
review: compliantReview()
|
|
963
|
+
},
|
|
964
|
+
// --- ThumbmarkJS-ported sources, prompt 11 ---------------------------
|
|
965
|
+
// Three sources FingerprintJS's 42-source list has no equivalent for at
|
|
966
|
+
// all (see packages/checkpoint-beacon/src/collectors/entropy/webrtc.ts,
|
|
967
|
+
// speech.ts, media-queries.ts for the collectors and the privacy
|
|
968
|
+
// reasoning behind the WebRTC collector in particular).
|
|
969
|
+
{
|
|
970
|
+
id: "transport.webrtcCodecs",
|
|
971
|
+
addedVersion: "v1",
|
|
972
|
+
removedVersion: null,
|
|
973
|
+
tier: "medium",
|
|
974
|
+
measurement: provisional(
|
|
975
|
+
"RTP header extensions and per-codec (rtpmap/fmtp/rtcp-fb) descriptors parsed from a locally-generated SDP offer. Determined by the WebRTC engine build and codec licensing bundled with a given browser version; stable within a browser version, moves on browser updates that add/remove codec or extension support (e.g. AV1/VP9 profile rollout). Collection never gathers a real ICE candidate: setLocalDescription is never called AND iceCandidatePoolSize is 0, so neither of the two ways gathering can start ever fires (see webrtc.ts)."
|
|
976
|
+
),
|
|
977
|
+
denoise: { kind: "none" },
|
|
978
|
+
mode: "consent",
|
|
979
|
+
plane: "transport",
|
|
980
|
+
group: "webrtc",
|
|
981
|
+
u: null,
|
|
982
|
+
supersedes: null,
|
|
983
|
+
description: "Counts and digests of RTP extensions (extmap) and per-codec descriptors (rtpmap/fmtp/rtcp-fb) for audio and video, parsed from a locally-generated SDP offer.",
|
|
984
|
+
review: compliantReview()
|
|
985
|
+
},
|
|
986
|
+
{
|
|
987
|
+
id: "platform.speechVoices",
|
|
988
|
+
addedVersion: "v1",
|
|
989
|
+
removedVersion: null,
|
|
990
|
+
tier: "medium",
|
|
991
|
+
measurement: provisional(
|
|
992
|
+
"speechSynthesis.getVoices() reduced to voiceURI/name/lang/localService/default per voice, sorted, then hashed. Tied to the OS/browser installed voice set: stable per device, moves when the OS installs a language pack or a browser update changes its bundled voice list. No modal() de-noising applies (voice enumeration is not farbled/randomized per call the way canvas/WebGL/audio reads are) \u2014 the observed timing nondeterminism is handled by the collector's voiceschanged/timeout race, not by resampling."
|
|
993
|
+
),
|
|
994
|
+
denoise: { kind: "none" },
|
|
995
|
+
mode: "consent",
|
|
996
|
+
plane: "platform",
|
|
997
|
+
group: "capabilities",
|
|
998
|
+
u: null,
|
|
999
|
+
supersedes: null,
|
|
1000
|
+
description: "Voice count and a digest of the sorted, normalized speechSynthesis voice list.",
|
|
1001
|
+
review: compliantReview()
|
|
1002
|
+
},
|
|
1003
|
+
{
|
|
1004
|
+
id: "platform.mediaQuerySweep",
|
|
1005
|
+
addedVersion: "v1",
|
|
1006
|
+
removedVersion: "v2",
|
|
1007
|
+
tier: "medium",
|
|
1008
|
+
measurement: provisional(
|
|
1009
|
+
"Systematic sweep of every legal value across 11 CSS media-query families (prefers-contrast, any-hover, any-pointer, pointer, hover, update, inverted-colors, prefers-reduced-motion, prefers-reduced-transparency, scripting, forced-colors). Mostly OS/input-hardware driven and stable per device, but a few families (hover/pointer/any-hover/any-pointer) can move on a trivial user action such as docking a touch device to a mouse, capping this at medium rather than high pending real measurement. Deliberately overlaps 5 already-registered vendored-FingerprintJS signals (platform.contrast, platform.invertedColors, platform.reducedMotion, platform.reducedTransparency, platform.forcedColors) as a cross-validation check, not a duplication bug \u2014 see media-queries.ts."
|
|
1010
|
+
),
|
|
1011
|
+
denoise: { kind: "none" },
|
|
1012
|
+
mode: "consent",
|
|
1013
|
+
plane: "platform",
|
|
1014
|
+
group: "display",
|
|
1015
|
+
u: null,
|
|
1016
|
+
supersedes: null,
|
|
1017
|
+
description: `Per-family matched value across 11 media-query families (family absent from the result when unsupported, never a false/placeholder value), plus a family count and a digest. Forked to platform.mediaQuerySweep.v2, which narrows this to 6 families: combining the 5 accessibility-preference families into this one derived feature trips the accessibility-preference-composite Sensitive Data Inference composition rule (see sensitive-attributes.ts) \u2014 a disability/health-accommodation inference risk, per P44. Collector-only; never wired into scoring, transport, or the identity graph at any point in this signal's v1 lifetime, so no stored device data exists to preserve compatibility with (Cursor Bugbot, PR #4639) \u2014 forked anyway, per this file's "never edited, only forked" discipline.`,
|
|
1018
|
+
review: compliantReview()
|
|
1019
|
+
},
|
|
1020
|
+
{
|
|
1021
|
+
id: "platform.mediaQuerySweep.v2",
|
|
1022
|
+
addedVersion: "v2",
|
|
1023
|
+
removedVersion: null,
|
|
1024
|
+
tier: "medium",
|
|
1025
|
+
measurement: provisional(
|
|
1026
|
+
"Systematic sweep of every legal value across 6 CSS media-query families (any-hover, any-pointer, pointer, hover, update, scripting) \u2014 none of which any existing collector reads. Mostly OS/input-hardware driven and stable per device, but a few families (hover/pointer/any-hover/any-pointer) can move on a trivial user action such as docking a touch device to a mouse, capping this at medium rather than high pending real measurement. Forked from platform.mediaQuerySweep (v1) to EXCLUDE the 5 media-query families already registered as their own accessibility-preference signals (platform.contrast, platform.invertedColors, platform.reducedMotion, platform.reducedTransparency, platform.forcedColors): combining 2+ of those into one derived feature trips the accessibility-preference-composite Sensitive Data Inference composition rule (see sensitive-attributes.ts) \u2014 a disability/health-accommodation inference risk, per P44. See media-queries.ts's module doc."
|
|
1027
|
+
),
|
|
1028
|
+
denoise: { kind: "none" },
|
|
1029
|
+
mode: "consent",
|
|
1030
|
+
plane: "platform",
|
|
1031
|
+
group: "display",
|
|
1032
|
+
u: null,
|
|
1033
|
+
supersedes: "platform.mediaQuerySweep",
|
|
1034
|
+
description: "Per-family matched value across 6 media-query families with no existing collector (family absent from the result when unsupported, never a false/placeholder value), plus a family count and a digest. Excludes the 5 families already covered by their own registered accessibility-preference signals \u2014 see measurement notes.",
|
|
1035
|
+
review: compliantReview()
|
|
1036
|
+
},
|
|
1037
|
+
// --- User-Agent Client Hints, contradiction-only (prompt 12) ------------
|
|
1038
|
+
// Distinct from platform.userAgentData (prompt 9): that signal is the
|
|
1039
|
+
// bundled entropy read FingerprintJS itself needs (mode: consent, one
|
|
1040
|
+
// signal). These nine are collected purely to catch a spoofed
|
|
1041
|
+
// User-Agent string disagreeing with the browser's real Client Hints —
|
|
1042
|
+
// mode: 'never', so none of them ever contribute to identity linkage.
|
|
1043
|
+
// See packages/checkpoint-beacon/src/collectors/entropy/client-hints.ts.
|
|
1044
|
+
{
|
|
1045
|
+
id: "platform.clientHints.architecture",
|
|
1046
|
+
addedVersion: "v1",
|
|
1047
|
+
removedVersion: null,
|
|
1048
|
+
tier: "low",
|
|
1049
|
+
measurement: provisional(
|
|
1050
|
+
"UA-CH high-entropy `architecture` hint (e.g. 'arm', 'x86'). Requested independently of platform.userAgentData's copy of the same hint, specifically so it can feed User-Agent/Client-Hints contradiction detection rather than identity linkage."
|
|
1051
|
+
),
|
|
1052
|
+
denoise: { kind: "none" },
|
|
1053
|
+
mode: "never",
|
|
1054
|
+
plane: "platform",
|
|
1055
|
+
group: "clientHints",
|
|
1056
|
+
u: null,
|
|
1057
|
+
supersedes: null,
|
|
1058
|
+
description: "UA-CH high-entropy CPU architecture hint.",
|
|
1059
|
+
review: compliantReview()
|
|
1060
|
+
},
|
|
1061
|
+
{
|
|
1062
|
+
id: "platform.clientHints.bitness",
|
|
1063
|
+
addedVersion: "v1",
|
|
1064
|
+
removedVersion: null,
|
|
1065
|
+
tier: "low",
|
|
1066
|
+
measurement: provisional(
|
|
1067
|
+
"UA-CH high-entropy `bitness` hint (e.g. '64'). Collected for contradiction detection only; see platform.clientHints.architecture."
|
|
1068
|
+
),
|
|
1069
|
+
denoise: { kind: "none" },
|
|
1070
|
+
mode: "never",
|
|
1071
|
+
plane: "platform",
|
|
1072
|
+
group: "clientHints",
|
|
1073
|
+
u: null,
|
|
1074
|
+
supersedes: null,
|
|
1075
|
+
description: "UA-CH high-entropy CPU bitness hint.",
|
|
1076
|
+
review: compliantReview()
|
|
1077
|
+
},
|
|
1078
|
+
{
|
|
1079
|
+
id: "platform.clientHints.model",
|
|
1080
|
+
addedVersion: "v1",
|
|
1081
|
+
removedVersion: null,
|
|
1082
|
+
tier: "low",
|
|
1083
|
+
measurement: provisional(
|
|
1084
|
+
"UA-CH high-entropy `model` hint. Empty string on desktop; device model on mobile. Collected for contradiction detection only; see platform.clientHints.architecture."
|
|
1085
|
+
),
|
|
1086
|
+
denoise: { kind: "none" },
|
|
1087
|
+
mode: "never",
|
|
1088
|
+
plane: "platform",
|
|
1089
|
+
group: "clientHints",
|
|
1090
|
+
u: null,
|
|
1091
|
+
supersedes: null,
|
|
1092
|
+
description: "UA-CH high-entropy device model hint.",
|
|
1093
|
+
review: compliantReview()
|
|
1094
|
+
},
|
|
1095
|
+
{
|
|
1096
|
+
id: "platform.clientHints.platform",
|
|
1097
|
+
addedVersion: "v1",
|
|
1098
|
+
removedVersion: null,
|
|
1099
|
+
tier: "low",
|
|
1100
|
+
measurement: provisional(
|
|
1101
|
+
"UA-CH low-entropy `platform` (e.g. 'Windows', 'macOS', 'Linux', 'Android', 'Chrome OS'), read synchronously off navigator.userAgentData rather than requested through getHighEntropyValues(). The half of this collector's output the platform contradiction check actually compares against the User-Agent string's platform."
|
|
1102
|
+
),
|
|
1103
|
+
denoise: { kind: "none" },
|
|
1104
|
+
mode: "never",
|
|
1105
|
+
plane: "platform",
|
|
1106
|
+
group: "clientHints",
|
|
1107
|
+
u: null,
|
|
1108
|
+
supersedes: null,
|
|
1109
|
+
description: "UA-CH low-entropy platform family string.",
|
|
1110
|
+
review: compliantReview()
|
|
1111
|
+
},
|
|
1112
|
+
{
|
|
1113
|
+
id: "platform.clientHints.platformVersion",
|
|
1114
|
+
addedVersion: "v1",
|
|
1115
|
+
removedVersion: null,
|
|
1116
|
+
tier: "low",
|
|
1117
|
+
measurement: provisional(
|
|
1118
|
+
"UA-CH high-entropy `platformVersion` hint (OS version string). Collected for contradiction detection only; see platform.clientHints.architecture."
|
|
1119
|
+
),
|
|
1120
|
+
denoise: { kind: "none" },
|
|
1121
|
+
mode: "never",
|
|
1122
|
+
plane: "platform",
|
|
1123
|
+
group: "clientHints",
|
|
1124
|
+
u: null,
|
|
1125
|
+
supersedes: null,
|
|
1126
|
+
description: "UA-CH high-entropy OS version hint.",
|
|
1127
|
+
review: compliantReview()
|
|
1128
|
+
},
|
|
1129
|
+
{
|
|
1130
|
+
id: "platform.clientHints.uaFullVersion",
|
|
1131
|
+
addedVersion: "v1",
|
|
1132
|
+
removedVersion: null,
|
|
1133
|
+
tier: "low",
|
|
1134
|
+
measurement: provisional(
|
|
1135
|
+
"UA-CH high-entropy `uaFullVersion` hint \u2014 deprecated upstream in favour of `fullVersionList`, but still requested here because a spoofing tool that patches the User-Agent string is more likely to miss this legacy field than the one it actually knows to fake."
|
|
1136
|
+
),
|
|
1137
|
+
denoise: { kind: "none" },
|
|
1138
|
+
mode: "never",
|
|
1139
|
+
plane: "platform",
|
|
1140
|
+
group: "clientHints",
|
|
1141
|
+
u: null,
|
|
1142
|
+
supersedes: null,
|
|
1143
|
+
description: "UA-CH high-entropy (deprecated) full browser version hint.",
|
|
1144
|
+
review: compliantReview()
|
|
1145
|
+
},
|
|
1146
|
+
{
|
|
1147
|
+
id: "platform.clientHints.fullVersionList",
|
|
1148
|
+
addedVersion: "v1",
|
|
1149
|
+
removedVersion: null,
|
|
1150
|
+
tier: "low",
|
|
1151
|
+
measurement: provisional(
|
|
1152
|
+
"UA-CH high-entropy `fullVersionList` hint: brand/full-version pairs, GREASE entries filtered before this signal is ever populated (see the collector for the filter and why an unfiltered read would self-split on every request)."
|
|
1153
|
+
),
|
|
1154
|
+
denoise: { kind: "none" },
|
|
1155
|
+
mode: "never",
|
|
1156
|
+
plane: "platform",
|
|
1157
|
+
group: "clientHints",
|
|
1158
|
+
u: null,
|
|
1159
|
+
supersedes: null,
|
|
1160
|
+
description: "UA-CH high-entropy brand/full-version list, GREASE-filtered.",
|
|
1161
|
+
review: compliantReview()
|
|
1162
|
+
},
|
|
1163
|
+
{
|
|
1164
|
+
id: "platform.clientHints.wow64",
|
|
1165
|
+
addedVersion: "v1",
|
|
1166
|
+
removedVersion: null,
|
|
1167
|
+
tier: "low",
|
|
1168
|
+
measurement: provisional(
|
|
1169
|
+
"UA-CH high-entropy `wow64` hint: whether a 32-bit browser is running under WOW64 on 64-bit Windows. Collected for contradiction detection only; see platform.clientHints.architecture."
|
|
1170
|
+
),
|
|
1171
|
+
denoise: { kind: "none" },
|
|
1172
|
+
mode: "never",
|
|
1173
|
+
plane: "platform",
|
|
1174
|
+
group: "clientHints",
|
|
1175
|
+
u: null,
|
|
1176
|
+
supersedes: null,
|
|
1177
|
+
description: "UA-CH high-entropy Windows WOW64 hint.",
|
|
1178
|
+
review: compliantReview()
|
|
1179
|
+
},
|
|
1180
|
+
{
|
|
1181
|
+
id: "platform.clientHints.mobile",
|
|
1182
|
+
addedVersion: "v1",
|
|
1183
|
+
removedVersion: null,
|
|
1184
|
+
tier: "low",
|
|
1185
|
+
measurement: provisional(
|
|
1186
|
+
"UA-CH low-entropy `mobile` flag, read synchronously off navigator.userAgentData rather than requested through getHighEntropyValues(). Collected for contradiction detection only (e.g. against a desktop User-Agent string), not identity linkage."
|
|
1187
|
+
),
|
|
1188
|
+
denoise: { kind: "none" },
|
|
1189
|
+
mode: "never",
|
|
1190
|
+
plane: "platform",
|
|
1191
|
+
group: "clientHints",
|
|
1192
|
+
u: null,
|
|
1193
|
+
supersedes: null,
|
|
1194
|
+
description: "UA-CH low-entropy mobile-device flag.",
|
|
1195
|
+
review: compliantReview()
|
|
1196
|
+
}
|
|
1197
|
+
];
|
|
1198
|
+
|
|
1199
|
+
// src/signals/resolve.ts
|
|
1200
|
+
function versionIndex(version) {
|
|
1201
|
+
return REGISTRY_VERSIONS.indexOf(version);
|
|
1202
|
+
}
|
|
1203
|
+
function isActiveAt(signal, version) {
|
|
1204
|
+
const at = versionIndex(version);
|
|
1205
|
+
const added = versionIndex(signal.addedVersion);
|
|
1206
|
+
const removed = signal.removedVersion === null ? Infinity : versionIndex(signal.removedVersion);
|
|
1207
|
+
return added <= at && at < removed;
|
|
1208
|
+
}
|
|
1209
|
+
function resolveSignalsAt(registry, version = CURRENT_REGISTRY_VERSION) {
|
|
1210
|
+
if (!REGISTRY_VERSIONS.includes(version)) {
|
|
1211
|
+
throw new Error(
|
|
1212
|
+
`Unrecognized registry version "${version}". Known versions: ${REGISTRY_VERSIONS.join(", ")}.`
|
|
1213
|
+
);
|
|
1214
|
+
}
|
|
1215
|
+
return registry.filter((signal) => isActiveAt(signal, version));
|
|
1216
|
+
}
|
|
1217
|
+
function getSignal(registry, id, version = CURRENT_REGISTRY_VERSION) {
|
|
1218
|
+
return resolveSignalsAt(registry, version).find((signal) => signal.id === id);
|
|
1219
|
+
}
|
|
1220
|
+
function listShippedSignals(registry) {
|
|
1221
|
+
return [...registry].sort((a, b) => a.id.localeCompare(b.id));
|
|
1222
|
+
}
|
|
1223
|
+
function groupSignals(signals) {
|
|
1224
|
+
const grouped = {};
|
|
1225
|
+
for (const signal of signals) {
|
|
1226
|
+
const plane = grouped[signal.plane] ??= {};
|
|
1227
|
+
(plane[signal.group] ??= []).push(signal);
|
|
1228
|
+
}
|
|
1229
|
+
return grouped;
|
|
1230
|
+
}
|
|
1231
|
+
|
|
1232
|
+
// ../../node_modules/.pnpm/canonicalize@3.0.0/node_modules/canonicalize/lib/canonicalize.js
|
|
1233
|
+
function canonicalize(object, seen = /* @__PURE__ */ new Set()) {
|
|
1234
|
+
if (typeof object === "number" && isNaN(object)) {
|
|
1235
|
+
throw new Error("NaN is not allowed");
|
|
1236
|
+
}
|
|
1237
|
+
if (typeof object === "number" && !isFinite(object)) {
|
|
1238
|
+
throw new Error("Infinity is not allowed");
|
|
1239
|
+
}
|
|
1240
|
+
if (object === null || typeof object !== "object") {
|
|
1241
|
+
return JSON.stringify(object);
|
|
1242
|
+
}
|
|
1243
|
+
if (typeof object.toJSON === "function") {
|
|
1244
|
+
if (seen.has(object)) {
|
|
1245
|
+
throw new Error("Circular reference detected");
|
|
1246
|
+
}
|
|
1247
|
+
seen.add(object);
|
|
1248
|
+
const result2 = canonicalize(object.toJSON(), seen);
|
|
1249
|
+
seen.delete(object);
|
|
1250
|
+
return result2;
|
|
1251
|
+
}
|
|
1252
|
+
if (seen.has(object)) {
|
|
1253
|
+
throw new Error("Circular reference detected");
|
|
1254
|
+
}
|
|
1255
|
+
seen.add(object);
|
|
1256
|
+
let result;
|
|
1257
|
+
if (Array.isArray(object)) {
|
|
1258
|
+
const values = object.map((cv) => {
|
|
1259
|
+
const value = cv === void 0 || typeof cv === "symbol" ? null : cv;
|
|
1260
|
+
return canonicalize(value, seen);
|
|
1261
|
+
});
|
|
1262
|
+
result = `[${values.join(",")}]`;
|
|
1263
|
+
} else {
|
|
1264
|
+
const parts = [];
|
|
1265
|
+
for (const key of Object.keys(object).sort()) {
|
|
1266
|
+
if (object[key] === void 0 || typeof object[key] === "symbol") {
|
|
1267
|
+
continue;
|
|
1268
|
+
}
|
|
1269
|
+
parts.push(`${canonicalize(key)}:${canonicalize(object[key], seen)}`);
|
|
1270
|
+
}
|
|
1271
|
+
result = `{${parts.join(",")}}`;
|
|
1272
|
+
}
|
|
1273
|
+
seen.delete(object);
|
|
1274
|
+
return result;
|
|
1275
|
+
}
|
|
1276
|
+
|
|
1277
|
+
// src/signals/merkle.ts
|
|
1278
|
+
var EXCLUDED_FROM_ROOT = /* @__PURE__ */ new Set(["behavioural"]);
|
|
1279
|
+
var TAG_PRESENT = "v:";
|
|
1280
|
+
var TAG_ABSENT = "a:";
|
|
1281
|
+
var TAG_ERROR = "e:";
|
|
1282
|
+
function digestHex(bytes) {
|
|
1283
|
+
return utils_js.bytesToHex(sha2_js.sha256(bytes));
|
|
1284
|
+
}
|
|
1285
|
+
function leafBytes(reading) {
|
|
1286
|
+
if (reading === void 0 || reading.kind === "absent") {
|
|
1287
|
+
return new TextEncoder().encode(TAG_ABSENT);
|
|
1288
|
+
}
|
|
1289
|
+
if (reading.kind === "error") {
|
|
1290
|
+
return new TextEncoder().encode(`${TAG_ERROR}error`);
|
|
1291
|
+
}
|
|
1292
|
+
if (reading.value === void 0) {
|
|
1293
|
+
throw new Error(
|
|
1294
|
+
'buildFingerprintTree: a "present" reading with value `undefined` is not a valid leaf \u2014 use { kind: "absent" } instead.'
|
|
1295
|
+
);
|
|
1296
|
+
}
|
|
1297
|
+
const json = canonicalize(reading.value);
|
|
1298
|
+
if (json === void 0) {
|
|
1299
|
+
throw new Error(
|
|
1300
|
+
"buildFingerprintTree: reading value is not JSON-serializable (function, symbol, etc)."
|
|
1301
|
+
);
|
|
1302
|
+
}
|
|
1303
|
+
return new TextEncoder().encode(`${TAG_PRESENT}${json}`);
|
|
1304
|
+
}
|
|
1305
|
+
function nodeDigest(orderedChildDigests) {
|
|
1306
|
+
return digestHex(new TextEncoder().encode(orderedChildDigests.join("")));
|
|
1307
|
+
}
|
|
1308
|
+
function buildFingerprintTree(registry, readings, registryVersion = CURRENT_REGISTRY_VERSION) {
|
|
1309
|
+
const grouped = groupSignals(resolveSignalsAt(registry, registryVersion));
|
|
1310
|
+
const planes = {};
|
|
1311
|
+
const rootInputs = [];
|
|
1312
|
+
for (const plane of Object.keys(grouped).sort()) {
|
|
1313
|
+
const groupsForPlane = grouped[plane];
|
|
1314
|
+
const groups = {};
|
|
1315
|
+
const groupDigests = [];
|
|
1316
|
+
for (const groupName of Object.keys(groupsForPlane).sort()) {
|
|
1317
|
+
const signalsInGroup = [...groupsForPlane[groupName]].sort(
|
|
1318
|
+
(a, b) => a.id.localeCompare(b.id)
|
|
1319
|
+
);
|
|
1320
|
+
const leaves = {};
|
|
1321
|
+
const leafDigests = [];
|
|
1322
|
+
for (const signal of signalsInGroup) {
|
|
1323
|
+
const digest = digestHex(leafBytes(readings[signal.id]));
|
|
1324
|
+
leaves[signal.id] = digest;
|
|
1325
|
+
leafDigests.push(digest);
|
|
1326
|
+
}
|
|
1327
|
+
const groupDigest = nodeDigest(leafDigests);
|
|
1328
|
+
groups[groupName] = { digest: groupDigest, leaves };
|
|
1329
|
+
groupDigests.push(groupDigest);
|
|
1330
|
+
}
|
|
1331
|
+
const planeDigest = nodeDigest(groupDigests);
|
|
1332
|
+
const includedInRoot = !EXCLUDED_FROM_ROOT.has(plane);
|
|
1333
|
+
planes[plane] = { digest: planeDigest, includedInRoot, groups };
|
|
1334
|
+
if (includedInRoot) rootInputs.push(planeDigest);
|
|
1335
|
+
}
|
|
1336
|
+
return {
|
|
1337
|
+
registryVersion,
|
|
1338
|
+
root: nodeDigest(rootInputs),
|
|
1339
|
+
planes
|
|
1340
|
+
};
|
|
1341
|
+
}
|
|
1342
|
+
function computeSessionFingerprintHash(clientAttributes) {
|
|
1343
|
+
const names = Object.keys(clientAttributes ?? {});
|
|
1344
|
+
if (names.length === 0) return null;
|
|
1345
|
+
const sorted = {};
|
|
1346
|
+
for (const name of names.sort()) sorted[name] = clientAttributes[name];
|
|
1347
|
+
const json = canonicalize(sorted);
|
|
1348
|
+
if (json === void 0) return null;
|
|
1349
|
+
return utils_js.bytesToHex(sha2_js.sha256(new TextEncoder().encode(json)));
|
|
1350
|
+
}
|
|
1351
|
+
|
|
1352
|
+
// src/signals/validate.ts
|
|
1353
|
+
var VALID_TIERS = ["high", "medium", "low"];
|
|
1354
|
+
var VALID_MODES = ["open", "consent", "never"];
|
|
1355
|
+
function versionIndex2(version) {
|
|
1356
|
+
return REGISTRY_VERSIONS.indexOf(version);
|
|
1357
|
+
}
|
|
1358
|
+
function validateRegistry(signals) {
|
|
1359
|
+
const errors = [];
|
|
1360
|
+
const byId = /* @__PURE__ */ new Map();
|
|
1361
|
+
const seenIds = /* @__PURE__ */ new Set();
|
|
1362
|
+
for (const signal of signals) {
|
|
1363
|
+
const label = signal?.id ?? "<unknown id>";
|
|
1364
|
+
if (seenIds.has(signal?.id)) {
|
|
1365
|
+
errors.push(`Duplicate signal id "${signal.id}".`);
|
|
1366
|
+
} else if (signal?.id) {
|
|
1367
|
+
seenIds.add(signal.id);
|
|
1368
|
+
byId.set(signal.id, signal);
|
|
1369
|
+
}
|
|
1370
|
+
if (!signal.tier) {
|
|
1371
|
+
errors.push(`Signal "${label}" has no tier. Every signal must carry a stability tier.`);
|
|
1372
|
+
} else if (!VALID_TIERS.includes(signal.tier)) {
|
|
1373
|
+
errors.push(`Signal "${label}" has invalid tier "${signal.tier}".`);
|
|
1374
|
+
}
|
|
1375
|
+
if (!signal.mode || !VALID_MODES.includes(signal.mode)) {
|
|
1376
|
+
errors.push(`Signal "${label}" has invalid mode "${signal.mode}".`);
|
|
1377
|
+
}
|
|
1378
|
+
if (!REGISTRY_VERSIONS.includes(signal.addedVersion)) {
|
|
1379
|
+
errors.push(`Signal "${label}" has invalid addedVersion "${signal.addedVersion}".`);
|
|
1380
|
+
}
|
|
1381
|
+
if (signal.removedVersion !== null) {
|
|
1382
|
+
if (!REGISTRY_VERSIONS.includes(signal.removedVersion)) {
|
|
1383
|
+
errors.push(`Signal "${label}" has invalid removedVersion "${signal.removedVersion}".`);
|
|
1384
|
+
} else if (versionIndex2(signal.removedVersion) <= versionIndex2(signal.addedVersion)) {
|
|
1385
|
+
errors.push(
|
|
1386
|
+
`Signal "${label}" has removedVersion "${signal.removedVersion}" at or before its addedVersion "${signal.addedVersion}".`
|
|
1387
|
+
);
|
|
1388
|
+
}
|
|
1389
|
+
}
|
|
1390
|
+
if (!signal.measurement) {
|
|
1391
|
+
errors.push(`Signal "${label}" has no measurement record for its tier assignment.`);
|
|
1392
|
+
} else if (!signal.measurement.provisional) {
|
|
1393
|
+
if (signal.measurement.agreementRate === null || signal.measurement.measuredAt === null) {
|
|
1394
|
+
errors.push(
|
|
1395
|
+
`Signal "${label}" has a finalized (non-provisional) tier but no recorded measurement (agreementRate/measuredAt). A tier with no measurement behind it is a guess wearing a label.`
|
|
1396
|
+
);
|
|
1397
|
+
}
|
|
1398
|
+
}
|
|
1399
|
+
const sensitiveCheck = checkSensitiveAttributeCompliance(signal);
|
|
1400
|
+
if (!sensitiveCheck.ok) {
|
|
1401
|
+
for (const violation of sensitiveCheck.violations) {
|
|
1402
|
+
errors.push(`Signal "${label}" ${violation.message}`);
|
|
1403
|
+
}
|
|
1404
|
+
}
|
|
1405
|
+
}
|
|
1406
|
+
for (const signal of signals) {
|
|
1407
|
+
if (signal.supersedes === null) continue;
|
|
1408
|
+
const target = byId.get(signal.supersedes);
|
|
1409
|
+
if (!target) {
|
|
1410
|
+
errors.push(
|
|
1411
|
+
`Signal "${signal.id}" supersedes "${signal.supersedes}", which does not exist in the registry.`
|
|
1412
|
+
);
|
|
1413
|
+
continue;
|
|
1414
|
+
}
|
|
1415
|
+
if (target.removedVersion === null || versionIndex2(target.removedVersion) > versionIndex2(signal.addedVersion)) {
|
|
1416
|
+
errors.push(
|
|
1417
|
+
`Signal "${signal.id}" forks "${signal.supersedes}" at "${signal.addedVersion}", but "${signal.supersedes}" has no matching removedVersion. Set removedVersion="${signal.addedVersion}" on "${signal.supersedes}" when forking.`
|
|
1418
|
+
);
|
|
1419
|
+
}
|
|
1420
|
+
}
|
|
1421
|
+
return { valid: errors.length === 0, errors };
|
|
1422
|
+
}
|
|
1423
|
+
|
|
1424
|
+
// src/signals/immutability.ts
|
|
1425
|
+
function denoiseEqual(a, b) {
|
|
1426
|
+
if (a.kind !== b.kind) return false;
|
|
1427
|
+
if (a.kind === "modal" && b.kind === "modal") return a.runs === b.runs;
|
|
1428
|
+
return true;
|
|
1429
|
+
}
|
|
1430
|
+
function computeImmutableSnapshot(signal) {
|
|
1431
|
+
return {
|
|
1432
|
+
id: signal.id,
|
|
1433
|
+
addedVersion: signal.addedVersion,
|
|
1434
|
+
removedVersion: signal.removedVersion,
|
|
1435
|
+
denoise: signal.denoise,
|
|
1436
|
+
mode: signal.mode,
|
|
1437
|
+
plane: signal.plane,
|
|
1438
|
+
group: signal.group,
|
|
1439
|
+
finalizedTier: signal.measurement.provisional ? null : signal.tier
|
|
1440
|
+
};
|
|
1441
|
+
}
|
|
1442
|
+
var FORK_INSTRUCTION = 'Shipped signals are immutable \u2014 a signal is never edited, only forked. Create a new signal (e.g. "<id>.v2") with supersedes set to this id and removedVersion set on this entry, instead of editing it in place.';
|
|
1443
|
+
function checkSnapshotConsistency(committed, live) {
|
|
1444
|
+
const violations = [];
|
|
1445
|
+
const liveById = new Map(live.map((s) => [s.id, s]));
|
|
1446
|
+
const committedIds = new Set(committed.map((r) => r.id));
|
|
1447
|
+
for (const record of committed) {
|
|
1448
|
+
const current = liveById.get(record.id);
|
|
1449
|
+
if (!current) {
|
|
1450
|
+
violations.push({
|
|
1451
|
+
id: record.id,
|
|
1452
|
+
kind: "deleted",
|
|
1453
|
+
message: `Signal "${record.id}" was removed from the registry entirely. Mark it removed with removedVersion instead of deleting it \u2014 historical fingerprints still reference it.`
|
|
1454
|
+
});
|
|
1455
|
+
continue;
|
|
1456
|
+
}
|
|
1457
|
+
const currentSnapshot = computeImmutableSnapshot(current);
|
|
1458
|
+
const frozenMismatch = currentSnapshot.addedVersion !== record.addedVersion || !denoiseEqual(currentSnapshot.denoise, record.denoise) || currentSnapshot.mode !== record.mode || currentSnapshot.plane !== record.plane || currentSnapshot.group !== record.group;
|
|
1459
|
+
const tierMismatch = record.finalizedTier !== null && currentSnapshot.finalizedTier !== record.finalizedTier;
|
|
1460
|
+
const removedVersionMismatch = record.removedVersion !== null && currentSnapshot.removedVersion !== record.removedVersion;
|
|
1461
|
+
if (frozenMismatch || tierMismatch || removedVersionMismatch) {
|
|
1462
|
+
violations.push({
|
|
1463
|
+
id: record.id,
|
|
1464
|
+
kind: "edited",
|
|
1465
|
+
message: `Signal "${record.id}" was edited in place. ${FORK_INSTRUCTION} Re-running the snapshot recorder will not fix this \u2014 it refuses to overwrite a divergent entry.`
|
|
1466
|
+
});
|
|
1467
|
+
}
|
|
1468
|
+
}
|
|
1469
|
+
for (const current of live) {
|
|
1470
|
+
if (!committedIds.has(current.id)) {
|
|
1471
|
+
violations.push({
|
|
1472
|
+
id: current.id,
|
|
1473
|
+
kind: "unrecorded",
|
|
1474
|
+
message: `Signal "${current.id}" is new and not yet recorded. Run \`pnpm --filter @kya-os/checkpoint-shared run signals:snapshot -- --write\` and commit the result.`
|
|
1475
|
+
});
|
|
1476
|
+
}
|
|
1477
|
+
}
|
|
1478
|
+
return { ok: violations.length === 0, violations };
|
|
1479
|
+
}
|
|
1480
|
+
function recordSnapshot(committed, live) {
|
|
1481
|
+
const result = checkSnapshotConsistency(committed, live);
|
|
1482
|
+
const editedOrDeleted = result.violations.filter((v) => v.kind !== "unrecorded");
|
|
1483
|
+
if (editedOrDeleted.length > 0) {
|
|
1484
|
+
throw new Error(editedOrDeleted.map((v) => v.message).join("\n"));
|
|
1485
|
+
}
|
|
1486
|
+
const liveById = new Map(live.map((s) => [s.id, s]));
|
|
1487
|
+
const committedIds = new Set(committed.map((r) => r.id));
|
|
1488
|
+
const updated = committed.map((record) => {
|
|
1489
|
+
const current = liveById.get(record.id);
|
|
1490
|
+
return current ? computeImmutableSnapshot(current) : record;
|
|
1491
|
+
});
|
|
1492
|
+
const additions = live.filter((s) => !committedIds.has(s.id)).map((s) => computeImmutableSnapshot(s));
|
|
1493
|
+
return [...updated, ...additions];
|
|
1494
|
+
}
|
|
1495
|
+
|
|
1496
|
+
// src/signals/docs.ts
|
|
1497
|
+
var GENERATED_HEADER = `<!-- GENERATED FILE \u2014 do not hand-edit. -->
|
|
1498
|
+
<!-- Generated from \`packages/checkpoint-shared/src/signals/registry.ts\` by -->
|
|
1499
|
+
<!-- \`pnpm --filter @kya-os/checkpoint-shared run signals:docs\`. -->
|
|
1500
|
+
<!-- CI rejects a stale copy of this file \u2014 see .github/workflows/signal-registry-check.yml. -->
|
|
1501
|
+
|
|
1502
|
+
# Signal registry
|
|
1503
|
+
|
|
1504
|
+
Every signal ever shipped, generated from the registry so this can never
|
|
1505
|
+
drift the way \`fingerprintjs-android\`'s hand-maintained \`api_reference.md\`
|
|
1506
|
+
did (it stayed on \`V_5\` after the enum moved to \`V_6\`).
|
|
1507
|
+
|
|
1508
|
+
A shipped signal is never edited, only forked: when a signal proves
|
|
1509
|
+
volatile or is re-tiered, a new signal is added at the next version and the
|
|
1510
|
+
old one is marked removed (exclusive) rather than changed in place, so
|
|
1511
|
+
historical fingerprints stay reproducible against the version they were
|
|
1512
|
+
computed under.
|
|
1513
|
+
`;
|
|
1514
|
+
function formatDenoise(denoise) {
|
|
1515
|
+
return denoise.kind === "modal" ? `modal(${denoise.runs})` : "none";
|
|
1516
|
+
}
|
|
1517
|
+
function formatVersion(version) {
|
|
1518
|
+
return version ?? "\u2014";
|
|
1519
|
+
}
|
|
1520
|
+
function formatTier(signal) {
|
|
1521
|
+
return signal.measurement.provisional ? `${signal.tier} (provisional)` : signal.tier;
|
|
1522
|
+
}
|
|
1523
|
+
function formatRow(signal) {
|
|
1524
|
+
const cells = [
|
|
1525
|
+
`\`${signal.id}\``,
|
|
1526
|
+
`${signal.plane}/${signal.group}`,
|
|
1527
|
+
formatVersion(signal.addedVersion),
|
|
1528
|
+
formatVersion(signal.removedVersion),
|
|
1529
|
+
formatTier(signal),
|
|
1530
|
+
signal.mode,
|
|
1531
|
+
formatDenoise(signal.denoise),
|
|
1532
|
+
signal.supersedes ? `\`${signal.supersedes}\`` : "\u2014",
|
|
1533
|
+
signal.u === null ? "\u2014" : String(signal.u)
|
|
1534
|
+
];
|
|
1535
|
+
return `| ${cells.join(" | ")} |`;
|
|
1536
|
+
}
|
|
1537
|
+
var TABLE_HEADER = [
|
|
1538
|
+
"| id | plane/group | added | removed | tier | mode | denoise | supersedes | u |",
|
|
1539
|
+
"| --- | --- | --- | --- | --- | --- | --- | --- | --- |"
|
|
1540
|
+
].join("\n");
|
|
1541
|
+
function generateRegistryMarkdown(registry) {
|
|
1542
|
+
const rows = listShippedSignals(registry).map(formatRow);
|
|
1543
|
+
return [GENERATED_HEADER, TABLE_HEADER, ...rows, ""].join("\n");
|
|
1544
|
+
}
|
|
1545
|
+
|
|
1546
|
+
exports.COMPOSITION_RISK_RULES = COMPOSITION_RISK_RULES;
|
|
1547
|
+
exports.CURRENT_REGISTRY_VERSION = CURRENT_REGISTRY_VERSION;
|
|
1548
|
+
exports.CURRENT_SENSITIVE_REJECTION_LIST_VERSION = CURRENT_SENSITIVE_REJECTION_LIST_VERSION;
|
|
1549
|
+
exports.FROZEN_FIELDS = FROZEN_FIELDS;
|
|
1550
|
+
exports.REGISTRY_VERSIONS = REGISTRY_VERSIONS;
|
|
1551
|
+
exports.SENSITIVE_ATTRIBUTE_REJECTION_LIST = SENSITIVE_ATTRIBUTE_REJECTION_LIST;
|
|
1552
|
+
exports.SENSITIVE_REJECTION_LIST_VERSIONS = SENSITIVE_REJECTION_LIST_VERSIONS;
|
|
1553
|
+
exports.SIGNAL_REGISTRY = SIGNAL_REGISTRY;
|
|
1554
|
+
exports.SensitiveAttributeRejectionError = SensitiveAttributeRejectionError;
|
|
1555
|
+
exports.TIER_LOCKED_FIELDS = TIER_LOCKED_FIELDS;
|
|
1556
|
+
exports.buildFingerprintTree = buildFingerprintTree;
|
|
1557
|
+
exports.checkCompositionRisk = checkCompositionRisk;
|
|
1558
|
+
exports.checkDeclaredCategory = checkDeclaredCategory;
|
|
1559
|
+
exports.checkDirectMatch = checkDirectMatch;
|
|
1560
|
+
exports.checkReviewRecordIntegrity = checkReviewRecordIntegrity;
|
|
1561
|
+
exports.checkSensitiveAttributeCompliance = checkSensitiveAttributeCompliance;
|
|
1562
|
+
exports.checkSnapshotConsistency = checkSnapshotConsistency;
|
|
1563
|
+
exports.computeImmutableSnapshot = computeImmutableSnapshot;
|
|
1564
|
+
exports.computeSessionFingerprintHash = computeSessionFingerprintHash;
|
|
1565
|
+
exports.evaluateSensitiveAttributeCompliance = evaluateSensitiveAttributeCompliance;
|
|
1566
|
+
exports.findSignalsNeedingReevaluation = findSignalsNeedingReevaluation;
|
|
1567
|
+
exports.generateRegistryMarkdown = generateRegistryMarkdown;
|
|
1568
|
+
exports.getSignal = getSignal;
|
|
1569
|
+
exports.groupSignals = groupSignals;
|
|
1570
|
+
exports.listShippedSignals = listShippedSignals;
|
|
1571
|
+
exports.recordSnapshot = recordSnapshot;
|
|
1572
|
+
exports.registerSignal = registerSignal;
|
|
1573
|
+
exports.resolveSignalsAt = resolveSignalsAt;
|
|
1574
|
+
exports.validateRegistry = validateRegistry;
|