validate: validateEventInFeed — feed-context check for event files

issue-to-pr validated proposals with the standalone-event schema, which
demands specVersion and license. events/<slug>.json is a feed fragment:
both fields are inherited from the feed, the editor deliberately omits
them, and build-feed --check applies feed rules. Editor-generated
proposals were therefore always rejected.

validateEventInFeed wraps the event in a minimal valid feed envelope and
rewrites error paths to be event-relative; the workflow script now uses
it instead of validateEvent.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: hhkaos

.github/scripts/issue-to-pr.mjs

@@ -22,7 +22,7 @@
 import { appendFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 
-import { validateEvent } from "../../packages/validate/dist/index.js";
+import { validateEventInFeed } from "../../packages/validate/dist/index.js";
 
 const marker = process.env.OTE_COMMENT_MARKER ?? "<!-- ote-issue-to-pr -->";
 const tmp = process.env.RUNNER_TEMP ?? ".";
@@ -104,7 +104,10 @@ try {
   ]);
 }
 
-const result = validateEvent(event);
+// Feed context, not standalone: events/<slug>.json is a feed fragment that
+// inherits specVersion and license from the feed (same rules build-feed
+// --check applies — the editor deliberately omits both fields).
+const result = validateEventInFeed(event);
 if (!result.valid) {
   reject("The event JSON is not valid against the OTE event schema", [
     ...result.errors.map((e) => `- \`${e.path}\` — ${e.message}`),

packages/validate/src/index.ts

@@ -5,6 +5,7 @@ import ajvFormats from "ajv-formats";
 const addFormats = ajvFormats as unknown as typeof ajvFormats.default;
 
 import { formatAjvErrors, type ValidationError } from "./errors.js";
+import { specVersion } from "./schemas.generated.js";
 import { eventSchema, feedSchema } from "./schemas.js";
 
 export type { ValidationError } from "./errors.js";
@@ -51,3 +52,37 @@ export function validateEvent(json: unknown): ValidationResult {
 export function validateFeed(json: unknown): ValidationResult {
   return run(validateFeedFn!, json);
 }
+
+// Minimal valid feed envelope for validateEventInFeed. Constant values are
+// never reported: any error a wrapped validation yields comes from the event.
+const FEED_ENVELOPE = {
+  specVersion,
+  title: "validateEventInFeed envelope",
+  license: "CC0-1.0",
+  updatedAt: "2026-01-01T00:00:00Z",
+};
+
+const EVENT_PATH_PREFIX = "events[0]";
+
+/**
+ * Validates a single event in FEED context: specVersion and license are
+ * inherited from the feed, so they are not required (unlike a standalone
+ * event document). This is the check for an events/<slug>.json file, which
+ * is a feed fragment — `build-feed --check` applies the same rules by
+ * validating the assembled feed. Error paths are relative to the event.
+ */
+export function validateEventInFeed(json: unknown): ValidationResult {
+  const result = run(validateFeedFn!, { ...FEED_ENVELOPE, events: [json] });
+  return {
+    valid: result.valid,
+    errors: result.errors.map(({ path, message }) => ({
+      message,
+      path:
+        path === EVENT_PATH_PREFIX
+          ? "(document)"
+          : path.startsWith(`${EVENT_PATH_PREFIX}.`)
+            ? path.slice(EVENT_PATH_PREFIX.length + 1)
+            : path,
+    })),
+  };
+}

packages/validate/test/validate.test.ts

@@ -4,7 +4,11 @@ import { fileURLToPath } from "node:url";
 
 import { describe, expect, it } from "vitest";
 
-import { validateEvent, validateFeed } from "../src/index.js";
+import {
+  validateEvent,
+  validateEventInFeed,
+  validateFeed,
+} from "../src/index.js";
 
 const fixturesDir = fileURLToPath(new URL("../fixtures/", import.meta.url));
 
@@ -120,10 +124,52 @@ describe("validateEvent — invalid fixtures", () => {
   });
 });
 
+describe("validateEventInFeed — feed-context rules for a single event", () => {
+  it("an event file without specVersion/license is valid (both inherited)", () => {
+    const feed = loadFixture("valid", "feed.json") as {
+      events: Record<string, unknown>[];
+    };
+    const event = feed.events[0]!;
+    expect(event.specVersion).toBeUndefined();
+    expect(event.license).toBeUndefined();
+    expect(validateEvent(event).valid).toBe(false); // standalone demands both…
+    const result = validateEventInFeed(event); // …feed context does not
+    expect(result.errors).toEqual([]);
+    expect(result.valid).toBe(true);
+  });
+
+  it("a standalone-shaped event (with specVersion/license) is also valid", () => {
+    const result = validateEventInFeed(loadFixture("valid", "event-minimal.json"));
+    expect(result.errors).toEqual([]);
+    expect(result.valid).toBe(true);
+  });
+
+  it("error paths are relative to the event, not the envelope", () => {
+    const result = validateEventInFeed({ name: "No id, date or timezone" });
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContainEqual({
+      path: "(document)",
+      message: 'is missing required property "id"',
+    });
+    const { errors } = validateEventInFeed({
+      id: "https://example.org/events/x",
+      name: "Bad geo",
+      startDate: "2026-06-01",
+      timezone: "UTC",
+      location: { venue: "Somewhere", geo: { lat: 91, lon: 0 } },
+    });
+    expect(errors).toContainEqual({
+      path: "location.geo.lat",
+      message: "must be <= 90",
+    });
+  });
+});
+
 describe("non-object inputs", () => {
   it.each([null, "text", 42, []])("%o is invalid", (input) => {
     expect(validateEvent(input).valid).toBe(false);
     expect(validateFeed(input).valid).toBe(false);
+    expect(validateEventInFeed(input).valid).toBe(false);
   });
 });