@honua/app-platform 0.1.11-beta.0 → 0.1.13

package/offline/status.js

@@ -0,0 +1,479 @@
+import { normalizeOfflineReplaySyncConflictBinding, projectOfflineReplaySyncConflict, } from "./replay-conflict.js";
+import { HONUA_OFFLINE_REGION_DIAGNOSTIC_KIND, HONUA_OFFLINE_REGION_DIAGNOSTIC_VERSION, HonuaOfflineRegionError, } from "./types.js";
+/** Stable discriminator and version for composed local-first status snapshots. */
+export const HONUA_LOCAL_FIRST_STATUS_KIND = "honua.local-first-status";
+export const HONUA_LOCAL_FIRST_STATUS_VERSION = "1.0";
+/** Conservative ceilings applied before any input array is copied or sorted. */
+export const DEFAULT_LOCAL_FIRST_MAX_REGIONS = 1_000;
+export const DEFAULT_LOCAL_FIRST_MAX_EDITS = 10_000;
+export const DEFAULT_LOCAL_FIRST_MAX_LISTED_EDIT_IDS = 100;
+const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const OPTION_KEYS = new Set(["connectivity", "now", "regions", "edits", "editCounts", "replica", "limits"]);
+const LIMIT_KEYS = new Set(["maxRegions", "maxEdits", "maxListedEditIds"]);
+const DIAGNOSTIC_KEYS = new Set([
+    "kind",
+    "version",
+    "generatedAt",
+    "regionId",
+    "inventoryRevision",
+    "cache",
+    "provenance",
+    "contents",
+    "admission",
+    "storage",
+]);
+const DIAGNOSTIC_CACHE_KEYS = new Set([
+    "state",
+    "freshness",
+    "completeness",
+    "reason",
+    "readable",
+    "observedAt",
+    "ageMs",
+    "staleAfterMs",
+    "expectedLogicalBytes",
+    "storedLogicalBytes",
+    "lastAccessedAt",
+    "expiresAt",
+    "pinned",
+]);
+const QUEUED_EDIT_KEYS = new Set([
+    "version",
+    "id",
+    "requestFingerprint",
+    "authorizationScopeDigest",
+    "sourceId",
+    "idempotencyKey",
+    "edit",
+    "dependencyIds",
+    "state",
+    "createdAt",
+    "updatedAt",
+    "attemptCount",
+    "lease",
+    "retry",
+    "applied",
+    "conflict",
+    "conflictResolution",
+    "cancellation",
+    "audit",
+]);
+const RETRY_KEYS = new Set(["retryAt", "reasonCode"]);
+const CACHE_STATES = new Set(["offline", "missing"]);
+const FRESHNESS_VALUES = new Set(["fresh", "stale", "expired"]);
+const COMPLETENESS_VALUES = new Set(["complete", "partial", "missing"]);
+const CACHE_REASONS = new Set(["offline-entry", "stale-entry", "expired-entry", "partial-entry", "cache-miss"]);
+const EDIT_STATES = [
+    "pending",
+    "leased",
+    "retryable",
+    "applied",
+    "conflicted",
+    "cancelled",
+];
+const UNDELIVERED_EDIT_STATES = new Set(["pending", "leased", "retryable"]);
+const FRESHNESS_RANK = { fresh: 0, stale: 1, expired: 2 };
+const COMPLETENESS_RANK = { complete: 0, partial: 1, missing: 2 };
+/**
+ * Compose one local-first status from region diagnostics, durable queue state,
+ * and a host-supplied connectivity signal.
+ *
+ * The headline `state` is decided by a total precedence over cache and queue
+ * facets, with connectivity supplying only the base case:
+ *
+ * `conflicted` > `expired` > `partial` > `pending` > `stale` > `offline` > `online`
+ *
+ * Data problems therefore outrank undelivered work, which outranks mere
+ * staleness, which outranks being disconnected. Reads no payload bytes,
+ * performs no network or storage I/O, and mutates nothing.
+ */
+export function createLocalFirstStatus(options) {
+    const record = plainRecord(options, "options");
+    allowedKeys(record, OPTION_KEYS, "options");
+    const limits = normalizeLimits(record.limits);
+    const connectivity = record.connectivity;
+    if (connectivity !== "online" && connectivity !== "offline") {
+        invalid("options.connectivity must be online or offline.", "options.connectivity");
+    }
+    const nowMs = record.now instanceof Date ? record.now.getTime() : Number.NaN;
+    if (!Number.isFinite(nowMs))
+        invalid("options.now must be a valid Date.", "options.now");
+    const replica = record.replica === undefined
+        ? undefined
+        : normalizeOfflineReplaySyncConflictBinding(record.replica, "options.replica");
+    // Only an absent key defaults; an explicit null must not read as "none".
+    const reads = summarizeReads(record.regions === undefined ? [] : record.regions, connectivity, limits);
+    const writes = summarizeWrites(record.edits === undefined ? [] : record.edits, record.editCounts, limits, replica);
+    const { state, reason } = resolveHeadline(reads, writes, connectivity);
+    return deepFreeze({
+        kind: HONUA_LOCAL_FIRST_STATUS_KIND,
+        version: HONUA_LOCAL_FIRST_STATUS_VERSION,
+        generatedAt: new Date(nowMs).toISOString(),
+        state,
+        reason,
+        connectivity,
+        reads,
+        writes,
+    });
+}
+function resolveHeadline(reads, writes, connectivity) {
+    if (writes.conflictedCount > 0)
+        return { state: "conflicted", reason: "conflicted-edits" };
+    if (reads.freshness === "expired")
+        return { state: "expired", reason: "expired-regions" };
+    if (reads.regionCount > 0 && reads.completeness !== "complete") {
+        return { state: "partial", reason: reads.completeness === "missing" ? "missing-regions" : "partial-regions" };
+    }
+    if (writes.undeliveredCount > 0)
+        return { state: "pending", reason: "undelivered-edits" };
+    if (reads.freshness === "stale")
+        return { state: "stale", reason: "stale-regions" };
+    if (connectivity === "offline")
+        return { state: "offline", reason: "disconnected" };
+    return { state: "online", reason: "connected" };
+}
+function summarizeReads(value, connectivity, limits) {
+    const input = denseArray(value, "options.regions", limits.maxRegions);
+    const seen = new Set();
+    const regions = [];
+    let storedRegionCount = 0;
+    let readableRegionCount = 0;
+    let freshness = "fresh";
+    let completeness;
+    let oldestObservedAt;
+    let earliestExpiresAt;
+    for (let index = 0; index < input.length; index += 1) {
+        const summary = captureRegionSummary(input[index], `options.regions[${index}]`);
+        if (seen.has(summary.regionId)) {
+            invalid(`Duplicate region diagnostic "${summary.regionId}".`, `options.regions[${index}].regionId`);
+        }
+        seen.add(summary.regionId);
+        regions.push(summary);
+        if (summary.state === "offline") {
+            storedRegionCount += 1;
+            // Freshness describes data that is actually held; a cache miss has no
+            // stored observation to age, so it must not colour the aggregate.
+            if (FRESHNESS_RANK[summary.freshness] > FRESHNESS_RANK[freshness])
+                freshness = summary.freshness;
+        }
+        if (summary.readable)
+            readableRegionCount += 1;
+        if (completeness === undefined || COMPLETENESS_RANK[summary.completeness] > COMPLETENESS_RANK[completeness]) {
+            completeness = summary.completeness;
+        }
+        if (oldestObservedAt === undefined || isEarlier(summary.observedAt, oldestObservedAt)) {
+            oldestObservedAt = summary.observedAt;
+        }
+        if (summary.expiresAt !== undefined &&
+            (earliestExpiresAt === undefined || isEarlier(summary.expiresAt, earliestExpiresAt))) {
+            earliestExpiresAt = summary.expiresAt;
+        }
+    }
+    regions.sort((left, right) => compareCodeUnits(left.regionId, right.regionId));
+    const availability = connectivity === "online" ? "live" : readableRegionCount > 0 ? "cached" : "unavailable";
+    return {
+        availability,
+        freshness,
+        completeness: completeness ?? "missing",
+        regionCount: regions.length,
+        storedRegionCount,
+        readableRegionCount,
+        ...(oldestObservedAt === undefined ? {} : { oldestObservedAt }),
+        ...(earliestExpiresAt === undefined ? {} : { earliestExpiresAt }),
+        regions,
+    };
+}
+function captureRegionSummary(value, path) {
+    const record = plainRecord(value, path);
+    allowedKeys(record, DIAGNOSTIC_KEYS, path);
+    if (record.kind !== HONUA_OFFLINE_REGION_DIAGNOSTIC_KIND)
+        invalid(`${path}.kind is unsupported.`, `${path}.kind`);
+    if (record.version !== HONUA_OFFLINE_REGION_DIAGNOSTIC_VERSION) {
+        invalid(`${path}.version is unsupported.`, `${path}.version`);
+    }
+    // Present but never descended into: this projection reads no payload,
+    // admission arithmetic, storage estimate, or attribution text.
+    plainRecord(record.contents, `${path}.contents`);
+    plainRecord(record.admission, `${path}.admission`);
+    if (record.storage !== undefined)
+        plainRecord(record.storage, `${path}.storage`);
+    const cache = plainRecord(record.cache, `${path}.cache`);
+    allowedKeys(cache, DIAGNOSTIC_CACHE_KEYS, `${path}.cache`);
+    const provenance = plainRecord(record.provenance, `${path}.provenance`);
+    const state = memberOf(cache.state, CACHE_STATES, `${path}.cache.state`);
+    const freshness = memberOf(cache.freshness, FRESHNESS_VALUES, `${path}.cache.freshness`);
+    const completeness = memberOf(cache.completeness, COMPLETENESS_VALUES, `${path}.cache.completeness`);
+    const reason = memberOf(cache.reason, CACHE_REASONS, `${path}.cache.reason`);
+    const readable = requiredBoolean(cache.readable, `${path}.cache.readable`);
+    assertCacheFacetsAgree({ state, freshness, completeness, reason, readable }, `${path}.cache`);
+    return {
+        regionId: requiredString(record.regionId, `${path}.regionId`),
+        sourceId: requiredString(provenance.sourceId, `${path}.provenance.sourceId`),
+        authorizationScopeDigest: requiredDigest(provenance.authorizationScopeDigest, `${path}.provenance.authorizationScopeDigest`),
+        state,
+        freshness,
+        completeness,
+        reason,
+        readable,
+        observedAt: normalizedTimestamp(cache.observedAt, `${path}.cache.observedAt`),
+        ageMs: nonNegativeInteger(cache.ageMs, `${path}.cache.ageMs`),
+        ...(cache.expiresAt === undefined
+            ? {}
+            : { expiresAt: normalizedTimestamp(cache.expiresAt, `${path}.cache.expiresAt`) }),
+        pinned: requiredBoolean(cache.pinned, `${path}.cache.pinned`),
+    };
+}
+/**
+ * `createOfflineRegionDiagnostic` derives every cache facet from one stored
+ * entry, so the facets are not independent. Checking each literal in isolation
+ * would accept impossible combinations - a `missing` entry claiming to be
+ * `complete` and `readable` - and an impossible input would then resolve to a
+ * confidently wrong headline. Reject the combination instead.
+ */
+function assertCacheFacetsAgree(facets, path) {
+    const stored = facets.state === "offline";
+    if (stored !== (facets.completeness !== "missing")) {
+        invalid(`${path}.completeness does not agree with ${path}.state.`, `${path}.completeness`);
+    }
+    const readable = stored && facets.completeness === "complete" && facets.freshness !== "expired";
+    if (facets.readable !== readable) {
+        invalid(`${path}.readable does not agree with the reported cache facets.`, `${path}.readable`);
+    }
+    const reason = !stored
+        ? "cache-miss"
+        : facets.freshness === "expired"
+            ? "expired-entry"
+            : facets.completeness === "partial"
+                ? "partial-entry"
+                : facets.freshness === "stale"
+                    ? "stale-entry"
+                    : "offline-entry";
+    if (facets.reason !== reason) {
+        invalid(`${path}.reason does not agree with the reported cache facets.`, `${path}.reason`);
+    }
+}
+function summarizeWrites(value, countsValue, limits, replica) {
+    const input = denseArray(value, "options.edits", limits.maxEdits);
+    const counts = {
+        pending: 0,
+        leased: 0,
+        retryable: 0,
+        applied: 0,
+        conflicted: 0,
+        cancelled: 0,
+    };
+    const seen = new Set();
+    const conflictedEditIds = [];
+    const projections = new Map();
+    let nextRetryAt;
+    let oldestUndeliveredAt;
+    for (let index = 0; index < input.length; index += 1) {
+        const path = `options.edits[${index}]`;
+        const record = plainRecord(input[index], path);
+        allowedKeys(record, QUEUED_EDIT_KEYS, path);
+        const id = requiredDigest(record.id, `${path}.id`);
+        if (seen.has(id))
+            invalid(`Duplicate queued edit "${id}".`, `${path}.id`);
+        seen.add(id);
+        const state = memberOfList(record.state, EDIT_STATES, `${path}.state`);
+        counts[state] += 1;
+        const createdAt = normalizedTimestamp(record.createdAt, `${path}.createdAt`);
+        if (state === "conflicted") {
+            conflictedEditIds.push(id);
+            // Projected from the same record this summary already validated, so the
+            // conflict vocabulary and the conflicted-edit count can never disagree.
+            if (replica !== undefined) {
+                projections.set(id, projectOfflineReplaySyncConflict({ edit: record, replica }));
+            }
+        }
+        if (UNDELIVERED_EDIT_STATES.has(state)) {
+            if (oldestUndeliveredAt === undefined || isEarlier(createdAt, oldestUndeliveredAt)) {
+                oldestUndeliveredAt = createdAt;
+            }
+        }
+        if (record.retry !== undefined) {
+            const retry = plainRecord(record.retry, `${path}.retry`);
+            allowedKeys(retry, RETRY_KEYS, `${path}.retry`);
+            const retryAt = normalizedTimestamp(retry.retryAt, `${path}.retry.retryAt`);
+            if (state === "retryable" && (nextRetryAt === undefined || isEarlier(retryAt, nextRetryAt))) {
+                nextRetryAt = retryAt;
+            }
+        }
+    }
+    conflictedEditIds.sort(compareCodeUnits);
+    // Authoritative totals win. A bounded sample can only ever be a lower bound,
+    // and reporting it as the total would let later undelivered work read as idle.
+    const authoritative = captureEditCounts(countsValue, counts);
+    const totals = authoritative ?? counts;
+    const conflictedCount = totals.conflicted;
+    const listedConflictedEditIds = conflictedEditIds.slice(0, limits.maxListedEditIds);
+    return {
+        state: conflictedCount > 0 ? "conflicted" : undeliveredTotal(totals) > 0 ? "pending" : "idle",
+        coverage: authoritative ? "complete" : "sampled",
+        counts: { ...totals },
+        undeliveredCount: undeliveredTotal(totals),
+        conflictedCount,
+        conflictedEditIds: listedConflictedEditIds,
+        conflictedEditIdsTruncated: conflictedCount > Math.min(conflictedEditIds.length, limits.maxListedEditIds),
+        syncConflicts: listedConflictedEditIds.map((id) => projections.get(id)).filter(isProjection),
+        ...(nextRetryAt === undefined ? {} : { nextRetryAt }),
+        ...(oldestUndeliveredAt === undefined ? {} : { oldestUndeliveredAt }),
+    };
+}
+function isProjection(value) {
+    return value !== undefined;
+}
+function undeliveredTotal(counts) {
+    let total = 0;
+    for (const state of EDIT_STATES)
+        if (UNDELIVERED_EDIT_STATES.has(state))
+            total += counts[state];
+    return total;
+}
+function captureEditCounts(value, sampled) {
+    if (value === undefined)
+        return undefined;
+    const record = plainRecord(value, "options.editCounts");
+    allowedKeys(record, new Set(EDIT_STATES), "options.editCounts");
+    const totals = { ...sampled };
+    for (const state of EDIT_STATES) {
+        const total = nonNegativeInteger(record[state], `options.editCounts.${state}`);
+        // A sample that exceeds its own total means the two inputs disagree; refuse
+        // rather than publish a status that cannot be true.
+        if (total < sampled[state]) {
+            invalid(`options.editCounts.${state} is smaller than the supplied sample.`, `options.editCounts.${state}`);
+        }
+        totals[state] = total;
+    }
+    return totals;
+}
+function normalizeLimits(value) {
+    if (value === undefined) {
+        return {
+            maxRegions: DEFAULT_LOCAL_FIRST_MAX_REGIONS,
+            maxEdits: DEFAULT_LOCAL_FIRST_MAX_EDITS,
+            maxListedEditIds: DEFAULT_LOCAL_FIRST_MAX_LISTED_EDIT_IDS,
+        };
+    }
+    const record = plainRecord(value, "options.limits");
+    allowedKeys(record, LIMIT_KEYS, "options.limits");
+    return {
+        maxRegions: tightened(record.maxRegions, DEFAULT_LOCAL_FIRST_MAX_REGIONS, "options.limits.maxRegions"),
+        maxEdits: tightened(record.maxEdits, DEFAULT_LOCAL_FIRST_MAX_EDITS, "options.limits.maxEdits"),
+        maxListedEditIds: tightened(record.maxListedEditIds, DEFAULT_LOCAL_FIRST_MAX_LISTED_EDIT_IDS, "options.limits.maxListedEditIds"),
+    };
+}
+function tightened(value, ceiling, path) {
+    return Math.min(value === undefined ? ceiling : nonNegativeInteger(value, path), ceiling);
+}
+function plainRecord(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        invalid(`${path} must be a plain object.`, path);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+        invalid(`${path} must be a plain object.`, path);
+    if (Object.getOwnPropertySymbols(value).length > 0)
+        invalid(`${path} must not contain symbol properties.`, path);
+    for (const key in value) {
+        if (!Object.hasOwn(value, key))
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(value, key);
+        if (!descriptor || !("value" in descriptor))
+            invalid(`${path}.${key} must be a data property.`, `${path}.${key}`);
+    }
+    return value;
+}
+function allowedKeys(record, allowed, path) {
+    for (const key in record) {
+        if (Object.hasOwn(record, key) && !allowed.has(key))
+            invalid(`${path}.${key} is not supported.`, `${path}.${key}`);
+    }
+}
+function denseArray(value, path, maximum) {
+    if (!Array.isArray(value))
+        invalid(`${path} must be an array.`, path);
+    if (Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length > 0) {
+        invalid(`${path} must be a plain array.`, path);
+    }
+    if (value.length > maximum) {
+        throw new HonuaOfflineRegionError("resource-limit-exceeded", `${path} contains ${value.length} entries; maximum is ${maximum}.`, { path });
+    }
+    for (const key in value) {
+        if (!Object.hasOwn(value, key))
+            continue;
+        const index = Number(key);
+        if (!Number.isSafeInteger(index) || index < 0 || index >= value.length || String(index) !== key) {
+            invalid(`${path} must not contain named properties.`, `${path}.${key}`);
+        }
+    }
+    for (let index = 0; index < value.length; index += 1) {
+        if (!Object.hasOwn(value, index))
+            invalid(`${path} must not contain sparse entries.`, `${path}[${index}]`);
+        const descriptor = Object.getOwnPropertyDescriptor(value, index);
+        if (!descriptor || !("value" in descriptor)) {
+            invalid(`${path}[${index}] must be a data property.`, `${path}[${index}]`);
+        }
+    }
+    return value;
+}
+function memberOf(value, allowed, path) {
+    if (typeof value !== "string" || !allowed.has(value))
+        invalid(`${path} is invalid.`, path);
+    return value;
+}
+function memberOfList(value, allowed, path) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        invalid(`${path} is invalid.`, path);
+    }
+    return value;
+}
+function requiredString(value, path) {
+    if (typeof value !== "string" || value.length === 0 || value.trim() !== value) {
+        invalid(`${path} must be a normalized non-empty string.`, path);
+    }
+    return value;
+}
+function requiredDigest(value, path) {
+    const result = requiredString(value, path);
+    if (!DIGEST_PATTERN.test(result))
+        invalid(`${path} must be a lowercase SHA-256 digest.`, path);
+    return result;
+}
+function requiredBoolean(value, path) {
+    if (typeof value !== "boolean")
+        invalid(`${path} must be a boolean.`, path);
+    return value;
+}
+function nonNegativeInteger(value, path) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        invalid(`${path} must be a non-negative safe integer.`, path);
+    }
+    return value;
+}
+function normalizedTimestamp(value, path) {
+    const raw = requiredString(value, path);
+    const parsed = Date.parse(raw);
+    if (!Number.isFinite(parsed) || new Date(parsed).toISOString() !== raw) {
+        invalid(`${path} must be a normalized ISO-8601 timestamp.`, path);
+    }
+    return raw;
+}
+function compareCodeUnits(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/** Chronological comparison; normalized ISO strings still differ lexically for expanded years. */
+function isEarlier(candidate, current) {
+    return Date.parse(candidate) < Date.parse(current);
+}
+function invalid(message, path) {
+    throw new HonuaOfflineRegionError("invalid-manifest", message, { path });
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return value;
+}

package/offline/store-conformance.d.ts

@@ -0,0 +1,48 @@
+import { type OfflineRegionStore } from "./types.js";
+/**
+ * One conformance suite every offline region store must pass.
+ *
+ * The IndexedDB adapter can only run in a browser and the in-memory adapter can
+ * run anywhere, so the suite is written as plain async functions rather than
+ * against a test framework: vitest runs it over the memory store, and the browser
+ * evidence runs the identical cases over real IndexedDB. A store that passes here
+ * is substitutable in the download coordinator and the read path.
+ *
+ * @experimental
+ */
+export declare const HONUA_OFFLINE_REGION_STORE_CONFORMANCE_KIND: "honua.offline-region-store-conformance";
+export declare const HONUA_OFFLINE_REGION_STORE_CONFORMANCE_VERSION: "1.0";
+export interface OfflineRegionStoreConformanceOptions {
+    /** Must return a store with no committed regions. Called once per case. */
+    readonly createStore: () => OfflineRegionStore | Promise<OfflineRegionStore>;
+    /** Optional teardown for the store a case finished with. */
+    readonly disposeStore?: (store: OfflineRegionStore) => void | Promise<void>;
+    /** Human label recorded on the report (for example `indexeddb`). */
+    readonly label?: string;
+    /** Run a subset by name. Unknown names fail the report rather than passing silently. */
+    readonly only?: readonly string[];
+}
+export interface OfflineRegionStoreConformanceCaseResultV1 {
+    readonly name: string;
+    readonly status: "passed" | "failed";
+    readonly detail?: string;
+}
+export interface OfflineRegionStoreConformanceReportV1 {
+    readonly kind: typeof HONUA_OFFLINE_REGION_STORE_CONFORMANCE_KIND;
+    readonly version: typeof HONUA_OFFLINE_REGION_STORE_CONFORMANCE_VERSION;
+    readonly label?: string;
+    readonly total: number;
+    readonly passed: number;
+    readonly failed: number;
+    readonly cases: readonly OfflineRegionStoreConformanceCaseResultV1[];
+}
+/** Names of every case in the suite, in execution order. */
+export declare const OFFLINE_REGION_STORE_CONFORMANCE_CASES: readonly string[];
+/**
+ * Run the suite and report per-case outcomes.
+ *
+ * Cases never share a store: each one is handed a fresh store from
+ * `createStore`, so a failure cannot cascade into a false failure downstream.
+ */
+export declare function runOfflineRegionStoreConformance(options: OfflineRegionStoreConformanceOptions): Promise<OfflineRegionStoreConformanceReportV1>;
+//# sourceMappingURL=store-conformance.d.ts.map

package/offline/store-conformance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store-conformance.d.ts","sourceRoot":"","sources":["../../../src/offline/store-conformance.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,kBAAkB,EACxB,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,2CAA2C,EAAG,wCAAiD,CAAC;AAC7G,eAAO,MAAM,8CAA8C,EAAG,KAAc,CAAC;AAE7E,MAAM,WAAW,oCAAoC;IACnD,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC7E,4DAA4D;IAC5D,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5E,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,wFAAwF;IACxF,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,yCAAyC;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,qCAAqC;IACpD,QAAQ,CAAC,IAAI,EAAE,OAAO,2CAA2C,CAAC;IAClE,QAAQ,CAAC,OAAO,EAAE,OAAO,8CAA8C,CAAC;IACxE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,SAAS,yCAAyC,EAAE,CAAC;CACtE;AAOD,4DAA4D;AAC5D,eAAO,MAAM,sCAAsC,EAAE,SAAS,MAAM,EAWnE,CAAC;AAgIF;;;;;GAKG;AACH,wBAAsB,gCAAgC,CACpD,OAAO,EAAE,oCAAoC,GAC5C,OAAO,CAAC,qCAAqC,CAAC,CAoChD"}