@civitai/blocks-react 0.56.0 → 0.57.0

package/dist/internal/pickerOverlay.js

@@ -206,11 +206,22 @@ export function openPickerOverlay(opts) {
         opts.onResolve(selection);
     };
     const selectCard = (card) => {
-        if (opts.type === 'Checkpoint') {
-            resolve({ kind: 'Checkpoint', selected: cardToCheckpoint(card) });
+        // 🔴 BRANCH ON THE REPLY CHANNEL, NOT ON `opts.type` (#391). The channel is
+        // what the block's consumers read the payload as; the requested type is
+        // only what the catalog was filtered by. Branching on the type sent a
+        // `cardToCheckpoint()` projection — no `modelType` — down
+        // `RESOURCE_PICKER_RESULT` for every `resourceType: 'Checkpoint'` request,
+        // and `BlockResourceInfo.modelType` is REQUIRED.
+        //
+        // `cardToResource` already resolves `modelType` correctly for both: it
+        // prefers the card's own REST-reported type and falls back to `opts.type`,
+        // so a Checkpoint asked for on the resource channel comes back
+        // `modelType: 'Checkpoint'`.
+        if (opts.resultChannel === 'CHECKPOINT_PICKER_RESULT') {
+            resolve({ channel: 'CHECKPOINT_PICKER_RESULT', selected: cardToCheckpoint(card) });
         }
         else {
-            resolve({ kind: 'LORA', selected: cardToResource(card, opts.type) });
+            resolve({ channel: 'RESOURCE_PICKER_RESULT', selected: cardToResource(card, opts.type) });
         }
     };
     const handle = {

package/dist/testing.d.ts

@@ -17,7 +17,7 @@
  * README section, failing on growth and on shrinkage alike.
  */
 import { type ReactNode } from 'react';
-import { __resetTransport } from './internal/singleton.js';
+import { __resetTransport } from './transport/singleton.js';
 import { type MockHostOptions } from './internal/mockHost.js';
 export { __resetTransport as resetTransport };
 export { createMockHost, readMockHostUrlOptions, type MockHost, type MockHostOptions, type MockHostFailMode, type MockHostScenarioPatch, type MockGenerationScenario, type MockBuzzScenario, type MockBuzzBalance, type MockBuzzHandle, type MockStorageScenario, type MockSharedScenario, type MockSharedSeed, type MockCannedImageScan, type CostSpec, type ImageSpec, type CannedPick, } from './internal/mockHost.js';

package/dist/testing.js

@@ -18,7 +18,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
  * README section, failing on growth and on shrinkage alike.
  */
 import { useEffect, useRef, useState } from 'react';
-import { __resetTransport } from './internal/singleton.js';
+import { __resetTransport } from './transport/singleton.js';
 import { createMockHost, readMockHostUrlOptions, } from './internal/mockHost.js';
 export { __resetTransport as resetTransport };
 export { createMockHost, readMockHostUrlOptions, } from './internal/mockHost.js';

package/dist/{internal → transport}/iframeTransport.d.ts

@@ -4,7 +4,16 @@ export interface IframeTransportOptions {
     /**
      * Origins from which `BLOCK_INIT` (and any other inbound message) is
      * accepted. MUST contain at least one entry. Messages from any other
-     * origin — including the local origin — are dropped silently.
+     * origin — including the local origin — are dropped; a drop that happens
+     * before init warns ONCE per distinct origin and is named in the
+     * init-timeout error (see {@link MAX_TRACKED_ORIGINS}).
+     *
+     * Entries are canonicalised by `OriginMatcher`, so a trailing slash, a
+     * mixed-case scheme/host and an explicit DEFAULT port all match the
+     * equivalent `event.origin` — while a non-default port, the scheme and the
+     * exact host stay significant. An entry that is not a bare origin THROWS
+     * here rather than being silently skipped. Read that file's docblock before
+     * changing anything about the comparison: it is a security boundary.
      *
      * Typically wired from `import.meta.env.VITE_BLOCK_ALLOWED_PARENT_ORIGINS`
      * (or the framework's equivalent) at block-app startup.
@@ -22,13 +31,34 @@ export interface IframeTransportOptions {
 export declare class IframeTransport implements BlockTransport {
     private readonly originMatcher;
     /**
-     * The EXACT (non-wildcard) entries of `allowedParentOrigins`, usable as a
-     * `postMessage` `targetOrigin`. A wildcard entry (`https://*.civitaic.com`)
-     * is not a concrete origin and cannot be a target, so it is excluded here —
-     * see {@link announceReady} for what happens when nothing exact remains.
+     * The EXACT (non-wildcard) entries of `allowedParentOrigins`, NORMALISED by
+     * `OriginMatcher` and usable as a `postMessage` `targetOrigin`. A wildcard
+     * entry (`https://*.civitaic.com`) is not a concrete origin and cannot be a
+     * target, so it is excluded there — see {@link announceReady} for what
+     * happens when nothing exact remains.
      */
     private readonly exactAllowedOrigins;
+    /**
+     * The allowlist AS CONFIGURED (trimmed, not normalised). Named in the
+     * init-timeout error so the operator sees the strings they actually wrote
+     * next to the origins that actually arrived.
+     */
+    private readonly configuredOrigins;
     private readonly window;
+    /**
+     * Origins observed BEFORE init resolved, split by what the allowlist gate did
+     * with them. Both bounded — see {@link MAX_TRACKED_ORIGINS}.
+     *
+     * 🔴 THE TWO BUCKETS ARE DIFFERENT DIAGNOSES AND AN EMPTY PAIR IS A THIRD.
+     * "rejected" says the host is talking and the allowlist is wrong; "accepted,
+     * but nothing was a valid BLOCK_INIT" says the allowlist is right and the
+     * payload or the message type is wrong; neither means the host frame never
+     * posted at all. Collapsing them would send the one person reading this error
+     * to the wrong half of the system — the failure this whole diagnostic exists
+     * to prevent.
+     */
+    private readonly acceptedOriginTally;
+    private readonly rejectedOriginTally;
     private snapshot;
     private readonly listeners;
     /** Origin of the parent — captured from the first valid `BLOCK_INIT`. */
@@ -71,6 +101,14 @@ export declare class IframeTransport implements BlockTransport {
      * chose to frame.
      */
     private announceReady;
+    /**
+     * One sentence naming the origins this transport actually heard from before
+     * init timed out — the single fact that turns "BLOCK_INIT never arrived" from
+     * a guess into a diagnosis.
+     *
+     * Three outcomes, deliberately worded apart (see {@link acceptedOriginTally}).
+     */
+    private describeObservedOrigins;
     getSnapshot(): BlockSnapshot;
     /**
      * The validated parent origin — `null` until `BLOCK_INIT` lands.

package/dist/{internal → transport}/iframeTransport.js

@@ -2,8 +2,52 @@ import { boundBlockToParentMessageType, isMessage, OTHER_MESSAGE_TYPE_LABEL, par
 import { EMPTY_SNAPSHOT, nextRequestId, RequestTimeoutError, snapshotFromInit, tokenFromWrapped, } from './transport.js';
 import { OriginMatcher } from './originMatcher.js';
 import { DEFAULT_REQUEST_TIMEOUT_MS } from './requestTimeouts.js';
-import { payloadValidatorFor } from './validate.js';
+import { isRoutableRequestId } from './requestId.js';
+import { payloadValidatorFor, projectInboundPayload } from './validate.js';
 const INIT_TIMEOUT_MS = 10_000;
+/**
+ * How many DISTINCT inbound origins are remembered for the init-timeout
+ * diagnostic, per bucket (accepted / rejected).
+ *
+ * Bounded on purpose: a framing page — or any browser extension sharing the
+ * window — can postMessage from an unbounded number of origins, and the host
+ * itself re-sends `BLOCK_INIT` on a ~400ms tick, so an uncapped set would let a
+ * hostile or merely noisy page grow an error string without limit. Five is
+ * enough to name the misconfigured origin next to the configured allowlist,
+ * which is the whole diagnostic; past that the message says it is truncated
+ * rather than pretending the list is complete.
+ */
+const MAX_TRACKED_ORIGINS = 5;
+function newTally() {
+    return { seen: new Set(), truncated: false };
+}
+/**
+ * Remembers `origin` if there is room. Returns true only the FIRST time an
+ * origin is recorded, so callers can attach a one-shot log to it without
+ * turning the host's 400ms init retry into a console flood.
+ */
+function recordOrigin(tally, origin) {
+    if (tally.seen.has(origin))
+        return false;
+    if (tally.seen.size >= MAX_TRACKED_ORIGINS) {
+        tally.truncated = true;
+        return false;
+    }
+    tally.seen.add(origin);
+    return true;
+}
+/** The quoted, comma-separated list of origins remembered on one bucket. */
+function formatOrigins(tally) {
+    return [...tally.seen].map((o) => `"${o}"`).join(', ');
+}
+/**
+ * Leading clause for the bucket's parenthetical when it overflowed, so a capped
+ * list is never read as a complete one. Empty when nothing was dropped — the
+ * common case, and the one where the list IS the whole truth.
+ */
+function truncationNote(tally) {
+    return tally.truncated ? `first ${MAX_TRACKED_ORIGINS} of more; ` : '';
+}
 /**
  * Iframe-mode transport. Validates `event.origin` on every inbound message,
  * awaits `BLOCK_INIT` with a 10s timeout (after which `waitForInit` rejects
@@ -13,13 +57,34 @@ const INIT_TIMEOUT_MS = 10_000;
 export class IframeTransport {
     originMatcher;
     /**
-     * The EXACT (non-wildcard) entries of `allowedParentOrigins`, usable as a
-     * `postMessage` `targetOrigin`. A wildcard entry (`https://*.civitaic.com`)
-     * is not a concrete origin and cannot be a target, so it is excluded here —
-     * see {@link announceReady} for what happens when nothing exact remains.
+     * The EXACT (non-wildcard) entries of `allowedParentOrigins`, NORMALISED by
+     * `OriginMatcher` and usable as a `postMessage` `targetOrigin`. A wildcard
+     * entry (`https://*.civitaic.com`) is not a concrete origin and cannot be a
+     * target, so it is excluded there — see {@link announceReady} for what
+     * happens when nothing exact remains.
      */
     exactAllowedOrigins;
+    /**
+     * The allowlist AS CONFIGURED (trimmed, not normalised). Named in the
+     * init-timeout error so the operator sees the strings they actually wrote
+     * next to the origins that actually arrived.
+     */
+    configuredOrigins;
     window;
+    /**
+     * Origins observed BEFORE init resolved, split by what the allowlist gate did
+     * with them. Both bounded — see {@link MAX_TRACKED_ORIGINS}.
+     *
+     * 🔴 THE TWO BUCKETS ARE DIFFERENT DIAGNOSES AND AN EMPTY PAIR IS A THIRD.
+     * "rejected" says the host is talking and the allowlist is wrong; "accepted,
+     * but nothing was a valid BLOCK_INIT" says the allowlist is right and the
+     * payload or the message type is wrong; neither means the host frame never
+     * posted at all. Collapsing them would send the one person reading this error
+     * to the wrong half of the system — the failure this whole diagnostic exists
+     * to prevent.
+     */
+    acceptedOriginTally = newTally();
+    rejectedOriginTally = newTally();
     snapshot = EMPTY_SNAPSHOT;
     listeners = new Set();
     /** Origin of the parent — captured from the first valid `BLOCK_INIT`. */
@@ -48,9 +113,15 @@ export class IframeTransport {
         // `https://*.example.com` entries match any subdomain on a dot boundary
         // (mirrors the host-side CSP frame-ancestors convention).
         this.originMatcher = new OriginMatcher(opts.allowedParentOrigins);
-        this.exactAllowedOrigins = opts.allowedParentOrigins
+        // From the matcher, NOT re-derived here: a second copy of "which entries are
+        // concrete origins, and how is one spelled" is a second place for the
+        // trailing-slash/case/default-port bug this class just fixed to come back —
+        // and it would come back specifically as a `postMessage` targetOrigin, where
+        // the failure is a silently dropped announce.
+        this.exactAllowedOrigins = this.originMatcher.exactOrigins;
+        this.configuredOrigins = opts.allowedParentOrigins
             .map((entry) => entry.trim())
-            .filter((entry) => entry.length > 0 && !entry.includes('*'));
+            .filter((entry) => entry.length > 0);
         this.window = opts.window ?? globalThis.window;
         if (!this.window) {
             throw new Error('IframeTransport: no window available; cannot mount on the server.');
@@ -63,6 +134,8 @@ export class IframeTransport {
             if (!this.initResolved) {
                 this.initResolved = true;
                 this.rejectInit(new Error(`IframeTransport: timed out waiting for BLOCK_INIT after ${INIT_TIMEOUT_MS}ms. ` +
+                    `${this.describeObservedOrigins()} ` +
+                    `Configured allowedParentOrigins: ${this.configuredOrigins.map((o) => `"${o}"`).join(', ') || '(none)'}. ` +
                     'Verify the host frame is sending the init message and that its origin is in allowedParentOrigins.'));
             }
         }, INIT_TIMEOUT_MS);
@@ -171,6 +244,28 @@ export class IframeTransport {
             }
         }
     }
+    /**
+     * One sentence naming the origins this transport actually heard from before
+     * init timed out — the single fact that turns "BLOCK_INIT never arrived" from
+     * a guess into a diagnosis.
+     *
+     * Three outcomes, deliberately worded apart (see {@link acceptedOriginTally}).
+     */
+    describeObservedOrigins() {
+        const parts = [];
+        if (this.rejectedOriginTally.seen.size > 0) {
+            parts.push(`rejected messages from ${formatOrigins(this.rejectedOriginTally)} ` +
+                `(${truncationNote(this.rejectedOriginTally)}no allowedParentOrigins entry matched)`);
+        }
+        if (this.acceptedOriginTally.seen.size > 0) {
+            parts.push(`accepted messages from ${formatOrigins(this.acceptedOriginTally)} ` +
+                `(${truncationNote(this.acceptedOriginTally)}none of them was a valid BLOCK_INIT)`);
+        }
+        if (parts.length === 0) {
+            return 'No inbound message was received from any origin.';
+        }
+        return `Origins seen: ${parts.join('; ')}.`;
+    }
     getSnapshot() {
         return this.snapshot;
     }
@@ -343,7 +438,7 @@ export class IframeTransport {
             return { label: OTHER_MESSAGE_TYPE_LABEL, hung: 'pushed' };
         }
         const requestId = payload?.requestId;
-        if (typeof requestId === 'string') {
+        if (isRoutableRequestId(requestId)) {
             const pending = this.pending.get(requestId);
             // The same predicate `handleMessage` applies before it will SETTLE a reply.
             // An id matching a request awaiting a DIFFERENT reply type names nothing we
@@ -432,8 +527,24 @@ export class IframeTransport {
         this.window.parent.postMessage(msg, this.parentOrigin);
     }
     handleMessage(event) {
-        if (!this.originMatcher.matches(event.origin))
+        if (!this.originMatcher.matches(event.origin)) {
+            // Still a DROP — nothing below this line runs. What changed is that the
+            // drop is no longer invisible: an origin rejected before init lands is the
+            // single fact that diagnoses a misspelled allowlist entry, and it is
+            // otherwise unobservable from inside the iframe. Bounded to
+            // MAX_TRACKED_ORIGINS distinct origins, and `recordOrigin` returns true
+            // only on the first sighting, so the host's ~400ms init retry warns ONCE
+            // rather than 25 times per ready window.
+            if (!this.initResolved && recordOrigin(this.rejectedOriginTally, event.origin)) {
+                // eslint-disable-next-line no-console -- developer-facing diagnostic at a trust boundary
+                console.warn(`IframeTransport: dropping a message from "${event.origin}" — no ` +
+                    'allowedParentOrigins entry matched. Configured: ' +
+                    `${this.configuredOrigins.map((o) => `"${o}"`).join(', ') || '(none)'}.`);
+            }
             return;
+        }
+        if (!this.initResolved)
+            recordOrigin(this.acceptedOriginTally, event.origin);
         const data = event.data;
         if (data == null || typeof data !== 'object' || typeof data.type !== 'string')
             return;
@@ -513,10 +624,28 @@ export class IframeTransport {
             return;
         }
         // For request/response replies, look up the pending entry by `requestId`.
-        const payload = data.payload;
+        //
+        // 🔴 PROJECTED, NOT RAW. This is the last point before an inbound payload
+        // crosses into block code — `pending.resolve` below and the push handlers
+        // further down are the only two deliveries, and BOTH read this binding.
+        // `projectInboundPayload` drops fields a consumer is not allowed to see
+        // (today: every key beyond `imageId`/`status` on a `hidden` gated image) and
+        // is identity for every other type. Validation said "deliver this message";
+        // this says "deliver these fields".
+        //
+        // The `TOKEN_REFRESH_RESPONSE` branch below still reads `data.payload` on
+        // purpose: it applies to the SNAPSHOT rather than handing anything to block
+        // code, and it needs the narrowing `isMessage` gave `data`. Every DELIVERY
+        // must read this binding instead — the raw object still carries whatever the
+        // host sent.
+        //
+        // It runs on the block's side of the boundary rather than in the hook
+        // because `getTransport` + `sendTypedRequest` are PUBLIC exports: a consumer
+        // that bypasses `useGatedImages()` still gets the projection.
+        const payload = projectInboundPayload(data.type, data.payload);
         let pending;
         let matchedRequestId = null;
-        if (payload && typeof payload.requestId === 'string') {
+        if (payload && isRoutableRequestId(payload.requestId)) {
             const candidate = this.pending.get(payload.requestId);
             if (candidate && candidate.responseType === data.type) {
                 pending = candidate;
@@ -549,8 +678,9 @@ export class IframeTransport {
         // listeners, so they fall through to the no-op tail below unchanged.
         const handlers = this.pushListeners.get(data.type);
         if (handlers && handlers.size > 0) {
+            // `payload`, not `data.payload`: the projected view — see the binding above.
             for (const handler of [...handlers])
-                handler(data.payload);
+                handler(payload);
             return;
         }
         if (isMessage(data, 'SUSPEND')) {

package/dist/transport/originMatcher.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Origin allowlist matching for {@link IframeTransport}.
+ *
+ * Each `allowedParentOrigins` entry is either:
+ * - an EXACT origin (`https://civitai.com`) — matched by string equality
+ *   against the NORMALISED entry, or
+ * - a SUFFIX-WILDCARD origin (`https://*.civitaic.com`) — matches any
+ *   `https://<sub>.civitaic.com`, where `<sub>` is one or more labels
+ *   (single-label `pr-9` or a full subtree `a.b`), but NOT the bare apex
+ *   `https://civitaic.com` and NOT a different registrable domain.
+ *
+ * The wildcard form mirrors the host-side CSP `frame-ancestors` convention
+ * (`https://*.civitaic.com`) so a single block build can trust both prod
+ * (`civitai.com`, an exact entry) and dynamic preview subdomains
+ * (`pr-N.civitaic.com`, a wildcard entry).
+ *
+ * ## Normalisation — ENTRIES ONLY, NEVER THE CANDIDATE
+ *
+ * 🔴 SECURITY DIRECTION. Entries are canonicalised at construction; the
+ * candidate handed to {@link OriginMatcher.matches} is compared RAW. That
+ * asymmetry is deliberate and must not be "tidied up": a real `event.origin`
+ * is already the serialization of a canonical origin (lowercase scheme + host,
+ * no trailing slash, default port elided, IDN in punycode), so normalising it
+ * again can only ADD accepts — e.g. `new URL('https://civitai.com/evil').origin`
+ * is `https://civitai.com`, so a `.origin` round-trip on the candidate would
+ * make a path-bearing string match an apex entry. Normalising only the entries
+ * is value-preserving on the set of REAL origins accepted while closing the
+ * spellings an operator actually writes.
+ *
+ * Equivalences deliberately ACCEPTED (an entry spelled this way matches the
+ * equivalent `event.origin`), all of them delegated to the URL parser so the
+ * rules are the WHATWG ones rather than hand-rolled string surgery:
+ * - trailing slash — `https://civitai.com/` ≡ `https://civitai.com`
+ * - scheme/host case — `HTTPS://CIVITAI.COM` ≡ `https://civitai.com`
+ *   (RFC 3986 §3.1/§3.2.2; path/query case is NOT touched — an origin has
+ *   neither, and an entry carrying one is rejected outright, below)
+ * - default port — `https://civitai.com:443` ≡ `https://civitai.com`,
+ *   `http://x:80` ≡ `http://x`
+ * - IDN — `https://пример.com` ≡ `https://xn--e1afmkfd.com`, which is the
+ *   form a browser puts on `event.origin`
+ *
+ * Distinctions deliberately KEPT (these are NOT equivalences — an entry and a
+ * candidate differing this way must not match):
+ * - a NON-default port stays significant: `https://civitai.com:8443` does not
+ *   match `https://civitai.com`
+ * - the scheme stays significant: `http://` never matches `https://`
+ * - a trailing-dot (fully-qualified) host is a DIFFERENT origin to the browser,
+ *   so `https://civitai.com.` and `https://civitai.com` stay distinct here too
+ * - no suffix/prefix logic on exact entries: `https://civitai.com.evil.com`
+ *   does not match `https://civitai.com`
+ *
+ * Spellings deliberately REJECTED — loudly, by throwing from the constructor.
+ * A malformed entry that is silently dropped is this file's own bug one level
+ * up: the allowlist then misses an origin the operator believes is on it, and
+ * nothing says so. An entry must denote an ORIGIN and nothing more:
+ * - no scheme (`civitai.com`) — unparseable
+ * - userinfo (`https://user:pass@civitai.com`) — `.origin` would silently
+ *   discard the credentials the author wrote
+ * - a path, query or fragment (`https://civitai.com/embed`) — `.origin` would
+ *   silently discard them, widening the entry to the whole origin
+ * - a scheme with no origin of its own (`foo://bar`, `file:///x`), whose
+ *   `.origin` serialises to the literal string `"null"` — the same string a
+ *   sandboxed opaque origin puts on `event.origin`, so accepting it would
+ *   allowlist every opaque frame at once
+ *
+ * Security: matching is scheme-pinned and suffix-anchored on a DOT boundary,
+ * so `https://*.civitaic.com` does NOT match `https://civitaic.com.attacker.tld`
+ * (different suffix) nor `https://evilcivitaic.com` (no dot boundary). A
+ * bare `*` or empty wildcard is rejected at construction.
+ */
+export declare class OriginMatcher {
+    private readonly exact;
+    private readonly wildcards;
+    /**
+     * The normalised EXACT origins, in first-seen order and de-duplicated.
+     *
+     * Exposed because `IframeTransport.announceReady` needs concrete
+     * `postMessage` targets and must derive them from the SAME normalisation as
+     * matching — one rule, one place. A wildcard is not a concrete origin and is
+     * absent here by construction.
+     */
+    readonly exactOrigins: readonly string[];
+    constructor(allowedParentOrigins: readonly string[]);
+    /**
+     * True when `origin` is allowed by an exact or wildcard allowlist entry.
+     *
+     * 🔴 `origin` is compared AS GIVEN — see the normalisation note in the module
+     * docblock for why it is never round-tripped through `new URL()` here.
+     */
+    matches(origin: string): boolean;
+}
+//# sourceMappingURL=originMatcher.d.ts.map

package/dist/transport/originMatcher.js

@@ -0,0 +1,222 @@
+/**
+ * Origin allowlist matching for {@link IframeTransport}.
+ *
+ * Each `allowedParentOrigins` entry is either:
+ * - an EXACT origin (`https://civitai.com`) — matched by string equality
+ *   against the NORMALISED entry, or
+ * - a SUFFIX-WILDCARD origin (`https://*.civitaic.com`) — matches any
+ *   `https://<sub>.civitaic.com`, where `<sub>` is one or more labels
+ *   (single-label `pr-9` or a full subtree `a.b`), but NOT the bare apex
+ *   `https://civitaic.com` and NOT a different registrable domain.
+ *
+ * The wildcard form mirrors the host-side CSP `frame-ancestors` convention
+ * (`https://*.civitaic.com`) so a single block build can trust both prod
+ * (`civitai.com`, an exact entry) and dynamic preview subdomains
+ * (`pr-N.civitaic.com`, a wildcard entry).
+ *
+ * ## Normalisation — ENTRIES ONLY, NEVER THE CANDIDATE
+ *
+ * 🔴 SECURITY DIRECTION. Entries are canonicalised at construction; the
+ * candidate handed to {@link OriginMatcher.matches} is compared RAW. That
+ * asymmetry is deliberate and must not be "tidied up": a real `event.origin`
+ * is already the serialization of a canonical origin (lowercase scheme + host,
+ * no trailing slash, default port elided, IDN in punycode), so normalising it
+ * again can only ADD accepts — e.g. `new URL('https://civitai.com/evil').origin`
+ * is `https://civitai.com`, so a `.origin` round-trip on the candidate would
+ * make a path-bearing string match an apex entry. Normalising only the entries
+ * is value-preserving on the set of REAL origins accepted while closing the
+ * spellings an operator actually writes.
+ *
+ * Equivalences deliberately ACCEPTED (an entry spelled this way matches the
+ * equivalent `event.origin`), all of them delegated to the URL parser so the
+ * rules are the WHATWG ones rather than hand-rolled string surgery:
+ * - trailing slash — `https://civitai.com/` ≡ `https://civitai.com`
+ * - scheme/host case — `HTTPS://CIVITAI.COM` ≡ `https://civitai.com`
+ *   (RFC 3986 §3.1/§3.2.2; path/query case is NOT touched — an origin has
+ *   neither, and an entry carrying one is rejected outright, below)
+ * - default port — `https://civitai.com:443` ≡ `https://civitai.com`,
+ *   `http://x:80` ≡ `http://x`
+ * - IDN — `https://пример.com` ≡ `https://xn--e1afmkfd.com`, which is the
+ *   form a browser puts on `event.origin`
+ *
+ * Distinctions deliberately KEPT (these are NOT equivalences — an entry and a
+ * candidate differing this way must not match):
+ * - a NON-default port stays significant: `https://civitai.com:8443` does not
+ *   match `https://civitai.com`
+ * - the scheme stays significant: `http://` never matches `https://`
+ * - a trailing-dot (fully-qualified) host is a DIFFERENT origin to the browser,
+ *   so `https://civitai.com.` and `https://civitai.com` stay distinct here too
+ * - no suffix/prefix logic on exact entries: `https://civitai.com.evil.com`
+ *   does not match `https://civitai.com`
+ *
+ * Spellings deliberately REJECTED — loudly, by throwing from the constructor.
+ * A malformed entry that is silently dropped is this file's own bug one level
+ * up: the allowlist then misses an origin the operator believes is on it, and
+ * nothing says so. An entry must denote an ORIGIN and nothing more:
+ * - no scheme (`civitai.com`) — unparseable
+ * - userinfo (`https://user:pass@civitai.com`) — `.origin` would silently
+ *   discard the credentials the author wrote
+ * - a path, query or fragment (`https://civitai.com/embed`) — `.origin` would
+ *   silently discard them, widening the entry to the whole origin
+ * - a scheme with no origin of its own (`foo://bar`, `file:///x`), whose
+ *   `.origin` serialises to the literal string `"null"` — the same string a
+ *   sandboxed opaque origin puts on `event.origin`, so accepting it would
+ *   allowlist every opaque frame at once
+ *
+ * Security: matching is scheme-pinned and suffix-anchored on a DOT boundary,
+ * so `https://*.civitaic.com` does NOT match `https://civitaic.com.attacker.tld`
+ * (different suffix) nor `https://evilcivitaic.com` (no dot boundary). A
+ * bare `*` or empty wildcard is rejected at construction.
+ */
+/**
+ * Stand-in label substituted for `*` so a wildcard entry can be canonicalised
+ * by the SAME URL parse as an exact entry (see {@link parseWildcard}). It must
+ * be a valid DNS label that the URL parser leaves untouched, and distinctive
+ * enough that a real suffix cannot begin with it.
+ */
+const WILDCARD_PROBE_LABEL = 'civitai-wildcard-probe';
+export class OriginMatcher {
+    exact;
+    wildcards;
+    /**
+     * The normalised EXACT origins, in first-seen order and de-duplicated.
+     *
+     * Exposed because `IframeTransport.announceReady` needs concrete
+     * `postMessage` targets and must derive them from the SAME normalisation as
+     * matching — one rule, one place. A wildcard is not a concrete origin and is
+     * absent here by construction.
+     */
+    exactOrigins;
+    constructor(allowedParentOrigins) {
+        const exact = new Set();
+        const wildcards = [];
+        for (const raw of allowedParentOrigins) {
+            const entry = raw.trim();
+            if (!entry)
+                continue;
+            const wildcard = parseWildcard(entry);
+            if (wildcard) {
+                wildcards.push(wildcard);
+            }
+            else {
+                exact.add(normaliseOrigin(entry, entry));
+            }
+        }
+        this.exact = exact;
+        this.exactOrigins = [...exact];
+        this.wildcards = wildcards;
+    }
+    /**
+     * True when `origin` is allowed by an exact or wildcard allowlist entry.
+     *
+     * 🔴 `origin` is compared AS GIVEN — see the normalisation note in the module
+     * docblock for why it is never round-tripped through `new URL()` here.
+     */
+    matches(origin) {
+        if (this.exact.has(origin))
+            return true;
+        for (const wc of this.wildcards) {
+            if (!origin.startsWith(wc.scheme))
+                continue;
+            const host = origin.slice(wc.scheme.length);
+            // Reject anything with a path/query smuggled into the host span:
+            // a real `event.origin` is scheme + host (+ optional :port). We require
+            // an exact host-suffix match with at least one leading label, and no '/'.
+            if (host.includes('/'))
+                continue;
+            // The host must END with the dot-anchored suffix AND have at least one
+            // character of label before the leading dot (so the apex itself is excluded).
+            if (host.length > wc.suffix.length && host.endsWith(wc.suffix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/**
+ * Canonicalises an allowlist entry to an origin serialization.
+ *
+ * `candidate` is what gets parsed; `entry` is what the operator wrote and is
+ * the only thing named in an error (for a wildcard the two differ — the probe
+ * label stands in for `*`). Throws on anything that is not, exactly, an origin.
+ */
+function normaliseOrigin(candidate, entry) {
+    let url;
+    try {
+        url = new URL(candidate);
+    }
+    catch {
+        throw new Error(`IframeTransport: invalid allowed parent origin "${entry}". ` +
+            'Entries must be absolute origins including a scheme, e.g. "https://civitai.com".');
+    }
+    const extras = [];
+    if (url.username || url.password)
+        extras.push('credentials');
+    // An absolute URL with a special scheme always has a pathname of at least
+    // "/", so only a LONGER path is a real path. `""` covers non-special schemes,
+    // which are rejected by the origin check below anyway.
+    if (url.pathname !== '' && url.pathname !== '/')
+        extras.push('a path');
+    if (url.search)
+        extras.push('a query string');
+    if (url.hash)
+        extras.push('a fragment');
+    if (extras.length > 0) {
+        throw new Error(`IframeTransport: invalid allowed parent origin "${entry}" — it carries ${extras.join(', ')}. An allowlist entry must be a bare origin (scheme + host + optional port), ` +
+            'e.g. "https://civitai.com"; anything beyond that is not part of an origin and ' +
+            'would be silently discarded.');
+    }
+    if (url.origin === 'null') {
+        throw new Error(`IframeTransport: invalid allowed parent origin "${entry}" — the "${url.protocol}" ` +
+            'scheme has no origin of its own, so it serialises to the literal "null" that a ' +
+            'sandboxed opaque frame also reports. Use an http(s) origin, e.g. "https://civitai.com".');
+    }
+    return url.origin;
+}
+/**
+ * Parses a `https://*.example.com`-style entry into `{scheme, suffix}`.
+ * Returns `null` for non-wildcard (exact) entries.
+ * Throws for malformed wildcards (`*` only, `https://*`, `https://*.`).
+ *
+ * Canonicalisation reuses {@link normaliseOrigin} by substituting a concrete
+ * placeholder label for `*` and stripping it back off the parsed origin. That
+ * is what makes a wildcard entry obey exactly the same case, default-port,
+ * trailing-slash and rejection rules as an exact one instead of a second,
+ * drifting copy of them — `https://*.CIVITAIC.COM:443/` and
+ * `https://*.civitaic.com` describe the same set, and a wildcard carrying a
+ * path is rejected rather than turning into an entry that can never match
+ * (`matches` refuses any host span containing `/`).
+ */
+function parseWildcard(entry) {
+    const star = entry.indexOf('*');
+    if (star === -1)
+        return null;
+    // Wildcard must be of the exact form `<scheme>://*.<suffix>`.
+    const marker = '://*.';
+    const markerAt = entry.indexOf(marker);
+    if (markerAt === -1) {
+        throw new Error(`IframeTransport: invalid wildcard origin "${entry}". ` +
+            'Wildcard entries must look like "https://*.example.com".');
+    }
+    const scheme = entry.slice(0, markerAt + 3); // include "://"
+    const bareSuffix = entry.slice(markerAt + marker.length); // after "://*."
+    if (!scheme || scheme === '://' || !bareSuffix || bareSuffix.includes('*')) {
+        throw new Error(`IframeTransport: invalid wildcard origin "${entry}". ` +
+            'A wildcard needs a scheme and a non-empty domain suffix with exactly one "*", ' +
+            'e.g. "https://*.example.com".');
+    }
+    const origin = normaliseOrigin(`${scheme}${WILDCARD_PROBE_LABEL}.${bareSuffix}`, entry);
+    const sep = origin.indexOf('://');
+    const normalisedScheme = origin.slice(0, sep + 3);
+    const host = origin.slice(sep + 3);
+    const probePrefix = `${WILDCARD_PROBE_LABEL}.`;
+    const normalisedSuffix = host.startsWith(probePrefix) ? host.slice(probePrefix.length) : '';
+    if (!normalisedSuffix) {
+        throw new Error(`IframeTransport: invalid wildcard origin "${entry}". ` +
+            'A wildcard needs a scheme and a non-empty domain suffix with exactly one "*", ' +
+            'e.g. "https://*.example.com".');
+    }
+    // Dot-anchor the suffix so `*.civitaic.com` only matches on a label boundary.
+    return { scheme: normalisedScheme, suffix: `.${normalisedSuffix}` };
+}
+//# sourceMappingURL=originMatcher.js.map