@scalemule/news-publication 0.0.48 → 0.0.50

package/README.md

@@ -245,3 +245,57 @@ publication must validate that return path and preserve it through sign-in.
 Inventory is unavailable until a verified operational placement is active. `placementAvailable` enforces verification freshness and keeps paid briefings disabled. Campaign approval, authorization, allocation capacity and manual commercial references remain server responsibilities. Report HTML distinguishes observed counts from unavailable data and can be printed or rendered to PDF. No invoice or payment is initiated by this SDK.
 
 The consent banner now offers a choice in every geography where optional measurement requires one. `measurementConsent` is the server gate for current, explicitly allowed categories and GPC/DNT. Positive permission is local: unsigned URL parameters and a binary network hub cannot grant all categories. Rendering sponsorship recognition does not require tracking consent; measuring it requires both performance and advertising permission.
+
+## Community pet sections
+
+The `pets`, `pets-view`, `pets-forms`, `pets-interactions`, `pets-server`,
+`pets-auth-server`, and `pets-publication` entry points add typed, moderated pet
+resources to existing Community Maps collections. Import `pets.css` for the
+scoped presentation. Server adapters require each application's own API key;
+never pass credentials or a `PetScope` to a client component.
+
+`PublicationPetsSection` resolves an accepted collection view and its coverage.
+`PublicationPetReferences` resolves `metadata.pet_resources` at render time:
+each reference has `collection_slug`, the API-returned `id`, and `kind`.
+Removed/private resources are omitted; article records need no copied pet data.
+`PublicationPetEvents` extends the existing publication calendar with reviewed
+pet event references and official registration links. Meet's optional `walk`
+field extends its existing dog-walk activity without creating another join system.
+
+`createPawAuthHandler` delegates authentication to the platform's supported
+Ledvery OIDC flow. Enable it only after configuring and testing the application
+client and callback. `createPublicationPetsHandler` restricts routes, requires
+same-origin authenticated writes, and proxies visibility-checked photographs.
+Approved sponsorships come from existing Blog campaign delivery and reporting.
+There is no fictional sponsor fallback and no public demonstration inventory.
+
+Private recovery contact and broad community alert delivery are not implemented
+by these components. Notification controls default to disabled. The canonical
+application, collections, publication views and legitimate source content must
+be provisioned separately before launch.
+
+### Native pet plugin and shared sign-in
+
+`pets-plugin` exports `PetAccountPage`, `PetSubmitPage`, `PetStoryPage` and
+`PetBrowsePage`, with `publicationPetPaths` or `standalonePetPaths`. These are
+server components: give them the publication’s `PetScope` resolved on the server
+and its current reader token. Mount publication pages at `/pets/account`,
+`/pets/submit`, `/pets/:id` and `/pets/browse/:kind`. `native` on the publication
+section, references and calendar keeps resource links inside the publication.
+
+Configure `createPawAuthHandler` with the host’s existing `sessionCookie`,
+`callbackPath` and `accountPath`. An existing callback should dispatch to this
+handler only when `openPawFlow(pawCookie(request, PAW_FLOW_COOKIE), state, key)`
+validates. Otherwise preserve the publication’s normal authentication flow.
+`GET resume?next=...` makes a top-level `prompt=none` attempt; protected pages
+should call it only when the session is absent/invalid, `signin` is absent and
+`PAW_SIGNED_OUT_COOKIE` is absent. Failed continuity returns `signin=required`
+or `signin=retry`, preventing redirect loops. Explicit `POST start` opens the
+normal sign-in. Honor and clear the sign-out marker in existing host login/logout
+flows. All cookies remain host-only; do not embed the sign-in in an iframe.
+
+The collection must explicitly set `shared_identity_provider` to its configured
+OIDC provider. Auth resolves the verified provider subject; Knowledge authorizes
+each accepted view and keeps ownership collection-scoped. Never correlate local
+users by email or forward one application’s reader token/API key to another.
+Provision and verify each RP before enabling sign-in or contribution flags.

package/dist/chunk-4JRWZXAP.js

@@ -0,0 +1,62 @@
+import { safeSponsorUrl } from './chunk-66GI2IX6.js';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+function SponsorAcknowledgment({
+  creative,
+  label = "Community Partner",
+  preview = false,
+  acknowledgment
+}) {
+  const logo = safeSponsorUrl(creative.logo_url);
+  const destination = safeSponsorUrl(creative.destination_url);
+  return /* @__PURE__ */ jsxs(
+    "aside",
+    {
+      className: "sm-sponsorship",
+      "aria-label": `${label}: ${creative.name}`,
+      "data-sponsorship": preview ? void 0 : acknowledgment?.campaign_id,
+      "data-placement-id": preview ? void 0 : acknowledgment?.placement_id,
+      "data-publication-id": preview ? void 0 : acknowledgment?.publication_id,
+      "data-sponsor-id": preview ? void 0 : acknowledgment?.sponsor_id,
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "sm-sponsorship-copy", children: [
+          /* @__PURE__ */ jsxs("p", { className: "sm-sponsorship-label", children: [
+            label,
+            preview ? " \xB7 Illustrative preview" : ""
+          ] }),
+          /* @__PURE__ */ jsx("p", { className: "sm-sponsorship-name", children: creative.name }),
+          creative.description && /* @__PURE__ */ jsx("p", { className: "sm-sponsorship-description", children: creative.description }),
+          destination && /* @__PURE__ */ jsxs(
+            "a",
+            {
+              href: destination,
+              rel: "sponsored noopener noreferrer",
+              referrerPolicy: "no-referrer",
+              "data-analytics-skip": "true",
+              children: [
+                creative.link_label || "Learn more",
+                /* @__PURE__ */ jsxs("span", { className: "sm-sponsorship-sr", children: [
+                  " about ",
+                  creative.name
+                ] })
+              ]
+            }
+          )
+        ] }),
+        logo && /* @__PURE__ */ jsx(
+          "img",
+          {
+            src: logo,
+            alt: `${creative.name} logo`,
+            loading: "lazy",
+            decoding: "async",
+            referrerPolicy: "no-referrer",
+            className: "sm-sponsorship-logo"
+          }
+        )
+      ]
+    }
+  );
+}
+
+export { SponsorAcknowledgment };

package/dist/chunk-ABPJMDUG.js

@@ -0,0 +1,251 @@
+import { PET_UUID, petReferences, PET_SLUG } from './chunk-AFJ6S5WJ.js';
+import { buildClientContextHeaders } from '@scalemule/sdk';
+
+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: {
+      ...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: {
+            ...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 [];
+  }
+}
+
+export { PetRequestError, createPublicationPetsHandler, petAcknowledgments, petPrivateHeaders, petRequest, resolvePetReferences };

package/dist/chunk-AFJ6S5WJ.js

@@ -0,0 +1,124 @@
+// src/pets.ts
+var PET_KINDS = [
+  "profile",
+  "spotlight",
+  "photo",
+  "celebration",
+  "lost",
+  "found",
+  "adoption",
+  "event"
+];
+var PET_NOTIFICATION_CATEGORIES = [
+  ["lost_found", "Lost & found"],
+  ["walks", "Paw Walks"],
+  ["adoption_events", "Adoption events"],
+  ["celebrations", "Pet celebrations"],
+  ["spotlight", "Paw of the Week"],
+  ["community", "Community information"]
+];
+var PET_PHOTO_CATEGORIES = [
+  ["cute", "Cute pets"],
+  ["funny", "Funny moments"],
+  ["adventures", "Adventures"],
+  ["senior", "Senior pets"],
+  ["rescue", "Rescue stories"],
+  ["young", "Puppies & kittens"],
+  ["unusual", "Unusual pets"],
+  ["friends", "Best friends"],
+  ["holiday", "Holiday pets"]
+];
+var PET_CELEBRATIONS = [
+  ["birthday", "Pet birthday"],
+  ["adoption_anniversary", "Adoption anniversary"],
+  ["welcome_home", "Welcome home"],
+  ["rescue_story", "Rescue story"],
+  ["happy_reunion", "Happy reunion"],
+  ["memorial", "Memorial tribute"]
+];
+var PET_SAFETY = {
+  recovery: "Bay Area Paw does not independently verify pet ownership. A report is a contributor\u2019s account. Never send money or verification codes to someone claiming to have found a pet. Keep microchip numbers and ownership evidence private.",
+  walks: "Walks are independently organized. Bay Area Paw does not supervise meetups or guarantee participants\u2019 safety. Meet in a public place, follow leash rules and respect other people and animals.",
+  adoption: "Contact the named shelter or rescue for current availability, eligibility and adoption arrangements. Bay Area Paw is not the adoption agency and does not collect adoption payments.",
+  wellness: "Wellness information is educational. Contact a veterinarian for advice about your pet."
+};
+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
+      }
+    ] : [];
+  });
+}
+function resolvePetCommunity(areas, selected, preference, publicationDefault) {
+  if (selected === "" || selected === void 0 && preference === "all") return void 0;
+  for (const candidate of [selected, preference, publicationDefault]) {
+    const found = areas.find(
+      (area) => area.id === candidate || area.slug === candidate
+    );
+    if (found) return found;
+  }
+  return void 0;
+}
+function safePetLink(raw) {
+  if (raw.startsWith("/") && !raw.startsWith("//") && !/[\\\r\n]/.test(raw))
+    return raw;
+  try {
+    const url = new URL(raw);
+    return url.protocol === "https:" && !url.username && !url.password ? url.href : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function adoptionAvailability(source, now = Date.now()) {
+  const at = source?.verified_at ? Date.parse(source.verified_at) : NaN;
+  return source?.availability_confirmed && Number.isFinite(at) && at <= now && now - at <= 864e5 ? "confirmed" : "check_with_organization";
+}
+function petProfileMetadata(resource, canonicalUrl, photoUrl) {
+  const canonical = safePetLink(canonicalUrl);
+  if (!resource || !canonical?.startsWith("https://"))
+    return {
+      title: "Pet profile unavailable",
+      robots: { index: false, follow: false }
+    };
+  return {
+    title: `Meet ${resource.content.name}`,
+    description: Array.from(resource.content.story).slice(0, 180).join(""),
+    alternates: { canonical },
+    openGraph: {
+      title: `Meet ${resource.content.name}`,
+      description: resource.content.story,
+      url: canonical,
+      ...photoUrl && safePetLink(photoUrl) ? { images: [{ url: photoUrl, alt: resource.content.name }] } : {}
+    }
+  };
+}
+function preparePawWalk(value) {
+  if (!Number.isInteger(value.duration_minutes) || value.duration_minutes < 10 || value.duration_minutes > 240)
+    throw new Error("Choose a walk duration from 10 to 240 minutes.");
+  if (value.distance_km !== void 0 && (!Number.isFinite(value.distance_km) || value.distance_km < 0 || value.distance_km > 30))
+    throw new Error("Choose a walking distance from 0 to 30 km.");
+  if (value.leash !== "required" && value.leash !== "venue_rules")
+    throw new Error("Choose the leash requirements.");
+  for (const field of [value.size_guidance, value.accessibility])
+    if (typeof field !== "string" || Array.from(field).length > 500)
+      throw new Error("Keep walk guidance within 500 characters.");
+  return {
+    duration_minutes: value.duration_minutes,
+    distance_km: value.distance_km,
+    leash: value.leash,
+    size_guidance: value.size_guidance,
+    accessibility: value.accessibility
+  };
+}
+
+export { PET_CELEBRATIONS, PET_KINDS, PET_NOTIFICATION_CATEGORIES, PET_PHOTO_CATEGORIES, PET_SAFETY, PET_SLUG, PET_UUID, adoptionAvailability, petProfileMetadata, petReferences, preparePawWalk, resolvePetCommunity, safePetLink };

package/dist/{chunk-GB36YM56.js → chunk-AMLVCZDP.js}

@@ -1,3 +1,5 @@
+import { preparePawWalk } from './chunk-AFJ6S5WJ.js';
+
 // src/meet.ts
 var MEET_ACTIVITIES = [
   { value: "coffee", label: "Coffee" },
@@ -57,6 +59,13 @@ function prepareMeetup(input, places, now = /* @__PURE__ */ new Date()) {
   if (!notes.ok) throw new Error(notes.reason);
   const capacity = Number(input.capacity ?? 6);
   if (!Number.isInteger(capacity) || capacity < 2 || capacity > 12) throw new Error("Choose a group size from 2 to 12.");
+  const walk = activity === "dogs" && input.walk ? preparePawWalk(input.walk) : void 0;
+  if (walk) for (const guidance of [walk.size_guidance, walk.accessibility]) {
+    if (guidance.trim()) {
+      const screened = screenMessage(guidance);
+      if (!screened.ok) throw new Error(screened.reason);
+    }
+  }
   return {
     activity,
     activityLabel: label,
@@ -65,7 +74,8 @@ function prepareMeetup(input, places, now = /* @__PURE__ */ new Date()) {
     placeDetail: place.detail,
     startsAt: new Date(starts).toISOString(),
     notes: notes.text,
-    capacity
+    capacity,
+    ...walk ? { walk } : {}
   };
 }