@setzkasten-cms/astro-admin 1.4.0 → 1.4.1

package/dist/api-routes/init-scan-page.js

@@ -0,0 +1,260 @@
+import {
+  analyzeAstroSection,
+  extractLayoutImport,
+  extractSectionImports
+} from "../chunk-K22A4ZBS.js";
+import {
+  prefixPath,
+  resolveStorageConfigForRequest
+} from "../chunk-6UIKVKED.js";
+import {
+  resolveGitHubTokenForRequest
+} from "../chunk-NKDATSPA.js";
+
+// src/api-routes/init-scan-page.ts
+function resolveFullConfig() {
+  const buildConfig = typeof __SETZKASTEN_FULL_CONFIG__ !== "undefined" ? __SETZKASTEN_FULL_CONFIG__ : null;
+  return buildConfig ?? globalThis.__SETZKASTEN_FULL_CONFIG__;
+}
+var POST = async ({ request, cookies }) => {
+  const session = cookies.get("setzkasten_session")?.value;
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  const tokenResult = await resolveGitHubTokenForRequest(request);
+  if (!tokenResult.ok) {
+    return new Response(tokenResult.error.message, { status: 500 });
+  }
+  const githubToken = tokenResult.value;
+  try {
+    const body = await request.json();
+    const storage = await resolveStorageConfigForRequest(request, body);
+    if (!storage) {
+      return Response.json({ error: "Could not resolve owner/repo. Set SETZKASTEN_OWNER and SETZKASTEN_REPO env vars." }, { status: 400 });
+    }
+    const { owner, repo, branch, projectPrefix } = storage;
+    const { pagePath } = body;
+    if (!pagePath) {
+      return Response.json({ error: "pagePath is required" }, { status: 400 });
+    }
+    const config = resolveFullConfig();
+    const managedSections = /* @__PURE__ */ new Map();
+    if (config) {
+      for (const product of Object.values(config.products)) {
+        for (const [key, section] of Object.entries(product.sections)) {
+          managedSections.set(key, new Set(Object.keys(section.fields)));
+        }
+      }
+    }
+    const treeResponse = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`,
+      githubToken
+    );
+    if (!treeResponse.ok) {
+      return Response.json(
+        { error: `Failed to fetch repo tree: ${treeResponse.status}` },
+        { status: treeResponse.status }
+      );
+    }
+    const treeData = await treeResponse.json();
+    const files = treeData.tree.map((item) => ({
+      path: item.path,
+      type: item.type
+    }));
+    let fullPagePath = prefixPath(pagePath, projectPrefix);
+    let pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken);
+    if (!pageSource && pagePath.endsWith(".astro")) {
+      const indexPath = pagePath.replace(/\.astro$/, "/index.astro");
+      fullPagePath = prefixPath(indexPath, projectPrefix);
+      pageSource = await fetchFileContent(owner, repo, branch, fullPagePath, githubToken);
+    }
+    if (!pageSource) {
+      return Response.json({ error: `Could not read page source: ${fullPagePath}` }, { status: 404 });
+    }
+    const imports = extractSectionImports(pageSource, fullPagePath, files, projectPrefix);
+    const serverConfig = globalThis.__SETZKASTEN_CONFIG__;
+    const contentPath = serverConfig?.storage?.contentPath || "content";
+    const unmanagedSections = [];
+    const managedUpdates = [];
+    for (const imp of imports) {
+      if (!imp.resolvedPath) continue;
+      if (!managedSections.has(imp.sectionKey)) {
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken);
+        if (!sectionSource) continue;
+        const section = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath
+        );
+        unmanagedSections.push(section);
+      } else {
+        const existingFieldKeys = managedSections.get(imp.sectionKey);
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken);
+        if (!sectionSource) continue;
+        const inferred = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath
+        );
+        const sectionJsonPath = `${contentPath}/_sections/${imp.sectionKey}.json`;
+        const sectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken);
+        const existingValues = /* @__PURE__ */ new Set();
+        if (sectionJson) {
+          try {
+            const data = JSON.parse(sectionJson);
+            for (const val of Object.values(data)) {
+              if (typeof val === "string" && val.length >= 2) existingValues.add(val);
+            }
+          } catch {
+          }
+        }
+        const missingFields = inferred.fields.filter((f) => {
+          if (existingFieldKeys.has(f.key)) return false;
+          if (typeof f.defaultValue === "string" && existingValues.has(f.defaultValue)) return false;
+          return true;
+        });
+        if (missingFields.length > 0) {
+          managedUpdates.push({
+            key: imp.sectionKey,
+            componentName: imp.componentName,
+            componentPath: imp.resolvedPath,
+            missingFields,
+            allFields: inferred.fields
+          });
+        }
+      }
+    }
+    {
+      const pageKeyNorm = pagePath.replace(/^src\/pages\//, "").replace(/\/(index)?\.astro$/, "").replace(/\.astro$/, "") || "index";
+      const sectionKey = "_page_" + pageKeyNorm.replace(/\//g, "_");
+      const pageSection = await analyzeAstroSection(
+        pageSource,
+        sectionKey,
+        pageKeyNorm.replace(/\//g, "_") + "Page",
+        fullPagePath,
+        { mode: "page" }
+      );
+      pageSection.isPageLevel = true;
+      if (!managedSections.has(sectionKey)) {
+        if (pageSection.fields.length > 0) {
+          unmanagedSections.push(pageSection);
+        }
+      } else {
+        const existingFieldKeys = managedSections.get(sectionKey);
+        const sectionJsonPath = `${contentPath}/_sections/${sectionKey}.json`;
+        const sectionJson = await fetchFileContent(owner, repo, branch, sectionJsonPath, githubToken);
+        const existingValues = /* @__PURE__ */ new Set();
+        if (sectionJson) {
+          try {
+            const data = JSON.parse(sectionJson);
+            for (const val of Object.values(data)) {
+              if (typeof val === "string" && val.length >= 2) existingValues.add(val);
+            }
+          } catch {
+          }
+        }
+        const missingFields = pageSection.fields.filter((f) => {
+          if (existingFieldKeys.has(f.key)) return false;
+          if (typeof f.defaultValue === "string" && existingValues.has(f.defaultValue)) return false;
+          return true;
+        });
+        if (missingFields.length > 0) {
+          managedUpdates.push({
+            key: sectionKey,
+            componentName: pageKeyNorm.replace(/\//g, "_") + "Page",
+            componentPath: fullPagePath,
+            missingFields,
+            allFields: pageSection.fields
+          });
+        }
+      }
+    }
+    {
+      const layoutImport = extractLayoutImport(pageSource, fullPagePath, files, projectPrefix);
+      if (layoutImport?.resolvedPath) {
+        const layoutSource = await fetchFileContent(owner, repo, branch, layoutImport.resolvedPath, githubToken);
+        if (layoutSource) {
+          for (const region of extractLayoutRegions(layoutSource)) {
+            const sectionKey = `_layout_${region.name}`;
+            if (managedSections.has(sectionKey)) continue;
+            const regionSource = `---
+---
+
+${region.html}`;
+            const section = await analyzeAstroSection(
+              regionSource,
+              sectionKey,
+              region.name,
+              layoutImport.resolvedPath,
+              { mode: "page" }
+            );
+            section.isPageLevel = true;
+            section.isLayoutRegion = true;
+            section.layoutPath = layoutImport.resolvedPath;
+            section.regionTag = region.tag;
+            if (section.fields.length > 0) {
+              unmanagedSections.push(section);
+            }
+          }
+        }
+      }
+    }
+    return Response.json({ unmanagedSections, managedUpdates });
+  } catch (error) {
+    console.error("[setzkasten] scan-page error:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Scan failed" },
+      { status: 500 }
+    );
+  }
+};
+async function githubFetch(url, token) {
+  return fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    }
+  });
+}
+function extractLayoutRegions(layoutSource) {
+  let template = layoutSource;
+  if (layoutSource.startsWith("---")) {
+    const endIdx = layoutSource.indexOf("\n---", 3);
+    if (endIdx !== -1) {
+      template = layoutSource.slice(endIdx + 4);
+    }
+  }
+  const regions = [];
+  for (const tag of ["header", "footer"]) {
+    const openTag = new RegExp(`<${tag}(\\s[^>]*)?>`, "i");
+    const openMatch = openTag.exec(template);
+    if (!openMatch) continue;
+    const closeTag = `</${tag}>`;
+    const closeIdx = template.indexOf(closeTag, openMatch.index);
+    if (closeIdx === -1) continue;
+    const html = template.slice(openMatch.index, closeIdx + closeTag.length);
+    regions.push({ name: tag, tag, html });
+  }
+  return regions;
+}
+async function fetchFileContent(owner, repo, branch, path, token) {
+  try {
+    const response = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      token
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    return data.encoding === "base64" ? Buffer.from(data.content, "base64").toString("utf-8") : data.content;
+  } catch {
+    return null;
+  }
+}
+export {
+  POST,
+  extractLayoutRegions,
+  resolveFullConfig
+};

package/dist/api-routes/init-scan.d.ts

@@ -0,0 +1,11 @@
+import { APIRoute } from 'astro';
+
+/**
+ * POST /api/setzkasten/init/scan
+ *
+ * Scans a GitHub repo and returns project analysis + detected sections.
+ * Body: { owner: string, repo: string, branch?: string }
+ */
+declare const POST: APIRoute;
+
+export { POST };

package/dist/api-routes/init-scan.js

@@ -0,0 +1,128 @@
+import {
+  analyzeAstroSection,
+  extractSectionImports,
+  findAstroPages
+} from "../chunk-K22A4ZBS.js";
+import {
+  resolveGitHubTokenForRequest
+} from "../chunk-NKDATSPA.js";
+
+// src/api-routes/init-scan.ts
+import { analyzeProject } from "@setzkasten-cms/core/init";
+var POST = async ({ request, cookies }) => {
+  const session = cookies.get("setzkasten_session")?.value;
+  if (!session) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+  const tokenResult = await resolveGitHubTokenForRequest(request);
+  if (!tokenResult.ok) {
+    return new Response(tokenResult.error.message, { status: 500 });
+  }
+  const githubToken = tokenResult.value;
+  try {
+    const body = await request.json();
+    const { owner, repo, branch = "main" } = body;
+    if (!owner || !repo) {
+      return Response.json({ error: "owner and repo are required" }, { status: 400 });
+    }
+    const treeResponse = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/git/trees/${branch}?recursive=1`,
+      githubToken
+    );
+    if (!treeResponse.ok) {
+      return Response.json(
+        { error: `Failed to fetch repo tree: ${treeResponse.status}` },
+        { status: treeResponse.status }
+      );
+    }
+    const treeData = await treeResponse.json();
+    const files = treeData.tree.map((item) => ({
+      path: item.path,
+      type: item.type
+    }));
+    const analysis = analyzeProject(files);
+    const astroRoot = analysis.projectRoots.find((r) => r.framework === "astro");
+    if (!astroRoot) {
+      return Response.json({
+        analysis,
+        pages: [],
+        sections: [],
+        astroConfigPath: null,
+        message: "Kein Astro-Projekt gefunden"
+      });
+    }
+    const pages = findAstroPages(files, astroRoot.path);
+    const allSections = /* @__PURE__ */ new Map();
+    const pageSections = {};
+    for (const page of pages) {
+      const pageSource = await fetchFileContent(owner, repo, branch, page.filePath, githubToken);
+      if (!pageSource) continue;
+      const imports = extractSectionImports(pageSource, page.filePath, files, astroRoot.path);
+      pageSections[page.pageKey] = imports.map((i) => i.sectionKey);
+      for (const imp of imports) {
+        if (allSections.has(imp.sectionKey)) continue;
+        if (!imp.resolvedPath) continue;
+        const sectionSource = await fetchFileContent(owner, repo, branch, imp.resolvedPath, githubToken);
+        if (!sectionSource) continue;
+        const section = await analyzeAstroSection(
+          sectionSource,
+          imp.sectionKey,
+          imp.componentName,
+          imp.resolvedPath
+        );
+        allSections.set(imp.sectionKey, section);
+      }
+    }
+    const astroConfigCandidates = ["astro.config.mjs", "astro.config.ts", "astro.config.js"];
+    let astroConfigPath = null;
+    for (const candidate of astroConfigCandidates) {
+      const path = astroRoot.path ? `${astroRoot.path}/${candidate}` : candidate;
+      if (files.some((f) => f.path === path)) {
+        astroConfigPath = path;
+        break;
+      }
+    }
+    return Response.json({
+      analysis,
+      projectRoot: astroRoot.path,
+      pages,
+      pageSections,
+      sections: Object.fromEntries(allSections),
+      astroConfigPath
+    });
+  } catch (error) {
+    console.error("[setzkasten] Init scan error:", error);
+    return Response.json(
+      { error: error instanceof Error ? error.message : "Scan failed" },
+      { status: 500 }
+    );
+  }
+};
+async function githubFetch(url, token) {
+  return fetch(url, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github+json",
+      "X-GitHub-Api-Version": "2022-11-28"
+    }
+  });
+}
+async function fetchFileContent(owner, repo, branch, path, token) {
+  try {
+    const response = await githubFetch(
+      `https://api.github.com/repos/${owner}/${repo}/contents/${path}?ref=${branch}`,
+      token
+    );
+    if (!response.ok) return null;
+    const data = await response.json();
+    if (data.encoding === "base64") {
+      return Buffer.from(data.content, "base64").toString("utf-8");
+    }
+    return data.content;
+  } catch {
+    return null;
+  }
+}
+export {
+  POST
+};

package/dist/api-routes/migrate-to-multi.d.ts

@@ -0,0 +1,26 @@
+import { APIRoute } from 'astro';
+
+/**
+ * POST /api/setzkasten/migrate/to-multi
+ *
+ * Body: { configRepo: 'owner/repo', configInstallationId: string,
+ *         previewOrigin?: string }
+ *
+ * Admin-only. Expects the deployer to have already (1) created the
+ * config repo and (2) installed the GitHub App on it. The endpoint then:
+ *
+ * 1. Reads `_editors.json` and `_global_config.json` from the current
+ *    single-mode website repo.
+ * 2. Writes both files into `<config-repo>/content/`.
+ * 3. Initialises `<config-repo>/websites.json` with a single entry that
+ *    snapshots the current single-mode setup (repo, branch, preview
+ *    origin, App-Installation-ID).
+ *
+ * After a 200 response the deployer still has to update
+ * `setzkasten.config.ts` (kind: 'single' → 'multi') and the ENV
+ * variables and redeploy. The wizard surfaces a copy-ready diff for
+ * those manual steps.
+ */
+declare const POST: APIRoute;
+
+export { POST };

package/dist/api-routes/migrate-to-multi.js

@@ -0,0 +1,188 @@
+import {
+  parseSession
+} from "../chunk-INIWFKQ3.js";
+import {
+  resolveStorageConfig
+} from "../chunk-6UIKVKED.js";
+import "../chunk-5PIMDP4N.js";
+import "../chunk-45ARVNT3.js";
+import {
+  resolveConfigRepoToken
+} from "../chunk-NKDATSPA.js";
+import {
+  resolveLicenseTier
+} from "../chunk-TJNJKPUL.js";
+import {
+  withTrailers
+} from "../chunk-KH22FJO5.js";
+
+// src/api-routes/migrate-to-multi.ts
+import { canAddWebsite, isMultiModeAvailable } from "@setzkasten-cms/core";
+var POST = async ({ request, cookies }) => {
+  const session = parseSession(cookies.get("setzkasten_session")?.value);
+  if (!session) return new Response(JSON.stringify({ error: "Unauthorized" }), { status: 401 });
+  if (session.user.role !== "admin")
+    return new Response(JSON.stringify({ error: "Forbidden" }), { status: 403 });
+  const tier = resolveLicenseTier();
+  if (!isMultiModeAvailable(tier)) {
+    return new Response(
+      JSON.stringify({
+        error: "Multi-Mode ist nur mit Pro- oder Enterprise-Lizenz verf\xFCgbar.",
+        tier
+      }),
+      { status: 402, headers: { "Content-Type": "application/json" } }
+    );
+  }
+  let body = {};
+  try {
+    body = await request.json();
+  } catch {
+    return new Response(JSON.stringify({ error: "Invalid JSON body" }), { status: 400 });
+  }
+  if (!body.configRepo || typeof body.configRepo !== "string" || !body.configRepo.includes("/")) {
+    return new Response(JSON.stringify({ error: "configRepo (owner/repo) ist erforderlich" }), {
+      status: 400
+    });
+  }
+  if (!body.configInstallationId || typeof body.configInstallationId !== "string") {
+    return new Response(JSON.stringify({ error: "configInstallationId ist erforderlich" }), {
+      status: 400
+    });
+  }
+  const fullConfig = globalThis.__SETZKASTEN_FULL_CONFIG__;
+  if (fullConfig?.storage?.kind && fullConfig.storage.kind !== "single" && fullConfig.storage.kind !== "github-app") {
+    return new Response(
+      JSON.stringify({
+        error: `Migration nur aus dem Single-Mode m\xF6glich. Aktueller storage.kind: ${fullConfig.storage.kind ?? "unbekannt"}`
+      }),
+      { status: 400 }
+    );
+  }
+  const allowed = canAddWebsite(tier, 0);
+  if (!allowed.ok) {
+    return new Response(JSON.stringify({ error: allowed.reason }), { status: 402 });
+  }
+  const sourceStorage = resolveStorageConfig();
+  if (!sourceStorage) {
+    return new Response(
+      JSON.stringify({ error: "Single-Mode Storage konnte nicht aufgel\xF6st werden" }),
+      { status: 500 }
+    );
+  }
+  const tokenResult = await resolveConfigRepoToken();
+  if (!tokenResult.ok) {
+    return new Response(JSON.stringify({ error: tokenResult.error.message }), { status: 500 });
+  }
+  const token = tokenResult.value;
+  const [configOwner, configRepo] = body.configRepo.split("/");
+  if (!configOwner || !configRepo) {
+    return new Response(JSON.stringify({ error: 'configRepo muss "owner/repo" sein' }), {
+      status: 400
+    });
+  }
+  const sourceContentPath = globalThis.__SETZKASTEN_CONFIG__?.storage?.contentPath ?? "content";
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "Content-Type": "application/json"
+  };
+  const ghBase = (owner, repo, path) => `https://api.github.com/repos/${owner}/${repo}/contents/${path}`;
+  const sourceEditors = await readOptional(
+    ghBase(sourceStorage.owner, sourceStorage.repo, `${sourceContentPath}/_editors.json`),
+    `?ref=${sourceStorage.branch}`,
+    headers
+  );
+  const sourceGlobal = await readOptional(
+    ghBase(sourceStorage.owner, sourceStorage.repo, `${sourceContentPath}/_global_config.json`),
+    `?ref=${sourceStorage.branch}`,
+    headers
+  );
+  const configBranch = "main";
+  const editorsCommit = sourceEditors ? await putFile(
+    ghBase(configOwner, configRepo, "content/_editors.json"),
+    sourceEditors,
+    configBranch,
+    "chore(migrate): copy editors from website repo",
+    headers
+  ) : true;
+  const globalCommit = sourceGlobal ? await putFile(
+    ghBase(configOwner, configRepo, "content/_global_config.json"),
+    sourceGlobal,
+    configBranch,
+    "chore(migrate): copy global config from website repo",
+    headers
+  ) : true;
+  const previewOrigin = body.previewOrigin ?? process.env.PUBLIC_SITE_URL ?? "http://localhost:4321";
+  const initialEntry = {
+    id: "main",
+    name: sourceStorage.repo,
+    repo: `${sourceStorage.owner}/${sourceStorage.repo}`,
+    branch: sourceStorage.branch,
+    previewOrigin,
+    githubApp: {
+      appId: process.env.GITHUB_APP_ID ?? "",
+      installationId: process.env.GITHUB_APP_INSTALLATION_ID ?? ""
+    }
+  };
+  const websitesContent = JSON.stringify({ websites: [initialEntry] }, null, 2);
+  const websitesCommit = await putFile(
+    ghBase(configOwner, configRepo, "websites.json"),
+    websitesContent,
+    configBranch,
+    "feat(migrate): initialise websites.json with current single-mode setup",
+    headers
+  );
+  return new Response(
+    JSON.stringify({
+      ok: true,
+      committed: {
+        editors: editorsCommit,
+        globalConfig: globalCommit,
+        websites: websitesCommit
+      },
+      // Echo back the values the user still has to set themselves.
+      manual: {
+        configRepo: body.configRepo,
+        configInstallationId: body.configInstallationId,
+        configBranch,
+        envChanges: {
+          add: {
+            SETZKASTEN_CONFIG_REPO: body.configRepo,
+            SETZKASTEN_CONFIG_BRANCH: configBranch,
+            GITHUB_APP_CONFIG_INSTALLATION_ID: body.configInstallationId
+          }
+        }
+      }
+    }),
+    { status: 200, headers: { "Content-Type": "application/json" } }
+  );
+};
+async function readOptional(url, qs, headers) {
+  const res = await fetch(url + qs, { headers });
+  if (!res.ok) return null;
+  const data = await res.json();
+  return data.encoding === "base64" ? Buffer.from(data.content, "base64").toString("utf-8") : data.content;
+}
+async function putFile(url, content, branch, message, headers) {
+  let sha;
+  try {
+    const existing = await fetch(`${url}?ref=${branch}`, { headers });
+    if (existing.ok) {
+      const data = await existing.json();
+      sha = data.sha;
+    }
+  } catch {
+  }
+  const body = {
+    message: withTrailers(message),
+    content: Buffer.from(content).toString("base64"),
+    branch
+  };
+  if (sha) body.sha = sha;
+  const res = await fetch(url, { method: "PUT", headers, body: JSON.stringify(body) });
+  return res.ok;
+}
+export {
+  POST
+};

package/dist/api-routes/pages.d.ts

@@ -0,0 +1,39 @@
+import { APIRoute } from 'astro';
+
+interface PageInfo {
+    path: string;
+    pageKey: string;
+    label: string;
+    hasConfig: boolean;
+    /** Unix-ms timestamp of the page's last Setzkasten-driven commit, when
+     *  `_pages-meta.json` knows about the page. */
+    lastModified?: number;
+}
+/**
+ * Returns the list of pages scanned at build time.
+ * Reads the Vite build-time constant first; falls back to globalThis for
+ * local dev / test environments where the define is not applied.
+ *
+ * Only valid in single-mode where the admin and the website share the same
+ * Astro project. Multi-mode has to fetch the page list per website at
+ * runtime (see {@link fetchPagesFromGitHub}).
+ */
+declare function resolvePages(): PageInfo[];
+/**
+ * GET /api/setzkasten/pages
+ *
+ * Single-mode: returns the build-time scan from the admin's own Astro
+ * project, enriched with `_pages-meta.json` timestamps from the
+ * (single) repo.
+ *
+ * Multi-mode: the X-SK-Website header selects one of the registered
+ * websites. The admin doesn't have build-time access to that website's
+ * `src/pages/` directory, so we fetch it via the GitHub Contents API
+ * (cached for 5 min), then enrich with the per-website
+ * `_pages-meta.json`. Without this branch, every website in Multi-Mode
+ * would see the admin's own page list — typically a single "index"
+ * stub — instead of its real pages.
+ */
+declare const GET: APIRoute;
+
+export { GET, resolvePages };