@echovisionlab/geul-common 0.4.0 → 0.5.0

package/src/collaboration/runtime-events.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod/mini";
 
 export type RuntimeEntityType =
   | "post"
@@ -237,156 +237,161 @@ export const ogGenerationRuntimeStatusSchema = z.enum([
 ]);
 
 export const ogGenerationLifecycleRuntimePayloadSchema = z
-  .object({
-    generationId: z.string().min(1),
-    runId: z.string().min(1),
+  .strictObject({
+    generationId: z.string().check(z.minLength(1)),
+    runId: z.string().check(z.minLength(1)),
     status: ogGenerationRuntimeStatusSchema,
-    assetId: z.string().min(1).optional(),
-    assetUrl: z.string().min(1).optional(),
-    errorCode: z.string().min(1).optional(),
-    error: z.string().min(1).optional(),
-    replacementGenerationId: z.string().min(1).optional(),
+    assetId: z.optional(z.string().check(z.minLength(1))),
+    assetUrl: z.optional(z.string().check(z.minLength(1))),
+    errorCode: z.optional(z.string().check(z.minLength(1))),
+    error: z.optional(z.string().check(z.minLength(1))),
+    replacementGenerationId: z.optional(z.string().check(z.minLength(1))),
   })
-  .strict()
-  .superRefine((payload, ctx) => {
-    if (payload.status === "ready" && !payload.assetId) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["assetId"],
-        message: "ready OG lifecycle requires assetId",
-      });
-    }
-    if (payload.status === "failed" && !payload.error) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["error"],
-        message: "failed OG lifecycle requires error",
-      });
-    }
-    if (payload.status === "superseded" && !payload.replacementGenerationId) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["replacementGenerationId"],
-        message: "superseded OG lifecycle requires replacementGenerationId",
-      });
-    }
-    if (payload.status !== "ready" && (payload.assetId || payload.assetUrl)) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["assetId"],
-        message: "only ready OG lifecycle may include an asset",
-      });
-    }
-    if (payload.status !== "superseded" && payload.replacementGenerationId) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["replacementGenerationId"],
-        message: "only superseded OG lifecycle may include a replacement",
-      });
-    }
-  });
-
-export const mediaProcessingRuntimeOutputsSchema = z
-  .object({
-    spectrogramAssetId: z.string().optional(),
-    thumbnailAssetId: z.string().optional(),
-    hlsGenerationId: z.string().optional(),
-    durationSeconds: z.number().int().nonnegative().optional(),
-    waveformAssetId: z.string().optional(),
-  })
-  .strict();
+  .check(
+    z.superRefine((payload, ctx) => {
+      if (payload.status === "ready" && !payload.assetId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["assetId"],
+          message: "ready OG lifecycle requires assetId",
+        });
+      }
+      if (payload.status === "failed" && !payload.error) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["error"],
+          message: "failed OG lifecycle requires error",
+        });
+      }
+      if (payload.status === "superseded" && !payload.replacementGenerationId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["replacementGenerationId"],
+          message: "superseded OG lifecycle requires replacementGenerationId",
+        });
+      }
+      if (payload.status !== "ready" && (payload.assetId || payload.assetUrl)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["assetId"],
+          message: "only ready OG lifecycle may include an asset",
+        });
+      }
+      if (payload.status !== "superseded" && payload.replacementGenerationId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["replacementGenerationId"],
+          message: "only superseded OG lifecycle may include a replacement",
+        });
+      }
+    }),
+  );
+
+export const mediaProcessingRuntimeOutputsSchema = z.strictObject({
+  spectrogramAssetId: z.optional(z.string()),
+  thumbnailAssetId: z.optional(z.string()),
+  hlsGenerationId: z.optional(z.string()),
+  durationSeconds: z.optional(z.int().check(z.nonnegative())),
+  waveformAssetId: z.optional(z.string()),
+});
 
 export const mediaProcessingLifecycleRuntimePayloadSchema = z
-  .object({
-    fileId: z.string().min(1),
-    slotId: z.string().optional(),
-    attemptId: z.string().optional(),
+  .strictObject({
+    fileId: z.string().check(z.minLength(1)),
+    slotId: z.optional(z.string()),
+    attemptId: z.optional(z.string()),
     status: mediaProcessingRuntimeStatusSchema,
-    percentage: z.number().int().min(0).max(100).optional(),
-    outputs: mediaProcessingRuntimeOutputsSchema.optional(),
-    error: z.string().optional(),
-    trackId: z.string().optional(),
-    releaseId: z.string().optional(),
-  })
-  .strict()
-  .superRefine((payload, ctx) => {
-    if (
-      payload.status === "processing" &&
-      typeof payload.percentage !== "number"
-    ) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["percentage"],
-        message: "processing media lifecycle requires percentage",
-      });
-    }
-    if (payload.status === "processing" && payload.outputs) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["outputs"],
-        message: "processing media lifecycle must not include ready outputs",
-      });
-    }
-    if (payload.status === "ready" && !payload.outputs) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["outputs"],
-        message: "ready media lifecycle requires outputs",
-      });
-    }
-    if (payload.status === "ready" && typeof payload.percentage === "number") {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["percentage"],
-        message: "ready media lifecycle must not include processing percentage",
-      });
-    }
-    if (payload.status === "failed" && payload.outputs) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["outputs"],
-        message: "failed media lifecycle must not include ready outputs",
-      });
-    }
-    if (payload.status === "failed" && typeof payload.percentage === "number") {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["percentage"],
-        message:
-          "failed media lifecycle must not include processing percentage",
-      });
-    }
-  });
-
-export const fileIngestLifecycleRuntimePayloadSchema = z
-  .object({
-    fileId: z.string().min(1),
-    uploadId: z.string().optional(),
-    mediaKind: z.string().optional(),
-    slotId: z.string().optional(),
-    attemptId: z.string().optional(),
-    source: z.enum(["upload", "embed"]),
-    stage: z.enum([
-      "uploading",
-      "downloading",
-      "finalized",
-      "attached",
-      "completed",
-      "expired",
-      "failed",
-      "unknown",
-    ]),
-    progress: z.number().int().min(0).max(100),
-    bytesCompleted: z.number().int().nonnegative().optional(),
-    bytesTotal: z.number().int().nonnegative().optional(),
-    fileName: z.string().optional(),
-    mimeType: z.string().optional(),
-    fileSize: z.number().int().nonnegative().optional(),
-    error: z.string().optional(),
-    trackId: z.string().optional(),
-    releaseId: z.string().optional(),
+    percentage: z.optional(z.int().check(z.minimum(0), z.maximum(100))),
+    outputs: z.optional(mediaProcessingRuntimeOutputsSchema),
+    error: z.optional(z.string()),
+    trackId: z.optional(z.string()),
+    releaseId: z.optional(z.string()),
   })
-  .strict();
+  .check(
+    z.superRefine((payload, ctx) => {
+      if (
+        payload.status === "processing" &&
+        typeof payload.percentage !== "number"
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["percentage"],
+          message: "processing media lifecycle requires percentage",
+        });
+      }
+      if (payload.status === "processing" && payload.outputs) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["outputs"],
+          message: "processing media lifecycle must not include ready outputs",
+        });
+      }
+      if (payload.status === "ready" && !payload.outputs) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["outputs"],
+          message: "ready media lifecycle requires outputs",
+        });
+      }
+      if (
+        payload.status === "ready" &&
+        typeof payload.percentage === "number"
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["percentage"],
+          message:
+            "ready media lifecycle must not include processing percentage",
+        });
+      }
+      if (payload.status === "failed" && payload.outputs) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["outputs"],
+          message: "failed media lifecycle must not include ready outputs",
+        });
+      }
+      if (
+        payload.status === "failed" &&
+        typeof payload.percentage === "number"
+      ) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["percentage"],
+          message:
+            "failed media lifecycle must not include processing percentage",
+        });
+      }
+    }),
+  );
+
+export const fileIngestLifecycleRuntimePayloadSchema = z.strictObject({
+  fileId: z.string().check(z.minLength(1)),
+  uploadId: z.optional(z.string()),
+  mediaKind: z.optional(z.string()),
+  slotId: z.optional(z.string()),
+  attemptId: z.optional(z.string()),
+  source: z.enum(["upload", "embed"]),
+  stage: z.enum([
+    "uploading",
+    "downloading",
+    "finalized",
+    "attached",
+    "completed",
+    "expired",
+    "failed",
+    "unknown",
+  ]),
+  progress: z.int().check(z.minimum(0), z.maximum(100)),
+  bytesCompleted: z.optional(z.int().check(z.nonnegative())),
+  bytesTotal: z.optional(z.int().check(z.nonnegative())),
+  fileName: z.optional(z.string()),
+  mimeType: z.optional(z.string()),
+  fileSize: z.optional(z.int().check(z.nonnegative())),
+  error: z.optional(z.string()),
+  trackId: z.optional(z.string()),
+  releaseId: z.optional(z.string()),
+});
 
 const localeScopedOgEntityTypes = new Set<OgGenerationRuntimeEntityType>([
   "post",
@@ -397,138 +402,123 @@ const localeScopedOgEntityTypes = new Set<OgGenerationRuntimeEntityType>([
 ]);
 
 const ogGenerationLifecycleRuntimeEventSchema = z
-  .object({
+  .strictObject({
     version: z.literal(1),
     kind: z.literal("og.lifecycle"),
     entityType: ogGenerationRuntimeEntityTypeSchema,
-    entityId: z.string().min(1),
-    locale: z.string().min(1).optional(),
-    correlationId: z.string().min(1),
-    sequence: z.number().int().optional(),
-    timestampMs: z.number().int(),
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string().check(z.minLength(1))),
+    correlationId: z.string().check(z.minLength(1)),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
     payload: ogGenerationLifecycleRuntimePayloadSchema,
   })
-  .strict()
-  .superRefine((event, ctx) => {
-    const requiresLocale = localeScopedOgEntityTypes.has(event.entityType);
-    if (requiresLocale && !event.locale) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["locale"],
-        message: `${event.entityType} OG lifecycle requires a locale target`,
-      });
-    }
-    if (!requiresLocale && event.locale) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["locale"],
-        message: `${event.entityType} OG lifecycle requires an entity target`,
-      });
-    }
-    if (event.correlationId !== event.payload.generationId) {
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        path: ["correlationId"],
-        message: "OG lifecycle correlationId must equal payload.generationId",
-      });
-    }
-  });
-
-export const translationLifecycleRuntimePayloadSchema = z
-  .object({
-    jobId: z.string().min(1),
-    targetLocale: z.string().min(1),
-    status: z.literal("failed"),
-    error: z.string().optional(),
-  })
-  .strict();
+  .check(
+    z.superRefine((event, ctx) => {
+      const requiresLocale = localeScopedOgEntityTypes.has(event.entityType);
+      if (requiresLocale && !event.locale) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["locale"],
+          message: `${event.entityType} OG lifecycle requires a locale target`,
+        });
+      }
+      if (!requiresLocale && event.locale) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["locale"],
+          message: `${event.entityType} OG lifecycle requires an entity target`,
+        });
+      }
+      if (event.correlationId !== event.payload.generationId) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["correlationId"],
+          message: "OG lifecycle correlationId must equal payload.generationId",
+        });
+      }
+    }),
+  );
+
+export const translationLifecycleRuntimePayloadSchema = z.strictObject({
+  jobId: z.string().check(z.minLength(1)),
+  targetLocale: z.string().check(z.minLength(1)),
+  status: z.literal("failed"),
+  error: z.optional(z.string()),
+});
 
 export const editorRuntimeEventSchema = z.discriminatedUnion("kind", [
   ogGenerationLifecycleRuntimeEventSchema,
-  z
-    .object({
-      version: z.literal(1),
-      kind: z.literal("render.complete"),
-      entityType: runtimeEntityTypeSchema,
-      entityId: z.string().min(1),
-      locale: z.string().optional(),
-      correlationId: z.string().optional(),
-      sequence: z.number().int().optional(),
-      timestampMs: z.number().int(),
-      payload: z
-        .object({
-          contentHash: z.string(),
-          success: z.boolean(),
-          error: z.string().optional(),
-        })
-        .strict(),
-    })
-    .strict(),
-  z
-    .object({
-      version: z.literal(1),
-      kind: z.literal("media.processing.lifecycle"),
-      entityType: runtimeEntityTypeSchema,
-      entityId: z.string().min(1),
-      locale: z.string().optional(),
-      correlationId: z.string().optional(),
-      sequence: z.number().int().optional(),
-      timestampMs: z.number().int(),
-      payload: mediaProcessingLifecycleRuntimePayloadSchema,
-    })
-    .strict(),
-  z
-    .object({
-      version: z.literal(1),
-      kind: z.literal("file.ingest.lifecycle"),
-      entityType: runtimeEntityTypeSchema,
-      entityId: z.string().min(1),
-      locale: z.string().optional(),
-      correlationId: z.string().optional(),
-      sequence: z.number().int().optional(),
-      timestampMs: z.number().int(),
-      payload: fileIngestLifecycleRuntimePayloadSchema,
-    })
-    .strict(),
-  z
-    .object({
-      version: z.literal(1),
-      kind: z.literal("translation.lifecycle"),
-      entityType: runtimeEntityTypeSchema,
-      entityId: z.string().min(1),
-      locale: z.string().optional(),
-      correlationId: z.string().optional(),
-      sequence: z.number().int().optional(),
-      timestampMs: z.number().int(),
-      payload: translationLifecycleRuntimePayloadSchema,
-    })
-    .strict(),
-  z
-    .object({
-      version: z.literal(1),
-      kind: z.literal("runtime.error"),
-      entityType: runtimeEntityTypeSchema,
-      entityId: z.string().min(1),
-      locale: z.string().optional(),
-      correlationId: z.string().optional(),
-      sequence: z.number().int().optional(),
-      timestampMs: z.number().int(),
-      payload: z
-        .object({
-          code: z.string().min(1),
-          message: z.string(),
-          retryable: z.boolean().optional(),
-          source: z.enum(["backend", "collab", "worker"]).optional(),
-          details: z
-            .record(
-              z.string(),
-              z.union([z.string(), z.number(), z.boolean(), z.null()]),
-            )
-            .optional(),
-        })
-        .strict(),
-    })
-    .strict(),
+  z.strictObject({
+    version: z.literal(1),
+    kind: z.literal("render.complete"),
+    entityType: runtimeEntityTypeSchema,
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string()),
+    correlationId: z.optional(z.string()),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
+    payload: z.strictObject({
+      contentHash: z.string(),
+      success: z.boolean(),
+      error: z.optional(z.string()),
+    }),
+  }),
+  z.strictObject({
+    version: z.literal(1),
+    kind: z.literal("media.processing.lifecycle"),
+    entityType: runtimeEntityTypeSchema,
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string()),
+    correlationId: z.optional(z.string()),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
+    payload: mediaProcessingLifecycleRuntimePayloadSchema,
+  }),
+  z.strictObject({
+    version: z.literal(1),
+    kind: z.literal("file.ingest.lifecycle"),
+    entityType: runtimeEntityTypeSchema,
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string()),
+    correlationId: z.optional(z.string()),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
+    payload: fileIngestLifecycleRuntimePayloadSchema,
+  }),
+  z.strictObject({
+    version: z.literal(1),
+    kind: z.literal("translation.lifecycle"),
+    entityType: runtimeEntityTypeSchema,
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string()),
+    correlationId: z.optional(z.string()),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
+    payload: translationLifecycleRuntimePayloadSchema,
+  }),
+  z.strictObject({
+    version: z.literal(1),
+    kind: z.literal("runtime.error"),
+    entityType: runtimeEntityTypeSchema,
+    entityId: z.string().check(z.minLength(1)),
+    locale: z.optional(z.string()),
+    correlationId: z.optional(z.string()),
+    sequence: z.optional(z.int()),
+    timestampMs: z.int(),
+    payload: z.strictObject({
+      code: z.string().check(z.minLength(1)),
+      message: z.string(),
+      retryable: z.optional(z.boolean()),
+      source: z.optional(z.enum(["backend", "collab", "worker"])),
+      details: z.optional(
+        z.record(
+          z.string(),
+          z.union([z.string(), z.number(), z.boolean(), z.null()]),
+        ),
+      ),
+    }),
+  }),
 ]);
 
 export function parseEditorRuntimeEventMessage(

package/src/collaboration/work.ts

@@ -1,35 +1,37 @@
-import { z } from "zod";
+import * as z from "zod/mini";
 
-export const workCollabFieldsSchema = z
-  .object({
-    title: z.string().optional(),
-    slug: z.string().nullable().optional(),
-    type: z.string().optional(),
-    summary: z.string().optional(),
-    featured: z.boolean().optional(),
-    year: z.number().int().min(1).max(9999).optional(),
-    month: z.number().int().min(1).max(12).optional(),
-    untilYear: z.number().int().min(1).max(9999).nullable().optional(),
-    untilMonth: z.number().int().min(1).max(12).nullable().optional(),
-    isPresent: z.boolean().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    featuredImageFileId: z.string().nullable().optional(),
-    creditsVersion: z.number().optional(),
-    creditOrder: z
-      .array(
-        z.discriminatedUnion("type", [
-          z.object({ type: z.literal("group"), id: z.string() }),
-          z.object({
-            type: z.literal("credit"),
-            id: z.string(),
-            creditType: z.enum(["artist", "member", "name"]),
-          }),
-        ]),
-      )
-      .optional(),
-    clients: z.array(z.string()).optional(), // Ordered list of client IDs
-  })
-  .strict();
+export const workCollabFieldsSchema = z.strictObject({
+  title: z.optional(z.string()),
+  slug: z.optional(z.nullable(z.string())),
+  type: z.optional(z.string()),
+  summary: z.optional(z.string()),
+  featured: z.optional(z.boolean()),
+  year: z.optional(z.int().check(z.minimum(1), z.maximum(9999))),
+  month: z.optional(z.int().check(z.minimum(1), z.maximum(12))),
+  untilYear: z.optional(
+    z.nullable(z.int().check(z.minimum(1), z.maximum(9999))),
+  ),
+  untilMonth: z.optional(
+    z.nullable(z.int().check(z.minimum(1), z.maximum(12))),
+  ),
+  isPresent: z.optional(z.boolean()),
+  metadata: z.optional(z.record(z.string(), z.unknown())),
+  featuredImageFileId: z.optional(z.nullable(z.string())),
+  creditsVersion: z.optional(z.number()),
+  creditOrder: z.optional(
+    z.array(
+      z.discriminatedUnion("type", [
+        z.object({ type: z.literal("group"), id: z.string() }),
+        z.object({
+          type: z.literal("credit"),
+          id: z.string(),
+          creditType: z.enum(["artist", "member", "name"]),
+        }),
+      ]),
+    ),
+  ),
+  clients: z.optional(z.array(z.string())), // Ordered list of client IDs
+});
 
 export const WORK_JSON_KEYS: ReadonlySet<
   keyof z.infer<typeof workCollabFieldsSchema>

package/src/page/types.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod/mini";
 import type { PageBlockType } from "./block-fixtures.ts";
 
 export interface InlineContent {
@@ -50,8 +50,6 @@ const pageContentSectionSchema = z.custom<Section>(
     value !== null && typeof value === "object" && !Array.isArray(value),
 );
 
-export const pageContentSchema: z.ZodType<PageContent> = z
-  .object({
-    sections: z.array(pageContentSectionSchema),
-  })
-  .strict();
+export const pageContentSchema: z.ZodMiniType<PageContent> = z.strictObject({
+  sections: z.array(pageContentSectionSchema),
+});

package/src/post/types.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import * as z from "zod/mini";
 import type { Block } from "../page/types.ts";
 
 export type PostContent = Block[];
@@ -8,6 +8,6 @@ const postContentBlockSchema = z.custom<Block>(
     value !== null && typeof value === "object" && !Array.isArray(value),
 );
 
-export const postContentSchema: z.ZodType<PostContent> = z.array(
+export const postContentSchema: z.ZodMiniType<PostContent> = z.array(
   postContentBlockSchema,
 );