@peekling/runtime 0.1.0

package/dist/sections.d.ts

@@ -0,0 +1,15 @@
+import type { SectionSnapshot } from "./types.js";
+export interface SectionVisibilityFact {
+    readonly [key: string]: string | number;
+    readonly selector: string;
+    readonly previousRatio: number;
+    readonly ratio: number;
+}
+export declare class SectionTracker {
+    #private;
+    constructor(document: Document, window: Window, selectors: readonly string[], thresholds: readonly number[], wake: () => void, capture?: (fact: SectionVisibilityFact) => void);
+    snapshot(): Readonly<Record<string, SectionSnapshot>>;
+    setSuspended(value: boolean): void;
+    destroy(): void;
+}
+//# sourceMappingURL=sections.d.ts.map

package/dist/sections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sections.d.ts","sourceRoot":"","sources":["../src/sections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAalD,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,qBAAa,cAAc;;IAezB,YACE,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,SAAS,MAAM,EAAE,EAC5B,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,IAAI,EAAE,MAAM,IAAI,EAChB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,EA4DhD;IAED,QAAQ,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAiBpD;IAED,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAmBjC;IAED,OAAO,IAAI,IAAI,CASd;CA+FF"}

package/dist/sections.js

@@ -0,0 +1,221 @@
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const RUNTIME_ROOTS = "[data-peekling-host],[data-peekling-content],[data-peekling-controls]";
+const REFRESH_CADENCE_MS = 250;
+export class SectionTracker {
+    #document;
+    #window;
+    #states = new Map();
+    #elements = new Map();
+    #observer;
+    #mutations;
+    #wake;
+    #capture;
+    #suspended = false;
+    #destroyed = false;
+    #dirty = false;
+    #failure;
+    #refreshTimer = 0;
+    constructor(document, window, selectors, thresholds, wake, capture) {
+        this.#document = document;
+        this.#window = window;
+        this.#wake = wake;
+        this.#capture = capture;
+        const initial = selectors.map((selector) => [selector, this.#select(selector)]);
+        const BrowserIntersectionObserver = window
+            .IntersectionObserver;
+        if (BrowserIntersectionObserver) {
+            this.#observer = new BrowserIntersectionObserver((entries) => {
+                let changed = false;
+                for (const entry of entries) {
+                    for (const selector of this.#elements.get(entry.target) ?? []) {
+                        const state = this.#states.get(selector);
+                        if (!state)
+                            continue;
+                        const ratio = entry.isIntersecting ? entry.intersectionRatio : 0;
+                        changed = this.#change(selector, state, ratio) || changed;
+                    }
+                }
+                if (changed)
+                    wake();
+            }, { threshold: [...thresholds] });
+        }
+        const BrowserMutationObserver = window
+            .MutationObserver;
+        if (BrowserMutationObserver) {
+            this.#mutations = new BrowserMutationObserver((records) => {
+                if (this.#suspended ||
+                    this.#destroyed ||
+                    this.#refreshTimer ||
+                    this.#dirty ||
+                    (records.length > 0 && records.every(runtimeOwnedMutation))) {
+                    return;
+                }
+                let needsRefresh = false;
+                for (const state of this.#states.values()) {
+                    if (!state[0]?.isConnected) {
+                        needsRefresh = true;
+                        break;
+                    }
+                }
+                if (!needsRefresh)
+                    return;
+                this.#scheduleRefresh();
+            });
+            this.#mutations.observe(document.documentElement, {
+                childList: true,
+                subtree: true,
+            });
+        }
+        for (const [selector, element] of initial) {
+            this.#states.set(selector, [undefined, 0, 0]);
+            this.#observe(selector, element);
+        }
+    }
+    snapshot() {
+        if (this.#failure)
+            throw this.#failure;
+        if (this.#dirty) {
+            this.#dirty = false;
+            this.#refreshGuarded();
+            if (this.#failure)
+                throw this.#failure;
+        }
+        const result = Object.create(null);
+        for (const [selector, state] of this.#states) {
+            result[selector] = {
+                ratio: state[2],
+                previousRatio: state[1],
+            };
+        }
+        return result;
+    }
+    setSuspended(value) {
+        if (this.#destroyed || value === this.#suspended)
+            return;
+        this.#suspended = value;
+        if (value) {
+            this.#cancelRefresh();
+            this.#dirty = false;
+            this.#observer?.disconnect();
+            this.#mutations?.disconnect();
+            return;
+        }
+        this.#mutations?.observe(this.#document.documentElement, {
+            childList: true,
+            subtree: true,
+        });
+        this.#dirty = false;
+        if (!this.#refreshGuarded())
+            return;
+        for (const element of this.#elements.keys()) {
+            this.#observer?.observe(element);
+        }
+    }
+    destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        this.#cancelRefresh();
+        this.#dirty = false;
+        this.#observer?.disconnect();
+        this.#mutations?.disconnect();
+        this.#elements.clear();
+        this.#states.clear();
+    }
+    #observe(selector, element = this.#select(selector)) {
+        const state = this.#states.get(selector);
+        if (!element) {
+            this.#detach(selector, state);
+            this.#change(selector, state, 0);
+            return;
+        }
+        if (element === state[0] && element.isConnected)
+            return;
+        this.#detach(selector, state);
+        state[0] = element;
+        const selectors = this.#elements.get(element) ?? new Set();
+        if (!selectors.size)
+            this.#observer?.observe(element);
+        selectors.add(selector);
+        this.#elements.set(element, selectors);
+    }
+    #select(selector) {
+        try {
+            return this.#document.querySelector(selector);
+        }
+        catch {
+            throw new TypeError(runtimeMessage("section.selector", `Invalid section selector: ${selector}`));
+        }
+    }
+    #detach(selector, state) {
+        const previous = state[0];
+        state[0] = undefined;
+        if (!previous)
+            return;
+        const selectors = this.#elements.get(previous);
+        selectors?.delete(selector);
+        if (!selectors?.size) {
+            this.#observer?.unobserve(previous);
+            this.#elements.delete(previous);
+        }
+    }
+    #change(selector, state, ratio) {
+        const previousRatio = state[2];
+        if (ratio === previousRatio)
+            return false;
+        state[1] = previousRatio;
+        state[2] = ratio;
+        this.#capture?.({ selector, previousRatio, ratio });
+        return true;
+    }
+    #refresh() {
+        for (const [selector, state] of this.#states) {
+            if (!state[0]?.isConnected)
+                this.#observe(selector);
+        }
+    }
+    #scheduleRefresh() {
+        if (this.#refreshTimer || this.#suspended || this.#destroyed)
+            return;
+        this.#refreshTimer = this.#window.setTimeout(() => {
+            this.#refreshTimer = 0;
+            if (this.#suspended || this.#destroyed || this.#failure || this.#dirty)
+                return;
+            this.#dirty = true;
+            this.#wake();
+        }, REFRESH_CADENCE_MS);
+    }
+    #cancelRefresh() {
+        if (this.#refreshTimer)
+            this.#window.clearTimeout(this.#refreshTimer);
+        this.#refreshTimer = 0;
+    }
+    #refreshGuarded() {
+        if (this.#failure)
+            return false;
+        try {
+            this.#refresh();
+            return true;
+        }
+        catch (cause) {
+            this.#failure =
+                cause instanceof Error
+                    ? cause
+                    : new Error(runtimeMessage("section.refresh", "Section tracking failed while the host document changed"));
+            this.#observer?.disconnect();
+            this.#mutations?.disconnect();
+            this.#wake();
+            return false;
+        }
+    }
+}
+function runtimeOwnedMutation(record) {
+    const target = record.target;
+    const element = typeof target.closest === "function" ? target : target.parentElement;
+    try {
+        return Boolean(element?.closest?.(RUNTIME_ROOTS));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/styles.d.ts

@@ -0,0 +1,18 @@
+export interface RuntimeStyleAsset {
+    /** Relative or absolute HTTPS candidate when supplied by Configuration. */
+    url: string;
+    integrity?: string;
+}
+export declare function connectRuntimeHost(host: HTMLElement, document: Document, marker: string): void;
+export declare function setBrowserStyleAsset(asset: RuntimeStyleAsset): void;
+export declare function validStyleIntegrity(value: unknown): value is string | undefined;
+export declare function resolveStyleAsset(configured: RuntimeStyleAsset | undefined, baseUrl: string): RuntimeStyleAsset;
+export declare class ShadowStyleSheet {
+    #private;
+    readonly ready: Promise<void>;
+    constructor(document: Document, root: ShadowRoot, asset: RuntimeStyleAsset);
+    addRule(selector: string): CSSStyleDeclaration;
+    removeRule(style: CSSStyleDeclaration): void;
+    destroy(): void;
+}
+//# sourceMappingURL=styles.d.ts.map

package/dist/styles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"styles.d.ts","sourceRoot":"","sources":["../src/styles.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,iBAAiB;IAChC,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,WAAW,EACjB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,GACb,IAAI,CAmBN;AAID,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAEnE;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,OAAO,GACb,KAAK,IAAI,MAAM,GAAG,SAAS,CAM7B;AAsBD,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,iBAAiB,GAAG,SAAS,EACzC,OAAO,EAAE,MAAM,GACd,iBAAiB,CAoBnB;AAED,qBAAa,gBAAgB;;IAC3B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAM9B,YAAY,QAAQ,EAAE,QAAQ,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,iBAAiB,EAmDzE;IAED,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAiB7C;IAED,UAAU,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI,CAU3C;IAED,OAAO,IAAI,IAAI,CAed;CACF"}

package/dist/styles.js

@@ -0,0 +1,132 @@
+import { runtimeMessage } from "./runtime-diagnostics.js";
+const browserBuild = typeof __PEEKLING_BROWSER_BUILD__ !== "undefined" &&
+    __PEEKLING_BROWSER_BUILD__;
+export function connectRuntimeHost(host, document, marker) {
+    if (host.ownerDocument !== document) {
+        throw new Error(runtimeMessage("root.document", "Peekling root was adopted into another document"));
+    }
+    const parent = document.documentElement;
+    if (!parent)
+        throw new Error(runtimeMessage("root.missing", "Peekling document has no document element"));
+    if (host.parentNode !== parent)
+        parent.append(host);
+    if (!host.hasAttribute(marker))
+        host.setAttribute(marker, "");
+}
+let browserDefault;
+export function setBrowserStyleAsset(asset) {
+    browserDefault = Object.freeze({ ...asset });
+}
+export function validStyleIntegrity(value) {
+    return (value === undefined ||
+        (typeof value === "string" &&
+            /^sha(?:256|384|512)-[A-Za-z0-9+/]+={0,2}$/.test(value)));
+}
+function defaultStyleAsset(baseUrl) {
+    if (browserBuild) {
+        return { url: new URL("./peekling.css", baseUrl).href };
+    }
+    try {
+        const url = new URL("./peekling.css", import.meta.url);
+        if (url.protocol === "https:" || url.protocol === "http:") {
+            return { url: url.href };
+        }
+    }
+    catch {
+        // The explicit Configuration hint below is stable across module loaders.
+    }
+    throw new TypeError(runtimeMessage("styles.default", "Pass styles.url pointing to @peekling/runtime/peekling.css"));
+}
+export function resolveStyleAsset(configured, baseUrl) {
+    const selected = configured ?? browserDefault ?? defaultStyleAsset(baseUrl);
+    const url = new URL(selected.url, baseUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+        throw new TypeError(runtimeMessage("styles.url", "styles.url must resolve to HTTP or HTTPS"));
+    }
+    if (!validStyleIntegrity(selected.integrity)) {
+        throw new TypeError(runtimeMessage("styles.integrity", "styles.integrity must be one SRI hash"));
+    }
+    return Object.freeze({
+        url: url.href,
+        ...(selected.integrity ? { integrity: selected.integrity } : {}),
+    });
+}
+export class ShadowStyleSheet {
+    ready;
+    #link;
+    #sheet;
+    #settled = false;
+    #rejectReady = () => { };
+    constructor(document, root, asset) {
+        const link = document.createElement("link");
+        this.#link = link;
+        link.rel = "stylesheet";
+        link.href = asset.url;
+        link.crossOrigin = "anonymous";
+        link.referrerPolicy = "no-referrer";
+        if (asset.integrity)
+            link.integrity = asset.integrity;
+        this.ready = new Promise((resolve, reject) => {
+            this.#rejectReady = reject;
+            const fail = (code, detail) => {
+                if (this.#settled)
+                    return;
+                this.#settled = true;
+                reject(new Error(runtimeMessage(code, detail)));
+            };
+            link.addEventListener("load", () => {
+                if (this.#settled)
+                    return;
+                const sheet = link.sheet;
+                if (!sheet || typeof sheet.insertRule !== "function") {
+                    fail("styles.cssom", "Peekling stylesheet did not expose CSSOM");
+                    return;
+                }
+                try {
+                    void sheet.cssRules.length;
+                }
+                catch {
+                    fail("styles.cors", "Peekling stylesheet requires same-origin or CORS-enabled delivery");
+                    return;
+                }
+                this.#sheet = sheet;
+                this.#settled = true;
+                resolve();
+            }, { once: true });
+            link.addEventListener("error", () => fail("styles.load", () => `Peekling stylesheet failed to load: ${asset.url}`), { once: true });
+        });
+        void this.ready.catch(() => { });
+        root.append(link);
+    }
+    addRule(selector) {
+        if (!this.#sheet)
+            throw new Error(runtimeMessage("styles.pending", "Peekling stylesheet is not ready"));
+        const index = this.#sheet.cssRules.length;
+        this.#sheet.insertRule(`${selector}{}`, index);
+        const rule = this.#sheet.cssRules[index];
+        if (!rule?.style) {
+            throw new Error(runtimeMessage("styles.rule", "Peekling stylesheet rule creation failed"));
+        }
+        return rule.style;
+    }
+    removeRule(style) {
+        const sheet = this.#sheet;
+        if (!sheet)
+            return;
+        for (let index = sheet.cssRules.length - 1; index >= 0; index--) {
+            const rule = sheet.cssRules[index];
+            if (rule?.style === style) {
+                sheet.deleteRule(index);
+                return;
+            }
+        }
+    }
+    destroy() {
+        if (!this.#settled) {
+            this.#settled = true;
+            this.#rejectReady(new DOMException(runtimeMessage("styles.cancelled", "Peekling stylesheet load cancelled"), "AbortError"));
+        }
+        this.#link.remove();
+        this.#sheet = undefined;
+    }
+}

package/dist/tooling-preflight.d.ts

@@ -0,0 +1,23 @@
+export interface PreflightOptions {
+    /** Optional Pack data used to validate Plan state and capability references. */
+    readonly pack?: unknown;
+    /** Base URL used only to resolve and validate relative resource URLs. */
+    readonly baseUrl?: string;
+}
+export interface PreflightDiagnostic {
+    readonly code: string;
+    readonly path: string;
+    readonly message: string;
+    readonly fix: string;
+}
+export interface PreflightResult {
+    readonly valid: boolean;
+    readonly errors: readonly PreflightDiagnostic[];
+    readonly warnings: readonly PreflightDiagnostic[];
+}
+/**
+ * Inspect configuration and optional Pack data without executing project code,
+ * predicates, callbacks, accessors, or network requests.
+ */
+export declare function preflight(configuration: unknown, options?: PreflightOptions): PreflightResult;
+//# sourceMappingURL=tooling-preflight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tooling-preflight.d.ts","sourceRoot":"","sources":["../src/tooling-preflight.ts"],"names":[],"mappings":"AAeA,MAAM,WAAW,gBAAgB;IAC/B,gFAAgF;IAChF,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,yEAAyE;IACzE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,MAAM,WAAW,mBAAmB;IAClC,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,mBAAmB,EAAE,CAAC;IAChD,QAAQ,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;CACnD;AAED;;;GAGG;AACH,wBAAgB,SAAS,CACvB,aAAa,EAAE,OAAO,EACtB,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CA2IjB"}

package/dist/tooling-preflight.js

@@ -0,0 +1,207 @@
+import { isNormalizedPack, validateNormalizedPack } from "./normalized.js";
+import { OwnDataError, snapshotConfiguration, snapshotOwnData, } from "./own-data.js";
+import { validateNativePack } from "./pack.js";
+import { preflight as configurationPreflight, } from "./preflight.js";
+import { toolingDiagnostic } from "./tooling-validation.js";
+import { NATIVE_DIRECTIONS } from "./types.js";
+/**
+ * Inspect configuration and optional Pack data without executing project code,
+ * predicates, callbacks, accessors, or network requests.
+ */
+export function preflight(configuration, options = {}) {
+    let checkedOptions;
+    try {
+        checkedOptions = snapshotOwnData(options);
+    }
+    catch (cause) {
+        return failedOptions(cause instanceof OwnDataError
+            ? cause.message
+            : "Preflight options cannot be inspected safely");
+    }
+    if (!checkedOptions ||
+        typeof checkedOptions !== "object" ||
+        Array.isArray(checkedOptions)) {
+        return failedOptions("Preflight options must be an object");
+    }
+    const toolErrors = [];
+    for (const field of Object.keys(checkedOptions)) {
+        if (field !== "pack" && field !== "baseUrl") {
+            toolErrors.push({
+                code: "unknown-preflight-option",
+                path: `$options.${field}`,
+                message: `Unknown preflight option ${field}`,
+                fix: "Remove this field",
+            });
+        }
+    }
+    const validBaseUrl = checkedOptions.baseUrl === undefined ||
+        (typeof checkedOptions.baseUrl === "string" &&
+            absoluteHttpUrl(checkedOptions.baseUrl));
+    if (!validBaseUrl) {
+        toolErrors.push({
+            code: "invalid-base-url",
+            path: "$options.baseUrl",
+            message: "baseUrl must be an absolute HTTP or HTTPS URL",
+            fix: "Pass the intended deployment page URL",
+        });
+    }
+    let snapshot;
+    let snapshotFailure;
+    try {
+        snapshot = snapshotConfiguration(configuration);
+    }
+    catch (cause) {
+        snapshotFailure = cause;
+    }
+    const externalPack = checkedOptions.pack;
+    if (externalPack !== undefined && snapshot?.pack !== undefined) {
+        toolErrors.push({
+            code: "pack-context-conflict",
+            path: "$options.pack",
+            message: "Configuration already contains an inline Pack",
+            fix: "Remove the external Pack option or the inline Configuration Pack",
+        });
+    }
+    const packInput = snapshot?.pack ?? externalPack;
+    let pack;
+    let packError;
+    if (packInput !== undefined) {
+        try {
+            pack = isNormalizedPack(packInput)
+                ? validateNormalizedPack(packInput)
+                : validateNativePack(packInput);
+        }
+        catch (cause) {
+            if (externalPack !== undefined && snapshot?.pack === undefined) {
+                packError = {
+                    code: "invalid-pack",
+                    path: "$pack",
+                    message: diagnosticMessage(cause),
+                    fix: "Pass a valid data-only Pack",
+                };
+            }
+        }
+    }
+    const checked = snapshot
+        ? configurationPreflight(snapshot, {
+            ...(validBaseUrl && typeof checkedOptions.baseUrl === "string"
+                ? { baseUrl: checkedOptions.baseUrl }
+                : {}),
+            ...(externalPack !== undefined ? { externalPackSelection: true } : {}),
+            ...(pack
+                ? {
+                    states: new Set(Object.keys(pack.states)),
+                    capabilities: new Set(pack.directionalStates &&
+                        NATIVE_DIRECTIONS.every((direction) => Object.hasOwn(pack.directionalStates ?? {}, direction))
+                        ? ["locomotion"]
+                        : []),
+                }
+                : {}),
+        })
+        : {
+            valid: false,
+            errors: [
+                {
+                    code: "invalid-options",
+                    path: "$",
+                    message: snapshotFailure instanceof OwnDataError
+                        ? snapshotFailure.message
+                        : "Options cannot be inspected safely",
+                    fix: "Pass own data in a local ordinary object or null-prototype object",
+                },
+            ],
+            warnings: [],
+        };
+    const errors = [
+        ...toolErrors,
+        ...(packError ? [packError] : []),
+        ...checked.errors,
+        ...(snapshot &&
+            pack &&
+            !checked.errors.some((issue) => issue.path === "$.atlasUrl")
+            ? inspectAtlasDensityPolicy(snapshot, pack)
+            : []),
+    ];
+    const warnings = [...checked.warnings];
+    if (snapshot?.plan && packInput === undefined) {
+        warnings.push({
+            code: "pack-context-missing",
+            path: "$.plan",
+            message: "Plan references cannot be checked without Pack context",
+            fix: "Pass the Pack with the preflight options or peekling doctor --pack",
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+function inspectAtlasDensityPolicy(options, pack) {
+    const variants = pack.atlas.variants;
+    if (!validDensity(options.maxDensity ?? 4)) {
+        return [];
+    }
+    const maxDensity = options.maxDensity ?? 4;
+    if (!variants?.length) {
+        const density = pack.atlas.density ?? 1;
+        const issues = [];
+        if (options.density !== undefined &&
+            validDensity(options.density) &&
+            options.density !== density) {
+            issues.push(toolingDiagnostic("atlas.override-density", "$.density", "single"));
+        }
+        if (density > maxDensity) {
+            issues.push(toolingDiagnostic("atlas.max-density", "$.maxDensity", "single"));
+        }
+        return issues;
+    }
+    if (typeof options.atlasUrl !== "string")
+        return [];
+    const available = variants.filter((item) => item.density <= maxDensity);
+    if (!available.length) {
+        return [toolingDiagnostic("atlas.max-density", "$.maxDensity")];
+    }
+    if (options.density === undefined) {
+        return [
+            toolingDiagnostic("atlas.override-density", "$.density", "missing"),
+        ];
+    }
+    if (!validDensity(options.density) ||
+        options.density > maxDensity ||
+        available.some((item) => item.density === options.density)) {
+        return [];
+    }
+    return [toolingDiagnostic("atlas.override-density", "$.density")];
+}
+function validDensity(value) {
+    return value === 1 || value === 2 || value === 4;
+}
+function failedOptions(message) {
+    return {
+        valid: false,
+        errors: [
+            {
+                code: "invalid-preflight-options",
+                path: "$options",
+                message,
+                fix: "Pass an optional Pack and baseUrl in an object",
+            },
+        ],
+        warnings: [],
+    };
+}
+function diagnosticMessage(cause) {
+    if (!(cause instanceof Error))
+        return "Pack could not be inspected safely";
+    return cause.message.replace(/^Pack validation failed:\s*/u, "").trim();
+}
+function absoluteHttpUrl(value) {
+    try {
+        const parsed = new URL(value);
+        return parsed.protocol === "http:" || parsed.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}

package/dist/tooling-validation.d.ts

@@ -0,0 +1,8 @@
+export interface ToolingConfigurationDiagnostic {
+    readonly code: string;
+    readonly path: string;
+    readonly message: string;
+    readonly fix: string;
+}
+export declare function toolingDiagnostic(code: string, path: string, detail?: string): ToolingConfigurationDiagnostic;
+//# sourceMappingURL=tooling-validation.d.ts.map

package/dist/tooling-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tooling-validation.d.ts","sourceRoot":"","sources":["../src/tooling-validation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,8BAA8B;IAC7C,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,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,8BAA8B,CAoLhC"}