@peekling/runtime 0.1.0

package/dist/normalized.js

@@ -0,0 +1,266 @@
+import { addPackIssue, packIssue, PackValidationError } from "./errors.js";
+import { validateEventPayload } from "./events.js";
+import { selectNativeDensity } from "./pack.js";
+import { ASSET_PATH_PATTERN, NAME_PATTERN, SEMVER_PATTERN, SPDX_LICENSE_PATTERN, } from "./contracts.js";
+import { closed, record as object, validateDensityVariants, validateMotionKeyframes, validateSha256, validateStateMap, } from "./pack-shared.js";
+import { NATIVE_DIRECTIONS, } from "./types.js";
+import { OwnDataError, snapshotPackData } from "./own-data.js";
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const MAX_NORMALIZED_ATLAS_BYTES = 32 * 1024 * 1024;
+function text(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 512 &&
+        !/[\u0000-\u001f\u007f]/.test(value));
+}
+export function isNormalizedPack(input) {
+    if (!object(input))
+        return false;
+    const atlas = Object.getOwnPropertyDescriptor(input, "atlas")?.value;
+    const assets = Object.getOwnPropertyDescriptor(input, "assets")?.value;
+    return object(atlas) && !object(assets);
+}
+export function validateNormalizedPack(input, geometry, preferredDensity) {
+    const issues = [];
+    try {
+        input = snapshotPackData(input);
+    }
+    catch (cause) {
+        if (cause instanceof OwnDataError) {
+            throw new PackValidationError([cause.message], cause.issueCode ? [cause.issueCode] : []);
+        }
+        throw cause;
+    }
+    if (!object(input) || !object(input.atlas) || !object(input.states)) {
+        throw new PackValidationError([
+            packIssue("normalized.structure", "normalized pack needs atlas and states"),
+        ]);
+    }
+    closed(input, [
+        "name",
+        "displayName",
+        "version",
+        "license",
+        "atlas",
+        "states",
+        "defaultScale",
+        "directionalStates",
+        "locomotionMotion",
+        "reactionStates",
+        "source",
+    ], "normalizedPack", issues);
+    for (const field of ["name", "version", "license"]) {
+        if (!text(input[field]))
+            addPackIssue(issues, `normalized.${field}`, `${field} must be a short safe string`);
+    }
+    if (!text(input.displayName) || input.displayName.length > 120)
+        addPackIssue(issues, "normalized.displayName", "displayName must be 1-120 characters");
+    else if (/:\/\//.test(input.displayName))
+        addPackIssue(issues, "normalized.displayName", "displayName must not contain a URL");
+    if (typeof input.version === "string" && input.version.length > 64)
+        addPackIssue(issues, "normalized.version", "version must be at most 64 characters");
+    if (text(input.name) && !NAME_PATTERN.test(input.name))
+        addPackIssue(issues, "normalized.name", "name must be a lowercase ID");
+    if (text(input.version) && !SEMVER_PATTERN.test(input.version))
+        addPackIssue(issues, "normalized.version", "version must be SemVer 2.0");
+    if (text(input.license) && !SPDX_LICENSE_PATTERN.test(input.license))
+        addPackIssue(issues, "normalized.license", "license must be SPDX or LicenseRef");
+    const atlas = input.atlas;
+    closed(atlas, [
+        "src",
+        "columns",
+        "rows",
+        "cellWidth",
+        "cellHeight",
+        "logicalWidth",
+        "logicalHeight",
+        "density",
+        "lineage",
+        "sha256",
+        "variants",
+    ], "atlas", issues);
+    const dimensions = [
+        ["columns", 256],
+        ["rows", 4_096],
+        ["cellWidth", 1_024],
+        ["cellHeight", 1_024],
+    ];
+    for (const [field, maximum] of dimensions) {
+        if (!Number.isInteger(atlas[field]) ||
+            atlas[field] < 1 ||
+            atlas[field] > maximum) {
+            addPackIssue(issues, `atlas.${field}`, `atlas.${field} must be integer 1-${maximum}`);
+        }
+    }
+    if (!text(atlas.src) ||
+        !ASSET_PATH_PATTERN.test(atlas.src) ||
+        !/\.(?:png|webp)$/i.test(atlas.src)) {
+        addPackIssue(issues, "atlas.src", "atlas.src must be a safe relative PNG or WebP path");
+    }
+    const columns = Number(atlas.columns);
+    const rows = Number(atlas.rows);
+    const cellWidth = Number(atlas.cellWidth);
+    const cellHeight = Number(atlas.cellHeight);
+    for (const field of ["logicalWidth", "logicalHeight"]) {
+        if (atlas[field] !== undefined &&
+            (!Number.isInteger(atlas[field]) ||
+                atlas[field] < 1 ||
+                atlas[field] > 256))
+            addPackIssue(issues, `atlas.${field}`, `atlas.${field} must be integer 1-256`);
+    }
+    if (atlas.density !== undefined &&
+        ![1, 2, 4].includes(atlas.density))
+        addPackIssue(issues, "atlas.density", "atlas.density must be 1, 2, or 4");
+    if (atlas.lineage !== undefined &&
+        (!text(atlas.lineage) ||
+            !/^[a-z0-9][a-z0-9._-]{2,127}$/.test(atlas.lineage)))
+        addPackIssue(issues, "atlas.lineage", "atlas.lineage must be a safe ID");
+    const variants = atlas.variants === undefined
+        ? []
+        : validateDensityVariants(atlas.variants, { path: "atlas.variants" }, issues);
+    const baseSha256 = atlas.sha256 === undefined
+        ? undefined
+        : validateSha256(atlas.sha256, "atlas.sha256", issues)
+            ? atlas.sha256
+            : undefined;
+    if (atlas.variants === undefined && atlas.sha256 === undefined) {
+        validateSha256(undefined, "atlas.sha256", issues);
+    }
+    const baseDensity = [1, 2, 4].includes(atlas.density)
+        ? atlas.density
+        : 1;
+    const logicalWidth = Number.isInteger(atlas.logicalWidth)
+        ? atlas.logicalWidth
+        : cellWidth / baseDensity;
+    const logicalHeight = Number.isInteger(atlas.logicalHeight)
+        ? atlas.logicalHeight
+        : cellHeight / baseDensity;
+    const selectedDensity = variants.length
+        ? selectNativeDensity(variants.map((item) => item.density), preferredDensity ?? baseDensity)
+        : baseDensity;
+    const selectedVariant = variants.find((item) => item.density === selectedDensity);
+    const selectedSha256 = selectedVariant?.sha256 ?? baseSha256;
+    const selectedSrc = selectedVariant?.src ?? atlas.src;
+    const selectedCellWidth = selectedVariant?.cellWidth ?? cellWidth;
+    const selectedCellHeight = selectedVariant?.cellHeight ?? cellHeight;
+    if (!Number.isInteger(logicalWidth) ||
+        !Number.isInteger(logicalHeight) ||
+        selectedCellWidth !== logicalWidth * selectedDensity ||
+        selectedCellHeight !== logicalHeight * selectedDensity) {
+        addPackIssue(issues, "atlas.logical-cell", "atlas candidates must preserve integer logical cells");
+    }
+    const cellCount = columns * rows;
+    if (columns * selectedCellWidth > 4096 || rows * selectedCellHeight > 4096) {
+        addPackIssue(issues, "atlas.size", "normalized atlas exceeds 4096x4096");
+    }
+    const states = validateStateMap(input.states, cellCount, issues);
+    if (!Number.isInteger(input.defaultScale) ||
+        input.defaultScale < 1 ||
+        input.defaultScale > 4) {
+        addPackIssue(issues, "normalized.defaultScale", "defaultScale must be integer 1-4");
+    }
+    const directionalStates = {};
+    if (input.directionalStates !== undefined) {
+        if (!object(input.directionalStates))
+            addPackIssue(issues, "directionalStates", "directionalStates must be an object");
+        else {
+            closed(input.directionalStates, NATIVE_DIRECTIONS, "directionalStates", issues);
+            for (const direction of NATIVE_DIRECTIONS) {
+                const target = input.directionalStates[direction];
+                if (target !== undefined) {
+                    if (typeof target !== "string" || !states[target]) {
+                        addPackIssue(issues, `directionalStates.${direction}`, `directionalStates.${direction} must name a state`);
+                    }
+                    else
+                        directionalStates[direction] = target;
+                }
+            }
+        }
+    }
+    const reactionStates = {};
+    if (input.reactionStates !== undefined) {
+        if (!object(input.reactionStates) ||
+            Object.keys(input.reactionStates).length > 32) {
+            addPackIssue(issues, "reactionStates.limit", "reactionStates allows up to 32 mappings");
+        }
+        else {
+            for (const [semantic, target] of Object.entries(input.reactionStates)) {
+                if (!/^[a-z][a-z0-9-]{0,63}$/.test(semantic) ||
+                    typeof target !== "string" ||
+                    !states[target]) {
+                    addPackIssue(issues, `reactionStates.${semantic}`, `reactionStates.${semantic} must name a state`);
+                }
+                else
+                    reactionStates[semantic] = target;
+            }
+        }
+    }
+    let locomotionMotion = [];
+    if (input.locomotionMotion !== undefined) {
+        locomotionMotion = validateMotionKeyframes(input.locomotionMotion, "locomotionMotion", issues);
+    }
+    if (geometry &&
+        (geometry.width !== columns * selectedCellWidth ||
+            geometry.height !== rows * selectedCellHeight)) {
+        addPackIssue(issues, "atlas.pixels", `atlas pixels must match ${columns * selectedCellWidth}x${rows * selectedCellHeight}`);
+    }
+    if (geometry?.byteLength !== undefined &&
+        (!Number.isSafeInteger(geometry.byteLength) ||
+            geometry.byteLength < 1 ||
+            geometry.byteLength > MAX_NORMALIZED_ATLAS_BYTES)) {
+        addPackIssue(issues, "atlas.size", "normalized atlas exceeds resource limits");
+    }
+    let source;
+    if (input.source !== undefined) {
+        try {
+            const checked = validateEventPayload(input.source);
+            if (!object(checked))
+                throw new TypeError(runtimeMessage("normalized.source", "source must be a JSON object"));
+            source = Object.freeze({ ...checked });
+        }
+        catch (cause) {
+            addPackIssue(issues, "normalized.source", `source must be bounded JSON: ${String(cause)}`);
+        }
+    }
+    if (issues.length || !selectedSha256) {
+        throw new PackValidationError(issues.length
+            ? issues
+            : [
+                packIssue("atlas.sha256", "atlas.sha256 must be 64 lowercase hexadecimal characters"),
+            ]);
+    }
+    return {
+        name: input.name,
+        displayName: text(input.displayName)
+            ? input.displayName
+            : input.name,
+        version: input.version,
+        license: input.license,
+        atlas: {
+            src: selectedSrc,
+            sha256: selectedSha256,
+            columns,
+            rows,
+            cellWidth: selectedCellWidth,
+            cellHeight: selectedCellHeight,
+            logicalWidth,
+            logicalHeight,
+            density: selectedDensity,
+            ...(typeof atlas.lineage === "string" ? { lineage: atlas.lineage } : {}),
+            ...(variants.length ? { variants } : {}),
+        },
+        states,
+        defaultScale: input.defaultScale,
+        ...(Object.keys(directionalStates).length ? { directionalStates } : {}),
+        ...(locomotionMotion.length ? { locomotionMotion } : {}),
+        ...(Object.keys(reactionStates).length ? { reactionStates } : {}),
+        ...(source ? { source } : {}),
+    };
+}
+export function resolveCapabilityName(requested, pack) {
+    if (!requested)
+        return undefined;
+    return pack.reactionStates && Object.hasOwn(pack.reactionStates, requested)
+        ? pack.reactionStates[requested]
+        : requested;
+}

package/dist/overrides.d.ts

@@ -0,0 +1,29 @@
+import { type PlanCompileContext } from "./plan-compiler.js";
+import type { BehaviorRequest, OverrideCompletionReason, OverrideHandle, OverrideInput, PlanBrowserEvent, PlanEventSource } from "./types.js";
+interface OverrideWorld {
+    pointer?: {
+        x: number;
+        y: number;
+    };
+    position?: {
+        x: number;
+        y: number;
+    };
+}
+/** Instance-owned temporary channel controller. It never mutates the Plan. */
+export declare class OverrideManager {
+    #private;
+    constructor(context: PlanCompileContext, now: () => number, diagnostic?: (message: string) => void);
+    add(input: OverrideInput): OverrideHandle;
+    reject(reason?: OverrideCompletionReason): OverrideHandle;
+    browserCompletionFor(id: string): PlanBrowserEvent | undefined;
+    /** Complete matching waits but never consume the event from the Plan stream. */
+    observeEvent(name: string, source?: PlanEventSource): false;
+    compose(base: Readonly<BehaviorRequest>, world: Readonly<OverrideWorld>): BehaviorRequest;
+    nextWakeAt(): number | undefined;
+    rebase(delta: number): void;
+    clear(reason: OverrideCompletionReason): void;
+}
+export declare function rejectedOverrideHandle(id: string, reason: OverrideCompletionReason): OverrideHandle;
+export {};
+//# sourceMappingURL=overrides.d.ts.map

package/dist/overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"overrides.d.ts","sourceRoot":"","sources":["../src/overrides.ts"],"names":[],"mappings":"AAGA,OAAO,EAGL,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,KAAK,EACV,eAAe,EACf,wBAAwB,EACxB,cAAc,EACd,aAAa,EAIb,gBAAgB,EAChB,eAAe,EAEhB,MAAM,YAAY,CAAC;AAiBpB,UAAU,aAAa;IACrB,OAAO,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACnC,QAAQ,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACrC;AAED,8EAA8E;AAC9E,qBAAa,eAAe;;IAO1B,YACE,OAAO,EAAE,kBAAkB,EAC3B,GAAG,EAAE,MAAM,MAAM,EACjB,UAAU,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAe,EAKjD;IAED,GAAG,CAAC,KAAK,EAAE,aAAa,GAAG,cAAc,CAyDxC;IAED,MAAM,CAAC,MAAM,GAAE,wBAAqC,GAAG,cAAc,CAIpE;IAED,oBAAoB,CAAC,EAAE,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAK7D;IAED,gFAAgF;IAChF,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,eAA+B,GAAG,KAAK,CAWzE;IAED,OAAO,CACL,IAAI,EAAE,QAAQ,CAAC,eAAe,CAAC,EAC/B,KAAK,EAAE,QAAQ,CAAC,aAAa,CAAC,GAC7B,eAAe,CAmDjB;IAED,UAAU,IAAI,MAAM,GAAG,SAAS,CAQ/B;IAED,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAK1B;IAED,KAAK,CAAC,MAAM,EAAE,wBAAwB,GAAG,IAAI,CAE5C;CA+CF;AAMD,wBAAgB,sBAAsB,CACpC,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,wBAAwB,GAC/B,cAAc,CAOhB"}

package/dist/overrides.js

@@ -0,0 +1,296 @@
+import { EVENT_NAME_PATTERN } from "./contracts.js";
+import { browserCompletionEvent, isContinuousBrowserEvent } from "./events.js";
+import { DEFAULT_PERSISTENT_REQUEST_LIMIT, DEFAULT_SPEED } from "./defaults.js";
+import { compileOverrideEffect, } from "./plan-compiler.js";
+import { snapshotOwnData } from "./own-data.js";
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const OVERRIDE_LIMIT = 8;
+const MAX_LIFETIME = DEFAULT_PERSISTENT_REQUEST_LIMIT;
+/** Instance-owned temporary channel controller. It never mutates the Plan. */
+export class OverrideManager {
+    #context;
+    #now;
+    #diagnostic;
+    #active = [];
+    #nextId = 1;
+    constructor(context, now, diagnostic = () => { }) {
+        this.#context = context;
+        this.#now = now;
+        this.#diagnostic = diagnostic;
+    }
+    add(input) {
+        const item = this.#create();
+        let checked;
+        let effect;
+        try {
+            checked = validateOverride(input);
+            effect = compileOverrideEffect(checked.effect, this.#context);
+        }
+        catch (cause) {
+            this.#diagnostic(runtimeMessage("override.invalid", () => `Override ${item.id} rejected: ${errorMessage(cause)}`));
+            item.finish("rejected");
+            return item.handle;
+        }
+        const conflicts = this.#active.filter((active) => active.effect.channels.some((channel) => effect.channels.includes(channel)));
+        if (conflicts.length && checked.mode !== "replace") {
+            this.#diagnostic(runtimeMessage("override.conflict", () => `Override ${item.id} conflict on ${conflictingChannels(conflicts, effect).join(", ")}`));
+            item.finish("conflict");
+            return item.handle;
+        }
+        for (const conflict of conflicts)
+            this.#finish(conflict, "replaced");
+        if (this.#active.length >= OVERRIDE_LIMIT) {
+            this.#diagnostic(runtimeMessage("override.limit", () => `Override ${item.id} rejected at the ${OVERRIDE_LIMIT}-override limit`));
+            item.finish("overflow");
+            return item.handle;
+        }
+        const startedAt = this.#now();
+        Object.assign(item, {
+            input: checked,
+            effect,
+            startedAt,
+            deadline: startedAt + lifetimeMs(checked),
+            status: "active",
+        });
+        this.#active.push(item);
+        return item.handle;
+    }
+    reject(reason = "rejected") {
+        const item = this.#create();
+        item.finish(reason);
+        return item.handle;
+    }
+    browserCompletionFor(id) {
+        const until = this.#active.find((item) => item.id === id)?.input.until;
+        return until?.type === "event"
+            ? browserCompletionEvent(until.name)
+            : undefined;
+    }
+    /** Complete matching waits but never consume the event from the Plan stream. */
+    observeEvent(name, source = "application") {
+        for (const item of [...this.#active]) {
+            if (item.input.until?.type === "event" &&
+                item.input.until.name === name &&
+                completionSource(item.input.until.name) === source) {
+                this.#finish(item, "event");
+            }
+        }
+        return false;
+    }
+    compose(base, world) {
+        const now = this.#now();
+        for (const item of [...this.#active]) {
+            if (now >= item.deadline)
+                this.#finish(item, "timeout");
+        }
+        const output = { ...base };
+        const surfaces = new Map();
+        for (const surface of base.surfaces ?? []) {
+            surfaces.set(surface.channel, surface);
+        }
+        for (const item of this.#active) {
+            const state = item.effect.state;
+            if (state?.kind === "state") {
+                output.state = state.name;
+                delete output.capability;
+            }
+            else if (state?.kind === "capability") {
+                output.capability = state.name;
+                delete output.state;
+            }
+            const motion = item.effect.motion;
+            if (motion && world.pointer && world.position) {
+                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 {
+                    delete output.motion;
+                }
+            }
+            for (const surface of item.effect.surfaces) {
+                surfaces.set(surface.channel, Object.freeze({
+                    id: surface.id,
+                    channel: surface.channel,
+                    contentId: surface.contentId,
+                    ...(surface.data === undefined ? {} : { data: surface.data }),
+                    key: item.id,
+                }));
+            }
+        }
+        output.surfaces = Object.freeze([...surfaces.values()]);
+        return output;
+    }
+    nextWakeAt() {
+        return this.#active.reduce((earliest, item) => earliest === undefined
+            ? item.deadline
+            : Math.min(earliest, item.deadline), undefined);
+    }
+    rebase(delta) {
+        for (const item of this.#active) {
+            item.startedAt += delta;
+            item.deadline += delta;
+        }
+    }
+    clear(reason) {
+        for (const item of [...this.#active])
+            this.#finish(item, reason);
+    }
+    #create() {
+        const id = `override:${this.#nextId++}`;
+        let resolve;
+        let done = false;
+        const finished = new Promise((accept) => {
+            resolve = accept;
+        });
+        const item = {};
+        const finish = (reason) => {
+            if (done)
+                return;
+            done = true;
+            item.status = rejectedReason(reason) ? "rejected" : "finished";
+            resolve({ id, reason });
+        };
+        const handle = Object.freeze({
+            id,
+            get status() {
+                return item.status;
+            },
+            finished,
+            cancel: () => {
+                if (item.status === "active")
+                    this.#finish(item, "cancelled");
+            },
+        });
+        Object.assign(item, {
+            id,
+            effect: Object.freeze({ channels: [], surfaces: [] }),
+            input: Object.freeze({
+                effect: Object.freeze({ channels: [] }),
+                until: Object.freeze({ type: "manual" }),
+            }),
+            startedAt: 0,
+            deadline: 0,
+            status: "rejected",
+            handle,
+            finish,
+        });
+        return item;
+    }
+    #finish(item, reason) {
+        const index = this.#active.indexOf(item);
+        if (index >= 0)
+            this.#active.splice(index, 1);
+        item.finish(reason);
+    }
+}
+function completionSource(name) {
+    return browserCompletionEvent(name) ? "browser" : "application";
+}
+export function rejectedOverrideHandle(id, reason) {
+    return Object.freeze({
+        id,
+        status: "rejected",
+        finished: Promise.resolve({ id, reason }),
+        cancel: () => { },
+    });
+}
+function validateOverride(input) {
+    const value = snapshotOwnData(input);
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new TypeError(runtimeMessage("override.object", "override must be an object"));
+    }
+    closed(value, ["effect", "until", "mode"], "override");
+    if (!value.effect)
+        throw new TypeError(runtimeMessage("override.effect", "override.effect is required"));
+    if (value.mode !== undefined &&
+        value.mode !== "reject" &&
+        value.mode !== "replace") {
+        throw new TypeError(runtimeMessage("override.mode", "override.mode must be reject or replace"));
+    }
+    const until = value.until === undefined
+        ? Object.freeze({ type: "manual" })
+        : value.until;
+    if (!until || typeof until !== "object" || Array.isArray(until)) {
+        throw new TypeError(runtimeMessage("override.until", "override.until must be an object"));
+    }
+    if (until.type === "duration") {
+        closed(until, ["type", "ms"], "override.until");
+        boundedLifetime(until.ms, "override.until.ms");
+    }
+    else if (until.type === "event") {
+        closed(until, ["type", "name", "timeout"], "override.until");
+        if (typeof until.name !== "string" ||
+            !EVENT_NAME_PATTERN.test(until.name)) {
+            throw new TypeError(runtimeMessage("override.until.name", "override.until.name is invalid"));
+        }
+        if (isContinuousBrowserEvent(until.name)) {
+            throw new TypeError(runtimeMessage("override.until.name", "continuous browser Events cannot be completion Events"));
+        }
+        if (until.timeout !== undefined) {
+            boundedLifetime(until.timeout, "override.until.timeout");
+        }
+    }
+    else if (until.type === "manual") {
+        closed(until, ["type", "maxMs"], "override.until");
+        if (until.maxMs !== undefined) {
+            boundedLifetime(until.maxMs, "override.until.maxMs");
+        }
+    }
+    else {
+        throw new TypeError(runtimeMessage("override.until.type", "override.until.type is invalid"));
+    }
+    return Object.freeze({
+        effect: value.effect,
+        until,
+        ...(value.mode === undefined ? {} : { mode: value.mode }),
+    });
+}
+function lifetimeMs(input) {
+    const until = input.until;
+    if (until?.type === "duration")
+        return until.ms;
+    if (until?.type === "event" && until.timeout !== undefined)
+        return until.timeout;
+    if (until?.type === "manual" && until.maxMs !== undefined)
+        return until.maxMs;
+    return MAX_LIFETIME;
+}
+function boundedLifetime(value, path) {
+    if (typeof value !== "number" ||
+        !Number.isFinite(value) ||
+        value < 1 ||
+        value > MAX_LIFETIME) {
+        throw new TypeError(runtimeMessage("override.lifetime", () => `${path} must be 1-${MAX_LIFETIME}`));
+    }
+}
+function closed(value, allowed, path) {
+    for (const key of Object.keys(value)) {
+        if (!allowed.includes(key))
+            throw new TypeError(runtimeMessage("override.unknown-field", () => `${path}.${key} is unknown`));
+    }
+}
+function conflictingChannels(active, effect) {
+    const channels = new Set();
+    for (const item of active) {
+        for (const channel of item.effect.channels) {
+            if (effect.channels.includes(channel))
+                channels.add(channel);
+        }
+    }
+    return [...channels];
+}
+function rejectedReason(reason) {
+    return (reason === "rejected" || reason === "conflict" || reason === "overflow");
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : "invalid input";
+}

package/dist/own-data.d.ts

@@ -0,0 +1,18 @@
+export declare class OwnDataError extends TypeError {
+    readonly issueCode: string | undefined;
+    constructor(path: string, reason: string, issueCode?: string);
+}
+export interface OwnDataSnapshotPolicy {
+    readonly json?: boolean;
+    readonly key?: (value: string) => boolean;
+    readonly maxArrayLength?: number;
+    readonly maxDepth?: number;
+    readonly maxObjectKeys?: number;
+    readonly maxStringLength?: number;
+    readonly maxValues?: number;
+}
+export declare function snapshotOwnData<T>(input: T, policy?: Readonly<OwnDataSnapshotPolicy>): T;
+/** Shared package-family boundary for data-only Pack and adapter input. */
+export declare function snapshotPackData<T>(input: T): T;
+export declare function snapshotConfiguration<T>(input: T): T;
+//# sourceMappingURL=own-data.d.ts.map

package/dist/own-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"own-data.d.ts","sourceRoot":"","sources":["../src/own-data.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAa,SAAQ,SAAS;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAEvC,YAAY,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,EAI3D;CACF;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AA8OD,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EACR,MAAM,CAAC,EAAE,QAAQ,CAAC,qBAAqB,CAAC,GACvC,CAAC,CAEH;AAED,2EAA2E;AAC3E,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAE/C;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEpD"}