@peekling/runtime 0.1.0

package/dist/contracts.d.ts

@@ -0,0 +1,10 @@
+export declare const NAME_PATTERN: RegExp;
+export declare const EVENT_NAME_PATTERN: RegExp;
+export declare const STATE_NAME_PATTERN: RegExp;
+export declare const SEMVER_PATTERN: RegExp;
+export declare const SPDX_LICENSE_PATTERN: RegExp;
+export declare const ASSET_PATH_PATTERN: RegExp;
+export declare const SURFACE_COLOR_PATTERN: RegExp;
+export declare function isSurfaceColor(value: unknown): value is string;
+export declare function isHttpPath(value: unknown, base: string): value is string;
+//# sourceMappingURL=contracts.d.ts.map

package/dist/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../src/contracts.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,QAAyC,CAAC;AACnE,eAAO,MAAM,kBAAkB,QAC0B,CAAC;AAC1D,eAAO,MAAM,kBAAkB,QACsB,CAAC;AACtD,eAAO,MAAM,cAAc,QAC2G,CAAC;AACvI,eAAO,MAAM,oBAAoB,QAC4F,CAAC;AAC9H,eAAO,MAAM,kBAAkB,QACwC,CAAC;AACxE,eAAO,MAAM,qBAAqB,QACgD,CAAC;AAEnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAE9D;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,KAAK,IAAI,MAAM,CA+CxE"}

package/dist/contracts.js

@@ -0,0 +1,106 @@
+export const NAME_PATTERN = /^(?!peekling:)[a-z][a-z0-9:-]{0,63}$/;
+export const EVENT_NAME_PATTERN = /^(?=.{1,64}$)[a-z][a-z0-9]*(?:[.:-][a-z][a-z0-9-]*)*$/;
+export const STATE_NAME_PATTERN = /^(?=.{1,64}$)[a-z][a-z0-9-]*(?::[A-Za-z0-9.-]+)?$/;
+export const SEMVER_PATTERN = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+export const SPDX_LICENSE_PATTERN = /^(?:[A-Za-z0-9][A-Za-z0-9.-]{0,63}|DocumentRef-[A-Za-z0-9][A-Za-z0-9.-]{0,31}:LicenseRef-[A-Za-z0-9][A-Za-z0-9.-]{0,31})$/;
+export const ASSET_PATH_PATTERN = /^(?!\/)(?!.*(?:^|\/)\.\.?(?:\/|$))(?!.*\/\/)[A-Za-z0-9._/-]{1,256}$/;
+export const SURFACE_COLOR_PATTERN = /^(?:transparent|#(?:[0-9A-Fa-f]{3,4}|[0-9A-Fa-f]{6}|[0-9A-Fa-f]{8}))(?![\s\S])/;
+export function isSurfaceColor(value) {
+    return typeof value === "string" && SURFACE_COLOR_PATTERN.test(value);
+}
+export function isHttpPath(value, base) {
+    if (typeof value !== "string" ||
+        value.length < 1 ||
+        value.length > 2_048 ||
+        /[\s\u0000-\u001f\u007f-\u009f\\]/u.test(value) ||
+        /%(?![0-9A-Fa-f]{2})/.test(value)) {
+        return false;
+    }
+    const absoluteHttps = /^https:\/\//i.test(value);
+    if ((!absoluteHttps && /^[A-Za-z][A-Za-z0-9+.-]*:/.test(value)) ||
+        value.startsWith("//") ||
+        (absoluteHttps && !validHttpsAuthority(value))) {
+        return false;
+    }
+    try {
+        if (absoluteHttps) {
+            const resolved = new URL(value);
+            return (resolved.protocol === "https:" &&
+                !resolved.username &&
+                !resolved.password &&
+                hasCanonicalHttpsHostname(value, resolved.hostname));
+        }
+        const baseUrl = new URL(base);
+        if ((baseUrl.protocol !== "https:" && baseUrl.protocol !== "http:") ||
+            baseUrl.username ||
+            baseUrl.password ||
+            !validParsedHostname(baseUrl.hostname)) {
+            return false;
+        }
+        const resolved = new URL(value, baseUrl);
+        return (!resolved.username &&
+            !resolved.password &&
+            (resolved.protocol === "https:" || resolved.protocol === "http:") &&
+            resolved.origin === baseUrl.origin);
+    }
+    catch {
+        return false;
+    }
+}
+function hasCanonicalHttpsHostname(value, parsed) {
+    const remainder = value.slice(8);
+    const boundary = remainder.search(/[/?#]/);
+    const authority = boundary < 0 ? remainder : remainder.slice(0, boundary);
+    if (authority.startsWith("["))
+        return true;
+    const colon = authority.indexOf(":");
+    const hostname = colon < 0 ? authority : authority.slice(0, colon);
+    return hostname.toLowerCase() === parsed.toLowerCase();
+}
+function validHttpsAuthority(value) {
+    const remainder = value.slice(8);
+    const boundary = remainder.search(/[/?#]/);
+    const authority = boundary < 0 ? remainder : remainder.slice(0, boundary);
+    if (!authority || authority.includes("@") || authority.includes("%")) {
+        return false;
+    }
+    if (authority.startsWith("[")) {
+        const close = authority.indexOf("]");
+        if (close < 2 ||
+            authority.indexOf("[", 1) >= 0 ||
+            authority.indexOf("]", close + 1) >= 0 ||
+            !validPortSuffix(authority.slice(close + 1))) {
+            return false;
+        }
+        return true;
+    }
+    const firstColon = authority.indexOf(":");
+    const lastColon = authority.lastIndexOf(":");
+    if (firstColon !== lastColon)
+        return false;
+    const hostname = firstColon < 0 ? authority : authority.slice(0, firstColon);
+    const suffix = firstColon < 0 ? "" : authority.slice(firstColon);
+    return validAsciiHostname(hostname) && validPortSuffix(suffix);
+}
+function validPortSuffix(value) {
+    if (value === "")
+        return true;
+    if (!/^:[0-9]{1,5}$/.test(value))
+        return false;
+    return Number(value.slice(1)) <= 65_535;
+}
+function validParsedHostname(value) {
+    return value.startsWith("[")
+        ? value.endsWith("]")
+        : validAsciiHostname(value);
+}
+function validAsciiHostname(value) {
+    if (!value || value.length > 253 || value.endsWith("."))
+        return false;
+    const labels = value.split(".");
+    if (labels.every((label) => /^[0-9]+$/.test(label))) {
+        return (labels.length === 4 &&
+            labels.every((label) => /^(?:0|[1-9][0-9]{0,2})$/.test(label) && Number(label) <= 255));
+    }
+    return labels.every((label) => /^(?:[A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9-]{0,61}[A-Za-z0-9])$/.test(label));
+}

package/dist/defaults.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_FORMAT: 1;
+export declare const DEFAULT_MAX_DENSITY: 4;
+export declare const DEFAULT_POSITION: "bottom-right";
+export declare const DEFAULT_NATIVE_SCALE = 2;
+export declare const DEFAULT_SPEED = 160;
+export declare const DEFAULT_PERSISTENT_REQUEST_LIMIT = 3600000;
+//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.d.ts","sourceRoot":"","sources":["../src/defaults.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,EAAG,CAAU,CAAC;AACzC,eAAO,MAAM,mBAAmB,EAAG,CAAU,CAAC;AAC9C,eAAO,MAAM,gBAAgB,EAAG,cAAuB,CAAC;AACxD,eAAO,MAAM,oBAAoB,IAAI,CAAC;AACtC,eAAO,MAAM,aAAa,MAAM,CAAC;AACjC,eAAO,MAAM,gCAAgC,UAAY,CAAC"}

package/dist/defaults.js

@@ -0,0 +1,6 @@
+export const DEFAULT_FORMAT = 1;
+export const DEFAULT_MAX_DENSITY = 4;
+export const DEFAULT_POSITION = "bottom-right";
+export const DEFAULT_NATIVE_SCALE = 2;
+export const DEFAULT_SPEED = 160;
+export const DEFAULT_PERSISTENT_REQUEST_LIMIT = 3_600_000;

package/dist/diagnostics.d.ts

@@ -0,0 +1,25 @@
+import type { DiagnosticRecord, DiagnosticSeverity } from "./types.js";
+export interface DiagnosticInput {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    phase: DiagnosticRecord["phase"];
+    overrideId?: string;
+    eventId?: number;
+    metadata?: Readonly<Record<string, string | number | boolean>>;
+    cause?: unknown;
+}
+export declare class DiagnosticChannel {
+    #private;
+    constructor(options: {
+        instanceId: string;
+        now: () => number;
+        logger?: (record: Readonly<DiagnosticRecord>) => void;
+        messageSink?: (message: string) => void;
+        context?: Readonly<Record<string, string | number | boolean>>;
+        debug?: boolean;
+        console?: boolean;
+    });
+    emit(input: Readonly<DiagnosticInput>): DiagnosticRecord | undefined;
+}
+//# sourceMappingURL=diagnostics.d.ts.map

package/dist/diagnostics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnostics.d.ts","sourceRoot":"","sources":["../src/diagnostics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAWvE,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;IAC/D,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,qBAAa,iBAAiB;;IAe5B,YAAY,OAAO,EAAE;QACnB,UAAU,EAAE,MAAM,CAAC;QACnB,GAAG,EAAE,MAAM,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,QAAQ,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAC;QACtD,WAAW,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;QACxC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC;QAC9D,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,OAAO,CAAC,EAAE,OAAO,CAAC;KACnB,EAQA;IAED,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,gBAAgB,GAAG,SAAS,CAyCnE;CA4CF"}

package/dist/diagnostics.js

@@ -0,0 +1,122 @@
+import { compactRuntimeDiagnostics } from "./runtime-diagnostics.js";
+const DIAGNOSTIC_WINDOW_MS = 60_000;
+const DIAGNOSTIC_LIMIT = 64;
+const DIAGNOSTIC_ERROR_RESERVE = 8;
+export class DiagnosticChannel {
+    #instanceId;
+    #now;
+    #logger;
+    #messageSink;
+    #context;
+    #debug;
+    #console;
+    #sequence = 0;
+    #window = [];
+    #overflowErrors = [];
+    #rateLimitSignal;
+    #logging = false;
+    constructor(options) {
+        this.#instanceId = options.instanceId;
+        this.#now = options.now;
+        this.#logger = options.logger;
+        this.#messageSink = options.messageSink;
+        this.#context = options.context;
+        this.#debug = options.debug === true;
+        this.#console = options.console;
+    }
+    emit(input) {
+        const now = this.#now();
+        this.#window = this.#window.filter((time) => now - time < DIAGNOSTIC_WINDOW_MS);
+        this.#overflowErrors = this.#overflowErrors.filter((time) => now - time < DIAGNOSTIC_WINDOW_MS);
+        if (this.#rateLimitSignal !== undefined &&
+            now - this.#rateLimitSignal >= DIAGNOSTIC_WINDOW_MS) {
+            this.#rateLimitSignal = undefined;
+        }
+        if (this.#logging)
+            return undefined;
+        if (this.#window.length >= DIAGNOSTIC_LIMIT) {
+            if (this.#rateLimitSignal === undefined) {
+                this.#rateLimitSignal = now;
+                this.#deliver({
+                    code: "diagnostics.rate-limited",
+                    severity: "warning",
+                    message: "Diagnostic output was rate limited",
+                    phase: "internal",
+                    metadata: {
+                        windowMs: DIAGNOSTIC_WINDOW_MS,
+                        recordLimit: DIAGNOSTIC_LIMIT,
+                        errorReserve: DIAGNOSTIC_ERROR_RESERVE,
+                    },
+                });
+            }
+            if (input.severity !== "error" ||
+                this.#overflowErrors.length >= DIAGNOSTIC_ERROR_RESERVE) {
+                return undefined;
+            }
+            this.#overflowErrors.push(now);
+            return this.#deliver(input);
+        }
+        this.#window.push(now);
+        return this.#deliver(input);
+    }
+    #deliver(input) {
+        const record = {
+            code: input.code,
+            severity: input.severity,
+            message: sanitizeMessage(input.message),
+            phase: input.phase,
+            sequence: ++this.#sequence,
+            timestamp: Date.now(),
+            instanceId: this.#instanceId,
+        };
+        if (input.overrideId)
+            record.overrideId = input.overrideId;
+        if (input.eventId !== undefined)
+            record.eventId = input.eventId;
+        if (input.metadata)
+            record.metadata = input.metadata;
+        if (this.#context)
+            record.context = this.#context;
+        if (this.#debug && input.cause)
+            record.cause = diagnosticCause(input.cause);
+        this.#logging = true;
+        try {
+            try {
+                this.#messageSink?.(record.message);
+            }
+            catch { }
+            try {
+                this.#logger?.(record);
+            }
+            catch { }
+        }
+        finally {
+            this.#logging = false;
+        }
+        if (!this.#messageSink &&
+            !this.#logger &&
+            (this.#console === true ||
+                (this.#console === undefined && record.severity === "error"))) {
+            console.warn(`[Peekling] ${record.message}${compactRuntimeDiagnostics && record.severity === "error"
+                ? " (use peekling.js for details)"
+                : ""}`);
+        }
+        return record;
+    }
+}
+function sanitizeMessage(value) {
+    return value
+        .replace(/https?:\/\/[^\s]+/gi, "[redacted-url]")
+        .replace(/\b(token|secret|password|authorization)=\S+/gi, "$1=[redacted]")
+        .slice(0, 500);
+}
+function diagnosticCause(value) {
+    if (value instanceof Error) {
+        return {
+            name: value.name.slice(0, 80),
+            message: value.message.slice(0, 500),
+            ...(value.stack ? { stack: value.stack.slice(0, 4_000) } : {}),
+        };
+    }
+    return { name: "Error", message: String(value).slice(0, 500) };
+}

package/dist/direction.d.ts

@@ -0,0 +1,3 @@
+import type { Direction, Point } from "./types.js";
+export declare function directionTo(from: Point, to: Point): Direction;
+//# sourceMappingURL=direction.d.ts.map

package/dist/direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direction.d.ts","sourceRoot":"","sources":["../src/direction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAInD,wBAAgB,WAAW,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,GAAG,SAAS,CAI7D"}

package/dist/direction.js

@@ -0,0 +1,6 @@
+const OCTANTS = ["E", "SE", "S", "SW", "W", "NW", "N", "NE"];
+export function directionTo(from, to) {
+    const angle = Math.atan2(to.y - from.y, to.x - from.x);
+    const octant = (Math.round(angle / (Math.PI / 4)) + 8) % 8;
+    return OCTANTS[octant];
+}

package/dist/errors.d.ts

@@ -0,0 +1,15 @@
+export type PackLoadFailureCategory = "abort" | "decode" | "hash" | "http" | "image" | "integrity" | "mime" | "network" | "size" | "timeout" | "validation";
+export declare class PackLoadError extends Error {
+    readonly code: string;
+    readonly category: PackLoadFailureCategory;
+    constructor(code: string, category: PackLoadFailureCategory, message: string, cause?: unknown);
+}
+export declare function packIssue(code: string, detail: string): string;
+export declare function addPackIssue(issues: string[], code: string, detail: string): void;
+export declare function throwPackIssue(code: string, detail: string): never;
+export declare class PackValidationError extends Error {
+    readonly issues: readonly string[];
+    readonly issueCodes: readonly string[];
+    constructor(issues: readonly string[], issueCodes?: readonly string[]);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,uBAAuB,GAC/B,OAAO,GACP,QAAQ,GACR,MAAM,GACN,MAAM,GACN,OAAO,GACP,WAAW,GACX,MAAM,GACN,SAAS,GACT,MAAM,GACN,SAAS,GACT,YAAY,CAAC;AAEjB,qBAAa,aAAc,SAAQ,KAAK;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAE3C,YACE,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,uBAAuB,EACjC,OAAO,EAAE,MAAM,EACf,KAAK,CAAC,EAAE,OAAO,EAMhB;CACF;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK9D;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EAAE,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,IAAI,CAEN;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,CAElE;AAED,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC,YAAY,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,UAAU,GAAE,SAAS,MAAM,EAAO,EA6BxE;CACF"}

package/dist/errors.js

@@ -0,0 +1,53 @@
+import { compactRuntimeDiagnostics, runtimeMessage, } from "./runtime-diagnostics.js";
+const ISSUE_CODE_SEPARATOR = "\0";
+export class PackLoadError extends Error {
+    code;
+    category;
+    constructor(code, category, message, cause) {
+        super(message, { cause });
+        this.name = "PackLoadError";
+        this.code = code;
+        this.category = category;
+    }
+}
+export function packIssue(code, detail) {
+    const message = runtimeMessage(code, detail);
+    return compactRuntimeDiagnostics
+        ? message
+        : `${message}${ISSUE_CODE_SEPARATOR}${code}`;
+}
+export function addPackIssue(issues, code, detail) {
+    issues.push(packIssue(code, detail));
+}
+export function throwPackIssue(code, detail) {
+    throw new PackValidationError([packIssue(code, detail)]);
+}
+export class PackValidationError extends Error {
+    issues;
+    issueCodes;
+    constructor(issues, issueCodes = []) {
+        let publicIssues = issues;
+        let decodedCodes = issues;
+        if (!compactRuntimeDiagnostics) {
+            const messages = [];
+            const codes = [];
+            for (const issue of issues) {
+                const separator = issue.lastIndexOf(ISSUE_CODE_SEPARATOR);
+                if (separator < 0) {
+                    messages.push(issue);
+                }
+                else {
+                    const code = issue.slice(separator + 1);
+                    messages.push(separator ? issue.slice(0, separator) : code);
+                    codes.push(code);
+                }
+            }
+            publicIssues = messages;
+            decodedCodes = codes;
+        }
+        super(runtimeMessage(`pack:${publicIssues.join(",")}`, () => `Invalid Peekling character pack:\n- ${publicIssues.join("\n- ")}`));
+        this.name = "PackValidationError";
+        this.issues = publicIssues;
+        this.issueCodes = issueCodes.length ? issueCodes : decodedCodes;
+    }
+}

package/dist/events.d.ts

@@ -0,0 +1,5 @@
+import type { JsonValue, PlanBrowserEvent } from "./types.js";
+export declare function browserCompletionEvent(name: string): PlanBrowserEvent | undefined;
+export declare function isContinuousBrowserEvent(name: string): boolean;
+export declare function validateEventPayload(input: unknown): JsonValue | undefined;
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAgB9D,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,MAAM,GACX,gBAAgB,GAAG,SAAS,CAW9B;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAgD1E"}

package/dist/events.js

@@ -0,0 +1,60 @@
+import { OwnDataError, snapshotOwnData } from "./own-data.js";
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const EVENT_KEY = /^[A-Za-z0-9_.:-]{1,64}$/;
+const EVENT_PAYLOAD_POLICY = Object.freeze({
+    json: true,
+    key: (value) => EVENT_KEY.test(value),
+    maxArrayLength: 64,
+    maxDepth: 6,
+    maxObjectKeys: 64,
+    maxStringLength: 2_048,
+    maxValues: 256,
+});
+let eventPayloadEncoder;
+export function browserCompletionEvent(name) {
+    switch (name) {
+        case "pointer.click":
+        case "document.visibility":
+        case "window.focus":
+        case "window.scroll":
+        case "page.lifecycle":
+            return name;
+        default:
+            return undefined;
+    }
+}
+export function isContinuousBrowserEvent(name) {
+    return name === "pointer.move" || name === "section.visibility";
+}
+export function validateEventPayload(input) {
+    if (input === undefined)
+        return undefined;
+    let result;
+    try {
+        result = snapshotOwnData(input, EVENT_PAYLOAD_POLICY);
+    }
+    catch (cause) {
+        if (cause instanceof OwnDataError) {
+            switch (cause.issueCode) {
+                case "data.array":
+                    throw new TypeError(runtimeMessage("event.array-limit", "Event array exceeds 64 items"));
+                case "data.cycle":
+                case "data.depth":
+                case "data.nodes":
+                    throw new TypeError(runtimeMessage("event.complexity", "Event payload is too complex"));
+                case "data.key":
+                    throw new TypeError(runtimeMessage("event.key", "Event payload key is invalid"));
+                case "data.keys":
+                    throw new TypeError(runtimeMessage("event.key-limit", "Event object exceeds 64 keys"));
+                case "data.string":
+                    throw new TypeError(runtimeMessage("event.string-limit", "Event payload string exceeds 2048 characters"));
+            }
+        }
+        throw new TypeError(runtimeMessage("event.payload", "Event payload must be JSON-like data"));
+    }
+    if ((eventPayloadEncoder ??= new TextEncoder()).encode(JSON.stringify(result))
+        .byteLength > 8_192) {
+        throw new TypeError(runtimeMessage("event.size", "Event payload exceeds 8 KiB"));
+    }
+    return result;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { hatch, type PeeklingFinishReason, type PeeklingFinishResult, type PeeklingHatchInput, type PeeklingInstance, type PeeklingOptions, type PeeklingPackSelection, type PeeklingPosition, } from "./runtime.js";
+export { hidePeekling, isPeeklingHidden, showPeekling, type PeeklingHideDuration, } from "./visibility.js";
+export type { RuntimeStyleAsset } from "./styles.js";
+export { definePeeklingElement, PEEKLING_ELEMENT_TAG, type PeeklingElement, } from "./web-component.js";
+export type { ContentRegion, DiagnosticRecord, DiagnosticSeverity, Direction, EmitResult, HostBindings, HostContent, HostContentItem, HostContentPrimitive, HostContentSurface, HostSurfaceMount, HostSurfaceMountContext, HostSurfaceMountResult, JsonValue, NativeDensity, NativeManifest, NormalizedPack, Plan, PlanBrowserEvent, PlanCapability, PlanChannel, PlanCondition, PlanDisposition, PlanEffect, PlanEventSource, PlanMotionEffect, PlanRule, PlanStateSelection, PlanSurfaceEffect, PlanSurfaceOrdering, OverrideCompletionReason, OverrideHandle, OverrideInput, OverrideLifetime, OverrideResult, OverrideStatus, StateDefinition, SurfaceTheme, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,kBAAkB,EACvB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,gBAAgB,GACtB,MAAM,cAAc,CAAC;AACtB,OAAO,EACL,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACZ,KAAK,oBAAoB,GAC1B,MAAM,iBAAiB,CAAC;AACzB,YAAY,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EACL,qBAAqB,EACrB,oBAAoB,EACpB,KAAK,eAAe,GACrB,MAAM,oBAAoB,CAAC;AAC5B,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,SAAS,EACT,UAAU,EACV,YAAY,EACZ,WAAW,EACX,eAAe,EACf,oBAAoB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,uBAAuB,EACvB,sBAAsB,EACtB,SAAS,EACT,aAAa,EACb,cAAc,EACd,cAAc,EACd,IAAI,EACJ,gBAAgB,EAChB,cAAc,EACd,WAAW,EACX,aAAa,EACb,eAAe,EACf,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,QAAQ,EACR,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,wBAAwB,EACxB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,eAAe,EACf,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,3 @@
+export { hatch, } from "./runtime.js";
+export { hidePeekling, isPeeklingHidden, showPeekling, } from "./visibility.js";
+export { definePeeklingElement, PEEKLING_ELEMENT_TAG, } from "./web-component.js";

package/dist/input.d.ts

@@ -0,0 +1,31 @@
+import type { JsonValue, PlanBrowserEvent, PlanEventSource, Point, ReactionEvent } from "./types.js";
+export declare class InputCollector {
+    #private;
+    pointer: Point | undefined;
+    readonly reactions: ReactionEvent[];
+    lastActivityAt: number;
+    constructor(document: Document, window: Window, options: {
+        events: ReadonlySet<PlanBrowserEvent>;
+        coalesce?: ReadonlyMap<string, true | {
+            sessionField: string;
+            revisionField: string;
+        }>;
+        diagnostic?: (message: string) => void;
+        now: () => number;
+        wake: () => void;
+    });
+    get reaction(): ReactionEvent | undefined;
+    captureReaction(name: string, payload?: JsonValue, source?: PlanEventSource): {
+        accepted: true;
+        id: number;
+        coalesced: boolean;
+    } | {
+        accepted: false;
+        reason: "queue-full";
+    };
+    consumeReaction(id: number): void;
+    retainEvent(event: PlanBrowserEvent): () => void;
+    setSuspended(value: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=input.d.ts.map

package/dist/input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input.d.ts","sourceRoot":"","sources":["../src/input.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,KAAK,EACL,aAAa,EACd,MAAM,YAAY,CAAC;AAWpB,qBAAa,cAAc;;IACzB,OAAO,EAAE,KAAK,GAAG,SAAS,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,aAAa,EAAE,CAAM;IACzC,cAAc,EAAE,MAAM,CAAC;IAkBvB,YACE,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE;QACP,MAAM,EAAE,WAAW,CAAC,gBAAgB,CAAC,CAAC;QACtC,QAAQ,CAAC,EAAE,WAAW,CACpB,MAAM,EACN,IAAI,GAAG;YAAE,YAAY,EAAE,MAAM,CAAC;YAAC,aAAa,EAAE,MAAM,CAAA;SAAE,CACvD,CAAC;QACF,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;QACvC,GAAG,EAAE,MAAM,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,IAAI,CAAC;KAClB,EAYF;IAED,IAAI,QAAQ,IAAI,aAAa,GAAG,SAAS,CAExC;IAED,eAAe,CACb,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,SAAS,EACnB,MAAM,GAAE,eAA+B,GAErC;QAAE,QAAQ,EAAE,IAAI,CAAC;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,GAClD;QAAE,QAAQ,EAAE,KAAK,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,CAiC5C;IAED,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAEhC;IAED,WAAW,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAQ/C;IAED,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAajC;IAED,OAAO,IAAI,IAAI,CAOd;CAkIF"}