@nagoorkani/session-capture-vue-replay 0.1.0

package/LICENSE

@@ -0,0 +1,25 @@
+PROPRIETARY SOFTWARE LICENSE
+
+Copyright (c) 2026 Nagoorkani2393. All rights reserved.
+
+This software, its source code, and its accompanying documentation (the
+"Software") are the proprietary and confidential property of the copyright
+holder.
+
+NO LICENSE IS GRANTED. No person or entity is permitted to use, copy, modify,
+merge, publish, distribute, sublicense, reverse engineer, create derivative
+works from, or sell the Software, in whole or in part, by any means, except
+under a separate written agreement signed by the copyright holder.
+
+Availability of the Software through a public package registry, source
+repository, or any other distribution channel is for the convenience of
+authorized licensees only. It does not grant any license, right, or permission
+to the general public, and no such license may be implied from that
+availability. Unauthorized use, reproduction, or distribution is prohibited.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,85 @@
+# @nagoorkani/session-capture-vue-replay
+
+Optional DOM session replay for [`@nagoorkani/session-capture-vue`](../vue/README.md).
+
+Separate from the SDK on purpose. rrweb is several times the size of the SDK
+it attaches to, and section 23 says a recorder that most projects will not turn
+on does not belong in everybody's bundle. The glue here is under 5 KB; rrweb is
+what you are actually installing.
+
+## Setup
+
+```bash
+npm install @nagoorkani/session-capture-vue-replay rrweb
+```
+
+```ts
+import { installReplay } from '@nagoorkani/session-capture-vue-replay'
+
+// After sessionCapture is installed, so the session is already open.
+installReplay({ endpoint: 'https://your-ingestion-host', apiKey: 'pk_live_…' })
+```
+
+Nothing records until remote config says so. `replayEnabled` and
+`replaySampleRate` are both off by default and live on the project's Settings
+page, because continuous recording is the most expensive thing this SDK does
+and a shipped page can only be stopped from the server. An unsampled session
+costs nothing — the recorder never starts.
+
+A session that hits an error is recorded whatever the sampling says, the same
+exemption errors get everywhere else here.
+
+## What is recorded
+
+rrweb's stream: one full snapshot of the DOM, then the mutations after it. The
+dashboard replays them to rebuild the page. Not screenshots — a browser cannot
+photograph itself, which is why this and the mobile package produce different
+data behind the same player.
+
+**Every input is masked before it is buffered.** Not a setting: § 32 says
+redaction happens in the SDK before anything is stored, and a DOM recording is
+the one capture path that would otherwise carry a password in plain text.
+
+Static text is *not* masked. Mark what should be:
+
+```ts
+installReplay({
+  endpoint, apiKey,
+  maskTextClass: 'sc-mask',   // text replaced with asterisks
+  blockClass: 'sc-block',     // element kept as a box, contents dropped
+})
+```
+
+Those are the defaults, so `<div class="sc-block">` works without configuring
+anything.
+
+## Delivery
+
+A segment every thirty seconds, or sooner if the buffer reaches 2 MB. The last
+one is sent with `keepalive` as the page goes away.
+
+**Segments are not persisted.** The mobile package keeps failed ones on disk
+because a phone loses connectivity for minutes at a time; a browser tab that
+has gone is gone, and its ~5 MB of `localStorage` is better spent on events —
+those are the bytes that reconstruct a timeline, and a lost segment costs
+pictures rather than facts. A failed send is retried once on the next tick and
+then dropped.
+
+rrweb's stream is only meaningful in order, so a lost segment breaks the replay
+from that point. A full snapshot is taken every two minutes to bound the
+damage: the recording resumes at the next one.
+
+## Size
+
+```bash
+pnpm --filter @nagoorkani/session-capture-vue-replay size
+```
+
+Measures this package only. rrweb and the SDK are external — including them
+would report the size of the recorder rather than of the glue.
+
+## License
+
+Proprietary — all rights reserved. See [LICENSE](./LICENSE). No use, copying,
+modification or distribution is permitted without a written agreement with the
+copyright holder.

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @nagoorkani/session-capture-vue-replay
+ *
+ * Optional DOM session replay, kept out of `@nagoorkani/session-capture-vue` so it costs
+ * nothing in bundle size for applications that do not want it (section 23).
+ * rrweb is several times the size of the SDK it attaches to, which is the
+ * whole reason this is a package of its own.
+ *
+ * Records a sampled session from start to finish, cutting a segment every
+ * thirty seconds. Which sessions those are is a remote-config decision —
+ * `replayEnabled` and `replaySampleRate`, both off by default — because
+ * continuous recording is the most expensive thing this SDK can do and a
+ * shipped page can only be stopped from the server.
+ *
+ * An unsampled session costs nothing: the recorder never starts.
+ */
+import { type RecorderOptions } from './recorder.ts';
+import { type UploadResult } from './upload.ts';
+export type { RecorderOptions, Segment } from './recorder.ts';
+export type { UploadResult } from './upload.ts';
+export interface ReplayOptions extends RecorderOptions {
+    /** Where to send segments. The same host as the SDK's `endpoint`. */
+    endpoint: string;
+    apiKey: string;
+    /**
+     * CSS class on elements to leave out of the recording entirely. Their shape
+     * is kept and their content is not.
+     */
+    blockClass?: string;
+    /** CSS class on elements whose text is replaced with asterisks. */
+    maskTextClass?: string;
+    /** Observes each upload. For diagnostics and the example app. */
+    onUpload?: (result: UploadResult, events: number) => void;
+}
+/**
+ * Start recording.
+ *
+ * Call after `sessionCapture` has been installed, and only in the browser —
+ * during server rendering there is no DOM to record and this does nothing.
+ */
+export declare const installReplay: (options: ReplayOptions) => void | undefined;
+/** Stop recording and unwind everything installed on the page. */
+export declare const stopReplay: () => void | undefined;
+/** Whether the open session is being recorded. */
+export declare const isRecording: () => boolean;

package/dist/index.js

@@ -0,0 +1,200 @@
+/**
+ * @nagoorkani/session-capture-vue-replay
+ *
+ * Optional DOM session replay, kept out of `@nagoorkani/session-capture-vue` so it costs
+ * nothing in bundle size for applications that do not want it (section 23).
+ * rrweb is several times the size of the SDK it attaches to, which is the
+ * whole reason this is a package of its own.
+ *
+ * Records a sampled session from start to finish, cutting a segment every
+ * thirty seconds. Which sessions those are is a remote-config decision —
+ * `replayEnabled` and `replaySampleRate`, both off by default — because
+ * continuous recording is the most expensive thing this SDK can do and a
+ * shipped page can only be stopped from the server.
+ *
+ * An unsampled session costs nothing: the recorder never starts.
+ */
+import { isSampled, ReplayGate, safe } from '@nagoorkani/session-capture-core';
+import { currentConfig, keepSessionAlive, onError, onSession, } from '@nagoorkani/session-capture-vue';
+import { record } from 'rrweb';
+import { Recorder } from "./recorder.js";
+import { uploadSegment } from "./upload.js";
+/** Set by `installReplay`; read by the flusher, which outlives one call. */
+const uploadOptions = {
+    endpoint: '',
+    apiKey: '',
+};
+let recorder = null;
+let flushTimer = null;
+let gateTimer = null;
+let pageHideListener = null;
+const unsubscribes = [];
+let gate = null;
+/** The session being recorded, or null when this one is not. */
+let recordingSession = null;
+/** Held for one more attempt when a send fails while the tab is still alive. */
+let retrying = [];
+let sending = false;
+/**
+ * How often the gate is asked, as opposed to how often a segment is cut.
+ *
+ * Two timers, and the difference matters. Remote config has not arrived when
+ * `installReplay` runs, so the first answer is always "wait" — and on the web
+ * a reload resumes the session rather than starting one, so the session hook
+ * that would have asked again never fires. Asking only on the flush tick would
+ * lose the first thirty seconds of every visit, which is the part that
+ * explains what the user was doing.
+ */
+const GATE_INTERVAL_MS = 2000;
+/**
+ * Start recording.
+ *
+ * Call after `sessionCapture` has been installed, and only in the browser —
+ * during server rendering there is no DOM to record and this does nothing.
+ */
+export const installReplay = safe((options) => {
+    if (recorder || typeof globalThis.document === 'undefined')
+        return;
+    uploadOptions.endpoint = options.endpoint;
+    uploadOptions.apiKey = options.apiKey;
+    uploadOptions.onUpload = options.onUpload;
+    recorder = new Recorder((emit) => record({
+        emit: (event) => emit(event),
+        // Every field a user types is masked before it is buffered. This is
+        // not a preference: § 32 says redaction happens in the SDK before
+        // anything is stored, and a DOM recording is the one capture path
+        // that would otherwise carry a password in plain text.
+        maskAllInputs: true,
+        blockClass: options.blockClass ?? 'sc-block',
+        maskTextClass: options.maskTextClass ?? 'sc-mask',
+        // A fresh full snapshot every two minutes. rrweb's stream is only
+        // meaningful in order, so without one a single lost or oversized
+        // segment would break every segment after it for the rest of the
+        // session; with one, the damage ends at the next checkout.
+        checkoutEveryNms: 2 * 60 * 1000,
+    }), options, 
+    // The buffer reached its ceiling before the timer did.
+    () => void flushNow());
+    gate = new ReplayGate(isSampled);
+    unsubscribes.push(onSession((sessionId) => {
+        // Whatever the previous session had buffered belongs to the previous
+        // session, so cut it before the id changes under it.
+        void flushNow();
+        gate?.open(sessionId);
+        recordingSession = null;
+        evaluate();
+    }));
+    // An error records regardless of sampling — the same exemption errors get
+    // everywhere else here — and flushes immediately, because an error often
+    // precedes the page being abandoned.
+    unsubscribes.push(onError((sessionId) => {
+        gate?.force(sessionId);
+        evaluate();
+        void flushNow();
+    }));
+    gateTimer = setInterval(evaluate, GATE_INTERVAL_MS);
+    gateTimer?.unref?.();
+    flushTimer = setInterval(() => {
+        evaluate();
+        void flushNow();
+    }, recorder.segmentMs);
+    flushTimer?.unref?.();
+    // The last cut. A hidden tab may never run again, and `keepalive` is the
+    // only request a browser promises to finish after the page is gone.
+    pageHideListener = () => void flushNow(true);
+    globalThis.addEventListener?.('pagehide', pageHideListener);
+    globalThis.addEventListener?.('visibilitychange', pageHideListener);
+    evaluate();
+}, undefined, 'installReplay');
+/** Stop recording and unwind everything installed on the page. */
+export const stopReplay = safe(() => {
+    for (const undo of unsubscribes.splice(0)) {
+        try {
+            undo();
+        }
+        catch {
+            // Teardown must never throw into the host page.
+        }
+    }
+    if (flushTimer)
+        clearInterval(flushTimer);
+    if (gateTimer)
+        clearInterval(gateTimer);
+    flushTimer = null;
+    gateTimer = null;
+    if (pageHideListener) {
+        globalThis.removeEventListener?.('pagehide', pageHideListener);
+        globalThis.removeEventListener?.('visibilitychange', pageHideListener);
+        pageHideListener = null;
+    }
+    recorder?.pause();
+    // Not merely stopped: § 36 — a kill switch that leaves screenshots of
+    // somebody's screen sitting in memory has not done its job.
+    recorder?.discard();
+    recorder = null;
+    gate?.reset();
+    gate = null;
+    recordingSession = null;
+    retrying = [];
+}, undefined, 'stopReplay');
+/** Whether the open session is being recorded. */
+export const isRecording = safe(() => recordingSession !== null && (recorder?.recording ?? false), false, 'isRecording');
+/** Ask the gate what this session should do, and act on the answer. */
+function evaluate() {
+    if (!gate || !recorder)
+        return;
+    const action = gate.evaluate(currentConfig());
+    switch (action.kind) {
+        case 'wait':
+            return;
+        case 'off':
+            recorder.pause();
+            recorder.discard();
+            retrying = [];
+            recordingSession = null;
+            return;
+        case 'skip':
+            recorder.pause();
+            recorder.discard();
+            recordingSession = null;
+            return;
+        case 'record':
+            recordingSession = action.sessionId;
+            recorder.start();
+    }
+}
+/**
+ * Cut a segment and send it.
+ *
+ * Recording is activity: a page nobody is clicking emits no events, so without
+ * this the session would idle out underneath the recorder and segments would
+ * arrive for a session the backend had already closed.
+ */
+async function flushNow(unloading = false) {
+    const active = recorder;
+    const sessionId = recordingSession;
+    if (!active || !sessionId || sending)
+        return;
+    const segment = [...retrying, ...active.take()];
+    retrying = [];
+    if (segment.length === 0)
+        return;
+    keepSessionAlive();
+    sending = true;
+    try {
+        const result = await uploadSegment({
+            endpoint: uploadOptions.endpoint,
+            apiKey: uploadOptions.apiKey,
+            sessionId,
+            keepalive: unloading,
+        }, segment);
+        // One more attempt on the next tick, then it is gone. Holding a failing
+        // segment forever is how an offline tab runs out of memory.
+        if (result.kind === 'failed' && !unloading)
+            retrying = segment;
+        uploadOptions.onUpload?.(result, segment.length);
+    }
+    finally {
+        sending = false;
+    }
+}

package/dist/recorder.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Recording the DOM, and cutting it into segments.
+ *
+ * A browser cannot photograph itself, so a web recording is not pictures: it
+ * is rrweb's stream of one full snapshot followed by mutations. The player
+ * replays them to rebuild what the user saw.
+ *
+ * `record` is injected rather than imported, exactly as the mobile recorder
+ * takes its screenshot function: it keeps this module testable in Node, where
+ * there is no DOM and no rrweb, and it is the seam that decides masking.
+ */
+export interface RecordedEvent {
+    /** rrweb stamps each event with the device clock. Display only, as ever. */
+    timestamp?: number;
+    [key: string]: unknown;
+}
+/** What rrweb's `record` is, reduced to what this uses. */
+export type RecordFn = (emit: (event: RecordedEvent) => void) => (() => void) | undefined;
+export interface Segment {
+    timestamp: number;
+    payload: Uint8Array;
+}
+export interface RecorderOptions {
+    /**
+     * How much of the stream one upload carries. Thirty seconds, matching the
+     * mobile package: long enough that a page's chatter is not one request per
+     * mutation, short enough that closing the tab loses little.
+     */
+    seconds?: number;
+    /**
+     * Bytes buffered before a segment is cut early.
+     *
+     * The ceiling exists twice over: ingestion refuses an upload above 8 MB, and
+     * a page that mutates heavily would otherwise hold megabytes of DOM in
+     * memory between ticks.
+     */
+    maxSegmentBytes?: number;
+}
+export declare class Recorder {
+    private readonly record;
+    private readonly maxSegmentBytes;
+    private readonly onSegmentFull;
+    private readonly encoder;
+    private stop;
+    private buffered;
+    private bufferedBytes;
+    private droppedCount;
+    readonly segmentMs: number;
+    constructor(record: RecordFn, options: RecorderOptions, onSegmentFull: () => void);
+    get recording(): boolean;
+    /** Events discarded for being individually too large to send. */
+    get dropped(): number;
+    start(): void;
+    /** Stop recording. Anything already buffered stays until it is taken. */
+    pause(): void;
+    /** Take everything buffered, leaving the recorder empty and still running. */
+    take(): Segment[];
+    /** Throw away what is buffered — a kill switch, or consent withdrawn. */
+    discard(): void;
+    private push;
+}

package/dist/recorder.js

@@ -0,0 +1,96 @@
+/**
+ * Recording the DOM, and cutting it into segments.
+ *
+ * A browser cannot photograph itself, so a web recording is not pictures: it
+ * is rrweb's stream of one full snapshot followed by mutations. The player
+ * replays them to rebuild what the user saw.
+ *
+ * `record` is injected rather than imported, exactly as the mobile recorder
+ * takes its screenshot function: it keeps this module testable in Node, where
+ * there is no DOM and no rrweb, and it is the seam that decides masking.
+ */
+const DEFAULTS = {
+    seconds: 30,
+    maxSegmentBytes: 2 * 1024 * 1024,
+};
+/**
+ * One event larger than this cannot be sent — ingestion's per-frame limit is
+ * 4 MB — so it is dropped rather than poisoning the segment it is in.
+ *
+ * ponytail: dropping one event breaks the replay from that point, because
+ * rrweb's stream is only meaningful in order. The alternative is an upload
+ * rejected whole, which breaks it just as badly and wastes the request. A
+ * periodic checkout is what recovers: the next full snapshot starts again.
+ */
+const MAX_EVENT_BYTES = 4 * 1024 * 1024;
+export class Recorder {
+    constructor(record, options, onSegmentFull) {
+        this.encoder = new TextEncoder();
+        this.buffered = [];
+        this.bufferedBytes = 0;
+        this.droppedCount = 0;
+        this.record = record;
+        this.segmentMs = Math.max(1000, (options.seconds ?? DEFAULTS.seconds) * 1000);
+        this.maxSegmentBytes = options.maxSegmentBytes ?? DEFAULTS.maxSegmentBytes;
+        this.onSegmentFull = onSegmentFull;
+    }
+    get recording() {
+        return this.stop !== undefined;
+    }
+    /** Events discarded for being individually too large to send. */
+    get dropped() {
+        return this.droppedCount;
+    }
+    start() {
+        if (this.stop)
+            return;
+        this.stop = this.record((event) => this.push(event)) ?? (() => { });
+    }
+    /** Stop recording. Anything already buffered stays until it is taken. */
+    pause() {
+        try {
+            this.stop?.();
+        }
+        catch {
+            // rrweb's own teardown must not throw into the host page.
+        }
+        this.stop = undefined;
+    }
+    /** Take everything buffered, leaving the recorder empty and still running. */
+    take() {
+        const segment = this.buffered;
+        this.buffered = [];
+        this.bufferedBytes = 0;
+        return segment;
+    }
+    /** Throw away what is buffered — a kill switch, or consent withdrawn. */
+    discard() {
+        this.buffered = [];
+        this.bufferedBytes = 0;
+    }
+    push(event) {
+        let payload;
+        try {
+            payload = this.encoder.encode(JSON.stringify(event));
+        }
+        catch {
+            // A circular or unserializable event. rrweb does not produce one, but a
+            // recorder must not throw into the page it is watching.
+            return;
+        }
+        if (payload.byteLength > MAX_EVENT_BYTES) {
+            this.droppedCount += 1;
+            return;
+        }
+        this.buffered.push({
+            timestamp: typeof event.timestamp === 'number' ? event.timestamp : Date.now(),
+            payload,
+        });
+        this.bufferedBytes += payload.byteLength;
+        if (this.bufferedBytes >= this.maxSegmentBytes) {
+            // Cut now rather than at the next tick: the ceiling is about memory and
+            // the upload limit, and both are reached before the timer is.
+            this.onSegmentFull();
+        }
+    }
+}

package/dist/upload.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Sending a segment.
+ *
+ * One attempt, no retry and no queue. The mobile package keeps failed segments
+ * on disk because a phone loses connectivity for minutes at a time; a browser
+ * tab that has gone is gone, and its ~5 MB of `localStorage` is better spent
+ * on events than on DOM snapshots — those are the bytes that reconstruct a
+ * timeline, and a lost segment costs pictures rather than facts.
+ *
+ * ponytail: in-memory only, so a segment that fails while the tab lives is
+ * retried once on the next tick and then dropped. Persist it when someone
+ * shows a recording worth the quota.
+ */
+import type { Segment } from './recorder.ts';
+export interface UploadOptions {
+    endpoint: string;
+    apiKey: string;
+    sessionId: string;
+    fetchImpl?: typeof fetch;
+    /** Ask the browser to finish this one after the page is gone. */
+    keepalive?: boolean;
+}
+export type UploadResult = {
+    kind: 'sent';
+    events: number;
+} | {
+    kind: 'skipped';
+    reason: string;
+} | {
+    kind: 'failed';
+    reason: string;
+};
+export declare function uploadSegment(options: UploadOptions, segment: readonly Segment[]): Promise<UploadResult>;

package/dist/upload.js

@@ -0,0 +1,47 @@
+/**
+ * Sending a segment.
+ *
+ * One attempt, no retry and no queue. The mobile package keeps failed segments
+ * on disk because a phone loses connectivity for minutes at a time; a browser
+ * tab that has gone is gone, and its ~5 MB of `localStorage` is better spent
+ * on events than on DOM snapshots — those are the bytes that reconstruct a
+ * timeline, and a lost segment costs pictures rather than facts.
+ *
+ * ponytail: in-memory only, so a segment that fails while the tab lives is
+ * retried once on the next tick and then dropped. Persist it when someone
+ * shows a recording worth the quota.
+ */
+import { encodeContainer, MAGIC_DOM } from '@nagoorkani/session-capture-core';
+export async function uploadSegment(options, segment) {
+    if (segment.length === 0)
+        return { kind: 'skipped', reason: 'no events' };
+    if (!options.sessionId) {
+        // Without a session there is nothing to attach the recording to, and the
+        // server would reject it anyway.
+        return { kind: 'skipped', reason: 'no session' };
+    }
+    const base = options.endpoint.replace(/\/$/, '');
+    // The same endpoint the mobile package uses. What differs is the container's
+    // magic — everything between here and the player treats a frame as opaque
+    // bytes with a timestamp, so one intake serves both.
+    const url = `${base}/v1/mobile/replay?sessionId=${encodeURIComponent(options.sessionId)}`;
+    const doFetch = options.fetchImpl ?? fetch;
+    try {
+        const body = encodeContainer(MAGIC_DOM, segment);
+        const response = await doFetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/octet-stream',
+                authorization: `Bearer ${options.apiKey}`,
+            },
+            body: body,
+            keepalive: options.keepalive === true,
+        });
+        return response.ok
+            ? { kind: 'sent', events: segment.length }
+            : { kind: 'failed', reason: `http ${response.status}` };
+    }
+    catch (err) {
+        return { kind: 'failed', reason: err instanceof Error ? err.message : 'network error' };
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@nagoorkani/session-capture-vue-replay",
+  "version": "0.1.0",
+  "description": "Optional DOM session replay for @nagoorkani/session-capture-vue",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@nagoorkani/session-capture-core": "0.1.0"
+  },
+  "peerDependencies": {
+    "rrweb": "^2.0.0",
+    "@nagoorkani/session-capture-vue": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "esbuild": "^0.24.2",
+    "rrweb": "^2.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=22.6"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nagoorkani2393/session-capture.git",
+    "directory": "sdk/vue-replay"
+  },
+  "homepage": "https://github.com/Nagoorkani2393/session-capture/tree/main/sdk/vue-replay#readme",
+  "bugs": {
+    "url": "https://github.com/Nagoorkani2393/session-capture/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test --experimental-strip-types \"src/**/*.test.ts\"",
+    "size": "node scripts/size.mjs"
+  }
+}