@ixo/domain.md 0.3.0

package/dist/chunk-BYBC2TSS.js

@@ -0,0 +1,597 @@
+import {
+  getTemplateManifestSchema
+} from "./chunk-T3STBWXP.js";
+import {
+  lint
+} from "./chunk-XDIWMZVF.js";
+import {
+  MAX_LINKED_BYTES,
+  MAX_SCALAR_LENGTH,
+  MAX_YAML_DEPTH,
+  MAX_YAML_NODES,
+  SPEC_VERSION
+} from "./chunk-G7PZJYAJ.js";
+
+// src/templates/errors.ts
+var TemplateValidationError = class extends Error {
+  name = "TemplateValidationError";
+};
+
+// src/templates/manifest.ts
+import Ajv2020Import from "ajv/dist/2020.js";
+import addFormatsImport from "ajv-formats";
+import { isAlias, parseDocument, visit as visitYaml } from "yaml";
+var Ajv2020 = Ajv2020Import;
+var addFormats = addFormatsImport;
+var ajv = new Ajv2020({ allErrors: true, strict: true, strictRequired: false });
+addFormats(ajv);
+var validate = ajv.compile(getTemplateManifestSchema());
+function parseTemplateManifest(bytes) {
+  if (bytes.byteLength > MAX_LINKED_BYTES)
+    throw new Error(`Template manifest exceeds ${MAX_LINKED_BYTES} bytes.`);
+  const source = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  const document = parseDocument(source, { prettyErrors: true, uniqueKeys: true, version: "1.2" });
+  if (document.errors.length > 0 || document.warnings.length > 0) {
+    throw new Error(
+      [...document.errors, ...document.warnings].map((item) => item.message).join("; ")
+    );
+  }
+  const unsafe = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  let depth = 0;
+  let scalarTooLong = false;
+  visitYaml(document, {
+    Node(_key, node, path) {
+      const candidate = node;
+      nodes += 1;
+      depth = Math.max(depth, path.length + 1);
+      if (typeof candidate.value === "string" && candidate.value.length > MAX_SCALAR_LENGTH)
+        scalarTooLong = true;
+      if (isAlias(node)) unsafe.add("alias");
+      if (candidate.anchor) unsafe.add("anchor");
+      if (candidate.tag?.startsWith("!")) unsafe.add("custom-tag");
+    },
+    Pair(_key, pair) {
+      const key = pair.key;
+      if (key?.value === "<<") unsafe.add("merge-key");
+    }
+  });
+  if (nodes > MAX_YAML_NODES || depth > MAX_YAML_DEPTH || scalarTooLong) {
+    throw new Error("Template manifest exceeds YAML node, depth, or scalar limits.");
+  }
+  if (unsafe.size > 0)
+    throw new Error(
+      `Template manifest contains forbidden YAML features: ${[...unsafe].sort().join(", ")}.`
+    );
+  const value = document.toJS({ maxAliasCount: 0 });
+  if (!validate(value)) {
+    const message = (validate.errors ?? []).map((error) => `${error.instancePath || "$"} ${error.message ?? "is invalid"}`).join("; ");
+    throw new Error(`Invalid template manifest: ${message}`);
+  }
+  const manifest = value;
+  const derivedTypes = /* @__PURE__ */ new Set();
+  for (const bundle of manifest.bundles) {
+    if (derivedTypes.has(bundle.derived_type))
+      throw new Error(`Duplicate template bundle ${bundle.derived_type}.`);
+    derivedTypes.add(bundle.derived_type);
+    const paths = /* @__PURE__ */ new Set();
+    for (const file of bundle.files) {
+      if (!file.path.startsWith(`templates/${bundle.derived_type}/`)) {
+        throw new Error(
+          `Template path ${file.path} does not match bundle type ${bundle.derived_type}.`
+        );
+      }
+      if (paths.has(file.path)) throw new Error(`Duplicate template path ${file.path}.`);
+      paths.add(file.path);
+    }
+    const domainFiles = bundle.files.filter((file) => file.role === "domain.md");
+    if (domainFiles.length !== 1 || domainFiles[0]?.media_type !== "text/markdown" || domainFiles[0].required !== true || domainFiles[0].path !== `templates/${bundle.derived_type}/domain.md.tmpl`) {
+      throw new Error(
+        `Template bundle ${bundle.derived_type} must contain exactly one required Markdown domain.md.`
+      );
+    }
+  }
+  return manifest;
+}
+
+// src/templates/resolver.ts
+import { lookup } from "dns/promises";
+import { lstat, readFile, realpath } from "fs/promises";
+import { request } from "https";
+import { relative, resolve } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import ipaddr from "ipaddr.js";
+function isPublicAddress(address) {
+  const parsed = ipaddr.parse(address);
+  const range = parsed.range();
+  return range === "unicast";
+}
+function validateHttpsTarget(url, addresses = []) {
+  if (url.protocol !== "https:") throw new Error("Only HTTPS template retrieval is allowed.");
+  if (url.username || url.password) throw new Error("Credentials in template URLs are forbidden.");
+  if (!url.hostname) throw new Error("Template URL hostname is required.");
+  if (addresses.some((address) => !isPublicAddress(address))) {
+    throw new Error(`Template hostname ${url.hostname} resolves to a non-public address.`);
+  }
+}
+var FileTemplateResolver = class {
+  supports(uri) {
+    return uri.startsWith("file:") || !/^[A-Za-z][A-Za-z0-9+.-]*:/.test(uri);
+  }
+  async resolve(uri, context) {
+    const path = resolve(uri.startsWith("file:") ? fileURLToPath(uri) : uri);
+    const stat = await lstat(path);
+    if (!stat.isFile() || stat.isSymbolicLink())
+      throw new Error("Template resources must be regular files, not symlinks.");
+    if (stat.size > context.maxBytes)
+      throw new Error(`Template resource exceeds ${context.maxBytes} bytes.`);
+    const canonical2 = await realpath(path);
+    if (canonical2 !== path) throw new Error("Template resource paths must not contain symlinks.");
+    return { uri: pathToFileURL(canonical2).href, bytes: await readFile(canonical2) };
+  }
+  static async resolveRelative(manifestUri, logicalPath) {
+    const manifestPath = fileURLToPath(manifestUri);
+    const root = await realpath(resolve(manifestPath, ".."));
+    const requested = resolve(root, logicalPath);
+    const lexicalTraversal = relative(root, requested);
+    if (lexicalTraversal.startsWith("..") || lexicalTraversal.startsWith("/") || lexicalTraversal === "") {
+      throw new Error(`Template path escapes or aliases the manifest root: ${logicalPath}`);
+    }
+    let current = root;
+    for (const component of lexicalTraversal.split(/[\\/]/)) {
+      current = resolve(current, component);
+      if ((await lstat(current)).isSymbolicLink())
+        throw new Error(`Template path contains a symlink: ${logicalPath}`);
+    }
+    const target = await realpath(requested);
+    const traversal = relative(root, target);
+    if (traversal.startsWith("..") || traversal.startsWith("/") || traversal === "") {
+      throw new Error(`Template path escapes or aliases the manifest root: ${logicalPath}`);
+    }
+    return pathToFileURL(target).href;
+  }
+};
+var HttpsTemplateResolver = class {
+  maxRedirects;
+  constructor(options = {}) {
+    this.maxRedirects = options.maxRedirects ?? 3;
+  }
+  supports(uri) {
+    return uri.startsWith("https:");
+  }
+  async resolve(uri, context) {
+    return this.fetch(new URL(uri), context, 0);
+  }
+  async fetch(url, context, redirects) {
+    validateHttpsTarget(url);
+    const addresses = await lookup(url.hostname, { all: true, verbatim: true });
+    if (addresses.length === 0)
+      throw new Error(`Template hostname ${url.hostname} did not resolve.`);
+    validateHttpsTarget(
+      url,
+      addresses.map((entry) => entry.address)
+    );
+    const approved = addresses[0];
+    if (!approved) throw new Error(`Template hostname ${url.hostname} did not resolve.`);
+    return new Promise((resolvePromise, reject) => {
+      const req = request(
+        url,
+        {
+          headers: { accept: "application/yaml, application/json, text/markdown, text/plain" },
+          lookup(_hostname, _options, callback) {
+            callback(null, approved.address, approved.family);
+          },
+          servername: url.hostname
+        },
+        (response) => {
+          const status = response.statusCode ?? 0;
+          const location = response.headers.location;
+          if (status >= 300 && status < 400 && location) {
+            response.resume();
+            if (redirects >= this.maxRedirects) {
+              reject(new Error("Template retrieval exceeded the redirect limit."));
+              return;
+            }
+            const redirected = new URL(location, url);
+            this.fetch(redirected, context, redirects + 1).then(resolvePromise, reject);
+            return;
+          }
+          if (status !== 200) {
+            response.resume();
+            reject(new Error(`Template retrieval returned HTTP ${status}.`));
+            return;
+          }
+          const chunks = [];
+          let size = 0;
+          response.on("data", (chunk) => {
+            size += chunk.length;
+            if (size > context.maxBytes) {
+              req.destroy(new Error(`Template resource exceeds ${context.maxBytes} bytes.`));
+              return;
+            }
+            chunks.push(chunk);
+          });
+          response.on("end", () => {
+            resolvePromise({
+              uri: url.href,
+              bytes: Buffer.concat(chunks),
+              ...typeof response.headers["content-type"] === "string" ? { mediaType: response.headers["content-type"] } : {}
+            });
+          });
+        }
+      );
+      req.setTimeout(
+        context.timeoutMs,
+        () => req.destroy(new Error("Template retrieval timed out."))
+      );
+      req.on("error", reject);
+      req.end();
+    });
+  }
+};
+var IpfsTemplateResolver = class {
+  gateway;
+  https;
+  constructor(gateway, httpsResolver = new HttpsTemplateResolver()) {
+    this.gateway = new URL(gateway.endsWith("/") ? gateway : `${gateway}/`);
+    validateHttpsTarget(this.gateway);
+    this.https = httpsResolver;
+  }
+  supports(uri) {
+    return uri.startsWith("ipfs:");
+  }
+  async resolve(uri, context) {
+    const source = new URL(uri);
+    const cid = source.hostname;
+    if (!cid) throw new Error("IPFS URI must include a CID host.");
+    const path = source.pathname.replace(/^\/+/, "");
+    const target = new URL(`ipfs/${cid}/${path}`, this.gateway);
+    const result = await this.https.resolve(target.href, context);
+    return { ...result, uri };
+  }
+};
+function relativeTemplateUri(manifestUri, logicalPath) {
+  if (manifestUri.startsWith("ipfs:")) {
+    const base = new URL(manifestUri);
+    const root = base.pathname.slice(0, base.pathname.lastIndexOf("/") + 1);
+    base.pathname = `${root}${logicalPath}`;
+    return base.href;
+  }
+  return new URL(logicalPath, manifestUri).href;
+}
+
+// src/templates/render.ts
+import { createHash } from "crypto";
+import { basename } from "path";
+import { CID } from "multiformats/cid";
+import { sha256 } from "multiformats/hashes/sha2";
+import { isAlias as isAlias2, parseDocument as parseDocument2, stringify, visit as visitYaml2 } from "yaml";
+function sha(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function canonical(value) {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (isRecord(value)) {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => `${JSON.stringify(key)}:${canonical(child)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function deterministicUuid(seed) {
+  const bytes = createHash("sha256").update(seed).digest().subarray(0, 16);
+  bytes[6] = (bytes[6] ?? 0) & 15 | 80;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const hex = bytes.toString("hex");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+async function verifyIdentity(resource, expectedSha, expectedCid) {
+  if (expectedSha && sha(resource.bytes) !== expectedSha.toLowerCase())
+    throw new TemplateValidationError(`SHA-256 mismatch for ${resource.uri}.`);
+  if (expectedCid) {
+    let cid;
+    try {
+      cid = CID.parse(expectedCid);
+    } catch {
+      throw new TemplateValidationError(`Invalid CID ${expectedCid}.`);
+    }
+    if (cid.code !== 85 || cid.multihash.code !== sha256.code) {
+      throw new TemplateValidationError(
+        `CID verification supports raw sha2-256 CIDs only: ${expectedCid}`
+      );
+    }
+    const digest = await sha256.digest(resource.bytes);
+    if (!Buffer.from(digest.digest).equals(Buffer.from(cid.multihash.digest)))
+      throw new TemplateValidationError(`CID mismatch for ${resource.uri}.`);
+  }
+}
+function chooseResolver(uri, resolvers) {
+  const resolver = resolvers.find((candidate) => candidate.supports(uri));
+  if (!resolver) throw new Error(`No template resolver supports ${uri}.`);
+  return resolver;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parameterDefinitions(marker) {
+  if (!Array.isArray(marker.parameters))
+    throw new TemplateValidationError("Template marker parameters must be an array.");
+  const seen = /* @__PURE__ */ new Set();
+  return marker.parameters.map((value) => {
+    if (!isRecord(value) || typeof value.name !== "string" || !["string", "number", "boolean", "object", "array"].includes(String(value.type)) || typeof value.required !== "boolean" || value.fill_at !== "author") {
+      throw new TemplateValidationError(
+        "Every template parameter must declare name, supported type, required, and fill_at: author."
+      );
+    }
+    if (seen.has(value.name))
+      throw new TemplateValidationError(`Duplicate template parameter ${value.name}.`);
+    seen.add(value.name);
+    return {
+      name: value.name,
+      type: value.type,
+      required: value.required === true,
+      fill_at: "author"
+    };
+  });
+}
+function valueMatches(value, type) {
+  if (type === "array") return Array.isArray(value);
+  if (type === "object") return isRecord(value);
+  return typeof value === type;
+}
+function replaceExactString(value, before, after) {
+  if (value === before) return after;
+  if (Array.isArray(value)) return value.map((item) => replaceExactString(item, before, after));
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [key, replaceExactString(item, before, after)])
+  );
+}
+function substitute(value, parameters, allowed, used) {
+  if (Array.isArray(value))
+    return value.map((child) => substitute(child, parameters, allowed, used));
+  if (!isRecord(value)) return value;
+  if (Object.keys(value).length === 1 && typeof value.$param === "string") {
+    const definition = allowed.get(value.$param);
+    if (!definition)
+      throw new TemplateValidationError(`Unknown structured parameter ${value.$param}.`);
+    const resolved = parameters[value.$param];
+    if (resolved === void 0)
+      throw new TemplateValidationError(
+        `Required structured parameter ${value.$param} is unresolved.`
+      );
+    if (!valueMatches(resolved, definition.type))
+      throw new TemplateValidationError(`Parameter ${value.$param} must be ${definition.type}.`);
+    used.add(value.$param);
+    return resolved;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, child]) => [
+      key,
+      substitute(child, parameters, allowed, used)
+    ])
+  );
+}
+function markdownEscape(value) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    throw new TemplateValidationError("Markdown parameters must be strings, numbers, or booleans.");
+  }
+  return String(value).replace(/[\\`*_[\]<>]/g, "\\$&").replace(/&/g, "&amp;");
+}
+function renderMarkdownTemplate(source, file, expectedProtocol, derivedType, parameters, draftId) {
+  const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(source);
+  if (!match?.[1])
+    throw new TemplateValidationError(`Template ${file.path} requires YAML frontmatter.`);
+  const yaml = parseDocument2(match[1], { prettyErrors: true, uniqueKeys: true, version: "1.2" });
+  if (yaml.errors.length > 0)
+    throw new TemplateValidationError(yaml.errors.map((error) => error.message).join("; "));
+  const unsafe = /* @__PURE__ */ new Set();
+  let nodes = 0;
+  let depth = 0;
+  let scalarTooLong = false;
+  visitYaml2(yaml, {
+    Node(_key, node, path) {
+      const candidate = node;
+      nodes += 1;
+      depth = Math.max(depth, path.length + 1);
+      if (typeof candidate.value === "string" && candidate.value.length > MAX_SCALAR_LENGTH)
+        scalarTooLong = true;
+      if (isAlias2(node)) unsafe.add("alias");
+      if (candidate.anchor) unsafe.add("anchor");
+      if (candidate.tag?.startsWith("!")) unsafe.add("custom-tag");
+    },
+    Pair(_key, pair) {
+      const key = pair.key;
+      if (key?.value === "<<") unsafe.add("merge-key");
+    }
+  });
+  if (nodes > MAX_YAML_NODES || depth > MAX_YAML_DEPTH || scalarTooLong || unsafe.size > 0) {
+    throw new TemplateValidationError(`Template ${file.path} contains unsafe or excessive YAML.`);
+  }
+  const frontmatter = yaml.toJS({ maxAliasCount: 0 });
+  const marker = frontmatter["x-template"];
+  const markerKeys = /* @__PURE__ */ new Set([
+    "is_template",
+    "instantiates_type",
+    "protocol",
+    "template_version",
+    "parameters"
+  ]);
+  if (!isRecord(marker) || marker.is_template !== true || marker.protocol !== expectedProtocol || marker.instantiates_type !== derivedType || typeof marker.template_version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(marker.template_version) || Object.keys(marker).some((key) => !markerKeys.has(key) && !key.startsWith("x-"))) {
+    throw new TemplateValidationError(`Template marker mismatch in ${file.path}.`);
+  }
+  const definitions = parameterDefinitions(marker);
+  const allowed = new Map(definitions.map((definition) => [definition.name, definition]));
+  for (const key of Object.keys(parameters))
+    if (!allowed.has(key)) throw new TemplateValidationError(`Undeclared parameter ${key}.`);
+  for (const definition of definitions) {
+    if (definition.required && parameters[definition.name] === void 0)
+      throw new TemplateValidationError(`Required parameter ${definition.name} is unresolved.`);
+    if (parameters[definition.name] !== void 0 && !valueMatches(parameters[definition.name], definition.type))
+      throw new TemplateValidationError(`Parameter ${definition.name} must be ${definition.type}.`);
+  }
+  delete frontmatter["x-template"];
+  const used = /* @__PURE__ */ new Set();
+  const substitutedFrontmatter = substitute(frontmatter, parameters, allowed, used);
+  const originalSubject = isRecord(substitutedFrontmatter.domain) && typeof substitutedFrontmatter.domain.id === "string" ? substitutedFrontmatter.domain.id : void 0;
+  const draftSubject = `urn:uuid:${draftId}`;
+  const renderedFrontmatter = originalSubject === void 0 ? substitutedFrontmatter : replaceExactString(substitutedFrontmatter, originalSubject, draftSubject);
+  if (isRecord(renderedFrontmatter.domain)) {
+    renderedFrontmatter.domain.id = draftSubject;
+    renderedFrontmatter.domain.iid = null;
+    renderedFrontmatter.domain.type = derivedType;
+    renderedFrontmatter.domain.class = expectedProtocol;
+    renderedFrontmatter.domain.status = "draft";
+  }
+  if (isRecord(renderedFrontmatter.constitution))
+    renderedFrontmatter.constitution.subject = draftSubject;
+  renderedFrontmatter.version = SPEC_VERSION;
+  if (isRecord(renderedFrontmatter.conformance))
+    renderedFrontmatter.conformance.profile = "authoring_draft";
+  const body = source.slice(match[0].length).replace(/\{\{([A-Za-z0-9_.-]+)\}\}/g, (_whole, name) => {
+    const definition = allowed.get(name);
+    if (!definition) throw new TemplateValidationError(`Unknown Markdown parameter ${name}.`);
+    const value = parameters[name];
+    if (value === void 0)
+      throw new TemplateValidationError(`Markdown parameter ${name} is unresolved.`);
+    used.add(name);
+    return markdownEscape(value);
+  });
+  for (const definition of definitions) {
+    if (definition.required && !used.has(definition.name))
+      throw new TemplateValidationError(
+        `Required parameter ${definition.name} was declared but unused.`
+      );
+  }
+  if (/\{\{[^{}\n]+\}\}/.test(body))
+    throw new TemplateValidationError(`Unresolved placeholder remains in ${file.path}.`);
+  return new TextEncoder().encode(
+    `---
+${stringify(renderedFrontmatter, { lineWidth: 0 }).trimEnd()}
+---
+${body.replace(/^\n/, "")}`
+  );
+}
+async function resolveRelative(manifestUri, path) {
+  return manifestUri.startsWith("file:") ? FileTemplateResolver.resolveRelative(manifestUri, path) : relativeTemplateUri(manifestUri, path);
+}
+async function renderTemplateBundle(request2) {
+  const resolvers = request2.resolvers ?? [
+    new FileTemplateResolver(),
+    new HttpsTemplateResolver(),
+    ...request2.ipfsGateway ? [new IpfsTemplateResolver(request2.ipfsGateway)] : []
+  ];
+  if (request2.manifestUri.startsWith("https:") && !request2.manifestSha256 && !request2.manifestCid) {
+    throw new Error("HTTPS manifests require --manifest-sha256 or --manifest-cid.");
+  }
+  if (request2.manifestUri.startsWith("ipfs:") && !request2.ipfsGateway) {
+    throw new Error("IPFS templates require an explicit HTTPS gateway.");
+  }
+  const context = { maxBytes: MAX_LINKED_BYTES, timeoutMs: request2.timeoutMs ?? 1e4 };
+  const manifestResource = await chooseResolver(request2.manifestUri, resolvers).resolve(
+    request2.manifestUri,
+    context
+  );
+  const ipfsManifest = request2.manifestUri.startsWith("ipfs:") ? new URL(request2.manifestUri) : void 0;
+  if (ipfsManifest && ipfsManifest.pathname !== "" && ipfsManifest.pathname !== "/" && !request2.manifestSha256) {
+    throw new Error("IPFS manifests below a root path require an explicit SHA-256 digest.");
+  }
+  const impliedCid = ipfsManifest && (ipfsManifest.pathname === "" || ipfsManifest.pathname === "/") ? ipfsManifest.hostname : void 0;
+  await verifyIdentity(manifestResource, request2.manifestSha256, request2.manifestCid ?? impliedCid);
+  let manifest;
+  try {
+    manifest = parseTemplateManifest(manifestResource.bytes);
+  } catch (error) {
+    throw new TemplateValidationError(
+      `Template manifest is invalid: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (manifest.protocol !== request2.expectedProtocol)
+    throw new TemplateValidationError(
+      "Template manifest protocol does not match expectedProtocol."
+    );
+  const bundle = manifest.bundles.find(
+    (candidate) => candidate.derived_type === request2.derivedType
+  );
+  if (!bundle)
+    throw new TemplateValidationError(`Template manifest has no ${request2.derivedType} bundle.`);
+  const parameterDigest = sha(new TextEncoder().encode(canonical(request2.parameters)));
+  const draftId = deterministicUuid(
+    `${manifest.protocol}:${bundle.bundle_version}:${sha(manifestResource.bytes)}:${parameterDigest}`
+  );
+  const rendered = [];
+  for (const file of bundle.files) {
+    const uri = file.uri ?? await resolveRelative(manifestResource.uri, file.path);
+    const resource = await chooseResolver(uri, resolvers).resolve(uri, context);
+    if (!manifestResource.uri.startsWith("file:") && resource.uri.startsWith("file:")) {
+      throw new TemplateValidationError("Remote manifests cannot resolve local file resources.");
+    }
+    if (resource.bytes.byteLength > file.max_bytes) {
+      throw new TemplateValidationError(
+        `Template ${file.path} exceeds its declared max_bytes limit.`
+      );
+    }
+    await verifyIdentity(resource, file.sha256, file.cid);
+    let source;
+    try {
+      source = new TextDecoder("utf-8", { fatal: true }).decode(resource.bytes);
+    } catch {
+      throw new TemplateValidationError(`Template ${file.path} is not valid UTF-8.`);
+    }
+    const bytes = file.media_type === "text/markdown" ? renderMarkdownTemplate(
+      source,
+      file,
+      request2.expectedProtocol,
+      request2.derivedType,
+      request2.parameters,
+      draftId
+    ) : resource.bytes;
+    rendered.push({
+      role: file.role,
+      path: file.path.replace(/^templates\/[a-z0-9_-]+\//, "").replace(/\.tmpl$/, ""),
+      bytes,
+      sha256: sha(bytes),
+      sourceUri: resource.uri
+    });
+  }
+  const domain = rendered.find((file) => basename(file.path) === "domain.md");
+  if (!domain) throw new TemplateValidationError("Rendered bundle must contain domain.md.");
+  const domainText = new TextDecoder().decode(domain.bytes);
+  const report = lint(domainText, { sourceName: domain.path, expectedProfile: "authoring_draft" });
+  if (!report.ok)
+    throw new TemplateValidationError(
+      `Rendered domain.md failed validation: ${report.findings.filter((item) => item.severity === "error").map((item) => `${item.code}: ${item.message}`).join("; ")}`
+    );
+  const provenance = stringify(
+    {
+      provenance: {
+        state: "authoring_draft",
+        specification_version: SPEC_VERSION,
+        protocol: manifest.protocol,
+        protocol_version: manifest.protocol_version,
+        manifest: { uri: manifestResource.uri, sha256: sha(manifestResource.bytes) },
+        bundle: { derived_type: bundle.derived_type, version: bundle.bundle_version },
+        draft_domain_id: `urn:uuid:${draftId}`,
+        files: rendered.map((file) => ({
+          role: file.role,
+          path: file.path,
+          source_uri: file.sourceUri,
+          sha256: file.sha256
+        })),
+        parameters_digest: parameterDigest
+      }
+    },
+    { lineWidth: 0 }
+  );
+  return { files: rendered, provenance, report, manifest };
+}
+
+export {
+  TemplateValidationError,
+  parseTemplateManifest,
+  validateHttpsTarget,
+  FileTemplateResolver,
+  HttpsTemplateResolver,
+  IpfsTemplateResolver,
+  relativeTemplateUri,
+  renderTemplateBundle
+};
+//# sourceMappingURL=chunk-BYBC2TSS.js.map