@learncard/partner-connect 0.3.10 → 0.4.1

package/dist/partner-connect.mjs

@@ -1,10 +1,10 @@
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
 class PartnerConnectError extends Error {
   constructor(code, message) {
     super(message);
-    __publicField$1(this, "code");
+    __publicField$2(this, "code");
     this.name = "PartnerConnectError";
     this.code = code;
     Object.setPrototypeOf(this, PartnerConnectError.prototype);
@@ -31,10 +31,679 @@ class PartnerConnectError extends Error {
   }
 }
 
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+const DEFAULT_DID = "did:web:mock.learncard.app:user";
+const DEFAULT_NAMESPACE = "lc-mock";
+const MOCK_PREFIX = "[LearnCard SDK \xB7 MOCK]";
+const hasDocument = () => typeof document !== "undefined" && typeof document.createElement === "function";
+const readAchievementName = (payload) => {
+  var _a, _b, _c, _d;
+  if (!payload || typeof payload !== "object") return "a credential";
+  const record = payload;
+  if (typeof record.templateAlias === "string" && record.templateAlias) {
+    const data = record.templateData;
+    if (data && typeof data === "object") {
+      const fields = data;
+      const named = (_c = (_b = (_a = fields.name) != null ? _a : fields.achievementName) != null ? _b : fields.courseName) != null ? _c : fields.title;
+      if (typeof named === "string" && named) return named;
+    }
+    return record.templateAlias;
+  }
+  const credential = (_d = record.credential) != null ? _d : record;
+  if (credential && typeof credential === "object") {
+    const subject = credential.credentialSubject;
+    const achievement = subject == null ? void 0 : subject.achievement;
+    if (achievement && typeof achievement.name === "string" && achievement.name) {
+      return achievement.name;
+    }
+    if (typeof credential.name === "string" && credential.name) return credential.name;
+  }
+  return "a credential";
+};
+class MockHost {
+  constructor(options) {
+    __publicField$1(this, "options");
+    /** In-memory counter fallback used when persistence is off/unavailable. */
+    __publicField$1(this, "memoryCounters", /* @__PURE__ */ new Map());
+    /** Session-scoped credential store; reads reflect writes and seeds. */
+    __publicField$1(this, "credentials", []);
+    __publicField$1(this, "identity");
+    /** DOM nodes injected for visual feedback, tracked for cleanup. */
+    __publicField$1(this, "domNodes", /* @__PURE__ */ new Set());
+    /** The app's single AI Topic, created lazily by the first AI session. */
+    __publicField$1(this, "aiTopic", null);
+    __publicField$1(this, "styleEl", null);
+    __publicField$1(this, "stackEl", null);
+    __publicField$1(this, "activeToasts", /* @__PURE__ */ new Map());
+    /** Pending exit-animation timers, tracked so `destroy()` can cancel them. */
+    __publicField$1(this, "exitTimers", /* @__PURE__ */ new Set());
+    __publicField$1(this, "idSeq", 0);
+    __publicField$1(this, "destroyed", false);
+    var _a, _b, _c, _d, _e, _f, _g;
+    this.options = {
+      ui: (_a = options == null ? void 0 : options.ui) != null ? _a : true,
+      log: (_b = options == null ? void 0 : options.log) != null ? _b : true,
+      persist: (_c = options == null ? void 0 : options.persist) != null ? _c : true,
+      namespace: (options == null ? void 0 : options.namespace) || DEFAULT_NAMESPACE
+    };
+    this.identity = {
+      ...(_d = options == null ? void 0 : options.identity) != null ? _d : {},
+      did: ((_e = options == null ? void 0 : options.identity) == null ? void 0 : _e.did) || (options == null ? void 0 : options.did) || DEFAULT_DID
+    };
+    for (const seed of (_f = options == null ? void 0 : options.credentials) != null ? _f : []) {
+      this.addCredential({
+        name: seed.name || seed.templateAlias || "Mock Credential",
+        templateAlias: seed.templateAlias,
+        boostUri: seed.boostUri,
+        recipient: seed.recipient,
+        status: seed.status
+      });
+    }
+    for (const [key, value] of Object.entries((_g = options == null ? void 0 : options.counters) != null ? _g : {})) {
+      if (this.readCounter(key) === void 0) this.writeCounter(key, value);
+    }
+    this.announce();
+  }
+  /**
+   * Resolve a simulated response for one SDK request. Mirrors the real host:
+   * direct actions map 1:1, and `APP_EVENT` is dispatched by its `type`.
+   */
+  handle(action, payload) {
+    var _a, _b;
+    if (this.destroyed) {
+      return Promise.reject({
+        code: "SDK_DESTROYED",
+        message: "Mock host was destroyed before the request completed"
+      });
+    }
+    this.log(action, payload);
+    if (action === "APP_EVENT") {
+      return this.handleAppEvent(payload);
+    }
+    switch (action) {
+      case "REQUEST_IDENTITY":
+        this.toast({
+          icon: "\u{1F464}",
+          segments: ["In LearnCard, the user would sign in. Returning a mock identity."]
+        });
+        return Promise.resolve({
+          token: `mock-token-${Date.now()}`,
+          user: { ...this.identity }
+        });
+      case "SEND_CREDENTIAL": {
+        const name = readAchievementName(payload);
+        const credentialId = `mock-credential-${Date.now()}-${this.idSeq += 1}`;
+        this.addCredential({
+          name,
+          credentialUri: credentialId,
+          credential: payload == null ? void 0 : payload.credential
+        });
+        this.showClaimToast(name);
+        return Promise.resolve({ credentialId, stored: true });
+      }
+      case "REQUEST_CONSENT": {
+        const redirect = Boolean(payload == null ? void 0 : payload.redirect);
+        this.showConsentBanner(redirect);
+        return Promise.resolve({ granted: true });
+      }
+      case "LAUNCH_FEATURE": {
+        const featurePath = (_a = payload == null ? void 0 : payload.featurePath) != null ? _a : "";
+        this.toast({
+          icon: "\u{1F680}",
+          segments: featurePath ? ["In LearnCard, this would open ", { b: featurePath }, "."] : ["In LearnCard, this would open a feature screen."]
+        });
+        return Promise.resolve({ launched: true, featurePath });
+      }
+      case "ASK_CREDENTIAL_SEARCH": {
+        const held = this.selfCredentials();
+        this.toast({
+          icon: "\u{1F50D}",
+          segments: held.length ? ["The user could share ", { b: String(held.length) }, " credential(s)."] : [
+            "In LearnCard, the user would be asked to share matching credentials. None in mock."
+          ]
+        });
+        return Promise.resolve({
+          verifiablePresentation: {
+            verifiableCredential: held.map((c) => c.credential)
+          }
+        });
+      }
+      case "ASK_CREDENTIAL_SPECIFIC": {
+        const credentialId = payload == null ? void 0 : payload.credentialId;
+        const found = this.credentials.find((c) => c.credentialUri === credentialId);
+        this.toast({
+          icon: "\u{1F50D}",
+          segments: found ? ["Sharing ", { b: found.name }, "."] : [
+            "In LearnCard, the user would be asked to share a credential. Not found in mock."
+          ]
+        });
+        return Promise.resolve({ credential: found == null ? void 0 : found.credential });
+      }
+      case "INITIATE_TEMPLATE_ISSUE": {
+        const input = payload;
+        const templateId = (_b = input == null ? void 0 : input.templateId) != null ? _b : "";
+        const recipients = Array.isArray(input == null ? void 0 : input.draftRecipients) ? input == null ? void 0 : input.draftRecipients : [];
+        for (const recipient of recipients) {
+          this.addCredential({
+            name: templateId || "Boost",
+            boostUri: templateId,
+            recipient,
+            status: "pending"
+          });
+        }
+        this.toast({
+          icon: "\u{1F4E4}",
+          segments: recipients.length ? [
+            "This would issue to ",
+            { b: String(recipients.length) },
+            " recipient(s)."
+          ] : ["In LearnCard, this would open the Send Boost flow."]
+        });
+        return Promise.resolve({ issued: true });
+      }
+      case "REQUEST_LEARNER_CONTEXT": {
+        const opts = payload != null ? payload : {};
+        const includeCredentials = opts.includeCredentials !== false;
+        const structured = opts.format === "structured";
+        const held = includeCredentials ? this.selfCredentials() : [];
+        this.toast({
+          icon: "\u{1F9E0}",
+          segments: !includeCredentials ? ["Learner profile requested with credentials excluded."] : held.length ? ["Learner profile: ", { b: String(held.length) }, " credential(s)."] : ["In LearnCard, the user's learner profile would load. Empty in mock."]
+        });
+        const prompt = !includeCredentials ? "Mock learner context: credentials were not requested." : held.length ? `Mock learner context. Credentials held: ${held.map((c) => c.name).join(", ")}.` : "Mock learner context: this user has no credentials in standalone mode.";
+        return Promise.resolve({
+          status: "ready",
+          prompt,
+          did: this.identity.did,
+          // Matches the real host: `raw` only ships for format: 'structured'.
+          ...structured ? { raw: { credentials: held.map((c) => c.credential) } } : {}
+        });
+      }
+      case "GET_SYNC_STATUS":
+        this.toast({
+          icon: "\u{1F504}",
+          segments: [
+            "In LearnCard, this reports data sync progress. Mock reports ready."
+          ]
+        });
+        return Promise.resolve({
+          status: "ready",
+          progress: {
+            totalCredentials: 0,
+            completedCredentials: 0,
+            failedCredentials: 0,
+            retryCount: 0
+          }
+        });
+      default:
+        this.toast({
+          icon: "\u2728",
+          segments: ["In LearnCard, this would run ", { b: action }, "."]
+        });
+        return Promise.resolve({});
+    }
+  }
+  /** Tear down injected UI and clear in-memory state. */
+  destroy() {
+    this.destroyed = true;
+    for (const entry of this.activeToasts.values()) clearTimeout(entry.timeoutId);
+    this.activeToasts.clear();
+    for (const timer of this.exitTimers) clearTimeout(timer);
+    this.exitTimers.clear();
+    for (const node of this.domNodes) node.remove();
+    this.domNodes.clear();
+    if (this.stackEl) {
+      this.stackEl.remove();
+      this.stackEl = null;
+    }
+    if (this.styleEl) {
+      this.styleEl.remove();
+      this.styleEl = null;
+    }
+    this.memoryCounters.clear();
+    this.credentials.length = 0;
+  }
+  handleAppEvent(event) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const type = typeof (event == null ? void 0 : event.type) === "string" ? event.type : "";
+    switch (type) {
+      case "send-credential": {
+        const name = readAchievementName(event);
+        const templateAlias = typeof event.templateAlias === "string" ? event.templateAlias : void 0;
+        const boostUri = `lc:mock:boost:${String((_a = event.templateAlias) != null ? _a : "template")}`;
+        if (event.preventDuplicateClaim) {
+          const existing = this.selfCredentials().find(
+            (c) => this.matchesTemplate(c, { templateAlias, boostUri })
+          );
+          if (existing) {
+            this.toast({
+              icon: "\u2705",
+              segments: ["The user already has ", { b: existing.name }, "."]
+            });
+            return Promise.resolve({
+              credentialUri: existing.credentialUri,
+              boostUri: (_b = existing.boostUri) != null ? _b : boostUri,
+              alreadyClaimed: true,
+              hasCredential: true,
+              status: existing.status,
+              receivedDate: existing.receivedDate
+            });
+          }
+        }
+        const record = this.addCredential({
+          name,
+          templateAlias,
+          boostUri,
+          status: "claimed"
+        });
+        this.showClaimToast(name);
+        return Promise.resolve({
+          credentialUri: record.credentialUri,
+          boostUri: (_c = record.boostUri) != null ? _c : boostUri,
+          alreadyClaimed: false,
+          hasCredential: true,
+          status: "claimed",
+          receivedDate: record.receivedDate
+        });
+      }
+      case "check-credential": {
+        const held = this.selfCredentials().find((c) => this.matchesTemplate(c, event));
+        this.toast({
+          icon: "\u{1F50E}",
+          segments: held ? ["The user already has ", { b: held.name }, "."] : ["Mock: the user doesn't have this credential yet."]
+        });
+        return Promise.resolve(
+          held ? {
+            hasCredential: true,
+            credentialUri: held.credentialUri,
+            receivedDate: held.receivedDate,
+            status: held.status
+          } : { hasCredential: false }
+        );
+      }
+      case "check-issuance-status": {
+        const recipient = typeof event.recipient === "string" ? event.recipient : "";
+        const match = this.credentials.find(
+          (c) => this.matchesTemplate(c, event) && c.recipient === recipient
+        );
+        this.toast({
+          icon: "\u{1F50E}",
+          segments: match ? ["Issued to ", { b: recipient }, " \u2014 ", { b: match.status }, "."] : ["Mock: not sent to this recipient yet."]
+        });
+        return Promise.resolve(
+          match ? {
+            sent: true,
+            credentialUri: match.credentialUri,
+            sentDate: match.sentDate,
+            claimedDate: match.claimedDate,
+            status: match.status
+          } : { sent: false }
+        );
+      }
+      case "get-template-recipients": {
+        const matched = this.credentials.filter((c) => this.matchesTemplate(c, event));
+        const limit = typeof event.limit === "number" && event.limit > 0 ? event.limit : void 0;
+        const parsedCursor = typeof event.cursor === "string" ? Number.parseInt(event.cursor, 10) : 0;
+        const offset = Number.isFinite(parsedCursor) && parsedCursor > 0 ? parsedCursor : 0;
+        const page = limit ? matched.slice(offset, offset + limit) : matched.slice(offset);
+        const nextOffset = offset + page.length;
+        const hasMore = nextOffset < matched.length;
+        this.toast({
+          icon: "\u{1F465}",
+          segments: [
+            "In LearnCard, this lists recipients. ",
+            { b: String(matched.length) },
+            " in mock."
+          ]
+        });
+        return Promise.resolve({
+          records: page.map((c) => this.toRecipientRecord(c)),
+          hasMore,
+          ...hasMore ? { cursor: String(nextOffset) } : {},
+          total: matched.length
+        });
+      }
+      case "send-notification": {
+        const title = typeof event.title === "string" ? event.title : "";
+        const body = typeof event.body === "string" ? event.body : "";
+        const text = [title, body].filter(Boolean).join(" \u2014 ");
+        this.toast({
+          icon: "\u{1F514}",
+          segments: text ? ["The user would be notified: ", { b: text }] : ["In LearnCard, the user would receive a notification."]
+        });
+        return Promise.resolve({ sent: true });
+      }
+      case "increment-counter": {
+        const key = String((_d = event.key) != null ? _d : "");
+        const amount = typeof event.amount === "number" ? event.amount : 0;
+        const previous = (_f = (_e = this.readCounter(key)) == null ? void 0 : _e.value) != null ? _f : 0;
+        const next = previous + amount;
+        this.writeCounter(key, next);
+        this.toast({
+          icon: "\u{1F522}",
+          segments: ["Counter ", { b: key }, " \u2192 ", { b: String(next) }, "."]
+        });
+        return Promise.resolve({ key, previousValue: previous, newValue: next });
+      }
+      case "get-counter": {
+        const key = String((_g = event.key) != null ? _g : "");
+        const stored = this.readCounter(key);
+        const value = (_h = stored == null ? void 0 : stored.value) != null ? _h : 0;
+        this.toast({
+          icon: "\u{1F522}",
+          segments: ["Counter ", { b: key }, " is ", { b: String(value) }, "."]
+        });
+        return Promise.resolve({
+          key,
+          value,
+          updatedAt: (_i = stored == null ? void 0 : stored.updatedAt) != null ? _i : null
+        });
+      }
+      case "get-counters": {
+        const requested = Array.isArray(event.keys) ? event.keys.map(String) : this.allCounterKeys();
+        const counters = requested.map((key) => {
+          var _a2, _b2;
+          const stored = this.readCounter(key);
+          return { key, value: (_a2 = stored == null ? void 0 : stored.value) != null ? _a2 : 0, updatedAt: (_b2 = stored == null ? void 0 : stored.updatedAt) != null ? _b2 : null };
+        });
+        this.toast({
+          icon: "\u{1F522}",
+          segments: ["Read ", { b: String(counters.length) }, " counter(s)."]
+        });
+        return Promise.resolve({ counters });
+      }
+      case "send-ai-session-credential": {
+        const sessionTitle = typeof event.sessionTitle === "string" && event.sessionTitle ? event.sessionTitle : "AI session";
+        const sessionBoostUri = this.nextUri("lc:mock:session-boost");
+        const record = this.addCredential({
+          name: sessionTitle,
+          boostUri: sessionBoostUri,
+          status: "claimed"
+        });
+        this.toast({
+          icon: "\u2705",
+          segments: [
+            "In LearnCard, an AI session credential would be saved: ",
+            { b: sessionTitle }
+          ]
+        });
+        const isNewTopic = this.aiTopic === null;
+        if (!this.aiTopic) {
+          this.aiTopic = {
+            topicUri: this.nextUri("lc:mock:topic"),
+            topicCredentialUri: this.nextUri("lc:mock:topic-credential")
+          };
+        }
+        return Promise.resolve({
+          topicUri: this.aiTopic.topicUri,
+          ...isNewTopic ? { topicCredentialUri: this.aiTopic.topicCredentialUri } : {},
+          sessionCredentialUri: record.credentialUri,
+          sessionBoostUri,
+          isNewTopic
+        });
+      }
+      default:
+        this.toast({
+          icon: "\u2728",
+          segments: ["In LearnCard, this would run ", { b: type }, "."]
+        });
+        return Promise.resolve({});
+    }
+  }
+  nextUri(prefix) {
+    this.idSeq += 1;
+    return `${prefix}:${Date.now()}-${this.idSeq}`;
+  }
+  buildMockVc(name, id) {
+    return {
+      "@context": ["https://www.w3.org/2018/credentials/v1"],
+      id,
+      type: ["VerifiableCredential"],
+      issuer: this.identity.did,
+      credentialSubject: { id: this.identity.did, achievement: { name } },
+      _mock: true
+    };
+  }
+  addCredential(input) {
+    var _a, _b, _c;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const status = (_a = input.status) != null ? _a : "claimed";
+    const credentialUri = (_b = input.credentialUri) != null ? _b : this.nextUri("lc:mock:credential");
+    const record = {
+      credentialUri,
+      boostUri: input.boostUri,
+      templateAlias: input.templateAlias,
+      name: input.name,
+      recipient: input.recipient || this.identity.did,
+      status,
+      sentDate: now,
+      claimedDate: status === "claimed" ? now : void 0,
+      receivedDate: status === "claimed" ? now : void 0,
+      credential: (_c = input.credential) != null ? _c : this.buildMockVc(input.name, credentialUri)
+    };
+    this.credentials.push(record);
+    return record;
+  }
+  selfCredentials() {
+    return this.credentials.filter((c) => c.recipient === this.identity.did);
+  }
+  matchesTemplate(c, q) {
+    if (typeof q.templateAlias === "string") return c.templateAlias === q.templateAlias;
+    if (typeof q.boostUri === "string") return c.boostUri === q.boostUri;
+    return false;
+  }
+  toRecipientRecord(c) {
+    return {
+      recipientProfileId: c.recipient,
+      recipientDisplayName: c.recipient,
+      sentDate: c.sentDate,
+      claimedDate: c.claimedDate,
+      credentialUri: c.credentialUri,
+      status: c.status
+    };
+  }
+  counterStorageKey() {
+    return `${this.options.namespace}:counters`;
+  }
+  loadCounters() {
+    if (this.options.persist && typeof localStorage !== "undefined") {
+      try {
+        const raw = localStorage.getItem(this.counterStorageKey());
+        if (raw) return JSON.parse(raw);
+      } catch {
+      }
+    }
+    const fromMemory = {};
+    for (const [key, value] of this.memoryCounters) fromMemory[key] = value;
+    return fromMemory;
+  }
+  readCounter(key) {
+    return this.loadCounters()[key];
+  }
+  allCounterKeys() {
+    return Object.keys(this.loadCounters());
+  }
+  /**
+   * The load → patch → save cycle below runs synchronously within one task,
+   * so increments in the same tab can never interleave. Concurrent writes
+   * from *other tabs* sharing the namespace can still be lost — acceptable
+   * for a dev-only mock, and inherent to `localStorage` without web locks.
+   */
+  writeCounter(key, value) {
+    const entry = { value, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    if (this.options.persist && typeof localStorage !== "undefined") {
+      try {
+        const all = this.loadCounters();
+        all[key] = entry;
+        localStorage.setItem(this.counterStorageKey(), JSON.stringify(all));
+        return;
+      } catch {
+      }
+    }
+    this.memoryCounters.set(key, entry);
+  }
+  log(action, payload) {
+    if (!this.options.log) return;
+    console.log(`${MOCK_PREFIX} ${action}`, payload != null ? payload : "");
+  }
+  announce() {
+    if (!this.options.log) return;
+    console.log(
+      `${MOCK_PREFIX} Standalone mock mode is active. The SDK is simulating the LearnCard host locally. When embedded in a real host, these calls run against it unchanged.`
+    );
+  }
+  showClaimToast(credentialName) {
+    this.toast({
+      icon: "\u2705",
+      ttl: 5200,
+      segments: ["In LearnCard, the user would receive ", { b: credentialName }, " here."]
+    });
+  }
+  showConsentBanner(redirectIgnored = false) {
+    this.toast({
+      icon: "\u{1F513}",
+      tone: "positive",
+      segments: redirectIgnored ? ["Consent auto-granted. Redirect ignored in mock."] : ["The user would review and grant consent. Auto-granted in mock."]
+    });
+    if (redirectIgnored) {
+      this.note(
+        "requestConsent: 'redirect' is ignored in mock mode \u2014 the real host would navigate to the contract's redirectUrl with the VP in the URL."
+      );
+    }
+  }
+  note(message) {
+    if (!this.options.log) return;
+    console.log(`${MOCK_PREFIX} ${message}`);
+  }
+  /**
+   * Show a branded toast describing what the real host would do. Identical
+   * messages coalesce into one toast with a ×N counter so repeated or polled
+   * calls never spam the screen.
+   */
+  toast(spec) {
+    var _a, _b;
+    if (!this.options.ui || !hasDocument()) return;
+    const tone = (_a = spec.tone) != null ? _a : "default";
+    const ttl = (_b = spec.ttl) != null ? _b : 4200;
+    const text = spec.segments.map((s) => typeof s === "string" ? s : s.b).join("");
+    const key = `${tone}|${spec.icon}|${text}`;
+    const existing = this.activeToasts.get(key);
+    if (existing) {
+      existing.count += 1;
+      existing.countEl.textContent = `\xD7${existing.count}`;
+      existing.countEl.style.display = "";
+      clearTimeout(existing.timeoutId);
+      existing.timeoutId = setTimeout(() => this.dismissToast(key), ttl);
+      return;
+    }
+    const stack = this.ensureStack();
+    if (!stack) return;
+    this.ensureStyles();
+    const toast = document.createElement("div");
+    toast.className = `lc-mock-toast lc-mock-toast--${tone}`;
+    const badge = document.createElement("div");
+    badge.className = "lc-mock-badge";
+    const name = document.createElement("span");
+    name.className = "lc-mock-badge-name";
+    name.textContent = `${spec.icon} LearnCard`;
+    const pill = document.createElement("span");
+    pill.className = "lc-mock-pill";
+    pill.textContent = "MOCK";
+    badge.append(name, pill);
+    const body = document.createElement("div");
+    body.className = "lc-mock-body";
+    for (const seg of spec.segments) {
+      if (typeof seg === "string") {
+        body.append(seg);
+      } else {
+        const strong = document.createElement("strong");
+        strong.textContent = seg.b;
+        body.appendChild(strong);
+      }
+    }
+    const countEl = document.createElement("span");
+    countEl.className = "lc-mock-count";
+    countEl.style.display = "none";
+    body.appendChild(countEl);
+    toast.append(badge, body);
+    stack.appendChild(toast);
+    this.domNodes.add(toast);
+    const timeoutId = setTimeout(() => this.dismissToast(key), ttl);
+    this.activeToasts.set(key, { node: toast, timeoutId, count: 1, countEl });
+  }
+  dismissToast(key) {
+    const entry = this.activeToasts.get(key);
+    if (!entry) return;
+    this.activeToasts.delete(key);
+    clearTimeout(entry.timeoutId);
+    const { node } = entry;
+    node.classList.add("lc-mock-out");
+    const exitTimer = setTimeout(() => {
+      this.exitTimers.delete(exitTimer);
+      node.remove();
+      this.domNodes.delete(node);
+    }, 200);
+    this.exitTimers.add(exitTimer);
+  }
+  ensureStack() {
+    if (!document.body) return null;
+    if (this.stackEl && document.body.contains(this.stackEl)) return this.stackEl;
+    const stack = document.createElement("div");
+    stack.className = "lc-mock-stack";
+    document.body.appendChild(stack);
+    this.stackEl = stack;
+    return stack;
+  }
+  ensureStyles() {
+    if (!this.options.ui || !hasDocument() || this.styleEl || !document.head) return;
+    const style = document.createElement("style");
+    style.textContent = `
+@keyframes lc-mock-in { from { opacity: 0; transform: translateY(10px) scale(0.98); } to { opacity: 1; transform: none; } }
+@keyframes lc-mock-out { to { opacity: 0; transform: translateY(6px); } }
+.lc-mock-stack {
+  position: fixed; bottom: 20px; right: 20px; z-index: 2147483647;
+  display: flex; flex-direction: column; gap: 10px; align-items: flex-end;
+  pointer-events: none; max-width: min(360px, calc(100vw - 40px));
+}
+.lc-mock-toast {
+  pointer-events: auto; width: 100%; box-sizing: border-box; padding: 11px 14px; border-radius: 14px;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; font-size: 13.5px;
+  line-height: 1.45; box-shadow: 0 10px 30px rgba(24,34,78,0.22); animation: lc-mock-in 180ms cubic-bezier(0.2,0.8,0.2,1);
+}
+.lc-mock-toast.lc-mock-out { animation: lc-mock-out 180ms ease-in forwards; }
+.lc-mock-toast--default { background: #18224E; color: #fff; }
+.lc-mock-toast--positive { background: #ECFDF5; color: #065F46; border: 1px solid #A7F3D0; }
+.lc-mock-badge {
+  display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 5px;
+  font-size: 11px; letter-spacing: 0.02em; text-transform: uppercase; opacity: 0.72;
+}
+.lc-mock-badge-name { font-weight: 600; }
+.lc-mock-pill { font-size: 10px; font-weight: 700; padding: 2px 6px; border-radius: 999px; background: rgba(255,255,255,0.16); }
+.lc-mock-toast--positive .lc-mock-pill { background: rgba(6,95,70,0.12); }
+.lc-mock-body strong { font-weight: 700; }
+.lc-mock-count { margin-left: 6px; font-weight: 700; opacity: 0.75; }
+`.trim();
+    document.head.appendChild(style);
+    this.styleEl = style;
+  }
+}
+
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 const SYNC_STATUS_POLL_MAX_DURATION_MS = 10 * 60 * 1e3;
+const DEFAULT_HOST_PROBE_TIMEOUT_MS = 1500;
+const isLocalDevHost = (hostname) => hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1" || hostname.endsWith(".localhost") || hostname.endsWith(".local");
+function isEmbedded() {
+  if (typeof window === "undefined") return false;
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
 const _PartnerConnect = class _PartnerConnect {
   constructor(options) {
     __publicField(this, "hostOrigins", ["https://learncard.app"]);
@@ -47,7 +716,15 @@ const _PartnerConnect = class _PartnerConnect {
     __publicField(this, "isInitialized", false);
     __publicField(this, "syncCompleteCallbacks", /* @__PURE__ */ new Set());
     __publicField(this, "syncStatusPollId", null);
-    var _a, _b;
+    __publicField(this, "mockHost", null);
+    __publicField(this, "embedded", false);
+    __publicField(this, "warnedNoHost", false);
+    __publicField(this, "hostProbeTimeout", DEFAULT_HOST_PROBE_TIMEOUT_MS);
+    /** Whether a real LearnCard host is believed to be listening. */
+    __publicField(this, "hostReachable", false);
+    /** Pending probe decision; requests queue behind it when set. */
+    __publicField(this, "activation", null);
+    var _a, _b, _c;
     const hostOrigin = (_a = options == null ? void 0 : options.hostOrigin) != null ? _a : _PartnerConnect.DEFAULT_HOST_ORIGIN;
     const configured = Array.isArray(hostOrigin) ? hostOrigin : [hostOrigin];
     const disableDefaults = (options == null ? void 0 : options.disableDefaultTenants) === true;
@@ -56,9 +733,108 @@ const _PartnerConnect = class _PartnerConnect {
     this.protocol = (options == null ? void 0 : options.protocol) || "LEARNCARD_V1";
     this.requestTimeout = (options == null ? void 0 : options.requestTimeout) || 3e4;
     this.allowNativeAppOrigins = (_b = options == null ? void 0 : options.allowNativeAppOrigins) != null ? _b : true;
+    this.hostProbeTimeout = (_c = options == null ? void 0 : options.hostProbeTimeout) != null ? _c : DEFAULT_HOST_PROBE_TIMEOUT_MS;
     this.pendingRequests = /* @__PURE__ */ new Map();
     this.configureActiveOrigin();
     this.setupMessageListener();
+    this.embedded = isEmbedded();
+    this.configureMockActivation(options);
+  }
+  /**
+   * Decide whether this instance talks to a real host, simulates one, or
+   * fails fast — the resolution of the `mock` option against the runtime
+   * embed context. See the `mock` option docs for the contract.
+   */
+  configureMockActivation(options) {
+    var _a;
+    const mockSetting = (_a = options == null ? void 0 : options.mock) != null ? _a : "auto";
+    if (mockSetting === true) {
+      this.mockHost = new MockHost(options == null ? void 0 : options.mockOptions);
+      return;
+    }
+    const canAutoMock = mockSetting === "standalone" || mockSetting === "auto" && this.isLocalDevContext();
+    if (!this.embedded) {
+      if (canAutoMock) {
+        this.mockHost = new MockHost(options == null ? void 0 : options.mockOptions);
+      }
+      return;
+    }
+    switch (this.classifyParent()) {
+      case "learncard":
+        this.hostReachable = true;
+        return;
+      case "foreign":
+        if (canAutoMock) {
+          this.mockHost = new MockHost(options == null ? void 0 : options.mockOptions);
+        }
+        return;
+      case "ambiguous":
+        if (canAutoMock) {
+          this.hostReachable = true;
+          this.activation = this.probeHost(options);
+        } else {
+          this.hostReachable = true;
+        }
+        return;
+    }
+  }
+  isLocalDevContext() {
+    if (typeof window === "undefined") return false;
+    return isLocalDevHost(window.location.hostname);
+  }
+  classifyParent() {
+    const ancestorOrigin = this.readAncestorOrigin();
+    if (!ancestorOrigin) return "ambiguous";
+    if (this.matchesConfiguredOrigin(ancestorOrigin)) return "learncard";
+    if (this.allowNativeAppOrigins && this.isOriginNativeApp(ancestorOrigin)) {
+      return "ambiguous";
+    }
+    return "foreign";
+  }
+  matchesConfiguredOrigin(origin) {
+    return this.hostOrigins.some((entry) => _PartnerConnect.matchesOriginPattern(origin, entry));
+  }
+  /**
+   * One-time host presence probe for the ambiguous-parent case. Sends a
+   * side-effect-free `GET_SYNC_STATUS`; an answer proves a live LearnCard
+   * host (responses are origin-checked), a timeout means nobody is
+   * listening and the mock takes over. Requests issued while the probe is
+   * in flight queue behind the decision instead of racing it.
+   */
+  probeHost(options) {
+    return this.postToHost("GET_SYNC_STATUS", void 0, this.hostProbeTimeout).then(() => {
+      this.activation = null;
+    }).catch(() => {
+      this.activation = null;
+      if (this.isInitialized) {
+        this.hostReachable = false;
+        this.mockHost = new MockHost(options == null ? void 0 : options.mockOptions);
+        console.warn(
+          `[LearnCard SDK] Embedded in a frame, but no LearnCard host answered within ${this.hostProbeTimeout}ms \u2014 activating standalone mock mode. If a real local host was just slow to boot, raise \`hostProbeTimeout\`.`
+        );
+      }
+    });
+  }
+  /**
+   * Whether this SDK instance is running inside an embedded iframe.
+   * Instance-level convenience wrapper around the standalone {@link isEmbedded}.
+   */
+  isEmbedded() {
+    return isEmbedded();
+  }
+  /**
+   * Whether the current page is running inside an embedded iframe.
+   * Static convenience wrapper around the standalone {@link isEmbedded}.
+   */
+  static isEmbedded() {
+    return isEmbedded();
+  }
+  /**
+   * Whether this instance is currently simulating the LearnCard host locally
+   * instead of talking to a real host over `postMessage`.
+   */
+  isMocked() {
+    return this.mockHost !== null;
   }
   /**
    * Read `window.location.ancestorOrigins[0]` without throwing if the
@@ -226,6 +1002,9 @@ const _PartnerConnect = class _PartnerConnect {
       if (data.protocol !== this.protocol || !data.requestId) {
         return;
       }
+      if (data.type !== "SUCCESS" && data.type !== "ERROR") {
+        return;
+      }
       const pending = this.pendingRequests.get(data.requestId);
       if (!pending) {
         return;
@@ -255,14 +1034,44 @@ const _PartnerConnect = class _PartnerConnect {
     return `${action}-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
   }
   /**
-   * Send a message to the parent window and return a Promise
+   * Send a message to the parent window and return a Promise. While a host
+   * presence probe is pending, requests queue behind its decision so they
+   * are answered by whichever side (real host or mock) actually exists.
    */
   sendMessage(action, payload) {
+    if (this.activation) {
+      return this.activation.then(() => this.dispatchMessage(action, payload));
+    }
+    return this.dispatchMessage(action, payload);
+  }
+  dispatchMessage(action, payload) {
     if (!this.isInitialized) {
       return Promise.reject(
         new PartnerConnectError("SDK_NOT_INITIALIZED", "SDK is not initialized")
       );
     }
+    if (this.mockHost) {
+      return this.mockHost.handle(action, payload).then((data) => data).catch((error) => {
+        throw PartnerConnectError.from(error);
+      });
+    }
+    if (!this.hostReachable) {
+      if (!this.warnedNoHost) {
+        this.warnedNoHost = true;
+        console.error(
+          "[LearnCard SDK] No LearnCard host is present (the app is standalone or inside a non-LearnCard frame), so SDK calls cannot complete. Embed your app in LearnCard, or pass `mock: true` to simulate the host during standalone development. Use isEmbedded() to branch your UI before calling."
+        );
+      }
+      return Promise.reject(
+        new PartnerConnectError(
+          "LC_NOT_EMBEDDED",
+          `Cannot ${action}: the app is not embedded in a LearnCard host.`
+        )
+      );
+    }
+    return this.postToHost(action, payload, this.requestTimeout);
+  }
+  postToHost(action, payload, timeout) {
     return new Promise((resolve, reject) => {
       const requestId = this.generateRequestId(action);
       const timeoutId = setTimeout(() => {
@@ -271,11 +1080,11 @@ const _PartnerConnect = class _PartnerConnect {
           reject(
             new PartnerConnectError(
               "LC_TIMEOUT",
-              `Request ${action} timed out after ${this.requestTimeout}ms`
+              `Request ${action} timed out after ${timeout}ms`
             )
           );
         }
-      }, this.requestTimeout);
+      }, timeout);
       this.pendingRequests.set(requestId, {
         resolve,
         reject,
@@ -756,6 +1565,10 @@ const _PartnerConnect = class _PartnerConnect {
       this.syncStatusPollId = null;
     }
     this.syncCompleteCallbacks.clear();
+    if (this.mockHost) {
+      this.mockHost.destroy();
+      this.mockHost = null;
+    }
     this.isInitialized = false;
   }
 };
@@ -810,5 +1623,5 @@ function createPartnerConnect(options) {
   return new PartnerConnect(options);
 }
 
-export { PartnerConnect, PartnerConnectError, createPartnerConnect, createPartnerConnect as default };
+export { PartnerConnect, PartnerConnectError, createPartnerConnect, createPartnerConnect as default, isEmbedded };
 //# sourceMappingURL=partner-connect.mjs.map