svelte-realtime 0.4.17 → 0.4.19

package/README.md

@@ -574,7 +574,7 @@ Same arguments return the same cached store instance. The cache is cleaned up wh
 
 ## Schema validation
 
-Use `live.validated(schema, fn)` to validate the first argument against a Zod or Valibot schema before the function runs.
+Use `live.validated(schema, fn)` to validate the first argument against a schema before the function runs. Any [Standard Schema](https://standardschema.dev/)-compatible validator is supported, including Zod, ArkType, Valibot, and others.
 
 ```js
 import { z } from 'zod';
@@ -592,7 +592,22 @@ export const addTodo = live.validated(CreateTodo, async (ctx, input) => {
 });
 ```
 
-On the client, validated exports work like regular `live()` calls. Validation errors are thrown as `RpcError` with `code: 'VALIDATION'` and an `issues` array. Valibot schemas are also supported -- the adapter detects the schema type automatically.
+Because `live.validated()` uses the [Standard Schema](https://standardschema.dev/) interface, you can swap in any compatible validator:
+
+```js
+import { type } from 'arktype';
+import { live } from 'svelte-realtime/server';
+
+const CreateTodo = type({ text: 'string>0', priority: '"low"|"medium"|"high"|undefined' });
+
+export const addTodo = live.validated(CreateTodo, async (ctx, input) => {
+  const todo = await db.todos.insert({ ...input, userId: ctx.user.id });
+  ctx.publish('todos', 'created', todo);
+  return todo;
+});
+```
+
+On the client, validated exports work like regular `live()` calls. Validation errors are thrown as `RpcError` with `code: 'VALIDATION'` and an `issues` array.
 
 ---
 
@@ -1948,7 +1963,7 @@ Import from `svelte-realtime/server`.
 | `live.stream(topic, initFn, options?)` | Create a reactive stream |
 | `live.channel(topic, options?)` | Create an ephemeral pub/sub channel |
 | `live.binary(fn, options?)` | Mark a function as a binary RPC handler (`maxSize` limits payload, default 10MB) |
-| `live.validated(schema, fn)` | RPC with Zod/Valibot input validation |
+| `live.validated(schema, fn)` | RPC with [Standard Schema](https://standardschema.dev/) input validation (Zod, ArkType, Valibot, etc.) |
 | `live.cron(schedule, topic, fn)` | Server-side scheduled function |
 | `live.derived(sources, fn, options?)` | Server-side computed stream (static or dynamic sources) |
 | `live.effect(sources, fn, options?)` | Server-side reactive side effect |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-realtime",
-  "version": "0.4.17",
+  "version": "0.4.19",
   "description": "Realtime RPC and reactive subscriptions for SvelteKit, built on svelte-adapter-uws",
   "author": "Kevin Radziszewski",
   "license": "MIT",

package/server.d.ts

@@ -370,18 +370,29 @@ export namespace live {
 	/**
 	 * Mark a function as RPC-callable with schema validation.
 	 * Validates args[0] against the schema before calling fn.
-	 * Supports Zod and Valibot schemas.
+	 * Supports any [Standard Schema](https://standardschema.dev/)-compatible schema,
+	 * including Zod, ArkType, Valibot v1+, and others.
 	 *
-	 * @param schema - Zod or Valibot schema
+	 * @param schema - Zod, ArkType, Valibot, or any Standard Schema-compatible schema
 	 * @param fn - Handler function (ctx, validatedInput, ...rest)
 	 *
 	 * @example
 	 * ```js
+	 * import { z } from 'zod';
 	 * const SendSchema = z.object({ text: z.string().min(1) });
 	 * export const send = live.validated(SendSchema, async (ctx, input) => {
 	 *   // input is validated and typed
 	 * });
 	 * ```
+	 *
+	 * @example
+	 * ```js
+	 * import { type } from 'arktype';
+	 * const SendSchema = type({ text: 'string>0' });
+	 * export const send = live.validated(SendSchema, async (ctx, input) => {
+	 *   // works with any Standard Schema-compatible validator
+	 * });
+	 * ```
 	 */
 	function validated<S, T extends (ctx: LiveContext<any>, input: any, ...args: any[]) => any>(
 		schema: S,

package/server.js

@@ -600,9 +600,10 @@ live.rateLimit = function rateLimit(config, fn) {
 /**
  * Mark a function as RPC-callable with schema validation.
  * Validates args[0] against the schema before calling fn.
- * Supports Zod (.safeParse method on schema) and Valibot (safeParse as standalone).
+ * Supports any Standard Schema-compatible schema (https://standardschema.dev/),
+ * including Zod, ArkType, Valibot v1+, and others.
  *
- * @param {any} schema - Zod or Valibot schema
+ * @param {any} schema - Zod, ArkType, Valibot, or any Standard Schema-compatible schema
  * @param {Function} fn - Handler function (ctx, validatedInput, ...rest)
  * @returns {Function}
  */
@@ -626,13 +627,36 @@ live.validated = function validated(schema, fn) {
 };
 
 /**
- * Validate input against a Zod or Valibot schema.
+ * Validate input against a Standard Schema-compatible schema, with legacy Zod/Valibot fallbacks.
  * @param {any} schema
  * @param {any} input
  * @returns {{ ok: true, data: any } | { ok: false, message: string, issues: Array<{ path: string[], message: string }> }}
  */
 function _validate(schema, input) {
-	// Zod-style: schema has .safeParse method
+	// Standard Schema: schema exposes `~standard.validate` (https://standardschema.dev/)
+	if (schema?.['~standard'] && typeof schema['~standard'].validate === 'function') {
+		const result = schema['~standard'].validate(input);
+		if (result instanceof Promise) {
+			return {
+				ok: false,
+				message: 'Async schemas are not supported in live.validated(). Use a synchronous schema.',
+				issues: [{ path: [], message: 'Async schema not supported' }]
+			};
+		}
+		if (result.issues == null) {
+			return { ok: true, data: result.value };
+		}
+		const issues = result.issues.map((/** @type {any} */ i) => ({
+			path: (i.path || []).map((/** @type {any} */ p) => {
+				const key = typeof p === 'object' && p !== null && 'key' in p ? p.key : p;
+				return key != null ? String(key) : '';
+			}).filter((k) => k !== ''),
+			message: i.message || 'Validation failed'
+		}));
+		return { ok: false, message: 'Validation failed', issues };
+	}
+
+	// Zod legacy fallback: schema has .safeParse method
 	if (typeof schema?.safeParse === 'function') {
 		const result = schema.safeParse(input);
 		if (result.success) {
@@ -649,7 +673,7 @@ function _validate(schema, input) {
 		};
 	}
 
-	// Valibot-style: schema is passed to a standalone safeParse
+	// Valibot legacy fallback: schema is passed to a standalone safeParse
 	// In Valibot v1, schemas have a ._run or .pipe method
 	// Try to use the schema directly as a Valibot schema
 	if (schema?._run || schema?.pipe || schema?.type) {
@@ -675,7 +699,7 @@ function _validate(schema, input) {
 	// Unknown schema type -- reject. Passing unvalidated input through is a security risk.
 	return {
 		ok: false,
-		message: 'Unrecognized schema type passed to live.validated(). Supported: Zod (.safeParse), Valibot (._run).',
+		message: 'Unrecognized schema type passed to live.validated(). Supported: Standard Schema (https://standardschema.dev/), Zod (.safeParse), Valibot (._run).',
 		issues: [{ path: [], message: 'Unrecognized schema type' }]
 	};
 }
@@ -1369,8 +1393,24 @@ export function __registerDerived(path, fn) {
 	if (/** @type {any} */ (fn).__derivedDynamic) {
 		const sourceFactory = /** @type {any} */ (fn).__derivedSourceFactory;
 		const debounce = /** @type {any} */ (fn).__derivedDebounce || 0;
+
+		/** @type {Map<string, any[]>} */
+		const topicArgs = new Map();
+		const topicFn = (...args) => {
+			const t = path + '\x00' + args.map(a => String(a).replace(/\x00/g, '')).join('\x00');
+			topicArgs.set(t, args);
+			if (topicArgs.size > 10000) {
+				const iter = topicArgs.keys();
+				topicArgs.delete(iter.next().value);
+			}
+			return t;
+		};
+		/** @type {any} */ (topicFn).__topicUsesCtx = false;
+		/** @type {any} */ (fn).__streamTopic = topicFn;
+		/** @type {any} */ (fn).__derivedTopicArgs = topicArgs;
+
 		const entry = {
-			sources: null, sourceFactory, fn, topic: /** @type {any} */ (fn).__streamTopic,
+			sources: null, sourceFactory, fn, topic: topicFn,
 			debounce, timer: null, dynamic: true, instances: new Map()
 		};
 		derivedRegistry.set(path, entry);
@@ -1379,11 +1419,11 @@ export function __registerDerived(path, fn) {
 		return;
 	}
 
+	/** @type {any} */ (fn).__streamTopic = path;
 	const sources = /** @type {any} */ (fn).__derivedSources;
-	const topic = /** @type {any} */ (fn).__streamTopic;
 	const debounce = /** @type {any} */ (fn).__derivedDebounce || 0;
-	if (!sources || !topic) return;
-	derivedRegistry.set(path, { sources, fn, topic, debounce, timer: null });
+	if (!sources) return;
+	derivedRegistry.set(path, { sources, fn, topic: path, debounce, timer: null });
 	for (const src of sources) {
 		let set = _derivedBySource.get(src);
 		if (!set) { set = new Set(); _derivedBySource.set(src, set); }