@mohasinac/appkit 4.71.0 → 4.72.0

package/dist/_internal/shared/checkout/settlement.d.ts

@@ -0,0 +1,186 @@
+import type { CartItemDocument } from "../../../features/cart/schemas/firestore";
+import type { ProductDocument } from "../../../features/products/schemas/firestore";
+/** The error code every refusal from this module carries. */
+export declare const GATEWAY_UNAVAILABLE_CODE = "GATEWAY_UNAVAILABLE_FOR_CART";
+/**
+ * Which of the two independent constraints bound.
+ *
+ * 🛑 A refusal names exactly one, and that is the point of the enum rather
+ * than a boolean pair: the message a buyer reads has to describe a single
+ * remedy. See `resolveCollectingGateway` for the order they are tested in and
+ * why that order makes the answer deterministic.
+ */
+export declare const SETTLEMENT_CONSTRAINT: {
+    /** The cart holds another store's goods, so capture must split. */
+    readonly VENDOR_COMPOSITION: "vendor-composition";
+    /** The cart holds a type the collecting gateway's own terms must permit. */
+    readonly LISTING_TYPE: "listing-type";
+};
+export type SettlementConstraint = (typeof SETTLEMENT_CONSTRAINT)[keyof typeof SETTLEMENT_CONSTRAINT];
+export interface CartVendorComposition {
+    /** Every distinct store in the cart, first-seen order. */
+    storeIds: string[];
+    /** Those that are NOT the platform's own store. */
+    thirdPartyStoreIds: string[];
+    /** What the cart was measured against — `null` when unconfigured. */
+    platformStoreId: string | null;
+    /** `thirdPartyStoreIds.length > 0`. */
+    requiresSplit: boolean;
+}
+/** The one field this module needs off a cart line. */
+type StoreScopedLine = Pick<CartItemDocument, "storeId">;
+/**
+ * Which stores a cart spans, and which of them are somebody else's.
+ *
+ * 🛑 This is NOT a second grouping, and the distinction matters because
+ * inventing one is exactly how the fee/add-on granularity drifted from the
+ * order granularity before (Root Cause #65). `storeId` is the SAME field the
+ * order splitter keys on: `_defaults.ts` and `preorder.rule.ts` build
+ * `"<type>:${item.storeId}"`, and the three per-line keys (`offer`,
+ * `collectorDrop`, `clearance`, all `":${item.itemId}"`) describe a SINGLE
+ * cart line, which belongs to a single store. So every resulting order group
+ * holds items from exactly one store, and `group.items[0].item.storeId` — how
+ * every call site in the codebase reads a group's store — is always one of the
+ * ids returned here. Taking the set over items and taking it over groups give
+ * the same answer; items is used because two of the three call sites have not
+ * split the cart yet at the point they must refuse.
+ *
+ * 🛑 `platformStoreId` UNSET means every store is third-party. An install that
+ * has not been told which store is its own must refuse online collection
+ * rather than assume the cart is all its own stock — assuming the other way
+ * round is a silent commingle on a real payment, and the failure is invisible
+ * because it looks exactly like a successful checkout.
+ *
+ * A line with no `storeId` is counted as third-party for the same reason: it
+ * is a store we cannot name, not a store we own.
+ */
+export declare function cartVendorComposition(items: readonly StoreScopedLine[], platformStoreId?: string | null): CartVendorComposition;
+/**
+ * Must this cart be collected by a gateway that splits at capture?
+ *
+ * The one-line form of `cartVendorComposition`, for call sites that only need
+ * the yes/no and not the ids.
+ */
+export declare function cartRequiresSplitSettlement(items: readonly StoreScopedLine[], platformStoreId?: string | null): boolean;
+export interface GatewayRequirement {
+    /** The collecting gateway must be able to split one capture across vendors. */
+    requiresSplit: boolean;
+    /** Vendor composition behind `requiresSplit`, for the message and the logs. */
+    composition: CartVendorComposition;
+    /**
+     * Listing types in this cart whose rule carries
+     * `requiresGatewayPermission` — distinct, first-seen order.
+     */
+    restrictedListingTypes: string[];
+    /** The first product title per restricted type, so a refusal can name it. */
+    restrictedLabelByType: Record<string, string>;
+}
+/**
+ * What the collecting gateway has to be capable of, and permitted to do, for
+ * this cart.
+ *
+ * Pure: the caller supplies the products it has already loaded. No IO, no
+ * clock, no registry read — this module is isomorphic and the provider
+ * registry is server-only.
+ *
+ * 🛑 Walks EVERY MEMBER of every line via `getCartItemMemberIds`, not
+ * `item.productId`. A bundle or grouped line's own `listingType` describes the
+ * WRAPPER, so reading it would answer for the wrong thing, and reading only
+ * the first member is how a grouped line containing one restricted listing
+ * slipped past the online path before (see `payment-gate.ts`'s header).
+ *
+ * An unresolved member is skipped rather than treated as restricted: the stock
+ * and existence checks that run over the same cart already fail loudly on a
+ * missing product, and inventing a payment refusal here would report the wrong
+ * problem.
+ */
+export declare function resolveGatewayRequirement(items: readonly CartItemDocument[], productById: ReadonlyMap<string, ProductDocument>, platformStoreId?: string | null): GatewayRequirement;
+/**
+ * One gateway an admin has enabled, reduced to the two facts that decide
+ * whether it may collect a given cart.
+ *
+ * 🛑 The two fields come from DIFFERENT OWNERS and must not be collapsed —
+ * `IPaymentProvider.acceptsRestrictedListingTypes`' own 🛑 says so. Razorpay
+ * Route splits perfectly well AND prohibits auctions; Cashfree happens to do
+ * both. `supportsSplit` is a CAPABILITY and is declared by the consumer's
+ * gateway registry (it is a fact about the product we bought, not about the
+ * adapter); `accepts` is a PERMISSION and is declared by the provider, which
+ * is the thing that knows what its own contract allows.
+ *
+ * 🛑 Neither is ever tested by NAME. `name === "cashfree"` would restate the
+ * compliance rule at every call site and go quietly wrong the day a second
+ * splitting gateway is added — the ten-hand-written-enumerations shape of Root
+ * Cause #61.
+ */
+export interface SettlementGatewayCandidate {
+    /** Short discriminator, for logs and for picking the provider back out. */
+    name: string;
+    /** Can it split ONE capture across several vendors, at capture time? */
+    supportsSplit: boolean;
+    /**
+     * Listing types this gateway's merchant terms permit.
+     *
+     * 🛑 `undefined` means "nothing declared", which the resolver treats as
+     * ACCEPTS NOTHING — the same fail-closed direction as
+     * `PaymentGateContext.gatewayAccepts`.
+     */
+    accepts?: readonly string[];
+    /** Lower wins when several candidates qualify. Absent sorts last. */
+    order?: number;
+}
+export interface GatewayResolution {
+    /** A qualifying gateway was found. */
+    ok: boolean;
+    /** The gateway that must collect this cart. Present only when `ok`. */
+    gateway?: SettlementGatewayCandidate;
+    /** What the cart demanded, whether or not anything satisfied it. */
+    requirement: GatewayRequirement;
+    /**
+     * Which constraint eliminated the last candidate. Absent when `ok`, and
+     * absent when NEITHER constraint bound and there simply was no gateway at
+     * all — that case is the pre-existing "online payment is not enabled" one
+     * and belongs to the caller's own gate, not to this rule.
+     */
+    failedConstraint?: SettlementConstraint;
+    /** Buyer-facing sentence. Present only when `!ok`. */
+    reason?: string;
+    /** Operator-facing detail naming ids. Present only when `!ok`. */
+    detail?: string;
+}
+export interface ResolveCollectingGatewayInput {
+    /** Every gateway currently enabled. Empty is a legitimate state. */
+    candidates: readonly SettlementGatewayCandidate[];
+    items: readonly CartItemDocument[];
+    productById: ReadonlyMap<string, ProductDocument>;
+    /** `siteSettings.payment.platformStoreId`. Unset ⇒ everything is third-party. */
+    platformStoreId?: string | null;
+}
+/**
+ * THE gateway that must collect this cart, or a refusal naming which
+ * constraint bound.
+ *
+ * ## The order the constraints are tested in, and why it is not arbitrary
+ *
+ * Candidates are narrowed by the SPLIT test first and the PERMISSION test
+ * second. That makes `failedConstraint` the constraint that genuinely
+ * eliminated the last survivor rather than whichever was checked first:
+ *
+ *  - nothing survives the split test  → `vendor-composition`. Correct, because
+ *    even a gateway that permits the category cannot lawfully collect this
+ *    cart.
+ *  - something survives the split test but nothing survives the permission
+ *    test → `listing-type`. Also correct: the vendor half is satisfiable, the
+ *    category half is not.
+ *
+ * Reporting the other way round would tell an admin to enable a splitting
+ * gateway they have already enabled.
+ *
+ * ## 🛑 Never falls back
+ *
+ * There is no "no qualifying gateway, so use the default one" branch, and its
+ * absence is the entire point of this function. That fallback is the
+ * commingling — and it would look exactly like a successful checkout, which is
+ * why it has to be structurally unavailable rather than merely discouraged.
+ */
+export declare function resolveCollectingGateway(input: ResolveCollectingGatewayInput): GatewayResolution;
+export {};

package/dist/_internal/shared/config/index.d.ts

@@ -1 +1 @@
-export type { AppkitConfig, AppkitSmokeRoute, AppkitThemeProbeRoute, AppkitAuthFixture, AppkitFirebaseConfig, AppkitFirebaseExtensions, AppkitVercelConfig, AppkitBrandConfig, AppkitSeoConfig, AppkitI18nConfig, FirestoreIndex, FirestoreIndexField, FirestoreFieldOverride, } from "./schema";
+export type { AppkitConfig, AppkitSmokeRoute, AppkitThemeProbeRoute, AppkitAuthFixture, AppkitFirebaseConfig, AppkitFirebaseExtensions, AppkitVercelConfig, AppkitBrandConfig, AppkitSeoConfig, AppkitI18nConfig, AppkitPortalHostsConfig, FirestoreIndex, FirestoreIndexField, FirestoreFieldOverride, } from "./schema";

package/dist/_internal/shared/config/schema.d.ts

@@ -1,4 +1,4 @@
-import type { FirestoreDocument } from "@mohasinac/appkit";
+import type { FirestoreDocument } from "../../../schemas/types";
 /**
  * AppkitConfig — consumer's contract with all appkit CLI binaries.
  *
@@ -264,6 +264,34 @@ export interface AppkitI18nConfig {
      */
     enableLocaleCookie?: boolean;
 }
+/**
+ * @deprecated Superseded by `next/routing/portals.ts` — do not add a consumer.
+ *
+ * This type used to declare itself "the ONE definition" of the portal
+ * hostnames, with a host-rewrite gate keeping a hand-synced copy of the same
+ * strings. In practice NOTHING ever read it (the "cookie-domain helper" the
+ * old comment credited does not exist), while the hand-synced copy in
+ * `src/proxy.ts` was the thing actually routing traffic — so the configured
+ * list and the live behaviour could never have disagreed loudly enough to be
+ * noticed. On 2026-11-07 three subdomains went live with an entry in neither
+ * place and silently served the public homepage from a portal host.
+ *
+ * `PORTAL_DEFINITIONS` in `next/routing/portals.ts` replaces both: a portal is
+ * recognised by its first hostname LABEL, so the mapping is derived from the
+ * request rather than configured per host, and a new domain needs no entry
+ * anywhere. The type survives only because it is re-exported from the public
+ * entry barrels; it carries no data in `appkit.config.js` any more.
+ */
+export interface AppkitPortalHostsConfig {
+    /** Serves the admin dashboard (`/admin/*`) at its root. */
+    admin?: string;
+    /** Serves the seller/store dashboard (`/store/*`) at its root — "seller" is
+     *  the external-facing name; CLAUDE.md's own convention is STORE
+     *  internally, so this key names the subdomain's PUBLIC identity. */
+    seller?: string;
+    /** Serves the auth flow (`/auth/*`) at its root. */
+    auth?: string;
+}
 export interface AppkitVercelConfig {
     /** Vercel project ID */
     projectId: string;
@@ -310,4 +338,10 @@ export interface AppkitConfig {
     firebase?: AppkitFirebaseConfig;
     /** Vercel project configuration (used by vercel-* CLI binaries) */
     vercel?: AppkitVercelConfig;
+    /**
+     * @deprecated Portal routing is derived, not configured — see
+     * `next/routing/portals.ts`. Left optional so an older consumer config that
+     * still sets it keeps type-checking; no code reads it.
+     */
+    portalHosts?: AppkitPortalHostsConfig;
 }

package/dist/_internal/shared/content/composite-sentences/en.d.ts

@@ -0,0 +1,31 @@
+/**
+ * English composite sentences — found by
+ * `scripts/find-composite-listing-sentences.mjs` against `messages/en.json`
+ * (5 genuine composites out of 74 candidates; the other 69 were single-topic
+ * prose on pages/sections already wholly about one listing type, which
+ * belongs to route/section-level gating, not fragment-level omission —
+ * CLAUDE.md's own "Listing Types Reference" / `hidden-surfaces.ts` already
+ * cover that case).
+ *
+ * A `Record<CompositeSentenceId, CompositeSentence>`, NOT `Partial` — a
+ * locale file missing one id is a compile error, same discipline
+ * `ALL_LISTING_TYPES_MAP` already uses (Root Cause #61).
+ *
+ * @tag domain:content
+ * @tag layer:shared
+ * @tag access:isomorphic
+ * @tag sideEffects:none
+ */
+import type { CompositeSentence } from "./registry";
+/**
+ * 🛑 `cancellationPolicy.sections.3.body` is deliberately NOT here. It is 3
+ * already-complete paragraphs, not one compound sentence — forcing it through
+ * this resolver's Oxford-comma `joinList` would read badly (a stray comma
+ * between two full paragraphs). It needs `resolveFragmentedAnswer` (the
+ * paragraph-concatenation resolver `fragments.ts` already built for admin
+ * prose) applied to STATIC copy instead, which this phase's static-copy half
+ * doesn't yet have a locale-file home for — tracked as a Phase 12 follow-up,
+ * not hacked into the wrong shape here.
+ */
+export type CompositeSentenceId = "homepage.howItWorksStep2Desc" | "search.metaDescription" | "helpPage.topicCollectorDropsDesc" | "cancellationPolicy.sections.3.heading" | "sellPage.listingStepDesc" | "sellPage.everyKindOfListingDesc" | "faqs.metaDescription" | "guides.metaDescription" | "helpCollectorDrops.metaDescription" | "sellerGuideClearance.metaDescription" | "storeGuideListings.metaDescription" | "support.metaDescription";
+export declare const SENTENCES_EN: Record<CompositeSentenceId, CompositeSentence>;

package/dist/_internal/shared/content/composite-sentences/en.js

@@ -0,0 +1,173 @@
+export const SENTENCES_EN = {
+    "homepage.howItWorksStep2Desc": {
+        id: "homepage.howItWorksStep2Desc",
+        lead: "Buy at a fixed price with secure checkout",
+        clauses: [
+            {
+                governs: { governs: "listingType", value: "pre-order" },
+                text: "reserve an upcoming release with a pre-order",
+            },
+        ],
+    },
+    "search.metaDescription": {
+        id: "search.metaDescription",
+        lead: "Search for products",
+        clauses: [
+            {
+                governs: { governs: "listingType", value: "collector-drop" },
+                text: "collector drops",
+            },
+            {
+                governs: { governs: "listingType", value: "pre-order" },
+                text: "pre-orders",
+            },
+        ],
+        conjunction: "and",
+        // `{{siteName}}`, not a literal — appkit is a library, and a hardcoded
+        // brand name inside `_internal/` is exactly what `audit-ssr-in-appkit`/
+        // `audit-appkit-brand-leak` exist to block. `getCompositeSentence()`
+        // (`./index.ts`) pipes the resolved string through `withBrand()` as its
+        // final step, same "fragment-filter, then token-substitute" two-pass
+        // shape already used for FAQ answers.
+        terminator: " and more on {{siteName}}.",
+    },
+    "helpPage.topicCollectorDropsDesc": {
+        id: "helpPage.topicCollectorDropsDesc",
+        lead: "How bidding works",
+        clauses: [
+            {
+                governs: { governs: "listingType", value: "collector-drop" },
+                text: "winning a collector drop",
+            },
+            {
+                governs: { governs: "listingType", value: "pre-order" },
+                text: "what pre-orders involve",
+            },
+        ],
+        conjunction: "and",
+    },
+    "cancellationPolicy.sections.3.heading": {
+        id: "cancellationPolicy.sections.3.heading",
+        lead: "Cancellation terms",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "Collector Drops" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-orders" },
+            { governs: { governs: "listingType", value: "clearance" }, text: "prize draws" },
+        ],
+        conjunction: "and",
+        leadSeparator: ": ",
+        terminator: "",
+    },
+    /*
+     * /sell — step 3's body sentence ("Add items with photos and a price.
+     * Sell outright, run a collector drop, take pre-orders, or list spare
+     * parts — whatever fits the item."). Found as a real Fact-1 gap
+     * (page-foundation-coverage, 2026-11-04): this sentence was a hardcoded
+     * TS literal in the page file, so `find-composite-listing-sentences.mjs`
+     * (which only scans `messages/en.json`) never saw it — disabling a type
+     * via the admin toggle would leave the page claiming it's still supported.
+     */
+    "sellPage.listingStepDesc": {
+        id: "sellPage.listingStepDesc",
+        lead: "Sell outright",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "run a collector drop" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "take pre-orders" },
+            { governs: { governs: "listingType", value: "spares" }, text: "list spare parts" },
+        ],
+        conjunction: "or",
+        terminator: " — whatever fits the item.",
+    },
+    /*
+     * /sell — the "Every kind of listing" benefit body. Same Fact-1 gap class
+     * as above, same page.
+     */
+    "sellPage.everyKindOfListingDesc": {
+        id: "sellPage.everyKindOfListingDesc",
+        lead: "Fixed price",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "collector drops" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-orders" },
+            { governs: { governs: "listingType", value: "clearance" }, text: "prize draws" },
+            { governs: { governs: "listingType", value: "spares" }, text: "spare parts" },
+            { governs: { governs: "listingType", value: "art-and-stickers" }, text: "art and sticker sheets" },
+        ],
+        conjunction: "and",
+        terminator: " — all supported, each with the right chrome.",
+    },
+    /*
+     * Fact 1 worklist (REPORT.md, 2026-11-04/05) — the 6 remaining real
+     * candidates `scanTsxCompositeSentences()` found: static meta-description
+     * copy naming 2+ governed listing types inline. Each `lead` below is
+     * written to read as a complete, grammatically valid sentence ON ITS OWN
+     * — the zero-survivors collapse case (every named clause disabled) must
+     * not depend on the clauses existing, unlike a lead that ends mid-clause.
+     */
+    "faqs.metaDescription": {
+        id: "faqs.metaDescription",
+        lead: "Answers to common questions about shipping, returns, and payments",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "collector drops" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-orders" },
+        ],
+        conjunction: "and",
+        leadSeparator: ", plus ",
+        terminator: " on LetItRip.",
+    },
+    "guides.metaDescription": {
+        id: "guides.metaDescription",
+        lead: "Every LetItRip explainer in one place: how offers, EMI and payouts work, what the fees and GST are, and how to tell a genuine release from an aftermarket copy",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "how collector drops work" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "how pre-orders work" },
+        ],
+        conjunction: "and",
+        leadSeparator: ", plus ",
+        terminator: ".",
+    },
+    // /help/collector-drops — collector-drop itself is the page's own named
+    // topic (fixed in `lead`, same reasoning `help/collector-drops`'s own
+    // route gating would use); only the secondary pre-order mention is gated.
+    "helpCollectorDrops.metaDescription": {
+        id: "helpCollectorDrops.metaDescription",
+        lead: "How collector drops work on LetItRip — bidding, winning, bid retraction policy, and safety tips",
+        clauses: [
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-order details" },
+        ],
+        leadSeparator: ", plus ",
+        terminator: ".",
+    },
+    // /seller-guide/clearance — clearance is the page's own topic, fixed
+    // in `lead`; only the secondary digital-code mention is gated.
+    "sellerGuideClearance.metaDescription": {
+        id: "sellerGuideClearance.metaDescription",
+        lead: "Run clearance on LetItRip",
+        clauses: [
+            { governs: { governs: "listingType", value: "digital-code" }, text: "digital code giveaways" },
+        ],
+        leadSeparator: " and ",
+        terminator: ". Learn how to create listings, manage codes, and announce winners.",
+    },
+    "storeGuideListings.metaDescription": {
+        id: "storeGuideListings.metaDescription",
+        lead: "How to create products on LetItRip",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "collector drops" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-orders" },
+        ],
+        conjunction: "and",
+        leadSeparator: ", plus ",
+        terminator: " — condition grades, media tips, pricing, and common mistakes.",
+    },
+    "support.metaDescription": {
+        id: "support.metaDescription",
+        lead: "Get help with buying, shipping, payments, and selling on LetItRip",
+        clauses: [
+            { governs: { governs: "listingType", value: "collector-drop" }, text: "collector drops" },
+            { governs: { governs: "listingType", value: "pre-order" }, text: "pre-orders" },
+        ],
+        conjunction: "and",
+        leadSeparator: ", plus ",
+        terminator: ". Browse FAQs or contact our support team.",
+    },
+};

package/dist/_internal/shared/content/composite-sentences/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Locale lookup + accessors for composite sentences (1A-ii, static-copy
+ * half). Typed on a plain `string` locale, not the consumer's own `Locale`
+ * union — appkit stays deployment-agnostic (the "north star": reusable
+ * across any ecommerce site, per the Context section of the master plan),
+ * so it cannot import a consumer-specific type. An unregistered locale falls
+ * back to English rather than throwing — same "absent still works" default
+ * every flag check in this codebase already uses.
+ *
+ * @tag domain:content
+ * @tag layer:shared
+ * @tag access:isomorphic
+ * @tag sideEffects:none
+ */
+import { type CompositeSentenceId } from "./en";
+import { type ContentFlagSnapshot } from "./registry";
+export type { CompositeSentenceId } from "./en";
+export type { CompositeSentence, ContentFlagSnapshot } from "./registry";
+export { resolveCompositeSentence } from "./registry";
+/** Server helper — call with the request's resolved locale + the live flag snapshot. */
+export declare function getCompositeSentence(id: CompositeSentenceId, locale: string, settings: ContentFlagSnapshot | null | undefined): string;

package/dist/_internal/shared/content/composite-sentences/index.js

@@ -0,0 +1,26 @@
+/**
+ * Locale lookup + accessors for composite sentences (1A-ii, static-copy
+ * half). Typed on a plain `string` locale, not the consumer's own `Locale`
+ * union — appkit stays deployment-agnostic (the "north star": reusable
+ * across any ecommerce site, per the Context section of the master plan),
+ * so it cannot import a consumer-specific type. An unregistered locale falls
+ * back to English rather than throwing — same "absent still works" default
+ * every flag check in this codebase already uses.
+ *
+ * @tag domain:content
+ * @tag layer:shared
+ * @tag access:isomorphic
+ * @tag sideEffects:none
+ */
+import { SENTENCES_EN } from "./en.js";
+import { resolveCompositeSentence, } from "./registry.js";
+import { withBrand } from "../../../../core/brand-text.js";
+export { resolveCompositeSentence } from "./registry.js";
+const COMPOSITE_SENTENCE_REGISTRIES = {
+    en: SENTENCES_EN,
+};
+/** Server helper — call with the request's resolved locale + the live flag snapshot. */
+export function getCompositeSentence(id, locale, settings) {
+    const registry = COMPOSITE_SENTENCE_REGISTRIES[locale] ?? SENTENCES_EN;
+    return withBrand(resolveCompositeSentence(registry[id], settings));
+}

package/dist/_internal/shared/content/composite-sentences/registry.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Composite-sentence cascade for STATIC, developer-authored copy
+ * (`messages/en.json`) — the static-copy half of 1A-ii. A sentence that names
+ * 2+ governed things inline (e.g. "Buy at a fixed price with secure
+ * checkout, or reserve an upcoming release with a pre-order.") goes stale the
+ * moment one of them is disabled. This resolver drops exactly the clause(s)
+ * naming a disabled thing and re-joins the survivors with correct grammar —
+ * never a dangling "or"/comma, never a double terminator.
+ *
+ * Distinct from `resolveFragmentedAnswer` (`../fragments.ts`, admin-authored
+ * prose, simple paragraph concatenation) because a single compound SENTENCE
+ * needs Oxford-comma-aware joining that paragraph-level admin content does
+ * not — two resolvers over the SAME `ContentFragment`/`visibleFragments`
+ * primitive, not two competing visibility mechanisms.
+ *
+ * @tag domain:content
+ * @tag layer:shared
+ * @tag access:isomorphic
+ * @tag sideEffects:none
+ */
+import { type ContentFragment, type ContentFlagSnapshot } from "../fragments";
+export type { ContentFlagSnapshot } from "../fragments";
+export interface CompositeSentence {
+    id: string;
+    /** Always-rendered opening clause — no trailing punctuation. */
+    lead: string;
+    /** Optional clauses, each independently gated via `ContentFragment.governs`. */
+    clauses: ContentFragment[];
+    /** Default "or". */
+    conjunction?: string;
+    /** Default ", ". */
+    leadSeparator?: string;
+    /** Default ".". */
+    terminator?: string;
+}
+/**
+ * Resolves a `CompositeSentence` against the live flag snapshot. When every
+ * optional clause is gone, collapses to just `${lead}${terminator}` — never a
+ * dangling conjunction or comma.
+ */
+export declare function resolveCompositeSentence(sentence: CompositeSentence, settings: ContentFlagSnapshot | null | undefined): string;

package/dist/_internal/shared/content/composite-sentences/registry.js

@@ -0,0 +1,50 @@
+/**
+ * Composite-sentence cascade for STATIC, developer-authored copy
+ * (`messages/en.json`) — the static-copy half of 1A-ii. A sentence that names
+ * 2+ governed things inline (e.g. "Buy at a fixed price with secure
+ * checkout, or reserve an upcoming release with a pre-order.") goes stale the
+ * moment one of them is disabled. This resolver drops exactly the clause(s)
+ * naming a disabled thing and re-joins the survivors with correct grammar —
+ * never a dangling "or"/comma, never a double terminator.
+ *
+ * Distinct from `resolveFragmentedAnswer` (`../fragments.ts`, admin-authored
+ * prose, simple paragraph concatenation) because a single compound SENTENCE
+ * needs Oxford-comma-aware joining that paragraph-level admin content does
+ * not — two resolvers over the SAME `ContentFragment`/`visibleFragments`
+ * primitive, not two competing visibility mechanisms.
+ *
+ * @tag domain:content
+ * @tag layer:shared
+ * @tag access:isomorphic
+ * @tag sideEffects:none
+ */
+import { visibleFragments, } from "../fragments.js";
+/**
+ * Oxford-comma-aware join of 1..N surviving clause texts.
+ *   1 item:  "a"
+ *   2 items: "a CONJ b"
+ *   3+:      "a, b, CONJ c"
+ */
+function joinList(items, conjunction) {
+    if (items.length === 0)
+        return "";
+    if (items.length === 1)
+        return items[0];
+    if (items.length === 2)
+        return `${items[0]} ${conjunction} ${items[1]}`;
+    return `${items.slice(0, -1).join(", ")}, ${conjunction} ${items[items.length - 1]}`;
+}
+/**
+ * Resolves a `CompositeSentence` against the live flag snapshot. When every
+ * optional clause is gone, collapses to just `${lead}${terminator}` — never a
+ * dangling conjunction or comma.
+ */
+export function resolveCompositeSentence(sentence, settings) {
+    const terminator = sentence.terminator ?? ".";
+    const survivors = visibleFragments(sentence.clauses, settings).map((c) => c.text);
+    if (survivors.length === 0)
+        return `${sentence.lead}${terminator}`;
+    const leadSeparator = sentence.leadSeparator ?? ", ";
+    const conjunction = sentence.conjunction ?? "or";
+    return `${sentence.lead}${leadSeparator}${joinList(survivors, conjunction)}${terminator}`;
+}

package/dist/_internal/shared/content/disclaimers.d.ts

@@ -32,8 +32,8 @@
 export type DisclaimerId = 
 /** Naming a person a scammer. The highest-exposure entry in this file. */
 "scam-registry"
-/** Prize draws and the lottery — state-specific gaming law. */
- | "prize-draw"
+/** Clearance and the giveaway — state-specific gaming law. */
+ | "clearance"
 /** Collectibles shown with historical prices. */
  | "not-investment-advice"
 /** The realised-price index. */
@@ -48,8 +48,8 @@ export type DisclaimerId =
  | "live-items"
 /** Pre-orders. */
  | "pre-order"
-/** Auctions. */
- | "auction-binding"
+/** Collector Drops. */
+ | "collectordrop-binding"
 /** EMI. */
  | "emi"
 /** Delivery estimates. */