@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/platform/published-content.js

@@ -1,611 +0,0 @@
-const PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION = 2;
-const EDITORIAL_PREVIEW_COOKIE = "treeseed-content-preview";
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function expectRecord(value, label) {
-  if (!isRecord(value)) {
-    throw new Error(`Invalid published content payload: expected ${label} to be an object.`);
-  }
-  return value;
-}
-function expectString(value, label) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`Invalid published content payload: expected ${label} to be a non-empty string.`);
-  }
-  return value.trim();
-}
-function optionalString(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function optionalNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function optionalBoolean(value) {
-  return typeof value === "boolean" ? value : void 0;
-}
-function getNodeCrypto() {
-  return globalThis.process?.getBuiltinModule?.("crypto") ?? null;
-}
-function stableHash(value) {
-  const crypto = getNodeCrypto();
-  if (crypto?.createHash) {
-    return crypto.createHash("sha256").update(value).digest("hex");
-  }
-  let hash = 2166136261;
-  for (let index = 0; index < value.length; index += 1) {
-    hash ^= value.charCodeAt(index);
-    hash = Math.imul(hash, 16777619);
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-function hmacSha256Base64Url(value, secret) {
-  const crypto = getNodeCrypto();
-  if (!crypto?.createHmac) {
-    throw new Error("Editorial preview token signing requires a crypto runtime.");
-  }
-  return crypto.createHmac("sha256", secret).update(value).digest("base64url");
-}
-function base64UrlEncode(value) {
-  return Buffer.from(value, "utf8").toString("base64url");
-}
-function base64UrlDecode(value) {
-  return Buffer.from(value, "base64url").toString("utf8");
-}
-function canonicalEntryPath(entry) {
-  return `${entry.model}/${entry.slug || entry.id}`.replace(/^\/+|\/+$/g, "");
-}
-function normalizeObjectPointer(value, label) {
-  const record = expectRecord(value, label);
-  return {
-    objectKey: expectString(record.objectKey ?? record.key, `${label}.objectKey`),
-    sha256: expectString(record.sha256, `${label}.sha256`),
-    size: optionalNumber(record.size),
-    contentType: optionalString(record.contentType),
-    publicUrl: optionalString(record.publicUrl)
-  };
-}
-function normalizeRuntimePointers(value, label) {
-  const record = isRecord(value) ? value : void 0;
-  if (!record) {
-    return void 0;
-  }
-  return {
-    docsHomePath: optionalString(record.docsHomePath),
-    booksRuntime: record.booksRuntime ? normalizeObjectPointer(record.booksRuntime, `${label}.booksRuntime`) : void 0,
-    docsTree: record.docsTree ? normalizeObjectPointer(record.docsTree, `${label}.docsTree`) : void 0,
-    searchIndex: record.searchIndex ? normalizeObjectPointer(record.searchIndex, `${label}.searchIndex`) : void 0
-  };
-}
-function normalizeLocator(value, label) {
-  const record = isRecord(value) ? value : void 0;
-  if (!record) {
-    return void 0;
-  }
-  return {
-    teamId: expectString(record.teamId, `${label}.teamId`),
-    manifestKey: expectString(record.manifestKey, `${label}.manifestKey`),
-    previewRoot: expectString(record.previewRoot, `${label}.previewRoot`),
-    overlayKey: optionalString(record.overlayKey),
-    previewId: optionalString(record.previewId),
-    mode: optionalString(record.mode)
-  };
-}
-function normalizeContentEntry(value, label) {
-  const record = expectRecord(value, label);
-  return {
-    id: expectString(record.id, `${label}.id`),
-    model: expectString(record.model, `${label}.model`),
-    slug: expectString(record.slug, `${label}.slug`),
-    title: optionalString(record.title),
-    summary: optionalString(record.summary),
-    status: optionalString(record.status),
-    visibility: optionalString(record.visibility),
-    teamId: optionalString(record.teamId),
-    publishedAt: optionalString(record.publishedAt),
-    updatedAt: optionalString(record.updatedAt),
-    content: normalizeObjectPointer(record.content, `${label}.content`),
-    rendered: record.rendered ? normalizeObjectPointer(record.rendered, `${label}.rendered`) : void 0,
-    search: record.search ? normalizeObjectPointer(record.search, `${label}.search`) : void 0,
-    metadata: isRecord(record.metadata) ? record.metadata : void 0
-  };
-}
-function normalizeArtifactVersion(value, label) {
-  const record = expectRecord(value, label);
-  return {
-    id: expectString(record.id, `${label}.id`),
-    itemId: expectString(record.itemId, `${label}.itemId`),
-    kind: expectString(record.kind, `${label}.kind`),
-    version: expectString(record.version, `${label}.version`),
-    label: optionalString(record.label),
-    visibility: optionalString(record.visibility),
-    teamId: optionalString(record.teamId),
-    publishedAt: expectString(record.publishedAt, `${label}.publishedAt`),
-    content: normalizeObjectPointer(record.content, `${label}.content`),
-    metadata: isRecord(record.metadata) ? record.metadata : void 0
-  };
-}
-function normalizeTombstones(value) {
-  return Array.isArray(value) ? value.map((item, index) => {
-    const tombstone = expectRecord(item, `tombstones[${index}]`);
-    return {
-      path: expectString(tombstone.path, `tombstones[${index}].path`),
-      removedAt: expectString(tombstone.removedAt, `tombstones[${index}].removedAt`),
-      previousSha256: optionalString(tombstone.previousSha256)
-    };
-  }) : [];
-}
-function parsePublishedContentManifest(value) {
-  const record = expectRecord(value, "manifest");
-  const collectionsRecord = isRecord(record.collections) ? record.collections : {};
-  return {
-    schemaVersion: optionalNumber(record.schemaVersion) ?? PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
-    siteSlug: expectString(record.siteSlug, "manifest.siteSlug"),
-    teamId: optionalString(record.teamId) ?? expectString(record.siteSlug, "manifest.siteSlug"),
-    revision: expectString(record.revision, "manifest.revision"),
-    generatedAt: expectString(record.generatedAt, "manifest.generatedAt"),
-    mode: optionalString(record.mode) ?? "production",
-    sourceCommit: optionalString(record.sourceCommit),
-    appRevision: optionalString(record.appRevision),
-    appCompatibility: isRecord(record.appCompatibility) ? {
-      min: optionalString(record.appCompatibility.min),
-      max: optionalString(record.appCompatibility.max),
-      lastKnownCompatibleRevision: optionalString(record.appCompatibility.lastKnownCompatibleRevision)
-    } : void 0,
-    locator: normalizeLocator(record.locator, "manifest.locator"),
-    collections: Object.fromEntries(
-      Object.entries(collectionsRecord).map(([model, pointer]) => [model, normalizeObjectPointer(pointer, `manifest.collections.${model}`)])
-    ),
-    entries: Array.isArray(record.entries) ? record.entries.map((entry, index) => normalizeContentEntry(entry, `manifest.entries[${index}]`)) : [],
-    artifacts: Array.isArray(record.artifacts) ? record.artifacts.map((artifact, index) => normalizeArtifactVersion(artifact, `manifest.artifacts[${index}]`)) : [],
-    runtime: normalizeRuntimePointers(record.runtime, "manifest.runtime"),
-    tombstones: normalizeTombstones(record.tombstones),
-    metadata: isRecord(record.metadata) ? record.metadata : void 0
-  };
-}
-function parsePublishedOverlayManifest(value) {
-  const record = expectRecord(value, "overlay");
-  const collectionsRecord = isRecord(record.collections) ? record.collections : {};
-  return {
-    schemaVersion: optionalNumber(record.schemaVersion) ?? PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
-    siteSlug: expectString(record.siteSlug, "overlay.siteSlug"),
-    teamId: optionalString(record.teamId) ?? expectString(record.siteSlug, "overlay.siteSlug"),
-    previewId: expectString(record.previewId, "overlay.previewId"),
-    generatedAt: expectString(record.generatedAt, "overlay.generatedAt"),
-    mode: optionalString(record.mode) ?? "editorial_overlay",
-    baseManifestKey: expectString(record.baseManifestKey, "overlay.baseManifestKey"),
-    baseRevision: optionalString(record.baseRevision),
-    sourceCommit: optionalString(record.sourceCommit),
-    expiresAt: optionalString(record.expiresAt),
-    locator: normalizeLocator(record.locator, "overlay.locator"),
-    collections: Object.fromEntries(
-      Object.entries(collectionsRecord).map(([model, pointer]) => [model, normalizeObjectPointer(pointer, `overlay.collections.${model}`)])
-    ),
-    entries: Array.isArray(record.entries) ? record.entries.map((entry, index) => normalizeContentEntry(entry, `overlay.entries[${index}]`)) : [],
-    artifacts: Array.isArray(record.artifacts) ? record.artifacts.map((artifact, index) => normalizeArtifactVersion(artifact, `overlay.artifacts[${index}]`)) : [],
-    runtime: normalizeRuntimePointers(record.runtime, "overlay.runtime"),
-    tombstones: normalizeTombstones(record.tombstones),
-    metadata: isRecord(record.metadata) ? record.metadata : void 0
-  };
-}
-function parsePublishedCollectionIndex(value) {
-  const record = expectRecord(value, "collection index");
-  return {
-    model: expectString(record.model, "collectionIndex.model"),
-    generatedAt: expectString(record.generatedAt, "collectionIndex.generatedAt"),
-    count: optionalNumber(record.count),
-    entries: Array.isArray(record.entries) ? record.entries.map((entry, index) => normalizeContentEntry(entry, `collectionIndex.entries[${index}]`)) : []
-  };
-}
-function resolvePublishedContentBucketBinding(config) {
-  return config.cloudflare.r2?.binding ?? "TREESEED_CONTENT_BUCKET";
-}
-function fillTeamTemplate(template, teamId) {
-  return template.replaceAll("{teamId}", teamId);
-}
-function resolvePublishedContentManifestKey(config, teamId) {
-  const resolvedTeamId = typeof teamId === "string" && teamId.trim() ? teamId.trim() : typeof config.slug === "string" && config.slug.trim() ? config.slug.trim() : "default";
-  return fillTeamTemplate(
-    config.cloudflare.r2?.manifestKeyTemplate ?? "teams/{teamId}/published/common.json",
-    resolvedTeamId
-  );
-}
-function resolvePublishedContentPreviewRoot(config, teamId) {
-  const resolvedTeamId = typeof teamId === "string" && teamId.trim() ? teamId.trim() : typeof config.slug === "string" && config.slug.trim() ? config.slug.trim() : "default";
-  return fillTeamTemplate(
-    config.cloudflare.r2?.previewRootTemplate ?? "teams/{teamId}/previews",
-    resolvedTeamId
-  );
-}
-function resolvePublishedContentPreviewTtlHours(config) {
-  return config.cloudflare.r2?.previewTtlHours ?? 168;
-}
-function resolveTeamScopedContentLocator(config, teamId, previewId) {
-  const previewRoot = resolvePublishedContentPreviewRoot(config, teamId);
-  return {
-    teamId,
-    manifestKey: resolvePublishedContentManifestKey(config, teamId),
-    previewRoot,
-    previewId: previewId || void 0,
-    overlayKey: previewId ? `${previewRoot}/${previewId}/overlay.json` : void 0,
-    mode: previewId ? "editorial_overlay" : "production"
-  };
-}
-function isTeamScopedR2ContentEnabled(config) {
-  return config.providers?.content?.runtime === "team_scoped_r2_overlay" && Boolean(config.cloudflare.r2?.binding);
-}
-function signEditorialPreviewToken(payload, secret) {
-  const normalized = {
-    teamId: expectString(payload.teamId, "previewToken.teamId"),
-    previewId: expectString(payload.previewId, "previewToken.previewId"),
-    expiresAt: expectString(payload.expiresAt, "previewToken.expiresAt")
-  };
-  const encodedPayload = base64UrlEncode(JSON.stringify(normalized));
-  const signature = hmacSha256Base64Url(encodedPayload, secret);
-  return `${encodedPayload}.${signature}`;
-}
-function verifyEditorialPreviewToken(token, secret) {
-  const [encodedPayload, signature] = String(token ?? "").split(".");
-  if (!encodedPayload || !signature) {
-    return null;
-  }
-  let expected;
-  try {
-    expected = hmacSha256Base64Url(encodedPayload, secret);
-  } catch {
-    return null;
-  }
-  if (expected !== signature) {
-    return null;
-  }
-  const payload = JSON.parse(base64UrlDecode(encodedPayload));
-  const normalized = {
-    teamId: expectString(payload.teamId, "previewToken.teamId"),
-    previewId: expectString(payload.previewId, "previewToken.previewId"),
-    expiresAt: expectString(payload.expiresAt, "previewToken.expiresAt")
-  };
-  if (Date.parse(normalized.expiresAt) <= Date.now()) {
-    return null;
-  }
-  return normalized;
-}
-function resolveCloudflareR2Bucket(runtime, binding) {
-  if (!runtime?.env || !binding) {
-    return null;
-  }
-  const candidate = runtime.env[binding];
-  return candidate && typeof candidate === "object" ? candidate : null;
-}
-async function readJsonObject(bucket, key) {
-  const object = await bucket.get(key);
-  return object ? object.json() : null;
-}
-async function readPublishedContentManifest(bucket, manifestKey) {
-  const payload = await readJsonObject(bucket, manifestKey);
-  return payload ? parsePublishedContentManifest(payload) : null;
-}
-async function readPublishedOverlayManifest(bucket, overlayKey) {
-  const payload = await readJsonObject(bucket, overlayKey);
-  return payload ? parsePublishedOverlayManifest(payload) : null;
-}
-function mergeEntries(baseEntries, overlayEntries = [], tombstones = []) {
-  const removed = new Set(tombstones.map((entry) => entry.path));
-  const merged = /* @__PURE__ */ new Map();
-  for (const entry of baseEntries) {
-    const key = canonicalEntryPath(entry);
-    if (!removed.has(key)) {
-      merged.set(key, entry);
-    }
-  }
-  for (const entry of overlayEntries) {
-    merged.set(canonicalEntryPath(entry), entry);
-  }
-  return [...merged.values()];
-}
-function mergeArtifacts(baseArtifacts = [], overlayArtifacts = []) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const artifact of baseArtifacts) {
-    merged.set(`${artifact.itemId}:${artifact.version}`, artifact);
-  }
-  for (const artifact of overlayArtifacts) {
-    merged.set(`${artifact.itemId}:${artifact.version}`, artifact);
-  }
-  return [...merged.values()];
-}
-function mergeRuntimePointers(baseRuntime, overlayRuntime) {
-  return overlayRuntime ? { ...baseRuntime ?? {}, ...overlayRuntime } : baseRuntime;
-}
-function mergeManifests(production, overlay) {
-  if (!overlay) {
-    return production;
-  }
-  return {
-    ...production,
-    mode: "editorial_overlay",
-    generatedAt: overlay.generatedAt,
-    sourceCommit: overlay.sourceCommit ?? production.sourceCommit,
-    locator: overlay.locator ?? production.locator,
-    collections: {
-      ...production.collections ?? {},
-      ...overlay.collections ?? {}
-    },
-    entries: mergeEntries(production.entries, overlay.entries ?? [], overlay.tombstones ?? []),
-    artifacts: mergeArtifacts(production.artifacts ?? [], overlay.artifacts ?? []),
-    runtime: mergeRuntimePointers(production.runtime, overlay.runtime),
-    tombstones: [...production.tombstones ?? [], ...overlay.tombstones ?? []],
-    metadata: {
-      ...production.metadata ?? {},
-      ...overlay.metadata ?? {},
-      overlayPreviewId: overlay.previewId,
-      overlayExpiresAt: overlay.expiresAt
-    }
-  };
-}
-function collectManifestPointers(manifest) {
-  const pointers = [];
-  for (const pointer of Object.values(manifest.collections ?? {})) {
-    pointers.push(pointer);
-  }
-  for (const entry of manifest.entries ?? []) {
-    pointers.push(entry.content);
-    if (entry.rendered) pointers.push(entry.rendered);
-    if (entry.search) pointers.push(entry.search);
-  }
-  for (const artifact of manifest.artifacts ?? []) {
-    pointers.push(artifact.content);
-  }
-  if (manifest.runtime?.booksRuntime) pointers.push(manifest.runtime.booksRuntime);
-  if (manifest.runtime?.docsTree) pointers.push(manifest.runtime.docsTree);
-  if (manifest.runtime?.searchIndex) pointers.push(manifest.runtime.searchIndex);
-  return pointers;
-}
-async function putContentObjects(bucket, objects) {
-  for (const object of objects) {
-    await bucket.put(object.pointer.objectKey, object.body, {
-      httpMetadata: object.httpMetadata,
-      customMetadata: object.customMetadata
-    });
-  }
-}
-class TeamScopedR2OverlayContentRuntimeProvider {
-  constructor(bucket, locator) {
-    this.bucket = bucket;
-    this.locator = locator;
-  }
-  bucket;
-  locator;
-  productionManifestPromise = null;
-  overlayManifestPromise = null;
-  manifestPromise = null;
-  collectionCache = /* @__PURE__ */ new Map();
-  async getProductionManifest() {
-    if (!this.productionManifestPromise) {
-      this.productionManifestPromise = (async () => {
-        const manifest = await readPublishedContentManifest(this.bucket, this.locator.manifestKey);
-        if (!manifest) {
-          const overlay = this.locator.overlayKey ? await readPublishedOverlayManifest(this.bucket, this.locator.overlayKey) : null;
-          if (overlay) {
-            return {
-              schemaVersion: overlay.schemaVersion,
-              siteSlug: overlay.siteSlug,
-              teamId: overlay.teamId,
-              revision: overlay.baseRevision ?? "unpublished",
-              generatedAt: overlay.generatedAt,
-              mode: "production",
-              sourceCommit: overlay.sourceCommit,
-              locator: {
-                ...this.locator,
-                mode: "production",
-                overlayKey: void 0,
-                previewId: void 0
-              },
-              collections: {},
-              entries: [],
-              artifacts: [],
-              runtime: {},
-              tombstones: [],
-              metadata: {
-                overlayOnly: true
-              }
-            };
-          }
-          throw new Error(`Published content manifest "${this.locator.manifestKey}" was not found in R2.`);
-        }
-        return manifest;
-      })();
-    }
-    return this.productionManifestPromise;
-  }
-  async getOverlayManifest() {
-    if (!this.locator.overlayKey) {
-      return null;
-    }
-    if (!this.overlayManifestPromise) {
-      this.overlayManifestPromise = readPublishedOverlayManifest(this.bucket, this.locator.overlayKey);
-    }
-    return this.overlayManifestPromise;
-  }
-  async getManifest() {
-    if (!this.manifestPromise) {
-      this.manifestPromise = (async () => mergeManifests(await this.getProductionManifest(), await this.getOverlayManifest()))();
-    }
-    return this.manifestPromise;
-  }
-  async getCollectionIndex(model) {
-    if (!this.collectionCache.has(model)) {
-      this.collectionCache.set(model, (async () => {
-        const [manifest, overlay, production] = await Promise.all([
-          this.getManifest(),
-          this.getOverlayManifest(),
-          this.getProductionManifest()
-        ]);
-        const pointer = manifest.collections?.[model];
-        if (!pointer) {
-          return {
-            model,
-            generatedAt: manifest.generatedAt,
-            count: 0,
-            entries: manifest.entries.filter((entry) => entry.model === model)
-          };
-        }
-        const payload = await readJsonObject(this.bucket, pointer.objectKey);
-        if (!payload) {
-          throw new Error(`Published collection index "${pointer.objectKey}" for model "${model}" was not found.`);
-        }
-        const parsed = parsePublishedCollectionIndex(payload);
-        if (!overlay) {
-          return parsed;
-        }
-        const baseIndexPointer = production.collections?.[model];
-        const basePayload = baseIndexPointer && baseIndexPointer.objectKey !== pointer.objectKey ? await readJsonObject(this.bucket, baseIndexPointer.objectKey) : null;
-        const baseEntries = basePayload ? parsePublishedCollectionIndex(basePayload).entries : parsed.entries;
-        return {
-          model,
-          generatedAt: manifest.generatedAt,
-          count: void 0,
-          entries: mergeEntries(
-            baseEntries,
-            (overlay.entries ?? []).filter((entry) => entry.model === model),
-            (overlay.tombstones ?? []).filter((entry) => entry.path.startsWith(`${model}/`))
-          )
-        };
-      })());
-    }
-    return this.collectionCache.get(model);
-  }
-  async listCollection(model) {
-    return (await this.getCollectionIndex(model)).entries;
-  }
-  async getEntry(model, slugOrId) {
-    const normalized = String(slugOrId).trim().replace(/^\/+|\/+$/g, "");
-    const manifest = await this.getManifest();
-    const fromManifest = manifest.entries.find((entry) => entry.model === model && (entry.slug === normalized || entry.id === normalized));
-    if (fromManifest) {
-      return fromManifest;
-    }
-    const index = await this.getCollectionIndex(model);
-    return index.entries.find((entry) => entry.slug === normalized || entry.id === normalized) ?? null;
-  }
-  async getArtifactVersion(itemId, version) {
-    const manifest = await this.getManifest();
-    const candidates = (manifest.artifacts ?? []).filter((artifact) => artifact.itemId === itemId);
-    if (!candidates.length) {
-      return null;
-    }
-    if (version) {
-      return candidates.find((artifact) => artifact.version === version || artifact.id === version) ?? null;
-    }
-    return [...candidates].sort((left, right) => right.publishedAt.localeCompare(left.publishedAt))[0] ?? null;
-  }
-  async getObject(pointer) {
-    const objectKey = typeof pointer === "string" ? pointer : pointer.objectKey;
-    return readJsonObject(this.bucket, objectKey);
-  }
-}
-class TeamScopedR2OverlayContentPublishProvider {
-  constructor(bucket, locator) {
-    this.bucket = bucket;
-    this.locator = locator;
-  }
-  bucket;
-  locator;
-  async publishRevision(input) {
-    await putContentObjects(this.bucket, input.objects);
-    const snapshotKey = this.locator.manifestKey.replace(/\/common\.json$/u, `/manifests/${input.manifest.revision}.json`);
-    await this.bucket.put(snapshotKey, JSON.stringify(input.manifest, null, 2));
-    await this.bucket.put(this.locator.manifestKey, JSON.stringify(input.manifest, null, 2));
-    return {
-      revision: input.manifest.revision,
-      manifestKey: this.locator.manifestKey
-    };
-  }
-  async publishOverlay(input) {
-    await putContentObjects(this.bucket, input.objects);
-    const overlayKey = input.overlay.locator?.overlayKey ?? `${this.locator.previewRoot}/${input.overlay.previewId}/overlay.json`;
-    await this.bucket.put(overlayKey, JSON.stringify(input.overlay, null, 2));
-    return {
-      previewId: input.overlay.previewId,
-      overlayKey
-    };
-  }
-  async promoteOverlay(input) {
-    const production = await readPublishedContentManifest(this.bucket, this.locator.manifestKey);
-    if (!production) {
-      throw new Error(`Published content manifest "${this.locator.manifestKey}" was not found in R2.`);
-    }
-    const overlayKey = `${this.locator.previewRoot}/${input.previewId}/overlay.json`;
-    const overlay = await readPublishedOverlayManifest(this.bucket, overlayKey);
-    if (!overlay) {
-      throw new Error(`Editorial overlay "${overlayKey}" was not found in R2.`);
-    }
-    const merged = mergeManifests(production, overlay);
-    const nextManifest = {
-      ...merged,
-      mode: "production",
-      revision: input.revision ?? `${overlay.previewId}-${stableHash(`${overlay.generatedAt}:${overlay.previewId}`).slice(0, 12)}`,
-      generatedAt: input.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
-      sourceCommit: input.sourceCommit ?? overlay.sourceCommit ?? merged.sourceCommit,
-      appRevision: input.appRevision ?? merged.appRevision,
-      locator: {
-        ...this.locator,
-        mode: "production",
-        overlayKey: void 0,
-        previewId: void 0
-      }
-    };
-    return this.publishRevision({
-      manifest: nextManifest,
-      objects: []
-    });
-  }
-  async rollbackRevision(snapshotKey) {
-    const manifest = await readPublishedContentManifest(this.bucket, snapshotKey);
-    if (!manifest) {
-      throw new Error(`Published content snapshot "${snapshotKey}" was not found in R2.`);
-    }
-    await this.bucket.put(this.locator.manifestKey, JSON.stringify(manifest, null, 2));
-    return {
-      revision: manifest.revision,
-      manifestKey: this.locator.manifestKey
-    };
-  }
-  async deleteOverlay(previewId, overlay = null) {
-    const overlayKey = `${this.locator.previewRoot}/${previewId}/overlay.json`;
-    if (this.bucket.delete) {
-      const manifest = overlay ?? await readPublishedOverlayManifest(this.bucket, overlayKey);
-      const keys = /* @__PURE__ */ new Set([overlayKey]);
-      for (const pointer of manifest ? collectManifestPointers(manifest) : []) {
-        keys.add(pointer.objectKey);
-      }
-      await this.bucket.delete([...keys]);
-    }
-  }
-}
-function createTeamScopedR2OverlayContentRuntimeProvider(options) {
-  return new TeamScopedR2OverlayContentRuntimeProvider(options.bucket, options.locator);
-}
-function createTeamScopedR2OverlayContentPublishProvider(options) {
-  return new TeamScopedR2OverlayContentPublishProvider(options.bucket, options.locator);
-}
-export {
-  EDITORIAL_PREVIEW_COOKIE,
-  PUBLISHED_CONTENT_MANIFEST_SCHEMA_VERSION,
-  TeamScopedR2OverlayContentPublishProvider,
-  TeamScopedR2OverlayContentRuntimeProvider,
-  createTeamScopedR2OverlayContentPublishProvider,
-  createTeamScopedR2OverlayContentRuntimeProvider,
-  isTeamScopedR2ContentEnabled,
-  parsePublishedCollectionIndex,
-  parsePublishedContentManifest,
-  parsePublishedOverlayManifest,
-  readPublishedContentManifest,
-  readPublishedOverlayManifest,
-  resolveCloudflareR2Bucket,
-  resolvePublishedContentBucketBinding,
-  resolvePublishedContentManifestKey,
-  resolvePublishedContentPreviewRoot,
-  resolvePublishedContentPreviewTtlHours,
-  resolveTeamScopedContentLocator,
-  signEditorialPreviewToken,
-  verifyEditorialPreviewToken
-};

package/dist/platform/site-config-schema.d.ts

@@ -1 +0,0 @@
-export { parseSiteConfig } from './utils/site-config-schema.js';

package/dist/platform/site-config-schema.js

@@ -1,4 +0,0 @@
-import { parseSiteConfig } from "./utils/site-config-schema.js";
-export {
-  parseSiteConfig
-};