@usergist/sdk-core 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -27,6 +27,16 @@ function err(code, message, details) {
   };
 }
 
+// src/types/workspace.ts
+function defaultOnboardingMessage(appName) {
+  return {
+    title: `Welcome to ${appName.trim() || "our app"}`,
+    body: "Glad you\u2019re here. Take a look around and make yourself at home.",
+    buttonLabel: "Got it",
+    format: "modal"
+  };
+}
+
 // src/types/survey.ts
 var SURVEY_END_SENTINEL = "__end__";
 
@@ -270,8 +280,8 @@ var THEME_PRESETS = [
     swatches: ["#8B5CF6", "#EC4899", "#E9D5FF"]
   }
 ];
-function getThemePresetById(id) {
-  return THEME_PRESETS.find((preset) => preset.id === id);
+function getThemePresetById(id2) {
+  return THEME_PRESETS.find((preset) => preset.id === id2);
 }
 function defaultThemePreset() {
   return THEME_PRESETS[0];
@@ -322,7 +332,7 @@ var USER_IDENTIFIED_EVENT_NAME = "$user_identified";
 function camelize(value) {
   return value.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
 }
-var ids = (...keys) => Object.fromEntries(keys.map((key) => [key, [key, camelize(key)]]));
+var ids = (...keys) => Object.fromEntries(keys.map((key2) => [key2, [key2, camelize(key2)]]));
 var pushEvents = [
   ["$push_sent", "UserGist Push Sent"],
   ["$push_delivered", "UserGist Push Delivered"],
@@ -379,8 +389,8 @@ var CORE_INTEGRATION_EVENTS = [
   { key: "$inapp_dismissed", name: "UserGist In-App Message Dismissed", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "dismiss_reason") } },
   { key: "$inapp_auto_dismissed", name: "UserGist In-App Message Auto-Dismissed", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "dismiss_reason") } },
   { key: "$inapp_cta_clicked", name: "UserGist In-App Message CTA Clicked", category: "inapp", subjectRole: "actor", properties: { ...ids("message_id", "cta_id", "cta_index"), action: ["action", "cta_action"] } },
-  ...pushEvents.map(([key, name]) => ({
-    key,
+  ...pushEvents.map(([key2, name]) => ({
+    key: key2,
     name,
     category: "push",
     subjectRole: "actor",
@@ -389,11 +399,11 @@ var CORE_INTEGRATION_EVENTS = [
       action_id: ["action_id", "actionId", "action_button", "actionButton"]
     }
   })),
-  ...requestEvents.map(([key, name, subjectRole]) => ({ key, name, category: "requests", subjectRole, properties: { ...ids("request_id", "comment_id", "source", "old_status", "new_status", "deleted_by"), usergist_actor_type: ["usergist_actor_type", "actor_type"] } }))
+  ...requestEvents.map(([key2, name, subjectRole]) => ({ key: key2, name, category: "requests", subjectRole, properties: { ...ids("request_id", "comment_id", "source", "old_status", "new_status", "deleted_by"), usergist_actor_type: ["usergist_actor_type", "actor_type"] } }))
 ];
 var CORE_EVENT_BY_KEY = new Map(CORE_INTEGRATION_EVENTS.map((event) => [event.key, event]));
-function getCoreIntegrationEvent(key) {
-  return CORE_EVENT_BY_KEY.get(key) ?? null;
+function getCoreIntegrationEvent(key2) {
+  return CORE_EVENT_BY_KEY.get(key2) ?? null;
 }
 function sanitizeCoreIntegrationProperties(definition, input) {
   if (!input) return {};
@@ -500,15 +510,15 @@ function evaluateGroup(group, user, now) {
   }
   return group.predicates.some((p) => evaluateNode(p, user, now));
 }
-function evaluateNode(node, user, now) {
-  if ("combinator" in node) return evaluateGroup(node, user, now);
-  switch (node.kind) {
+function evaluateNode(node2, user, now) {
+  if ("combinator" in node2) return evaluateGroup(node2, user, now);
+  switch (node2.kind) {
     case "user_property":
-      return evaluateUserProperty(node, user);
+      return evaluateUserProperty(node2, user);
     case "event_count":
-      return evaluateEventCount(node, user);
+      return evaluateEventCount(node2, user);
     case "event_occurred":
-      return evaluateEventOccurred(node, user, now);
+      return evaluateEventOccurred(node2, user, now);
   }
 }
 function evaluateUserProperty(p, user) {
@@ -662,15 +672,15 @@ function reachableQuestions(flow, startId) {
   const visited = /* @__PURE__ */ new Set();
   const stack = [start];
   while (stack.length > 0) {
-    const id = stack.pop();
-    if (id === void 0) continue;
-    if (visited.has(id)) continue;
-    visited.add(id);
-    const outgoing = flow.branches.filter((b) => b.fromQuestionId === id);
+    const id2 = stack.pop();
+    if (id2 === void 0) continue;
+    if (visited.has(id2)) continue;
+    visited.add(id2);
+    const outgoing = flow.branches.filter((b) => b.fromQuestionId === id2);
     for (const b of outgoing) {
       if (b.toQuestionId !== SURVEY_END_SENTINEL) stack.push(b.toQuestionId);
     }
-    const idx = flow.questions.findIndex((q) => q.id === id);
+    const idx = flow.questions.findIndex((q) => q.id === id2);
     if (idx >= 0 && idx < flow.questions.length - 1) {
       const next = flow.questions[idx + 1];
       if (next) stack.push(next.id);
@@ -709,7 +719,7 @@ function tzOffsetMinutes(at, tz) {
 function startCandidate(schedule, now, tz) {
   const localNow = wallClock(now, tz);
   const target = new Date(localNow);
-  target.setHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
+  target.setUTCHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
   return localToUtc(target, tz);
 }
 function walkForward(candidate, schedule, now, tz) {
@@ -727,30 +737,30 @@ function walkForward(candidate, schedule, now, tz) {
 function matchesFrequency(local, schedule) {
   if (schedule.frequency === "daily") return true;
   if (schedule.frequency === "weekly") {
-    return schedule.weekday === void 0 || local.getDay() === schedule.weekday;
+    return schedule.weekday === void 0 || local.getUTCDay() === schedule.weekday;
   }
-  return schedule.dayOfMonth === void 0 || local.getDate() === schedule.dayOfMonth;
+  return schedule.dayOfMonth === void 0 || local.getUTCDate() === schedule.dayOfMonth;
 }
 function step(cursor, cursorLocal, schedule, tz) {
   if (schedule.frequency === "daily" || schedule.frequency === "weekly") {
     return addDays(cursor, 1);
   }
   const next = new Date(cursorLocal);
-  next.setMonth(next.getMonth() + 1);
+  next.setUTCMonth(next.getUTCMonth() + 1);
   if (schedule.dayOfMonth !== void 0) {
-    const lastDay = lastDayOfMonth(next.getFullYear(), next.getMonth());
-    next.setDate(Math.min(schedule.dayOfMonth, lastDay));
+    const lastDay = lastDayOfMonth(next.getUTCFullYear(), next.getUTCMonth());
+    next.setUTCDate(Math.min(schedule.dayOfMonth, lastDay));
   }
-  next.setHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
+  next.setUTCHours(schedule.hourLocal, schedule.minuteLocal, 0, 0);
   return localToUtc(next, tz);
 }
 function addDays(d, days) {
   const next = new Date(d.getTime());
-  next.setDate(next.getDate() + days);
+  next.setUTCDate(next.getUTCDate() + days);
   return next;
 }
 function lastDayOfMonth(year, monthIndex) {
-  return new Date(year, monthIndex + 1, 0).getDate();
+  return new Date(Date.UTC(year, monthIndex + 1, 0)).getUTCDate();
 }
 function wallClock(d, tz) {
   const offsetMin = tzOffsetMinutes(d, tz);
@@ -778,11 +788,151 @@ function getFormatter(tz) {
   return fmt;
 }
 
+// src/timezone.ts
+var PARTS_FORMATTER_CACHE = /* @__PURE__ */ new Map();
+function isValidIanaTimeZone(value) {
+  if (!value.trim()) return false;
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value }).format();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function zonedDateTimeParts(instant, timeZone) {
+  if (!isValidIanaTimeZone(timeZone)) {
+    throw new RangeError(`Invalid IANA timezone: ${timeZone}`);
+  }
+  if (!Number.isFinite(instant.getTime())) {
+    throw new RangeError("Invalid date");
+  }
+  const formatter = getPartsFormatter(timeZone);
+  const parts = formatter.formatToParts(instant).reduce(
+    (result, part) => {
+      if (part.type !== "literal") result[part.type] = part.value;
+      return result;
+    },
+    {}
+  );
+  const year = Number(parts.year);
+  const month = Number(parts.month);
+  const day = Number(parts.day);
+  const hour = Number(parts.hour);
+  const minute = Number(parts.minute);
+  return {
+    date: `${year}-${pad2(month)}-${pad2(day)}`,
+    time: `${pad2(hour)}:${pad2(minute)}`,
+    weekday: new Date(Date.UTC(year, month - 1, day)).getUTCDay(),
+    dayOfMonth: day
+  };
+}
+function zonedDateTimeToUtc(date, time, timeZone) {
+  if (!isValidIanaTimeZone(timeZone)) {
+    throw new RangeError(`Invalid IANA timezone: ${timeZone}`);
+  }
+  const dateMatch = /^(\d{4})-(\d{2})-(\d{2})$/.exec(date);
+  const timeMatch = /^(\d{2}):(\d{2})$/.exec(time);
+  if (!dateMatch || !timeMatch) throw new RangeError("Invalid local date or time");
+  const year = Number(dateMatch[1]);
+  const month = Number(dateMatch[2]);
+  const day = Number(dateMatch[3]);
+  const hour = Number(timeMatch[1]);
+  const minute = Number(timeMatch[2]);
+  const naive = Date.UTC(year, month - 1, day, hour, minute, 0, 0);
+  const calendarCheck = new Date(naive);
+  if (calendarCheck.getUTCFullYear() !== year || calendarCheck.getUTCMonth() !== month - 1 || calendarCheck.getUTCDate() !== day || hour > 23 || minute > 59) {
+    throw new RangeError("Invalid local date or time");
+  }
+  const offsets = new Set(
+    [-36, -12, 0, 12, 36].map(
+      (hours) => timeZoneOffsetMinutes(new Date(naive + hours * 36e5), timeZone)
+    )
+  );
+  const candidates = [...offsets].map((offset) => new Date(naive - offset * 6e4)).filter((candidate2) => {
+    const roundTrip = zonedDateTimeParts(candidate2, timeZone);
+    return roundTrip.date === date && roundTrip.time === time;
+  }).sort((left, right) => left.getTime() - right.getTime());
+  const candidate = candidates[0];
+  if (!candidate) {
+    throw new RangeError("This local time does not exist in the selected timezone");
+  }
+  return candidate;
+}
+function zonedDateEndToUtc(date, timeZone) {
+  const lastMinute = zonedDateTimeToUtc(date, "23:59", timeZone);
+  return new Date(lastMinute.getTime() + 59999);
+}
+function timeZoneOffsetMinutes(instant, timeZone) {
+  const parts = getPartsFormatter(timeZone).formatToParts(instant).reduce((result, part) => {
+    if (part.type !== "literal") result[part.type] = part.value;
+    return result;
+  }, {});
+  const asUtc = Date.UTC(
+    Number(parts.year),
+    Number(parts.month) - 1,
+    Number(parts.day),
+    Number(parts.hour),
+    Number(parts.minute),
+    Number(parts.second)
+  );
+  return Math.round((asUtc - instant.getTime()) / 6e4);
+}
+function getPartsFormatter(timeZone) {
+  const cached = PARTS_FORMATTER_CACHE.get(timeZone);
+  if (cached) return cached;
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hourCycle: "h23",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  PARTS_FORMATTER_CACHE.set(timeZone, formatter);
+  return formatter;
+}
+function pad2(value) {
+  return String(value).padStart(2, "0");
+}
+
 // src/contract/endpoints.ts
 var endpoints = {
+  "GET /v1/apps/:appId/search": {},
+  "POST /v1/apps/:appId/delivery-diagnostics": {},
+  "GET /v1/workspaces/:wid/portal": {},
+  "PUT /v1/workspaces/:wid/portal": {},
+  "GET /v1/workspaces/:wid/portal/slug-available": {},
+  "PUT /v1/workspaces/:wid/portal/apps/:appId": {},
+  "POST /v1/workspaces/:wid/portal/publish": {},
+  "POST /v1/workspaces/:wid/portal/unpublish": {},
+  "GET /v1/workspaces/:wid/portal/preview/:appId": {},
+  "PATCH /v1/apps/:appId/requests/portal-visibility": {},
+  "GET /v1/portal/:portalSlug": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/requests": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/requests/counts": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/requests/:requestId": {},
+  "POST /v1/portal/:portalSlug/auth/start": {},
+  "POST /v1/portal/:portalSlug/auth/verify": {},
+  "GET /v1/portal/:portalSlug/session": {},
+  "DELETE /v1/portal/:portalSlug/session": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/votes": {},
+  "POST /v1/portal/:portalSlug/apps/:appSlug/requests": {},
+  "PUT /v1/portal/:portalSlug/apps/:appSlug/requests/:requestId/vote": {},
+  "POST /v1/sdk/clients": {},
+  "POST /v1/sdk/clients/:id/end": {},
+  "GET /v1/sdk/clients/:id/instructions": {},
+  "POST /v1/sdk/presentations/authorize": {},
+  "POST /v1/sdk/presentations/:id/receipt": {},
   "GET /v1/me": {},
+  "PATCH /v1/me": {},
+  "PATCH /v1/me/onboarding": {},
+  "GET /v1/features": {},
+  "GET /v1/signup-status": {},
   "GET /v1/workspaces": {},
   "POST /v1/workspaces": {},
+  "PATCH /v1/workspaces/:wid": {},
   "GET /v1/workspaces/:wid/members": {},
   "GET /v1/workspaces/:wid/invites": {},
   "POST /v1/workspaces/:wid/invites": {},
@@ -791,11 +941,18 @@ var endpoints = {
   "GET /v1/workspaces/:wid/apps": {},
   "POST /v1/workspaces/:wid/apps": {},
   "GET /v1/workspaces/:wid/api-tokens": {},
+  "GET /v1/workspaces/:wid/ai-connections": {},
+  "PATCH /v1/workspaces/:wid/ai-connections/:id": {},
+  "POST /v1/workspaces/:wid/ai-connections/:id/revoke": {},
+  "GET /v1/workspaces/:wid/ai-connections/:id/activity": {},
+  "POST /v1/mcp/consent": {},
   "POST /v1/workspaces/:wid/api-tokens": {},
   "DELETE /v1/workspaces/:wid/api-tokens/:tokenId": {},
   "GET /v1/apps/:appId": {},
   "PATCH /v1/apps/:appId": {},
   "DELETE /v1/apps/:appId": {},
+  "GET /v1/apps/:appId/onboarding": {},
+  "PATCH /v1/apps/:appId/onboarding": {},
   "POST /v1/apps/:appId/sdk/subject-tokens": {},
   // ---------- outbound analytics integrations ----------
   "GET /v1/apps/:appId/integrations": {},
@@ -852,6 +1009,10 @@ var endpoints = {
   "POST /v1/sdk/ingest": {},
   "GET /v1/sdk/armed-triggers": {},
   "POST /v1/sdk/consent": {},
+  "PATCH /v1/apps/:appId/users/properties": {},
+  "POST /v1/sdk/user-properties": {},
+  "GET /v1/apps/:appId/personalization/fields": {},
+  "POST /v1/apps/:appId/personalization/preview": {},
   "POST /v1/sdk/identify": {},
   "POST /v1/sdk/responses": {},
   // GDPR
@@ -956,6 +1117,9 @@ var endpoints = {
   "GET /v1/apps/:appId/request-settings": {},
   "PUT /v1/apps/:appId/request-settings": {},
   "GET /v1/apps/:appId/request-settings/slug-available": {},
+  /** Multipart `file` field; the processed logo URL is saved into branding.logoUrl. */
+  "POST /v1/apps/:appId/request-settings/logo": {},
+  "DELETE /v1/apps/:appId/request-settings/logo": {},
   "POST /v1/apps/:appId/requests/seed-segments": {},
   // ---------- feature requests — SDK (write-key) ----------
   "GET /v1/sdk/requests": {},
@@ -983,8 +1147,15 @@ var endpoints = {
   "GET /v1/workspaces/:wid/billing/periods": {},
   // ---------- super admin ----------
   "GET /v1/admin/session": {},
+  "GET /v1/admin/feature-flags": {},
+  "PATCH /v1/admin/feature-flags/:key": {},
   "GET /v1/admin/customers": {},
   "GET /v1/admin/customers/:workspaceId": {},
+  "POST /v1/admin/customers/:workspaceId/permanent-deletion": {},
+  "GET /v1/admin/dashboard-users": {},
+  "POST /v1/admin/dashboard-users/:userId/permanent-deletion": {},
+  "GET /v1/admin/deletion-jobs/:jobId": {},
+  "POST /v1/admin/deletion-jobs/:jobId/retry": {},
   "POST /v1/admin/customers/:workspaceId/billing-events/:eventId/replay": {},
   "POST /v1/admin/customers/:workspaceId/grants": {},
   "POST /v1/admin/customers/:workspaceId/grants/:grantId/extend": {},
@@ -997,7 +1168,43 @@ var endpoints = {
   // ---------- feature requests — public web roadmap (no auth) ----------
   "GET /v1/public/roadmap/:slug": {},
   "GET /v1/public/roadmap/:slug/r/:requestId": {},
-  "GET /v1/public/roadmap/:slug/branding": {}
+  "GET /v1/public/roadmap/:slug/branding": {},
+  "GET /v1/apps/:appId/help/articles": {},
+  "POST /v1/apps/:appId/help/articles": {},
+  "GET /v1/apps/:appId/help/articles/:documentId": {},
+  "PUT /v1/apps/:appId/help/articles/:documentId": {},
+  "POST /v1/apps/:appId/help/articles/:documentId/lifecycle": {},
+  "GET /v1/apps/:appId/changelog": {},
+  "POST /v1/apps/:appId/changelog": {},
+  "GET /v1/apps/:appId/changelog/:documentId": {},
+  "PUT /v1/apps/:appId/changelog/:documentId": {},
+  "POST /v1/apps/:appId/changelog/:documentId/lifecycle": {},
+  "GET /v1/apps/:appId/help/collections": {},
+  "POST /v1/apps/:appId/help/collections": {},
+  "PATCH /v1/apps/:appId/help/collections/:collectionId": {},
+  "POST /v1/apps/:appId/help/collections/:collectionId/position": {},
+  "POST /v1/apps/:appId/help/articles/:documentId/position": {},
+  "GET /v1/apps/:appId/roadmap": {},
+  "POST /v1/apps/:appId/roadmap": {},
+  "GET /v1/apps/:appId/roadmap/:itemId": {},
+  "PUT /v1/apps/:appId/roadmap/:itemId": {},
+  "POST /v1/apps/:appId/roadmap/:itemId/status": {},
+  "POST /v1/apps/:appId/roadmap/:itemId/lifecycle": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/help/collections": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/help/collections/:collectionId": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/help/articles": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/help/articles/:documentId": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/changelog": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/changelog/:documentId": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/roadmap": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/roadmap/:itemId": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/requests/:requestId/changelog": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/roadmap/:itemId/changelog": {},
+  "GET /v1/apps/:appId/portal-content/link-targets": {},
+  // Binary routes use multipart/stream transports, not the JSON client helper.
+  "POST /v1/apps/:appId/portal-content/assets/:kind/:documentId": {},
+  "GET /v1/apps/:appId/portal-content/assets/:assetId": {},
+  "GET /v1/portal/:portalSlug/apps/:appSlug/assets/:assetId": {}
 };
 
 // src/schemas/index.ts
@@ -1005,24 +1212,74 @@ var schemas_exports = {};
 __export(schemas_exports, {
   acceptWorkspaceInviteSchema: () => acceptWorkspaceInviteSchema,
   apiTokenScopeSchema: () => apiTokenScopeSchema,
+  contentActionSchema: () => contentActionSchema,
+  contentBodySchema: () => contentBodySchema,
+  contentKindSchema: () => contentKindSchema,
+  contentLinkQuerySchema: () => contentLinkQuerySchema,
+  contentLinkSchema: () => contentLinkSchema,
+  contentPageQuerySchema: () => contentPageQuerySchema,
+  contentQuerySchema: () => contentQuerySchema,
+  contentStateSchema: () => contentStateSchema,
   createApiTokenSchema: () => createApiTokenSchema,
   createAppSchema: () => createAppSchema,
+  createCollectionSchema: () => createCollectionSchema,
+  createDocumentSchema: () => createDocumentSchema,
+  createRoadmapSchema: () => createRoadmapSchema,
   createWorkspaceSchema: () => createWorkspaceSchema,
   createWriteKeySchema: () => createWriteKeySchema,
+  deferCurrentUserOnboardingSchema: () => deferCurrentUserOnboardingSchema,
+  deliveryPlatformsSchema: () => deliveryPlatformsSchema,
+  documentDraftSchema: () => documentDraftSchema,
   emailSchema: () => emailSchema,
   inviteMemberSchema: () => inviteMemberSchema,
   isoDateTimeSchema: () => isoDateTimeSchema,
   loginMagicLinkConsumeRequestSchema: () => loginMagicLinkConsumeRequestSchema,
   loginMagicLinkRequestSchema: () => loginMagicLinkRequestSchema,
   loginPasswordRequestSchema: () => loginPasswordRequestSchema,
+  mcpCapabilitySchema: () => mcpCapabilitySchema,
+  mcpConsentSchema: () => mcpConsentSchema,
+  mcpGrantSchema: () => mcpGrantSchema,
+  mcpPageSchema: () => mcpPageSchema,
+  mcpSearchSchema: () => mcpSearchSchema,
+  mcpUpdateConnectionSchema: () => mcpUpdateConnectionSchema,
+  moveRoadmapSchema: () => moveRoadmapSchema,
+  onboardingGoalSchema: () => onboardingGoalSchema,
+  onboardingPushChoiceSchema: () => onboardingPushChoiceSchema,
+  onboardingStatusSchema: () => onboardingStatusSchema,
+  onboardingStepSchema: () => onboardingStepSchema,
   passwordSchema: () => passwordSchema,
   platformSchema: () => platformSchema,
+  portalAssetUploadKeySchema: () => portalAssetUploadKeySchema,
+  portalAuthStartSchema: () => portalAuthStartSchema,
+  portalAuthVerifySchema: () => portalAuthVerifySchema,
+  portalEmailSchema: () => portalEmailSchema,
+  portalRequestQuerySchema: () => portalRequestQuerySchema,
+  portalSlugSchema: () => portalSlugSchema,
+  portalSubmissionSchema: () => portalSubmissionSchema,
+  portalVisibilitySchema: () => portalVisibilitySchema,
+  portalVoteSchema: () => portalVoteSchema,
+  reorderContentSchema: () => reorderContentSchema,
+  roadmapQuerySchema: () => roadmapQuerySchema,
+  roadmapStatusSchema: () => roadmapStatusSchema,
   rotateWriteKeySchema: () => rotateWriteKeySchema,
+  saveDocumentSchema: () => saveDocumentSchema,
+  saveRoadmapSchema: () => saveRoadmapSchema,
   signupRequestSchema: () => signupRequestSchema,
   slugSchema: () => slugSchema,
+  subjectRefSchema: () => subjectRefSchema,
   updateAppSchema: () => updateAppSchema,
+  updateCollectionSchema: () => updateCollectionSchema,
+  updateCurrentUserSchema: () => updateCurrentUserSchema,
+  updateOnboardingSchema: () => updateOnboardingSchema,
+  updatePortalAppSchema: () => updatePortalAppSchema,
+  updatePortalSchema: () => updatePortalSchema,
+  updateWorkspaceSchema: () => updateWorkspaceSchema,
   uuidSchema: () => uuidSchema,
+  webAppConfigSchema: () => webAppConfigSchema,
+  webOriginSchema: () => webOriginSchema,
+  webPresentationSchema: () => webPresentationSchema,
   workspaceRoleSchema: () => workspaceRoleSchema,
+  workspaceTimezoneSchema: () => workspaceTimezoneSchema,
   writeKeyEnvironmentSchema: () => writeKeyEnvironmentSchema
 });
 var slugSchema = zod.z.string().min(1).max(64).regex(/^[a-z0-9-]+$/, "Must be lowercase, digits, and dashes only");
@@ -1049,21 +1306,199 @@ var loginMagicLinkRequestSchema = zod.z.object({
 var loginMagicLinkConsumeRequestSchema = zod.z.object({
   token: zod.z.string().min(16).max(512)
 });
-var platformSchema = zod.z.enum(["ios", "android", "react-native", "flutter"]);
-var writeKeyEnvironmentSchema = zod.z.enum(["production", "staging", "development"]);
-var apiTokenScopeSchema = zod.z.enum(["sdk:subjects", "push.transactional"]);
+var updateCurrentUserSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(120).optional()
+}).strict().refine((value) => Object.keys(value).length > 0, {
+  message: "At least one field is required"
+});
+var deliveryPlatformsSchema = zod.z.array(zod.z.enum(["ios", "android", "web"])).min(1).max(3).transform((values) => [...new Set(values)]);
+var webPresentationSchema = zod.z.object({
+  layout: zod.z.enum(["modal", "card", "panel"]).optional(),
+  size: zod.z.enum(["compact", "standard", "wide"]).optional(),
+  position: zod.z.enum(["left", "right"]).optional(),
+  backdrop: zod.z.boolean().optional()
+}).strict();
+var webOriginSchema = zod.z.string().max(2048).refine((value) => {
+  try {
+    const url = new URL(value);
+    return url.origin === value && !url.username && !url.password && (url.protocol === "https:" || url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname));
+  } catch {
+    return false;
+  }
+}, "Use an exact HTTPS origin, or an HTTP localhost origin for development");
+var webAppConfigSchema = zod.z.object({
+  allowedOrigins: zod.z.array(webOriginSchema).max(30).transform((values) => [...new Set(values)])
+}).strict();
+
+// src/types/portal.ts
+var PORTAL_RESERVED_SLUGS = [
+  "www",
+  "app",
+  "api",
+  "admin",
+  "auth",
+  "portal",
+  "docs",
+  "status",
+  "mail",
+  "support",
+  "login",
+  "logout",
+  "signup",
+  "billing",
+  "dashboard",
+  "cdn",
+  "assets",
+  "static",
+  "smtp",
+  "ftp",
+  "help",
+  "account",
+  "accounts",
+  "developer"
+];
+var PORTAL_SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-]{1,46})[a-z0-9]$/;
+function validPortalSlug(slug) {
+  return PORTAL_SLUG_PATTERN.test(slug) && !PORTAL_RESERVED_SLUGS.includes(slug);
+}
+function suggestPortalSlug(name) {
+  const value = name.toLowerCase().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 48).replace(/-$/, "");
+  return validPortalSlug(value) ? value : value.length >= 3 ? `${value.slice(0, 40)}-team` : "";
+}
+function buildPortalUrl(slug, baseDomain = "usergist.com", appSlug) {
+  if (!validPortalSlug(slug) || !/^[a-z0-9.-]+$/i.test(baseDomain)) throw new Error("Invalid portal address");
+  const base = `https://${slug}.${baseDomain}`;
+  return appSlug ? `${base}/${encodeURIComponent(appSlug)}/requests` : base;
+}
+
+// src/schemas/portal.ts
+var portalSlugSchema = zod.z.string().refine(
+  validPortalSlug,
+  "Use 3\u201348 lowercase letters, numbers, or interior hyphens. This name must not be reserved."
+);
+var updatePortalSchema = zod.z.object({
+  displayName: zod.z.string().trim().min(1).max(100).optional(),
+  slug: portalSlugSchema.optional(),
+  setupDismissed: zod.z.boolean().optional()
+}).strict();
+var updatePortalAppSchema = zod.z.object({ slug: portalSlugSchema, enabled: zod.z.boolean() }).strict();
+var portalVisibilitySchema = zod.z.object({ ids: zod.z.array(zod.z.string().uuid()).min(1).max(100), visible: zod.z.boolean() }).strict();
+var portalEmailSchema = zod.z.string().trim().email().max(254).transform((value) => value.toLowerCase());
+var portalAuthStartSchema = zod.z.object({ email: portalEmailSchema }).strict();
+var portalAuthVerifySchema = zod.z.object({ email: portalEmailSchema, code: zod.z.string().regex(/^\d{6}$/) }).strict();
+var portalSubmissionSchema = zod.z.object({
+  title: zod.z.string().trim().min(1).max(120),
+  description: zod.z.string().trim().min(1).max(1500),
+  idempotencyKey: zod.z.string().uuid(),
+  feedbackConsent: zod.z.literal(true)
+}).strict();
+var portalVoteSchema = zod.z.object({ vote: zod.z.boolean(), feedbackConsent: zod.z.literal(true) }).strict();
+var portalRequestQuerySchema = zod.z.object({
+  q: zod.z.string().trim().max(200).optional(),
+  status: zod.z.enum(["under_review", "planned", "in_progress", "shipped", "declined"]).optional(),
+  sort: zod.z.enum(["top", "newest", "status_changed"]).default("top"),
+  page: zod.z.coerce.number().int().min(1).max(1e5).default(1),
+  limit: zod.z.coerce.number().int().min(1).max(100).default(20)
+}).strict();
+
+// src/schemas/apps.ts
+var workspaceTimezoneSchema = zod.z.string().trim().min(1).max(64).refine(isValidIanaTimeZone, "Enter a valid IANA timezone");
+var platformSchema = zod.z.enum([
+  "ios",
+  "android",
+  "react-native",
+  "expo",
+  "flutter",
+  "web"
+]);
+var writeKeyEnvironmentSchema = zod.z.enum([
+  "production",
+  "staging",
+  "development"
+]);
+var onboardingGoalSchema = zod.z.enum([
+  "feedback",
+  "survey",
+  "inapp",
+  "push",
+  "requests"
+]);
+var onboardingStatusSchema = zod.z.enum([
+  "in_progress",
+  "deferred",
+  "completed"
+]);
+var onboardingStepSchema = zod.z.enum([
+  "connect",
+  "verify",
+  "experience",
+  "push",
+  "launch"
+]);
+var onboardingPushChoiceSchema = zod.z.enum([
+  "pending",
+  "configured",
+  "skipped"
+]);
+var apiTokenScopeSchema = zod.z.enum([
+  "sdk:subjects",
+  "push.transactional",
+  "users.properties.write"
+]);
 var createAppSchema = zod.z.object({
   name: zod.z.string().min(1).max(120),
   slug: slugSchema.optional(),
   platforms: zod.z.array(platformSchema).min(1).max(8),
-  environment: writeKeyEnvironmentSchema.default("production")
+  environment: writeKeyEnvironmentSchema.default("production"),
+  onboardingGoal: onboardingGoalSchema.optional(),
+  setupMode: zod.z.enum(["sdk", "portal"]).optional(),
+  portal: zod.z.object({
+    appSlug: portalSlugSchema,
+    company: zod.z.object({
+      displayName: zod.z.string().trim().min(1).max(100),
+      slug: portalSlugSchema
+    }).strict().optional()
+  }).strict().optional(),
+  webConfig: webAppConfigSchema.optional()
+});
+var updateOnboardingSchema = zod.z.object({
+  action: zod.z.enum([
+    "resume",
+    "defer",
+    "create_first_inapp",
+    "first_inapp_completed",
+    "create_first_feedback",
+    "first_feedback_completed",
+    "push_configured",
+    "push_skipped",
+    "complete"
+  ]).optional(),
+  step: onboardingStepSchema.optional(),
+  question: zod.z.string().trim().min(1).max(500).optional(),
+  message: zod.z.object({
+    title: zod.z.string().trim().min(1).max(200),
+    body: zod.z.string().trim().min(1).max(500),
+    buttonLabel: zod.z.string().trim().min(1).max(40),
+    format: zod.z.enum(["modal", "slideup"])
+  }).strict().optional()
+}).refine((value) => Boolean(value.action || value.step), {
+  message: "Provide an onboarding action or step"
+}).refine(
+  (value) => value.action !== "create_first_feedback" || Boolean(value.question),
+  { message: "Provide a question for the first feedback experience" }
+);
+var deferCurrentUserOnboardingSchema = zod.z.object({
+  action: zod.z.literal("defer")
 });
 var updateAppSchema = zod.z.object({
   name: zod.z.string().min(1).max(120).optional(),
   platforms: zod.z.array(platformSchema).min(1).max(8).optional(),
   piiAllowList: zod.z.array(zod.z.string().min(1).max(120)).max(128).optional(),
-  lifecycleEventsEnabled: zod.z.boolean().optional()
-}).refine((v) => Object.keys(v).length > 0, { message: "At least one field is required" });
+  lifecycleEventsEnabled: zod.z.boolean().optional(),
+  webConfig: webAppConfigSchema.optional()
+}).refine((v) => Object.keys(v).length > 0, {
+  message: "At least one field is required"
+});
 var createWriteKeySchema = zod.z.object({
   label: zod.z.string().min(1).max(120).optional(),
   environment: writeKeyEnvironmentSchema.default("production")
@@ -1078,8 +1513,15 @@ var createApiTokenSchema = zod.z.object({
   expiresInDays: zod.z.number().int().min(1).max(365).default(90)
 });
 var createWorkspaceSchema = zod.z.object({
-  name: zod.z.string().min(1).max(120),
-  slug: slugSchema.optional()
+  name: zod.z.string().trim().min(1).max(120),
+  slug: slugSchema.optional(),
+  timezone: workspaceTimezoneSchema.default("UTC")
+});
+var updateWorkspaceSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(120).optional(),
+  timezone: workspaceTimezoneSchema.optional()
+}).strict().refine((value) => Object.keys(value).length > 0, {
+  message: "At least one field is required"
 });
 var inviteMemberSchema = zod.z.object({
   email: emailSchema,
@@ -1089,6 +1531,714 @@ var acceptWorkspaceInviteSchema = zod.z.object({
   token: zod.z.string().regex(/^[a-f0-9]{64}$/i, "Invalid invitation token")
 });
 
+// src/types/portal-content.ts
+function emptyDocumentDraft() {
+  return {
+    title: "",
+    summary: "",
+    body: { type: "doc", content: [{ type: "paragraph" }] },
+    collectionId: null,
+    category: "improved",
+    releaseDate: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+    version: "",
+    links: []
+  };
+}
+function contentText(node2) {
+  return node2.text ?? (node2.content ?? []).map(contentText).join(node2.type === "paragraph" || node2.type === "heading" ? "" : "\n");
+}
+function contentAssetIds(node2) {
+  return [
+    .../* @__PURE__ */ new Set([
+      ...node2.type === "image" && node2.attrs?.assetId ? [node2.attrs.assetId] : [],
+      ...(node2.content ?? []).flatMap(contentAssetIds)
+    ])
+  ];
+}
+function contentSlug(title) {
+  return title.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 96).replace(/-$/, "") || "article";
+}
+function safeContentHref(href) {
+  return /^(https?:\/\/|mailto:|\/[^/]|#[a-zA-Z0-9_-])/.test(href) && !/[\u0000-\u0020\\]/.test(href);
+}
+
+// src/schemas/portal-content.ts
+var uuid = zod.z.string().uuid();
+var contentKindSchema = zod.z.enum(["article", "changelog"]);
+var contentStateSchema = zod.z.enum(["draft", "published", "archived"]);
+var roadmapStatusSchema = zod.z.enum(["planned", "in_progress", "shipped"]);
+var contentLinkSchema = zod.z.object({ kind: zod.z.enum(["request", "roadmap"]), id: uuid }).strict();
+var mark = zod.z.object({
+  type: zod.z.enum(["bold", "italic", "code", "link"]),
+  attrs: zod.z.object({ href: zod.z.string().max(2048).refine(safeContentHref, "Use a safe link URL") }).strict().optional()
+}).strict().refine((m) => m.type === "link" ? Boolean(m.attrs) : !m.attrs);
+var node = zod.z.lazy(
+  () => zod.z.object({
+    type: zod.z.enum([
+      "doc",
+      "paragraph",
+      "heading",
+      "text",
+      "bulletList",
+      "orderedList",
+      "listItem",
+      "blockquote",
+      "codeBlock",
+      "hardBreak",
+      "image"
+    ]),
+    text: zod.z.string().max(1e5).optional(),
+    attrs: zod.z.object({
+      level: zod.z.number().int().min(2).max(3).optional(),
+      start: zod.z.number().int().min(1).max(1e4).optional(),
+      language: zod.z.string().max(40).nullable().optional(),
+      assetId: uuid.optional(),
+      alt: zod.z.string().max(500).optional()
+    }).strict().optional(),
+    marks: zod.z.array(mark).max(4).optional(),
+    content: zod.z.array(node).max(5e3).optional()
+  }).strict()
+);
+var contentBodySchema = zod.z.unknown().superRefine((value, ctx) => {
+  let count = 0, invalid = false;
+  const walk = (v, depth) => {
+    if (depth > 20 || ++count > 5e3) {
+      invalid = true;
+      return;
+    }
+    if (v && typeof v === "object" && "content" in v && Array.isArray(v.content))
+      for (const child of v.content) {
+        if (invalid) break;
+        walk(child, depth + 1);
+      }
+  };
+  walk(value, 0);
+  if (invalid)
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "Document is too deeply nested or contains too many blocks"
+    });
+}).pipe(node).superRefine((value, ctx) => {
+  if (value.type !== "doc" || contentText(value).length > 1e5)
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "Invalid document or body exceeds 100,000 characters"
+    });
+  const walk = (v, root = false) => {
+    const blocks = ["paragraph", "heading", "bulletList", "orderedList", "blockquote", "codeBlock", "image"];
+    const children = v.content ?? [];
+    const allowed = v.type === "doc" || v.type === "blockquote" ? blocks : v.type === "listItem" ? blocks.filter((t) => t !== "heading") : v.type === "bulletList" || v.type === "orderedList" ? ["listItem"] : v.type === "paragraph" || v.type === "heading" ? ["text", "hardBreak"] : v.type === "codeBlock" ? ["text"] : [];
+    const attrs = Object.keys(v.attrs ?? {});
+    const allowedAttrs = v.type === "heading" ? ["level"] : v.type === "orderedList" ? ["start"] : v.type === "codeBlock" ? ["language"] : v.type === "image" ? ["assetId", "alt"] : [];
+    if (!root && v.type === "doc" || v.type === "text" && (!v.text || v.content) || v.type !== "text" && (v.text !== void 0 || Boolean(v.marks?.length)) || v.type === "image" && (!v.attrs?.assetId || v.content) || v.type === "heading" && !v.attrs?.level || attrs.some((a) => !allowedAttrs.includes(a)) || children.some((c) => !allowed.includes(c.type)) || v.type === "listItem" && children[0]?.type !== "paragraph" || ["bulletList", "orderedList", "blockquote", "doc"].includes(v.type) && !children.length || v.type === "codeBlock" && children.some((c) => c.marks?.length))
+      ctx.addIssue({ code: zod.z.ZodIssueCode.custom, message: "Invalid content block" });
+    v.content?.forEach((c) => walk(c));
+  };
+  walk(value, true);
+});
+var documentDraftSchema = zod.z.object({
+  title: zod.z.string().trim().max(160),
+  summary: zod.z.string().max(280),
+  body: contentBodySchema,
+  collectionId: uuid.nullable(),
+  category: zod.z.enum(["new", "improved", "fixed"]),
+  releaseDate: zod.z.string().regex(/^\d{4}-\d{2}-\d{2}$/).refine(
+    (v) => !Number.isNaN(Date.parse(v)) && new Date(v).toISOString().slice(0, 10) === v,
+    "Choose a valid date"
+  ),
+  version: zod.z.string().max(40),
+  links: zod.z.array(contentLinkSchema).max(100)
+}).strict();
+var createDocumentSchema = zod.z.object({
+  idempotencyKey: uuid,
+  title: zod.z.string().trim().max(160).optional(),
+  collectionId: uuid.nullable().optional(),
+  links: zod.z.array(contentLinkSchema).max(100).optional()
+}).strict();
+var saveDocumentSchema = zod.z.object({ revision: zod.z.number().int().positive(), draft: documentDraftSchema }).strict();
+var contentActionSchema = zod.z.object({
+  revision: zod.z.number().int().positive(),
+  action: zod.z.enum(["publish", "unpublish", "archive", "restore"])
+}).strict();
+var contentQuerySchema = zod.z.object({
+  q: zod.z.string().trim().max(200).optional(),
+  state: contentStateSchema.optional(),
+  collectionId: uuid.optional(),
+  category: zod.z.enum(["new", "improved", "fixed"]).optional(),
+  cursor: zod.z.string().max(2e3).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(50).default(20)
+}).strict();
+var createCollectionSchema = zod.z.object({
+  title: zod.z.string().trim().min(1).max(160),
+  description: zod.z.string().max(280),
+  idempotencyKey: uuid
+}).strict();
+var contentPageQuerySchema = contentQuerySchema.pick({ cursor: true, limit: true });
+var portalAssetUploadKeySchema = uuid;
+var updateCollectionSchema = zod.z.object({
+  revision: zod.z.number().int().positive(),
+  title: zod.z.string().trim().min(1).max(160).optional(),
+  description: zod.z.string().max(280).optional(),
+  archived: zod.z.boolean().optional()
+}).strict();
+var reorderContentSchema = zod.z.object({ revision: zod.z.number().int().positive(), direction: zod.z.enum(["up", "down"]) }).strict();
+var roadmapQuerySchema = zod.z.object({
+  status: roadmapStatusSchema,
+  cursor: zod.z.string().max(2e3).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(50).default(20),
+  archived: zod.z.enum(["true", "false"]).transform((v) => v === "true").optional()
+}).strict();
+var roadmapFields = {
+  title: zod.z.string().trim().min(1).max(120),
+  description: zod.z.string().max(1500),
+  requestIds: zod.z.array(uuid).max(100).refine((v) => new Set(v).size === v.length)
+};
+var createRoadmapSchema = zod.z.object({ ...roadmapFields, idempotencyKey: uuid, status: roadmapStatusSchema }).strict();
+var saveRoadmapSchema = zod.z.object({ ...roadmapFields, revision: zod.z.number().int().positive() }).strict();
+var moveRoadmapSchema = zod.z.object({
+  revision: zod.z.number().int().positive(),
+  status: roadmapStatusSchema,
+  requests: zod.z.array(zod.z.object({ id: uuid, updatedAt: zod.z.string().datetime() }).strict()).max(100).refine((v) => new Set(v.map((r) => r.id)).size === v.length)
+}).strict();
+var contentLinkQuerySchema = zod.z.object({
+  kind: zod.z.enum(["request", "roadmap"]),
+  q: zod.z.string().trim().max(200).optional(),
+  cursor: zod.z.string().max(2e3).optional(),
+  limit: zod.z.coerce.number().int().min(1).max(100).default(20),
+  ids: zod.z.string().max(4e3).optional().refine((v) => !v || v.split(",").every((id2) => uuid.safeParse(id2).success), "Invalid linked IDs")
+}).strict();
+
+// src/types/mcp.ts
+var MCP_DOMAINS = ["context", "users", "analytics", "requests", "roadmap", "content", "experiences", "segments", "brand", "portal", "push", "integrations", "sdk", "apps"];
+var MCP_ACCESS_MODES = ["read_only", "approve_changes", "automatic"];
+var MCP_CAPABILITIES = [
+  "context:read",
+  "users:read",
+  "analytics:read",
+  "requests:read",
+  "requests:manage",
+  "requests:publish",
+  "roadmap:read",
+  "roadmap:manage",
+  "roadmap:publish",
+  "content:read",
+  "content:manage",
+  "content:publish",
+  "experiences:read",
+  "experiences:manage",
+  "experiences:publish",
+  "segments:read",
+  "segments:manage",
+  "brand:read",
+  "brand:manage",
+  "portal:read",
+  "portal:manage",
+  "portal:publish",
+  "push:read",
+  "push:manage",
+  "push:send",
+  "integrations:read",
+  "integrations:manage",
+  "integrations:send",
+  "sdk:read",
+  "sdk:manage",
+  "apps:read",
+  "apps:manage"
+];
+var MCP_DEFAULT_CAPABILITIES = [
+  "context:read",
+  "users:read",
+  "analytics:read",
+  "requests:read",
+  "roadmap:read",
+  "content:read",
+  "experiences:read",
+  "segments:read",
+  "brand:read",
+  "portal:read",
+  "push:read",
+  "sdk:read",
+  "apps:read",
+  "requests:manage",
+  "roadmap:manage",
+  "content:manage",
+  "experiences:manage",
+  "segments:manage"
+];
+
+// src/schemas/mcp.ts
+var mcpCapabilitySchema = zod.z.string().refine((value) => MCP_CAPABILITIES.includes(value), "Unknown MCP capability");
+var mcpGrantSchema = zod.z.object({
+  name: zod.z.string().trim().min(1).max(100).default("AI connection"),
+  appIds: zod.z.array(zod.z.string().uuid()).min(1).max(100).refine((v) => new Set(v).size === v.length, "Duplicate app IDs"),
+  capabilities: zod.z.array(mcpCapabilitySchema).max(56).default([...MCP_DEFAULT_CAPABILITIES]),
+  mode: zod.z.enum(MCP_ACCESS_MODES).default("approve_changes")
+}).strict();
+var mcpConsentSchema = mcpGrantSchema.extend({
+  workspaceId: zod.z.string().uuid(),
+  externalAuthId: zod.z.string().min(10).max(256).regex(/^[a-zA-Z0-9_-]+$/)
+});
+var mcpUpdateConnectionSchema = mcpGrantSchema.extend({ policyVersion: zod.z.number().int().positive() });
+var subjectRefSchema = zod.z.union([
+  zod.z.object({ subjectId: zod.z.string().uuid() }).strict(),
+  zod.z.object({ externalId: zod.z.string().min(1).max(256) }).strict(),
+  zod.z.object({ anonymousId: zod.z.string().min(1).max(256) }).strict()
+]);
+var mcpPageSchema = zod.z.object({ cursor: zod.z.string().max(4096).optional(), limit: zod.z.number().int().min(1).max(100).default(25) });
+var mcpSearchSchema = mcpPageSchema.extend({
+  query: zod.z.string().trim().min(1).max(500),
+  types: zod.z.array(zod.z.enum(["request", "feedback_answer", "survey_answer", "roadmap", "article", "changelog"])).max(6).optional(),
+  variant: zod.z.enum(["draft", "published", "record"]).optional()
+});
+
+// src/types/web.ts
+var DELIVERY_PROTOCOL_VERSION = 2;
+function deliveryPlatformsForApp(platforms) {
+  const values = /* @__PURE__ */ new Set();
+  for (const platform of platforms) {
+    if (platform === "web" || platform === "ios" || platform === "android") values.add(platform);
+    if (platform === "expo" || platform === "react-native" || platform === "flutter") {
+      values.add("ios");
+      values.add("android");
+    }
+  }
+  return [...values];
+}
+function resolveWebPresentation(pillar, override) {
+  return {
+    layout: override?.layout ?? "modal",
+    size: override?.size ?? (pillar === "requests" ? "wide" : "standard"),
+    position: override?.position ?? "right",
+    backdrop: override?.backdrop ?? override?.layout !== "card"
+  };
+}
+var id = zod.z.string().regex(/^[A-Za-z][A-Za-z0-9_]{0,63}$/);
+var key = zod.z.string().min(1).max(120).refine(
+  (v) => !["__proto__", "prototype", "constructor"].includes(v),
+  "Reserved property key"
+);
+var scalar = zod.z.union([
+  zod.z.string().max(8192),
+  zod.z.number().finite(),
+  zod.z.boolean(),
+  zod.z.null()
+]);
+var baseSource = { id, label: zod.z.string().min(1).max(120) };
+var filterSchema = zod.z.object({
+  key,
+  op: zod.z.enum([
+    "eq",
+    "neq",
+    "gt",
+    "gte",
+    "lt",
+    "lte",
+    "in",
+    "nin",
+    "contains",
+    "starts_with",
+    "exists",
+    "not_exists"
+  ]),
+  value: zod.z.union([
+    zod.z.string(),
+    zod.z.number().finite(),
+    zod.z.boolean(),
+    zod.z.array(zod.z.union([zod.z.string(), zod.z.number().finite()])).max(100)
+  ]).optional()
+});
+var personalizationSpecSchema = zod.z.object({
+  version: zod.z.literal(1),
+  sources: zod.z.array(
+    zod.z.discriminatedUnion("kind", [
+      zod.z.object({ ...baseSource, kind: zod.z.literal("user_property") }),
+      zod.z.object({ ...baseSource, kind: zod.z.literal("trigger_event") }),
+      zod.z.object({ ...baseSource, kind: zod.z.literal("send_data") }),
+      zod.z.object({ ...baseSource, kind: zod.z.literal("app") }),
+      zod.z.object({ ...baseSource, kind: zod.z.literal("now") }),
+      zod.z.object({
+        ...baseSource,
+        kind: zod.z.literal("latest_event"),
+        eventName: zod.z.string().min(1).max(120),
+        lookbackDays: zod.z.number().int().min(1).max(90),
+        filters: zod.z.array(filterSchema).max(8).optional()
+      })
+    ])
+  ).max(16),
+  bindings: zod.z.array(
+    zod.z.object({
+      id,
+      label: zod.z.string().min(1).max(120),
+      sourceId: id,
+      key,
+      type: zod.z.enum(["string", "number", "boolean", "date"]),
+      fallback: scalar.optional()
+    })
+  ).max(64),
+  missingData: zod.z.literal("skip")
+}).superRefine((spec, ctx) => {
+  const sources = new Set(spec.sources.map((source) => source.id));
+  if (sources.size !== spec.sources.length)
+    ctx.addIssue({
+      code: "custom",
+      path: ["sources"],
+      message: "Source IDs must be unique"
+    });
+  if (spec.sources.filter((source) => source.kind === "latest_event").length > 4)
+    ctx.addIssue({
+      code: "custom",
+      path: ["sources"],
+      message: "Use at most four activity sources"
+    });
+  const bindings = /* @__PURE__ */ new Set();
+  spec.bindings.forEach((binding, index) => {
+    if (bindings.has(binding.id))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "id"],
+        message: "Field IDs must be unique"
+      });
+    bindings.add(binding.id);
+    if (!sources.has(binding.sourceId))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "sourceId"],
+        message: "Choose an existing source"
+      });
+    if (binding.fallback !== void 0 && (isMissing(binding.fallback) || !matchesType(binding.fallback, binding.type)))
+      ctx.addIssue({
+        code: "custom",
+        path: ["bindings", index, "fallback"],
+        message: "Fallback must be a non-empty value of the selected type"
+      });
+  });
+});
+var userPropertiesUpdateSchema = zod.z.object({
+  mutationId: zod.z.string().uuid(),
+  set: zod.z.record(key, scalar).refine(
+    (v) => Object.keys(v).length <= 64,
+    "Update at most 64 properties"
+  ).optional(),
+  unset: zod.z.array(key).max(64).optional()
+}).superRefine((update, ctx) => {
+  if (!Object.keys(update.set ?? {}).length && !update.unset?.length)
+    ctx.addIssue({
+      code: "custom",
+      message: "Supply properties to set or remove"
+    });
+  if (update.unset?.some((name) => Object.hasOwn(update.set ?? {}, name)))
+    ctx.addIssue({
+      code: "custom",
+      message: "A property cannot be set and removed in the same update"
+    });
+});
+function isMissing(value) {
+  return value == null || typeof value === "string" && !value.trim();
+}
+function matchesType(value, type) {
+  if (type === "date")
+    return typeof value === "string" && !Number.isNaN(Date.parse(value));
+  return typeof value === type && (typeof value !== "number" || Number.isFinite(value));
+}
+function resolvePersonalizationBindings(spec, sources) {
+  const values = /* @__PURE__ */ Object.create(null);
+  const issues = [];
+  const fallbackBindingIds = [];
+  for (const binding of spec.bindings) {
+    const source = sources[binding.sourceId]?.values;
+    const value = source && Object.hasOwn(source, binding.key) ? source[binding.key] : void 0;
+    const missing = isMissing(value);
+    if (!missing && matchesType(value, binding.type))
+      values[binding.id] = value;
+    else if (missing && binding.fallback !== void 0) {
+      values[binding.id] = binding.fallback;
+      fallbackBindingIds.push(binding.id);
+    } else
+      issues.push({
+        code: missing ? "missing" : "type_mismatch",
+        bindingId: binding.id,
+        message: missing ? `${binding.label} is missing` : `${binding.label} must be ${binding.type}`
+      });
+  }
+  return {
+    status: issues.length ? "skipped" : fallbackBindingIds.length ? "using_fallback" : "ready",
+    values,
+    fallbackBindingIds,
+    issues,
+    sources
+  };
+}
+var TOKEN = /\{\{\s*p\.([A-Za-z][A-Za-z0-9_]*)\s*\}\}/g;
+var WHOLE_TOKEN = /^\{\{\s*p\.([A-Za-z][A-Za-z0-9_]*)\s*\}\}$/;
+function personalizationToken(bindingId) {
+  return `{{p.${bindingId}}}`;
+}
+function renderPersonalizedValue(input, values, issues, path = "", mode = "text") {
+  if (typeof input === "string") {
+    const whole = WHOLE_TOKEN.exec(input);
+    const lookup = (bindingId) => {
+      if (Object.hasOwn(values, bindingId)) return values[bindingId];
+      issues.push({
+        code: "unknown_binding",
+        bindingId,
+        path,
+        message: `No value is available for ${bindingId}`
+      });
+      return null;
+    };
+    if (mode === "json" && whole) return lookup(whole[1]);
+    if (/\{\{|\}\}/.test(input.replace(TOKEN, "")))
+      issues.push({
+        code: "invalid_template",
+        path,
+        message: "Insert a valid dynamic field"
+      });
+    const result = input.replace(TOKEN, (_, bindingId) => {
+      const value = lookup(bindingId);
+      return mode === "url" && !whole ? encodeURIComponent(String(value ?? "")) : String(value ?? "");
+    });
+    if (mode === "url" && result) {
+      try {
+        const url = new URL(result);
+        if (["javascript:", "data:", "file:", "vbscript:"].includes(url.protocol))
+          throw new Error("unsafe");
+        if (!whole && /\{\{/.test(input.split(/:\/\//)[0] ?? ""))
+          throw new Error("dynamic scheme");
+        if (!whole && /\{\{/.test(
+          input.match(/^[a-z][a-z0-9+.-]*:\/\/([^/?#]*)/i)?.[1] ?? ""
+        ))
+          throw new Error("dynamic authority");
+      } catch {
+        issues.push({
+          code: "invalid_destination",
+          path,
+          message: "The resolved destination must be a valid app link or web URL"
+        });
+      }
+    }
+    return result;
+  }
+  if (Array.isArray(input))
+    return input.map(
+      (item, index) => renderPersonalizedValue(item, values, issues, `${path}/${index}`, mode)
+    );
+  if (input && typeof input === "object") {
+    const result = /* @__PURE__ */ Object.create(null);
+    for (const [name, value] of Object.entries(input)) {
+      if (["__proto__", "constructor", "prototype"].includes(name)) {
+        issues.push({
+          code: "invalid_template",
+          path,
+          message: "Reserved object key"
+        });
+        continue;
+      }
+      result[name] = renderPersonalizedValue(
+        value,
+        values,
+        issues,
+        `${path}/${name}`,
+        mode
+      );
+    }
+    return result;
+  }
+  return input;
+}
+var TEXT_KEYS = /* @__PURE__ */ new Set([
+  "title",
+  "body",
+  "subtitle",
+  "headline",
+  "label",
+  "placeholder",
+  "followUp",
+  "lowLabel",
+  "highLabel",
+  "description",
+  "buttonText",
+  "submitLabel",
+  "nextLabel",
+  "backLabel",
+  "text"
+]);
+var URL_KEYS = /* @__PURE__ */ new Set(["imageUrl", "deepLink", "target"]);
+var CONTENT_KEYS = /* @__PURE__ */ new Set([
+  "questions",
+  "options",
+  "ctas",
+  "cta",
+  "actionButtons",
+  "flow",
+  "welcome",
+  "thankYou",
+  "completion",
+  "endScreen",
+  "openAction"
+]);
+function personalizationUsage(content) {
+  const usage = /* @__PURE__ */ new Map();
+  const scan = (value, field) => {
+    if (typeof value === "string") {
+      for (const match of value.matchAll(TOKEN)) {
+        const fields = usage.get(match[1]) ?? /* @__PURE__ */ new Set();
+        fields.add(field);
+        usage.set(match[1], fields);
+      }
+    } else if (Array.isArray(value)) value.forEach((item) => scan(item, field));
+    else if (value && typeof value === "object")
+      Object.values(value).forEach((item) => scan(item, field));
+  };
+  const walk = (value) => {
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [key2, item] of Object.entries(value)) {
+      if (TEXT_KEYS.has(key2) || URL_KEYS.has(key2) || key2 === "actionJson" || key2 === "payloadExtras")
+        scan(item, key2);
+      else if (CONTENT_KEYS.has(key2)) walk(item);
+    }
+  };
+  walk(content);
+  return usage;
+}
+function renderPersonalizedContent(content, resolution) {
+  const usage = personalizationUsage(content);
+  const onlyOptionalImage = (id2) => usage.get(id2)?.size === 1 && usage.get(id2)?.has("imageUrl");
+  const issues = resolution.issues.filter(
+    (issue) => !issue.bindingId || usage.has(issue.bindingId) && !(issue.code === "missing" && onlyOptionalImage(issue.bindingId))
+  );
+  const fallbacks = resolution.fallbackBindingIds.filter((id2) => usage.has(id2));
+  const walk = (value, path = "") => {
+    if (Array.isArray(value))
+      return value.map((item, index) => walk(item, `${path}/${index}`));
+    if (!value || typeof value !== "object") return value;
+    return Object.fromEntries(
+      Object.entries(value).map(([name, item]) => {
+        const childPath = `${path}/${name}`;
+        if (TEXT_KEYS.has(name) && typeof item === "string")
+          return [
+            name,
+            renderPersonalizedValue(item, resolution.values, issues, childPath)
+          ];
+        if (URL_KEYS.has(name) && typeof item === "string") {
+          if (name === "imageUrl" && [...item.matchAll(TOKEN)].some(
+            (match) => resolution.issues.some(
+              (issue) => issue.bindingId === match[1] && issue.code === "missing"
+            )
+          ))
+            return [name, null];
+          const isEvent = name === "target" && value.action === "custom_event";
+          const rendered2 = renderPersonalizedValue(
+            item,
+            resolution.values,
+            issues,
+            childPath,
+            isEvent ? "text" : "url"
+          );
+          if (name === "imageUrl" && rendered2 && !String(rendered2).startsWith("https://"))
+            issues.push({
+              code: "invalid_destination",
+              path: childPath,
+              message: "Image URLs must use HTTPS"
+            });
+          return [name, rendered2];
+        }
+        if (name === "actionJson" || name === "payloadExtras")
+          return [
+            name,
+            renderPersonalizedValue(
+              item,
+              resolution.values,
+              issues,
+              childPath,
+              "json"
+            )
+          ];
+        if (CONTENT_KEYS.has(name)) return [name, walk(item, childPath)];
+        return [name, item];
+      })
+    );
+  };
+  const rendered = walk(content);
+  return {
+    content: rendered,
+    resolution: {
+      ...resolution,
+      fallbackBindingIds: fallbacks,
+      status: issues.length ? "skipped" : fallbacks.length ? "using_fallback" : "ready",
+      issues
+    }
+  };
+}
+
+// src/presentation.ts
+var PresentationGate = class {
+  paused;
+  identity = 0;
+  revisions = { feedback: 0, survey: 0 };
+  listeners = /* @__PURE__ */ new Set();
+  constructor(paused = false) {
+    this.paused = paused;
+  }
+  get isPaused() {
+    return this.paused;
+  }
+  setPaused(paused) {
+    this.paused = paused;
+    this.notify();
+  }
+  invalidate(purpose) {
+    if (purpose) this.revisions[purpose]++;
+    else this.identity++;
+    this.notify();
+  }
+  validator(purpose) {
+    const identity = this.identity;
+    const revision = this.revisions[purpose];
+    return () => identity === this.identity && revision === this.revisions[purpose];
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  runWhenReady(run, valid, cancel = () => {
+  }) {
+    if (!valid()) {
+      cancel();
+      return;
+    }
+    if (!this.paused) {
+      run();
+      return;
+    }
+    const stop = this.subscribe(() => {
+      if (valid() && this.paused) return;
+      stop();
+      if (valid()) run();
+      else cancel();
+    });
+  }
+  waitUntilReady(valid) {
+    if (!valid()) return Promise.resolve(false);
+    if (!this.paused) return Promise.resolve(true);
+    return new Promise((resolve) => {
+      const stop = this.subscribe(() => {
+        if (valid() && this.paused) return;
+        stop();
+        resolve(valid());
+      });
+    });
+  }
+  notify() {
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+
 exports.APP_OPEN_EVENT_NAME = APP_OPEN_EVENT_NAME;
 exports.APP_VERSION_CHANGED_EVENT_NAME = APP_VERSION_CHANGED_EVENT_NAME;
 exports.AUDIENCE_JOIN_EVENT_NAME = AUDIENCE_JOIN_EVENT_NAME;
@@ -1096,13 +2246,21 @@ exports.AUDIENCE_JOIN_TRIGGER_KIND = AUDIENCE_JOIN_TRIGGER_KIND;
 exports.BILLING_GRACE_DAYS = BILLING_GRACE_DAYS;
 exports.COMMERCIAL_BILLING_PLANS = COMMERCIAL_BILLING_PLANS;
 exports.CORE_INTEGRATION_EVENTS = CORE_INTEGRATION_EVENTS;
+exports.DELIVERY_PROTOCOL_VERSION = DELIVERY_PROTOCOL_VERSION;
 exports.INAPP_AUTO_DISMISSED_EVENT_NAME = INAPP_AUTO_DISMISSED_EVENT_NAME;
 exports.INAPP_CTA_CLICKED_EVENT_NAME = INAPP_CTA_CLICKED_EVENT_NAME;
 exports.INAPP_DISMISSED_EVENT_NAME = INAPP_DISMISSED_EVENT_NAME;
 exports.INAPP_SHOWN_EVENT_NAME = INAPP_SHOWN_EVENT_NAME;
 exports.INTEGRATION_CATEGORIES = INTEGRATION_CATEGORIES;
 exports.INTEGRATION_PROVIDERS = INTEGRATION_PROVIDERS;
+exports.MCP_ACCESS_MODES = MCP_ACCESS_MODES;
+exports.MCP_CAPABILITIES = MCP_CAPABILITIES;
+exports.MCP_DEFAULT_CAPABILITIES = MCP_DEFAULT_CAPABILITIES;
+exports.MCP_DOMAINS = MCP_DOMAINS;
+exports.PORTAL_RESERVED_SLUGS = PORTAL_RESERVED_SLUGS;
+exports.PORTAL_SLUG_PATTERN = PORTAL_SLUG_PATTERN;
 exports.PUSH_EVENTS = PUSH_EVENTS;
+exports.PresentationGate = PresentationGate;
 exports.RADIUS_PRESETS = RADIUS_PRESETS;
 exports.RECIPIENTS_LIMIT = RECIPIENTS_LIMIT;
 exports.REQUEST_COMMENTED_EVENT_NAME = REQUEST_COMMENTED_EVENT_NAME;
@@ -1123,10 +2281,17 @@ exports.TRIAL_APP_LIMIT = TRIAL_APP_LIMIT;
 exports.TRIAL_DAYS = TRIAL_DAYS;
 exports.USER_IDENTIFIED_EVENT_NAME = USER_IDENTIFIED_EVENT_NAME;
 exports.brandTokensFromPreset = brandTokensFromPreset;
+exports.buildPortalUrl = buildPortalUrl;
+exports.contentAssetIds = contentAssetIds;
+exports.contentSlug = contentSlug;
+exports.contentText = contentText;
 exports.defaultEventTrigger = defaultEventTrigger;
+exports.defaultOnboardingMessage = defaultOnboardingMessage;
 exports.defaultThemePreset = defaultThemePreset;
 exports.defaultTriggerSpec = defaultTriggerSpec;
+exports.deliveryPlatformsForApp = deliveryPlatformsForApp;
 exports.emptyAudienceSpec = emptyAudienceSpec;
+exports.emptyDocumentDraft = emptyDocumentDraft;
 exports.emptySegmentDsl = emptySegmentDsl;
 exports.endpoints = endpoints;
 exports.err = err;
@@ -1140,15 +2305,30 @@ exports.getCoreIntegrationEvent = getCoreIntegrationEvent;
 exports.getThemePresetById = getThemePresetById;
 exports.inAppColorsFromBrandTokens = inAppColorsFromBrandTokens;
 exports.isSilentPushPayload = isSilentPushPayload;
+exports.isValidIanaTimeZone = isValidIanaTimeZone;
 exports.nextPeriodicFire = nextPeriodicFire;
 exports.nextQuestionId = nextQuestionId;
 exports.ok = ok;
+exports.personalizationSpecSchema = personalizationSpecSchema;
+exports.personalizationToken = personalizationToken;
+exports.personalizationUsage = personalizationUsage;
 exports.promptThemeFromBrandTokens = promptThemeFromBrandTokens;
 exports.reachableQuestions = reachableQuestions;
+exports.renderPersonalizedContent = renderPersonalizedContent;
+exports.renderPersonalizedValue = renderPersonalizedValue;
 exports.requestAccentFromBrandTokens = requestAccentFromBrandTokens;
+exports.resolvePersonalizationBindings = resolvePersonalizationBindings;
+exports.resolveWebPresentation = resolveWebPresentation;
+exports.safeContentHref = safeContentHref;
 exports.sanitizeCoreIntegrationProperties = sanitizeCoreIntegrationProperties;
 exports.schemas = schemas_exports;
 exports.serializedRulesToDsl = serializedRulesToDsl;
+exports.suggestPortalSlug = suggestPortalSlug;
 exports.tzOffsetMinutes = tzOffsetMinutes;
+exports.userPropertiesUpdateSchema = userPropertiesUpdateSchema;
+exports.validPortalSlug = validPortalSlug;
+exports.zonedDateEndToUtc = zonedDateEndToUtc;
+exports.zonedDateTimeParts = zonedDateTimeParts;
+exports.zonedDateTimeToUtc = zonedDateTimeToUtc;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map