@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/decompress.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The shape this needs, rather than the class it usually gets (AGL-1151).
+ *
+ * A structural type keeps `firebase/firestore` out of this module entirely.
+ * The import here was type-only and therefore erased — it cost nothing — but
+ * naming the shape says what is actually required and stops the next person
+ * reaching for the class again.
+ */
+export interface ByteSource {
+    toUint8Array(): Uint8Array;
+}
+/**
+ * Either form the bytes arrive in: a Firestore `Bytes` (client SDK) or a bare
+ * view (AGL-1223). The Admin SDK materialises a bytes field as a Node
+ * `Buffer`, which has no `toUint8Array`, so server readers had to hand-roll an
+ * adapter — and the obvious adapter is wrong (see below).
+ */
+export type CompressedValue = ByteSource | ArrayBufferView;
+export declare function decompress<T>(value: CompressedValue): T;
+export default decompress;

package/src/lib/app-utils/decompress.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright 2022 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { decode } from "@msgpack/msgpack";
+function toBytes(value) {
+    if (ArrayBuffer.isView(value)) {
+        // Offset and length, ALWAYS. firebase-admin hands back POOLED Buffers —
+        // a 156-byte field is typically a view at some offset into a shared 8 KB
+        // ArrayBuffer — so `new Uint8Array(value.buffer)` decodes the whole pool
+        // and throws on the trailing garbage instead of returning the document.
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return value.toUint8Array();
+}
+export function decompress(value) {
+    return decode(toBytes(value));
+}
+export default decompress;
+
+//# sourceMappingURL=decompress.js.map

package/src/lib/app-utils/decompress.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/decompress.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2022 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { decode } from '@msgpack/msgpack'\n\n/**\n * The shape this needs, rather than the class it usually gets (AGL-1151).\n *\n * A structural type keeps `firebase/firestore` out of this module entirely.\n * The import here was type-only and therefore erased — it cost nothing — but\n * naming the shape says what is actually required and stops the next person\n * reaching for the class again.\n */\nexport interface ByteSource {\n  toUint8Array(): Uint8Array\n}\n\n/**\n * Either form the bytes arrive in: a Firestore `Bytes` (client SDK) or a bare\n * view (AGL-1223). The Admin SDK materialises a bytes field as a Node\n * `Buffer`, which has no `toUint8Array`, so server readers had to hand-roll an\n * adapter — and the obvious adapter is wrong (see below).\n */\nexport type CompressedValue = ByteSource | ArrayBufferView\n\nfunction toBytes(value: CompressedValue): Uint8Array {\n  if (ArrayBuffer.isView(value)) {\n    // Offset and length, ALWAYS. firebase-admin hands back POOLED Buffers —\n    // a 156-byte field is typically a view at some offset into a shared 8 KB\n    // ArrayBuffer — so `new Uint8Array(value.buffer)` decodes the whole pool\n    // and throws on the trailing garbage instead of returning the document.\n    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength)\n  }\n  return value.toUint8Array()\n}\n\nexport function decompress<T>(value: CompressedValue): T {\n  return decode(toBytes(value)) as T\n}\nexport default decompress\n"],"names":["decode","toBytes","value","ArrayBuffer","isView","Uint8Array","buffer","byteOffset","byteLength","toUint8Array","decompress"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,MAAM,QAAQ,mBAAkB;AAsBzC,SAASC,QAAQC,KAAsB;IACrC,IAAIC,YAAYC,MAAM,CAACF,QAAQ;QAC7B,wEAAwE;QACxE,yEAAyE;QACzE,yEAAyE;QACzE,wEAAwE;QACxE,OAAO,IAAIG,WAAWH,MAAMI,MAAM,EAAEJ,MAAMK,UAAU,EAAEL,MAAMM,UAAU;IACxE;IACA,OAAON,MAAMO,YAAY;AAC3B;AAEA,OAAO,SAASC,WAAcR,KAAsB;IAClD,OAAOF,OAAOC,QAAQC;AACxB;AACA,eAAeQ,WAAU"}

package/src/lib/app-utils/dedicated-sending-domain.d.ts

@@ -0,0 +1,47 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { AglynOrgBilling, OrgPlan } from '../foundation/definitions/org-billing.types';
+/**
+ * The lowest plan whose sites get a domain of their own, for the surfaces that
+ * have to NAME a tier — an upsell card, a refusal that says what to buy.
+ *
+ * Derived from `PLAN_ENTITLEMENTS` rather than declared, because a tier name
+ * written down beside a gate is pricing copy that keeps rendering after the
+ * gate moves. There is one decision here — the flag's column in the plan
+ * table — and this is a view of it, so the two cannot disagree.
+ *
+ * `planGrantingFeature` walks the self-serve ladder and then `enterprise`,
+ * which is priced by contract and is not a rung of `SELF_SERVE_PLANS`. It
+ * answers `undefined` when no plan carries the flag on its base tier; a caller
+ * naming a tier must handle that rather than substituting one.
+ */
+export declare const DEDICATED_SENDING_DOMAIN_MIN_PLAN: OrgPlan;
+/**
+ * Whether an org's sites may hold a dedicated platform sending domain.
+ *
+ * Takes the ORG rather than its plan name, and that is the whole point: the
+ * answer is the plan's default with the org's own overrides applied, so a
+ * grant on one account is honored here without moving the account's tier.
+ *
+ * An absent org answers `false`. `resolveOrgEntitlements(null)` resolves to
+ * the free plan, which carries no dedicated domain, so a site whose org cannot
+ * be read still sends — on the pool, like every other site. The cost of
+ * failing closed is that a domain is not provisioned until the org resolves,
+ * which the sweep then corrects. Failing open would spend a zone record and a
+ * provider slot on an org nobody could name.
+ */
+export declare function holdsDedicatedSendingDomain(org: Partial<AglynOrgBilling> | null | undefined): boolean;

package/src/lib/app-utils/dedicated-sending-domain.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * WHO GETS A SENDING DOMAIN OF THEIR OWN.
+ *
+ * A site's mail leaves on one of three kinds of identity, and this module
+ * decides which of them an org may reach:
+ *
+ *   shared pool     `notifications@shared{n}.mail.aglyn.app`. Every site,
+ *                   every tier, no provisioning, no DNS. Transactional only.
+ *   dedicated       `hello@{label}.mail.aglyn.app`. One provider domain object
+ *                   and three records in OUR zone, per site. **This module.**
+ *   customer-owned  `hello@acme.com`. One provider domain object and records
+ *                   the customer publishes in THEIR zone. Gated separately, on
+ *                   the `customSendingDomain` feature flag, and available from
+ *                   the same tier as this one — it is the option that costs
+ *                   the platform no zone records at all, so it is the one that
+ *                   scales.
+ *
+ * ## Why the dedicated tier is a gate at all
+ *
+ * Not because a domain object has a price — it does not; the provider meters
+ * emails and contacts and bundles domains as a quota. Because it is `O(hosts)`
+ * in resources that do not stretch:
+ *
+ *   - **Records in our own zone.** Three per site, forever. Nothing about a
+ *     customer-owned domain costs us this, which is why the two are separate
+ *     decisions rather than one "custom domain" feature.
+ *   - **The provider's account-wide domain allowance**, which is a bundled
+ *     quota with a real ceiling and no self-serve way past a certain size.
+ *   - **A place in the re-verification sweep, permanently.** Every dedicated
+ *     domain has to be re-checked on a schedule, against DNS and against the
+ *     provider, at an account-wide rate limit the SENDS share. That cost
+ *     recurs; the provisioning cost is paid once.
+ *
+ * Provisioning by SIGNUP spends all three on sites that may never send a
+ * message. Provisioning by PLAN spends them on sites whose revenue covers
+ * them — better, and still the wrong curve, because revenue is the number the
+ * platform is trying to grow while the provider's allowance grows only by
+ * purchase.
+ *
+ * So this gate is one of three conditions and not the only one. A domain is
+ * claimed when a merchant ASKS for one, from the sending-identity route; this
+ * decides whether their org carries what they asked for; and the provider
+ * ceiling in `provision-sending-domain.ts` decides whether the claim can
+ * actually be filled. Demand is therefore proportional to the merchants who
+ * want an Aglyn-branded sending name rather than to everyone who pays, and a
+ * site refused at any of the three keeps sending on the shared pool.
+ *
+ * ## An entitlement, so one org can be granted one
+ *
+ * `dedicatedSendingDomain` is read through `checkEntitlement` like every other
+ * capability on the platform, which buys two things a plan comparison cannot.
+ *
+ * A per-org override GRANTS it: staff can put a single lower-tier org on a
+ * dedicated domain — the support case this gate meets most often — without
+ * repricing the account, and the grant is a field on the org document with an
+ * audit row rather than a plan change that also moves eight quotas. The
+ * override is a draw on the provider's allowance like any other claim, so it
+ * is bounded by the same ceiling; what it is not bounded by is the tier.
+ *
+ * A dead subscription REVOKES it. `resolveEffectivePlan` reads a canceled or
+ * unpaid subscription down to `free`, so an org that stops paying stops being
+ * able to claim NEW domains here — while the sites it already holds keep
+ * theirs, because the claim path's pinned-label early return sits above this
+ * gate and a downgrade never repossesses a name that has earned reputation.
+ *
+ * Nothing outside this file decides who may hold a dedicated domain.
+ */ import { checkEntitlement, planGrantingFeature } from "./plan-entitlements.js";
+/**
+ * The lowest plan whose sites get a domain of their own, for the surfaces that
+ * have to NAME a tier — an upsell card, a refusal that says what to buy.
+ *
+ * Derived from `PLAN_ENTITLEMENTS` rather than declared, because a tier name
+ * written down beside a gate is pricing copy that keeps rendering after the
+ * gate moves. There is one decision here — the flag's column in the plan
+ * table — and this is a view of it, so the two cannot disagree.
+ *
+ * `planGrantingFeature` walks the self-serve ladder and then `enterprise`,
+ * which is priced by contract and is not a rung of `SELF_SERVE_PLANS`. It
+ * answers `undefined` when no plan carries the flag on its base tier; a caller
+ * naming a tier must handle that rather than substituting one.
+ */ export const DEDICATED_SENDING_DOMAIN_MIN_PLAN = planGrantingFeature('dedicatedSendingDomain');
+/**
+ * Whether an org's sites may hold a dedicated platform sending domain.
+ *
+ * Takes the ORG rather than its plan name, and that is the whole point: the
+ * answer is the plan's default with the org's own overrides applied, so a
+ * grant on one account is honored here without moving the account's tier.
+ *
+ * An absent org answers `false`. `resolveOrgEntitlements(null)` resolves to
+ * the free plan, which carries no dedicated domain, so a site whose org cannot
+ * be read still sends — on the pool, like every other site. The cost of
+ * failing closed is that a domain is not provisioned until the org resolves,
+ * which the sweep then corrects. Failing open would spend a zone record and a
+ * provider slot on an org nobody could name.
+ */ export function holdsDedicatedSendingDomain(org) {
+    return checkEntitlement(org, 'dedicatedSendingDomain');
+}
+
+//# sourceMappingURL=dedicated-sending-domain.js.map

package/src/lib/app-utils/dedicated-sending-domain.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/dedicated-sending-domain.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * WHO GETS A SENDING DOMAIN OF THEIR OWN.\n *\n * A site's mail leaves on one of three kinds of identity, and this module\n * decides which of them an org may reach:\n *\n *   shared pool     `notifications@shared{n}.mail.aglyn.app`. Every site,\n *                   every tier, no provisioning, no DNS. Transactional only.\n *   dedicated       `hello@{label}.mail.aglyn.app`. One provider domain object\n *                   and three records in OUR zone, per site. **This module.**\n *   customer-owned  `hello@acme.com`. One provider domain object and records\n *                   the customer publishes in THEIR zone. Gated separately, on\n *                   the `customSendingDomain` feature flag, and available from\n *                   the same tier as this one — it is the option that costs\n *                   the platform no zone records at all, so it is the one that\n *                   scales.\n *\n * ## Why the dedicated tier is a gate at all\n *\n * Not because a domain object has a price — it does not; the provider meters\n * emails and contacts and bundles domains as a quota. Because it is `O(hosts)`\n * in resources that do not stretch:\n *\n *   - **Records in our own zone.** Three per site, forever. Nothing about a\n *     customer-owned domain costs us this, which is why the two are separate\n *     decisions rather than one \"custom domain\" feature.\n *   - **The provider's account-wide domain allowance**, which is a bundled\n *     quota with a real ceiling and no self-serve way past a certain size.\n *   - **A place in the re-verification sweep, permanently.** Every dedicated\n *     domain has to be re-checked on a schedule, against DNS and against the\n *     provider, at an account-wide rate limit the SENDS share. That cost\n *     recurs; the provisioning cost is paid once.\n *\n * Provisioning by SIGNUP spends all three on sites that may never send a\n * message. Provisioning by PLAN spends them on sites whose revenue covers\n * them — better, and still the wrong curve, because revenue is the number the\n * platform is trying to grow while the provider's allowance grows only by\n * purchase.\n *\n * So this gate is one of three conditions and not the only one. A domain is\n * claimed when a merchant ASKS for one, from the sending-identity route; this\n * decides whether their org carries what they asked for; and the provider\n * ceiling in `provision-sending-domain.ts` decides whether the claim can\n * actually be filled. Demand is therefore proportional to the merchants who\n * want an Aglyn-branded sending name rather than to everyone who pays, and a\n * site refused at any of the three keeps sending on the shared pool.\n *\n * ## An entitlement, so one org can be granted one\n *\n * `dedicatedSendingDomain` is read through `checkEntitlement` like every other\n * capability on the platform, which buys two things a plan comparison cannot.\n *\n * A per-org override GRANTS it: staff can put a single lower-tier org on a\n * dedicated domain — the support case this gate meets most often — without\n * repricing the account, and the grant is a field on the org document with an\n * audit row rather than a plan change that also moves eight quotas. The\n * override is a draw on the provider's allowance like any other claim, so it\n * is bounded by the same ceiling; what it is not bounded by is the tier.\n *\n * A dead subscription REVOKES it. `resolveEffectivePlan` reads a canceled or\n * unpaid subscription down to `free`, so an org that stops paying stops being\n * able to claim NEW domains here — while the sites it already holds keep\n * theirs, because the claim path's pinned-label early return sits above this\n * gate and a downgrade never repossesses a name that has earned reputation.\n *\n * Nothing outside this file decides who may hold a dedicated domain.\n */\n\nimport { checkEntitlement, planGrantingFeature } from './plan-entitlements'\nimport type {\n  AglynOrgBilling,\n  OrgPlan,\n} from '../foundation/definitions/org-billing.types'\n\n/**\n * The lowest plan whose sites get a domain of their own, for the surfaces that\n * have to NAME a tier — an upsell card, a refusal that says what to buy.\n *\n * Derived from `PLAN_ENTITLEMENTS` rather than declared, because a tier name\n * written down beside a gate is pricing copy that keeps rendering after the\n * gate moves. There is one decision here — the flag's column in the plan\n * table — and this is a view of it, so the two cannot disagree.\n *\n * `planGrantingFeature` walks the self-serve ladder and then `enterprise`,\n * which is priced by contract and is not a rung of `SELF_SERVE_PLANS`. It\n * answers `undefined` when no plan carries the flag on its base tier; a caller\n * naming a tier must handle that rather than substituting one.\n */\nexport const DEDICATED_SENDING_DOMAIN_MIN_PLAN: OrgPlan = planGrantingFeature(\n  'dedicatedSendingDomain',\n)\n\n/**\n * Whether an org's sites may hold a dedicated platform sending domain.\n *\n * Takes the ORG rather than its plan name, and that is the whole point: the\n * answer is the plan's default with the org's own overrides applied, so a\n * grant on one account is honored here without moving the account's tier.\n *\n * An absent org answers `false`. `resolveOrgEntitlements(null)` resolves to\n * the free plan, which carries no dedicated domain, so a site whose org cannot\n * be read still sends — on the pool, like every other site. The cost of\n * failing closed is that a domain is not provisioned until the org resolves,\n * which the sweep then corrects. Failing open would spend a zone record and a\n * provider slot on an org nobody could name.\n */\nexport function holdsDedicatedSendingDomain(\n  org: Partial<AglynOrgBilling> | null | undefined,\n): boolean {\n  return checkEntitlement(org, 'dedicatedSendingDomain')\n}\n"],"names":["checkEntitlement","planGrantingFeature","DEDICATED_SENDING_DOMAIN_MIN_PLAN","holdsDedicatedSendingDomain","org"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkEC,GAED,SAASA,gBAAgB,EAAEC,mBAAmB,QAAQ,yBAAqB;AAM3E;;;;;;;;;;;;;CAaC,GACD,OAAO,MAAMC,oCAA6CD,oBACxD,0BACD;AAED;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASE,4BACdC,GAAgD;IAEhD,OAAOJ,iBAAiBI,KAAK;AAC/B"}

package/src/lib/app-utils/deferred-image.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The three attributes that defer an image to its own turn (AGL-2486).
+ *
+ * ## What this is for
+ *
+ * The Image element already ranks itself: the lead image is `eager` and every
+ * later one is `lazy` + `low` + `async`. That reasoning is written out at the
+ * `fetchPriority` prop in `libs/plugins/mui/src/lib/components/image.tsx` and
+ * is not repeated here.
+ *
+ * What that fix could not reach is every OTHER `<img>` a published page
+ * renders: a product grid, a related-products rail, a wishlist, a cart line,
+ * an event thumbnail, a Product card. Those carried **no loading hint at
+ * all** — which is `eager` at the browser's default priority. So a product
+ * grid four sections down was fetched EAGERLY, at a HIGHER priority than the
+ * `lazy` + `low` Image element in the section the reader was actually looking
+ * at. That is the reported symptom — "images several sections below the fold
+ * load before the current section" — and it survived the Image-element fix
+ * precisely because ranking the Image elements against each other says
+ * nothing about the images that opted out of the ranking entirely.
+ *
+ * Uniformly `lazy` is also what produces the second half of what the item
+ * asks for. There is no "next section" hint to give a browser: Chrome fetches
+ * a `lazy` image once it comes within its viewport-distance threshold, so
+ * ordering among deferred images falls out of distance from the viewport on
+ * its own — but ONLY once every image is in that scheme. One unhinted image
+ * does not merely rank badly, it leaves the scheme.
+ *
+ * ## Deliberately NOT applied to
+ *
+ * The image at the top of a page, which is the LCP candidate: the Image
+ * element's lead image, and the product-detail gallery hero. Making those
+ * `lazy` would re-introduce the ORIGINAL bug this issue opened with — an LCP
+ * image not discovered until after layout. Those sites carry a comment
+ * saying so, because "finish the job" is the obvious next edit and it is
+ * wrong.
+ *
+ * ## Why a shared constant rather than three literals
+ *
+ * The set only works if it is the same set everywhere: an image with `lazy`
+ * but no `fetchpriority` outranks an image with both, so a partially-applied
+ * hint re-creates a smaller version of the same inversion. Two of the three
+ * sites in `collection.tsx` were exactly that — `loading="lazy"` and nothing
+ * else — which is why this is a named thing to spread rather than a habit to
+ * remember.
+ *
+ * Spread it, never mutate it:
+ *
+ * ```tsx
+ * <Box component="img" src={url} alt="" {...DEFERRED_IMAGE_ATTRIBUTES} />
+ * ```
+ */
+export declare const DEFERRED_IMAGE_ATTRIBUTES: Readonly<{
+    /** Not fetched until the browser decides it is near the viewport. */
+    readonly loading: "lazy";
+    /**
+     * And when it is fetched, it does not compete with the section on screen.
+     * One-directional on purpose: deprioritising an image provably not being
+     * looked at cannot starve whatever the LCP turns out to be, whereas
+     * PROMOTING one is a claim about every other request in flight that no
+     * render-time function is in a position to make.
+     */
+    readonly fetchPriority: "low";
+    /**
+     * Decoded off the main thread. A deferred image has no paint deadline, so
+     * decoding it synchronously is main-thread time spent on pixels nobody is
+     * looking at yet — which is the same budget item 22 is about.
+     */
+    readonly decoding: "async";
+}>;

package/src/lib/app-utils/deferred-image.js

@@ -0,0 +1,83 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * The three attributes that defer an image to its own turn (AGL-2486).
+ *
+ * ## What this is for
+ *
+ * The Image element already ranks itself: the lead image is `eager` and every
+ * later one is `lazy` + `low` + `async`. That reasoning is written out at the
+ * `fetchPriority` prop in `libs/plugins/mui/src/lib/components/image.tsx` and
+ * is not repeated here.
+ *
+ * What that fix could not reach is every OTHER `<img>` a published page
+ * renders: a product grid, a related-products rail, a wishlist, a cart line,
+ * an event thumbnail, a Product card. Those carried **no loading hint at
+ * all** — which is `eager` at the browser's default priority. So a product
+ * grid four sections down was fetched EAGERLY, at a HIGHER priority than the
+ * `lazy` + `low` Image element in the section the reader was actually looking
+ * at. That is the reported symptom — "images several sections below the fold
+ * load before the current section" — and it survived the Image-element fix
+ * precisely because ranking the Image elements against each other says
+ * nothing about the images that opted out of the ranking entirely.
+ *
+ * Uniformly `lazy` is also what produces the second half of what the item
+ * asks for. There is no "next section" hint to give a browser: Chrome fetches
+ * a `lazy` image once it comes within its viewport-distance threshold, so
+ * ordering among deferred images falls out of distance from the viewport on
+ * its own — but ONLY once every image is in that scheme. One unhinted image
+ * does not merely rank badly, it leaves the scheme.
+ *
+ * ## Deliberately NOT applied to
+ *
+ * The image at the top of a page, which is the LCP candidate: the Image
+ * element's lead image, and the product-detail gallery hero. Making those
+ * `lazy` would re-introduce the ORIGINAL bug this issue opened with — an LCP
+ * image not discovered until after layout. Those sites carry a comment
+ * saying so, because "finish the job" is the obvious next edit and it is
+ * wrong.
+ *
+ * ## Why a shared constant rather than three literals
+ *
+ * The set only works if it is the same set everywhere: an image with `lazy`
+ * but no `fetchpriority` outranks an image with both, so a partially-applied
+ * hint re-creates a smaller version of the same inversion. Two of the three
+ * sites in `collection.tsx` were exactly that — `loading="lazy"` and nothing
+ * else — which is why this is a named thing to spread rather than a habit to
+ * remember.
+ *
+ * Spread it, never mutate it:
+ *
+ * ```tsx
+ * <Box component="img" src={url} alt="" {...DEFERRED_IMAGE_ATTRIBUTES} />
+ * ```
+ */ export const DEFERRED_IMAGE_ATTRIBUTES = Object.freeze({
+    /** Not fetched until the browser decides it is near the viewport. */ loading: 'lazy',
+    /**
+   * And when it is fetched, it does not compete with the section on screen.
+   * One-directional on purpose: deprioritising an image provably not being
+   * looked at cannot starve whatever the LCP turns out to be, whereas
+   * PROMOTING one is a claim about every other request in flight that no
+   * render-time function is in a position to make.
+   */ fetchPriority: 'low',
+    /**
+   * Decoded off the main thread. A deferred image has no paint deadline, so
+   * decoding it synchronously is main-thread time spent on pixels nobody is
+   * looking at yet — which is the same budget item 22 is about.
+   */ decoding: 'async'
+});
+
+//# sourceMappingURL=deferred-image.js.map

package/src/lib/app-utils/deferred-image.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/deferred-image.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * The three attributes that defer an image to its own turn (AGL-2486).\n *\n * ## What this is for\n *\n * The Image element already ranks itself: the lead image is `eager` and every\n * later one is `lazy` + `low` + `async`. That reasoning is written out at the\n * `fetchPriority` prop in `libs/plugins/mui/src/lib/components/image.tsx` and\n * is not repeated here.\n *\n * What that fix could not reach is every OTHER `<img>` a published page\n * renders: a product grid, a related-products rail, a wishlist, a cart line,\n * an event thumbnail, a Product card. Those carried **no loading hint at\n * all** — which is `eager` at the browser's default priority. So a product\n * grid four sections down was fetched EAGERLY, at a HIGHER priority than the\n * `lazy` + `low` Image element in the section the reader was actually looking\n * at. That is the reported symptom — \"images several sections below the fold\n * load before the current section\" — and it survived the Image-element fix\n * precisely because ranking the Image elements against each other says\n * nothing about the images that opted out of the ranking entirely.\n *\n * Uniformly `lazy` is also what produces the second half of what the item\n * asks for. There is no \"next section\" hint to give a browser: Chrome fetches\n * a `lazy` image once it comes within its viewport-distance threshold, so\n * ordering among deferred images falls out of distance from the viewport on\n * its own — but ONLY once every image is in that scheme. One unhinted image\n * does not merely rank badly, it leaves the scheme.\n *\n * ## Deliberately NOT applied to\n *\n * The image at the top of a page, which is the LCP candidate: the Image\n * element's lead image, and the product-detail gallery hero. Making those\n * `lazy` would re-introduce the ORIGINAL bug this issue opened with — an LCP\n * image not discovered until after layout. Those sites carry a comment\n * saying so, because \"finish the job\" is the obvious next edit and it is\n * wrong.\n *\n * ## Why a shared constant rather than three literals\n *\n * The set only works if it is the same set everywhere: an image with `lazy`\n * but no `fetchpriority` outranks an image with both, so a partially-applied\n * hint re-creates a smaller version of the same inversion. Two of the three\n * sites in `collection.tsx` were exactly that — `loading=\"lazy\"` and nothing\n * else — which is why this is a named thing to spread rather than a habit to\n * remember.\n *\n * Spread it, never mutate it:\n *\n * ```tsx\n * <Box component=\"img\" src={url} alt=\"\" {...DEFERRED_IMAGE_ATTRIBUTES} />\n * ```\n */\nexport const DEFERRED_IMAGE_ATTRIBUTES = Object.freeze({\n  /** Not fetched until the browser decides it is near the viewport. */\n  loading: 'lazy',\n  /**\n   * And when it is fetched, it does not compete with the section on screen.\n   * One-directional on purpose: deprioritising an image provably not being\n   * looked at cannot starve whatever the LCP turns out to be, whereas\n   * PROMOTING one is a claim about every other request in flight that no\n   * render-time function is in a position to make.\n   */\n  fetchPriority: 'low',\n  /**\n   * Decoded off the main thread. A deferred image has no paint deadline, so\n   * decoding it synchronously is main-thread time spent on pixels nobody is\n   * looking at yet — which is the same budget item 22 is about.\n   */\n  decoding: 'async',\n} as const)\n"],"names":["DEFERRED_IMAGE_ATTRIBUTES","Object","freeze","loading","fetchPriority","decoding"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmDC,GACD,OAAO,MAAMA,4BAA4BC,OAAOC,MAAM,CAAC;IACrD,mEAAmE,GACnEC,SAAS;IACT;;;;;;GAMC,GACDC,eAAe;IACf;;;;GAIC,GACDC,UAAU;AACZ,GAAW"}

package/src/lib/app-utils/definition-canvas-tree.d.ts

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+type Nodes = Record<string, any>;
+/**
+ * Adapt a reusable-component definition for the canvas, and back (AGL-680).
+ *
+ * The canvas requires its root to be the canonical `_@_` node — `setNodes`
+ * stores whatever it is handed and `rootNode` looks up that exact id, so a
+ * tree without it has no root and renders nothing.
+ *
+ * A definition's root is NOT `_@_`: `promoteToComponent` walks a selected
+ * subtree, so the root is whichever node was selected. Loading one straight
+ * into the canvas therefore produced an empty editor with "Error rendering
+ * undefined" in the console — found by the editor smoke test, not by
+ * typechecking, because both shapes are `Record<string, node>`.
+ *
+ * So the definition is wrapped under a synthetic canvas root on the way in
+ * and unwrapped on the way out. The wrapper is never published: the tenant
+ * runtime grafts from `rootId`, and an extra always-empty container in
+ * every instance would be both wrong and wasteful.
+ *
+ * A map with no findable root always yields the empty canvas root rather
+ * than being passed through (AGL-753). Passing it through renders `'Invalid
+ * node'` with Add Element disabled — an editor with no way out, so the
+ * document can never be repaired from the UI. Components created before
+ * AGL-693 are stored as exactly that (`nodes: {}`), which is why this is a
+ * load-time repair and not a migration.
+ */
+export declare function definitionToCanvasTree(definition: {
+    rootId?: string;
+    nodes?: Nodes;
+}): Nodes;
+/**
+ * Recover the definition shape from a canvas tree.
+ *
+ * Returns the single child of the synthetic root as `rootId` and drops the
+ * wrapper. A canvas root with several children means the author added
+ * siblings at the top level — there is no single definition root to name,
+ * so the wrapper is kept and reported, letting the caller refuse rather
+ * than silently publishing only the first child.
+ */
+export declare function canvasTreeToDefinition(nodes: Nodes | undefined): {
+    rootId?: string;
+    nodes: Nodes;
+    ambiguousRoot: boolean;
+};
+export {};

package/src/lib/app-utils/definition-canvas-tree.js

@@ -0,0 +1,126 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { CANVAS_ROOT_ELEMENT_ID } from "../foundation/constants/canvas.js";
+/**
+ * Adapt a reusable-component definition for the canvas, and back (AGL-680).
+ *
+ * The canvas requires its root to be the canonical `_@_` node — `setNodes`
+ * stores whatever it is handed and `rootNode` looks up that exact id, so a
+ * tree without it has no root and renders nothing.
+ *
+ * A definition's root is NOT `_@_`: `promoteToComponent` walks a selected
+ * subtree, so the root is whichever node was selected. Loading one straight
+ * into the canvas therefore produced an empty editor with "Error rendering
+ * undefined" in the console — found by the editor smoke test, not by
+ * typechecking, because both shapes are `Record<string, node>`.
+ *
+ * So the definition is wrapped under a synthetic canvas root on the way in
+ * and unwrapped on the way out. The wrapper is never published: the tenant
+ * runtime grafts from `rootId`, and an extra always-empty container in
+ * every instance would be both wrong and wasteful.
+ *
+ * A map with no findable root always yields the empty canvas root rather
+ * than being passed through (AGL-753). Passing it through renders `'Invalid
+ * node'` with Add Element disabled — an editor with no way out, so the
+ * document can never be repaired from the UI. Components created before
+ * AGL-693 are stored as exactly that (`nodes: {}`), which is why this is a
+ * load-time repair and not a migration.
+ */ export function definitionToCanvasTree(definition) {
+    var _ref, _Object_keys_find;
+    const nodes = (_ref = definition == null ? void 0 : definition.nodes) != null ? _ref : {};
+    // Already canvas-shaped (a tree saved by this editor) — leave it alone.
+    if (nodes[CANVAS_ROOT_ELEMENT_ID]) return nodes;
+    const rootId = (definition == null ? void 0 : definition.rootId) && nodes[definition.rootId] ? definition.rootId : (_Object_keys_find = Object.keys(nodes).find((id)=>{
+        var _nodes_id;
+        return !((_nodes_id = nodes[id]) == null ? void 0 : _nodes_id.parentId);
+    })) != null ? _Object_keys_find : // A definition promoted out of a screen can keep the `parentId` it
+    // had there, so "no parent" is not always "no parentId" — a parent
+    // that is not itself in the map is just as much a root.
+    Object.keys(nodes).find((id)=>{
+        var _nodes_id;
+        return !nodes[(_nodes_id = nodes[id]) == null ? void 0 : _nodes_id.parentId];
+    });
+    if (!rootId) {
+        return {
+            [CANVAS_ROOT_ELEMENT_ID]: {
+                $id: CANVAS_ROOT_ELEMENT_ID,
+                componentId: 'div',
+                parentId: null,
+                nodes: []
+            }
+        };
+    }
+    return _extends({}, nodes, {
+        [rootId]: _extends({}, nodes[rootId], {
+            parentId: CANVAS_ROOT_ELEMENT_ID
+        }),
+        [CANVAS_ROOT_ELEMENT_ID]: {
+            $id: CANVAS_ROOT_ELEMENT_ID,
+            componentId: 'box',
+            parentId: null,
+            nodes: [
+                rootId
+            ]
+        }
+    });
+}
+/**
+ * Recover the definition shape from a canvas tree.
+ *
+ * Returns the single child of the synthetic root as `rootId` and drops the
+ * wrapper. A canvas root with several children means the author added
+ * siblings at the top level — there is no single definition root to name,
+ * so the wrapper is kept and reported, letting the caller refuse rather
+ * than silently publishing only the first child.
+ */ export function canvasTreeToDefinition(nodes) {
+    const map = nodes != null ? nodes : {};
+    const canvasRoot = map[CANVAS_ROOT_ELEMENT_ID];
+    if (!canvasRoot) {
+        const rootId = Object.keys(map).find((id)=>{
+            var _map_id;
+            return !((_map_id = map[id]) == null ? void 0 : _map_id.parentId);
+        });
+        return {
+            rootId,
+            nodes: map,
+            ambiguousRoot: false
+        };
+    }
+    const children = Array.isArray(canvasRoot.nodes) ? canvasRoot.nodes.filter((id)=>map[id]) : [];
+    if (children.length !== 1) {
+        return {
+            rootId: CANVAS_ROOT_ELEMENT_ID,
+            nodes: map,
+            ambiguousRoot: true
+        };
+    }
+    const rootId = children[0];
+    const stripped = {};
+    for (const [id, node] of Object.entries(map)){
+        if (id === CANVAS_ROOT_ELEMENT_ID) continue;
+        stripped[id] = id === rootId ? _extends({}, node, {
+            parentId: null
+        }) : node;
+    }
+    return {
+        rootId,
+        nodes: stripped,
+        ambiguousRoot: false
+    };
+}
+
+//# sourceMappingURL=definition-canvas-tree.js.map

package/src/lib/app-utils/definition-canvas-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/definition-canvas-tree.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { CANVAS_ROOT_ELEMENT_ID } from '../foundation/constants/canvas'\n\ntype Nodes = Record<string, any>\n\n/**\n * Adapt a reusable-component definition for the canvas, and back (AGL-680).\n *\n * The canvas requires its root to be the canonical `_@_` node — `setNodes`\n * stores whatever it is handed and `rootNode` looks up that exact id, so a\n * tree without it has no root and renders nothing.\n *\n * A definition's root is NOT `_@_`: `promoteToComponent` walks a selected\n * subtree, so the root is whichever node was selected. Loading one straight\n * into the canvas therefore produced an empty editor with \"Error rendering\n * undefined\" in the console — found by the editor smoke test, not by\n * typechecking, because both shapes are `Record<string, node>`.\n *\n * So the definition is wrapped under a synthetic canvas root on the way in\n * and unwrapped on the way out. The wrapper is never published: the tenant\n * runtime grafts from `rootId`, and an extra always-empty container in\n * every instance would be both wrong and wasteful.\n *\n * A map with no findable root always yields the empty canvas root rather\n * than being passed through (AGL-753). Passing it through renders `'Invalid\n * node'` with Add Element disabled — an editor with no way out, so the\n * document can never be repaired from the UI. Components created before\n * AGL-693 are stored as exactly that (`nodes: {}`), which is why this is a\n * load-time repair and not a migration.\n */\nexport function definitionToCanvasTree(definition: {\n  rootId?: string\n  nodes?: Nodes\n}): Nodes {\n  const nodes = definition?.nodes ?? {}\n  // Already canvas-shaped (a tree saved by this editor) — leave it alone.\n  if (nodes[CANVAS_ROOT_ELEMENT_ID]) return nodes\n\n  const rootId =\n    definition?.rootId && nodes[definition.rootId]\n      ? definition.rootId\n      : (Object.keys(nodes).find((id) => !nodes[id]?.parentId) ??\n        // A definition promoted out of a screen can keep the `parentId` it\n        // had there, so \"no parent\" is not always \"no parentId\" — a parent\n        // that is not itself in the map is just as much a root.\n        Object.keys(nodes).find((id) => !nodes[nodes[id]?.parentId]))\n  if (!rootId) {\n    return {\n      [CANVAS_ROOT_ELEMENT_ID]: {\n        $id: CANVAS_ROOT_ELEMENT_ID,\n        componentId: 'div',\n        parentId: null,\n        nodes: [],\n      },\n    }\n  }\n\n  return {\n    ...nodes,\n    [rootId]: { ...nodes[rootId], parentId: CANVAS_ROOT_ELEMENT_ID },\n    [CANVAS_ROOT_ELEMENT_ID]: {\n      $id: CANVAS_ROOT_ELEMENT_ID,\n      componentId: 'box',\n      parentId: null,\n      nodes: [rootId],\n    },\n  }\n}\n\n/**\n * Recover the definition shape from a canvas tree.\n *\n * Returns the single child of the synthetic root as `rootId` and drops the\n * wrapper. A canvas root with several children means the author added\n * siblings at the top level — there is no single definition root to name,\n * so the wrapper is kept and reported, letting the caller refuse rather\n * than silently publishing only the first child.\n */\nexport function canvasTreeToDefinition(nodes: Nodes | undefined): {\n  rootId?: string\n  nodes: Nodes\n  ambiguousRoot: boolean\n} {\n  const map = nodes ?? {}\n  const canvasRoot = map[CANVAS_ROOT_ELEMENT_ID]\n  if (!canvasRoot) {\n    const rootId = Object.keys(map).find((id) => !map[id]?.parentId)\n    return { rootId, nodes: map, ambiguousRoot: false }\n  }\n\n  const children: string[] = Array.isArray(canvasRoot.nodes)\n    ? canvasRoot.nodes.filter((id: string) => map[id])\n    : []\n  if (children.length !== 1) {\n    return {\n      rootId: CANVAS_ROOT_ELEMENT_ID,\n      nodes: map,\n      ambiguousRoot: true,\n    }\n  }\n\n  const rootId = children[0]\n  const stripped: Nodes = {}\n  for (const [id, node] of Object.entries(map)) {\n    if (id === CANVAS_ROOT_ELEMENT_ID) continue\n    stripped[id] = id === rootId ? { ...node, parentId: null } : node\n  }\n  return { rootId, nodes: stripped, ambiguousRoot: false }\n}\n"],"names":["CANVAS_ROOT_ELEMENT_ID","definitionToCanvasTree","definition","Object","nodes","rootId","keys","find","id","parentId","$id","componentId","canvasTreeToDefinition","map","canvasRoot","ambiguousRoot","children","Array","isArray","filter","length","stripped","node","entries"],"mappings":";AAAA;;;;;;;;;;;;;;;CAeC,GAED,SAASA,sBAAsB,QAAQ,oCAAgC;AAIvE;;;;;;;;;;;;;;;;;;;;;;;;CAwBC,GACD,OAAO,SAASC,uBAAuBC,UAGtC;cAQQC;IAPP,MAAMC,gBAAQF,8BAAAA,WAAYE,KAAK,mBAAI,CAAC;IACpC,wEAAwE;IACxE,IAAIA,KAAK,CAACJ,uBAAuB,EAAE,OAAOI;IAE1C,MAAMC,SACJH,CAAAA,8BAAAA,WAAYG,MAAM,KAAID,KAAK,CAACF,WAAWG,MAAM,CAAC,GAC1CH,WAAWG,MAAM,IAChBF,oBAAAA,OAAOG,IAAI,CAACF,OAAOG,IAAI,CAAC,CAACC;YAAQJ;eAAD,GAACA,YAAAA,KAAK,CAACI,GAAG,qBAATJ,UAAWK,QAAQ;kBAApDN,oBACD,mEAAmE;IACnE,mEAAmE;IACnE,wDAAwD;IACxDA,OAAOG,IAAI,CAACF,OAAOG,IAAI,CAAC,CAACC;YAAcJ;eAAP,CAACA,KAAK,EAACA,YAAAA,KAAK,CAACI,GAAG,qBAATJ,UAAWK,QAAQ,CAAC;;IACjE,IAAI,CAACJ,QAAQ;QACX,OAAO;YACL,CAACL,uBAAuB,EAAE;gBACxBU,KAAKV;gBACLW,aAAa;gBACbF,UAAU;gBACVL,OAAO,EAAE;YACX;QACF;IACF;IAEA,OAAO,aACFA;QACH,CAACC,OAAO,EAAE,aAAKD,KAAK,CAACC,OAAO;YAAEI,UAAUT;;QACxC,CAACA,uBAAuB,EAAE;YACxBU,KAAKV;YACLW,aAAa;YACbF,UAAU;YACVL,OAAO;gBAACC;aAAO;QACjB;;AAEJ;AAEA;;;;;;;;CAQC,GACD,OAAO,SAASO,uBAAuBR,KAAwB;IAK7D,MAAMS,MAAMT,gBAAAA,QAAS,CAAC;IACtB,MAAMU,aAAaD,GAAG,CAACb,uBAAuB;IAC9C,IAAI,CAACc,YAAY;QACf,MAAMT,SAASF,OAAOG,IAAI,CAACO,KAAKN,IAAI,CAAC,CAACC;gBAAQK;mBAAD,GAACA,UAAAA,GAAG,CAACL,GAAG,qBAAPK,QAASJ,QAAQ;;QAC/D,OAAO;YAAEJ;YAAQD,OAAOS;YAAKE,eAAe;QAAM;IACpD;IAEA,MAAMC,WAAqBC,MAAMC,OAAO,CAACJ,WAAWV,KAAK,IACrDU,WAAWV,KAAK,CAACe,MAAM,CAAC,CAACX,KAAeK,GAAG,CAACL,GAAG,IAC/C,EAAE;IACN,IAAIQ,SAASI,MAAM,KAAK,GAAG;QACzB,OAAO;YACLf,QAAQL;YACRI,OAAOS;YACPE,eAAe;QACjB;IACF;IAEA,MAAMV,SAASW,QAAQ,CAAC,EAAE;IAC1B,MAAMK,WAAkB,CAAC;IACzB,KAAK,MAAM,CAACb,IAAIc,KAAK,IAAInB,OAAOoB,OAAO,CAACV,KAAM;QAC5C,IAAIL,OAAOR,wBAAwB;QACnCqB,QAAQ,CAACb,GAAG,GAAGA,OAAOH,SAAS,aAAKiB;YAAMb,UAAU;aAASa;IAC/D;IACA,OAAO;QAAEjB;QAAQD,OAAOiB;QAAUN,eAAe;IAAM;AACzD"}