@peekling/runtime 0.1.0

package/dist/plan.d.ts

@@ -0,0 +1,21 @@
+import { type CompiledPlan, type PlanEventEvaluation } from "./plan-compiler.js";
+import { type BehaviorRequest, type Plan, type World } from "./types.js";
+export declare function compiledPlanSectionRequirements(plan: CompiledPlan): {
+    selectors: readonly string[];
+    thresholds: readonly number[];
+};
+/** The engine-owned default Plan policy. It uses the public Plan shape. */
+export declare function createDefaultPlan(locomotion: boolean): Plan;
+/** Instance-owned evaluator for one immutable compiled Plan. */
+export declare class PlanRuntime {
+    #private;
+    constructor(plan: CompiledPlan);
+    get plan(): CompiledPlan;
+    get lastEventStatus(): PlanEventEvaluation["status"] | undefined;
+    get lastEventRejections(): PlanEventEvaluation["rejectedSurfaces"];
+    evaluate(world: Readonly<World>): BehaviorRequest;
+    reset(): void;
+    nextWakeAt(): number | undefined;
+    rebase(delta: number): void;
+}
+//# sourceMappingURL=plan.d.ts.map

package/dist/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../src/plan.ts"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,YAAY,EAGjB,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,IAAI,EAGT,KAAK,KAAK,EACX,MAAM,YAAY,CAAC;AAEpB,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,YAAY,GAAG;IACnE,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAC7B,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,CAgBA;AAED,2EAA2E;AAC3E,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,OAAO,GAAG,IAAI,CAsB3D;AAaD,gEAAgE;AAChE,qBAAa,WAAW;;IAatB,YAAY,IAAI,EAAE,YAAY,EAE7B;IAED,IAAI,IAAI,IAAI,YAAY,CAEvB;IAED,IAAI,eAAe,IAAI,mBAAmB,CAAC,QAAQ,CAAC,GAAG,SAAS,CAE/D;IAED,IAAI,mBAAmB,IAAI,mBAAmB,CAAC,kBAAkB,CAAC,CAEjE;IAED,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,CAAC,GAAG,eAAe,CAwIhD;IAED,KAAK,IAAI,IAAI,CAQZ;IAED,UAAU,IAAI,MAAM,GAAG,SAAS,CAU/B;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAM1B;CAmFF"}

package/dist/plan.js

@@ -0,0 +1,287 @@
+import { DEFAULT_PERSISTENT_REQUEST_LIMIT, DEFAULT_SPEED } from "./defaults.js";
+import { createPlanEventState, evaluatePlanEvent, selectCompiledEffectChannels, } from "./plan-compiler.js";
+import { browserCompletionEvent } from "./events.js";
+import {} from "./types.js";
+export function compiledPlanSectionRequirements(plan) {
+    const selectors = new Set();
+    const thresholds = new Set([0, 1]);
+    for (const rule of plan.rules) {
+        if (rule.when.source === "browser" &&
+            rule.when.event === "section.visibility") {
+            selectors.add(rule.when.selector);
+            thresholds.add(rule.when.threshold ?? 0.25);
+        }
+    }
+    return {
+        selectors: [...selectors],
+        thresholds: [...thresholds].sort((left, right) => left - right),
+    };
+}
+/** The engine-owned default Plan policy. It uses the public Plan shape. */
+export function createDefaultPlan(locomotion) {
+    return {
+        baseline: {
+            channels: ["state"],
+            state: { state: "idle" },
+        },
+        ...(locomotion
+            ? {
+                rules: [
+                    {
+                        id: "follow-pointer",
+                        when: { source: "browser", event: "pointer.move" },
+                        effect: {
+                            channels: ["motion", "state"],
+                            motion: { type: "follow-pointer", speed: DEFAULT_SPEED },
+                            state: { capability: "locomotion" },
+                        },
+                    },
+                ],
+            }
+            : {}),
+    };
+}
+/** Instance-owned evaluator for one immutable compiled Plan. */
+export class PlanRuntime {
+    #plan;
+    #eventState = createPlanEventState();
+    #activeChannels = new Map();
+    #activeSurfaces = new Map();
+    #activeInterrupts = [];
+    #surfaceVersion = 0;
+    #lastEventStatus;
+    #lastEventRejections = [];
+    constructor(plan) {
+        this.#plan = plan;
+    }
+    get plan() {
+        return this.#plan;
+    }
+    get lastEventStatus() {
+        return this.#lastEventStatus;
+    }
+    get lastEventRejections() {
+        return this.#lastEventRejections;
+    }
+    evaluate(world) {
+        this.#lastEventStatus = undefined;
+        this.#lastEventRejections = [];
+        const reaction = world.reaction;
+        this.#expireInterrupts(world.now);
+        if (reaction) {
+            const selected = evaluatePlanEvent(this.#plan, this.#eventState, {
+                source: reaction.source,
+                name: reaction.name,
+                ...(reaction.payload === undefined
+                    ? {}
+                    : { payload: reaction.payload }),
+            });
+            this.#lastEventStatus = selected.status;
+            this.#lastEventRejections = selected.rejectedSurfaces;
+            if (selected.status !== "invalid" &&
+                selected.status !== "stale" &&
+                selected.status !== "closed") {
+                this.#expireInterrupts(world.now, reaction.source, reaction.name);
+            }
+            if (selected.status === "matched") {
+                const claimed = new Set();
+                selected.effects.forEach((effect, index) => {
+                    const available = effect.channels.filter((channel) => !claimed.has(channel));
+                    if (!available.length)
+                        return;
+                    for (const channel of available)
+                        claimed.add(channel);
+                    if (effect.until) {
+                        this.#startInterrupt(selectCompiledEffectChannels(effect, available), world.now);
+                    }
+                    else {
+                        for (const channel of available) {
+                            if (channel === "motion" || channel === "state") {
+                                this.#activeChannels.set(channel, [
+                                    selected.rules[index].effect,
+                                    effect,
+                                ]);
+                            }
+                        }
+                        for (const surface of effect.surfaces) {
+                            if (available.includes(surface.channel)) {
+                                this.#applySurface(surface);
+                            }
+                        }
+                    }
+                });
+            }
+        }
+        const channels = new Map();
+        for (const interrupt of this.#activeInterrupts) {
+            for (const channel of interrupt.effect.channels) {
+                channels.set(channel, interrupt.effect);
+            }
+        }
+        for (const rule of this.#plan.rules) {
+            const continuous = this.#isContinuous(rule, world);
+            for (const channel of ["motion", "state"]) {
+                if (channels.has(channel))
+                    continue;
+                const latched = this.#activeChannels.get(channel);
+                const effect = continuous && rule.effect.channels.includes(channel)
+                    ? rule.effect
+                    : latched?.[0] === rule.effect
+                        ? latched[1]
+                        : undefined;
+                if (effect)
+                    channels.set(channel, effect);
+            }
+        }
+        for (const channel of this.#plan.baseline.channels) {
+            if (!channels.has(channel))
+                channels.set(channel, this.#plan.baseline);
+        }
+        const output = {};
+        const state = channels.get("state")?.state;
+        if (state?.kind === "state")
+            output.state = state.name;
+        if (state?.kind === "capability") {
+            output.capability = state.name;
+        }
+        const motion = channels.get("motion")?.motion;
+        if (motion && world.pointer) {
+            const dx = world.pointer.x - world.position.x;
+            const dy = world.pointer.y - world.position.y;
+            const distance = Math.hypot(dx, dy);
+            const arrivalRadius = motion.arrivalRadius ?? 0;
+            if (distance > arrivalRadius) {
+                output.motion = {
+                    x: dx / distance,
+                    y: dy / distance,
+                    speed: motion.speed ?? DEFAULT_SPEED,
+                    maxDistance: distance - arrivalRadius,
+                };
+            }
+            else if (channels.get("motion") === channels.get("state")) {
+                delete output.capability;
+                const baseline = this.#baselineState();
+                if (!output.state && baseline)
+                    output.state = baseline;
+            }
+        }
+        const selected = new Map();
+        for (const surface of this.#plan.baseline.surfaces) {
+            selected.set(surface.channel, { surface, version: 0 });
+        }
+        for (const active of this.#activeSurfaces.values()) {
+            selected.set(active.surface.channel, active);
+        }
+        for (const interrupt of this.#activeInterrupts) {
+            for (const surface of interrupt.effect.surfaces) {
+                selected.set(surface.channel, {
+                    surface,
+                    version: interrupt.version,
+                });
+            }
+        }
+        if (selected.size) {
+            output.surfaces = Object.freeze([...selected.values()].map(({ surface, version }) => Object.freeze({
+                id: surface.id,
+                channel: surface.channel,
+                contentId: surface.contentId,
+                ...(surface.data === undefined ? {} : { data: surface.data }),
+                key: `${surface.channel}:${version}`,
+            })));
+        }
+        if (reaction && this.#lastEventStatus === "matched") {
+            output.reactionId = reaction.id;
+        }
+        return output;
+    }
+    reset() {
+        this.#activeChannels.clear();
+        this.#activeSurfaces.clear();
+        this.#activeInterrupts = [];
+        this.#eventState.ordering.clear();
+        this.#eventState.sessions.clear();
+        this.#lastEventStatus = undefined;
+        this.#lastEventRejections = [];
+    }
+    nextWakeAt() {
+        return this.#activeInterrupts.reduce((earliest, interrupt) => {
+            if (!Number.isFinite(interrupt.deadline))
+                return earliest;
+            return earliest === undefined
+                ? interrupt.deadline
+                : Math.min(earliest, interrupt.deadline);
+        }, undefined);
+    }
+    rebase(delta) {
+        if (!delta)
+            return;
+        this.#activeInterrupts = this.#activeInterrupts.map((interrupt) => ({
+            ...interrupt,
+            deadline: interrupt.deadline + delta,
+        }));
+    }
+    #baselineState() {
+        const state = this.#plan.baseline.state;
+        return state?.kind === "state" ? state.name : undefined;
+    }
+    #isContinuous(rule, world) {
+        const condition = rule.when;
+        if (condition.source !== "browser")
+            return false;
+        if (condition.event === "pointer.move") {
+            if (!world.pointer)
+                return false;
+            const motion = rule.effect.motion;
+            if (!motion)
+                return true;
+            return (Math.hypot(world.pointer.x - world.position.x, world.pointer.y - world.position.y) > (motion.arrivalRadius ?? 0));
+        }
+        if (condition.event !== "section.visibility")
+            return false;
+        const section = world.sections?.[condition.selector];
+        const threshold = condition.threshold ?? 0.25;
+        return (condition.phase === "while-visible" && (section?.ratio ?? 0) >= threshold);
+    }
+    #applySurface(surface) {
+        const current = this.#activeSurfaces.get(surface.channel);
+        if (surface.disposition === "ignore")
+            return;
+        const next = surface.disposition === "update" && current
+            ? { ...surface, contentId: current.surface.contentId }
+            : surface;
+        this.#activeSurfaces.set(surface.channel, {
+            surface: Object.freeze(next),
+            version: ++this.#surfaceVersion,
+        });
+    }
+    #startInterrupt(effect, now) {
+        const lifetime = effect.until;
+        const duration = lifetime.type === "duration"
+            ? lifetime.ms
+            : (lifetime.timeout ?? DEFAULT_PERSISTENT_REQUEST_LIMIT);
+        const deadline = now + duration;
+        if (!Number.isFinite(deadline))
+            return;
+        this.#activeInterrupts = this.#activeInterrupts.filter((active) => !active.effect.channels.some((channel) => effect.channels.includes(channel)));
+        this.#activeInterrupts.push({
+            effect,
+            deadline,
+            version: ++this.#surfaceVersion,
+        });
+    }
+    #expireInterrupts(now, eventSource, eventName) {
+        this.#activeInterrupts = this.#activeInterrupts.filter((active) => {
+            if (now >= active.deadline)
+                return false;
+            const until = active.effect.until;
+            return !(eventSource !== undefined &&
+                eventName !== undefined &&
+                until.type === "event" &&
+                completionSource(until.name) === eventSource &&
+                until.name === eventName);
+        });
+    }
+}
+function completionSource(name) {
+    return browserCompletionEvent(name) ? "browser" : "application";
+}

package/dist/preflight-api.d.ts

@@ -0,0 +1,3 @@
+export { preflight } from "./tooling-preflight.js";
+export type { PreflightDiagnostic, PreflightOptions, PreflightResult, } from "./tooling-preflight.js";
+//# sourceMappingURL=preflight-api.d.ts.map

package/dist/preflight-api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight-api.d.ts","sourceRoot":"","sources":["../src/preflight-api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,YAAY,EACV,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,GAChB,MAAM,wBAAwB,CAAC"}

package/dist/preflight-api.js

@@ -0,0 +1 @@
+export { preflight } from "./tooling-preflight.js";

package/dist/preflight.d.ts

@@ -0,0 +1,22 @@
+import type { PeeklingOptions } from "./runtime.js";
+export interface PreflightIssue {
+    readonly code: string;
+    readonly path: string;
+    readonly message: string;
+    readonly fix: string;
+}
+export interface PreflightResult {
+    readonly valid: boolean;
+    readonly errors: readonly PreflightIssue[];
+    readonly warnings: readonly PreflightIssue[];
+}
+export interface PreflightContext {
+    readonly document?: Document;
+    readonly baseUrl?: string;
+    readonly states?: ReadonlySet<string>;
+    readonly capabilities?: ReadonlySet<"locomotion">;
+    /** Package-internal context for an externally supplied, validated Pack. */
+    readonly externalPackSelection?: boolean;
+}
+export declare function preflight(input: PeeklingOptions, context?: PreflightContext): PreflightResult;
+//# sourceMappingURL=preflight.d.ts.map

package/dist/preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight.d.ts","sourceRoot":"","sources":["../src/preflight.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAMpD,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,QAAQ,CAAC,EAAE,QAAQ,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACtC,QAAQ,CAAC,YAAY,CAAC,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC;IAClD,2EAA2E;IAC3E,QAAQ,CAAC,qBAAqB,CAAC,EAAE,OAAO,CAAC;CAC1C;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,eAAe,EACtB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CA6GjB"}

package/dist/preflight.js

@@ -0,0 +1,158 @@
+import { validateConfiguration } from "./configuration-validation.js";
+import { isNormalizedPack, validateNormalizedPack } from "./normalized.js";
+import { OwnDataError, snapshotConfiguration } from "./own-data.js";
+import { validateNativePack } from "./pack.js";
+import { preflightPlan } from "./plan-compiler.js";
+import { toolingDiagnostic } from "./tooling-validation.js";
+import { CONTENT_REGIONS } from "./types.js";
+const REMOVED_FIELDS = new Set(["run", "constructor", "behaviors"]);
+export function preflight(input, context = {}) {
+    const errors = [];
+    const warnings = [];
+    let options;
+    try {
+        options = snapshotConfiguration(input);
+    }
+    catch (cause) {
+        errors.push({
+            code: "invalid-options",
+            path: "$",
+            message: cause instanceof OwnDataError
+                ? cause.message
+                : "Options cannot be inspected safely",
+            fix: "Pass own data in a local ordinary object or null-prototype object",
+        });
+        return { valid: false, errors, warnings };
+    }
+    if (!options || typeof options !== "object" || Array.isArray(options)) {
+        errors.push({
+            code: "invalid-options",
+            path: "$",
+            message: "Options must be an object",
+            fix: "Pass own data in a local ordinary object or null-prototype object",
+        });
+        return { valid: false, errors, warnings };
+    }
+    for (const field of REMOVED_FIELDS) {
+        if (!Object.hasOwn(options, field))
+            continue;
+        const guidance = removedFieldDiagnostic(field);
+        errors.push({
+            code: "removed-api",
+            path: `$.${field}`,
+            message: guidance.message,
+            fix: guidance.fix,
+        });
+    }
+    if (options.pack !== undefined) {
+        try {
+            if (isNormalizedPack(options.pack))
+                validateNormalizedPack(options.pack);
+            else
+                validateNativePack(options.pack);
+        }
+        catch (cause) {
+            errors.push({
+                code: "invalid-pack",
+                path: "$.pack",
+                message: String(cause),
+                fix: "Pass a valid data-only Pack",
+            });
+        }
+    }
+    const reportFault = (code, path, detail) => {
+        if (context.externalPackSelection && code === "manifest.selection")
+            return;
+        errors.push(toolingDiagnostic(code, path, detail));
+    };
+    const checkedOptions = { ...options };
+    for (const field of REMOVED_FIELDS)
+        Reflect.deleteProperty(checkedOptions, field);
+    const content = validateConfiguration(checkedOptions, context.baseUrl ?? "https://peekling.invalid/", reportFault);
+    if (options.plan !== undefined) {
+        const checkedPlan = preflightPlan(options.plan, {
+            ...(context.states ? { states: context.states } : {}),
+            ...(context.capabilities ? { capabilities: context.capabilities } : {}),
+            contentIds: new Set(Object.keys(content)),
+        });
+        for (const issue of checkedPlan.errors) {
+            errors.push({
+                code: issue.code,
+                path: issue.path.replace(/^\$plan/, "$.plan"),
+                message: issue.message,
+                fix: "Fix the Plan field and referenced Pack or content ID",
+            });
+        }
+        inspectSelectors(options, context.document, errors, warnings);
+    }
+    for (const field of ["onDiagnostic", "logger"]) {
+        if (typeof options[field] === "function") {
+            warnings.push({
+                code: "unverified-callback",
+                path: `$.${field}`,
+                message: "Preflight cannot prove callback behavior",
+                fix: "Keep callback side effects bounded",
+            });
+        }
+    }
+    for (const [id, item] of Object.entries(content)) {
+        for (const region of CONTENT_REGIONS) {
+            const surface = item[region];
+            if (surface && typeof surface !== "string" && surface.mountId) {
+                warnings.push({
+                    code: "unverified-host-code",
+                    path: `$.content.${id}.${region}`,
+                    message: "Preflight cannot prove host code safe",
+                    fix: "Keep host code bounded",
+                });
+            }
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+function inspectSelectors(options, document, errors, warnings) {
+    if (!document || !options.plan || !Array.isArray(options.plan.rules))
+        return;
+    for (const [index, rule] of options.plan.rules.entries()) {
+        const when = rule?.when;
+        if (!when ||
+            when.source !== "browser" ||
+            when.event !== "section.visibility" ||
+            typeof when.selector !== "string") {
+            continue;
+        }
+        const path = `$.plan.rules[${index}].when.selector`;
+        try {
+            if (!document.querySelector(when.selector)) {
+                warnings.push({
+                    code: "missing-selector",
+                    path,
+                    message: `No element currently matches ${when.selector}`,
+                    fix: "Ensure the element exists",
+                });
+            }
+        }
+        catch {
+            errors.push({
+                code: "invalid-selector",
+                path,
+                message: `Invalid selector ${when.selector}`,
+                fix: "Use a valid bounded CSS selector",
+            });
+        }
+    }
+}
+function removedFieldDiagnostic(field) {
+    if (field === "behaviors") {
+        return {
+            message: "behaviors is not a Peekling 0.1 configuration field",
+            fix: "Express the behavior as Rules in one canonical Plan",
+        };
+    }
+    return {
+        message: field === "run"
+            ? "run is not part of the Peekling 0.1 API"
+            : "Direct construction is not part of the Peekling 0.1 API",
+        fix: "Create the instance with hatch(configuration)",
+    };
+}

package/dist/registry.d.ts

@@ -0,0 +1,9 @@
+interface CharacterPackReference {
+    readonly url: string;
+    readonly sha256: string;
+}
+export declare function isRegisteredCharacter(character: string): boolean;
+export declare function characterPackReference(character: string): CharacterPackReference;
+export declare function characterManifestUrl(character: string): string;
+export {};
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAcA,UAAU,sBAAsB;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AASD,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,sBAAsB,CASxB;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE9D"}

package/dist/registry.js

@@ -0,0 +1,24 @@
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const PEEK_REFERENCE_URL = typeof __PEEK_PACK_URL__ === "string"
+    ? __PEEK_PACK_URL__
+    : "https://cdn.jsdelivr.net/npm/@peekling/pack-peek@0.1.0/character.json";
+const PEEK_REFERENCE_SHA256 = typeof __PEEK_PACK_SHA256__ === "string"
+    ? __PEEK_PACK_SHA256__
+    : "bc01840e84f72edca4b0421dca4d07623b38d971d851bfc647e1cada03e1cbcc";
+const REGISTRY = {
+    peek: Object.freeze({
+        url: PEEK_REFERENCE_URL,
+        sha256: PEEK_REFERENCE_SHA256,
+    }),
+};
+export function isRegisteredCharacter(character) {
+    return Object.hasOwn(REGISTRY, character);
+}
+export function characterPackReference(character) {
+    if (!isRegisteredCharacter(character))
+        throw new Error(runtimeMessage("character.unknown", `Unknown Peekling character: ${character}`));
+    return REGISTRY[character];
+}
+export function characterManifestUrl(character) {
+    return characterPackReference(character).url;
+}

package/dist/renderer.d.ts

@@ -0,0 +1,16 @@
+import type { NormalizedPack, Point, StateDefinition } from "./types.js";
+import { type RuntimeStyleAsset } from "./styles.js";
+export declare function frameAt(state: StateDefinition, elapsed: number): number;
+export declare function snapToDevicePixel(value: number, devicePixelRatio?: number): number;
+export declare class AtlasRenderer {
+    #private;
+    readonly host: HTMLElement;
+    readonly ready: Promise<void>;
+    constructor(document: Document, pack: NormalizedPack, atlasUrl: string, scale: number, styles: RuntimeStyleAsset);
+    swapAtlas(pack: NormalizedPack, atlasUrl: string): void;
+    setHidden(hidden: boolean): void;
+    nextFrameIn(now: number): number | undefined;
+    render(stateName: string, now: number, position: Point, devicePixelRatio?: number, lift?: number): void;
+    destroy(): void;
+}
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAGzE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,aAAa,CAAC;AAErB,wBAAgB,OAAO,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAkBvE;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,gBAAgB,SAAI,GAAG,MAAM,CAM7E;AAED,qBAAa,aAAa;;IACxB,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAe9B,YACE,QAAQ,EAAE,QAAQ,EAClB,IAAI,EAAE,cAAc,EACpB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,iBAAiB,EAoB1B;IAED,SAAS,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAGtD;IAoBD,SAAS,CAAC,MAAM,EAAE,OAAO,GAAG,IAAI,CAG/B;IAED,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAuB3C;IAED,MAAM,CACJ,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,KAAK,EACf,gBAAgB,SAAI,EACpB,IAAI,SAAI,GACP,IAAI,CAkDN;IAED,OAAO,IAAI,IAAI,CAKd;CAkBF"}