Reference Integrity Hashes Implementation Plan¶

describe('LockfileReference', () => {
  it('should accept valid reference entry', () => {
    const ref: LockfileReference = {
      hash: 'sha256-abc123def456',
      lockedAt: '2026-04-01T12:00:00Z',
    };
    expect(ref.hash).toBe('sha256-abc123def456');
    expect(ref.lockedAt).toBe('2026-04-01T12:00:00Z');
  });
});

import type { LockfileDependency, Lockfile, LockfileReference } from '../types/lockfile.js';

/**
 * A locked reference file from a registry.
 * Key format in lockfile: `<repoUrl>\0<relativePath>\0<version>`
 */
export interface LockfileReference {
  /** Content integrity hash in SRI format: "sha256-<hex>" */
  hash: string;
  /** ISO timestamp of when prs lock recorded this hash */
  lockedAt: string;
}

export interface Lockfile {
  /** Lockfile format version. Use type guard `isValidLockfile()` after parsing. */
  version: number;
  /** Map of repo URL to locked dependency */
  dependencies: Record<string, LockfileDependency>;
  /** Map of reference key to integrity hash (optional, for registry reference files) */
  references?: Record<string, LockfileReference>;
}

  it('should accept valid lockfile with references section', () => {
    const lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        'https://github.com/org/repo\0ref.md\0v1.0.0': {
          hash: 'sha256-abc123',
          lockedAt: '2026-04-01T12:00:00Z',
        },
      },
    };
    expect(isValidLockfile(lockfile)).toBe(true);
  });

  it('should accept lockfile without references section (backward compat)', () => {
    const lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
    };
    expect(isValidLockfile(lockfile)).toBe(true);
  });

  it('should reject lockfile with non-object references', () => {
    const lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: 'bad',
    };
    expect(isValidLockfile(lockfile)).toBe(false);
  });

  it('should reject lockfile with malformed reference entry', () => {
    const lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        'key': { hash: 123 },
      },
    };
    expect(isValidLockfile(lockfile)).toBe(false);
  });

/** Type guard: validates parsed lockfile has correct version and shape */
export function isValidLockfile(data: unknown): data is Lockfile {
  if (
    typeof data !== 'object' ||
    data === null ||
    !('version' in data) ||
    (data as Record<string, unknown>)['version'] !== LOCKFILE_VERSION ||
    !('dependencies' in data)
  ) {
    return false;
  }

  // Validate optional references section shape
  if ('references' in data) {
    const refs = (data as Record<string, unknown>)['references'];
    if (typeof refs !== 'object' || refs === null || Array.isArray(refs)) {
      return false;
    }
    for (const entry of Object.values(refs as Record<string, unknown>)) {
      if (
        typeof entry !== 'object' ||
        entry === null ||
        typeof (entry as Record<string, unknown>)['hash'] !== 'string' ||
        typeof (entry as Record<string, unknown>)['lockedAt'] !== 'string'
      ) {
        return false;
      }
    }
  }

  return true;
}

import { describe, it, expect } from 'vitest';
import { hashContent, buildReferenceKey, isInsideCachePath } from '../reference-hasher.js';

describe('hashContent', () => {
  it('should produce sha256- prefixed hash', () => {
    const content = Buffer.from('hello world');
    const result = hashContent(content);
    expect(result).toMatch(/^sha256-[a-f0-9]{64}$/);
  });

  it('should produce consistent hash for same content', () => {
    const content = Buffer.from('test content');
    expect(hashContent(content)).toBe(hashContent(content));
  });

  it('should produce different hash for different content', () => {
    const a = Buffer.from('content a');
    const b = Buffer.from('content b');
    expect(hashContent(a)).not.toBe(hashContent(b));
  });

  it('should handle empty buffer', () => {
    const result = hashContent(Buffer.from(''));
    expect(result).toMatch(/^sha256-[a-f0-9]{64}$/);
  });
});

import { createHash } from 'crypto';
import { resolve, normalize } from 'path';

/**
 * Compute SHA-256 hash of in-memory content.
 * Returns SRI-format string: "sha256-<hex>"
 *
 * @param content - Raw file bytes to hash
 */
export function hashContent(content: Buffer): string {
  const hex = createHash('sha256').update(content).digest('hex');
  return `sha256-${hex}`;
}

describe('buildReferenceKey', () => {
  it('should join components with null byte separator', () => {
    const key = buildReferenceKey(
      'https://github.com/org/repo',
      'references/patterns.md',
      'v2.1.0'
    );
    expect(key).toBe('https://github.com/org/repo\0references/patterns.md\0v2.1.0');
  });

  it('should handle empty version', () => {
    const key = buildReferenceKey('https://github.com/org/repo', 'file.md', '');
    expect(key).toBe('https://github.com/org/repo\0file.md\0');
  });

  it('should not collide with crafted URL containing separator chars', () => {
    const key1 = buildReferenceKey('https://evil.com/a', 'b.md', 'v1');
    const key2 = buildReferenceKey('https://evil.com/a\0b.md\0v1', '', '');
    expect(key1).not.toBe(key2);
  });
});

/**
 * Build a lockfile key for a registry reference file.
 * Format: `<repoUrl>\0<relativePath>\0<version>`
 *
 * Uses null byte separator consistent with MARKER_SEP in loader.ts.
 * This is the sole canonical key builder — used by both lock generation
 * and compile-time verification.
 *
 * @param repoUrl - Git repository URL
 * @param relativePath - Path within the repository
 * @param version - Version tag or branch
 */
export function buildReferenceKey(
  repoUrl: string,
  relativePath: string,
  version: string
): string {
  return `${repoUrl}\0${relativePath}\0${version}`;
}

describe('isInsideCachePath', () => {
  it('should return true for path inside cache', () => {
    expect(isInsideCachePath('/cache/registries/org/repo/v1/file.md', '/cache')).toBe(true);
  });

  it('should return false for path traversal outside cache', () => {
    expect(isInsideCachePath('/cache/../etc/passwd', '/cache')).toBe(false);
  });

  it('should return false for completely outside path', () => {
    expect(isInsideCachePath('/other/path/file.md', '/cache')).toBe(false);
  });

  it('should handle nested traversal', () => {
    expect(isInsideCachePath('/cache/a/../../etc/passwd', '/cache')).toBe(false);
  });

  it('should normalize paths before comparison', () => {
    expect(isInsideCachePath('/cache/./registries/../registries/file.md', '/cache')).toBe(true);
  });
});

/**
 * Verify that a resolved file path is contained within the cache directory.
 * Prevents path traversal attacks via symlinks or `../` in reference paths.
 *
 * @param filePath - Resolved absolute file path
 * @param cachePath - Cache directory boundary
 * @returns true if filePath is inside cachePath after normalization
 */
export function isInsideCachePath(filePath: string, cachePath: string): boolean {
  const normalizedFile = resolve(normalize(filePath));
  const normalizedCache = resolve(normalize(cachePath));
  return normalizedFile.startsWith(normalizedCache + '/') || normalizedFile === normalizedCache;
}

export { hashContent, buildReferenceKey, isInsideCachePath } from './reference-hasher.js';

export interface LockOptions {
  /** Preview without writing lockfile */
  dryRun?: boolean;
  /** Force fresh clone and re-hash all registry references */
  update?: boolean;
}

  /** Skip reference integrity hash verification */
  ignoreHashes?: boolean;

  /** Skip reference integrity checks (disables PS031) */
  ignoreHashes?: boolean;

  /** Skip reference integrity hash verification */
  ignoreHashes?: boolean;

import type { Logger, Program, SourceLocation, PolicyDefinition, Lockfile } from '@promptscript/core';

  /** Lockfile for reference integrity checks */
  lockfile?: Lockfile;
  /** Set of resolved absolute paths that came from registry cache */
  registryReferences?: Set<string>;
  /** Skip reference integrity checks */
  ignoreHashes?: boolean;

import { describe, it, expect } from 'vitest';
import { referenceIntegrity } from '../reference-integrity.js';
import type { Program, SourceLocation, Block, Lockfile } from '@promptscript/core';
import { LOCKFILE_VERSION } from '@promptscript/core';
import type { RuleContext, ValidationMessage, ValidatorConfig } from '../../types.js';

const loc: SourceLocation = { file: 'test.prs', line: 1, column: 1 };

function makeSkillsBlock(skills: Record<string, { references?: string[] }>): Block {
  const properties: Record<string, unknown> = {};
  for (const [name, skill] of Object.entries(skills)) {
    properties[name] = {
      description: `${name} skill`,
      ...(skill.references ? { references: skill.references } : {}),
    };
  }
  return {
    type: 'Block',
    name: 'skills',
    loc,
    content: { type: 'ObjectContent', properties, loc },
  };
}

function makeAst(blocks: Block[] = []): Program {
  return {
    type: 'Program',
    loc,
    meta: { type: 'MetaBlock', loc, fields: { id: 'test', version: '1.0.0' } },
    uses: [],
    blocks,
    extends: [],
  };
}

function validate(
  ast: Program,
  config: ValidatorConfig = {}
): ValidationMessage[] {
  const messages: ValidationMessage[] = [];
  const ctx: RuleContext = {
    ast,
    config,
    report: (msg) => {
      messages.push({
        ruleId: referenceIntegrity.id,
        ruleName: referenceIntegrity.name,
        severity: referenceIntegrity.defaultSeverity,
        ...msg,
      });
    },
  };
  referenceIntegrity.validate(ctx);
  return messages;
}

describe('PS031: reference-integrity', () => {
  it('should have correct metadata', () => {
    expect(referenceIntegrity.id).toBe('PS031');
    expect(referenceIntegrity.name).toBe('reference-integrity');
    expect(referenceIntegrity.defaultSeverity).toBe('warning');
  });

  it('should produce no messages when no lockfile', () => {
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: ['ref.md'] } })]);
    const messages = validate(ast, {});
    expect(messages).toHaveLength(0);
  });

  it('should produce no messages when lockfile has no references section', () => {
    const lockfile: Lockfile = { version: LOCKFILE_VERSION, dependencies: {} };
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: ['ref.md'] } })]);
    const messages = validate(ast, { lockfile });
    expect(messages).toHaveLength(0);
  });

  it('should produce no messages when ignoreHashes is true', () => {
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {},
    };
    const registryReferences = new Set(['/cache/registries/org/repo/v1/ref.md']);
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: ['ref.md'] } })]);
    const messages = validate(ast, { lockfile, registryReferences, ignoreHashes: true });
    expect(messages).toHaveLength(0);
  });

  it('should produce no messages for local references (not in registryReferences set)', () => {
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {},
    };
    const registryReferences = new Set<string>(); // empty — no registry refs
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: ['local.md'] } })]);
    const messages = validate(ast, { lockfile, registryReferences });
    expect(messages).toHaveLength(0);
  });

  it('should warn when registry reference has no hash entry', () => {
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {},
    };
    const refPath = '/cache/registries/org/repo/v1/ref.md';
    const registryReferences = new Set([refPath]);
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: [refPath] } })]);
    const messages = validate(ast, { lockfile, registryReferences });
    expect(messages).toHaveLength(1);
    expect(messages[0]!.message).toContain('no integrity hash');
    expect(messages[0]!.suggestion).toContain('prs lock');
  });

  it('should produce no messages when all registry references have hash entries', () => {
    const refPath = '/cache/registries/org/repo/v1/ref.md';
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        'somekey': {
          hash: 'sha256-abc123',
          lockedAt: '2026-04-01T12:00:00Z',
        },
      },
    };
    const registryReferences = new Set([refPath]);
    // PS031 checks presence in lockfile.references values, not by specific key lookup
    // The rule checks if registryReferences paths have ANY matching entry
    const ast = makeAst([makeSkillsBlock({ mySkill: { references: [refPath] } })]);
    // For this test, we need the config to map refPath -> key
    // PS031 uses registryReferenceKeys map instead
    const messages = validate(ast, {
      lockfile,
      registryReferences,
      registryReferenceKeys: new Map([[refPath, 'somekey']]),
    } as ValidatorConfig);
    expect(messages).toHaveLength(0);
  });

  it('should skip skills blocks without references', () => {
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {},
    };
    const ast = makeAst([makeSkillsBlock({ mySkill: {} })]);
    const messages = validate(ast, { lockfile, registryReferences: new Set() });
    expect(messages).toHaveLength(0);
  });
});

import type { ValidationRule } from '../types.js';

/**
 * PS031: Reference integrity.
 *
 * Checks that registry-sourced skill reference files have corresponding
 * integrity hash entries in the lockfile. This is a structural presence
 * check — actual hash verification happens in the compiler layer.
 */
export const referenceIntegrity: ValidationRule = {
  id: 'PS031',
  name: 'reference-integrity',
  description: 'Registry reference files must have integrity hashes in lockfile',
  defaultSeverity: 'warning',
  validate: (ctx) => {
    const { lockfile, registryReferences, ignoreHashes } = ctx.config;

    // Skip if no lockfile, no references section, or hashes disabled
    if (ignoreHashes || !lockfile || !lockfile.references || !registryReferences) {
      return;
    }

    // Walk @skills blocks looking for references arrays
    for (const block of ctx.ast.blocks) {
      if (block.name !== 'skills' || block.content.type !== 'ObjectContent') {
        continue;
      }

      for (const [, skillValue] of Object.entries(block.content.properties)) {
        if (
          typeof skillValue !== 'object' ||
          skillValue === null ||
          !('references' in skillValue)
        ) {
          continue;
        }

        const refs = (skillValue as Record<string, unknown>)['references'];
        if (!Array.isArray(refs)) continue;

        for (const ref of refs) {
          if (typeof ref !== 'string') continue;

          // Only check registry-sourced references
          if (!registryReferences.has(ref)) continue;

          // Check if any lockfile entry covers this reference
          const hasEntry = Object.keys(lockfile.references).some(
            (key) => key.includes(ref) || ref.includes(key.split('\0')[1] ?? '')
          );

          if (!hasEntry) {
            ctx.report({
              message: `Registry reference "${ref}" has no integrity hash in lockfile`,
              location: block.loc,
              suggestion: 'Run `prs lock` to generate integrity hashes for registry references',
            });
          }
        }
      }
    }
  },
};

import { referenceIntegrity } from './reference-integrity.js';

export { referenceIntegrity } from './reference-integrity.js';

  // Reference integrity (PS031)
  referenceIntegrity,

import { describe, it, expect } from 'vitest';
import { verifyReferenceIntegrity } from '../reference-verifier.js';
import type { Lockfile } from '@promptscript/core';
import { LOCKFILE_VERSION } from '@promptscript/core';
import { hashContent, buildReferenceKey } from '@promptscript/resolver';

describe('verifyReferenceIntegrity', () => {
  const repoUrl = 'https://github.com/org/repo';
  const version = 'v1.0.0';

  it('should pass when hash matches', () => {
    const content = Buffer.from('valid content');
    const hash = hashContent(content);
    const key = buildReferenceKey(repoUrl, 'ref.md', version);
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        [key]: { hash, lockedAt: '2026-04-01T00:00:00Z' },
      },
    };

    expect(() =>
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'ref.md',
        version,
        lockfile,
      })
    ).not.toThrow();
  });

  it('should throw on hash mismatch', () => {
    const content = Buffer.from('tampered content');
    const key = buildReferenceKey(repoUrl, 'ref.md', version);
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        [key]: { hash: 'sha256-wrong', lockedAt: '2026-04-01T00:00:00Z' },
      },
    };

    expect(() =>
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'ref.md',
        version,
        lockfile,
      })
    ).toThrow(/hash mismatch/i);
  });

  it('should throw when no hash entry exists and lockfile has references section', () => {
    const content = Buffer.from('new content');
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {},
    };

    expect(() =>
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'new-ref.md',
        version,
        lockfile,
      })
    ).toThrow(/no integrity hash/i);
  });

  it('should skip verification when lockfile has no references section', () => {
    const content = Buffer.from('content');
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
    };

    expect(() =>
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'ref.md',
        version,
        lockfile,
      })
    ).not.toThrow();
  });

  it('should skip verification when no lockfile provided', () => {
    const content = Buffer.from('content');

    expect(() =>
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'ref.md',
        version,
        lockfile: undefined,
      })
    ).not.toThrow();
  });

  it('should include file name and remediation in mismatch error', () => {
    const content = Buffer.from('tampered');
    const key = buildReferenceKey(repoUrl, 'patterns.md', version);
    const lockfile: Lockfile = {
      version: LOCKFILE_VERSION,
      dependencies: {},
      references: {
        [key]: { hash: 'sha256-wrong', lockedAt: '2026-04-01T00:00:00Z' },
      },
    };

    try {
      verifyReferenceIntegrity({
        content,
        repoUrl,
        relativePath: 'patterns.md',
        version,
        lockfile,
      });
      expect.fail('should have thrown');
    } catch (err) {
      const msg = (err as Error).message;
      expect(msg).toContain('patterns.md');
      expect(msg).toContain('prs lock --update');
    }
  });
});

import type { Lockfile } from '@promptscript/core';
import { hashContent, buildReferenceKey } from '@promptscript/resolver';

/**
 * Parameters for reference integrity verification.
 */
export interface VerifyReferenceOptions {
  /** Raw file content (already read into memory) */
  content: Buffer;
  /** Repository URL */
  repoUrl: string;
  /** Relative path within the repository */
  relativePath: string;
  /** Version tag */
  version: string;
  /** Lockfile (may be undefined if not present) */
  lockfile: Lockfile | undefined;
}

/**
 * Verify that a registry reference file's content matches the lockfile hash.
 *
 * @throws Error if hash mismatches or entry is missing (when lockfile has references section)
 */
export function verifyReferenceIntegrity(options: VerifyReferenceOptions): void {
  const { content, repoUrl, relativePath, version, lockfile } = options;

  // No lockfile or no references section — skip (backward compat)
  if (!lockfile || !lockfile.references) {
    return;
  }

  const key = buildReferenceKey(repoUrl, relativePath, version);
  const entry = lockfile.references[key];

  if (!entry) {
    throw new Error(
      `Reference file "${relativePath}" has no integrity hash in lockfile. ` +
      `Run \`prs lock\` to generate integrity hashes for registry references.`
    );
  }

  const actualHash = hashContent(content);
  if (actualHash !== entry.hash) {
    throw new Error(
      `Reference file hash mismatch: ${relativePath} has changed since last lock. ` +
      `Run \`prs lock --update\` to accept changes.`
    );
  }
}

import { verifyReferenceIntegrity } from './reference-verifier.js';

    // Stage 1.5: Verify reference integrity (between resolve and validate)
    if (!this.options.ignoreHashes && this.options.resolver.lockfile?.references) {
      this.logger.verbose('=== Stage 1.5: Reference Integrity ===');
      // Collect registry reference paths for the validator
      const registryReferences = new Set<string>();

      for (const block of resolved.ast.blocks) {
        if (block.name !== 'skills' || block.content.type !== 'ObjectContent') continue;

        for (const [, skillValue] of Object.entries(block.content.properties)) {
          if (
            typeof skillValue !== 'object' ||
            skillValue === null ||
            !('references' in skillValue)
          ) continue;

          const refs = (skillValue as Record<string, unknown>)['references'];
          if (!Array.isArray(refs)) continue;

          for (const ref of refs) {
            if (typeof ref !== 'string') continue;
            registryReferences.add(ref);
          }
        }
      }

      // Pass registry references to validator config for PS031
      if (this.options.validator) {
        this.options.validator.registryReferences = registryReferences;
        this.options.validator.lockfile = this.options.resolver.lockfile;
        this.options.validator.ignoreHashes = this.options.ignoreHashes;
      }
    } else if (this.options.ignoreHashes) {
      this.logger.verbose('⚠ --ignore-hashes is set: reference integrity verification is disabled');
      if (this.options.validator) {
        this.options.validator.ignoreHashes = true;
      }
    }

.option('--ignore-hashes', 'Skip reference integrity hash verification')

.option('--ignore-hashes', 'Skip reference integrity checks')

.option('--update', 'Force fresh clone and re-hash all registry references')

    const compiler = new Compiler({
      resolver: {
        registryPath,
        localPath,
        skills: resolveUniversalDir(config.universalDir),
        registries: config.registries,
        lockfile,
      },
      validator: config.validation,
      formatters: targets,
      customConventions: config.customConventions,
      prettier: prettierOptions,
      logger,
      skillContent,
      ignoreHashes: options.ignoreHashes,
    });

    if (options.ignoreHashes) {
      console.error('⚠ --ignore-hashes is set: reference integrity verification is disabled');
    }

    ignoreHashes: options.ignoreHashes,

import { describe, it, expect } from 'vitest';
import { collectRegistryReferences } from '../lock-reference-scanner.js';
import type { Program, SourceLocation, Block } from '@promptscript/core';

const loc: SourceLocation = { file: 'test.prs', line: 1, column: 1 };

function makeSkillsBlock(skills: Record<string, { references?: string[] }>): Block {
  const properties: Record<string, unknown> = {};
  for (const [name, skill] of Object.entries(skills)) {
    properties[name] = {
      description: `${name} skill`,
      ...(skill.references ? { references: skill.references } : {}),
    };
  }
  return {
    type: 'Block',
    name: 'skills',
    loc,
    content: { type: 'ObjectContent', properties, loc },
  };
}

function makeAst(blocks: Block[] = []): Program {
  return {
    type: 'Program',
    loc,
    meta: { type: 'MetaBlock', loc, fields: { id: 'test', version: '1.0.0' } },
    uses: [],
    blocks,
    extends: [],
  };
}

describe('collectRegistryReferences', () => {
  it('should return empty array when no skills blocks', () => {
    const result = collectRegistryReferences(makeAst(), '/cache');
    expect(result).toEqual([]);
  });

  it('should return empty array when skills have no references', () => {
    const ast = makeAst([makeSkillsBlock({ mySkill: {} })]);
    const result = collectRegistryReferences(ast, '/cache');
    expect(result).toEqual([]);
  });

  it('should collect references that start with cache path', () => {
    const ast = makeAst([
      makeSkillsBlock({
        mySkill: { references: ['/cache/registries/org/repo/v1/ref.md', './local.md'] },
      }),
    ]);
    const result = collectRegistryReferences(ast, '/cache');
    expect(result).toHaveLength(1);
    expect(result[0]).toBe('/cache/registries/org/repo/v1/ref.md');
  });

  it('should deduplicate references', () => {
    const refPath = '/cache/registries/org/repo/v1/ref.md';
    const ast = makeAst([
      makeSkillsBlock({
        skillA: { references: [refPath] },
        skillB: { references: [refPath] },
      }),
    ]);
    const result = collectRegistryReferences(ast, '/cache');
    expect(result).toHaveLength(1);
  });

  it('should skip non-string reference entries', () => {
    const block: Block = {
      type: 'Block',
      name: 'skills',
      loc,
      content: {
        type: 'ObjectContent',
        properties: {
          mySkill: { description: 'test', references: [123, null, '/cache/ref.md'] },
        },
        loc,
      },
    };
    const ast = makeAst([block]);
    const result = collectRegistryReferences(ast, '/cache');
    expect(result).toHaveLength(1);
  });
});