blodemd 0.0.4 → 0.0.6

package/docs/lib/openapi.ts

@@ -0,0 +1,158 @@
+import { ensureArray, normalizePath } from "@repo/common";
+import type { CollectionConfig, DocsOpenApiSource } from "@repo/models";
+import {
+  extractOpenApiOperations,
+  openApiIdentifier,
+  openApiSlug,
+  parseOpenApiSpec,
+} from "@repo/prebuild";
+import type { OpenApiOperation, OpenApiSpec } from "@repo/prebuild";
+import { loadPrebuiltOpenApiIndex } from "@repo/previewing";
+import type { ContentSource, PrebuiltOpenApiEntry } from "@repo/previewing";
+
+export interface OpenApiEntry {
+  slug: string;
+  identifier: string;
+  operation: OpenApiOperation;
+  spec: OpenApiSpec;
+  source: DocsOpenApiSource;
+  sourceKey: string;
+}
+
+export interface OpenApiRegistry {
+  entries: OpenApiEntry[];
+  bySlug: Map<string, OpenApiEntry>;
+  byIdentifier: Map<string, OpenApiEntry>;
+  bySource: Map<string, OpenApiEntry[]>;
+}
+
+const toRegistry = (entries: OpenApiEntry[]): OpenApiRegistry => {
+  const bySlug = new Map<string, OpenApiEntry>();
+  const byIdentifier = new Map<string, OpenApiEntry>();
+  const bySource = new Map<string, OpenApiEntry[]>();
+
+  for (const entry of entries) {
+    bySlug.set(entry.slug, entry);
+    byIdentifier.set(entry.identifier, entry);
+    if (!bySource.has(entry.sourceKey)) {
+      bySource.set(entry.sourceKey, []);
+    }
+    bySource.get(entry.sourceKey)?.push(entry);
+  }
+
+  return { byIdentifier, bySlug, bySource, entries };
+};
+
+export const fromPrebuiltOpenApiEntries = (
+  entries: PrebuiltOpenApiEntry[]
+): OpenApiRegistry => toRegistry(entries);
+
+const getOpenApiSourceKey = (source: DocsOpenApiSource): string =>
+  `${source.source}::${source.directory ?? ""}::${(source.include ?? []).join(
+    "|"
+  )}`;
+
+const toSourceObject = (
+  value: string | DocsOpenApiSource
+): DocsOpenApiSource => {
+  if (typeof value === "string") {
+    return { source: value };
+  }
+  return value;
+};
+
+const collectOpenApiSources = (collection?: CollectionConfig) => {
+  const sources: DocsOpenApiSource[] = [];
+
+  for (const item of ensureArray(collection?.openapi)) {
+    if (!item) {
+      continue;
+    }
+    sources.push(toSourceObject(item));
+  }
+
+  const groups = collection?.navigation?.groups ?? [];
+  for (const group of groups) {
+    if (!group.openapi) {
+      continue;
+    }
+    sources.push(toSourceObject(group.openapi));
+  }
+
+  const seen = new Set<string>();
+  return sources.filter((source) => {
+    const key = getOpenApiSourceKey(source);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+};
+
+export const buildOpenApiRegistry = async (
+  collection: CollectionConfig | undefined,
+  contentSource: ContentSource
+): Promise<OpenApiRegistry> => {
+  if (!collection || collection.type !== "docs") {
+    return toRegistry([]);
+  }
+
+  const entries: OpenApiEntry[] = [];
+  const slugPrefix = normalizePath(collection.slugPrefix ?? "");
+
+  const sources = collectOpenApiSources(collection);
+  const resolved = await Promise.all(
+    sources.map(async (source) => {
+      const rawSpec = await contentSource.readFile(source.source);
+      const spec = parseOpenApiSpec(rawSpec, source.source);
+      const directory = source.directory ?? "api";
+      const { operations } = extractOpenApiOperations(spec, directory);
+      return { directory, operations, source, spec };
+    })
+  );
+
+  for (const { directory, operations, source, spec } of resolved) {
+    const sourceKey = getOpenApiSourceKey(source);
+    const includeIdentifiers = source.include?.length
+      ? new Set(source.include)
+      : null;
+
+    for (const operation of operations) {
+      const identifier = openApiIdentifier(operation.method, operation.path);
+      if (includeIdentifiers && !includeIdentifiers.has(identifier)) {
+        continue;
+      }
+
+      const baseSlug = normalizePath(
+        openApiSlug(operation.method, operation.path, directory)
+      );
+      const slug = slugPrefix
+        ? normalizePath(`${slugPrefix}/${baseSlug}`)
+        : baseSlug;
+      const entry: OpenApiEntry = {
+        identifier,
+        operation,
+        slug: normalizePath(slug),
+        source,
+        sourceKey,
+        spec,
+      };
+      entries.push(entry);
+    }
+  }
+
+  return toRegistry(entries);
+};
+
+export const loadOpenApiRegistry = async (
+  collection: CollectionConfig | undefined,
+  contentSource: ContentSource
+): Promise<OpenApiRegistry> => {
+  const prebuilt = await loadPrebuiltOpenApiIndex(contentSource);
+  if (prebuilt) {
+    return fromPrebuiltOpenApiEntries(prebuilt);
+  }
+
+  return await buildOpenApiRegistry(collection, contentSource);
+};

package/docs/lib/routes.ts

@@ -0,0 +1,10 @@
+import { normalizePath, withLeadingSlash } from "@repo/common";
+
+export const toDocHref = (path: string, basePath = "") => {
+  const clean = normalizePath(path);
+  const base = basePath ? withLeadingSlash(basePath) : "";
+  if (!clean || clean === "index") {
+    return base || "/";
+  }
+  return `${base}/${clean}`.replaceAll(/\/+/g, "/");
+};

package/docs/lib/server-cache.ts

@@ -0,0 +1,83 @@
+interface CacheEntry<Value> {
+  expiresAt: number;
+  value: Promise<Value>;
+}
+
+interface TimedPromiseCacheOptions {
+  maxEntries: number;
+  ttlMs: number;
+}
+
+export interface TimedPromiseCache<Key, Value> {
+  clear(): void;
+  delete(key: Key): void;
+  deleteByPrefix(prefix: string): void;
+  getOrCreate(key: Key, factory: () => Promise<Value>): Promise<Value>;
+}
+
+export const createTimedPromiseCache = <Key, Value>({
+  maxEntries,
+  ttlMs,
+}: TimedPromiseCacheOptions): TimedPromiseCache<Key, Value> => {
+  const entries = new Map<Key, CacheEntry<Value>>();
+
+  const deleteOldest = () => {
+    const oldestKey = entries.keys().next().value as Key | undefined;
+    if (oldestKey !== undefined) {
+      entries.delete(oldestKey);
+    }
+  };
+
+  const pruneExpired = (now: number) => {
+    for (const [key, entry] of entries) {
+      if (entry.expiresAt <= now) {
+        entries.delete(key);
+      }
+    }
+  };
+
+  return {
+    clear() {
+      entries.clear();
+    },
+    delete(key) {
+      entries.delete(key);
+    },
+    deleteByPrefix(prefix: string) {
+      for (const key of entries.keys()) {
+        if (typeof key === "string" && key.startsWith(prefix)) {
+          entries.delete(key);
+        }
+      }
+    },
+    getOrCreate(key, factory) {
+      const now = Date.now();
+      pruneExpired(now);
+
+      const existing = entries.get(key);
+      if (existing) {
+        return existing.value;
+      }
+
+      const value = (async () => {
+        try {
+          return await factory();
+        } catch (error) {
+          entries.delete(key);
+          throw error;
+        }
+      })();
+
+      entries.set(key, {
+        expiresAt: now + ttlMs,
+        value,
+      });
+
+      if (entries.size > maxEntries) {
+        deleteOldest();
+      }
+
+      return value;
+    },
+  };
+};

package/docs/lib/shiki.ts

@@ -0,0 +1,35 @@
+import { createHighlighter } from "shiki";
+
+const COMMON_LANGS = [
+  "bash",
+  "css",
+  "diff",
+  "go",
+  "graphql",
+  "html",
+  "javascript",
+  "json",
+  "jsx",
+  "markdown",
+  "mdx",
+  "python",
+  "rust",
+  "sql",
+  "tsx",
+  "typescript",
+  "yaml",
+] as const;
+
+const THEMES = ["github-dark", "github-light"] as const;
+
+let highlighterPromise: ReturnType<typeof createHighlighter> | null = null;
+
+export const getHighlighter = () => {
+  if (!highlighterPromise) {
+    highlighterPromise = createHighlighter({
+      langs: [...COMMON_LANGS],
+      themes: [...THEMES],
+    });
+  }
+  return highlighterPromise;
+};

package/docs/lib/theme.ts

@@ -0,0 +1,29 @@
+import type { SiteConfig } from "@repo/models";
+import type { CSSProperties } from "react";
+
+export const themeStylesFromConfig = (config: SiteConfig): CSSProperties => {
+  const { colors } = config;
+  if (!colors) {
+    return {};
+  }
+
+  const styles: Record<string, string> = {};
+
+  if (colors.primary) {
+    styles["--color-primary"] = colors.primary;
+  }
+  if (colors.border) {
+    styles["--color-border"] = colors.border;
+  }
+  if (colors.muted) {
+    styles["--color-muted"] = colors.muted;
+  }
+  if (colors.surface) {
+    styles["--color-surface"] = colors.surface;
+  }
+  if (colors.background) {
+    styles["--color-background"] = colors.background;
+  }
+
+  return styles as CSSProperties;
+};

package/docs/lib/toc.ts

@@ -0,0 +1,2 @@
+export { extractToc } from "@repo/previewing";
+export type { TocItem } from "@repo/previewing";

package/docs/lib/utils.ts

@@ -0,0 +1,5 @@
+import { clsx } from "clsx";
+import type { ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+export const cn = (...inputs: ClassValue[]) => twMerge(clsx(inputs));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blodemd",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Blode.md CLI",
   "repository": {
     "type": "git",
@@ -10,7 +10,10 @@
     "blodemd": "./dist/cli.mjs"
   },
   "files": [
-    "dist"
+    "dist",
+    "dev-server",
+    "docs",
+    "packages"
   ],
   "type": "module",
   "main": "./dist/index.mjs",
@@ -24,6 +27,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "prepublishOnly": "node scripts/prepare-dist.mjs",
     "check-types": "tsc --noEmit -p tsconfig.json",
     "lint": "oxlint .",
     "lint:fix": "oxlint --fix .",
@@ -31,12 +35,39 @@
     "format:check": "oxfmt ."
   },
   "dependencies": {
+    "@base-ui/react": "^1.3.0",
     "@clack/prompts": "^1.0.0",
+    "@mdx-js/mdx": "^3.1.1",
+    "@shikijs/rehype": "^4.0.2",
+    "@tailwindcss/postcss": "^4.2.2",
+    "blode-icons-react": "^0.3.10",
     "chalk": "^5.6.2",
+    "chokidar": "^4.0.3",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "cmdk": "^1.1.1",
     "commander": "^14.0.0",
-    "open": "^10.2.0"
+    "geist": "^1.7.0",
+    "next": "16.2.1",
+    "next-mdx-remote": "^6.0.0",
+    "next-themes": "^0.4.6",
+    "open": "^10.2.0",
+    "radix-ui": "^1.4.3",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "rehype-autolink-headings": "^7.1.0",
+    "rehype-slug": "^6.0.0",
+    "remark-gfm": "^4.0.0",
+    "shadcn": "^4.1.1",
+    "shiki": "^4.0.2",
+    "tailwind-merge": "^3.5.0",
+    "tailwindcss": "^4.2.2",
+    "tw-animate-css": "^1.4.0",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@repo/previewing": "*",
     "@repo/typescript-config": "*",
     "@types/node": "^22.15.3",
     "oxfmt": "^0.42.0",

package/packages/@repo/common/dist/index.d.ts

@@ -0,0 +1,9 @@
+export declare const normalizePath: (value: string) => string;
+export declare const withLeadingSlash: (value: string) => string;
+export declare const withoutLeadingSlash: (value: string) => string;
+export declare const slugify: (value: string) => string;
+export declare const ensureArray: <T>(value?: T | T[]) => T[];
+export declare const uniq: <T>(values: T[]) => T[];
+export declare const safeJsonParse: <T>(value: string) => T | null;
+export declare const clamp: (value: number, min: number, max: number) => number;
+//# sourceMappingURL=index.d.ts.map

package/packages/@repo/common/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,aAAa,GAAI,OAAO,MAAM,WAK1C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,WAK7C,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,MAAM,WAKhD,CAAC;AAEF,eAAO,MAAM,OAAO,GAAI,OAAO,MAAM,WAKL,CAAC;AAEjC,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,QAK7C,CAAC;AAEF,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,QAAQ,CAAC,EAAE,QAAyB,CAAC;AAE7D,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,OAAO,MAAM,KAAG,CAAC,GAAG,IAMpD,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,WACxB,CAAC"}

package/packages/@repo/common/dist/index.js

@@ -0,0 +1,42 @@
+const BACKSLASH_TO_SLASH_REGEX = /\\/g;
+const TRAILING_SLASHES_REGEX = /\/+$/g;
+const LEADING_SLASHES_REGEX = /^\/+/;
+export const normalizePath = (value) => {
+    const trimmed = value
+        .replace(BACKSLASH_TO_SLASH_REGEX, "/")
+        .replace(TRAILING_SLASHES_REGEX, "");
+    return trimmed.replace(LEADING_SLASHES_REGEX, "");
+};
+export const withLeadingSlash = (value) => {
+    if (!value) {
+        return "/";
+    }
+    return value.startsWith("/") ? value : `/${value}`;
+};
+export const withoutLeadingSlash = (value) => {
+    if (!value) {
+        return "";
+    }
+    return value.startsWith("/") ? value.slice(1) : value;
+};
+export const slugify = (value) => value
+    .toLowerCase()
+    .trim()
+    .replaceAll(/[^a-z0-9]+/g, "-")
+    .replaceAll(/(^-|-$)+/g, "");
+export const ensureArray = (value) => {
+    if (value === undefined) {
+        return [];
+    }
+    return Array.isArray(value) ? value : [value];
+};
+export const uniq = (values) => [...new Set(values)];
+export const safeJsonParse = (value) => {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
+export const clamp = (value, min, max) => Math.min(Math.max(value, min), max);

package/packages/@repo/common/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@repo/common",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "types": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc",
+    "check-types": "tsc --noEmit",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt ."
+  },
+  "devDependencies": {
+    "@repo/typescript-config": "*",
+    "@types/node": "^22.19.15",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "typescript": "6.0.2",
+    "ultracite": "^7.3.2"
+  }
+}

package/packages/@repo/common/src/common.unit.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  clamp,
+  ensureArray,
+  normalizePath,
+  safeJsonParse,
+  slugify,
+  uniq,
+  withLeadingSlash,
+  withoutLeadingSlash,
+} from "./index";
+
+describe("common utilities", () => {
+  it("normalizes paths", () => {
+    expect(normalizePath("/docs/guide/")).toBe("docs/guide");
+    expect(normalizePath("\\docs\\guide\\")).toBe("docs/guide");
+  });
+
+  it("adds and removes leading slashes", () => {
+    expect(withLeadingSlash("docs")).toBe("/docs");
+    expect(withLeadingSlash("/docs")).toBe("/docs");
+    expect(withLeadingSlash("")).toBe("/");
+    expect(withoutLeadingSlash("/docs")).toBe("docs");
+    expect(withoutLeadingSlash("docs")).toBe("docs");
+    expect(withoutLeadingSlash("")).toBe("");
+  });
+
+  it("slugifies strings", () => {
+    expect(slugify("Hello, blodemd!")).toBe("hello-blodemd");
+  });
+
+  it("normalizes arrays", () => {
+    expect(ensureArray()).toEqual([]);
+    expect(ensureArray("one")).toEqual(["one"]);
+    expect(ensureArray(["one", "two"])).toEqual(["one", "two"]);
+  });
+
+  it("deduplicates arrays", () => {
+    expect(uniq(["a", "a", "b"])).toEqual(["a", "b"]);
+  });
+
+  it("safely parses JSON", () => {
+    expect(safeJsonParse<{ ok: boolean }>('{"ok":true}')).toEqual({
+      ok: true,
+    });
+    expect(safeJsonParse("{")).toBeNull();
+  });
+
+  it("clamps values", () => {
+    expect(clamp(5, 0, 10)).toBe(5);
+    expect(clamp(-1, 0, 10)).toBe(0);
+    expect(clamp(11, 0, 10)).toBe(10);
+  });
+});

package/packages/@repo/common/src/index.ts

@@ -0,0 +1,51 @@
+const BACKSLASH_TO_SLASH_REGEX = /\\/g;
+const TRAILING_SLASHES_REGEX = /\/+$/g;
+const LEADING_SLASHES_REGEX = /^\/+/;
+
+export const normalizePath = (value: string) => {
+  const trimmed = value
+    .replace(BACKSLASH_TO_SLASH_REGEX, "/")
+    .replace(TRAILING_SLASHES_REGEX, "");
+  return trimmed.replace(LEADING_SLASHES_REGEX, "");
+};
+
+export const withLeadingSlash = (value: string) => {
+  if (!value) {
+    return "/";
+  }
+  return value.startsWith("/") ? value : `/${value}`;
+};
+
+export const withoutLeadingSlash = (value: string) => {
+  if (!value) {
+    return "";
+  }
+  return value.startsWith("/") ? value.slice(1) : value;
+};
+
+export const slugify = (value: string) =>
+  value
+    .toLowerCase()
+    .trim()
+    .replaceAll(/[^a-z0-9]+/g, "-")
+    .replaceAll(/(^-|-$)+/g, "");
+
+export const ensureArray = <T>(value?: T | T[]) => {
+  if (value === undefined) {
+    return [] as T[];
+  }
+  return Array.isArray(value) ? value : [value];
+};
+
+export const uniq = <T>(values: T[]) => [...new Set(values)];
+
+export const safeJsonParse = <T>(value: string): T | null => {
+  try {
+    return JSON.parse(value) as T;
+  } catch {
+    return null;
+  }
+};
+
+export const clamp = (value: number, min: number, max: number) =>
+  Math.min(Math.max(value, min), max);

package/packages/@repo/contracts/dist/api-key.d.ts

@@ -0,0 +1,30 @@
+import { z } from "zod";
+export declare const ApiKeySchema: z.ZodObject<{
+    createdAt: z.ZodString;
+    id: z.ZodString;
+    lastUsedAt: z.ZodOptional<z.ZodString>;
+    name: z.ZodString;
+    prefix: z.ZodString;
+    projectId: z.ZodString;
+    revokedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ApiKey = z.infer<typeof ApiKeySchema>;
+export declare const ApiKeyCreateSchema: z.ZodObject<{
+    name: z.ZodString;
+    projectId: z.ZodString;
+}, z.core.$strip>;
+export type ApiKeyCreateInput = z.infer<typeof ApiKeyCreateSchema>;
+export declare const ApiKeyCreateResponseSchema: z.ZodObject<{
+    apiKey: z.ZodObject<{
+        createdAt: z.ZodString;
+        id: z.ZodString;
+        lastUsedAt: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        prefix: z.ZodString;
+        projectId: z.ZodString;
+        revokedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    token: z.ZodString;
+}, z.core.$strip>;
+export type ApiKeyCreateResponse = z.infer<typeof ApiKeyCreateResponseSchema>;
+//# sourceMappingURL=api-key.d.ts.map

package/packages/@repo/contracts/dist/api-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api-key.d.ts","sourceRoot":"","sources":["../src/api-key.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,YAAY;;;;;;;;iBAQvB,CAAC;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,eAAO,MAAM,kBAAkB;;;iBAG7B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEnE,eAAO,MAAM,0BAA0B;;;;;;;;;;;iBAGrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/packages/@repo/contracts/dist/api-key.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { IsoDateSchema } from "./dates.js";
+import { IdSchema } from "./ids.js";
+export const ApiKeySchema = z.object({
+    createdAt: IsoDateSchema,
+    id: IdSchema,
+    lastUsedAt: IsoDateSchema.optional(),
+    name: z.string().min(1),
+    prefix: z.string().min(1),
+    projectId: IdSchema,
+    revokedAt: IsoDateSchema.optional(),
+});
+export const ApiKeyCreateSchema = z.object({
+    name: z.string().min(1),
+    projectId: IdSchema,
+});
+export const ApiKeyCreateResponseSchema = z.object({
+    apiKey: ApiKeySchema,
+    token: z.string().min(1),
+});

package/packages/@repo/contracts/dist/dates.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+export declare const IsoDateSchema: z.ZodString;
+export type IsoDate = z.infer<typeof IsoDateSchema>;
+//# sourceMappingURL=dates.d.ts.map

package/packages/@repo/contracts/dist/dates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../src/dates.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa,aAAwB,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/packages/@repo/contracts/dist/dates.js

@@ -0,0 +1,2 @@
+import { z } from "zod";
+export const IsoDateSchema = z.string().datetime();