@forgeax/engine-pack 0.1.2

package/src/errors.ts

@@ -0,0 +1,47 @@
+// errors.ts — PackError class (feat-20260513-guid-asset-package-system w15)
+//
+// Four-field surface: .code / .expected / .hint / .detail
+// Structurally parallel to AssetError / RhiError / RemoteError
+// (charter proposition 5 consistent abstraction).
+//
+// .detail is narrowed per .code via PackErrorDetail discriminated union
+// (requirements §6.2 AC-07; plan-strategy §D-5).
+
+import type { PackErrorCode, PackErrorDetail } from '@forgeax/engine-types';
+
+/**
+ * Structured error for the engine-pack disk scanner fail-fast chain.
+ *
+ * AI users consume via exhaustive switch on .code — no default case needed:
+ * ```ts
+ * switch (err.code) {
+ *   case 'pack-guid-collision':
+ *     console.error(err.detail.paths);
+ *     break;
+ *   case 'pack-cyclic-reference':
+ *     console.error(err.detail.cycle);
+ *     break;
+ *   // ...all 8 cases
+ * }
+ * ```
+ */
+export class PackError extends Error {
+  readonly code: PackErrorCode;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: PackErrorDetail;
+
+  constructor(args: {
+    code: PackErrorCode;
+    expected: string;
+    hint: string;
+    detail: PackErrorDetail;
+  }) {
+    super(`[PackError ${args.code}] expected: ${args.expected}; hint: ${args.hint}`);
+    this.name = 'PackError';
+    this.code = args.code;
+    this.expected = args.expected;
+    this.hint = args.hint;
+    this.detail = args.detail;
+  }
+}

package/src/evidence/material-cook.ts

@@ -0,0 +1,332 @@
+import type {
+  MaterialAsset,
+  MaterialParameter,
+  MaterialPass,
+  MaterialTextureReference,
+  MaterialTextureValue,
+  MaterialValue,
+  Result,
+} from '@forgeax/engine-types';
+import { err, MATERIAL_TEXTURE_SLOTS, ok } from '@forgeax/engine-types';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+
+export interface MaterialCookRefs {
+  readonly parent: readonly string[];
+  readonly textures: readonly string[];
+  readonly samplers: readonly string[];
+  readonly modules: readonly string[];
+}
+
+export interface MaterialCookArtifact {
+  readonly mediaType: string;
+  readonly path: string;
+  readonly digest: string;
+  readonly bytes: Uint8Array;
+}
+
+export interface MaterialCookReceipt {
+  readonly schemaVersion: 'material-cook/2';
+  readonly sourceClosure: readonly string[];
+  readonly profile: string;
+  readonly compilerVersion: string;
+  readonly inputDigest: string;
+  readonly outputDigest: string;
+  readonly layoutIdentity: string;
+  readonly derivedInterface: { readonly layoutIdentity: string };
+  readonly publicationGeneration?: number;
+}
+
+export interface MaterialParameterContract {
+  readonly parameters: readonly MaterialParameter[];
+  readonly values: Readonly<Record<string, MaterialValue | null>>;
+}
+
+export interface CookedMaterialRecord {
+  readonly schemaVersion: 'material-cook/2';
+  readonly guid: string;
+  readonly authored?: MaterialAsset;
+  readonly materialGuid?: string;
+  readonly publicationGeneration?: number;
+  readonly specializationKey?: string;
+  readonly artifactDigest?: string;
+  readonly sourceClosure?: readonly string[];
+  readonly parameterContract?: MaterialParameterContract;
+  readonly resolved: {
+    readonly passes: readonly MaterialPass[];
+    readonly parameters: readonly MaterialParameter[];
+    readonly values: Readonly<Record<string, MaterialValue | null>>;
+  };
+  readonly refs: MaterialCookRefs;
+  readonly artifact: MaterialCookArtifact;
+  readonly receipt: MaterialCookReceipt;
+}
+
+export interface MaterialCookRecordError {
+  readonly code: 'material-cook-record-invalid';
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: { readonly field: string };
+}
+
+export interface MaterialCookIdentityExpectation {
+  readonly layoutIdentity?: string;
+  readonly artifactDigest?: string;
+  readonly inputDigest?: string;
+}
+
+function unique(values: readonly string[]): readonly string[] {
+  return [...new Set(values)].sort();
+}
+
+function guidText(value: string | Uint8Array): string {
+  return typeof value === 'string'
+    ? value
+    : Array.from(value, (byte) => byte.toString(16).padStart(2, '0')).join('');
+}
+
+function cookGuidText(value: MaterialTextureReference): string | undefined {
+  return typeof value === 'number' ? undefined : guidText(value);
+}
+
+function textureValues(
+  values: Readonly<Record<string, MaterialValue | null>> | undefined,
+  textureFields: ReadonlySet<string>,
+): readonly MaterialTextureValue[] {
+  return Object.entries(values ?? {}).flatMap(([name, value]) => {
+    if (value === null) return [];
+    if (typeof value === 'string') {
+      return textureFields.has(name) ? [{ texture: value }] : [];
+    }
+    return value !== null &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      'texture' in value
+      ? [value as MaterialTextureValue]
+      : [];
+  });
+}
+
+export function collectMaterialCookRefs(material: Partial<MaterialAsset>): MaterialCookRefs {
+  const textureFields =
+    material.parameters === undefined
+      ? new Set<string>(MATERIAL_TEXTURE_SLOTS)
+      : new Set(
+          material.parameters
+            .filter((parameter) => parameter.type === 'texture')
+            .map((parameter) => parameter.name),
+        );
+  const textures = textureValues(material.values, textureFields);
+  return {
+    parent: material.parent ? [guidText(material.parent)] : [],
+    textures: unique(
+      textures.flatMap((value) => {
+        const guid = cookGuidText(value.texture);
+        return guid === undefined ? [] : [guid];
+      }),
+    ),
+    samplers: unique(
+      textures.flatMap((value) => {
+        if (value.sampler === undefined) return [];
+        const guid = cookGuidText(value.sampler);
+        return guid === undefined ? [] : [guid];
+      }),
+    ),
+    modules: unique((material.passes ?? []).map((pass) => pass.program.module)),
+  };
+}
+
+export function createMaterialArtifactDigest(bytes: Uint8Array): string {
+  return `sha256:${bytesToHex(sha256(bytes))}`;
+}
+
+function jsonValue(value: unknown): unknown {
+  if (value instanceof Uint8Array) return [...value];
+  if (Array.isArray(value)) return value.map(jsonValue);
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value)
+        .filter(([, entry]) => entry !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, entry]) => [key, jsonValue(entry)]),
+    );
+  }
+  return value;
+}
+
+export function serializeCookedMaterialRecord(record: CookedMaterialRecord): string {
+  return JSON.stringify(jsonValue(record));
+}
+
+export function serializeMaterialCookReceipt(receipt: MaterialCookReceipt): string {
+  return JSON.stringify(jsonValue({ ...receipt, sourceClosure: unique(receipt.sourceClosure) }));
+}
+
+function invalid(field: string): Result<never, MaterialCookRecordError> {
+  return err({
+    code: 'material-cook-record-invalid',
+    expected: 'a complete material-cook/2 record with derived layout identity',
+    hint: 're-cook the material and publish its record, artifact, references, and receipt together',
+    detail: { field },
+  });
+}
+
+export function validateMaterialCookReceipt(
+  value: unknown,
+  expected: MaterialCookIdentityExpectation = {},
+): Result<MaterialCookReceipt, MaterialCookRecordError> {
+  if (value === null || typeof value !== 'object') return invalid('receipt');
+  const candidate = value as Record<string, unknown>;
+  if (candidate.schemaVersion !== 'material-cook/2') return invalid('receipt.schemaVersion');
+  if (typeof candidate.layoutIdentity !== 'string' || candidate.layoutIdentity.length === 0) {
+    return invalid('receipt.layoutIdentity');
+  }
+  if (candidate.derivedInterface === null || typeof candidate.derivedInterface !== 'object') {
+    return invalid('receipt.derivedInterface');
+  }
+  const derivedInterface = candidate.derivedInterface as Record<string, unknown>;
+  if (derivedInterface.layoutIdentity !== candidate.layoutIdentity) {
+    return invalid('receipt.derivedInterface.layoutIdentity');
+  }
+  for (const field of [
+    'sourceClosure',
+    'profile',
+    'compilerVersion',
+    'inputDigest',
+    'outputDigest',
+  ]) {
+    const fieldValue = candidate[field];
+    if (
+      (field === 'sourceClosure' && !Array.isArray(fieldValue)) ||
+      (field !== 'sourceClosure' && typeof fieldValue !== 'string')
+    ) {
+      return invalid(`receipt.${field}`);
+    }
+  }
+  const sourceClosure = candidate.sourceClosure;
+  if (Array.isArray(sourceClosure) && sourceClosure.some((path) => typeof path !== 'string')) {
+    return invalid('receipt.sourceClosure');
+  }
+  if (
+    expected.layoutIdentity !== undefined &&
+    candidate.layoutIdentity !== expected.layoutIdentity
+  ) {
+    return invalid('receipt.layoutIdentity');
+  }
+  if (expected.artifactDigest !== undefined && candidate.outputDigest !== expected.artifactDigest) {
+    return invalid('receipt.outputDigest');
+  }
+  if (expected.inputDigest !== undefined && candidate.inputDigest !== expected.inputDigest) {
+    return invalid('receipt.inputDigest');
+  }
+  if (
+    candidate.publicationGeneration !== undefined &&
+    (typeof candidate.publicationGeneration !== 'number' ||
+      !Number.isSafeInteger(candidate.publicationGeneration) ||
+      candidate.publicationGeneration < 1)
+  ) {
+    return invalid('receipt.publicationGeneration');
+  }
+  return ok({
+    schemaVersion: 'material-cook/2',
+    sourceClosure: candidate.sourceClosure as string[],
+    profile: candidate.profile as string,
+    compilerVersion: candidate.compilerVersion as string,
+    inputDigest: candidate.inputDigest as string,
+    outputDigest: candidate.outputDigest as string,
+    layoutIdentity: candidate.layoutIdentity,
+    derivedInterface: { layoutIdentity: derivedInterface.layoutIdentity as string },
+    ...(candidate.publicationGeneration === undefined
+      ? {}
+      : { publicationGeneration: candidate.publicationGeneration as number }),
+  });
+}
+
+export function validateCookedMaterialRecord(
+  value: unknown,
+): Result<CookedMaterialRecord, MaterialCookRecordError> {
+  if (value === null || typeof value !== 'object') return invalid('record');
+  const candidate = value as Record<string, unknown>;
+  if (candidate.schemaVersion !== 'material-cook/2') return invalid('schemaVersion');
+  if (typeof candidate.guid !== 'string' || !candidate.guid) return invalid('guid');
+  if (candidate.materialGuid !== undefined && typeof candidate.materialGuid !== 'string')
+    return invalid('materialGuid');
+  if (
+    candidate.publicationGeneration !== undefined &&
+    (typeof candidate.publicationGeneration !== 'number' ||
+      !Number.isSafeInteger(candidate.publicationGeneration) ||
+      candidate.publicationGeneration < 1)
+  )
+    return invalid('publicationGeneration');
+  if (candidate.specializationKey !== undefined && typeof candidate.specializationKey !== 'string')
+    return invalid('specializationKey');
+  if (candidate.artifactDigest !== undefined && typeof candidate.artifactDigest !== 'string')
+    return invalid('artifactDigest');
+  if (
+    candidate.sourceClosure !== undefined &&
+    (!Array.isArray(candidate.sourceClosure) ||
+      candidate.sourceClosure.some((path) => typeof path !== 'string'))
+  )
+    return invalid('sourceClosure');
+  if (candidate.parameterContract !== undefined) {
+    if (candidate.parameterContract === null || typeof candidate.parameterContract !== 'object')
+      return invalid('parameterContract');
+    const parameterContract = candidate.parameterContract as Record<string, unknown>;
+    if (!Array.isArray(parameterContract.parameters))
+      return invalid('parameterContract.parameters');
+    if (
+      parameterContract.values === null ||
+      typeof parameterContract.values !== 'object' ||
+      Array.isArray(parameterContract.values)
+    )
+      return invalid('parameterContract.values');
+  }
+  if (candidate.resolved === null || typeof candidate.resolved !== 'object')
+    return invalid('resolved');
+  if (candidate.refs === null || typeof candidate.refs !== 'object') return invalid('refs');
+  if (candidate.artifact === null || typeof candidate.artifact !== 'object')
+    return invalid('artifact');
+  if (candidate.receipt === null || typeof candidate.receipt !== 'object')
+    return invalid('receipt');
+  const artifact = candidate.artifact as Record<string, unknown>;
+  if (
+    typeof artifact.digest !== 'string' ||
+    (!Array.isArray(artifact.bytes) && !ArrayBuffer.isView(artifact.bytes))
+  ) {
+    return invalid('artifact');
+  }
+  const receiptResult = validateMaterialCookReceipt(candidate.receipt, {
+    artifactDigest: artifact.digest as string,
+  });
+  if (!receiptResult.ok) return receiptResult;
+  if (candidate.artifactDigest !== undefined && candidate.artifactDigest !== artifact.digest)
+    return invalid('artifactDigest');
+  if (
+    candidate.publicationGeneration !== undefined &&
+    receiptResult.value.publicationGeneration !== candidate.publicationGeneration
+  )
+    return invalid('receipt.publicationGeneration');
+  const normalized = {
+    ...candidate,
+    artifact: {
+      ...artifact,
+      bytes: ArrayBuffer.isView(artifact.bytes)
+        ? Uint8Array.from(artifact.bytes as Uint8Array)
+        : Uint8Array.from(artifact.bytes as number[]),
+    },
+    receipt: receiptResult.value,
+  } as CookedMaterialRecord;
+  return ok(normalized);
+}
+
+export function projectCookedMaterialRecord(
+  record: CookedMaterialRecord,
+): Omit<CookedMaterialRecord, 'guid' | 'authored'> {
+  return {
+    resolved: record.resolved,
+    refs: record.refs,
+    artifact: record.artifact,
+    receipt: record.receipt,
+    schemaVersion: record.schemaVersion,
+  };
+}

package/src/evidence/offline-evidence.ts

@@ -0,0 +1,90 @@
+import type {
+  ArtifactDescriptor,
+  ArtifactVerificationStatus,
+  AssetEvidence,
+  AssetEvidenceError,
+  AssetEvidenceInputs,
+  AssetEvidenceLocator,
+  CookProduct,
+  CookReceipt,
+  PackageVerificationEvidence,
+  SourceDeclarationEvidence,
+} from '@forgeax/engine-types';
+import {
+  projectAssetEvidence,
+  projectCookProductEvidence,
+  type Result,
+} from '@forgeax/engine-types';
+
+/** Pack artifact descriptor with verification supplied by an offline verifier. */
+export interface OfflineArtifactInput extends ArtifactDescriptor {
+  readonly verification?: ArtifactVerificationStatus;
+}
+
+/** Validated Pack v2 package facts consumed by the offline projector. */
+export interface OfflinePackageInput {
+  readonly guid: string;
+  readonly digest?: string;
+  readonly artifacts: Readonly<Record<string, OfflineArtifactInput>>;
+}
+
+/** Node/CLI input shape; it intentionally has no runtime or WebSocket fields. */
+export interface OfflineAssetEvidenceInput {
+  readonly guid: string;
+  readonly source?: SourceDeclarationEvidence;
+  readonly locator?: AssetEvidenceLocator;
+  readonly receipt?: CookReceipt;
+  readonly package?: OfflinePackageInput;
+  readonly product?: CookProduct;
+}
+
+function packageEvidence(input: OfflinePackageInput): NonNullable<AssetEvidenceInputs['package']> {
+  return {
+    guid: input.guid,
+    ...(input.digest === undefined ? {} : { digest: input.digest }),
+    artifacts: Object.fromEntries(
+      Object.entries(input.artifacts).map(([key, artifact]) => [
+        key,
+        {
+          descriptor: artifact,
+          verification: artifact.verification ?? 'passed',
+        },
+      ]),
+    ),
+  };
+}
+
+/** Build the shared evidence view without loading runtime assets or opening WS. */
+export function buildOfflineAssetEvidence(
+  input: OfflineAssetEvidenceInput,
+): Promise<Result<AssetEvidence, AssetEvidenceError>> {
+  if (input.product !== undefined) {
+    return Promise.resolve(projectCookProductEvidence(input.product, input.locator));
+  }
+  const evidenceInput: AssetEvidenceInputs = {
+    guid: input.guid,
+    ...(input.source === undefined ? {} : { source: input.source }),
+    ...(input.locator === undefined ? {} : { locator: input.locator }),
+    ...(input.receipt === undefined ? {} : { receipt: input.receipt }),
+    ...(input.package === undefined ? {} : { package: packageEvidence(input.package) }),
+  };
+  return Promise.resolve(projectAssetEvidence(evidenceInput));
+}
+
+export function packageVerification(
+  input: OfflinePackageInput | undefined,
+): PackageVerificationEvidence | undefined {
+  if (input === undefined) return undefined;
+  const packageInput = packageEvidence(input);
+  const statuses = Object.values(packageInput.artifacts).map(
+    (artifact) => artifact.verification ?? 'notChecked',
+  );
+  return {
+    status: statuses.some((status) => status === 'failed')
+      ? 'failed'
+      : statuses.length > 0 && statuses.every((status) => status === 'passed')
+        ? 'passed'
+        : 'notChecked',
+    ...(input?.digest === undefined ? {} : { digest: input.digest }),
+  };
+}

package/src/evidence/source-inventory.ts

@@ -0,0 +1,193 @@
+import { createHash } from 'node:crypto';
+import { readdir, readFile } from 'node:fs/promises';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import type { SourceDeclarationEvidence } from '@forgeax/engine-types';
+import { SCANNER_BLACKLIST, scan } from '../scanner.js';
+import { projectScriptablePackMeta } from '../scriptable-pack.js';
+import { loadScriptablePack } from '../scriptable-pack-node.js';
+
+/** Project root and GUID used to locate an authoritative source declaration. */
+export interface SourceInventoryRequest {
+  readonly projectRoot: string;
+  readonly guid: string;
+}
+
+export interface ProducerSemanticIdentityInput {
+  readonly producerRoot: string;
+  readonly sourcePath: string;
+  readonly sourceDigest: string;
+  readonly schemaVersion: string;
+  readonly importer: string;
+  readonly codec: string;
+  readonly settings: unknown;
+  readonly producer: string;
+  readonly profile: string;
+  readonly declaredGuids?: readonly string[];
+}
+
+export interface ProducerRelativeDdcIdentity {
+  readonly logicalPath: string;
+  readonly sourceDigest: string;
+  readonly key: string;
+}
+
+function stableValue(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value as Record<string, unknown>)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, stableValue(entry)]),
+    );
+  }
+  return value;
+}
+
+export function producerRelativeLogicalPath(producerRoot: string, sourcePath: string): string {
+  const root = resolve(producerRoot);
+  const source = resolve(sourcePath);
+  const path = relative(root, source);
+  if (
+    path.length === 0 ||
+    path === '..' ||
+    path.startsWith(`..${sep}`) ||
+    resolve(root, path) !== source
+  ) {
+    throw new Error('producer source must be inside the injected producer root');
+  }
+  return path.split(sep).join('/');
+}
+
+export function producerRelativeDdcKey(input: ProducerSemanticIdentityInput): string {
+  const logicalPath = producerRelativeLogicalPath(input.producerRoot, input.sourcePath);
+  const semantic = {
+    schemaVersion: input.schemaVersion,
+    logicalPath,
+    sourceDigest: input.sourceDigest,
+    importer: input.importer,
+    codec: input.codec,
+    settings: stableValue(input.settings),
+    producer: input.producer,
+    profile: input.profile,
+    declaredGuids: [...(input.declaredGuids ?? [])].sort(),
+  };
+  return createHash('sha256').update(JSON.stringify(semantic)).digest('hex');
+}
+
+export function producerRelativeDdcIdentity(
+  input: ProducerSemanticIdentityInput,
+): ProducerRelativeDdcIdentity {
+  return {
+    logicalPath: producerRelativeLogicalPath(input.producerRoot, input.sourcePath),
+    sourceDigest: input.sourceDigest,
+    key: producerRelativeDdcKey(input),
+  };
+}
+
+function fingerprint(meta: string, source: Uint8Array | undefined): string {
+  const hash = createHash('sha256').update(meta);
+  if (source !== undefined) hash.update(source);
+  return hash.digest('base64');
+}
+
+function sourceFromMeta(
+  metaPath: string,
+  meta: {
+    readonly source?: unknown;
+    readonly inputFingerprint?: unknown;
+    readonly importSettings?: unknown;
+    readonly subAssets?: readonly { readonly guid?: unknown }[];
+  },
+  guid: string,
+  raw: string,
+): SourceDeclarationEvidence | undefined {
+  if (
+    !meta.subAssets?.some(
+      (asset) => typeof asset.guid === 'string' && asset.guid.toLowerCase() === guid.toLowerCase(),
+    )
+  ) {
+    return undefined;
+  }
+  const source =
+    typeof meta.source === 'string' ? meta.source : basename(metaPath).replace(/\.meta\.json$/, '');
+  const sourcePath = resolve(dirname(metaPath), source);
+  const inputFingerprint =
+    typeof meta.inputFingerprint === 'string' ? meta.inputFingerprint : fingerprint(raw, undefined);
+  return { origin: 'sourceMeta', sourcePath, inputFingerprint };
+}
+
+async function collectDeclarationPaths(root: string): Promise<string[]> {
+  const paths: string[] = [];
+  async function visit(dir: string): Promise<void> {
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (!SCANNER_BLACKLIST.has(entry.name)) await visit(path);
+        continue;
+      }
+      if (
+        entry.isFile() &&
+        (entry.name.endsWith('.meta.json') ||
+          entry.name.endsWith('.pack.json') ||
+          entry.name.endsWith('.pack.ts'))
+      ) {
+        paths.push(path);
+      }
+    }
+  }
+  await visit(root);
+  return paths;
+}
+
+/** Read `.meta.json` or `.pack.json` source declarations without runtime imports. */
+export async function readSourceInventory(
+  request: SourceInventoryRequest,
+): Promise<SourceDeclarationEvidence | undefined> {
+  const result = await scan([request.projectRoot]);
+  const paths = result.ok ? result.value : await collectDeclarationPaths(request.projectRoot);
+  const guid = request.guid.toLowerCase();
+  let authored: SourceDeclarationEvidence | undefined;
+  for (const path of paths) {
+    if (path.endsWith('.pack.ts')) {
+      const loaded = await loadScriptablePack(path, { metadataOnly: true });
+      if (!loaded.ok) continue;
+      const meta = projectScriptablePackMeta(loaded.value, path);
+      if (meta.subAssets.some((asset) => asset.guid.toLowerCase() === guid)) {
+        return { origin: 'sourceMeta', sourcePath: path };
+      }
+      continue;
+    }
+    const raw = await readFile(path, 'utf8').catch(() => undefined);
+    if (raw === undefined) continue;
+    let parsed: {
+      readonly assets?: readonly { readonly guid?: unknown }[];
+      readonly source?: unknown;
+      readonly inputFingerprint?: unknown;
+      readonly importSettings?: unknown;
+      readonly subAssets?: readonly { readonly guid?: unknown }[];
+    };
+    try {
+      parsed = JSON.parse(raw) as typeof parsed;
+    } catch {
+      continue;
+    }
+    if (path.endsWith('.pack.json')) {
+      if (
+        parsed.assets?.some(
+          (asset) =>
+            typeof asset.guid === 'string' &&
+            (asset.guid === request.guid || asset.guid.toLowerCase() === guid),
+        )
+      ) {
+        authored = { origin: 'authoredPack', sourcePath: path };
+      }
+      continue;
+    }
+    if (path.endsWith('.meta.json')) {
+      const source = sourceFromMeta(path, parsed, request.guid, raw);
+      if (source !== undefined) return source;
+    }
+  }
+  return authored;
+}