@treeseed/sdk 0.4.8 → 0.4.10

package/dist/platform/published-content.js

@@ -0,0 +1,588 @@
+import { createHash, createHmac } from "node:crypto";
+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 stableHash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+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 = createHmac("sha256", secret).update(encodedPayload).digest("base64url");
+  return `${encodedPayload}.${signature}`;
+}
+function verifyEditorialPreviewToken(token, secret) {
+  const [encodedPayload, signature] = String(token ?? "").split(".");
+  if (!encodedPayload || !signature) {
+    return null;
+  }
+  const expected = createHmac("sha256", secret).update(encodedPayload).digest("base64url");
+  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/tenant/runtime-config.d.ts

@@ -1,4 +1,4 @@
 import type { TreeseedTenantConfig } from '../contracts.ts';
-export declare const RUNTIME_TENANT: TreeseedTenantConfig;
 export declare const RUNTIME_PROJECT_ROOT: string;
+export declare const RUNTIME_TENANT: TreeseedTenantConfig;
 export declare const RUNTIME_SITE_CONFIG: any;

package/dist/platform/tenant/runtime-config.js

@@ -1,11 +1,44 @@
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { loadTreeseedManifest } from "../tenant-config.js";
 import { parseSiteConfig } from "../utils/site-config-schema.js";
 const injectedTenantConfig = typeof __TREESEED_TENANT_CONFIG__ !== "undefined" ? __TREESEED_TENANT_CONFIG__ : null;
 const injectedProjectRoot = typeof __TREESEED_PROJECT_ROOT__ !== "undefined" ? __TREESEED_PROJECT_ROOT__ : null;
 const injectedSiteConfig = typeof __TREESEED_SITE_CONFIG__ !== "undefined" ? __TREESEED_SITE_CONFIG__ : null;
-const RUNTIME_TENANT = injectedTenantConfig ?? loadTreeseedManifest();
+function fallbackTenantConfig(projectRoot) {
+  return {
+    id: "treeseed-runtime",
+    siteConfigPath: resolve(projectRoot, "treeseed.site.yaml"),
+    content: {
+      pages: resolve(projectRoot, "src/content/pages"),
+      notes: resolve(projectRoot, "src/content/notes"),
+      questions: resolve(projectRoot, "src/content/questions"),
+      objectives: resolve(projectRoot, "src/content/objectives"),
+      people: resolve(projectRoot, "src/content/people"),
+      agents: resolve(projectRoot, "src/content/agents"),
+      books: resolve(projectRoot, "src/content/books"),
+      docs: resolve(projectRoot, "src/content/knowledge"),
+      templates: resolve(projectRoot, "src/content/templates"),
+      knowledge_packs: resolve(projectRoot, "src/content/knowledge-packs"),
+      workdays: resolve(projectRoot, "src/content/workdays")
+    },
+    features: {
+      docs: true,
+      books: true
+    }
+  };
+}
 const RUNTIME_PROJECT_ROOT = injectedProjectRoot ?? process.cwd();
+const RUNTIME_TENANT = (() => {
+  if (injectedTenantConfig) {
+    return injectedTenantConfig;
+  }
+  try {
+    return loadTreeseedManifest();
+  } catch {
+    return fallbackTenantConfig(RUNTIME_PROJECT_ROOT);
+  }
+})();
 const RUNTIME_SITE_CONFIG = injectedSiteConfig ?? (() => {
   try {
     return parseSiteConfig(readFileSync(RUNTIME_TENANT.siteConfigPath, "utf8"));

package/dist/platform/tenant-config.d.ts

@@ -1,7 +1,8 @@
-import type { TreeseedTenantConfig } from './contracts.ts';
+import type { TreeseedContentCollection, TreeseedTenantConfig } from './contracts.ts';
 export declare function resolveTreeseedTenantRoot(): string;
 export declare function defineTreeseedTenant<T>(tenantConfig: T): T;
 export declare function loadTreeseedManifest(manifestPath?: string): TreeseedTenantConfig;
 export declare const loadTreeseedTenantManifest: typeof loadTreeseedManifest;
 export declare function getTenantContentRoot(tenantConfig: Pick<TreeseedTenantConfig, 'content'>, collectionName: string): string;
 export declare function tenantFeatureEnabled(tenantConfig: Pick<TreeseedTenantConfig, 'features'>, featureName: string): boolean;
+export declare function tenantModelRendered(tenantConfig: Pick<TreeseedTenantConfig, 'features' | 'site'>, modelName: TreeseedContentCollection): boolean;

package/dist/platform/tenant-config.js

@@ -168,11 +168,27 @@ function getTenantContentRoot(tenantConfig, collectionName) {
 function tenantFeatureEnabled(tenantConfig, featureName) {
   return tenantConfig.features?.[featureName] !== false;
 }
+const MODEL_FEATURE_MAP = {
+  docs: "docs",
+  books: "books",
+  notes: "notes",
+  questions: "questions",
+  objectives: "objectives",
+  agents: "agents"
+};
+function tenantModelRendered(tenantConfig, modelName) {
+  const featureName = MODEL_FEATURE_MAP[modelName];
+  if (featureName && !tenantFeatureEnabled(tenantConfig, featureName)) {
+    return false;
+  }
+  return tenantConfig.site?.models?.[modelName]?.rendered !== false;
+}
 export {
   defineTreeseedTenant,
   getTenantContentRoot,
   loadTreeseedManifest,
   loadTreeseedTenantManifest,
   resolveTreeseedTenantRoot,
-  tenantFeatureEnabled
+  tenantFeatureEnabled,
+  tenantModelRendered
 };