@akasecurity/ai-tc-antigravity 0.9.12 → 0.9.13

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.
@@ -20482,7 +20482,17 @@ var UNPRICEABLE_PROVIDERS = Object.freeze([
20482
20482
  "gateway",
20483
20483
  "unknown",
20484
20484
  "cli",
20485
- "api"
20485
+ "api",
20486
+ // The browser extension's native host records these as `llm_call.provider`
20487
+ // for a web-chat turn — the web tool id, deliberately never the vendor id
20488
+ // (`openai`/`anthropic`) the session root carries. Subscription traffic
20489
+ // burns rate-limit budget, not dollar credits, and listing them here is
20490
+ // what keeps that true structurally: a later maintainer who wants to price
20491
+ // web-chat traffic at API rates has to delete this entry first, and meet
20492
+ // the reason on the way, rather than quietly adding one to
20493
+ // PROVIDER_PLATFORM.
20494
+ "chatgpt",
20495
+ "claude-ai"
20486
20496
  ]);
20487
20497
  function platformForProvider(provider) {
20488
20498
  return PROVIDER_PLATFORM.get(provider.trim().toLowerCase()) ?? null;
@@ -20625,7 +20635,12 @@ var HARNESS = {
20625
20635
  ClaudeDesktop: "claudedesktop",
20626
20636
  ChatGpt: "chatgpt",
20627
20637
  ClaudeAi: "claudeai",
20628
- Api: "api"
20638
+ Api: "api",
20639
+ // Not a coding assistant a person drives — an in-process SDK embedded in an
20640
+ // application, so it has no IDE/CLI/desktop/web surface of its own. Carries
20641
+ // the same id as its SOURCE_TOOL counterpart, unlike every capture-side tool
20642
+ // whose wire spelling differs from its display spelling.
20643
+ AiTcSdk: "ai-tc-sdk"
20629
20644
  };
20630
20645
  var Harness = external_exports.enum(HARNESS).meta({ id: "Harness" });
20631
20646
  var SOURCE_TOOL = {
@@ -20641,9 +20656,15 @@ var SOURCE_TOOL = {
20641
20656
  // whose tool could not be identified both render through the read side's
20642
20657
  // miss path rather than as a harness of their own.
20643
20658
  Cli: "cli",
20644
- Unknown: "unknown"
20659
+ Unknown: "unknown",
20660
+ // The wire id an in-process, request-path SDK stamps on its own structural
20661
+ // rows (`request_decision`) — never a capture of prompt/response/tool text,
20662
+ // since the SDK sits in front of a model call rather than inside a coding
20663
+ // assistant's own hook contract.
20664
+ AiTcSdk: "ai-tc-sdk"
20645
20665
  };
20646
20666
  var SourceTool = external_exports.enum(SOURCE_TOOL).meta({ id: "SourceTool" });
20667
+ var WebSourceTool = SourceTool.extract(["ChatGpt", "ClaudeAi"]);
20647
20668
  var TOOL_TO_HARNESS = {
20648
20669
  [SOURCE_TOOL.ClaudeCode]: HARNESS.ClaudeCode,
20649
20670
  [SOURCE_TOOL.ClaudeDesktop]: HARNESS.ClaudeDesktop,
@@ -20652,7 +20673,12 @@ var TOOL_TO_HARNESS = {
20652
20673
  [SOURCE_TOOL.ChatGpt]: HARNESS.ChatGpt,
20653
20674
  [SOURCE_TOOL.Codex]: HARNESS.Codex,
20654
20675
  [SOURCE_TOOL.Antigravity]: HARNESS.Antigravity,
20655
- [SOURCE_TOOL.ClaudeAi]: HARNESS.ClaudeAi
20676
+ [SOURCE_TOOL.ClaudeAi]: HARNESS.ClaudeAi,
20677
+ // Wire and display id are the same string here, but the row still belongs:
20678
+ // both vocabularies carry the `AiTcSdk` member, and the join is exactly
20679
+ // their intersection — leaving a shared member out would read as an
20680
+ // uninstrumented tool on both surfaces, which this one is not.
20681
+ [SOURCE_TOOL.AiTcSdk]: HARNESS.AiTcSdk
20656
20682
  };
20657
20683
 
20658
20684
  // ../../packages/schema/src/zod/finding.ts
@@ -20686,7 +20712,8 @@ var FindingProvider = Harness.extract([
20686
20712
  "ClaudeAi",
20687
20713
  "Codex",
20688
20714
  "Antigravity",
20689
- "Api"
20715
+ "Api",
20716
+ "AiTcSdk"
20690
20717
  ]).meta({ id: "FindingProvider" });
20691
20718
  var FindingCategory = external_exports.enum([
20692
20719
  "secret",
@@ -21063,18 +21090,41 @@ var AuditEventType = external_exports.enum([
21063
21090
  // 'tool_call' is the reconciler's structural row for every call, while
21064
21091
  // 'tool_use' exists only where a hook enforced against the arguments.
21065
21092
  "tool_use",
21066
- // One row per model REFUSAL: a switch onto a prohibited model that was
21067
- // denied, or a turn refused because the session was already running on one.
21068
- // A structural row like the ones above rather than a capture — it carries
21069
- // the model that was refused and nothing the user typed, because what is
21070
- // worth recording about a governance decision is the decision, and prompt
21071
- // text is the thing this product exists to keep from travelling.
21093
+ // One row per model REFUSAL, across all four seams a prohibited model can be
21094
+ // stopped at: a switch onto it, a turn already running on it, a subagent
21095
+ // spawn asking for it, or a request-path refusal an embedded request-path
21096
+ // SDK makes in-process before the call leaves the application. Which seam
21097
+ // rides `attributes.refusal_seam`, never this member name. A structural row
21098
+ // like the ones above rather than a capture — it carries the model that was
21099
+ // refused and nothing the user typed, because what is worth recording about
21100
+ // a governance decision is the decision, and prompt text is the thing this
21101
+ // product exists to keep from travelling.
21072
21102
  "model_refusal",
21103
+ // One row per request-path DECISION: a policy check an embedded request-path
21104
+ // SDK performs in-process before a model call leaves the application, or
21105
+ // against that call's non-streamed response. A structural row like
21106
+ // 'model_refusal' rather than a capture — content-free in the same way:
21107
+ // which side, which seam, what action and which field are decided rides
21108
+ // `attributes`, never this member name, and the matched text itself never
21109
+ // travels.
21110
+ //
21111
+ // A prohibited-model refusal on the request path is deliberately NOT this
21112
+ // member: it stays 'model_refusal' with `refusal_seam: 'request'`, so it
21113
+ // shares one bucket with the plugin's switch/turn/spawn refusals rather
21114
+ // than splitting one governance concept across two event types. This
21115
+ // member carries every OTHER request-path decision.
21116
+ "request_decision",
21073
21117
  // One row per config-inventory scan, hung off the session root. It is the
21074
21118
  // fact the posture inspection findings reference (findings require an
21075
21119
  // audit_event_id), and its started_at is the "scanned Nm ago" the read
21076
21120
  // surface renders.
21077
- "config_scan"
21121
+ "config_scan",
21122
+ // One row per reported browser-extension capture status, hung off the web
21123
+ // session root. The durable home of what one tab's network interception
21124
+ // is doing — a write-through of the native host's in-memory tracker, so a
21125
+ // second process (aka extension status) and a restarted host both have
21126
+ // somewhere to read it back from.
21127
+ "capture_status"
21078
21128
  ]).meta({ id: "AuditEventType" });
21079
21129
  var AttributeBag = external_exports.record(external_exports.string(), external_exports.unknown());
21080
21130
  var HostAttributes = external_exports.object({
@@ -21234,6 +21284,20 @@ var CaptureAttributes = external_exports.object({
21234
21284
  // repeated rather than referenced because a store reader opens this file.
21235
21285
  redact_degraded_to: ActionTaken.optional()
21236
21286
  }).catchall(external_exports.unknown());
21287
+ var CaptureStatusAttributes = external_exports.object({
21288
+ source_tool: external_exports.string().optional(),
21289
+ patched: external_exports.boolean().optional(),
21290
+ live: external_exports.boolean().optional(),
21291
+ blind: external_exports.boolean().optional(),
21292
+ sends_seen_dom: external_exports.number().int().nonnegative().optional(),
21293
+ exchanges_seen_net: external_exports.number().int().nonnegative().optional(),
21294
+ parse_failures: external_exports.number().int().nonnegative().optional(),
21295
+ unparsed_bodies: external_exports.number().int().nonnegative().optional(),
21296
+ shape_misses: external_exports.array(external_exports.string()).optional(),
21297
+ conversation_endpoints: external_exports.number().int().nonnegative().optional(),
21298
+ closed: external_exports.boolean().optional(),
21299
+ enforcement: external_exports.string().optional()
21300
+ }).catchall(external_exports.unknown());
21237
21301
  var ToolCallInspection = external_exports.object({
21238
21302
  ruleId: external_exports.string().min(1),
21239
21303
  ruleName: external_exports.string(),
@@ -22093,6 +22157,30 @@ var AttachedCredential = external_exports.object({
22093
22157
  keyPrefix: external_exports.string().min(1).max(16).optional(),
22094
22158
  mintedAt: external_exports.iso.datetime().optional()
22095
22159
  });
22160
+ var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
22161
+ function unsafeEndpointReason(endpoint) {
22162
+ let parsed2;
22163
+ try {
22164
+ parsed2 = new URL(endpoint);
22165
+ } catch {
22166
+ return "unparseable";
22167
+ }
22168
+ if (parsed2.username !== "" || parsed2.password !== "") return "userinfo";
22169
+ if (parsed2.search !== "" || parsed2.hash !== "") return "query-or-fragment";
22170
+ if (parsed2.protocol === "https:") return null;
22171
+ return parsed2.protocol === "http:" && LOOPBACK_HOSTS.has(parsed2.hostname) ? null : "insecure";
22172
+ }
22173
+ function isSafeEndpoint(endpoint) {
22174
+ return unsafeEndpointReason(endpoint) === null;
22175
+ }
22176
+ function originOnly(endpoint) {
22177
+ try {
22178
+ const parsed2 = new URL(endpoint);
22179
+ return `${parsed2.protocol}//${parsed2.host}`;
22180
+ } catch {
22181
+ return "(unparseable endpoint)";
22182
+ }
22183
+ }
22096
22184
  var MAX_DATE_MS = 253402300799999;
22097
22185
  var MAX_INT4 = 2147483647;
22098
22186
  var StorePosturePack = external_exports.object({
@@ -22247,6 +22335,11 @@ var RemoteFailureKind = external_exports.enum([
22247
22335
  "rejected",
22248
22336
  "unreachable"
22249
22337
  ]);
22338
+ var ControlPlaneFailure = RemoteFailureKind.extract([
22339
+ "unauthorized",
22340
+ "forbidden",
22341
+ "unreachable"
22342
+ ]);
22250
22343
  var AttachDeviceRequest = external_exports.object({
22251
22344
  // This machine's own continuity id, so re-attaching ROTATES the credential
22252
22345
  // on one machine record instead of producing a second one. Client-minted
@@ -22786,7 +22879,12 @@ var EventMetadata = external_exports.object({
22786
22879
  // in — set by the browser extension's network capture so a stored `response`
22787
22880
  // row can be joined to the `llm_call` leaf describing the same turn. Absent
22788
22881
  // on every other capture path, which has no such id.
22789
- messageId: external_exports.string().optional(),
22882
+ //
22883
+ // Non-empty for the reason WebExchange.messageId is: it is the join key, and
22884
+ // a blank one matches no `llm_call` leaf. That refusal reaches only the
22885
+ // places an event is PARSED; the local write path types the event and parses
22886
+ // nothing, which is why `toCaptureAttributes` omits a blank one separately.
22887
+ messageId: external_exports.string().min(1).optional(),
22790
22888
  conversationId: external_exports.string().optional(),
22791
22889
  // How long THIS capture's inspection blocked its caller, in whole
22792
22890
  // milliseconds — the plugin's own added latency, NOT the LLM call it sat in
@@ -23633,6 +23731,85 @@ function policyIdIsReversible(policyId) {
23633
23731
  var DEFAULT_ACTIONS = Object.fromEntries(
23634
23732
  DetectionCategory.options.map((c) => [c, builtinPolicyToAction(severityFloorPolicy(c))])
23635
23733
  );
23734
+ function ruleCategoryMap(wireRules, localRules, compiledRules) {
23735
+ const map2 = /* @__PURE__ */ new Map();
23736
+ for (const rule of wireRules ?? []) map2.set(rule.id, rule.category);
23737
+ for (const rule of localRules ?? []) map2.set(rule.id, rule.category);
23738
+ for (const rule of compiledRules) map2.set(rule.id, rule.category);
23739
+ return map2;
23740
+ }
23741
+ function policyKey(policy) {
23742
+ return "ruleId" in policy.target ? `rule:${policy.target.ruleId}` : `category:${policy.target.category}`;
23743
+ }
23744
+ function floorFor(policy, categoryByRuleId) {
23745
+ const category = "category" in policy.target ? policy.target.category : categoryByRuleId.get(policy.target.ruleId);
23746
+ return category === void 0 ? null : DEFAULT_ACTIONS[category];
23747
+ }
23748
+ function strongerOf(a, b) {
23749
+ if (a === null) return b;
23750
+ if (b === null) return a;
23751
+ return strongerAction(a, b);
23752
+ }
23753
+ function mergeRaiseOnly(localPolicies, remotePolicies, categoryByRuleId) {
23754
+ const merged = /* @__PURE__ */ new Map();
23755
+ const disabled = [];
23756
+ const remoteCategoryAction = /* @__PURE__ */ new Map();
23757
+ for (const policy of remotePolicies) {
23758
+ if (!policy.enabled) continue;
23759
+ if (!("category" in policy.target)) continue;
23760
+ if (remoteCategoryAction.has(policy.target.category)) continue;
23761
+ const floor = floorFor(policy, categoryByRuleId);
23762
+ remoteCategoryAction.set(
23763
+ policy.target.category,
23764
+ floor !== null && !isActionAtLeast(policy.action, floor) ? floor : policy.action
23765
+ );
23766
+ }
23767
+ for (const policy of localPolicies) {
23768
+ if (!policy.enabled) {
23769
+ disabled.push(policy);
23770
+ continue;
23771
+ }
23772
+ const key = policyKey(policy);
23773
+ if (merged.has(key)) continue;
23774
+ let remoteFloor = null;
23775
+ if ("ruleId" in policy.target) {
23776
+ const category = categoryByRuleId.get(policy.target.ruleId);
23777
+ if (category !== void 0) remoteFloor = remoteCategoryAction.get(category) ?? null;
23778
+ }
23779
+ merged.set(
23780
+ key,
23781
+ remoteFloor !== null && !isActionAtLeast(policy.action, remoteFloor) ? { ...policy, action: remoteFloor } : policy
23782
+ );
23783
+ }
23784
+ const localCategoryAction = /* @__PURE__ */ new Map();
23785
+ for (const policy of merged.values()) {
23786
+ if ("category" in policy.target) localCategoryAction.set(policy.target.category, policy.action);
23787
+ }
23788
+ for (const policy of remotePolicies) {
23789
+ if (!policy.enabled) {
23790
+ disabled.push(policy);
23791
+ continue;
23792
+ }
23793
+ const key = policyKey(policy);
23794
+ const floor = floorFor(policy, categoryByRuleId);
23795
+ let localFloor = null;
23796
+ if ("ruleId" in policy.target) {
23797
+ const category = categoryByRuleId.get(policy.target.ruleId);
23798
+ if (category !== void 0) localFloor = localCategoryAction.get(category) ?? null;
23799
+ }
23800
+ const effectiveFloor = strongerOf(floor, localFloor);
23801
+ const clamped = effectiveFloor !== null && !isActionAtLeast(policy.action, effectiveFloor) ? { ...policy, action: effectiveFloor } : policy;
23802
+ const existing = merged.get(key);
23803
+ if (existing === void 0) {
23804
+ merged.set(key, clamped);
23805
+ continue;
23806
+ }
23807
+ if (actionRank(clamped.action) > actionRank(existing.action)) {
23808
+ merged.set(key, clamped);
23809
+ }
23810
+ }
23811
+ return [...merged.values(), ...disabled];
23812
+ }
23636
23813
  var BUILTIN_POLICIES = Object.fromEntries(
23637
23814
  KNOWN_BUILTIN_IDS.map((id) => [id, { id, ...BUILTIN_POLICY_SPECS[id] }])
23638
23815
  );
@@ -23858,6 +24035,18 @@ var HistorySyncConsent = external_exports.object({
23858
24035
  payloadVersion: external_exports.number().int().positive(),
23859
24036
  endpoint: external_exports.string()
23860
24037
  });
24038
+ var WebChatCaptureConsent = external_exports.object({
24039
+ acknowledgedAt: external_exports.iso.datetime(),
24040
+ version: external_exports.number().int().positive()
24041
+ });
24042
+ var WebChatResponseCapture = external_exports.enum(["with-findings", "always", "never"]);
24043
+ var WebChatCapture = external_exports.object({
24044
+ responses: WebChatResponseCapture.default("with-findings"),
24045
+ account: external_exports.boolean().default(false),
24046
+ // Absent until granted. Presence alone does not authorize anything — see
24047
+ // isWebChatCaptureConsentValid.
24048
+ consent: WebChatCaptureConsent.optional()
24049
+ });
23861
24050
  var BODY_RETENTION_DEFAULT_DAYS = 30;
23862
24051
  var BodyRetention = external_exports.object({
23863
24052
  enabled: external_exports.boolean().default(false),
@@ -23916,6 +24105,16 @@ var WorkspaceSettings = external_exports.object({
23916
24105
  // both widenings. Absent until granted, and a grant for a different endpoint
23917
24106
  // or an older payload no longer counts.
23918
24107
  historySyncConsent: HistorySyncConsent.optional(),
24108
+ // What the browser extension may record from a web chat, and the grant that
24109
+ // authorizes it. Absent until the user answers: recording something that was
24110
+ // never recorded before is never an assumed grant on upgrade, so the whole
24111
+ // block is optional rather than defaulted in. What an absent block means is
24112
+ // webChatCaptureOf's answer, in one place.
24113
+ //
24114
+ // Enforcement is NOT gated on this. A machine that has never answered still
24115
+ // blocks, redacts and warns on what a user sends; the grant covers what is
24116
+ // written down.
24117
+ webChatCapture: WebChatCapture.optional(),
23919
24118
  // Local body expiry (see BodyRetention). Off until switched on; expiring a
23920
24119
  // body never removes the row or its findings.
23921
24120
  bodyRetention: BodyRetention.default({
@@ -24023,7 +24222,10 @@ function toCaptureAttributes(event) {
24023
24222
  // `.catchall(z.unknown())` carries the long tail.
24024
24223
  ...metadata?.model !== void 0 ? { model: metadata.model } : {},
24025
24224
  ...metadata?.turnIndex !== void 0 ? { turn_index: metadata.turnIndex } : {},
24026
- ...metadata?.messageId !== void 0 ? { message_id: metadata.messageId } : {},
24225
+ // A blank id is omitted rather than stored: it is a join key and `''` joins
24226
+ // nothing. This runs on the local write path, which types the event but
24227
+ // never parses it, so EventMetadata's own `.min(1)` does not reach here.
24228
+ ...metadata?.messageId !== void 0 && metadata.messageId !== "" ? { message_id: metadata.messageId } : {},
24027
24229
  ...metadata?.conversationId !== void 0 ? { conversation_id: metadata.conversationId } : {}
24028
24230
  };
24029
24231
  }
@@ -24397,12 +24599,14 @@ var RecommendedActionIdParam = external_exports.object({ id: external_exports.st
24397
24599
  // ../../packages/schema/src/zod/settings-action.ts
24398
24600
  var HistorySyncConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "HistorySyncConsentChoice" });
24399
24601
  var ModelJudgeConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "ModelJudgeConsentChoice" });
24602
+ var WebChatCaptureConsentChoice = external_exports.enum(["granted", "revoked", "unchanged"]).meta({ id: "WebChatCaptureConsentChoice" });
24400
24603
  var SaveSettingsInput = external_exports.object({
24401
24604
  historicalAccess: external_exports.string(),
24402
24605
  modelJudgeConsent: ModelJudgeConsentChoice,
24403
24606
  historySyncConsent: HistorySyncConsentChoice,
24404
24607
  vaultConsent: external_exports.string(),
24405
24608
  vaultInlineReveal: external_exports.string(),
24609
+ webChatCaptureConsent: WebChatCaptureConsentChoice,
24406
24610
  // Widened to `string` like its neighbours rather than typed as
24407
24611
  // `RedactFallback`, on this module's own layering rule: shape here, VALUE at
24408
24612
  // the call site, so the domain check receives the type it was written for.
@@ -24617,11 +24821,24 @@ var WebExchange = external_exports.object({
24617
24821
  turnIndex: external_exports.number().int().nonnegative().optional(),
24618
24822
  toolCalls: external_exports.array(WebToolCall).default([]),
24619
24823
  // Absent when the adapter recovered no text. Capped by the caller at
24620
- // RESPONSE_TEXT_MAX_BYTES; `truncated` records that the cap was reached, so a
24621
- // short capture is never mistaken for a short reply.
24824
+ // RESPONSE_TEXT_MAX_BYTES, so a short capture is never mistaken for a short
24825
+ // reply.
24622
24826
  responseText: external_exports.string().optional(),
24827
+ // The stored text is short of the reply. It does NOT say which of the two
24828
+ // ceilings on this path cut it: the caller applies its own cap on the raw
24829
+ // bytes it reads off the wire, which can be reached by a stream whose
24830
+ // recovered text stays well under RESPONSE_TEXT_MAX_BYTES, and applies that
24831
+ // one to the text. A reader cannot tell them apart, and nothing downstream
24832
+ // should branch as though it could.
24623
24833
  truncated: external_exports.boolean().default(false)
24624
24834
  });
24835
+ var WebEnforcementState = external_exports.enum([
24836
+ "watching",
24837
+ "composer-only",
24838
+ "button-only",
24839
+ "unattached",
24840
+ "unknown"
24841
+ ]);
24625
24842
  var RESPONSE_TEXT_MAX_BYTES = 2 * 1024 * 1024;
24626
24843
  var WebCaptureStatus = external_exports.object({
24627
24844
  patched: external_exports.boolean(),
@@ -24633,8 +24850,66 @@ var WebCaptureStatus = external_exports.object({
24633
24850
  unparsedBodies: external_exports.number().int().nonnegative(),
24634
24851
  // The adapter-declared JSON key paths that were absent from a real payload —
24635
24852
  // the earliest signal that a site's contract moved.
24636
- shapeMisses: external_exports.array(external_exports.string()).default([])
24637
- });
24853
+ shapeMisses: external_exports.array(external_exports.string()).default([]),
24854
+ // How many `kind: 'conversation'` endpoints the reporting tab's adapter
24855
+ // compiled. Zero means this build declares none for the site, so observing
24856
+ // nothing is the design rather than a fault — the one fact that separates a
24857
+ // site nobody has surveyed yet from one whose contract moved. Defaulted so a
24858
+ // build predating the field is read as declaring nothing rather than refused.
24859
+ conversationEndpoints: external_exports.number().int().nonnegative().default(0),
24860
+ // The document that sent this report is going away. The bridge sets it on
24861
+ // its `pagehide` report and nowhere else.
24862
+ //
24863
+ // A property of the REPORT rather than of capture health, which is why
24864
+ // nothing in `deriveWebCaptureState` reads it and why it stays out of the
24865
+ // bridge's own report signature — a closing tab's last word must not be
24866
+ // suppressed for carrying the same health as the report before it. What
24867
+ // reads it is the per-site fold: a document that said it was unloading stops
24868
+ // voting on the site's state, so the reload the `blind` remediation asks for
24869
+ // can actually clear the verdict it was shown. A document that dies without
24870
+ // sending one is covered by CAPTURE_STATUS_DOCUMENT_QUIET_MS instead.
24871
+ //
24872
+ // Defaulted so a build predating the field reads as a document that never
24873
+ // said it was closing — which keeps it voting, the same as every report that
24874
+ // is not a final one.
24875
+ closed: external_exports.boolean().default(false),
24876
+ // What the DOM enforcement path is doing, which none of the counters above
24877
+ // can say: `sendsSeenDom` rises only once a send has COMPLETED, so a tab
24878
+ // whose watcher never bound reports zero exactly like a tab nobody typed in.
24879
+ // Defaulted to 'unknown' rather than 'watching' so a status from a build
24880
+ // predating the field is not read as reporting a healthy one.
24881
+ enforcement: WebEnforcementState.default("unknown")
24882
+ });
24883
+ function webCaptureStatusObservedTurnPath(status) {
24884
+ if (!status.patched) return true;
24885
+ if (status.conversationEndpoints === 0) return true;
24886
+ return status.blind || status.shapeMisses.length > 0 || status.parseFailures > 0 || status.unparsedBodies > 0 || status.exchangesSeenNet > 0;
24887
+ }
24888
+ function pickReportedCaptureStatus(candidates) {
24889
+ return candidates.find((c) => webCaptureStatusObservedTurnPath(c.status)) ?? candidates[0];
24890
+ }
24891
+ var CAPTURE_STATUS_RECENCY_MS = 30 * 24 * 60 * 60 * 1e3;
24892
+ var CAPTURE_STATUS_RECENCY_DAYS = CAPTURE_STATUS_RECENCY_MS / (24 * 60 * 60 * 1e3);
24893
+ var CAPTURE_STATUS_DOCUMENT_QUIET_MS = 12 * 60 * 60 * 1e3;
24894
+ function fromCaptureStatusAttributes(bag) {
24895
+ const parsedBag = CaptureStatusAttributes.safeParse(bag);
24896
+ if (!parsedBag.success) return null;
24897
+ const b = parsedBag.data;
24898
+ const parsedStatus = WebCaptureStatus.safeParse({
24899
+ patched: b.patched,
24900
+ live: b.live,
24901
+ blind: b.blind,
24902
+ sendsSeenDom: b.sends_seen_dom,
24903
+ exchangesSeenNet: b.exchanges_seen_net,
24904
+ parseFailures: b.parse_failures,
24905
+ unparsedBodies: b.unparsed_bodies,
24906
+ shapeMisses: b.shape_misses,
24907
+ conversationEndpoints: b.conversation_endpoints,
24908
+ closed: b.closed,
24909
+ enforcement: b.enforcement
24910
+ });
24911
+ return parsedStatus.success ? parsedStatus.data : null;
24912
+ }
24638
24913
 
24639
24914
  // ../../packages/persistence/src/paths.ts
24640
24915
  import {
@@ -24765,17 +25040,6 @@ function publishByLink(tmp, file2, data) {
24765
25040
  function controlPlaneCredentialPath(settingsDir2) {
24766
25041
  return join2(settingsDir2, ATTACHED_CREDENTIAL_FILENAME);
24767
25042
  }
24768
- var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
24769
- function isSafeEndpoint(endpoint) {
24770
- let parsed2;
24771
- try {
24772
- parsed2 = new URL(endpoint);
24773
- } catch {
24774
- return false;
24775
- }
24776
- if (parsed2.protocol === "https:") return true;
24777
- return parsed2.protocol === "http:" && LOOPBACK_HOSTS.has(parsed2.hostname);
24778
- }
24779
25043
  function repairOrRefuseMode(file2) {
24780
25044
  const link = lstatSync2(file2, { throwIfNoEntry: false });
24781
25045
  if (link === void 0) return "absent";
@@ -26568,7 +26832,7 @@ var SESSION_ROOT = `event_type = 'session'`;
26568
26832
  var HAS_ACTIVITY = `EXISTS (
26569
26833
  SELECT 1 FROM audit_events c
26570
26834
  WHERE c.root_session_id = audit_events.id
26571
- AND c.event_type NOT IN ('hook', 'config_scan'))`;
26835
+ AND c.event_type NOT IN ('hook', 'config_scan', 'capture_status'))`;
26572
26836
  var SqliteActivityRepository = class {
26573
26837
  constructor(db, now = () => Date.now()) {
26574
26838
  this.db = db;
@@ -26595,10 +26859,10 @@ var SqliteActivityRepository = class {
26595
26859
  SELECT id FROM audit_events WHERE event_type = 'session' AND started_at >= ?
26596
26860
  UNION
26597
26861
  SELECT root_session_id FROM audit_events INDEXED BY idx_audit_started_at
26598
- WHERE started_at >= ?
26862
+ WHERE started_at >= ? AND event_type <> 'capture_status'
26599
26863
  UNION
26600
26864
  SELECT root_session_id FROM audit_events INDEXED BY idx_audit_ended_at
26601
- WHERE ended_at >= ?)`,
26865
+ WHERE ended_at >= ? AND event_type <> 'capture_status')`,
26602
26866
  [liveThreshold, liveThreshold, liveThreshold]
26603
26867
  );
26604
26868
  const toolCallsToday = countScalar(
@@ -27005,7 +27269,10 @@ var SqliteAuditEventsRepository = class {
27005
27269
  attributes = excluded.attributes,
27006
27270
  ended_at = excluded.ended_at
27007
27271
  WHERE COALESCE(json_extract(excluded.attributes, '$.output_tokens'), 0)
27008
- > COALESCE(json_extract(audit_events.attributes, '$.output_tokens'), 0)`
27272
+ > COALESCE(json_extract(audit_events.attributes, '$.output_tokens'), 0)
27273
+ OR (json_extract(excluded.attributes, '$.usage_source') IS NOT NULL
27274
+ AND json_extract(excluded.attributes, '$.output_tokens') IS NULL
27275
+ AND excluded.attributes <> audit_events.attributes)`
27009
27276
  );
27010
27277
  this.upsertSessionRootStmt = db.prepare(
27011
27278
  `INSERT OR IGNORE INTO audit_events
@@ -27273,6 +27540,87 @@ var SqliteBodyRetentionRepository = class {
27273
27540
  }
27274
27541
  };
27275
27542
 
27543
+ // ../../packages/persistence/src/repositories/capture-status.ts
27544
+ var STATUS_LOOKBACK_ROWS = 128;
27545
+ var SqliteCaptureStatusRepository = class {
27546
+ constructor(db) {
27547
+ this.db = db;
27548
+ this.recentStmt = db.prepare(
27549
+ `SELECT a.started_at AS startedAt,
27550
+ a.attributes AS attributes,
27551
+ a.root_session_id AS rootSessionId
27552
+ FROM audit_events a
27553
+ WHERE a.event_type = 'capture_status'
27554
+ AND a.source_tool = ?
27555
+ AND a.started_at >= ?
27556
+ ORDER BY a.started_at DESC, a.id DESC
27557
+ LIMIT ?`
27558
+ );
27559
+ }
27560
+ db;
27561
+ recentStmt;
27562
+ /**
27563
+ * Every document that reported for a site, in registry order by site, from
27564
+ * the last `CAPTURE_STATUS_RECENCY_MS`.
27565
+ *
27566
+ * SEVERAL per site, not one: a browser is many documents and each reports
27567
+ * for itself, so one row per site is a choice about which of them a user
27568
+ * sees — and the newest is the wrong one, since a healthy tab writing a
27569
+ * fresh report would hide a drifting tab's verdict, which is the whole
27570
+ * reason these rows exist. The pick WITHIN a document is made here (the
27571
+ * unchanged `pickReportedCaptureStatus`, over that document's own rows);
27572
+ * choosing between documents belongs where the state semantics live, and
27573
+ * that is `reportedCaptureDocumentForSite` in `@akasecurity/detections` —
27574
+ * this package may not import it.
27575
+ *
27576
+ * `now` is a required argument rather than a `Date.now()` read, so a caller
27577
+ * that already holds a render instant passes THAT one and a test can drive
27578
+ * the window without moving the wall clock.
27579
+ *
27580
+ * A site whose reports have all aged out contributes nothing, so it derives
27581
+ * to `unreported`. That is the point: nothing but the browser extension ever
27582
+ * writes these rows, so an uninstalled extension's last verdict would
27583
+ * otherwise stand as a live claim for ever with no later report able to
27584
+ * clear it.
27585
+ */
27586
+ latest(now) {
27587
+ const since = now - CAPTURE_STATUS_RECENCY_MS;
27588
+ const documents = [];
27589
+ for (const tool of WebSourceTool.options) {
27590
+ const rows = /* @__PURE__ */ new Map();
27591
+ const lastWord = /* @__PURE__ */ new Map();
27592
+ for (const row of allRows(this.recentStmt, [
27593
+ tool,
27594
+ since,
27595
+ STATUS_LOOKBACK_ROWS
27596
+ ])) {
27597
+ const status = fromCaptureStatusAttributes(parseJsonObject(row.attributes));
27598
+ if (status === null) continue;
27599
+ const record2 = { tool, observedAt: epochMillisToIso(row.startedAt), status };
27600
+ const group = rows.get(row.rootSessionId);
27601
+ if (group === void 0) {
27602
+ rows.set(row.rootSessionId, [record2]);
27603
+ lastWord.set(row.rootSessionId, { at: record2.observedAt, closed: status.closed });
27604
+ } else {
27605
+ group.push(record2);
27606
+ }
27607
+ }
27608
+ for (const [root, candidates] of rows) {
27609
+ const picked = pickReportedCaptureStatus(candidates);
27610
+ const last = lastWord.get(root);
27611
+ if (picked === void 0 || last === void 0) continue;
27612
+ documents.push({
27613
+ ...picked,
27614
+ ...root === null ? {} : { rootSessionId: root },
27615
+ lastReportAt: last.at,
27616
+ closed: last.closed
27617
+ });
27618
+ }
27619
+ }
27620
+ return documents;
27621
+ }
27622
+ };
27623
+
27276
27624
  // ../../packages/persistence/src/repositories/classified-data.ts
27277
27625
  var SqliteClassifiedDataRepository = class {
27278
27626
  constructor(db) {
@@ -32850,6 +33198,7 @@ function openAndInitialize(file2, base, skipTags) {
32850
33198
  activity: new SqliteActivityRepository(db),
32851
33199
  sourceProject: new SqliteSourceProjectRepository(db),
32852
33200
  auditEvents: new SqliteAuditEventsRepository(db),
33201
+ captureStatus: new SqliteCaptureStatusRepository(db),
32853
33202
  classifiedData: new SqliteClassifiedDataRepository(db),
32854
33203
  inspectionDefinitions: new SqliteInspectionDefinitionsRepository(db),
32855
33204
  inspectionFindings: new SqliteInspectionFindingsRepository(db),
@@ -32890,6 +33239,7 @@ function openLocalDatabase(dir, options = {}) {
32890
33239
  activity,
32891
33240
  sourceProject,
32892
33241
  auditEvents,
33242
+ captureStatus,
32893
33243
  classifiedData,
32894
33244
  inspectionDefinitions,
32895
33245
  inspectionFindings,
@@ -33107,6 +33457,7 @@ function openLocalDatabase(dir, options = {}) {
33107
33457
  activity,
33108
33458
  sourceProject,
33109
33459
  auditEvents,
33460
+ captureStatus,
33110
33461
  classifiedData,
33111
33462
  inspectionDefinitions,
33112
33463
  inspectionFindings,
@@ -33332,11 +33683,6 @@ function fingerprintValue(key, raw) {
33332
33683
  // ../../packages/persistence/src/forward-health.ts
33333
33684
  import { readFileSync as readFileSync7 } from "fs";
33334
33685
  import { join as join9 } from "path";
33335
- var FAILURES = /* @__PURE__ */ new Set([
33336
- "unauthorized",
33337
- "forbidden",
33338
- "unreachable"
33339
- ]);
33340
33686
  var BREAKER_COOLDOWN_MS = 3e4;
33341
33687
  function parseForwardHealth(raw, nowMs) {
33342
33688
  try {
@@ -33345,7 +33691,8 @@ function parseForwardHealth(raw, nowMs) {
33345
33691
  const record2 = parsed2;
33346
33692
  const failures = typeof record2.consecutiveFailures === "number" && record2.consecutiveFailures >= 0 ? record2.consecutiveFailures : 0;
33347
33693
  const openedAtMs = typeof record2.openedAtMs === "number" && Number.isFinite(record2.openedAtMs) && record2.openedAtMs <= nowMs ? record2.openedAtMs : null;
33348
- const lastFailure = typeof record2.lastFailure === "string" && FAILURES.has(record2.lastFailure) ? record2.lastFailure : null;
33694
+ const parsedFailure = ControlPlaneFailure.safeParse(record2.lastFailure);
33695
+ const lastFailure = parsedFailure.success ? parsedFailure.data : null;
33349
33696
  return { consecutiveFailures: failures, openedAtMs, lastFailure };
33350
33697
  } catch {
33351
33698
  return null;
@@ -34429,6 +34776,56 @@ var CONFIG_POSTURE_RULES = [
34429
34776
  }
34430
34777
  ];
34431
34778
 
34779
+ // ../../packages/detections/src/posture/web-capture-posture.ts
34780
+ var RULE_VERSION2 = "1";
34781
+ var DRIFT_MIN_PARSE_FAILURES = 2;
34782
+ var WEB_CAPTURE_DRIFT_STATES = /* @__PURE__ */ new Set([
34783
+ "blind",
34784
+ "degraded"
34785
+ ]);
34786
+ var WEB_CAPTURE_DRIFT_RULE = {
34787
+ ruleId: "web-capture-drift",
34788
+ version: RULE_VERSION2,
34789
+ name: "Web chat capture is not reading the site",
34790
+ category: "config",
34791
+ severity: "medium",
34792
+ definition: JSON.stringify({
34793
+ kind: "web-capture-drift",
34794
+ states: [...WEB_CAPTURE_DRIFT_STATES],
34795
+ minParseFailures: DRIFT_MIN_PARSE_FAILURES
34796
+ })
34797
+ };
34798
+ var STATIC_COPY = {
34799
+ active: { headline: "turns are being observed on this site" },
34800
+ unreported: {
34801
+ // Says "recently" rather than "yet": the store read is bounded to
34802
+ // CAPTURE_STATUS_RECENCY_MS, so this state covers a site nothing has ever
34803
+ // reported for AND one whose last report has aged out. The two are the
34804
+ // same fact to a reader — nobody has confirmed anything lately — and the
34805
+ // copy may not claim the stronger of them.
34806
+ headline: `no report in the last ${String(CAPTURE_STATUS_RECENCY_DAYS)} days \u2014 open the site in Chrome with the extension loaded`
34807
+ },
34808
+ standby: {
34809
+ headline: "this build declares no endpoints for the site, so nothing is observed yet"
34810
+ },
34811
+ unpatched: {
34812
+ // Says what the flags say and no more. `patched` is false both for a tap
34813
+ // that installed and hooked neither transport and for one that never ran
34814
+ // at all — a page reports the same status either way, so the copy may not
34815
+ // assert one of them.
34816
+ headline: "the page tap captured neither fetch nor XHR \u2014 it may not have installed; reload the extension at chrome://extensions"
34817
+ },
34818
+ idle: { headline: "watching; no turn has been observed yet" },
34819
+ blind: {
34820
+ headline: "messages were sent in the page that the network capture never saw",
34821
+ remediation: "reload the tab. If it persists after `aka update` and reloading the extension at chrome://extensions, the site's send path has changed and needs a new extension build."
34822
+ },
34823
+ degraded: {
34824
+ headline: "the site's payloads no longer carry the fields the extension reads",
34825
+ remediation: "run `aka update`, then reload the extension at chrome://extensions. If it stays degraded after an update, the site's contract has changed and needs a new extension build."
34826
+ }
34827
+ };
34828
+
34432
34829
  // ../../packages/detections/src/security/redos-probe.ts
34433
34830
  var BUDGET_MS = 100;
34434
34831
  var EXPONENTIAL_UNITS = [
@@ -38196,6 +38593,12 @@ var RemoteRequestInvalid = class extends Error {
38196
38593
  }
38197
38594
  cause;
38198
38595
  };
38596
+ var RemoteEndpointRefused = class extends Error {
38597
+ constructor(endpoint) {
38598
+ super(`refusing to talk to an unsafe control-plane endpoint: ${originOnly(endpoint)}`);
38599
+ this.name = "RemoteEndpointRefused";
38600
+ }
38601
+ };
38199
38602
  var RemoteResponseInvalid = class extends Error {
38200
38603
  constructor(route2, detail) {
38201
38604
  super(`control plane answered ${route2} with ${detail}`);
@@ -38348,14 +38751,15 @@ function parsed(schema, body, route2) {
38348
38751
  }
38349
38752
  return result.data;
38350
38753
  }
38351
- function withoutTrailingSlashes(endpoint) {
38754
+ function resolveBaseUrl(endpoint) {
38755
+ if (!isSafeEndpoint(endpoint)) throw new RemoteEndpointRefused(endpoint);
38352
38756
  let end = endpoint.length;
38353
38757
  while (end > 0 && endpoint.charCodeAt(end - 1) === SLASH2) end -= 1;
38354
38758
  return endpoint.slice(0, end);
38355
38759
  }
38356
38760
  var SLASH2 = "/".charCodeAt(0);
38357
38761
  function createRemoteClient(options) {
38358
- const base = withoutTrailingSlashes(options.endpoint);
38762
+ const base = resolveBaseUrl(options.endpoint);
38359
38763
  const url2 = (route2) => `${base}${route2}`;
38360
38764
  const common = { apiKey: options.apiKey, timeoutMs: options.timeoutMs };
38361
38765
  const sendOne = async (event) => {
@@ -38485,6 +38889,7 @@ function classifyRemoteFailure(err) {
38485
38889
  case "RemoteRouteAbsent":
38486
38890
  return "route-absent";
38487
38891
  case "RemoteRequestInvalid":
38892
+ case "RemoteEndpointRefused":
38488
38893
  return "invalid-request";
38489
38894
  case "RemoteResponseInvalid":
38490
38895
  return "rejected";
@@ -38688,86 +39093,10 @@ function createForwardPolicy(deps) {
38688
39093
  }
38689
39094
 
38690
39095
  // ../../packages/plugin-runtime/src/attached/gateway.ts
38691
- function strongerOf(a, b) {
38692
- if (a === null) return b;
38693
- if (b === null) return a;
38694
- return strongerAction(a, b);
38695
- }
38696
- function ruleCategoryMap(wireRules, localRules) {
38697
- const map2 = /* @__PURE__ */ new Map();
38698
- for (const rule of wireRules ?? []) map2.set(rule.id, rule.category);
38699
- for (const rule of localRules ?? []) map2.set(rule.id, rule.category);
38700
- for (const pack of bundledDetections()) {
38701
- for (const rule of pack.rules) map2.set(rule.id, rule.category);
38702
- }
38703
- return map2;
38704
- }
38705
- function policyKey(policy) {
38706
- return "ruleId" in policy.target ? `rule:${policy.target.ruleId}` : `category:${policy.target.category}`;
38707
- }
38708
- function floorFor(policy, categoryByRuleId) {
38709
- const category = "category" in policy.target ? policy.target.category : categoryByRuleId.get(policy.target.ruleId);
38710
- return category === void 0 ? null : DEFAULT_ACTIONS[category];
38711
- }
38712
- function mergeRaiseOnly(localPolicies, remotePolicies, categoryByRuleId) {
38713
- const merged = /* @__PURE__ */ new Map();
38714
- const disabled = [];
38715
- const remoteCategoryAction = /* @__PURE__ */ new Map();
38716
- for (const policy of remotePolicies) {
38717
- if (!policy.enabled) continue;
38718
- if (!("category" in policy.target)) continue;
38719
- if (remoteCategoryAction.has(policy.target.category)) continue;
38720
- const floor = floorFor(policy, categoryByRuleId);
38721
- remoteCategoryAction.set(
38722
- policy.target.category,
38723
- floor !== null && !isActionAtLeast(policy.action, floor) ? floor : policy.action
38724
- );
38725
- }
38726
- for (const policy of localPolicies) {
38727
- if (!policy.enabled) {
38728
- disabled.push(policy);
38729
- continue;
38730
- }
38731
- const key = policyKey(policy);
38732
- if (merged.has(key)) continue;
38733
- let remoteFloor = null;
38734
- if ("ruleId" in policy.target) {
38735
- const category = categoryByRuleId.get(policy.target.ruleId);
38736
- if (category !== void 0) remoteFloor = remoteCategoryAction.get(category) ?? null;
38737
- }
38738
- merged.set(
38739
- key,
38740
- remoteFloor !== null && !isActionAtLeast(policy.action, remoteFloor) ? { ...policy, action: remoteFloor } : policy
38741
- );
38742
- }
38743
- const localCategoryAction = /* @__PURE__ */ new Map();
38744
- for (const policy of merged.values()) {
38745
- if ("category" in policy.target) localCategoryAction.set(policy.target.category, policy.action);
38746
- }
38747
- for (const policy of remotePolicies) {
38748
- if (!policy.enabled) {
38749
- disabled.push(policy);
38750
- continue;
38751
- }
38752
- const key = policyKey(policy);
38753
- const floor = floorFor(policy, categoryByRuleId);
38754
- let localFloor = null;
38755
- if ("ruleId" in policy.target) {
38756
- const category = categoryByRuleId.get(policy.target.ruleId);
38757
- if (category !== void 0) localFloor = localCategoryAction.get(category) ?? null;
38758
- }
38759
- const effectiveFloor = strongerOf(floor, localFloor);
38760
- const clamped = effectiveFloor !== null && !isActionAtLeast(policy.action, effectiveFloor) ? { ...policy, action: effectiveFloor } : policy;
38761
- const existing = merged.get(key);
38762
- if (existing === void 0) {
38763
- merged.set(key, clamped);
38764
- continue;
38765
- }
38766
- if (actionRank(clamped.action) > actionRank(existing.action)) {
38767
- merged.set(key, clamped);
38768
- }
38769
- }
38770
- return [...merged.values(), ...disabled];
39096
+ var bundledRulesFlatCache;
39097
+ function bundledRulesFlat() {
39098
+ bundledRulesFlatCache ??= bundledDetections().flatMap((pack) => pack.rules);
39099
+ return bundledRulesFlatCache;
38771
39100
  }
38772
39101
  var AttachedDataGateway = class {
38773
39102
  constructor(deps) {
@@ -39087,6 +39416,9 @@ var AttachedDataGateway = class {
39087
39416
  async readSessionProvider(sessionId) {
39088
39417
  return this.deps.local.readSessionProvider(sessionId);
39089
39418
  }
39419
+ async readCaptureStatuses() {
39420
+ return this.deps.local.readCaptureStatuses();
39421
+ }
39090
39422
  async facets() {
39091
39423
  return this.deps.local.facets();
39092
39424
  }
@@ -39169,7 +39501,7 @@ var AttachedDataGateway = class {
39169
39501
  policies: mergeRaiseOnly(
39170
39502
  local.policies,
39171
39503
  cached2.policies,
39172
- ruleCategoryMap(cached2.rules, local.rules)
39504
+ ruleCategoryMap(cached2.rules, local.rules, bundledRulesFlat())
39173
39505
  ),
39174
39506
  customKeywords: [...local.customKeywords, ...cached2.customKeywords],
39175
39507
  // TAKEN FROM THE CACHE, unlike the two fields below — and the asymmetry
@@ -39370,10 +39702,15 @@ import { join as join30 } from "path";
39370
39702
  // ../../packages/plugin-runtime/src/attached/atomic-publish.ts
39371
39703
  import { rename as rename2 } from "fs/promises";
39372
39704
  var RETRYABLE = /* @__PURE__ */ new Set(["EPERM", "EACCES", "EBUSY"]);
39373
- var ATTEMPTS = 5;
39705
+ var IMMEDIATE_RETRIES = 8;
39706
+ var TIMED_RETRIES = 4;
39707
+ var ATTEMPTS = 1 + IMMEDIATE_RETRIES + TIMED_RETRIES;
39374
39708
  var delay = (ms) => new Promise((resolve3) => {
39375
39709
  setTimeout(resolve3, ms);
39376
39710
  });
39711
+ var yieldToLoop = () => new Promise((resolve3) => {
39712
+ setImmediate(resolve3);
39713
+ });
39377
39714
  async function publishByRename(tmp, file2, move = rename2) {
39378
39715
  for (let attempt = 1; ; attempt += 1) {
39379
39716
  try {
@@ -39382,7 +39719,7 @@ async function publishByRename(tmp, file2, move = rename2) {
39382
39719
  } catch (err) {
39383
39720
  const code = err.code;
39384
39721
  if (attempt >= ATTEMPTS || code === void 0 || !RETRYABLE.has(code)) throw err;
39385
- await delay(attempt * 10);
39722
+ await (attempt <= IMMEDIATE_RETRIES ? yieldToLoop() : delay((attempt - IMMEDIATE_RETRIES) * 10));
39386
39723
  }
39387
39724
  }
39388
39725
  }
@@ -39846,6 +40183,9 @@ var StandaloneDataGateway = class {
39846
40183
  readSessionProvider(sessionId) {
39847
40184
  return Promise.resolve(this.db.auditEvents.sessionProvider(sessionId));
39848
40185
  }
40186
+ readCaptureStatuses() {
40187
+ return Promise.resolve(this.db.captureStatus.latest(Date.now()));
40188
+ }
39849
40189
  facets() {
39850
40190
  return Promise.resolve(this.db.facets());
39851
40191
  }