feat: wire channels through pipeline, remove dead code, add metadata version

__test__/domain/channel-manifest.test.ts

@@ -19,9 +19,11 @@ describe('ChannelManifest', () => {
       expect(policy.channels[0].toString()).toBe('public/default');
     });
 
-    it('isPublic returns true for any path', () => {
+    it('resolve returns shouldRelease=true for any doc', () => {
       const manifest = ChannelManifest.allPublic();
-      expect(manifest.isPublic('anything')).toBe(true);
+      expect(manifest.resolve(mockDoc('anything', 'cc-1')).shouldRelease).toBe(
+        true
+      );
     });
   });
 
@@ -194,26 +196,35 @@ describe('ChannelManifest', () => {
     });
   });
 
-  describe('isPublic', () => {
-    it('returns true for public entries', () => {
+  describe('resolve — visibility', () => {
+    it('returns shouldRelease=true for public entries', () => {
       const manifest = ChannelManifest.parse({
         documents: [{ source: 'sources/cc-51015.adoc' }]
       });
-      expect(manifest.isPublic('sources/cc-51015.adoc')).toBe(true);
+      expect(
+        manifest.resolve(mockDoc('sources/cc-51015.adoc', 'cc-51015'))
+          .shouldRelease
+      ).toBe(true);
     });
 
-    it('returns false for private entries', () => {
+    it('returns shouldRelease=false for private entries', () => {
       const manifest = ChannelManifest.parse({
         documents: [{ source: 'sources/cc-51015.adoc', visibility: 'private' }]
       });
-      expect(manifest.isPublic('sources/cc-51015.adoc')).toBe(false);
+      expect(
+        manifest.resolve(mockDoc('sources/cc-51015.adoc', 'cc-51015'))
+          .shouldRelease
+      ).toBe(false);
     });
 
-    it('returns true for members entries', () => {
+    it('returns shouldRelease=true for members entries', () => {
       const manifest = ChannelManifest.parse({
         documents: [{ source: 'sources/cc-51015.adoc', visibility: 'members' }]
       });
-      expect(manifest.isPublic('sources/cc-51015.adoc')).toBe(true);
+      expect(
+        manifest.resolve(mockDoc('sources/cc-51015.adoc', 'cc-51015'))
+          .shouldRelease
+      ).toBe(true);
     });
   });
 

__test__/domain/release-metadata.test.ts

@@ -37,6 +37,7 @@ describe('ReleaseMetadata', () => {
     const meta = ReleaseMetadata.fromDocument(doc, channels);
     const json = meta.toJSON();
 
+    expect(json.version).toBe(1);
     expect(json.id).toBe('cc-51015');
     expect(json.title).toBe('Test Document');
     expect(json.edition).toBe('1');
@@ -74,6 +75,7 @@ describe('parseReleaseMetadata', () => {
 
 <!-- mn-release-metadata
 {
+  "version": 1,
   "id": "cc-51015",
   "title": "Test",
   "edition": "1",

__test__/filters/visibility-filter.test.ts → __test__/filters/channel-manifest-filter.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { VisibilityFilter } from '../../src/filters/visibility-filter.js';
-import { ReleaseManifest } from '../../src/domain/release-manifest.js';
+import { ChannelManifestFilter } from '../../src/filters/channel-manifest-filter.js';
+import { ChannelManifest } from '../../src/domain/channel-manifest.js';
 import {
   DocumentId,
   DocumentStage,
@@ -26,24 +26,24 @@ function makeDoc(sourcePath: string, rawId: string): DocumentMetadata {
   };
 }
 
-describe('VisibilityFilter', () => {
+describe('ChannelManifestFilter', () => {
   it('keeps all documents when manifest is allPublic', () => {
-    const manifest = ReleaseManifest.allPublic();
-    const filter = new VisibilityFilter(manifest);
+    const manifest = ChannelManifest.allPublic();
+    const filter = new ChannelManifestFilter(manifest);
     const docs = [makeDoc('a.adoc', 'CC 1'), makeDoc('b.adoc', 'CC 2')];
 
     const result = filter.filter(docs);
     expect(result).toHaveLength(2);
   });
 
   it('removes private documents', () => {
-    const manifest = ReleaseManifest.parse({
+    const manifest = ChannelManifest.parse({
       documents: [
         { source: 'sources/cc-51015.adoc' },
         { source: 'sources/cc-51026.adoc', visibility: 'private' }
       ]
     });
-    const filter = new VisibilityFilter(manifest);
+    const filter = new ChannelManifestFilter(manifest);
     const docs = [
       makeDoc('sources/cc-51015.adoc', 'CC 51015'),
       makeDoc('sources/cc-51026.adoc', 'CC 51026')
@@ -54,11 +54,11 @@ describe('VisibilityFilter', () => {
     expect(result[0].id.toString()).toBe('cc-51015');
   });
 
-  it('removes documents not in manifest', () => {
-    const manifest = ReleaseManifest.parse({
+  it('removes documents not in manifest (private-by-default)', () => {
+    const manifest = ChannelManifest.parse({
       documents: [{ source: 'sources/cc-51015.adoc' }]
     });
-    const filter = new VisibilityFilter(manifest);
+    const filter = new ChannelManifestFilter(manifest);
     const docs = [
       makeDoc('sources/cc-51015.adoc', 'CC 51015'),
       makeDoc('sources/cc-99999.adoc', 'CC 99999')
@@ -70,13 +70,30 @@ describe('VisibilityFilter', () => {
   });
 
   it('returns empty when all documents are private', () => {
-    const manifest = ReleaseManifest.parse({
+    const manifest = ChannelManifest.parse({
       documents: [{ source: 'a.adoc', visibility: 'private' }]
     });
-    const filter = new VisibilityFilter(manifest);
+    const filter = new ChannelManifestFilter(manifest);
     const docs = [makeDoc('a.adoc', 'CC 1')];
 
     const result = filter.filter(docs);
     expect(result).toHaveLength(0);
   });
+
+  it('keeps members-visible documents', () => {
+    const manifest = ChannelManifest.parse({
+      documents: [
+        { source: 'sources/cc-51015.adoc' },
+        { source: 'sources/cc-51026.adoc', visibility: 'members' }
+      ]
+    });
+    const filter = new ChannelManifestFilter(manifest);
+    const docs = [
+      makeDoc('sources/cc-51015.adoc', 'CC 51015'),
+      makeDoc('sources/cc-51026.adoc', 'CC 51026')
+    ];
+
+    const result = filter.filter(docs);
+    expect(result).toHaveLength(2);
+  });
 });

__test__/filters/manifest-loader.test.ts

@@ -3,6 +3,10 @@ import { loadManifest } from '../../src/filters/manifest-loader.js';
 import { mkdir, writeFile, rm } from 'fs/promises';
 import { join } from 'path';
 
+function mockDoc(sourcePath: string, id: string) {
+  return { sourcePath, id: { toString: () => id } };
+}
+
 describe('manifest-loader', () => {
   let tmpDir: string;
 
@@ -25,20 +29,30 @@ describe('manifest-loader', () => {
     );
 
     const manifest = await loadManifest(tmpDir, 'manifest.yml');
-    expect(manifest.isPublic('sources/cc-51015.adoc')).toBe(true);
-    expect(manifest.isPublic('sources/cc-51026.adoc')).toBe(false);
+    expect(
+      manifest.resolve(mockDoc('sources/cc-51015.adoc', 'cc-51015'))
+        .shouldRelease
+    ).toBe(true);
+    expect(
+      manifest.resolve(mockDoc('sources/cc-51026.adoc', 'cc-51026'))
+        .shouldRelease
+    ).toBe(false);
   });
 
   it('returns allPublic when file does not exist', async () => {
     const manifest = await loadManifest(tmpDir, 'nonexistent.yml');
-    expect(manifest.isPublic('any/path.adoc')).toBe(true);
+    expect(
+      manifest.resolve(mockDoc('any/path.adoc', 'cc-1')).shouldRelease
+    ).toBe(true);
   });
 
-  it('returns allPublic for empty manifest', async () => {
+  it('returns allPrivate for empty manifest', async () => {
     await writeFile(join(tmpDir, 'empty.yml'), '{}');
 
     const manifest = await loadManifest(tmpDir, 'empty.yml');
-    expect(manifest.isPublic('any/path.adoc')).toBe(false);
+    expect(
+      manifest.resolve(mockDoc('any/path.adoc', 'cc-1')).shouldRelease
+    ).toBe(false);
     expect(manifest.listAll()).toEqual([]);
   });
 
@@ -58,6 +72,8 @@ describe('manifest-loader', () => {
     await writeFile(join(tmpDir, 'nodoc.yml'), `other: value`);
 
     const manifest = await loadManifest(tmpDir, 'nodoc.yml');
-    expect(manifest.isPublic('any/path.adoc')).toBe(false);
+    expect(
+      manifest.resolve(mockDoc('any/path.adoc', 'cc-1')).shouldRelease
+    ).toBe(false);
   });
 });