Small TypeScript libraries on web standards, for the server and the browser.

import { type } from "arktype"
import { isValid, validate, validateSchema } from "@spy4x/validation"

const userSchema = type({ name: "1 <= string <= 10", joinedAt: "string.date.iso.parse" })

const { error, data } = validate(userSchema, input)
if (error) return error.description
await save(data) // `data` is parsed, so `joinedAt` is a `Date`

On JSR: @spy4x/validation →

import { type } from "arktype"
import { UUID_V7_PATTERN, uuidV7 } from "@spy4x/platform/universal/uuid"

const noteSchema = type({ id: UUID_V7_PATTERN, text: "string" })
const note = noteSchema.assert({ id: uuidV7(), text: "milk" })

On JSR: @spy4x/platform →

import { createStorage } from "@spy4x/server/storage"

const storage = await createStorage() // reads Deno.env, returns undefined if unconfigured
await storage?.upload("media/photo.png", bytes)

On JSR: @spy4x/server →

import { validatePublicUrl } from "@spy4x/net/url-policy"

async function fetchUserSuppliedUrl(userInput: string) {
  const safeUrl = await validatePublicUrl(userInput) // throws on a private/loopback/link-local target
  return fetch(safeUrl)
}

On JSR: @spy4x/net →

const { publicKey, keys } = await generateVapidKeyPair() // once; store `keys`, serve `publicKey`
const sender = await createWebPushSender({
  vapidKeys: keys,
  subject: "mailto:ops@example.com",
  store,
})
const result = await sender.send(user.id, { title: "Backup done", body: null, url: null })

On JSR: @spy4x/integrations →

import { formatDateTimeLong, zonedDateTime } from "@spy4x/time/tz"

// A stored booking: a wall clock, the zone it was made in, the guest's zone.
const instant = zonedDateTime("2026-08-28", "10:00", "Europe/Berlin")
formatDateTimeLong("2026-08-28", "10:00", "Europe/Berlin") // "Friday, 28 August 2026 at 10:00"

On JSR: @spy4x/time →

import { createSmtpSender } from "@spy4x/email/smtp"
const sender = createSmtpSender({
  host: "smtp.example.com",
  port: 587,
  user: "user@example.com",
  pass: "test-password-not-real",
  from: "Booking <booking@example.com>",
})

const result = await sender.send({
  to: ["guest@example.com", "host@example.com"],
  subject: "Booking confirmed",
  text: "Your meeting is booked.",
})
if (!result.ok) console.error(result.error, result.rejected)

On JSR: @spy4x/email →

import { AggregateNotifier, ConnectionRegistry, createSystemClock } from "@spy4x/realtime"

const clock = createSystemClock()
const registry = new ConnectionRegistry({
  clock,
  maxConnectionsPerUser: 20,
})

// From the upgrade handler: authenticate once at the upgrade, then attach. `attach` returns `null`
// — and has already closed the socket — once the user is at `maxConnectionsPerUser`.
const handle = registry.attach(userId, adaptSocket(await upgrade(request)))
if (!handle) logger.warn("refused a socket: user already at the connection cap", { userId })

On JSR: @spy4x/realtime →

import { BillingEventType, createStripeBilling } from "@spy4x/billing"

const billing = createStripeBilling({
  secretKey, // read from your own config; the library never reads the environment
  webhookSecret,
  plans: [{ planId: "pro", priceId: "price_…" }],
})

// Checkout: redirect the customer to `result.value.url`.
const result = await billing.createCheckout({
  planId: "pro",
  successUrl: "https://app.example.com/billing/done",
  cancelUrl: "https://app.example.com/billing",
  reference: account.id, // comes back as `subscription.reference` on every event
})

On JSR: @spy4x/billing →

import { CalDavErrorCode, createCalDavClient } from "@spy4x/caldav"

const client = createCalDavClient({
  serverUrl: "https://dav.example.com/", // the bare host or `…/dav/cal/` both work
  auth: { username: "user@example.com", password: "…" },
})

const found = await client.discover() // .well-known → current-user-principal → calendar-home-set
if (!found.success) throw new Error(found.error.message)
const calendars = await client.listCalendars(found.output.homeUrls[0])
// Each: url, displayName, components, color?, ctag?, syncToken?

On JSR: @spy4x/caldav →

import { parseTask } from "@spy4x/tasks/model"
import { SortMode, sortTasks, todayView } from "@spy4x/tasks/view"
import { parseQuickAdd } from "@spy4x/tasks/quick-add"

const zone = "Europe/Berlin"
const tasks = resources.map(parseTask).flatMap((result) => result.success ? [result.output] : [])

const byDue = sortTasks(tasks, SortMode.Due, zone)
const { overdue, today } = todayView(tasks, new Date(), zone)

const typed = parseQuickAdd("Call Anna @phone #work tomorrow 3pm !high", {
  now: new Date(),
  timeZone: zone,
})
typed.title // "Call Anna"

On JSR: @spy4x/tasks →