@mega-yfue/eufy-sdk 0.2.0-beta.0 → 0.2.0-beta.10

package/dist/transport/mqtt/solix-mqtt.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Live telemetry for Anker Solix devices over the AWS-IoT MQTT plane.
+ *
+ * The transport is the shared `SecureMqtt` — the exact same anker AWS-IoT broker + per-user
+ * client-cert mutual TLS the eufy device path uses; a Solix account's `get_user_mqtt_info` result maps
+ * straight onto {@link SecureMqttCredentials}. Solix devices publish telemetry continuously on
+ * `dt/{app_name}/{product_code}/{device_sn}/param_info` as an **ff09 TLV frame** (the same framing
+ * family as {@link parseFf09SettingsResponse}), so this module only adds the Solix topic + a small
+ * ff09 param decoder on top of the reused transport.
+ *
+ * Frame layout (observed on a Smart Meter Gen 2 / AE1X0):
+ *   ff09 | len(u16 LE, incl. trailing XOR checksum) | 5-byte header | TLV fields | xor
+ * each TLV field is `tag(1) | len(1) | value(len)`; measurement fields carry `type(1) | 4 bytes`,
+ * type `0x05` = float32 LE. Field `a2` is the device serial (ASCII after a leading type byte).
+ */
+import { EventEmitter } from "node:events";
+import { type SecureMqttCredentials } from "./secure-mqtt.js";
+import { type Logger } from "../../core/index.js";
+/** A decoded telemetry channel: the raw value plus float/uint interpretations of a 4-byte payload. */
+export interface SolixChannel {
+    /** The leading type byte (`0x05` = float32 LE for the meter's measurement channels). */
+    type: number;
+    raw: Buffer;
+    /** Present when the payload is 4 bytes: little-endian float32. */
+    float?: number;
+    /** Present when the payload is 4 bytes: little-endian uint32. */
+    uint?: number;
+}
+/** A parsed ff09 param frame: the device serial (from `a2`) + the raw TLV field map keyed by tag. */
+export interface SolixParamFrame {
+    deviceSn?: string;
+    /** tag byte → value bytes (still including the per-field leading type byte for measurement fields). */
+    fields: Map<number, Buffer>;
+}
+/**
+ * Telemetry field tags for the Smart Meter (AE1X0) that we emit under a stable NAME, keyed by ff09 tag
+ * byte. Only tags whose tag→name binding is CONFIRMED against a live frame live here:
+ *
+ * - `0xac` = `meterVoltageL1` — confirmed against live single-phase data (a nominal mains voltage).
+ *
+ * Every other measurement tag still surfaces as `channel_<hex tag>` (see {@link solixReadings}), so
+ * nothing on the wire is lost — a caller reads unconfirmed tags there. The names are deliberately NOT
+ * asserted for the rest: the app exposes the field *list*, but the tag→name *binding* below is a
+ * structural inference until a known-load capture pins it, and a mislabelled live float is worse than an
+ * honest `channel_<tag>`. The recovered candidates, to re-add one line each (moving the tag from this
+ * comment to the map above) as a known-load capture confirms each binding:
+ *
+ *   0xa8 meterPowerL1   0xa9 meterPowerL2   0xaa meterPowerL3   0xab meterPowerTotal
+ *   0xad meterVoltageL2 0xae meterVoltageL3 0xaf meterCurrentL1 0xb0 meterCurrentL2
+ *   0xb1 meterCurrentL3 0xb2 meterCurrentTotal 0xb3 meterImportEnergy 0xb4 meterExportEnergy
+ */
+export declare const SOLIX_METER_FIELD_NAMES: Readonly<Record<number, string>>;
+/** Interpret one TLV value as a telemetry channel (leading type byte + payload). */
+export declare function readSolixChannel(value: Buffer | undefined): SolixChannel | undefined;
+/**
+ * Decode an ff09 Solix param frame into its serial + TLV field map. Returns `null` for a non-ff09
+ * buffer, a length field that doesn't fit, or a bad checksum. Validates the trailing XOR checksum first
+ * (so a corrupted frame is rejected rather than yielding plausible floats), then walks `tag|len|value`
+ * from the first `0xa1` tag to the declared length minus the checksum byte via the shared
+ * `walkFf09Tlv` (bounded by `end`, so a field length can't overrun into the checksum).
+ */
+export declare function decodeSolixParamFrame(buf: Buffer): SolixParamFrame | null;
+/**
+ * Reduce a param frame to named + raw telemetry values. Tags below `0xa6` are skipped — `a1`/`a2`/`a3`
+ * carry the field count, the serial and the status, not measurements. A measurement channel is one whose
+ * leading type byte is `0x05` (float32 LE over a 4-byte payload); any other type is a non-measurement
+ * param and contributes nothing. Each measurement is emitted under `channel_<hex tag>`, and additionally
+ * under its name when the tag has a confirmed one in {@link SOLIX_METER_FIELD_NAMES}.
+ */
+export declare function solixReadings(frame: SolixParamFrame): Record<string, number>;
+/** A live telemetry sample emitted by {@link SolixMqtt} as a `reading` event. */
+export interface SolixReading {
+    deviceSn: string;
+    productCode: string;
+    topic: string;
+    frame: SolixParamFrame;
+    values: Record<string, number>;
+}
+/** The minimum device shape {@link SolixMqtt.watch} needs (as returned by `SolixClient.getDevices`). */
+export interface SolixMqttDevice {
+    device_sn: string;
+    product_code: string;
+}
+/** Options for {@link SolixMqtt}. */
+export interface SolixMqttOptions {
+    /** `get_user_mqtt_info` result — carries endpoint, cert/key, app_name, thing_name, user_id. */
+    mqttInfo: SecureMqttCredentials;
+    /** Override the MQTT clientId. Defaults to the cert CN (`thing_name`), distinct from the app's id. */
+    clientId?: string;
+    /**
+     * Account/user id (40-hex) for the arming `account_id` + heartbeat topic. Defaults to
+     * `mqttInfo.user_id`; set it if the credentials omit it.
+     */
+    userId?: string;
+    /**
+     * How often (ms) to re-send the device-info arming request that keeps realtime telemetry flowing.
+     * The device stops pushing `param_info` when no client keeps requesting it (the app re-arms on every
+     * foreground resume + a periodic heartbeat), so a passive subscriber goes silent after the server's
+     * reporting window closes. Default 25s — inside the observed ~30s cadence with keepalive 60. Set `0`
+     * to disable arming (subscribe-only, the old behaviour).
+     */
+    armIntervalMs?: number;
+    /**
+     * The `head.client_id` stamped into the command/heartbeat envelopes — the app-shaped
+     * `android-{app_name}-{user_id}-{mqttUuid}-{ts}` (see {@link buildAppShapedClientId}). Defaults to
+     * that shape built from {@link mqttUuid}. Pass this to pin the whole string.
+     */
+    appClientId?: string;
+    /**
+     * Stable 16-hex install UUID for the app-shaped client id. Defaults to one derived deterministically
+     * from the user id ({@link mqttUuidFrom}) — no storage needed, so the broker sees one stable client
+     * across restarts.
+     *
+     * The trade this makes: the default seed is the **account** id, which every client on that account
+     * shares, so two clients on one account derive the same uuid → the same `client_id`, and the broker
+     * evicts one to admit the other (they take the channel from each other indefinitely). Restart
+     * stability is the common case and this is the deliberate default, but pass an explicit `mqttUuid`
+     * (per host/install) when more than one client runs on the same account, to be told apart.
+     */
+    mqttUuid?: string;
+    /** The account's `site_id` for the `power_site` heartbeat. Omitted from the frame when unknown. */
+    siteId?: string;
+    logger?: Logger;
+}
+/**
+ * Subscribe to a Solix device's live telemetry and emit decoded `reading` events. Reuses
+ * `SecureMqtt` for the connection; adds only the Solix data topic + ff09 param decoding.
+ *
+ *   const mqtt = new SolixMqtt({ mqttInfo: await solix.getUserMqttInfo() });
+ *   mqtt.on("reading", (r) => console.log(r.deviceSn, r.values.meterVoltageL1));
+ *   await mqtt.watch(device);   // device = a SolixClient.getDevices() entry
+ */
+export declare class SolixMqtt extends EventEmitter {
+    private readonly transport;
+    private readonly appName;
+    private readonly userId?;
+    private readonly appClientId;
+    private readonly armIntervalMs;
+    private readonly logger?;
+    private readonly siteId?;
+    private readonly watched;
+    private seq;
+    private armTimer?;
+    /**
+     * Bind to one account's MQTT plane. The envelope `client_id` takes the app's shape
+     * (`android-{app}-{uid}-{mqttUuid}-{ts}`); its `mqttUuid` half must be stable across restarts, or every
+     * restart presents itself to the broker as a new client, so it defaults deterministically from the user
+     * id (see {@link SolixMqttOptions.mqttUuid}) rather than a fresh random per instance.
+     */
+    constructor(opts: SolixMqttOptions);
+    /**
+     * Connect, subscribe to the device's telemetry (+ command-reply) topics, ARM realtime reporting, and
+     * start the re-arm/heartbeat timer so telemetry keeps flowing without the app. Idempotent per device.
+     *
+     * Subscribes ONLY to what the device sends — `param_info` plus the device and account command-reply
+     * channels — never the `…/req` channels, which are the app→device request side this arms on, and would
+     * echo its own publishes back.
+     *
+     * Throws when `param_info` was not granted. A scope-denied filter comes back as SUBACK_FAILURE rather
+     * than an error (see `SecureMqtt.subscribe`), so an unusable subscription otherwise looks like
+     * success: the call would resolve and arm on every interval while no reading ever arrives.
+     *
+     * The re-arm timer is unreffed, so a caller that watches and returns can still exit.
+     */
+    watch(device: SolixMqttDevice): Promise<void>;
+    /** Tear down the connection and stop the re-arm timer. */
+    close(): Promise<void>;
+    /**
+     * Re-arm every watched device and send the site heartbeat. The device only pushes `param_info` while
+     * a client keeps requesting it — this replays the app's `requestDeviceInfo` (cmd 17) + `power_site`
+     * heartbeat (cmd 10); the request frames are reproduced byte-for-byte by {@link buildFf09Request}
+     * (checksum-verified against captured frames in its spec). Best-effort: a publish failure is emitted,
+     * not thrown, so one bad device doesn't stop the rest or kill the timer.
+     */
+    private armAll;
+    /** Publish the device-info arming request (both the "info" and "realtime" ff09 variants the app sends). */
+    private arm;
+    /** The common `head` fields for every cmd envelope; callers add `cmd` + the per-message variable bits. */
+    private makeHead;
+    /**
+     * Build the `{head, payload}` cmd-17 (requestDeviceInfo) envelope carrying a base64 ff09 request.
+     * `account_id` is omitted when the user id is unknown: a live broker cannot tell an empty placeholder
+     * from a real value, so sending `""` would claim an account this client does not have.
+     */
+    private commandEnvelope;
+    /**
+     * The `power_site` heartbeat (cmd 10) envelope the app sends on a timer to keep the session alive.
+     * `site_id` is omitted when unknown, for the same reason `account_id` is in {@link commandEnvelope}.
+     */
+    private heartbeatEnvelope;
+    /**
+     * Decode one inbound MQTT message envelope and emit a `reading` if it carries an ff09 param frame. The
+     * product code and the fallback serial come from the topic (`dt/{app}/{pn}/{sn}/param_info`); the frame's
+     * own `a2` field wins for the serial when it carries one.
+     */
+    private onMessage;
+}
+/**
+ * Pull the ff09 binary frame out of a received message. Solix telemetry arrives as a `{head, payload}`
+ * envelope whose `payload` is a JSON string carrying base64 `data` (or `trans`); `SecureMqtt`
+ * has already JSON-parsed the outer envelope. Returns the decoded frame bytes, or `null`.
+ */
+export declare function extractFf09Payload(raw: unknown): Buffer | null;
+/**
+ * Build the ff09 request frame the app base64-encodes into a `requestDeviceInfo` (cmd 17) command's
+ * `data`. Captured live from the Anker app — request-type tag `a1`=0x22; the `realtime` variant adds
+ * `a2`/`a3` params (this is the one that keeps `param_info` reporting flowing), while `info` is the bare
+ * device-info fetch. Frame:
+ *   `ff09 | len(u16 LE, TOTAL bytes incl. ff09+len+xor) | 5-byte header | a1 01 22
+ *    [| a2 02 01 01 | a3 03 02 2c 01] | fe … <ts32 LE> | xor`
+ * `fe` carries a fresh unix-timestamp nonce; the trailing byte is XOR of every preceding byte (the same
+ * checksum the meter's telemetry frames use — verified to reproduce the captured frames exactly).
+ */
+export declare function buildFf09Request(variant: "info" | "realtime", atUnixSec?: number): Buffer;

package/dist/transport/mqtt/topics.d.ts

@@ -78,3 +78,23 @@ export interface ParsedTopic {
  * so an unparsed topic leaves `deviceSn` unset instead of carrying a guess.
  */
 export declare function parseSecureTopic(topic: string): ParsedTopic | undefined;
+/** The per-device Solix topics for `{appName, productCode, deviceSn}`. */
+export interface SolixDeviceTopics {
+    /** Telemetry the device pushes (SUBSCRIBE) — ff09 `param_info` frames. */
+    paramInfo: string;
+    /** This device's command replies (SUBSCRIBE). */
+    cmdRes: string;
+    /** The device's requestDeviceInfo channel (PUBLISH only — the app arms reporting here). */
+    req: string;
+}
+/** Build the per-device Solix topics. `param_info` is the telemetry we decode; `req` is publish-only. */
+export declare function solixDeviceTopics(appName: string, productCode: string, deviceSn: string): SolixDeviceTopics;
+/** The per-account Solix topics keyed by `user_id`. */
+export interface SolixUserTopics {
+    /** Account-level command replies (SUBSCRIBE). */
+    cmdRes: string;
+    /** The `power_site` heartbeat channel (PUBLISH only). */
+    powerSite: string;
+}
+/** Build the per-account Solix topics. Note: the account `…/req` channel is publish-side and NOT subscribed. */
+export declare function solixUserTopics(appName: string, userId: string): SolixUserTopics;

package/dist/transport/p2p/command-router.d.ts

@@ -18,6 +18,23 @@ import type { FfmpegLevel } from "../ffmpeg.js";
 import { SharedLiveSource } from "./shared-live-source.js";
 import { type PowerTier, type SessionManagerOpts } from "./session-manager.js";
 import { FragmentRecording } from "./fragment-recording.js";
+/**
+ * What a caller's own deadline on a station call has to clear, in milliseconds.
+ *
+ * A caller that bounds one of these calls itself races these waits, and a bound below them reports the
+ * caller's own expiry in place of the reason this SDK was about to give — the two are indistinguishable to
+ * whoever reads the outcome, and they call for different next steps. Published so that bound can be derived
+ * rather than copied: a literal in a caller's source is a second source of truth that goes stale silently
+ * when these change.
+ *
+ * `connect` applies to every call on a station, because nothing can be addressed to one before its session is
+ * up. `level2Grace` applies twice where the key is required: the negotiation is re-prompted once.
+ */
+export declare const P2P_STATION_WAITS: {
+    readonly connect: 20000;
+    readonly level2Grace: 25000;
+    readonly level2Settle: 8000;
+};
 /**
  * Options accepted when warming a {@link SharedLiveSource} for a device (all optional).
  *
@@ -90,6 +107,12 @@ export declare class P2PCommandRouter {
     constructor(deps: P2PRouterDeps);
     /** Forward one P2P failure once even when both the session listener and startup waiter observe it. */
     private reportError;
+    /**
+     * Emit a live trace under a station session's handle, for work this router does ON that session before
+     * the session itself records anything — reaching the station, and resolving what a device is on it. Same
+     * handle as everything the session goes on to trace, which is what groups one attempt.
+     */
+    private traceOnStation;
     /**
      * Whether this transport stack drives `dev`'s `ff09-*` commands — true when the device has its own
      * usable P2P endpoint (a non-empty `p2p_did`). The command sink asks each stack this to route a

package/dist/transport/p2p/index.d.ts

@@ -10,4 +10,5 @@ export * from "./envelope.js";
 export * from "./write-commands.js";
 export * from "./lan-ip.js";
 export { LIVE_TRACE_MESSAGE, type LiveTrace } from "./live-trace.js";
+export { P2P_STATION_WAITS } from "./command-router.js";
 export * as p2pCodec from "./codec.js";

package/dist/transport/p2p/live-trace.d.ts

@@ -63,12 +63,37 @@ export type LiveTrace =
     phase: "sequence-restart";
     dataType: number;
 }
+/**
+ * Work on a station is holding for its session to connect, with the milliseconds it will wait.
+ *
+ * The earliest phase there is: nothing else on a station can be attempted until its session is up, and a
+ * caller whose own deadline expires inside this wait has this record and no other. Emitted only where a wait
+ * actually happens, so its absence states that the session was already connected.
+ */
+ | {
+    phase: "session-connect-wait";
+    waitMs: number;
+}
+/** The session connected, after this long. */
+ | {
+    phase: "session-connected";
+    waitedMs: number;
+}
+/**
+ * The session did not connect within its wait, so nothing on this station can be attempted.
+ *
+ * The one outcome that is otherwise indistinguishable from a station that answered and then refused: both
+ * leave a caller with no media and no phase naming a station.
+ */
+ | {
+    phase: "session-unreachable";
+    waitedMs: number;
+}
 /**
  * A live start is holding for the station's level-2 key, with the milliseconds it will wait.
  *
- * The first of three phases that account for the wait before any media command is sent. A start that looks
- * slow is either waiting here, waiting for the station to serve the channel it was asked for, or being
- * re-issued — and only these separate them.
+ * A start that looks slow is either waiting here, waiting for its session to connect, waiting for the station
+ * to serve the channel it was asked for, or being re-issued — and only these phases separate them.
  */
  | {
     phase: "level2-wait";
@@ -79,10 +104,63 @@ export type LiveTrace =
     phase: "level2-ready";
     cipherId: number;
 }
-/** The level-2 key did not arrive in its grace, so the start proceeds at level 1 or not at all. */
+/**
+ * The station's key is not coming, why, and the cipher where a station named one.
+ *
+ * Every ending of a level-2 wait carries one of these reasons, so a start refused for want of a key is
+ * accounted for however it ended. `grace-elapsed` is a wait that ran out and states how long was waited;
+ * the rest are answered without waiting, because the negotiation is one-shot per connection and a
+ * concluded one is final. `no-cipher-key` and `derivation-failed` are about this account's cipher
+ * material, `not-negotiating` and `session-closed` about the station or its connection — and only a
+ * reason reached under a negotiation has a cipher to name.
+ *
+ * A `grace-elapsed` start proceeds at level 1 where it has such a form, and not at all where it does not.
+ */
  | {
-    phase: "level2-absent";
-    waitedMs: number;
+    phase: "level2-unavailable";
+    reason: "no-cipher-key" | "derivation-failed" | "not-negotiating" | "session-closed" | "grace-elapsed";
+    cipherId?: number;
+    waitedMs?: number;
+}
+/**
+ * A station's cipher was answered with material for a DIFFERENT cipher, which was used in its place.
+ *
+ * The one lookup outcome no other phase accounts for: material for the cipher the station named is followed
+ * by `level2-ready` or by `level2-unavailable` with `derivation-failed`, an answer holding none by
+ * `no-cipher-key`, and a lookup that threw is reported as an error. Substituted material derives to
+ * nothing and otherwise reads as a station fault. `cipherId` is the cipher the station asked for,
+ * `answeredCipherId` the one whose material was used.
+ */
+ | {
+    phase: "cipher-fallback";
+    cipherId: number;
+    answeredCipherId: number;
+}
+/**
+ * The station answered its gateway-info prompt, so a key derivation has begun under the cipher it named.
+ *
+ * What separates a station that never answered the prompt from one that answered and produced no usable key:
+ * without it, `level2-unavailable` with `not-negotiating` covers both, and they are a station or network
+ * problem and an account cipher-material problem respectively.
+ */
+ | {
+    phase: "level2-negotiating";
+    cipherId: number;
+}
+/**
+ * A station was resolved for a call, stating what the caller's device is on it and whose station it is.
+ *
+ * Emitted before anything is sent, so it is the only account of the intended topology on a call that fails
+ * during resolution: an attached camera's media start has no unencrypted form, so whether a device was taken
+ * as attached decides what its failure means. `stationAdmin` states whether the signed-in account is the
+ * station's administrator, which is what a key the account cannot resolve turns on; `unstated` is a device
+ * record that names no administrator, which is not the same as naming another.
+ */
+ | {
+    phase: "station-resolved";
+    topology: "attached" | "own";
+    channel: number;
+    stationAdmin: "self" | "other" | "unstated";
 }
 /** A shared source began warming, with the interval it re-issues on and the deadline it fails at. */
  | {
@@ -110,6 +188,22 @@ export type LiveTrace =
  | {
     phase: "path-stale";
     silentMs: number;
+}
+/**
+ * A stream received nothing on its own channel for the stall window, and what was done about it.
+ *
+ * A station that switches to a sibling leaves the stream it was serving with no frames, no error and no
+ * stop, so this silence is the only statement that it happened. `reasserted` re-issued the media start,
+ * which is the repair; `declined` left the channel alone because nothing is attached to this pull and
+ * taking the station back would take it from a camera someone is watching.
+ *
+ * Media still arriving means this never fires, so a picture that stopped advancing while this is silent
+ * stopped for a reason upstream of the station's attention.
+ */
+ | {
+    phase: "channel-silent";
+    silentMs: number;
+    outcome: "reasserted" | "declined";
 };
 /**
  * Record one startup observation at debug level.

package/dist/transport/p2p/media.d.ts

@@ -34,11 +34,22 @@ export declare function openLiveStream(session: P2PSession, opts?: LiveStreamOpt
  * The header states the stream's geometry when the capture started, and a stream that reconfigures
  * mid-burst leaves it describing something the returned bytes contradict; the return value describes an
  * image, so the image is its source of truth.
+ *
+ * The consumer is detached the moment the collected run is complete, and the decode that follows holds no
+ * station: it works on bytes already in memory. A station serves one camera at a time and the SDK refuses a
+ * second channel on one that is busy, so a still that kept its pull attached across its own decode would deny
+ * that station to every live request for the length of an FFmpeg run — measured on a real base as a live
+ * request refused 370ms after the still it was waiting on had already collected everything it needed.
+ *
+ * `signal` ends the collection itself, not only the wait for it, and rejects with the signal's own reason
+ * because the abandonment is the caller's fact and not a failure of the source. It reaches only the
+ * collection: past that the station is already free, so there is nothing left for it to release.
  */
 export declare function captureSnapshotFromShared(source: SharedLiveSource, opts?: {
     timeoutMs?: number;
     collectMs?: number;
     skipKeyframes?: number;
+    signal?: AbortSignal;
     logger?: Logger;
     ffmpegLevel?: FfmpegLevel;
     ffmpegPath?: string;

package/dist/transport/p2p/p2p-session.d.ts

@@ -208,6 +208,10 @@ export declare class P2PSession extends EventEmitter {
      * cameras from that second group streamed normally at level-1 — including one of the same firmware as an
      * own-session camera that delivered no video at all for a reason of its own. An expired grace therefore
      * separates nothing on this path, and a start failure on such a session is not evidence about it.
+     *
+     * Every `false` answer carries a `level2-unavailable` trace naming its reason, wherever the wait ended: a
+     * `terminal` outcome is the one already stated where the negotiation concluded, since that is where the
+     * cipher and the cause are known, and re-stating it here would double every settled negotiation.
      */
     awaitLevel2Key(graceMs: number, graceFrom?: "call" | "session"): Promise<boolean>;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mega-yfue/eufy-sdk",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0-beta.10",
   "description": "One typed TypeScript client for the Anker eufy v6 cloud — capability-driven devices, realtime events over P2P/MQTT/push, and live media",
   "license": "Apache-2.0",
   "author": "mega-yfue",
@@ -64,7 +64,8 @@
     "guard:docrefs": "bash scripts/ci/guard-doc-refs.sh",
     "guard:lines": "bash scripts/ci/guard-lines.sh",
     "check:esm": "node -e \"import('./dist/index.js').then(m=>console.log('ESM OK:',Object.keys(m).length,'exports'))\"",
-    "verify": "npm run format:check && npm run typecheck && npm run guard:decorrelation && npm run guard:lines && npm run guard:docrefs && npm run guard:consumer-agnostic && npm run guard:capability-ownership && npm run build && npm run check:esm && npm run typecheck:examples && npm test",
+    "check:snippets": "node scripts/ci/check-doc-snippets.mjs",
+    "verify": "npm run format:check && npm run typecheck && npm run guard:decorrelation && npm run guard:lines && npm run guard:docrefs && npm run guard:consumer-agnostic && npm run guard:capability-ownership && npm run build && npm run check:esm && npm run check:snippets && npm run typecheck:examples && npm test",
     "release": "bash scripts/release.sh"
   },
   "engines": {