@ankhorage/zora 25.5.0 → 25.6.2

package/src/capabilities/index.test.ts

@@ -1,9 +1,11 @@
 import { readFileSync } from 'node:fs';
 
-import { isCapability } from '@ankhorage/contracts/capabilities';
+import { isCapability, isCapabilityId } from '@ankhorage/capability';
+import type { Capability } from '@ankhorage/contracts/capability';
 import { isRecord } from '@ankhorage/utility/object';
 import { expect, test } from 'bun:test';
 
+import { ZORA_COMPONENT_META } from '../features/registry';
 import { CAPABILITIES } from './index';
 
 const packageJson: unknown = JSON.parse(
@@ -13,11 +15,66 @@ const packageCapabilities =
   isRecord(packageJson) && isRecord(packageJson.ankh) ? packageJson.ankh.capabilities : undefined;
 
 test('publishes valid, uniquely identified canonical ZORA capabilities', () => {
-  expect(CAPABILITIES).toHaveLength(2);
   expect(CAPABILITIES.every(isCapability)).toBe(true);
   expect(new Set(CAPABILITIES.map((capability) => capability.id)).size).toBe(CAPABILITIES.length);
 });
 
+test('projects each direct-manifest event metadata entry into one canonical event capability', () => {
+  const metadataEvents = Object.values(ZORA_COMPONENT_META)
+    .filter((component) => component.directManifestNode)
+    .flatMap((component) => Object.values(component.events ?? {}));
+  const eventCapabilities = CAPABILITIES.filter((capability) => capability.access.includes('emit'));
+
+  expect(eventCapabilities).toHaveLength(
+    new Set(metadataEvents.map((event) => event.eventType)).size,
+  );
+  const eventCapabilitiesById = new Map<Capability['id'], Capability>(
+    eventCapabilities.map((capability) => [capability.id, capability]),
+  );
+
+  for (const event of metadataEvents) {
+    if (!isCapabilityId(event.eventType)) throw new Error(`Invalid event id: ${event.eventType}`);
+    const capability = eventCapabilitiesById.get(event.eventType);
+    expect(capability?.owner).toBe('@ankhorage/zora');
+    expect(capability?.access).toEqual(['emit']);
+    expect(capability?.binding).toEqual({ kind: 'event', bindableAs: ['source'] });
+    expect(capability?.label).toBe(event.label);
+    expect(capability?.description).toBe(event.description);
+  }
+});
+
+test('projects event payload metadata into matching output schemas', () => {
+  const eventCapabilities = new Map<Capability['id'], Capability>(
+    CAPABILITIES.filter((capability) => capability.access.includes('emit')).map((capability) => [
+      capability.id,
+      capability,
+    ]),
+  );
+
+  for (const component of Object.values(ZORA_COMPONENT_META)) {
+    if (!component.directManifestNode) continue;
+    for (const event of Object.values(component.events ?? {})) {
+      if (!isCapabilityId(event.eventType)) throw new Error(`Invalid event id: ${event.eventType}`);
+      const capability = eventCapabilities.get(event.eventType);
+      const schema = capability?.output?.schema;
+      expect(schema?.type).toBe('object');
+
+      for (const field of event.payloadFields ?? []) {
+        if (field.path.includes('.')) continue;
+        const fieldSchema = Object.entries(schema?.properties ?? {}).find(
+          ([fieldName]) => fieldName === field.path,
+        )?.[1];
+        expect(fieldSchema?.type).toBe(
+          field.type === 'record' ? 'object' : field.type === 'unknown' ? undefined : field.type,
+        );
+        expect(fieldSchema?.additionalProperties).toBe(field.type === 'record' ? true : undefined);
+        expect(fieldSchema?.title).toBe(field.label);
+        expect(fieldSchema?.description).toBe(field.description);
+      }
+    }
+  }
+});
+
 test('keeps Ankh package metadata identical to the canonical catalog', () => {
   expect(Array.isArray(packageCapabilities)).toBe(true);
   if (!Array.isArray(packageCapabilities)) {
@@ -37,18 +94,33 @@ test('exports the catalog from the public capabilities subpath', async () => {
 });
 
 test('preserves the executable action semantics of ZORA provider capabilities', () => {
-  expect(CAPABILITIES).toEqual([
-    expect.objectContaining({
-      id: 'zora.create',
-      owner: '@ankhorage/zora',
-      access: ['invoke'],
-      binding: { kind: 'action', bindableAs: ['target'] },
-    }),
-    expect.objectContaining({
-      id: 'zora.sync',
-      owner: '@ankhorage/zora',
-      access: ['invoke'],
-      binding: { kind: 'action', bindableAs: ['target'] },
-    }),
+  const actions = CAPABILITIES.filter((capability) => capability.access.includes('invoke'));
+  expect(actions.map((capability) => capability.id)).toEqual(['zora.create', 'zora.sync']);
+  expect(actions.every((capability) => capability.binding.kind === 'action')).toBe(true);
+  expect(actions.every((capability) => capability.binding.bindableAs.includes('target'))).toBe(
+    true,
+  );
+});
+
+test('built public capability entrypoint imports under Node ESM', async () => {
+  const subprocess = Bun.spawn(
+    [
+      'node',
+      '--input-type=module',
+      '-e',
+      "import('./dist/capabilities/index.js').then(({ CAPABILITIES }) => { if (!Array.isArray(CAPABILITIES)) process.exit(1); });",
+    ],
+    {
+      cwd: process.cwd(),
+      stderr: 'pipe',
+      stdout: 'pipe',
+    },
+  );
+  const [exitCode, stderr] = await Promise.all([
+    subprocess.exited,
+    new Response(subprocess.stderr).text(),
   ]);
+
+  expect(stderr).toBe('');
+  expect(exitCode).toBe(0);
 });

package/src/capabilities/index.ts

@@ -1,4 +1,6 @@
-import type { Capability } from '@ankhorage/contracts/capabilities';
+import type { Capability } from '@ankhorage/contracts/capability';
+
+import { createEventCapabilities } from '../features/registry/createEventCapabilities.js';
 
 export const CAPABILITIES = [
   {
@@ -60,4 +62,5 @@ export const CAPABILITIES = [
       },
     },
   },
-] as const satisfies readonly Capability[];
+  ...createEventCapabilities(),
+] satisfies readonly Capability[];

package/src/cli/index.test.ts

@@ -6,7 +6,9 @@ import provider from './index';
 test('publishes ZORA create and sync through the Ankh provider', () => {
   expect(provider.id).toBe('@ankhorage/zora');
   expect(provider.category).toBe('zora');
-  expect(provider.capabilities).toBe(CAPABILITIES);
+  expect(provider.capabilities).toEqual(
+    CAPABILITIES.filter((capability) => capability.access.includes('invoke')),
+  );
   expect(provider.commands).toEqual([
     {
       path: ['create'],
@@ -24,9 +26,9 @@ test('publishes ZORA create and sync through the Ankh provider', () => {
   expect(provider.handlers[1]?.path).toEqual(['sync']);
 });
 
-test('maps every provider command to one canonical capability independent of catalog order', () => {
+test('maps every provider command to one executable canonical capability independent of catalog order', () => {
   const commandCapabilityIds = provider.commands.map((command) => command.capability);
-  const capabilityIds = CAPABILITIES.map((capability) => capability.id);
+  const capabilityIds = provider.capabilities.map((capability) => capability.id);
 
   expect(new Set(commandCapabilityIds).size).toBe(commandCapabilityIds.length);
   expect(new Set(commandCapabilityIds)).toEqual(new Set(capabilityIds));

package/src/cli/index.ts

@@ -3,7 +3,7 @@ import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 import type { AnkhRuntimeCommandProvider } from '@ankhorage/ankh';
-import type { Capability } from '@ankhorage/contracts/capabilities';
+import type { Capability } from '@ankhorage/contracts/capability';
 
 import { CAPABILITIES } from '../capabilities';
 import { create } from './commands/create';
@@ -19,12 +19,15 @@ const SYNC_COMMAND = {
   capability: 'zora.sync' satisfies Capability['id'],
   summary: 'Regenerate the declared ZORA web materialization.',
 } as const;
+const COMMAND_CAPABILITIES = CAPABILITIES.filter((capability) =>
+  capability.access.includes('invoke'),
+);
 
 const provider = {
   id: '@ankhorage/zora',
   category: 'zora',
   version: readPackageVersion(),
-  capabilities: CAPABILITIES,
+  capabilities: COMMAND_CAPABILITIES,
   commands: [CREATE_COMMAND, SYNC_COMMAND],
   handlers: [
     {