@scalemule/news-publication 0.0.47 → 0.0.49

package/dist/pets-publication.d.cts

@@ -0,0 +1,36 @@
+import React__default from 'react';
+import { PetScope } from './pets-server.cjs';
+import { PetCommunity } from './pets.cjs';
+import '@scalemule/sdk';
+import './sponsorships-CtnBe3S8.cjs';
+
+/** Server rendering adapters. Publications keep their host routing, identity and credentials. */
+
+type PetPageQuery = {
+    community?: string;
+    after?: string;
+};
+declare function PublicationPetsSection({ scope, query, region, canonicalOrigin, defaultCommunity, walksUrl, cleanCaption, }: {
+    scope: PetScope;
+    query: PetPageQuery;
+    region: string;
+    canonicalOrigin: string;
+    defaultCommunity?: string;
+    walksUrl?: string;
+    cleanCaption?: (caption: string) => string;
+}): Promise<React__default.JSX.Element>;
+declare function PublicationPetReferences({ scope, metadata, canonicalOrigin, communities, cleanCaption, }: {
+    scope: PetScope;
+    metadata: unknown;
+    canonicalOrigin: string;
+    communities?: PetCommunity[];
+    cleanCaption?: (value: string) => string;
+}): Promise<React__default.JSX.Element | null>;
+/** Extends the existing publication calendar with reviewed source references. */
+declare function PublicationPetEvents({ scope, canonicalOrigin, cleanCaption, }: {
+    scope: PetScope;
+    canonicalOrigin: string;
+    cleanCaption?: (value: string) => string;
+}): Promise<React__default.JSX.Element | null>;
+
+export { type PetPageQuery, PublicationPetEvents, PublicationPetReferences, PublicationPetsSection };

package/dist/pets-publication.d.ts

@@ -0,0 +1,36 @@
+import React__default from 'react';
+import { PetScope } from './pets-server.js';
+import { PetCommunity } from './pets.js';
+import '@scalemule/sdk';
+import './sponsorships-CtnBe3S8.js';
+
+/** Server rendering adapters. Publications keep their host routing, identity and credentials. */
+
+type PetPageQuery = {
+    community?: string;
+    after?: string;
+};
+declare function PublicationPetsSection({ scope, query, region, canonicalOrigin, defaultCommunity, walksUrl, cleanCaption, }: {
+    scope: PetScope;
+    query: PetPageQuery;
+    region: string;
+    canonicalOrigin: string;
+    defaultCommunity?: string;
+    walksUrl?: string;
+    cleanCaption?: (caption: string) => string;
+}): Promise<React__default.JSX.Element>;
+declare function PublicationPetReferences({ scope, metadata, canonicalOrigin, communities, cleanCaption, }: {
+    scope: PetScope;
+    metadata: unknown;
+    canonicalOrigin: string;
+    communities?: PetCommunity[];
+    cleanCaption?: (value: string) => string;
+}): Promise<React__default.JSX.Element | null>;
+/** Extends the existing publication calendar with reviewed source references. */
+declare function PublicationPetEvents({ scope, canonicalOrigin, cleanCaption, }: {
+    scope: PetScope;
+    canonicalOrigin: string;
+    cleanCaption?: (value: string) => string;
+}): Promise<React__default.JSX.Element | null>;
+
+export { type PetPageQuery, PublicationPetEvents, PublicationPetReferences, PublicationPetsSection };

package/dist/pets-publication.js

@@ -0,0 +1,177 @@
+import { PetsSection, PawOfTheWeekCard, AdoptionListingCard, PetEventCard, PetCelebrationCard, LostPetNotice, PetProfileCard } from './chunk-TTLM7YOH.js';
+import './chunk-4JRWZXAP.js';
+import { petRequest, petAcknowledgments, resolvePetReferences } from './chunk-ZXH3O537.js';
+import './chunk-66GI2IX6.js';
+import { resolvePetCommunity } from './chunk-MBBPEFDA.js';
+import { jsx, jsxs } from 'react/jsx-runtime';
+import { createElement } from 'react';
+
+async function PublicationPetsSection({
+  scope,
+  query,
+  region,
+  canonicalOrigin,
+  defaultCommunity,
+  walksUrl,
+  cleanCaption = (v) => v
+}) {
+  const root = `/v1/knowledge/community-maps/collections/${scope.collectionSlug}`;
+  const mediaUrl = (id, photo) => `/api/pets/${id}/media/${photo}`;
+  try {
+    const collection = await petRequest(scope, root);
+    const home = defaultCommunity || collection.areas.find(
+      (area) => area.name.toLocaleLowerCase() === region.toLocaleLowerCase()
+    )?.id;
+    const chosen = resolvePetCommunity(
+      collection.areas,
+      query.community,
+      void 0,
+      home
+    );
+    const filter = new URLSearchParams();
+    if (chosen) filter.set("area_id", chosen.id);
+    if (query.after) filter.set("after", query.after);
+    const date = new Intl.DateTimeFormat("en-CA", {
+      timeZone: "America/Los_Angeles",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit"
+    }).format(/* @__PURE__ */ new Date());
+    const monday = /* @__PURE__ */ new Date(date + "T12:00:00Z");
+    monday.setUTCDate(monday.getUTCDate() - (monday.getUTCDay() + 6) % 7);
+    const weekly = new URLSearchParams({
+      kind: "spotlight",
+      week: monday.toISOString().split("T")[0]
+    });
+    if (chosen) weekly.set("area_id", chosen.id);
+    const [feeds, spotlights] = await Promise.all([
+      Promise.all(
+        ["neighbors", "lost_found", "celebration", "adoption"].map((kind) => {
+          const q = new URLSearchParams(filter);
+          q.set("kind", kind);
+          q.set("limit", "6");
+          return petRequest(
+            scope,
+            root + "/pets?" + q
+          );
+        })
+      ),
+      petRequest(scope, root + "/pets?" + weekly)
+    ]);
+    const clean = (r) => ({
+      ...r,
+      media: r.media.map((m) => ({
+        ...m,
+        caption: cleanCaption(m.caption),
+        attribution: cleanCaption(m.attribution)
+      }))
+    });
+    const local = chosen ? "?community=" + encodeURIComponent(chosen.slug) : "";
+    return /* @__PURE__ */ jsx(
+      PetsSection,
+      {
+        basePath: "/pets",
+        regionLabel: region,
+        resourceBasePath: canonicalOrigin + "/pets",
+        communities: collection.areas,
+        community: chosen,
+        acknowledgments: await petAcknowledgments(scope, chosen?.slug),
+        resources: feeds.flatMap((feed) => feed.items).map(clean),
+        spotlight: spotlights.items[0] && clean(spotlights.items[0]),
+        mediaUrl,
+        contributeUrl: canonicalOrigin + "/submit" + local,
+        placesUrl: canonicalOrigin + "/places" + local,
+        walksUrl,
+        browseBasePath: canonicalOrigin + "/browse",
+        eventsUrl: canonicalOrigin + "/events"
+      }
+    );
+  } catch {
+    return /* @__PURE__ */ jsx(
+      PetsSection,
+      {
+        communities: [],
+        resources: [],
+        mediaUrl,
+        regionLabel: region,
+        unavailable: true
+      }
+    );
+  }
+}
+async function PublicationPetReferences({
+  scope,
+  metadata,
+  canonicalOrigin,
+  communities,
+  cleanCaption = (v) => v
+}) {
+  let resources;
+  try {
+    resources = await resolvePetReferences(scope, metadata);
+  } catch {
+    return /* @__PURE__ */ jsx("p", { children: "Linked pet resources are temporarily unavailable." });
+  }
+  if (!resources.length) return null;
+  return /* @__PURE__ */ jsx("section", { className: "paw", "aria-label": "Related community pet resources", children: resources.map((resource) => {
+    const props = {
+      resource: {
+        ...resource,
+        media: resource.media.map((m) => ({
+          ...m,
+          caption: cleanCaption(m.caption),
+          attribution: cleanCaption(m.attribution)
+        }))
+      },
+      community: communities?.find((c) => c.id === resource.area_id)?.name || "Our community",
+      href: `${canonicalOrigin}/pets/${resource.id}`,
+      mediaUrl: (id, photo) => `/api/pets/${id}/media/${photo}`
+    };
+    const Card = resource.kind === "spotlight" ? PawOfTheWeekCard : resource.kind === "adoption" ? AdoptionListingCard : resource.kind === "event" ? PetEventCard : resource.kind === "celebration" ? PetCelebrationCard : ["lost", "found"].includes(resource.kind) ? LostPetNotice : PetProfileCard;
+    return /* @__PURE__ */ createElement(Card, { ...props, key: resource.id });
+  }) });
+}
+async function PublicationPetEvents({
+  scope,
+  canonicalOrigin,
+  cleanCaption = (value) => value
+}) {
+  try {
+    const query = new URLSearchParams({
+      kind: "event",
+      limit: "6",
+      starts_after: (/* @__PURE__ */ new Date()).toISOString(),
+      starts_before: new Date(Date.now() + 7 * 864e5).toISOString()
+    });
+    const { items } = await petRequest(
+      scope,
+      `/v1/knowledge/community-maps/collections/${scope.collectionSlug}/pets?${query}`
+    );
+    if (!items.length) return null;
+    return /* @__PURE__ */ jsxs("section", { className: "paw paw-section", "aria-label": "Pet events this week", children: [
+      /* @__PURE__ */ jsx("h2", { children: "This week for pets and their people" }),
+      /* @__PURE__ */ jsx("div", { className: "paw-gallery", children: items.map((resource) => /* @__PURE__ */ jsx(
+        PetEventCard,
+        {
+          resource: {
+            ...resource,
+            media: resource.media.map((photo) => ({
+              ...photo,
+              caption: cleanCaption(photo.caption),
+              attribution: cleanCaption(photo.attribution)
+            }))
+          },
+          community: "Our community",
+          href: `${canonicalOrigin}/pets/${resource.id}`,
+          mediaUrl: (id, media) => `/api/pets/${id}/media/${media}`
+        },
+        resource.id
+      )) }),
+      /* @__PURE__ */ jsx("a", { href: canonicalOrigin + "/events", children: "Browse the pet community calendar" })
+    ] });
+  } catch {
+    return /* @__PURE__ */ jsx("p", { role: "status", children: "Pet event listings are temporarily unavailable." });
+  }
+}
+
+export { PublicationPetEvents, PublicationPetReferences, PublicationPetsSection };

package/dist/pets-server.cjs

@@ -0,0 +1,289 @@
+'use strict';
+
+var sdk = require('@scalemule/sdk');
+
+// src/pets-server.ts
+
+// src/pets.ts
+var PET_KINDS = [
+  "profile",
+  "spotlight",
+  "photo",
+  "celebration",
+  "lost",
+  "found",
+  "adoption",
+  "event"
+];
+var PET_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var PET_SLUG = /^[a-z0-9][a-z0-9-]{0,190}$/;
+function petReferences(metadata) {
+  const entries = metadata && typeof metadata === "object" ? metadata.pet_resources : null;
+  if (!Array.isArray(entries)) return [];
+  return entries.slice(0, 12).flatMap((v) => {
+    if (!v || typeof v !== "object") return [];
+    const r = v;
+    return typeof r.collection_slug === "string" && PET_SLUG.test(r.collection_slug) && typeof r.id === "string" && PET_UUID.test(r.id) && PET_KINDS.includes(r.kind) ? [
+      {
+        collection_slug: r.collection_slug,
+        id: r.id,
+        kind: r.kind
+      }
+    ] : [];
+  });
+}
+
+// src/pets-server.ts
+var PetRequestError = class extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+};
+var petPrivateHeaders = {
+  "cache-control": "private, no-store",
+  "x-robots-tag": "noindex, nofollow",
+  "referrer-policy": "no-referrer",
+  "x-content-type-options": "nosniff"
+};
+async function bounded(request, max) {
+  if (Number(request.headers.get("content-length")) > max)
+    throw new PetRequestError(413, "The submission is too large.");
+  const reader = request.body?.getReader();
+  if (!reader) return new Uint8Array();
+  const parts = [];
+  let size = 0;
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.length;
+      if (size > max) {
+        await reader.cancel();
+        throw new PetRequestError(413, "The submission is too large.");
+      }
+      parts.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(parts);
+}
+function config(scope) {
+  const url = new URL(scope.gatewayUrl);
+  if (!scope.apiKey || !PET_SLUG.test(scope.collectionSlug) || url.username || url.password || url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1"].includes(url.hostname)))
+    throw new PetRequestError(503, "The pet community is not available yet.");
+  return url.origin;
+}
+async function petRequest(scope, path, init = {}, fetcher = fetch) {
+  const gateway = config(scope);
+  if (!path.startsWith("/v1/") || path.includes("..") || /[\\\r\n]/.test(path))
+    throw new Error("Invalid platform path");
+  const response = await fetcher(gateway + path, {
+    method: init.method || "GET",
+    headers: {
+      ...sdk.buildClientContextHeaders(scope.clientContext),
+      "x-api-key": scope.apiKey,
+      "content-type": "application/json",
+      ...scope.accessToken ? { authorization: `Bearer ${scope.accessToken}` } : {}
+    },
+    body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+    cache: "no-store",
+    redirect: "error",
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok)
+    throw new PetRequestError(
+      response.status,
+      response.status === 401 ? "Please sign in to continue." : response.status === 404 ? "This pet resource is not available." : response.status === 409 ? "This contribution changed. Reload before saving." : response.status === 429 ? "Please wait before trying again." : "We couldn\u2019t complete that request. Please try again."
+    );
+  const json = await response.json();
+  return json?.data ?? json;
+}
+function createPublicationPetsHandler(options) {
+  const fetcher = options.fetch || fetch;
+  return async function handler(request, path) {
+    const json = (data, status = 200) => Response.json(data, { status, headers: petPrivateHeaders });
+    try {
+      const scope = await options.resolve(request), gateway = config(scope), method = request.method;
+      const root = `/v1/knowledge/community-maps/collections/${scope.collectionSlug}`;
+      const id = path[0] && PET_UUID.test(path[0]);
+      const isMedia = id && path.length === 3 && path[1] === "media" && PET_UUID.test(path[2]);
+      const upload = path.length === 3 && path[0] === "submissions" && PET_UUID.test(path[1]) && path[2] === "media";
+      const ownMedia = path.length === 4 && path[0] === "submissions" && PET_UUID.test(path[1]) && path[2] === "media" && PET_UUID.test(path[3]);
+      const own = path[0] === "mine" && (path.length === 1 || path.length === 2 && PET_UUID.test(path[1]));
+      const preferences = path.length === 1 && path[0] === "preferences";
+      const reaction = id && path.length === 2 && path[1] === "reaction";
+      const report = id && path.length === 2 && path[1] === "reports";
+      const publicRead = method === "GET" && (!path.length || id && path.length === 1 || isMedia || path.length === 1 && path[0] === "community");
+      const read = publicRead || method === "GET" && (own || ownMedia || preferences || reaction);
+      const write = method === "POST" && (!path.length || upload || report || id && path.length === 2 && path[1] === "reunited") || method === "PUT" && (preferences || reaction) || ["PUT", "DELETE"].includes(method) && id && path.length === 1;
+      if (!read && !write) return json({ error: "Route not found" }, 404);
+      if (write && (!scope.writesEnabled || request.headers.get("origin") !== new URL(scope.origin).origin))
+        return json(
+          { error: "Continue from the pet community\u2019s official website." },
+          403
+        );
+      if ((write || own || ownMedia || preferences || reaction) && !scope.accessToken)
+        return json({ error: "Sign in to continue." }, 401);
+      let endpoint = root + (path[0] === "community" ? "" : upload || ownMedia ? "/" + path.join("/") : "/pets" + (path.length ? "/" + path.join("/") : ""));
+      const query = new URLSearchParams();
+      if (method === "GET" && !path.length)
+        for (const key of [
+          "area_id",
+          "kind",
+          "after",
+          "week",
+          "limit",
+          "category",
+          "species",
+          "event_type",
+          "cost",
+          "starts_after",
+          "starts_before"
+        ]) {
+          const value = new URL(request.url).searchParams.get(key);
+          if (value) query.set(key, value);
+        }
+      if (own) {
+        const after = new URL(request.url).searchParams.get("after");
+        if (after && PET_UUID.test(after)) query.set("after", after);
+      }
+      if (query.size) endpoint += "?" + query;
+      if (isMedia) {
+        const imageQuery = new URLSearchParams();
+        const sourceQuery = new URL(request.url).searchParams;
+        if (["640", "1280"].includes(sourceQuery.get("width") || ""))
+          imageQuery.set("width", sourceQuery.get("width"));
+        if (["jpeg", "webp"].includes(sourceQuery.get("format") || ""))
+          imageQuery.set("format", sourceQuery.get("format"));
+        if (imageQuery.size) endpoint += "?" + imageQuery;
+      }
+      if (isMedia || upload || ownMedia) {
+        let body2;
+        const type = request.headers.get("content-type") || "";
+        if (upload) {
+          if (!type.startsWith("multipart/form-data;"))
+            throw new PetRequestError(415, "Choose a photograph.");
+          body2 = await bounded(request, 9 * 1024 * 1024);
+        }
+        const response = await fetcher(gateway + endpoint, {
+          method,
+          headers: {
+            ...sdk.buildClientContextHeaders(scope.clientContext),
+            "x-api-key": scope.apiKey,
+            ...scope.accessToken ? { authorization: `Bearer ${scope.accessToken}` } : {},
+            ...upload ? { "content-type": type } : {}
+          },
+          body: body2,
+          cache: "no-store",
+          redirect: "error",
+          signal: AbortSignal.timeout(45e3)
+        });
+        if (!response.ok) {
+          await response.body?.cancel();
+          return json(
+            {
+              error: "The photograph is unavailable. Check its size and try again."
+            },
+            response.status >= 500 ? 503 : response.status
+          );
+        }
+        if (upload) return json(await response.json());
+        const imageType = response.headers.get("content-type")?.split(";")[0] || "";
+        if (!["image/png", "image/jpeg", "image/webp"].includes(imageType)) {
+          await response.body?.cancel();
+          return json({ error: "Photograph unavailable" }, 404);
+        }
+        return new Response(response.body, {
+          headers: { ...petPrivateHeaders, "content-type": imageType }
+        });
+      }
+      let body;
+      if (write) {
+        if (!request.headers.get("content-type")?.startsWith("application/json"))
+          throw new PetRequestError(415, "Use the pet contribution form.");
+        try {
+          body = JSON.parse(
+            new TextDecoder().decode(await bounded(request, 32768))
+          );
+        } catch (error) {
+          if (error instanceof PetRequestError) throw error;
+          throw new PetRequestError(400, "Check the contribution fields.");
+        }
+      }
+      return json({
+        data: await petRequest(scope, endpoint, { method, body }, fetcher)
+      });
+    } catch (error) {
+      return json(
+        {
+          error: error instanceof PetRequestError ? error.message : "The pet community is temporarily unavailable."
+        },
+        error instanceof PetRequestError ? error.status : 503
+      );
+    }
+  };
+}
+async function resolvePetReferences(scope, metadata, fetcher = fetch) {
+  const references = petReferences(metadata).filter(
+    (ref) => ref.collection_slug === scope.collectionSlug
+  );
+  const results = await Promise.all(
+    references.map(async (ref) => {
+      try {
+        const resource = await petRequest(
+          { ...scope, accessToken: void 0 },
+          `/v1/knowledge/community-maps/collections/${ref.collection_slug}/pets/${ref.id}`,
+          {},
+          fetcher
+        );
+        return resource.kind === ref.kind ? resource : null;
+      } catch (error) {
+        if (error instanceof PetRequestError && [403, 404].includes(error.status))
+          return null;
+        throw error;
+      }
+    })
+  );
+  return results.filter(
+    (resource) => resource !== null
+  );
+}
+async function petAcknowledgments(scope, community, productPath = "/pets", fetcher = fetch) {
+  if (!scope.publicationId || !PET_UUID.test(scope.publicationId)) return [];
+  try {
+    const groups = await Promise.all(
+      ["community_partner", "community_guide"].map(
+        async (placement) => {
+          const query = new URLSearchParams({
+            placement_type: placement,
+            product_path: productPath
+          });
+          if (community) query.set("community", community);
+          const response = await petRequest(
+            { ...scope, accessToken: void 0 },
+            `/v1/blog/publications/${scope.publicationId}/sponsorships/delivery?${query}`,
+            {},
+            fetcher
+          );
+          return response.items.filter(
+            (item) => item.publication_id === scope.publicationId && item.placement_type === placement
+          );
+        }
+      )
+    );
+    return groups.flat().slice(0, 2);
+  } catch {
+    console.warn("paw.sponsorship_delivery_unavailable");
+    return [];
+  }
+}
+
+exports.PetRequestError = PetRequestError;
+exports.createPublicationPetsHandler = createPublicationPetsHandler;
+exports.petAcknowledgments = petAcknowledgments;
+exports.petPrivateHeaders = petPrivateHeaders;
+exports.petRequest = petRequest;
+exports.resolvePetReferences = resolvePetReferences;

package/dist/pets-server.d.cts

@@ -0,0 +1,42 @@
+import { ClientContext } from '@scalemule/sdk';
+import { P as PublicAcknowledgment } from './sponsorships-CtnBe3S8.cjs';
+import { PetResource } from './pets.cjs';
+
+/** Server-only, publication-scoped proxy. Never import credentials into a client component. */
+
+type PetScope = {
+    apiKey: string;
+    gatewayUrl: string;
+    origin: string;
+    collectionSlug: string;
+    publicationId?: string;
+    accessToken?: string;
+    clientContext: ClientContext;
+    writesEnabled?: boolean;
+};
+declare class PetRequestError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+declare const petPrivateHeaders: {
+    "cache-control": string;
+    "x-robots-tag": string;
+    "referrer-policy": string;
+    "x-content-type-options": string;
+};
+declare function petRequest<T>(scope: PetScope, path: string, init?: {
+    method?: string;
+    body?: unknown;
+}, fetcher?: typeof fetch): Promise<T>;
+declare function createPublicationPetsHandler(options: {
+    resolve(request: Request): Promise<PetScope>;
+    fetch?: typeof fetch;
+}): (request: Request, path: string[]) => Promise<Response>;
+/** Resolve article references at render time through the publication's accepted view.
+ * Withdrawing a resource removes its embedded card; articles never cache private snapshots. */
+declare function resolvePetReferences(scope: PetScope, metadata: unknown, fetcher?: typeof fetch): Promise<PetResource[]>;
+/** The existing campaign service owns approval, agreements, geography and reporting.
+ * No campaign is inferred from a logo, partner prospect or submitted pet content. */
+declare function petAcknowledgments(scope: PetScope, community?: string, productPath?: string, fetcher?: typeof fetch): Promise<PublicAcknowledgment[]>;
+
+export { PetRequestError, type PetScope, createPublicationPetsHandler, petAcknowledgments, petPrivateHeaders, petRequest, resolvePetReferences };

package/dist/pets-server.d.ts

@@ -0,0 +1,42 @@
+import { ClientContext } from '@scalemule/sdk';
+import { P as PublicAcknowledgment } from './sponsorships-CtnBe3S8.js';
+import { PetResource } from './pets.js';
+
+/** Server-only, publication-scoped proxy. Never import credentials into a client component. */
+
+type PetScope = {
+    apiKey: string;
+    gatewayUrl: string;
+    origin: string;
+    collectionSlug: string;
+    publicationId?: string;
+    accessToken?: string;
+    clientContext: ClientContext;
+    writesEnabled?: boolean;
+};
+declare class PetRequestError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+declare const petPrivateHeaders: {
+    "cache-control": string;
+    "x-robots-tag": string;
+    "referrer-policy": string;
+    "x-content-type-options": string;
+};
+declare function petRequest<T>(scope: PetScope, path: string, init?: {
+    method?: string;
+    body?: unknown;
+}, fetcher?: typeof fetch): Promise<T>;
+declare function createPublicationPetsHandler(options: {
+    resolve(request: Request): Promise<PetScope>;
+    fetch?: typeof fetch;
+}): (request: Request, path: string[]) => Promise<Response>;
+/** Resolve article references at render time through the publication's accepted view.
+ * Withdrawing a resource removes its embedded card; articles never cache private snapshots. */
+declare function resolvePetReferences(scope: PetScope, metadata: unknown, fetcher?: typeof fetch): Promise<PetResource[]>;
+/** The existing campaign service owns approval, agreements, geography and reporting.
+ * No campaign is inferred from a logo, partner prospect or submitted pet content. */
+declare function petAcknowledgments(scope: PetScope, community?: string, productPath?: string, fetcher?: typeof fetch): Promise<PublicAcknowledgment[]>;
+
+export { PetRequestError, type PetScope, createPublicationPetsHandler, petAcknowledgments, petPrivateHeaders, petRequest, resolvePetReferences };

package/dist/pets-server.js

@@ -0,0 +1,2 @@
+export { PetRequestError, createPublicationPetsHandler, petAcknowledgments, petPrivateHeaders, petRequest, resolvePetReferences } from './chunk-ZXH3O537.js';
+import './chunk-MBBPEFDA.js';