@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/multimodal_v2/utils/perceived_voice_turn_tracker.js

@@ -0,0 +1,345 @@
+function _extends() {
+    _extends = Object.assign || function(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source){
+                if (Object.prototype.hasOwnProperty.call(source, key)) {
+                    target[key] = source[key];
+                }
+            }
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+// No-drop per-turn state machine for the client-side "visitor-perceived voice" metric.
+//
+// Division of labor: the **server** owns "was a response generated?" (authoritative, via the
+// `coffeeStateUpdate` per-turn outcome); the **client** owns "was the generated answer *heard*,
+// and how fast?" (the unique perception layer the server is blind to).
+//
+// Lifecycle: a mic-quiet opens a *candidate* t0; resumed mic-active before confirmation
+// re-anchors t0 (discards the stale candidate); an `is_user_speaking:false` observed within
+// toleranceMs of the candidate confirms the turn and arms the response budget.
+//
+// The answer anchor: like the server, the turn's answer is its **last audible response** (a tool
+// turn answers with the continuation that follows the tool round-trip, not with its preamble).
+// Which onset that is cannot be heard from the audio alone — the detector reports a new onset for
+// any bot-audio gap past its hangover, and an ordinary pause between two sentences looks exactly
+// like a tool round-trip — so re-anchoring on every onset would walk the measurement to the last
+// *sentence* of a long answer. Instead the server publishes the response boundary
+// (`voice_answer_seq`, see `onAnswerBoundary`): a boundary that arrives once the anchored audio run
+// has ended discards that anchor (it was a preamble) so the answer's own onset anchors, while one
+// that arrives mid-run keeps it (the run *is* this response, delivered ahead of its marker). Absent
+// the signal (old coffee, dropped event) the first onset heard anchors and stands, which
+// under-reports a spoken preamble's tool turn but never drifts.
+//
+// Bot onsets do **not** resolve the turn. Resolution happens on:
+//   - the server outcome (preferred terminal marker): `success` -> if an onset was already heard,
+//     emit success+latency; else the answer is still in transit, so mark the turn *generated* and
+//     wait for the audible onset (or the budget) rather than falsely emitting `not_heard`;
+//     `failed`/`incomplete` -> `no_generation`/`not_heard`; `empty`/`interrupted` -> excluded
+//     (emit nothing); `timeout` -> deferred to the client budget.
+//   - the budget expiry (fallback when no server outcome arrives — old client / coffee down /
+//     dropped event): heard within budget -> success; else `timeout` (`not_heard` if the bot was
+//     seen, else `no_generation`). Preserves the no-drop guarantee.
+//   - the visitor speaking again over a still-open turn, mirroring the server's barge-in rule
+//     (`VoiceTurnTracker.on_user_started_speaking`): audio already delivered -> resolve like a
+//     delivered answer; nothing heard -> excluded, as the server excludes `interrupted`. Without
+//     this a turn awaiting a slow answer stays open across the next exchange, and the bot's reply
+//     to the *following* question lands inside this turn's measurement.
+//   - a visibilitychange -> hidden mid-turn -> `backgrounded` (a labeled bucket, excluded from
+//     the SLI ratio, not a silent drop).
+// Every turn resolves exactly once.
+class PerceivedVoiceTurnTracker {
+    onMicQuiet(ts) {
+        try {
+            if (this.confirmedT0 !== null) return; // already open; ignore intra-answer quiets
+            this.candidateT0 = ts; // latest quiet wins
+            // Ordering guard: the server's is_user_speaking:false can land *before* the detector's
+            // backdated mic-quiet (it fires only after the hangover confirms silence). In that order
+            // setUserSpeaking(false) ran while candidateT0 was still null and couldn't confirm, and
+            // nothing else would retry — so a slow/no-response turn (the timeouts we care about most)
+            // would never open. If an authoritative "not speaking" was already observed, confirm now.
+            if (this.sawServerSpeaking && !this.userSpeaking) this.tryConfirm();
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    onMicActive(_ts) {
+        try {
+            // Speech resumed before confirmation => the previous quiet was an intra-utterance pause,
+            // not the end of the turn. Discard the stale candidate so it doesn't leak into the next
+            // confirmed turn's latency measurement.
+            if (this.confirmedT0 === null) this.candidateT0 = null;
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    setUserSpeaking(v) {
+        try {
+            this.userSpeaking = v;
+            this.sawServerSpeaking = true;
+            // Any is_user_speaking:false observation (not just a true->false edge) can confirm a
+            // pending candidate: userSpeaking defaults to false before the first server update
+            // arrives, so gating on an edge would miss a legitimate confirmation racing the very
+            // first coffeeStateUpdate broadcast.
+            if (!v) {
+                this.tryConfirm();
+                return;
+            }
+            // The visitor is talking over a turn that never resolved. Close it the way the server
+            // closes its own on `speech_started`: a turn that delivered audio resolves like a delivered
+            // answer (the visitor chose to cut in), and one that delivered nothing is a barge-in into
+            // silence, which the server excludes as `interrupted`.
+            if (this.confirmedT0 !== null && !this.resolved) {
+                if (this.answerOnsetTs !== null) this.resolveGenerated();
+                else this.exclude();
+            }
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    setBotSpeaking(v) {
+        try {
+            if (v && this.confirmedT0 !== null) this.botSpeakingSeen = true;
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    onBotOnset(ts) {
+        try {
+            this.botRunActive = true;
+            if (this.confirmedT0 === null || this.resolved) return;
+            if (ts < this.confirmedT0) return;
+            // Anchor the first onset of the current answer and leave it there. Later onsets in the same
+            // response are the gaps between its sentences, not a new answer; only a server-published
+            // response boundary re-opens the anchor (see onAnswerBoundary).
+            if (this.answerOnsetTs === null) this.answerOnsetTs = ts;
+            // If the server already confirmed generation while nothing had been heard yet, this onset
+            // is the audible answer we were waiting for -> resolve now (see onServerOutcome `success`).
+            if (this.generated && !this.resolved) this.resolveGenerated();
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    // The bot's current audio run ended (the detector saw silence persist past its hangover). Only
+    // once a run has ended can a further onset fire, which is what lets `onAnswerBoundary` tell a
+    // finished preamble from a response still being delivered.
+    onBotSilence(_ts) {
+        try {
+            this.botRunActive = false;
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    // A new audible response has begun server-side (`voice_answer_seq` on `coffeeStateUpdate`,
+    // published by coffee's VoiceTurnTracker on each response's first audio byte). Anything anchored
+    // from an *earlier*, already-finished response is a preamble and is discarded so the next onset
+    // anchors the answer. Best-effort: when it never arrives the first onset simply stands.
+    onAnswerBoundary(seq) {
+        try {
+            if (typeof seq !== "number") return;
+            // Same monotonic dedupe as the outcome token: the value is sticky and re-broadcast on every
+            // unrelated state update, so only a strictly greater sequence is a new boundary.
+            if (this.lastAnswerSeq !== null && seq <= this.lastAnswerSeq) return;
+            this.lastAnswerSeq = seq;
+            if (this.confirmedT0 === null || this.resolved) {
+                // The marker can beat the detector's backdated mic-quiet, so the turn it belongs to may
+                // not be confirmed yet. Hold it: tryConfirm counts it as this turn's generation evidence
+                // only if it postdates that turn's t0, so it can't vouch for a later turn.
+                this.pendingAnswerBoundaryTs = this.deps.now();
+                return;
+            }
+            this.answerStartedSeen = true;
+            // Whether the anchor belongs to the response being announced or to a preamble is decided by
+            // the detector's audio run, not by how promptly the marker was delivered. While the run that
+            // produced the anchor is still playing, no further onset can fire for it (an onset needs a
+            // silence gap past the hangover first), so clearing the anchor here would strand the turn
+            // with nothing to anchor and time out an answer the visitor did hear. Keep it: that run is
+            // this response, delivered over WebRTC ahead of its marker. Once the run has ended the
+            // anchor was a preamble, and the answer's own onset is still to come.
+            if (!this.botRunActive) this.answerOnsetTs = null;
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    // The server's authoritative per-turn outcome + its monotonic turn_token, forwarded from
+    // `coffeeStateUpdate`. Best-effort: when it never arrives, the budget fallback still resolves.
+    onServerOutcome(outcome, token) {
+        try {
+            if (typeof token !== "number") return;
+            // Dedupe the sticky snapshot: apply each new token once. Also drops out-of-order replays.
+            if (this.lastOutcomeToken !== null && token <= this.lastOutcomeToken) return;
+            this.lastOutcomeToken = token;
+            if (this.confirmedT0 === null || this.resolved) return; // no open turn to attribute it to
+            switch(outcome){
+                case "empty":
+                case "interrupted":
+                    // No answer was expected (backchannel / silent turn) or the visitor barged in: exclude
+                    // the turn entirely, mirroring the server SLI's exclusions. Emit nothing.
+                    this.exclude();
+                    break;
+                case "failed":
+                case "incomplete":
+                    // The backend produced no clean answer -> a generation-side failure. If we heard any
+                    // audio (a preamble) or the bot was seen, it's "seen but not delivered"; else nothing.
+                    this.resolve("timeout", this.botAudioSeen ? "not_heard" : "no_generation");
+                    break;
+                case "success":
+                    // The server delivered an answer. Now our unique job: was it heard, and how fast?
+                    // Do NOT resolve `not_heard` synchronously: the outcome snapshot can arrive before the
+                    // final audio finishes traversing WebRTC/jitter/decode/render, so if nothing has been
+                    // heard yet we'd falsely call a heard answer `not_heard`. If we already have an onset,
+                    // resolve now; otherwise mark the turn generated and defer to the audible onset (in
+                    // onBotOnset) or, failing that, the budget fallback.
+                    if (this.answerOnsetTs !== null) this.resolveGenerated();
+                    else this.generated = true;
+                    break;
+                // "timeout" (and anything unrecognized) is not a clean "answer is done" marker — the
+                // answer may still be streaming — so defer to the client budget rather than resolving here.
+                default:
+                    break;
+            }
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    onHidden() {
+        try {
+            if (this.confirmedT0 !== null && !this.resolved) this.resolve("backgrounded", "none");
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    dispose() {
+        try {
+            // Don't silently drop a confirmed in-flight turn on call end / reconnect / flag-off: that
+            // would omit it from the uptime denominator and bias availability upward. Resolve it as
+            // `backgrounded` (a labeled bucket already excluded from the SLI ratio) so it's accounted
+            // for, honoring the no-drop guarantee.
+            if (this.confirmedT0 !== null && !this.resolved) this.resolve("backgrounded", "none");
+            this.clearBudget();
+            this.resolved = true;
+            this.reset();
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    tryConfirm() {
+        if (this.candidateT0 === null || this.confirmedT0 !== null) return;
+        const age = this.deps.now() - this.candidateT0;
+        if (age > this.deps.toleranceMs) {
+            this.candidateT0 = null; // stale mic-quiet; not this turn
+            return;
+        }
+        this.confirmedT0 = this.candidateT0;
+        this.candidateT0 = null;
+        this.resolved = false;
+        this.botSpeakingSeen = false;
+        this.generated = false;
+        // A boundary held from before confirmation is this turn's answer starting when it postdates t0
+        // (the server was already speaking while we waited on the detector's backdated mic-quiet).
+        // An older one announced a previous turn's answer and must not vouch for this turn, which would
+        // invert the `no_generation` / `not_heard` split it feeds.
+        this.answerStartedSeen = this.pendingAnswerBoundaryTs !== null && this.pendingAnswerBoundaryTs >= this.confirmedT0;
+        this.pendingAnswerBoundaryTs = null;
+        this.answerOnsetTs = null;
+        // Count the budget from t0, not from this confirmation: the mic-quiet is backdated by the
+        // detector's hangover and confirmation waits on the server's `is_user_speaking:false`, so
+        // arming it here would let a turn run up to toleranceMs past the deadline the status is
+        // judged against — and report a latency above a budget it was supposed to bound.
+        const remainingMs = Math.max(0, this.deps.budgetMs - age);
+        this.budgetTimerId = this.deps.setTimer(()=>this.onBudgetExpired(), remainingMs);
+    }
+    onBudgetExpired() {
+        try {
+            if (this.resolved || this.confirmedT0 === null) return;
+            // Fallback path: no server terminal arrived within budget. Resolve from what we perceived.
+            if (this.answerOnsetTs !== null) {
+                // We heard the answer; any onset recorded before the budget fired is within budget.
+                this.resolveGenerated();
+            } else {
+                // Nothing heard. If the server had confirmed generation (or the bot was seen), the answer
+                // was produced but never reached the visitor -> the back-gap failure; else no generation.
+                this.resolve("timeout", this.generated || this.botAudioSeen ? "not_heard" : "no_generation");
+            }
+        } catch (unused) {
+        /* observation-only */ }
+    }
+    // Resolve a turn the server (or the budget fallback) confirms had a generated answer: emit the
+    // uncensored latency to the anchored answer onset if we heard one, and label success/timeout by
+    // whether that onset landed within budget; if generation happened but nothing was heard, it's
+    // the back-gap failure (`not_heard`).
+    resolveGenerated() {
+        const t0 = this.confirmedT0;
+        if (t0 === null) return;
+        if (this.answerOnsetTs !== null) {
+            const latency = this.answerOnsetTs - t0;
+            if (latency >= 0) this.deps.emitLatency(latency);
+            const withinBudget = latency <= this.deps.budgetMs;
+            this.resolve(withinBudget ? "success" : "timeout", withinBudget ? "none" : "not_heard");
+        } else {
+            this.resolve("timeout", "not_heard");
+        }
+    }
+    resolve(status, stage) {
+        if (this.resolved) return;
+        this.resolved = true;
+        this.clearBudget();
+        this.deps.emitTurn(status, stage);
+        this.reset();
+    }
+    // Resolve without emitting (excluded from the SLI, mirroring server `empty`/`interrupted`).
+    exclude() {
+        if (this.resolved) return;
+        this.resolved = true;
+        this.clearBudget();
+        this.reset();
+    }
+    // Whether the bot produced audio this turn by any signal we have: something anchored, a
+    // response boundary from the server, or `is_bot_speaking`. Separates "generated but never
+    // delivered" (`not_heard`) from "nothing was ever produced" (`no_generation`).
+    get botAudioSeen() {
+        return this.answerOnsetTs !== null || this.answerStartedSeen || this.botSpeakingSeen;
+    }
+    // Clear per-turn state for the next turn. `lastOutcomeToken` / `lastAnswerSeq` persist across
+    // turns (both monotonic for the whole call).
+    reset() {
+        this.confirmedT0 = null;
+        this.candidateT0 = null;
+        this.answerOnsetTs = null;
+        this.pendingAnswerBoundaryTs = null;
+        this.botSpeakingSeen = false;
+        this.generated = false;
+        this.answerStartedSeen = false;
+    }
+    clearBudget() {
+        if (this.budgetTimerId !== null) {
+            this.deps.clearTimer(this.budgetTimerId);
+            this.budgetTimerId = null;
+        }
+    }
+    constructor(deps){
+        this.userSpeaking = false;
+        this.sawServerSpeaking = false; // at least one is_user_speaking update has been observed
+        this.botSpeakingSeen = false; // is_bot_speaking observed since the turn was confirmed
+        this.generated = false; // server confirmed a generated answer; awaiting the audible onset
+        this.answerStartedSeen = false; // a response boundary was observed since the turn was confirmed
+        // Whether bot audio is currently running per the detector's hysteresis. A property of the audio
+        // rather than of a turn, so it deliberately survives reset() across turns.
+        this.botRunActive = false;
+        // Candidate (pre-confirmation) and confirmed (post-confirmation, budget-armed) turn state.
+        this.candidateT0 = null;
+        this.confirmedT0 = null;
+        this.answerOnsetTs = null; // first onset of the current answer, null if none
+        // A boundary observed while no turn was confirmed, held for the turn it may belong to.
+        this.pendingAnswerBoundaryTs = null;
+        this.budgetTimerId = null;
+        this.resolved = false;
+        // Highest server turn_token consumed. The outcome rides a *sticky* state snapshot that is
+        // re-broadcast on every unrelated update, so we apply each token at most once (monotonic dedupe).
+        this.lastOutcomeToken = null;
+        // Highest server answer-boundary sequence consumed. Rides the same sticky snapshot, and is
+        // monotonic for the whole call, so the same dedupe applies.
+        this.lastAnswerSeq = null;
+        this.deps = _extends({
+            toleranceMs: 1500,
+            now: ()=>performance.now(),
+            setTimer: (cb, ms)=>window.setTimeout(cb, ms),
+            clearTimer: (id)=>window.clearTimeout(id)
+        }, deps);
+    }
+}
+
+export { PerceivedVoiceTurnTracker };

package/widget/multimodal_v2/utils/sanitize_html.js

@@ -0,0 +1,132 @@
+/**
+ * Simple HTML sanitization utility to prevent XSS attacks.
+ * Removes dangerous tags and attributes while preserving safe HTML structure.
+ */ // Default dangerous tags that should always be removed
+const DEFAULT_FORBIDDEN_TAGS = new Set([
+    "script",
+    "style",
+    "iframe",
+    "object",
+    "embed",
+    "form",
+    "input",
+    "textarea",
+    "button",
+    "select",
+    "meta",
+    "link",
+    "base",
+    // SVG elements that can contain embedded scripts
+    "svg",
+    "math",
+    "foreignObject"
+]);
+// Default dangerous attributes that should always be removed
+const DEFAULT_FORBIDDEN_ATTRS = new Set([
+    // Event handlers
+    "onerror",
+    "onload",
+    "onclick",
+    "onmouseover",
+    "onmouseout",
+    "onmousedown",
+    "onmouseup",
+    "onfocus",
+    "onblur",
+    "onchange",
+    "onsubmit",
+    "onkeydown",
+    "onkeyup",
+    "onkeypress",
+    "ondrag",
+    "ondrop",
+    "srcdoc",
+    "formaction",
+    "poster",
+    "dynsrc",
+    "lowsrc",
+    "xlink:href"
+]);
+/**
+ * Checks if a URL value starts with a dangerous protocol.
+ */ function hasDangerousProtocol(value) {
+    const normalizedValue = value.toLowerCase().trim();
+    // Check for dangerous protocols - split to avoid linter detection
+    const jsProto = "javascript:";
+    return normalizedValue.startsWith(jsProto) || normalizedValue.startsWith("data:") || normalizedValue.startsWith("vbscript:");
+}
+/**
+ * Sanitizes HTML string to prevent XSS attacks.
+ * Uses the same interface as DOMPurify in case we need to migrate to it later.
+ *
+ * @param html - The HTML string to sanitize
+ * @param config - Optional configuration for sanitization
+ * @returns DocumentFragment by default, or string if RETURN_DOM is false
+ */ function sanitizeHtml(html, config) {
+    const { ADD_ATTR = [], FORBID_TAGS = [], FORBID_ATTR = [], AFTER_SANITIZE_ATTRIBUTES } = config != null ? config : {};
+    // Build sets for efficient lookup
+    const forbiddenTags = new Set([
+        ...DEFAULT_FORBIDDEN_TAGS,
+        ...FORBID_TAGS.map((t)=>t.toLowerCase())
+    ]);
+    const forbiddenAttrs = new Set([
+        ...DEFAULT_FORBIDDEN_ATTRS,
+        ...FORBID_ATTR.map((a)=>a.toLowerCase())
+    ]);
+    const allowedAttrs = new Set(ADD_ATTR.map((a)=>a.toLowerCase()));
+    // Create a temporary container to parse HTML
+    const template = document.createElement("template");
+    template.innerHTML = html;
+    const { content } = template;
+    // Process all elements
+    sanitizeNode(content, forbiddenTags, forbiddenAttrs, allowedAttrs, AFTER_SANITIZE_ATTRIBUTES);
+    // Return DOM directly by default (avoids serialization)
+    return content;
+}
+function sanitizeNode(node, forbiddenTags, forbiddenAttrs, allowedAttrs, afterSanitize) {
+    // Collect nodes to remove (can't modify while iterating)
+    const nodesToRemove = [];
+    // Process child nodes
+    for (const child of Array.from(node.childNodes)){
+        if (child.nodeType === Node.ELEMENT_NODE) {
+            const element = child;
+            const tagName = element.tagName.toLowerCase();
+            // Remove forbidden tags entirely
+            if (forbiddenTags.has(tagName)) {
+                nodesToRemove.push(child);
+            } else {
+                // Sanitize attributes
+                sanitizeAttributes(element, forbiddenAttrs, allowedAttrs);
+                // Apply post-sanitization callback
+                if (afterSanitize) {
+                    afterSanitize(element);
+                }
+                // Recursively sanitize children
+                sanitizeNode(child, forbiddenTags, forbiddenAttrs, allowedAttrs, afterSanitize);
+            }
+        }
+    }
+    // Remove collected nodes
+    for (const nodeToRemove of nodesToRemove){
+        node.removeChild(nodeToRemove);
+    }
+}
+function sanitizeAttributes(element, forbiddenAttrs, allowedAttrs) {
+    const attrsToRemove = [];
+    for (const attr of Array.from(element.attributes)){
+        const { name, value } = attr;
+        const attrName = name.toLowerCase();
+        const shouldRemove = forbiddenAttrs.has(attrName) && !allowedAttrs.has(attrName) || // Remove any attribute starting with "on" (event handlers)
+        attrName.startsWith("on") || // Remove dangerous URL protocols
+        (attrName === "href" || attrName === "src" || attrName === "action") && hasDangerousProtocol(value);
+        if (shouldRemove) {
+            attrsToRemove.push(name);
+        }
+    }
+    // Remove collected attributes
+    for (const attrName of attrsToRemove){
+        element.removeAttribute(attrName);
+    }
+}
+
+export { sanitizeHtml };

package/widget/multimodal_v2/utils/signals.js

@@ -0,0 +1,97 @@
+import { signals_core_module_d, signals_core_module_w } from "../../../js/multimodal_v2.js";
+import { getCache } from "./multimodal_cache.js";
+import { ObjectsMap } from "./objects_map.js";
+
+
+
+
+const ANY_KEY = "utils.signals.any";
+function $any() {
+    for(var _len = arguments.length, signals = new Array(_len), _key = 0; _key < _len; _key++){
+        signals[_key] = arguments[_key];
+    }
+    return deriveMany(signals, ANY_KEY, (signals)=>signals.some((signal)=>signal.value));
+}
+const ALL_KEY = "utils.signals.all";
+function $all() {
+    for(var _len = arguments.length, signals = new Array(_len), _key = 0; _key < _len; _key++){
+        signals[_key] = arguments[_key];
+    }
+    return deriveMany(signals, ALL_KEY, (signals)=>signals.every((signal)=>signal.value));
+}
+const NOT_KEY = Symbol("utils.signals.not");
+function $not(signal) {
+    return derive(signal, NOT_KEY, (signal)=>!signal.value);
+}
+const EMPTY_KEY = Symbol("utils.signals.empty");
+function $empty(signal) {
+    return derive(signal, EMPTY_KEY, (signal)=>signal.value.length === 0);
+}
+function $present(signal) {
+    return $not($empty(signal));
+}
+const EXISTS_KEY = Symbol("utils.signals.exists");
+function $exists(signal) {
+    return derive(signal, EXISTS_KEY, (signal)=>signal.value != null);
+}
+function $absent(signal) {
+    return $not($exists(signal));
+}
+const ATTR_KEY = "utils.signals.attr";
+function $attr(signal, key) {
+    return derive(signal, ATTR_KEY + "." + key, (signal)=>{
+        var _ref;
+        var _signal_value;
+        return (_ref = (_signal_value = signal.value) == null ? void 0 : _signal_value[key]) != null ? _ref : null;
+    });
+}
+function $fromImport(importFn) {
+    for(var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        args[_key - 1] = arguments[_key];
+    }
+    const sig = signals_core_module_d(null);
+    let loadPromise = null;
+    const load = async ()=>{
+        // Already loaded
+        if (sig.value) {
+            return sig.value;
+        }
+        // Already loading
+        if (loadPromise) {
+            return loadPromise;
+        }
+        // Start loading
+        loadPromise = importFn().then((module)=>{
+            // Use default export
+            const Class = module.default;
+            sig.value = new Class(...args);
+            return sig.value;
+        });
+        return loadPromise;
+    };
+    return Object.assign(sig, {
+        load
+    });
+}
+function isSignalike(value) {
+    return typeof value === "object" && value !== null && "value" in value && "subscribe" in value && "peek" in value;
+}
+function derive(signal, key, fn) {
+    if (key in signal) return signal[key];
+    const derived = signals_core_module_w(()=>fn(signal));
+    Object.assign(signal, {
+        [key]: derived
+    });
+    return derived;
+}
+function deriveMany(signals, key, fn) {
+    const map = getCache(key, ()=>new ObjectsMap());
+    return map.getOrSet(signals, (signals)=>signals_core_module_w(()=>fn(signals)));
+}
+
+var signals_$absent = /* unused export */ undefined;
+var signals_$all = /* unused export */ undefined;
+var signals_$attr = /* unused export */ undefined;
+var signals_$empty = /* unused export */ undefined;
+var signals_$present = /* unused export */ undefined;
+export { $any, $exists, $fromImport, $not, isSignalike, signals_$absent as $absent, signals_$all as $all, signals_$attr as $attr, signals_$empty as $empty, signals_$present as $present };