apcore-js 0.5.0 → 0.7.0

package/tests/test-acl.test.ts

@@ -1,423 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { ACL } from '../src/acl.js';
-import { ACLRuleError, ConfigNotFoundError } from '../src/errors.js';
-import { Context, createIdentity } from '../src/context.js';
-
-function makeContext(opts: {
-  callerId?: string | null;
-  callChain?: string[];
-  identityType?: string;
-  roles?: string[];
-} = {}): Context {
-  const identity = opts.identityType
-    ? createIdentity('test-user', opts.identityType, opts.roles ?? [])
-    : null;
-  return new Context(
-    'trace-test',
-    opts.callerId ?? null,
-    opts.callChain ?? [],
-    null,
-    identity,
-  );
-}
-
-describe('ACL', () => {
-  it('allows access when allow rule matches', () => {
-    const acl = new ACL([
-      { callers: ['module.a'], targets: ['module.b'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.a', 'module.b')).toBe(true);
-  });
-
-  it('denies access when deny rule matches', () => {
-    const acl = new ACL([
-      { callers: ['module.a'], targets: ['module.b'], effect: 'deny', description: '' },
-    ]);
-    expect(acl.check('module.a', 'module.b')).toBe(false);
-  });
-
-  it('returns default deny when no rule matches', () => {
-    const acl = new ACL([
-      { callers: ['module.a'], targets: ['module.b'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.x', 'module.y')).toBe(false);
-  });
-
-  it('first-match-wins: deny before allow', () => {
-    const acl = new ACL([
-      { callers: ['module.a'], targets: ['module.b'], effect: 'deny', description: '' },
-      { callers: ['module.a'], targets: ['module.b'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.a', 'module.b')).toBe(false);
-  });
-
-  it('first-match-wins: allow before deny', () => {
-    const acl = new ACL([
-      { callers: ['module.a'], targets: ['module.b'], effect: 'allow', description: '' },
-      { callers: ['module.a'], targets: ['module.b'], effect: 'deny', description: '' },
-    ]);
-    expect(acl.check('module.a', 'module.b')).toBe(true);
-  });
-
-  it('default effect allow when no rules match', () => {
-    const acl = new ACL([], 'allow');
-    expect(acl.check('any', 'thing')).toBe(true);
-  });
-
-  it('maps null callerId to @external', () => {
-    const acl = new ACL([
-      { callers: ['@external'], targets: ['public.api'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check(null, 'public.api')).toBe(true);
-  });
-
-  it('does not match @external for real module caller', () => {
-    const acl = new ACL([
-      { callers: ['@external'], targets: ['public.api'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.a', 'public.api')).toBe(false);
-  });
-
-  it('wildcard * matches all callers', () => {
-    const acl = new ACL([
-      { callers: ['*'], targets: ['public.api'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.a', 'public.api')).toBe(true);
-    expect(acl.check('module.b', 'public.api')).toBe(true);
-  });
-
-  it('wildcard * matches all targets', () => {
-    const acl = new ACL([
-      { callers: ['module.admin'], targets: ['*'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('module.admin', 'anything')).toBe(true);
-  });
-
-  it('prefix wildcard matching', () => {
-    const acl = new ACL([
-      { callers: ['core.*'], targets: ['data.*'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('core.auth', 'data.store')).toBe(true);
-    expect(acl.check('other.x', 'data.y')).toBe(false);
-  });
-
-  it('@system matches system identity type', () => {
-    const acl = new ACL([
-      { callers: ['@system'], targets: ['*'], effect: 'allow', description: '' },
-    ]);
-    const ctx = makeContext({ identityType: 'system' });
-    expect(acl.check('any.module', 'any.target', ctx)).toBe(true);
-  });
-
-  it('@system does not match non-system identity', () => {
-    const acl = new ACL([
-      { callers: ['@system'], targets: ['*'], effect: 'allow', description: '' },
-    ]);
-    const ctx = makeContext({ identityType: 'user' });
-    expect(acl.check('any.module', 'any.target', ctx)).toBe(false);
-  });
-
-  it('conditions: identity_types allows matching type', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['admin'], effect: 'allow', description: '',
-      conditions: { identity_types: ['admin'] },
-    }]);
-    const ctx = makeContext({ identityType: 'admin' });
-    expect(acl.check('mod.a', 'admin', ctx)).toBe(true);
-  });
-
-  it('conditions: identity_types denies non-matching type', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['admin'], effect: 'allow', description: '',
-      conditions: { identity_types: ['admin'] },
-    }]);
-    const ctx = makeContext({ identityType: 'user' });
-    expect(acl.check('mod.a', 'admin', ctx)).toBe(false);
-  });
-
-  it('conditions: roles allows matching role', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['settings'], effect: 'allow', description: '',
-      conditions: { roles: ['editor', 'admin'] },
-    }]);
-    const ctx = makeContext({ identityType: 'user', roles: ['editor'] });
-    expect(acl.check('mod.a', 'settings', ctx)).toBe(true);
-  });
-
-  it('conditions: roles denies missing role', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['settings'], effect: 'allow', description: '',
-      conditions: { roles: ['admin'] },
-    }]);
-    const ctx = makeContext({ identityType: 'user', roles: ['viewer'] });
-    expect(acl.check('mod.a', 'settings', ctx)).toBe(false);
-  });
-
-  it('conditions: max_call_depth allows within limit', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['deep'], effect: 'allow', description: '',
-      conditions: { max_call_depth: 3 },
-    }]);
-    const ctx = makeContext({ callChain: ['a', 'b'] });
-    expect(acl.check('mod.a', 'deep', ctx)).toBe(true);
-  });
-
-  it('conditions: max_call_depth denies exceeding limit', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['deep'], effect: 'allow', description: '',
-      conditions: { max_call_depth: 2 },
-    }]);
-    const ctx = makeContext({ callChain: ['a', 'b', 'c'] });
-    expect(acl.check('mod.a', 'deep', ctx)).toBe(false);
-  });
-
-  it('conditions fail when no context provided', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['deep'], effect: 'allow', description: '',
-      conditions: { max_call_depth: 5 },
-    }]);
-    expect(acl.check('mod.a', 'deep')).toBe(false);
-  });
-
-  it('addRule adds to highest priority', () => {
-    const acl = new ACL([
-      { callers: ['*'], targets: ['*'], effect: 'deny', description: '' },
-    ]);
-    expect(acl.check('mod.a', 'mod.b')).toBe(false);
-
-    acl.addRule({ callers: ['mod.a'], targets: ['mod.b'], effect: 'allow', description: '' });
-    expect(acl.check('mod.a', 'mod.b')).toBe(true);
-  });
-
-  it('removeRule removes matching rule', () => {
-    const acl = new ACL([
-      { callers: ['mod.a'], targets: ['mod.b'], effect: 'allow', description: '' },
-    ]);
-    expect(acl.check('mod.a', 'mod.b')).toBe(true);
-
-    const removed = acl.removeRule(['mod.a'], ['mod.b']);
-    expect(removed).toBe(true);
-    expect(acl.check('mod.a', 'mod.b')).toBe(false);
-  });
-
-  it('removeRule returns false when no match', () => {
-    const acl = new ACL([]);
-    expect(acl.removeRule(['x'], ['y'])).toBe(false);
-  });
-});
-
-describe('ACL.load', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'acl-test-'));
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('loads valid ACL from a YAML file', () => {
-    const yamlContent = `
-rules:
-  - callers: ["module.a"]
-    targets: ["module.b"]
-    effect: allow
-    description: "allow a to b"
-`;
-    const filePath = join(tmpDir, 'acl.yaml');
-    writeFileSync(filePath, yamlContent, 'utf-8');
-
-    const acl = ACL.load(filePath);
-    expect(acl.check('module.a', 'module.b')).toBe(true);
-    expect(acl.check('module.x', 'module.y')).toBe(false);
-  });
-
-  it('loads ACL with custom default_effect from YAML', () => {
-    const yamlContent = `
-default_effect: allow
-rules: []
-`;
-    const filePath = join(tmpDir, 'acl.yaml');
-    writeFileSync(filePath, yamlContent, 'utf-8');
-
-    const acl = ACL.load(filePath);
-    expect(acl.check('any.caller', 'any.target')).toBe(true);
-  });
-
-  it('throws ConfigNotFoundError for missing file', () => {
-    const missingPath = join(tmpDir, 'nonexistent.yaml');
-    expect(() => ACL.load(missingPath)).toThrow(ConfigNotFoundError);
-  });
-
-  it('throws ACLRuleError for invalid YAML syntax', () => {
-    const filePath = join(tmpDir, 'bad.yaml');
-    writeFileSync(filePath, ':\n  :\n    - [invalid', 'utf-8');
-
-    expect(() => ACL.load(filePath)).toThrow(ACLRuleError);
-  });
-
-  it('throws ACLRuleError when YAML is not a mapping', () => {
-    const filePath = join(tmpDir, 'array.yaml');
-    writeFileSync(filePath, '- item1\n- item2\n', 'utf-8');
-
-    expect(() => ACL.load(filePath)).toThrow(ACLRuleError);
-    expect(() => ACL.load(filePath)).toThrow(/must be a mapping/);
-  });
-
-  it('throws ACLRuleError when YAML is a scalar', () => {
-    const filePath = join(tmpDir, 'scalar.yaml');
-    writeFileSync(filePath, 'just a string\n', 'utf-8');
-
-    expect(() => ACL.load(filePath)).toThrow(ACLRuleError);
-    expect(() => ACL.load(filePath)).toThrow(/must be a mapping/);
-  });
-
-  it('throws ACLRuleError when rules key is missing', () => {
-    const filePath = join(tmpDir, 'norules.yaml');
-    writeFileSync(filePath, 'default_effect: allow\n', 'utf-8');
-
-    expect(() => ACL.load(filePath)).toThrow(ACLRuleError);
-    expect(() => ACL.load(filePath)).toThrow(/missing required 'rules' key/);
-  });
-
-  it('throws ACLRuleError when rules is not an array', () => {
-    const filePath = join(tmpDir, 'badrules.yaml');
-    writeFileSync(filePath, 'rules: "not-a-list"\n', 'utf-8');
-
-    expect(() => ACL.load(filePath)).toThrow(ACLRuleError);
-    expect(() => ACL.load(filePath)).toThrow(/'rules' must be a list/);
-  });
-
-  it('loads ACL with multiple rules and conditions', () => {
-    const yamlContent = `
-rules:
-  - callers: ["*"]
-    targets: ["admin.panel"]
-    effect: allow
-    description: "admin access"
-    conditions:
-      roles: ["admin"]
-  - callers: ["*"]
-    targets: ["*"]
-    effect: deny
-    description: "deny all"
-`;
-    const filePath = join(tmpDir, 'multi.yaml');
-    writeFileSync(filePath, yamlContent, 'utf-8');
-
-    const acl = ACL.load(filePath);
-    const adminCtx = makeContext({ identityType: 'user', roles: ['admin'] });
-    const userCtx = makeContext({ identityType: 'user', roles: ['viewer'] });
-
-    expect(acl.check('mod.a', 'admin.panel', adminCtx)).toBe(true);
-    expect(acl.check('mod.a', 'admin.panel', userCtx)).toBe(false);
-  });
-});
-
-describe('ACL.reload', () => {
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), 'acl-reload-'));
-  });
-
-  afterEach(() => {
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it('reloads updated rules from the same YAML file', () => {
-    const filePath = join(tmpDir, 'acl.yaml');
-    writeFileSync(filePath, `
-rules:
-  - callers: ["module.a"]
-    targets: ["module.b"]
-    effect: deny
-    description: "initial deny"
-`, 'utf-8');
-
-    const acl = ACL.load(filePath);
-    expect(acl.check('module.a', 'module.b')).toBe(false);
-
-    writeFileSync(filePath, `
-rules:
-  - callers: ["module.a"]
-    targets: ["module.b"]
-    effect: allow
-    description: "updated allow"
-`, 'utf-8');
-
-    acl.reload();
-    expect(acl.check('module.a', 'module.b')).toBe(true);
-  });
-
-  it('throws ACLRuleError when ACL was not loaded from a file', () => {
-    const acl = new ACL([
-      { callers: ['*'], targets: ['*'], effect: 'allow', description: '' },
-    ]);
-
-    expect(() => acl.reload()).toThrow(ACLRuleError);
-    expect(() => acl.reload()).toThrow(/Cannot reload/);
-  });
-});
-
-describe('ACL constructor validation', () => {
-  it('throws ACLRuleError for invalid defaultEffect', () => {
-    expect(() => new ACL([], 'block')).toThrow(ACLRuleError);
-    expect(() => new ACL([], 'block')).toThrow(/Invalid default_effect/);
-  });
-
-  it('throws ACLRuleError for empty string defaultEffect', () => {
-    expect(() => new ACL([], '')).toThrow(ACLRuleError);
-  });
-});
-
-describe('ACL condition validation', () => {
-  it('returns false when identity_types condition is not an array', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['target'], effect: 'allow', description: '',
-      conditions: { identity_types: 'admin' },
-    }]);
-    const ctx = makeContext({ identityType: 'admin' });
-    expect(acl.check('mod.a', 'target', ctx)).toBe(false);
-  });
-
-  it('returns false when roles condition is not an array', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['target'], effect: 'allow', description: '',
-      conditions: { roles: 'admin' },
-    }]);
-    const ctx = makeContext({ identityType: 'user', roles: ['admin'] });
-    expect(acl.check('mod.a', 'target', ctx)).toBe(false);
-  });
-
-  it('returns false when max_call_depth condition is not a number', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['target'], effect: 'allow', description: '',
-      conditions: { max_call_depth: '5' },
-    }]);
-    const ctx = makeContext({ callChain: ['a'] });
-    expect(acl.check('mod.a', 'target', ctx)).toBe(false);
-  });
-
-  it('returns false for roles condition when identity is null', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['target'], effect: 'allow', description: '',
-      conditions: { roles: ['admin'] },
-    }]);
-    const ctx = makeContext({});
-    expect(acl.check('mod.a', 'target', ctx)).toBe(false);
-  });
-
-  it('returns false for identity_types condition when identity is null', () => {
-    const acl = new ACL([{
-      callers: ['*'], targets: ['target'], effect: 'allow', description: '',
-      conditions: { identity_types: ['admin'] },
-    }]);
-    const ctx = makeContext({});
-    expect(acl.check('mod.a', 'target', ctx)).toBe(false);
-  });
-});

package/tests/test-bindings.test.ts

@@ -1,227 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from 'node:fs';
-import { join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { BindingLoader } from '../src/bindings.js';
-import { Registry } from '../src/registry/registry.js';
-import {
-  BindingInvalidTargetError,
-  BindingFileInvalidError,
-  BindingModuleNotFoundError,
-  BindingCallableNotFoundError,
-  BindingNotCallableError,
-} from '../src/errors.js';
-
-let tmpDir: string;
-let loader: BindingLoader;
-let registry: Registry;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'apcore-binding-test-'));
-  loader = new BindingLoader();
-  registry = new Registry();
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function writeTempModule(filename: string, content: string): string {
-  const filePath = join(tmpDir, filename);
-  writeFileSync(filePath, content, 'utf-8');
-  return filePath;
-}
-
-function writeTempYaml(filename: string, content: string): string {
-  const filePath = join(tmpDir, filename);
-  writeFileSync(filePath, content, 'utf-8');
-  return filePath;
-}
-
-describe('BindingLoader', () => {
-  describe('instantiation', () => {
-    it('creates a new instance', () => {
-      expect(new BindingLoader()).toBeInstanceOf(BindingLoader);
-    });
-
-    it('has loadBindings, loadBindingDir, and resolveTarget methods', () => {
-      const bl = new BindingLoader();
-      expect(typeof bl.loadBindings).toBe('function');
-      expect(typeof bl.loadBindingDir).toBe('function');
-      expect(typeof bl.resolveTarget).toBe('function');
-    });
-  });
-
-  describe('resolveTarget', () => {
-    it('throws BindingInvalidTargetError for target without colon', async () => {
-      await expect(loader.resolveTarget('no_colon_here')).rejects.toThrow(BindingInvalidTargetError);
-    });
-
-    it('throws BindingModuleNotFoundError for non-existent module path', async () => {
-      await expect(
-        loader.resolveTarget('/nonexistent/path/to/module.mjs:someFunc'),
-      ).rejects.toThrow(BindingModuleNotFoundError);
-    });
-
-    it('successfully resolves a function export from a real JS module', async () => {
-      const modPath = writeTempModule(
-        'func_export.mjs',
-        'export function greet(name) { return `Hello, ${name}`; }\n',
-      );
-      const fn = await loader.resolveTarget(`${modPath}:greet`);
-      expect(typeof fn).toBe('function');
-      expect(fn('World')).toBe('Hello, World');
-    });
-
-    it('successfully resolves a class method', async () => {
-      const modPath = writeTempModule(
-        'class_export.mjs',
-        `export class Calculator {\n  add(a, b) { return a + b; }\n}\n`,
-      );
-      const fn = await loader.resolveTarget(`${modPath}:Calculator.add`);
-      expect(typeof fn).toBe('function');
-      expect(fn(2, 3)).toBe(5);
-    });
-
-    it('throws BindingCallableNotFoundError for missing callable', async () => {
-      const modPath = writeTempModule('missing_callable.mjs', 'export function exists() { return true; }\n');
-      await expect(loader.resolveTarget(`${modPath}:doesNotExist`)).rejects.toThrow(BindingCallableNotFoundError);
-    });
-
-    it('throws BindingNotCallableError for non-function export', async () => {
-      const modPath = writeTempModule('non_callable.mjs', 'export const MY_CONSTANT = 42;\n');
-      await expect(loader.resolveTarget(`${modPath}:MY_CONSTANT`)).rejects.toThrow(BindingNotCallableError);
-    });
-  });
-
-  describe('loadBindings', () => {
-    it('throws BindingFileInvalidError for non-existent file', async () => {
-      await expect(
-        loader.loadBindings('/nonexistent/path/binding.yaml', registry),
-      ).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for invalid YAML', async () => {
-      const yamlPath = writeTempYaml('invalid.binding.yaml', '{ invalid yaml: [unclosed');
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for empty file', async () => {
-      const yamlPath = writeTempYaml('empty.binding.yaml', '');
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for missing bindings key', async () => {
-      const yamlPath = writeTempYaml('nokey.binding.yaml', 'other_key: value\n');
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for non-array bindings value', async () => {
-      const yamlPath = writeTempYaml('notarray.binding.yaml', 'bindings: "not an array"\n');
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for binding entry missing module_id', async () => {
-      const modPath = writeTempModule('dummy_mod.mjs', 'export function dummy() { return {}; }\n');
-      const yamlPath = writeTempYaml('noid.binding.yaml', `bindings:\n  - target: "${modPath}:dummy"\n`);
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('throws BindingFileInvalidError for binding entry missing target', async () => {
-      const yamlPath = writeTempYaml('notarget.binding.yaml', 'bindings:\n  - module_id: "test.module"\n');
-      await expect(loader.loadBindings(yamlPath, registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('successfully loads valid binding with inline schemas', async () => {
-      const modPath = writeTempModule(
-        'inline_schema_mod.mjs',
-        'export function process(inputs) { return { result: inputs.name }; }\n',
-      );
-      const yamlPath = writeTempYaml(
-        'inline.binding.yaml',
-        `bindings:\n  - module_id: "test.inline"\n    target: "${modPath}:process"\n    description: "Inline schema test"\n    version: "2.0.0"\n    tags:\n      - demo\n    input_schema:\n      type: object\n      properties:\n        name:\n          type: string\n    output_schema:\n      type: object\n      properties:\n        result:\n          type: string\n`,
-      );
-      const results = await loader.loadBindings(yamlPath, registry);
-      expect(results).toHaveLength(1);
-      expect(results[0].moduleId).toBe('test.inline');
-      expect(results[0].description).toBe('Inline schema test');
-      expect(results[0].version).toBe('2.0.0');
-    });
-
-    it('successfully loads binding with permissive fallback (no schema)', async () => {
-      const modPath = writeTempModule('permissive_mod.mjs', 'export function loose(inputs) { return { ok: true }; }\n');
-      const yamlPath = writeTempYaml(
-        'permissive.binding.yaml',
-        `bindings:\n  - module_id: "test.permissive"\n    target: "${modPath}:loose"\n`,
-      );
-      const results = await loader.loadBindings(yamlPath, registry);
-      expect(results).toHaveLength(1);
-      expect(results[0].moduleId).toBe('test.permissive');
-      expect(results[0].inputSchema).toBeDefined();
-      expect(results[0].outputSchema).toBeDefined();
-    });
-
-    it('registers modules in the registry', async () => {
-      const modPath = writeTempModule('registered_mod.mjs', 'export function handler() { return {}; }\n');
-      const yamlPath = writeTempYaml(
-        'register.binding.yaml',
-        `bindings:\n  - module_id: "test.registered"\n    target: "${modPath}:handler"\n`,
-      );
-      await loader.loadBindings(yamlPath, registry);
-      expect(registry.has('test.registered')).toBe(true);
-    });
-
-    it('loads multiple binding entries from single file', async () => {
-      const modPath = writeTempModule(
-        'multi_mod.mjs',
-        `export function funcA() { return { a: true }; }\nexport function funcB() { return { b: true }; }\n`,
-      );
-      const yamlPath = writeTempYaml(
-        'multi.binding.yaml',
-        `bindings:\n  - module_id: "test.multi.a"\n    target: "${modPath}:funcA"\n  - module_id: "test.multi.b"\n    target: "${modPath}:funcB"\n`,
-      );
-      const results = await loader.loadBindings(yamlPath, registry);
-      expect(results).toHaveLength(2);
-      expect(registry.has('test.multi.a')).toBe(true);
-      expect(registry.has('test.multi.b')).toBe(true);
-    });
-  });
-
-  describe('loadBindingDir', () => {
-    it('throws BindingFileInvalidError for non-existent directory', async () => {
-      await expect(loader.loadBindingDir('/nonexistent/dir/path', registry)).rejects.toThrow(BindingFileInvalidError);
-    });
-
-    it('loads all *.binding.yaml files in directory', async () => {
-      const bindDir = join(tmpDir, 'bindings');
-      mkdirSync(bindDir);
-
-      const modPath = writeTempModule(
-        'dir_mod.mjs',
-        `export function alpha() { return { alpha: true }; }\nexport function beta() { return { beta: true }; }\n`,
-      );
-
-      writeTempYaml(
-        join('bindings', 'alpha.binding.yaml'),
-        `bindings:\n  - module_id: "dir.alpha"\n    target: "${modPath}:alpha"\n`,
-      );
-      writeTempYaml(
-        join('bindings', 'beta.binding.yaml'),
-        `bindings:\n  - module_id: "dir.beta"\n    target: "${modPath}:beta"\n`,
-      );
-
-      const results = await loader.loadBindingDir(bindDir, registry);
-      expect(results).toHaveLength(2);
-      expect(registry.has('dir.alpha')).toBe(true);
-      expect(registry.has('dir.beta')).toBe(true);
-    });
-
-    it('returns empty array for directory with no binding files', async () => {
-      const emptyDir = join(tmpDir, 'empty');
-      mkdirSync(emptyDir);
-
-      const results = await loader.loadBindingDir(emptyDir, registry);
-      expect(results).toHaveLength(0);
-    });
-  });
-});