siteplane 0.1.68 → 0.2.0-next.1

package/dist/chunk-BLJCWIYD.js

@@ -0,0 +1,340 @@
+import {
+  readSiteplaneConfig
+} from "./chunk-KZ3AQ6OA.js";
+
+// ../shared/dist/signing-keys.js
+var pkcs8Ed25519Prefix = Uint8Array.from([
+  48,
+  46,
+  2,
+  1,
+  0,
+  48,
+  5,
+  6,
+  3,
+  43,
+  101,
+  112,
+  4,
+  34,
+  4,
+  32
+]);
+var ed25519 = { name: "Ed25519" };
+async function verifyWithSigningKey(publicKey, signature, data) {
+  const key = await crypto.subtle.importKey("raw", decodeKey(publicKey, "whpk_"), ed25519, false, ["verify"]);
+  return crypto.subtle.verify(ed25519, key, signature, data);
+}
+function decodeBase64(value) {
+  const standard = value.replace(/-/gu, "+").replace(/_/gu, "/");
+  return Uint8Array.from(atob(standard.padEnd(Math.ceil(standard.length / 4) * 4, "=")), (character) => character.charCodeAt(0));
+}
+function decodeKey(key, prefix) {
+  let bytes;
+  try {
+    if (key.startsWith(prefix))
+      bytes = decodeBase64(key.slice(prefix.length));
+  } catch {
+    bytes = void 0;
+  }
+  if (bytes?.length !== 32)
+    throw new Error("invalid_signing_key");
+  return bytes;
+}
+
+// ../shared/dist/preview-token.js
+var PREVIEW_TOKEN_MAX_SECONDS = 60 * 60;
+var header = encodeJson({ alg: "EdDSA", typ: "JWT" });
+var clockSkewSeconds = 60;
+async function verifyPreviewToken(input) {
+  const parts = input.token.split(".");
+  const nowSeconds = Math.floor((input.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  let claims = null;
+  let signature = null;
+  if (parts.length === 3 && parts[0] === header) {
+    try {
+      claims = readClaims(JSON.parse(new TextDecoder().decode(decodeBase64(parts[1]))), nowSeconds);
+      signature = decodeBase64(parts[2]);
+    } catch {
+      claims = null;
+    }
+  }
+  if (!claims || !signature)
+    return { ok: false, reason: "malformed" };
+  const signingInput = new TextEncoder().encode(`${parts[0]}.${parts[1]}`);
+  let signed = false;
+  for (const publicKey of input.publicKeys) {
+    signed = await verifyWithSigningKey(publicKey, signature, signingInput);
+    if (signed)
+      break;
+  }
+  if (!signed)
+    return { ok: false, reason: "signature_invalid" };
+  if (claims.aud !== input.siteId)
+    return { ok: false, reason: "wrong_site" };
+  if (claims.exp <= nowSeconds)
+    return { ok: false, reason: "expired" };
+  return { ok: true, claims };
+}
+function readClaims(value, nowSeconds) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const claims = value;
+  const { aud, sub, scope, actor, editor_origin: editorOrigin, iat, exp, jti } = claims;
+  if (typeof aud !== "string" || !aud || typeof sub !== "string" || !sub || scope !== "drafts:read" || actor !== "workspace_member" && actor !== "site_member" || typeof editorOrigin !== "string" || !isOrigin(editorOrigin) || !Number.isSafeInteger(iat) || !Number.isSafeInteger(exp) || typeof iat !== "number" || typeof exp !== "number" || exp - iat > PREVIEW_TOKEN_MAX_SECONDS || iat > nowSeconds + clockSkewSeconds || typeof jti !== "string" || !jti) {
+    return null;
+  }
+  return { aud, sub, scope, actor, editor_origin: editorOrigin, iat, exp, jti };
+}
+function isOrigin(value) {
+  try {
+    return new URL(value).origin === value;
+  } catch {
+    return false;
+  }
+}
+function encodeJson(value) {
+  return toBase64Url(new TextEncoder().encode(JSON.stringify(value)));
+}
+function toBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes)
+    binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/u, "");
+}
+
+// ../shared/dist/webhook-signature.js
+var WEBHOOK_TOLERANCE_SECONDS = 5 * 60;
+var encoder = new TextEncoder();
+function webhookSignedContent(id, timestamp, payload) {
+  return `${id}.${timestamp}.${payload}`;
+}
+async function verifyWebhook(input) {
+  const read = (name) => input.headers instanceof Headers ? input.headers.get(name) : input.headers[name];
+  const id = read("webhook-id");
+  const timestamp = read("webhook-timestamp");
+  const signatureHeader = read("webhook-signature");
+  if (!id || !timestamp || !signatureHeader)
+    return { ok: false, reason: "missing_headers" };
+  const nowSeconds = Math.floor((input.now ?? /* @__PURE__ */ new Date()).getTime() / 1e3);
+  if (!/^\d{1,12}$/u.test(timestamp) || Math.abs(nowSeconds - Number(timestamp)) > WEBHOOK_TOLERANCE_SECONDS) {
+    return { ok: false, reason: "timestamp_out_of_window" };
+  }
+  const content = encoder.encode(webhookSignedContent(id, timestamp, input.payload));
+  const signatures = signatureHeader.split(" ").flatMap((entry) => {
+    const [version, signature] = entry.split(",");
+    if (version !== "v1a" || !signature)
+      return [];
+    try {
+      return [decodeBase64(signature)];
+    } catch {
+      return [];
+    }
+  });
+  for (const publicKey of input.publicKeys) {
+    for (const signature of signatures) {
+      if (await verifyWithSigningKey(publicKey, signature, content))
+        return { ok: true };
+    }
+  }
+  return { ok: false, reason: "no_matching_signature" };
+}
+
+// src/runtime/preview.ts
+var PREVIEW_COOKIE = "siteplane-preview";
+async function verifySitePreviewToken(config, token, keys, now) {
+  const verify = async (reload) => verifyPreviewToken({
+    token,
+    siteId: config.siteId,
+    publicKeys: await keys(config, "preview", reload ? { reload } : {}),
+    now
+  });
+  let result = await verify(false);
+  if (!result.ok && result.reason === "signature_invalid") result = await verify(true);
+  return result.ok ? result.claims : null;
+}
+async function verifySiteRevalidation(config, request, keys, now) {
+  const verify = async (reload) => verifyWebhook({
+    headers: request.headers,
+    payload: request.payload,
+    publicKeys: await keys(config, "revalidation", reload ? { reload } : {}),
+    now
+  });
+  let result = await verify(false);
+  if (!result.ok && result.reason === "no_matching_signature") result = await verify(true);
+  return result.ok;
+}
+
+// src/runtime/server.ts
+import { cookies, draftMode } from "next/headers";
+import projectConfig from "siteplane/config";
+
+// src/runtime/fetch-json.ts
+var SITEPLANE_DEADLINE_MS = 3e3;
+var SITEPLANE_DRAFT_MODE_DEADLINE_MS = 1e4;
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+async function fetchJson(fetchImpl, url, init, deadlineMs = SITEPLANE_DEADLINE_MS) {
+  const controller = new AbortController();
+  let timer;
+  const deadline = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      controller.abort();
+      resolve(null);
+    }, deadlineMs);
+  });
+  const answer = (async () => {
+    const response = await fetchImpl(url, { ...init, signal: controller.signal });
+    const text = await readBoundedText(response);
+    if (text === null) return null;
+    return { status: response.status, body: JSON.parse(text) };
+  })().catch(() => null);
+  try {
+    return await Promise.race([answer, deadline]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function readBoundedText(response) {
+  if (!response.body) return "";
+  const reader = response.body.getReader();
+  const chunks = [];
+  let bytes = 0;
+  for (; ; ) {
+    const chunk = await reader.read();
+    if (chunk.done) break;
+    bytes += chunk.value.byteLength;
+    if (bytes > MAX_BODY_BYTES) {
+      await reader.cancel();
+      return null;
+    }
+    chunks.push(chunk.value);
+  }
+  const combined = new Uint8Array(bytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    combined.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(combined);
+}
+
+// src/runtime/signing-keys.ts
+var MAX_AGE_MS = 60 * 60 * 1e3;
+var RELOAD_THROTTLE_MS = 60 * 1e3;
+function createSigningKeyStore(dependencies) {
+  const cached = /* @__PURE__ */ new Map();
+  const lastAttempt = /* @__PURE__ */ new Map();
+  async function load(apiOrigin) {
+    lastAttempt.set(apiOrigin, dependencies.now());
+    const answer = await fetchJson(dependencies.fetch, `${apiOrigin}/api/runtime/v1/signing-keys`, {
+      cache: "no-store"
+    });
+    const keys = answer?.status === 200 ? readKeySet(answer.body) : null;
+    if (keys) cached.set(apiOrigin, { keys, loadedAt: dependencies.now() });
+  }
+  return {
+    async keys(config, purpose, options = {}) {
+      const entry = cached.get(config.apiOrigin);
+      const now = dependencies.now();
+      const expired = !entry || now - entry.loadedAt > MAX_AGE_MS;
+      const reloadAllowed = now - (lastAttempt.get(config.apiOrigin) ?? Number.NEGATIVE_INFINITY) >= RELOAD_THROTTLE_MS;
+      if ((expired || options.reload) && (reloadAllowed || !entry)) await load(config.apiOrigin);
+      return cached.get(config.apiOrigin)?.keys[purpose] ?? [];
+    }
+  };
+}
+function readKeySet(body) {
+  if (typeof body !== "object" || body === null) return null;
+  const { revalidation, preview } = body;
+  return isKeyList(revalidation) && isKeyList(preview) ? { revalidation, preview } : null;
+}
+function isKeyList(value) {
+  return Array.isArray(value) && value.every((key) => typeof key === "string" && key.startsWith("whpk_"));
+}
+
+// src/runtime/values.ts
+function siteCacheTag(siteId) {
+  return `siteplane:${siteId}`;
+}
+function createValueSource(dependencies) {
+  const lastGood = /* @__PURE__ */ new Map();
+  return {
+    async published(config, options = {}) {
+      const key = `${config.apiOrigin} ${config.siteId}`;
+      const values = await readValues(
+        dependencies.fetch,
+        config,
+        `${config.apiOrigin}/api/runtime/v1/sites/${config.siteId}/values`,
+        { next: { revalidate: 60, tags: [siteCacheTag(config.siteId)] } },
+        options.draftMode ? SITEPLANE_DRAFT_MODE_DEADLINE_MS : SITEPLANE_DEADLINE_MS
+      );
+      if (values) {
+        lastGood.set(key, values);
+        return values;
+      }
+      return lastGood.get(key) ?? {};
+    },
+    async drafts(config, previewToken) {
+      return readValues(
+        dependencies.fetch,
+        config,
+        `${config.apiOrigin}/api/runtime/v1/sites/${config.siteId}/drafts`,
+        { cache: "no-store", headers: { authorization: `Bearer ${previewToken}` } },
+        SITEPLANE_DRAFT_MODE_DEADLINE_MS
+      );
+    }
+  };
+}
+async function readValues(fetchImpl, config, url, init, deadlineMs) {
+  const answer = await fetchJson(fetchImpl, url, init, deadlineMs);
+  if (!answer || answer.status !== 200) return null;
+  const { siteId, values } = answer.body ?? {};
+  if (siteId !== config.siteId || typeof values !== "object" || values === null || Array.isArray(values)) {
+    return null;
+  }
+  return values;
+}
+
+// src/runtime/server.ts
+var siteConfig = readSiteplaneConfig(projectConfig);
+var nextFetch = (input, init) => fetch(input, init);
+var valueSource = createValueSource({ fetch: nextFetch });
+var signingKeys = createSigningKeyStore({ fetch: nextFetch, now: () => Date.now() });
+async function isDraftMode() {
+  try {
+    return (await draftMode()).isEnabled;
+  } catch {
+    return false;
+  }
+}
+async function readPreviewToken() {
+  if (!await isDraftMode()) return null;
+  try {
+    return (await cookies()).get(PREVIEW_COOKIE)?.value ?? null;
+  } catch {
+    return null;
+  }
+}
+async function loadSiteValues() {
+  if (!siteConfig) return {};
+  const draft = await isDraftMode();
+  const token = draft ? await readPreviewToken() : null;
+  const [published, drafts] = await Promise.all([
+    valueSource.published(siteConfig, { draftMode: draft }),
+    token ? valueSource.drafts(siteConfig, token) : Promise.resolve(null)
+  ]);
+  return drafts ? { ...published, ...drafts } : published;
+}
+
+export {
+  PREVIEW_COOKIE,
+  verifySitePreviewToken,
+  verifySiteRevalidation,
+  siteCacheTag,
+  siteConfig,
+  signingKeys,
+  isDraftMode,
+  readPreviewToken,
+  loadSiteValues
+};

package/dist/chunk-KZ3AQ6OA.js

@@ -0,0 +1,27 @@
+// ../shared/dist/siteplane-config.js
+var SITEPLANE_CONFIG_FILE = "siteplane.config.json";
+var siteIdPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+function readSiteplaneConfig(value) {
+  if (typeof value !== "object" || value === null)
+    return null;
+  const { siteId, apiOrigin, editorOrigins } = value;
+  if (typeof siteId !== "string" || !siteIdPattern.test(siteId) || !isWebOrigin(apiOrigin) || !Array.isArray(editorOrigins) || !editorOrigins.every(isWebOrigin)) {
+    return null;
+  }
+  return { siteId, apiOrigin, editorOrigins: [...editorOrigins] };
+}
+function isWebOrigin(value) {
+  if (typeof value !== "string")
+    return false;
+  try {
+    const url = new URL(value);
+    return (url.protocol === "https:" || url.protocol === "http:") && url.origin === value;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  SITEPLANE_CONFIG_FILE,
+  readSiteplaneConfig
+};

package/dist/components.d.ts

@@ -0,0 +1,22 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * `<SiteplaneBridge />` in the root layout (Vertrag 54 §8.2). A server
+ * component: for normal visitors it renders nothing. In Draft Mode with a valid
+ * preview token it loads the bridge, which talks only to the token's editor
+ * origin.
+ */
+declare function SiteplaneBridge(): Promise<react_jsx_runtime.JSX.Element | null>;
+/**
+ * `<SiteplaneAnalytics siteId="…" />` (Vertrag 54 §10): page views, App Router
+ * navigations and clicks, without cookies or browser storage, sent to
+ * Siteplane's collector. In Draft Mode, which only the editor's preview uses,
+ * it renders nothing, so previews never count. The client part reads the
+ * search parameters and therefore sits in its own Suspense boundary, as with
+ * Vercel's `<Analytics />`.
+ */
+declare function SiteplaneAnalytics({ siteId }: {
+    siteId: string;
+}): Promise<react_jsx_runtime.JSX.Element | null>;
+
+export { SiteplaneAnalytics, SiteplaneBridge };

package/dist/components.js

@@ -0,0 +1,43 @@
+import {
+  isDraftMode,
+  readPreviewToken,
+  signingKeys,
+  siteConfig,
+  verifySitePreviewToken
+} from "./chunk-BLJCWIYD.js";
+import "./chunk-KZ3AQ6OA.js";
+
+// ../shared/dist/site-analytics.js
+var SITE_ANALYTICS_SEND_PATH = "/api/analytics/send";
+function siteAnalyticsEndpoint(apiOrigin) {
+  return `${apiOrigin}${SITE_ANALYTICS_SEND_PATH}`;
+}
+
+// src/components.tsx
+import { Suspense } from "react";
+import { AnalyticsTracker } from "siteplane/internal/analytics";
+import { BridgeLoader } from "siteplane/internal/bridge-loader";
+import { jsx } from "react/jsx-runtime";
+async function SiteplaneBridge() {
+  const editorOrigin = await readEditorOrigin();
+  return editorOrigin ? /* @__PURE__ */ jsx(BridgeLoader, { editorOrigin }) : null;
+}
+async function readEditorOrigin() {
+  try {
+    const token = await readPreviewToken();
+    if (!siteConfig || !token) return null;
+    const claims = await verifySitePreviewToken(siteConfig, token, signingKeys.keys, /* @__PURE__ */ new Date());
+    return claims?.editor_origin ?? null;
+  } catch {
+    return null;
+  }
+}
+async function SiteplaneAnalytics({ siteId }) {
+  if (await isDraftMode()) return null;
+  const endpoint = siteAnalyticsEndpoint(siteConfig?.apiOrigin ?? "https://siteplane.io");
+  return /* @__PURE__ */ jsx(Suspense, { fallback: null, children: /* @__PURE__ */ jsx(AnalyticsTracker, { siteId, endpoint }) });
+}
+export {
+  SiteplaneAnalytics,
+  SiteplaneBridge
+};

package/dist/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * `siteplane/config`: `withSiteplane` points this module at the project's
+ * `siteplane.config.json`. Without the wrapper or the file it stays empty, and
+ * the website renders its code fallbacks.
+ */
+declare const config: unknown;
+
+export { config as default };

package/dist/config.js

@@ -0,0 +1,6 @@
+// src/config.ts
+var config = null;
+var config_default = config;
+export {
+  config_default as default
+};

package/dist/index.d.ts

@@ -1 +1,38 @@
-export declare const siteplanePackageName = "siteplane";
+/** A link field: `href` and a visible `label`. */
+type SiteplaneLink = {
+    href: string;
+    label: string;
+};
+/** An image field; `alt` may be empty for decorative images, the size comes from Siteplane when known. */
+type SiteplaneImage = {
+    src: string;
+    alt: string;
+    width?: number | undefined;
+    height?: number | undefined;
+};
+type SiteplaneAttrs = {
+    "data-siteplane-field": string;
+} | Record<string, never>;
+/** The attribute the bridge finds the field by in the Draft Mode preview. */
+declare function attrs(fieldId: string): SiteplaneAttrs;
+
+/**
+ * The field API for server components (Vertrag 54 §6.2):
+ *
+ * ```tsx
+ * const title = await siteplane.text("home.hero.title", "Fresh rolls since 1920");
+ * <h1 {...siteplane.attrs("home.hero.title")}>{title}</h1>
+ * ```
+ *
+ * All values of the site load once per request (React `cache()`); without
+ * Siteplane the code fallbacks render.
+ */
+declare const siteplane: {
+    text: (fieldId: string, fallback: string) => Promise<string>;
+    longText: (fieldId: string, fallback: string) => Promise<string>;
+    link: (fieldId: string, fallback: SiteplaneLink) => Promise<SiteplaneLink>;
+    image: (fieldId: string, fallback: SiteplaneImage) => Promise<SiteplaneImage>;
+    attrs: typeof attrs;
+};
+
+export { type SiteplaneAttrs, type SiteplaneImage, type SiteplaneLink, siteplane };