@projectdochelp/s3te 1.0.0

package/packages/core/src/config.mjs

@@ -0,0 +1,464 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+import { assert, S3teError } from "./errors.mjs";
+
+const KNOWN_PLACEHOLDERS = new Set(["env", "stackPrefix", "project", "variant", "lang"]);
+
+function upperSnakeCase(value) {
+  return value.replace(/-/g, "_").toUpperCase();
+}
+
+function findPlaceholders(input) {
+  return [...String(input).matchAll(/\{([^{}]+)\}/g)].map((match) => match[1]);
+}
+
+function ensureKnownPlaceholders(input, fieldPath, errors) {
+  for (const token of findPlaceholders(input)) {
+    if (KNOWN_PLACEHOLDERS.has(token)) {
+      continue;
+    }
+
+    errors.push({
+      code: "CONFIG_PLACEHOLDER_ERROR",
+      message: `Unknown placeholder {${token}} in ${fieldPath}.`,
+      details: { fieldPath, token }
+    });
+  }
+}
+
+function replacePlaceholders(input, values) {
+  return String(input).replace(/\{(env|stackPrefix|project|variant|lang)\}/g, (_, token) => values[token]);
+}
+
+function normalizeRelativeProjectPath(relativePath) {
+  const normalized = String(relativePath).replace(/\\/g, "/");
+  assert(!path.isAbsolute(normalized), "CONFIG_PATH_ERROR", "Absolute project paths are not allowed.", { relativePath });
+  assert(!normalized.split("/").includes(".."), "CONFIG_PATH_ERROR", "Parent traversal is not allowed in project paths.", { relativePath });
+  return normalized;
+}
+
+function isValidProjectName(name) {
+  return /^[a-z0-9-]+$/.test(name);
+}
+
+function isValidUpperSnake(value) {
+  return /^[A-Z0-9_]+$/.test(value);
+}
+
+function defaultTargetBucketPattern({ variant, language, languageCount, isDefaultLanguage, project }) {
+  if (languageCount === 1 || isDefaultLanguage) {
+    return `{env}-${variant}-${project}`;
+  }
+
+  return `{env}-${variant}-${project}-${language}`;
+}
+
+async function ensureDirectoryExists(projectDir, relativePath, errors) {
+  const targetPath = path.join(projectDir, relativePath);
+  try {
+    const stat = await fs.stat(targetPath);
+    if (!stat.isDirectory()) {
+      errors.push({
+        code: "CONFIG_PATH_ERROR",
+        message: `Expected directory but found file: ${relativePath}`,
+        details: { relativePath }
+      });
+    }
+  } catch {
+    errors.push({
+      code: "CONFIG_PATH_ERROR",
+      message: `Missing directory: ${relativePath}`,
+      details: { relativePath }
+    });
+  }
+}
+
+function createPlaceholderContext(config, environmentName, variantName, languageCode) {
+  const environmentConfig = config.environments[environmentName];
+  const variantConfig = variantName ? config.variants[variantName] : null;
+  return {
+    env: environmentName,
+    stackPrefix: environmentConfig.stackPrefix,
+    project: config.project.name,
+    variant: variantName ?? "website",
+    lang: languageCode ?? variantConfig?.defaultLanguage ?? "en"
+  };
+}
+
+export async function loadProjectConfig(configPath) {
+  const raw = await fs.readFile(configPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new S3teError("CONFIG_SCHEMA_ERROR", "Config file is not valid JSON.", { configPath, cause: error.message });
+  }
+}
+
+export function resolveProjectConfig(projectConfig) {
+  const configVersion = projectConfig.configVersion ?? 1;
+  const project = {
+    name: projectConfig.project?.name,
+    displayName: projectConfig.project?.displayName
+  };
+
+  const rendering = {
+    minifyHtml: projectConfig.rendering?.minifyHtml ?? true,
+    renderExtensions: projectConfig.rendering?.renderExtensions ?? [".html", ".htm", ".part"],
+    outputDir: projectConfig.rendering?.outputDir ?? "offline/S3TELocal/preview",
+    maxRenderDepth: projectConfig.rendering?.maxRenderDepth ?? 50
+  };
+
+  const environments = {};
+  for (const [environmentName, environmentConfig] of Object.entries(projectConfig.environments ?? {})) {
+    environments[environmentName] = {
+      name: environmentName,
+      awsRegion: environmentConfig.awsRegion,
+      stackPrefix: environmentConfig.stackPrefix ?? upperSnakeCase(environmentName),
+      certificateArn: environmentConfig.certificateArn,
+      route53HostedZoneId: environmentConfig.route53HostedZoneId
+    };
+  }
+
+  const variants = {};
+  const awsCodeBuckets = { ...(projectConfig.aws?.codeBuckets ?? {}) };
+
+  for (const [variantName, variantConfig] of Object.entries(projectConfig.variants ?? {})) {
+    const languages = {};
+    const languageEntries = Object.entries(variantConfig.languages ?? {});
+    for (const [languageCode, languageConfig] of languageEntries) {
+      languages[languageCode] = {
+        code: languageCode,
+        baseUrl: languageConfig.baseUrl,
+        targetBucket: languageConfig.targetBucket,
+        cloudFrontAliases: [...(languageConfig.cloudFrontAliases ?? [])],
+        webinyLocale: languageConfig.webinyLocale ?? languageCode
+      };
+    }
+
+    variants[variantName] = {
+      name: variantName,
+      sourceDir: normalizeRelativeProjectPath(variantConfig.sourceDir ?? `app/${variantName}`),
+      partDir: normalizeRelativeProjectPath(variantConfig.partDir ?? "app/part"),
+      defaultLanguage: variantConfig.defaultLanguage,
+      routing: {
+        indexDocument: variantConfig.routing?.indexDocument ?? "index.html",
+        notFoundDocument: variantConfig.routing?.notFoundDocument ?? "404.html"
+      },
+      languages
+    };
+
+    awsCodeBuckets[variantName] = awsCodeBuckets[variantName] ?? "{env}-{variant}-code-{project}";
+  }
+
+  const aws = {
+    codeBuckets: awsCodeBuckets,
+    dependencyStore: {
+      tableName: projectConfig.aws?.dependencyStore?.tableName ?? "{stackPrefix}_s3te_dependencies_{project}"
+    },
+    contentStore: {
+      tableName: projectConfig.aws?.contentStore?.tableName ?? "{stackPrefix}_s3te_content_{project}",
+      contentIdIndexName: projectConfig.aws?.contentStore?.contentIdIndexName ?? "contentid"
+    },
+    invalidationStore: {
+      tableName: projectConfig.aws?.invalidationStore?.tableName ?? "{stackPrefix}_s3te_invalidations_{project}",
+      debounceSeconds: projectConfig.aws?.invalidationStore?.debounceSeconds ?? 60
+    },
+    lambda: {
+      runtime: projectConfig.aws?.lambda?.runtime ?? "nodejs22.x",
+      architecture: projectConfig.aws?.lambda?.architecture ?? "arm64"
+    }
+  };
+
+  const integrations = {
+    webiny: {
+      enabled: projectConfig.integrations?.webiny?.enabled ?? false,
+      sourceTableName: projectConfig.integrations?.webiny?.sourceTableName,
+      mirrorTableName: projectConfig.integrations?.webiny?.mirrorTableName ?? "{stackPrefix}_s3te_content_{project}",
+      relevantModels: projectConfig.integrations?.webiny?.relevantModels ?? ["staticContent", "staticCodeContent"],
+      tenant: projectConfig.integrations?.webiny?.tenant
+    }
+  };
+
+  for (const [variantName, variantConfig] of Object.entries(variants)) {
+    const languageEntries = Object.values(variantConfig.languages);
+    const languageCount = languageEntries.length;
+    for (const languageConfig of languageEntries) {
+      languageConfig.targetBucket = languageConfig.targetBucket ?? defaultTargetBucketPattern({
+        variant: variantName,
+        language: languageConfig.code,
+        languageCount,
+        isDefaultLanguage: languageConfig.code === variantConfig.defaultLanguage,
+        project: project.name
+      });
+    }
+  }
+
+  return {
+    configVersion,
+    project,
+    environments,
+    rendering,
+    variants,
+    aws,
+    integrations
+  };
+}
+
+export function resolveCodeBucketName(config, environmentName, variantName) {
+  return replacePlaceholders(
+    config.aws.codeBuckets[variantName],
+    createPlaceholderContext(config, environmentName, variantName)
+  );
+}
+
+export function resolveTargetBucketName(config, environmentName, variantName, languageCode) {
+  return replacePlaceholders(
+    config.variants[variantName].languages[languageCode].targetBucket,
+    createPlaceholderContext(config, environmentName, variantName, languageCode)
+  );
+}
+
+export function resolveTableNames(config, environmentName) {
+  const context = createPlaceholderContext(config, environmentName);
+  return {
+    dependency: replacePlaceholders(config.aws.dependencyStore.tableName, context),
+    content: replacePlaceholders(config.aws.contentStore.tableName, context),
+    invalidation: replacePlaceholders(config.aws.invalidationStore.tableName, context),
+    webinyMirror: replacePlaceholders(config.integrations.webiny.mirrorTableName, context)
+  };
+}
+
+export function resolveRuntimeManifestParameterName(config, environmentName) {
+  const environmentConfig = config.environments[environmentName];
+  return `/${environmentConfig.stackPrefix}/s3te/${config.project.name}/runtime-manifest`;
+}
+
+export function resolveStackName(config, environmentName) {
+  return `${config.environments[environmentName].stackPrefix}-s3te-${config.project.name}`;
+}
+
+export function buildEnvironmentRuntimeConfig(config, environmentName, stackOutputs = {}) {
+  const environmentConfig = config.environments[environmentName];
+  const tables = resolveTableNames(config, environmentName);
+  const runtimeParameterName = resolveRuntimeManifestParameterName(config, environmentName);
+  const stackName = resolveStackName(config, environmentName);
+  const variants = {};
+
+  for (const [variantName, variantConfig] of Object.entries(config.variants)) {
+    const languages = {};
+    for (const [languageCode, languageConfig] of Object.entries(variantConfig.languages)) {
+      const targetBucket = resolveTargetBucketName(config, environmentName, variantName, languageCode);
+      languages[languageCode] = {
+        code: languageCode,
+        baseUrl: languageConfig.baseUrl,
+        targetBucket,
+        cloudFrontAliases: [...languageConfig.cloudFrontAliases],
+        webinyLocale: languageConfig.webinyLocale,
+        distributionId: stackOutputs.distributionIds?.[variantName]?.[languageCode] ?? "",
+        distributionDomainName: stackOutputs.distributionDomains?.[variantName]?.[languageCode] ?? ""
+      };
+    }
+
+    variants[variantName] = {
+      name: variantName,
+      sourceDir: variantConfig.sourceDir,
+      partDir: variantConfig.partDir,
+      defaultLanguage: variantConfig.defaultLanguage,
+      routing: { ...variantConfig.routing },
+      codeBucket: resolveCodeBucketName(config, environmentName, variantName),
+      languages
+    };
+  }
+
+  return {
+    name: environmentName,
+    awsRegion: environmentConfig.awsRegion,
+    stackPrefix: environmentConfig.stackPrefix,
+    certificateArn: environmentConfig.certificateArn,
+    route53HostedZoneId: environmentConfig.route53HostedZoneId,
+    stackName,
+    runtimeParameterName,
+    tables,
+    lambda: { ...config.aws.lambda },
+    rendering: { ...config.rendering },
+    integrations: {
+      webiny: {
+        ...config.integrations.webiny,
+        mirrorTableName: tables.webinyMirror
+      }
+    },
+    variants
+  };
+}
+
+export async function validateAndResolveProjectConfig(projectConfig, options = {}) {
+  const projectDir = options.projectDir ?? process.cwd();
+  const errors = [];
+  const warnings = [];
+
+  if (!projectConfig || typeof projectConfig !== "object") {
+    throw new S3teError("CONFIG_SCHEMA_ERROR", "Project config must be an object.");
+  }
+
+  if (!projectConfig.project || typeof projectConfig.project !== "object") {
+    errors.push({ code: "CONFIG_SCHEMA_ERROR", message: "Missing project block." });
+  } else if (!isValidProjectName(projectConfig.project.name ?? "")) {
+    errors.push({
+      code: "CONFIG_SCHEMA_ERROR",
+      message: "project.name must match ^[a-z0-9-]+$.",
+      details: { value: projectConfig.project.name }
+    });
+  }
+
+  const environmentEntries = Object.entries(projectConfig.environments ?? {});
+  if (environmentEntries.length === 0) {
+    errors.push({ code: "CONFIG_SCHEMA_ERROR", message: "At least one environment is required." });
+  }
+
+  for (const [environmentName, environmentConfig] of environmentEntries) {
+    if (!environmentConfig.awsRegion) {
+      errors.push({ code: "CONFIG_SCHEMA_ERROR", message: `Environment ${environmentName} is missing awsRegion.` });
+    }
+    if (!environmentConfig.certificateArn) {
+      errors.push({ code: "CONFIG_SCHEMA_ERROR", message: `Environment ${environmentName} is missing certificateArn.` });
+    } else if (!/^arn:aws:acm:us-east-1:\d{12}:certificate\/.+$/.test(environmentConfig.certificateArn)) {
+      errors.push({
+        code: "CONFIG_CONFLICT_ERROR",
+        message: `Environment ${environmentName} certificateArn must point to ACM in us-east-1.`,
+        details: { certificateArn: environmentConfig.certificateArn }
+      });
+    }
+    if (environmentConfig.stackPrefix && !isValidUpperSnake(environmentConfig.stackPrefix)) {
+      errors.push({
+        code: "CONFIG_SCHEMA_ERROR",
+        message: `Environment ${environmentName} stackPrefix must match ^[A-Z0-9_]+$.`,
+        details: { stackPrefix: environmentConfig.stackPrefix }
+      });
+    }
+  }
+
+  const variantEntries = Object.entries(projectConfig.variants ?? {});
+  if (variantEntries.length === 0) {
+    errors.push({ code: "CONFIG_SCHEMA_ERROR", message: "At least one variant is required." });
+  }
+
+  for (const [variantName, variantConfig] of variantEntries) {
+    const languageEntries = Object.entries(variantConfig.languages ?? {});
+    if (languageEntries.length === 0) {
+      errors.push({ code: "CONFIG_SCHEMA_ERROR", message: `Variant ${variantName} needs at least one language.` });
+      continue;
+    }
+
+    if (!variantConfig.defaultLanguage || !variantConfig.languages?.[variantConfig.defaultLanguage]) {
+      errors.push({
+        code: "CONFIG_CONFLICT_ERROR",
+        message: `Variant ${variantName} defaultLanguage must exist in languages.`
+      });
+    }
+
+    for (const [languageCode, languageConfig] of languageEntries) {
+      if (!languageConfig.baseUrl) {
+        errors.push({
+          code: "CONFIG_SCHEMA_ERROR",
+          message: `Variant ${variantName} language ${languageCode} is missing baseUrl.`
+        });
+      }
+      if (!Array.isArray(languageConfig.cloudFrontAliases) || languageConfig.cloudFrontAliases.length === 0) {
+        errors.push({
+          code: "CONFIG_SCHEMA_ERROR",
+          message: `Variant ${variantName} language ${languageCode} needs at least one cloudFrontAlias.`
+        });
+      }
+      if (languageConfig.webinyLocale !== undefined && typeof languageConfig.webinyLocale !== "string") {
+        errors.push({
+          code: "CONFIG_SCHEMA_ERROR",
+          message: `Variant ${variantName} language ${languageCode} webinyLocale must be a string.`,
+          details: { value: languageConfig.webinyLocale }
+        });
+      }
+      if (languageConfig.targetBucket) {
+        ensureKnownPlaceholders(languageConfig.targetBucket, `variants.${variantName}.languages.${languageCode}.targetBucket`, errors);
+      }
+    }
+  }
+
+  if (projectConfig.integrations?.webiny?.enabled && !projectConfig.integrations?.webiny?.sourceTableName) {
+    errors.push({
+      code: "CONFIG_CONFLICT_ERROR",
+      message: "Webiny integration requires sourceTableName when enabled."
+    });
+  }
+
+  for (const [variantName, pattern] of Object.entries(projectConfig.aws?.codeBuckets ?? {})) {
+    ensureKnownPlaceholders(pattern, `aws.codeBuckets.${variantName}`, errors);
+  }
+
+  if (projectConfig.aws?.dependencyStore?.tableName) {
+    ensureKnownPlaceholders(projectConfig.aws.dependencyStore.tableName, "aws.dependencyStore.tableName", errors);
+  }
+  if (projectConfig.aws?.contentStore?.tableName) {
+    ensureKnownPlaceholders(projectConfig.aws.contentStore.tableName, "aws.contentStore.tableName", errors);
+  }
+  if (projectConfig.aws?.invalidationStore?.tableName) {
+    ensureKnownPlaceholders(projectConfig.aws.invalidationStore.tableName, "aws.invalidationStore.tableName", errors);
+  }
+  if (projectConfig.integrations?.webiny?.mirrorTableName) {
+    ensureKnownPlaceholders(projectConfig.integrations.webiny.mirrorTableName, "integrations.webiny.mirrorTableName", errors);
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors, warnings, config: null };
+  }
+
+  const resolvedConfig = resolveProjectConfig(projectConfig);
+  const seenTargetBuckets = new Set();
+  const seenCodeBuckets = new Set();
+
+  for (const variantConfig of Object.values(resolvedConfig.variants)) {
+    await ensureDirectoryExists(projectDir, variantConfig.sourceDir, errors);
+    await ensureDirectoryExists(projectDir, variantConfig.partDir, errors);
+  }
+
+  for (const environmentName of Object.keys(resolvedConfig.environments)) {
+    const tables = resolveTableNames(resolvedConfig, environmentName);
+
+    const tableNames = [tables.dependency, tables.content, tables.invalidation];
+    for (const tableName of tableNames) {
+      if (!/^[A-Za-z0-9_.-]+$/.test(tableName)) {
+        errors.push({
+          code: "CONFIG_CONFLICT_ERROR",
+          message: `Resolved table name ${tableName} contains invalid characters.`
+        });
+      }
+    }
+
+    for (const [variantName, variantConfig] of Object.entries(resolvedConfig.variants)) {
+      const codeBucket = resolveCodeBucketName(resolvedConfig, environmentName, variantName);
+      if (seenCodeBuckets.has(codeBucket)) {
+        errors.push({
+          code: "CONFIG_CONFLICT_ERROR",
+          message: `Duplicate code bucket ${codeBucket}.`
+        });
+      }
+      seenCodeBuckets.add(codeBucket);
+
+      for (const languageCode of Object.keys(variantConfig.languages)) {
+        const targetBucket = resolveTargetBucketName(resolvedConfig, environmentName, variantName, languageCode);
+        if (seenTargetBuckets.has(targetBucket)) {
+          errors.push({
+            code: "CONFIG_CONFLICT_ERROR",
+            message: `Duplicate target bucket ${targetBucket}.`
+          });
+        }
+        seenTargetBuckets.add(targetBucket);
+      }
+    }
+  }
+
+  if (errors.length > 0) {
+    return { ok: false, errors, warnings, config: null };
+  }
+
+  return { ok: true, errors, warnings, config: resolvedConfig };
+}

package/packages/core/src/content-query.mjs

@@ -0,0 +1,176 @@
+function legacyAttributeValueToPlain(attribute) {
+  if (attribute == null || typeof attribute !== "object") {
+    return undefined;
+  }
+
+  if ("S" in attribute) {
+    return attribute.S;
+  }
+  if ("N" in attribute) {
+    return Number(attribute.N);
+  }
+  if ("BOOL" in attribute) {
+    return Boolean(attribute.BOOL);
+  }
+  if ("NULL" in attribute) {
+    return null;
+  }
+  if ("L" in attribute) {
+    return attribute.L.map((entry) => legacyAttributeValueToPlain(entry));
+  }
+
+  return undefined;
+}
+
+function readComparableValue(item, field) {
+  if (field === "__typename") {
+    return item.model;
+  }
+  if (field === "contentId") {
+    return item.contentId;
+  }
+  if (field === "id") {
+    return item.id;
+  }
+  if (field === "locale") {
+    return item.locale ?? null;
+  }
+  if (field === "tenant") {
+    return item.tenant ?? null;
+  }
+  if (field === "_version") {
+    return item.version ?? null;
+  }
+  if (field === "_lastChangedAt") {
+    return item.lastChangedAt ?? null;
+  }
+
+  return item.values?.[field];
+}
+
+function compareFilter(actual, expected, filterType) {
+  if (filterType === "contains") {
+    if (Array.isArray(actual)) {
+      return actual.includes(expected);
+    }
+
+    if (typeof actual === "string" && typeof expected === "string") {
+      return actual.includes(expected);
+    }
+  }
+
+  if (Array.isArray(actual) && Array.isArray(expected)) {
+    return JSON.stringify(actual) === JSON.stringify(expected);
+  }
+
+  return actual === expected;
+}
+
+function compareOrder(a, b) {
+  const aHasOrder = typeof a.values?.order === "number";
+  const bHasOrder = typeof b.values?.order === "number";
+
+  if (aHasOrder && bHasOrder) {
+    if (a.values.order !== b.values.order) {
+      return a.values.order - b.values.order;
+    }
+  } else if (aHasOrder && !bHasOrder) {
+    return -1;
+  } else if (!aHasOrder && bHasOrder) {
+    return 1;
+  }
+
+  if (a.contentId !== b.contentId) {
+    return String(a.contentId).localeCompare(String(b.contentId));
+  }
+
+  return String(a.id).localeCompare(String(b.id));
+}
+
+export function applyContentQuery(items, query) {
+  const filterType = query.filterType ?? "equals";
+  const clauses = query.filter ?? [];
+
+  let results = items.filter((item) => {
+    for (const clause of clauses) {
+      const entries = Object.entries(clause);
+      if (entries.length !== 1) {
+        return false;
+      }
+
+      const [field, legacyValue] = entries[0];
+      const expected = legacyAttributeValueToPlain(legacyValue);
+      const actual = readComparableValue(item, field);
+      if (!compareFilter(actual, expected, filterType)) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+
+  results = results.sort(compareOrder);
+
+  if (typeof query.limit === "number") {
+    if (query.limit <= 0) {
+      return [];
+    }
+    return results.slice(0, query.limit);
+  }
+
+  return results;
+}
+
+export function readContentField(item, field, language) {
+  if (!item) {
+    return null;
+  }
+
+  if (field === "__typename") {
+    return item.model;
+  }
+  if (field === "contentId") {
+    return item.contentId;
+  }
+  if (field === "id") {
+    return item.id;
+  }
+  if (field === "locale") {
+    return item.locale ?? null;
+  }
+  if (field === "tenant") {
+    return item.tenant ?? null;
+  }
+  if (field === "_version") {
+    return item.version ?? null;
+  }
+  if (field === "_lastChangedAt") {
+    return item.lastChangedAt ?? null;
+  }
+
+  if (field === "content") {
+    const preferred = item.values?.[`content${language}`];
+    if (preferred !== undefined) {
+      return preferred;
+    }
+  }
+
+  return item.values?.[field] ?? null;
+}
+
+export function serializeContentValue(value) {
+  if (value == null) {
+    return "";
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => {
+      const text = typeof entry === "string" && entry.includes("-")
+        ? entry.slice(entry.lastIndexOf("-") + 1)
+        : String(entry);
+      return `<a href='${String(entry)}'>${text}</a>`;
+    }).join("");
+  }
+
+  return String(value);
+}

package/packages/core/src/errors.mjs

@@ -0,0 +1,14 @@
+export class S3teError extends Error {
+  constructor(code, message, details = undefined) {
+    super(message);
+    this.name = "S3teError";
+    this.code = code;
+    this.details = details;
+  }
+}
+
+export function assert(condition, code, message, details = undefined) {
+  if (!condition) {
+    throw new S3teError(code, message, details);
+  }
+}

package/packages/core/src/index.mjs

@@ -0,0 +1,24 @@
+export { S3teError } from "./errors.mjs";
+export { getContentTypeForPath } from "./mime.mjs";
+export { minifyHtml, repairTruncatedHtml } from "./minify.mjs";
+export {
+  buildEnvironmentRuntimeConfig,
+  loadProjectConfig,
+  resolveCodeBucketName,
+  resolveRuntimeManifestParameterName,
+  resolveProjectConfig,
+  resolveStackName,
+  resolveTableNames,
+  resolveTargetBucketName,
+  validateAndResolveProjectConfig
+} from "./config.mjs";
+export {
+  applyContentQuery,
+  readContentField,
+  serializeContentValue
+} from "./content-query.mjs";
+export {
+  createManualRenderTargets,
+  isRenderableKey,
+  renderSourceTemplate
+} from "./render.mjs";