@domino-sdk/relay 1.61.0 → 1.63.0

package/dist/chunk-QR6HH4DI.js

@@ -0,0 +1,508 @@
+import {
+  parseDefinition
+} from "./chunk-FO2LCZTL.js";
+import {
+  authoringIdentityShape,
+  calendarPeriodSchema,
+  contentMetricSchema,
+  contentMetricsSchema,
+  identifier,
+  maxPointsAmount,
+  missingPrerequisiteSchema,
+  pageCursorSchema,
+  pointsRewardSchema,
+  prerequisiteSchema,
+  resourceHandle,
+  responseShape,
+  tierRewardSchema
+} from "./chunk-ID3BZXFZ.js";
+
+// src/engagement.ts
+import * as z from "zod";
+var amount = /* @__PURE__ */ (() => z.number().int().safe().nonnegative())();
+var engagementBudgetSchema = /* @__PURE__ */ (() => z.strictObject({
+  scope: z.enum(["member", "project"]),
+  period: calendarPeriodSchema,
+  limit: amount
+}))();
+var engagementDefinitionSchema = /* @__PURE__ */ (() => z.strictObject({
+  key: identifier,
+  qualifiedBy: identifier,
+  balance: identifier,
+  metrics: z.array(contentMetricSchema).min(1).max(10).refine(
+    (metrics) => new Set(metrics).size === metrics.length,
+    "Metrics must be unique"
+  ),
+  baseline: z.literal("historical"),
+  maxAgeMs: z.number().int().positive().max(864e5).default(36e5),
+  budgets: z.array(engagementBudgetSchema).max(8).default([]).refine(
+    (budgets) => new Set(budgets.map((b) => b.scope + ":" + b.period)).size === budgets.length,
+    "Give each scope and period one budget"
+  )
+}))();
+var engagementScoreInputSchema = /* @__PURE__ */ (() => z.strictObject({
+  metrics: contentMetricsSchema,
+  baseline: contentMetricsSchema
+}))();
+var engagementScoreSchema = /* @__PURE__ */ (() => z.strictObject({
+  target: amount,
+  baseline: amount
+}))();
+var engagementPublishSchema = /* @__PURE__ */ (() => z.strictObject({
+  actionId: identifier,
+  code: z.string().min(1).max(1e6)
+}))();
+var engagementRuleSchema = /* @__PURE__ */ (() => z.strictObject({
+  version: identifier,
+  definition: engagementDefinitionSchema,
+  publishedAt: amount
+}))();
+var engagementPageQuerySchema = /* @__PURE__ */ (() => z.strictObject({
+  rule: identifier,
+  content: z.string().min(1).max(256),
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional()
+}))();
+var engagementSettlementSchema = /* @__PURE__ */ (() => z.strictObject({
+  id: identifier,
+  day: z.string(),
+  observation: identifier,
+  qualification: identifier,
+  earned: amount,
+  growth: amount,
+  paid: amount,
+  excluded: amount,
+  entry: identifier.nullable(),
+  createdAt: amount
+}))();
+var engagementPageSchema = /* @__PURE__ */ (() => z.strictObject({
+  rule: engagementRuleSchema,
+  account: z.strictObject({
+    member: identifier,
+    earned: amount,
+    accounted: amount,
+    paid: amount,
+    excluded: amount,
+    pending: amount,
+    counters: contentMetricsSchema,
+    baseline: contentMetricsSchema,
+    observation: identifier.nullable(),
+    nextSettlementAt: amount.nullable(),
+    reason: z.string().nullable()
+  }).nullable(),
+  items: z.array(engagementSettlementSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var engagementChangePreviewInputSchema = /* @__PURE__ */ (() => z.strictObject({
+  code: z.string().min(1).max(1e6)
+}))();
+var engagementChangeSchema = /* @__PURE__ */ (() => engagementPublishSchema.extend({
+  expectedVersion: identifier,
+  previewHash: identifier
+}))();
+var total = /* @__PURE__ */ (() => z.string().regex(/^(0|[1-9][0-9]*)$/))();
+var engagementChangePreviewSchema = /* @__PURE__ */ (() => z.strictObject({
+  rule: identifier,
+  fromVersion: identifier,
+  toVersion: identifier,
+  previewHash: identifier,
+  definition: engagementDefinitionSchema,
+  boundary: z.literal("available-eligible-observation"),
+  settlement: z.literal("deferred"),
+  summary: z.strictObject({
+    knownAdmissions: amount,
+    accounts: amount,
+    uninitialized: amount,
+    pendingTransitions: amount,
+    earned: total,
+    paid: total,
+    excluded: total,
+    pending: total
+  })
+}))();
+var engagementVersionSchema = /* @__PURE__ */ (() => engagementRuleSchema.extend({
+  previousVersion: identifier.nullable()
+}))();
+var engagementRuleVersionPageSchema = /* @__PURE__ */ (() => z.object({
+  items: z.array(
+    z.object({
+      version: identifier,
+      definition: z.object({
+        ...engagementDefinitionSchema.shape,
+        budgets: z.array(z.object(engagementBudgetSchema.shape)).max(8).default([])
+      }),
+      publishedAt: amount,
+      previousVersion: identifier.nullable()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var engagementVersionPageSchema = /* @__PURE__ */ (() => z.strictObject({
+  items: z.array(engagementVersionSchema),
+  next: amount.nullable()
+}))();
+var engagementVersionQuerySchema = /* @__PURE__ */ (() => z.strictObject({
+  rule: identifier,
+  before: z.coerce.number().int().positive().safe().optional()
+}))();
+var engagementBoundaryPageSchema = /* @__PURE__ */ (() => z.strictObject({
+  current: engagementRuleSchema.nullable(),
+  requested: engagementRuleSchema,
+  items: z.array(
+    z.strictObject({
+      from: identifier,
+      to: identifier,
+      baseline: contentMetricsSchema,
+      observedAt: amount,
+      settlement: engagementSettlementSchema
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var engagementArtifactSchema = /* @__PURE__ */ (() => engagementPublishSchema.omit({
+  actionId: true
+}))();
+var deploymentEntry = /* @__PURE__ */ (() => engagementArtifactSchema.extend({
+  rule: engagementRuleSchema
+}))();
+var engagementDeploymentEntrySchema = /* @__PURE__ */ (() => z.discriminatedUnion("kind", [
+  deploymentEntry.extend({ kind: z.literal("create") }),
+  deploymentEntry.extend({ kind: z.literal("unchanged") }),
+  deploymentEntry.extend({
+    kind: z.literal("change"),
+    change: engagementChangePreviewSchema
+  })
+]))();
+
+// src/referrals.ts
+import * as z2 from "zod";
+var rewardSchema = /* @__PURE__ */ (() => z2.union([pointsRewardSchema, tierRewardSchema]))();
+var amount2 = /* @__PURE__ */ (() => z2.number().int().safe().nonnegative())();
+var reason = /* @__PURE__ */ (() => z2.string().trim().min(1).max(1e3))();
+var referralDefinitionSchema = /* @__PURE__ */ (() => z2.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z2.string().trim().min(1).max(120),
+  enabled: z2.boolean().default(true),
+  qualification: z2.discriminatedUnion("kind", [
+    z2.object({ kind: z2.literal("signup") }).strict(),
+    z2.object({ kind: z2.literal("quest"), quest: identifier }).strict(),
+    z2.object({ kind: z2.literal("external") }).strict()
+  ]),
+  inviterGroup: identifier.optional(),
+  rewards: z2.object({
+    inviter: z2.array(rewardSchema).max(10).default([]),
+    invitee: z2.array(rewardSchema).max(10).default([])
+  }).strict().default({ inviter: [], invitee: [] }),
+  milestones: z2.array(
+    z2.object({
+      id: identifier,
+      count: amount2.min(1),
+      rewards: z2.array(rewardSchema).min(1).max(10)
+    }).strict()
+  ).max(30).default([]),
+  bonuses: z2.array(
+    z2.object({
+      id: identifier,
+      balance: identifier,
+      basisPoints: amount2.min(1).max(1e4),
+      quests: z2.array(identifier).min(1).max(100).optional(),
+      external: z2.boolean().default(false),
+      durationDays: amount2.min(1).max(36500).optional(),
+      maxPoints: amount2.min(1).optional()
+    }).strict()
+  ).max(20).default([])
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((e) => e.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule IDs must be unique" });
+    }
+  }
+}))();
+var referralAuthoringSchema = /* @__PURE__ */ (() => z2.object(referralDefinitionSchema.shape).omit({ id: true }).extend({
+  ...authoringIdentityShape,
+  inviterGroup: identifier.optional()
+}).strict().superRefine((value, ctx) => {
+  for (const entries of [value.milestones, value.bonuses]) {
+    if (new Set(entries.map((entry) => entry.id)).size !== entries.length) {
+      ctx.addIssue({ code: "custom", message: "Rule keys must be unique" });
+    }
+  }
+}))();
+var referralArtifactSchema = /* @__PURE__ */ (() => z2.union([
+  referralAuthoringSchema,
+  z2.object({ code: z2.string().min(1).max(2e6) }).strict()
+]))();
+var publishedReferralSchema = /* @__PURE__ */ (() => z2.object({
+  archivedAt: z2.number().int().nonnegative().nullable().optional(),
+  version: identifier,
+  definition: referralDefinitionSchema,
+  publishedAt: amount2,
+  actor: z2.string().nullable()
+}))();
+var referralAcceptSchema = /* @__PURE__ */ (() => z2.object({ actionId: identifier, code: identifier }).strict())();
+var referralSuspensionSchema = /* @__PURE__ */ (() => z2.object({ actionId: identifier, suspended: z2.boolean(), reason }).strict())();
+var referralQualificationSchema = /* @__PURE__ */ (() => z2.object({ actionId: identifier, qualified: z2.boolean(), reason }).strict())();
+var referralRewardResolutionSchema = /* @__PURE__ */ (() => z2.object({ actionId: identifier, reason }).strict())();
+var referralControlSchema = /* @__PURE__ */ (() => z2.discriminatedUnion("kind", [
+  z2.object({
+    kind: z2.literal("suspend"),
+    actionId: identifier,
+    member: identifier,
+    suspended: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("qualify"),
+    actionId: identifier,
+    member: identifier,
+    program: identifier,
+    qualified: z2.boolean(),
+    reason
+  }).strict(),
+  z2.object({
+    kind: z2.literal("resolve-reward"),
+    actionId: identifier,
+    entitlement: identifier,
+    reason
+  }).strict()
+]))();
+var referralRelationshipSchema = /* @__PURE__ */ (() => z2.object({
+  member: identifier,
+  inviter: identifier,
+  acceptedAt: amount2,
+  suspended: z2.boolean(),
+  /** The member import that recorded this referral, or null when the friend accepted an invitation. */
+  import: identifier.nullable().optional()
+}))();
+var referralAccountSchema = /* @__PURE__ */ (() => z2.object({
+  id: identifier,
+  program: identifier,
+  kind: z2.enum(["bonus", "fixed", "milestone"]),
+  balance: identifier,
+  earned: amount2,
+  settled: amount2,
+  outstanding: amount2
+}))();
+var referralSummarySchema = /* @__PURE__ */ (() => z2.object({
+  code: identifier,
+  attributed: amount2,
+  programs: z2.array(
+    z2.object({
+      definition: referralDefinitionSchema,
+      qualified: amount2,
+      milestones: z2.array(
+        z2.object({ id: identifier, count: amount2, reached: z2.boolean() })
+      )
+    })
+  ),
+  accounts: z2.array(referralAccountSchema)
+}))();
+var referralHistorySchema = /* @__PURE__ */ (() => z2.object({
+  items: z2.array(
+    z2.object({
+      id: amount2,
+      program: identifier,
+      balance: identifier,
+      amount: z2.number().int().safe(),
+      at: amount2,
+      reason: z2.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var referralManagementSchema = /* @__PURE__ */ (() => z2.object({
+  relationships: z2.array(referralRelationshipSchema),
+  qualifications: z2.array(
+    z2.object({
+      member: identifier,
+      program: identifier,
+      qualified: z2.boolean(),
+      qualifiedAt: amount2,
+      /** The member import that recorded this qualification, which paid no reward, or null. */
+      import: identifier.nullable().optional()
+    })
+  ),
+  accounts: z2.array(
+    referralAccountSchema.extend({ member: identifier, invitee: z2.string() })
+  ),
+  reviews: z2.array(
+    z2.object({
+      entitlement: identifier,
+      member: identifier,
+      program: identifier,
+      reason: z2.string()
+    })
+  ),
+  nextCursor: pageCursorSchema.nullable().default(null),
+  /** @deprecated Use `nextCursor`, passed back as `cursor`. Removed in 2.0.0. */
+  next: amount2.nullable()
+}))();
+
+// src/offers.ts
+import * as z3 from "zod";
+var quantity = /* @__PURE__ */ (() => z3.number().int().safe().nonnegative())();
+var offerPriceSchema = /* @__PURE__ */ (() => pointsRewardSchema.extend({
+  amount: z3.number().int().positive().max(maxPointsAmount)
+}))();
+var offerLimitSchema = /* @__PURE__ */ (() => z3.object({ perMember: z3.number().int().positive().max(1e4) }).strict())();
+var offerDefinitionSchema = /* @__PURE__ */ (() => z3.object({
+  id: identifier,
+  key: identifier.optional(),
+  title: z3.string().trim().min(1).max(120),
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  stock: quantity.max(1e6),
+  limit: offerLimitSchema.default({ perMember: 1 }),
+  /**
+   * What a member must meet to redeem, the same prerequisites quests take: `completed`,
+   * `balanceAtLeast` and `inGroup`. Checked when the member redeems; absent, anyone can.
+   */
+  requires: z3.array(prerequisiteSchema).max(30).optional(),
+  enabled: z3.boolean().default(true)
+}).strict())();
+var offerAuthoringSchema = /* @__PURE__ */ (() => offerDefinitionSchema.omit({ id: true, title: true, enabled: true }).extend({
+  ...authoringIdentityShape,
+  title: z3.string().trim().min(1).max(120).optional(),
+  // `defineOffer` returns `enabled: true`, and a deployment describes the module's default
+  // export and parses it again, so the output has to read back. Pause an offer in Console.
+  enabled: z3.literal(true).optional()
+}).strict().transform(({ enabled: _, ...offer }) => ({
+  ...offer,
+  title: offer.title ?? offer.reward.reward.title,
+  enabled: true
+})))();
+var offerArtifactSchema = /* @__PURE__ */ (() => z3.union([
+  offerAuthoringSchema,
+  z3.object({ code: z3.string().min(1).max(2e6) }).strict()
+]))();
+var offerAvailabilitySchema = /* @__PURE__ */ (() => responseShape(
+  z3.discriminatedUnion("kind", [
+    z3.object({ kind: z3.literal("available"), remaining: quantity }).strict(),
+    z3.object({ kind: z3.literal("out-of-stock") }).strict(),
+    z3.object({ kind: z3.literal("limit-reached") }).strict(),
+    z3.object({ kind: z3.literal("paused") }).strict()
+  ])
+))();
+var offerSchema = /* @__PURE__ */ (() => responseShape(
+  offerDefinitionSchema.extend({
+    revision: z3.number().int().positive(),
+    available: quantity,
+    redeemed: quantity,
+    availability: offerAvailabilitySchema,
+    /**
+     * When an operator archived the offer, or `null`. Only management reads carry it and list an
+     * archived offer; it refuses new redemptions with `offer-paused` until it is restored.
+     */
+    archivedAt: z3.number().int().nonnegative().nullable().optional(),
+    /**
+     * The prerequisites the signed-in member has not met yet, so an app can show the offer locked
+     * and why. Empty when nothing is missing or the read has no member; redeeming while it is not
+     * empty fails with `prerequisites-incomplete`.
+     */
+    missing: z3.array(missingPrerequisiteSchema).default([])
+  })
+))();
+var redeemOfferSchema = /* @__PURE__ */ (() => z3.object({ actionId: identifier }).strict())();
+var redemptionBase = /* @__PURE__ */ (() => ({
+  id: identifier,
+  offer: identifier,
+  member: identifier,
+  /**
+   * @deprecated Use `id` to refer to a redemption. A redemption is fulfilled in the request that
+   * makes it, so nothing is reserved beforehand; the ID refers to no other record. Removed in
+   * 2.0.0.
+   */
+  reservation: identifier,
+  price: offerPriceSchema,
+  reward: tierRewardSchema,
+  entitlement: identifier,
+  revision: z3.number().int().positive(),
+  redeemedAt: z3.number().int().safe().nonnegative()
+}))();
+var redemptionSchema = /* @__PURE__ */ (() => responseShape(
+  z3.discriminatedUnion("status", [
+    z3.object({ ...redemptionBase, status: z3.literal("fulfilled") }).strict(),
+    z3.object({
+      ...redemptionBase,
+      status: z3.literal("canceled"),
+      canceledAt: z3.number().int().safe().nonnegative(),
+      reason: z3.string().min(1).max(500)
+    }).strict()
+  ])
+))();
+var redemptionQuerySchema = /* @__PURE__ */ (() => z3.strictObject({
+  member: identifier.optional(),
+  cursor: pageCursorSchema.optional(),
+  limit: z3.coerce.number().int().min(1).max(100).optional()
+}))();
+var redemptionPageSchema = /* @__PURE__ */ (() => z3.object({
+  items: z3.array(redemptionSchema),
+  nextCursor: pageCursorSchema.nullable()
+}))();
+var offerControlSchema = /* @__PURE__ */ (() => z3.object({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  enabled: z3.boolean(),
+  reason: z3.string().trim().min(1).max(500)
+}).strict())();
+var redemptionCancellationSchema = /* @__PURE__ */ (() => z3.object({
+  actionId: identifier,
+  revision: z3.number().int().positive(),
+  reason: z3.string().trim().min(1).max(500)
+}).strict())();
+function defineOffer(input) {
+  return resourceHandle(
+    "offer",
+    parseDefinition("Offer", offerAuthoringSchema, input)
+  );
+}
+
+export {
+  engagementBudgetSchema,
+  engagementDefinitionSchema,
+  engagementScoreInputSchema,
+  engagementScoreSchema,
+  engagementPublishSchema,
+  engagementRuleSchema,
+  engagementPageQuerySchema,
+  engagementSettlementSchema,
+  engagementPageSchema,
+  engagementChangePreviewInputSchema,
+  engagementChangeSchema,
+  engagementChangePreviewSchema,
+  engagementRuleVersionPageSchema,
+  engagementVersionPageSchema,
+  engagementVersionQuerySchema,
+  engagementBoundaryPageSchema,
+  engagementArtifactSchema,
+  engagementDeploymentEntrySchema,
+  referralDefinitionSchema,
+  referralAuthoringSchema,
+  referralArtifactSchema,
+  publishedReferralSchema,
+  referralAcceptSchema,
+  referralSuspensionSchema,
+  referralQualificationSchema,
+  referralRewardResolutionSchema,
+  referralControlSchema,
+  referralRelationshipSchema,
+  referralAccountSchema,
+  referralSummarySchema,
+  referralHistorySchema,
+  referralManagementSchema,
+  offerPriceSchema,
+  offerLimitSchema,
+  offerDefinitionSchema,
+  offerAuthoringSchema,
+  offerArtifactSchema,
+  offerAvailabilitySchema,
+  offerSchema,
+  redeemOfferSchema,
+  redemptionSchema,
+  redemptionQuerySchema,
+  redemptionPageSchema,
+  offerControlSchema,
+  redemptionCancellationSchema,
+  defineOffer
+};

package/dist/chunk-TLSQETTY.js

@@ -0,0 +1,41 @@
+// src/youtube.ts
+import * as z from "zod";
+var youtubeShortBodySchema = /* @__PURE__ */ (() => z.object({
+  title: z.string(),
+  description: z.string(),
+  tags: z.array(z.string()),
+  durationSeconds: z.number().int().nonnegative(),
+  /** When the video was published, epoch milliseconds. */
+  publishedAt: z.number().int().nonnegative()
+}))();
+var youtubeShortMetrics = ["views", "likes", "comments"];
+
+// src/tiktok.ts
+import * as z2 from "zod";
+var tiktokVideoBodySchema = /* @__PURE__ */ (() => z2.object({
+  title: z2.string(),
+  /** The creator's caption, `video_description` in TikTok's API. */
+  description: z2.string(),
+  durationSeconds: z2.number().int().nonnegative(),
+  width: z2.number().int().nonnegative(),
+  height: z2.number().int().nonnegative(),
+  /** When the video was posted, epoch milliseconds. */
+  createdAt: z2.number().int().nonnegative(),
+  /** TikTok's shareable link to the video. */
+  shareUrl: z2.string(),
+  /** Whether the creator labelled the video as AI-generated content. */
+  isAigc: z2.boolean()
+}))();
+var tiktokVideoMetrics = [
+  "views",
+  "likes",
+  "comments",
+  "shares"
+];
+
+export {
+  youtubeShortBodySchema,
+  youtubeShortMetrics,
+  tiktokVideoBodySchema,
+  tiktokVideoMetrics
+};

package/dist/{chunk-MHPKEVEW.js → chunk-U66GUVSG.js}

@@ -20,6 +20,7 @@ var participantRoutes = [
   { method: "POST", path: "/v1/auth/logout" },
   { method: "GET", path: "/v1/auth/accounts" },
   { method: "GET", path: "/v1/auth/accounts/telegram" },
+  { method: "GET", path: "/v1/auth/sign-in-accounts" },
   { method: "GET", path: "/v1/auth/creator-accounts" },
   { method: "POST", path: "/v1/auth/accounts/disconnect" },
   { method: "POST", path: "/v1/auth/telegram/mini-app" },
@@ -52,6 +53,9 @@ var participantRoutes = [
   { method: "GET", path: "/v1/me/profile" },
   { method: "POST", path: "/v1/me/profile" },
   { method: "POST", path: "/v1/me/profile/avatar" },
+  // The member's marketing consent per channel.
+  { method: "GET", path: "/v1/me/consent" },
+  { method: "POST", path: "/v1/me/consent" },
   { method: "GET", path: `/v1/profiles/:profile${id}` },
   { method: "GET", path: `/v1/profiles/:profile${id}/completions` },
   {
@@ -85,6 +89,7 @@ var participantRoutes = [
   { method: "GET", path: `/v1/leaderboards/:board${id}` },
   { method: "GET", path: "/v1/point-ledgers" },
   { method: "GET", path: "/v1/badges" },
+  { method: "GET", path: "/v1/badges/catalog" },
   { method: "GET", path: "/v1/me/badges" },
   { method: "GET", path: "/v1/profiles/:profile{[\\w-]+}/badges" },
   { method: "GET", path: "/v1/tiered-rewards" }
@@ -105,10 +110,10 @@ function participantRoutePattern(path) {
   });
   return new RegExp("^" + source.join("") + "$");
 }
-var compiled = participantRoutes.map((route) => ({
+var compiled = /* @__PURE__ */ (() => participantRoutes.map((route) => ({
   ...route,
   pattern: participantRoutePattern(route.path)
-}));
+})))();
 function isParticipantRoute(path, method) {
   return compiled.some(
     (route) => route.method === method && route.pattern.test(path)

package/dist/{chunk-KDR2VAJP.js → chunk-UYVJZR33.js}

@@ -1,10 +1,10 @@
 // src/host-environment.ts
 import * as z from "zod";
 var hostEnvironmentPath = "/__domino/environment";
-var hostEnvironmentSchema = z.object({
+var hostEnvironmentSchema = /* @__PURE__ */ (() => z.object({
   environment: z.enum(["test", "live"]),
   kind: z.enum(["staging", "preview", "live"])
-});
+}))();
 var pending;
 async function readHostEnvironment() {
   try {

package/dist/chunk-UZ765UGH.js

@@ -0,0 +1,18 @@
+// src/origins.ts
+var loopbackHosts = [
+  "localhost",
+  "127.0.0.1",
+  "[::1]"
+];
+function secureOrLoopbackOrigin(url, options = {}) {
+  return url.protocol === "https:" || url.protocol === "http:" && (loopbackHosts.includes(url.hostname) || (options.localHosts ?? []).includes(url.hostname));
+}
+function bareOrigin(url) {
+  return !url.username && !url.password && !url.search && !url.hash && url.pathname === "/";
+}
+
+export {
+  loopbackHosts,
+  secureOrLoopbackOrigin,
+  bareOrigin
+};

package/dist/{chunk-7A4J67ZL.js → chunk-VWQGWGCH.js}

@@ -1,6 +1,6 @@
 import {
   capabilityFailureSchema
-} from "./chunk-4OC7REYX.js";
+} from "./chunk-MWMCQLCG.js";
 import {
   contentPerformanceSnapshotSchema,
   decisionSchema,
@@ -8,12 +8,12 @@ import {
   rewardBundleSchema,
   settingsValuesSchema,
   trackerTriggerContextSchema
-} from "./chunk-ZDJLPN4L.js";
+} from "./chunk-ID3BZXFZ.js";
 
 // src/server/attempt-captures.ts
 import * as z from "zod";
-var timestamp = z.number().int().nonnegative().safe();
-var capturedFactSchema = z.object({
+var timestamp = /* @__PURE__ */ (() => z.number().int().nonnegative().safe())();
+var capturedFactSchema = /* @__PURE__ */ (() => z.object({
   /** The call's position in the run, from 0. */
   sequence: z.number().int().nonnegative(),
   /** The capability request quest code sent, after validation. */
@@ -31,8 +31,8 @@ var capturedFactSchema = z.object({
    * did not keep, or a call without an answer. A replay cannot answer such a call.
    */
   captured: z.boolean()
-});
-var attemptCaptureSchema = z.object({
+}))();
+var attemptCaptureSchema = /* @__PURE__ */ (() => z.object({
   format: z.literal(1),
   attempt: identifier,
   environment: z.literal("test"),
@@ -71,7 +71,7 @@ var attemptCaptureSchema = z.object({
    * has decided nothing, and for runs decided before Relay kept decisions.
    */
   recorded: decisionSchema.nullable()
-});
+}))();
 
 export {
   capturedFactSchema,