@canmi/seam-server 0.4.18 → 0.5.10

package/dist/index.js

@@ -141,24 +141,21 @@ const t = {
 };
 
 //#endregion
-//#region src/manifest/index.ts
-function buildManifest(definitions, channels) {
-	const mapped = {};
-	for (const [name, def] of Object.entries(definitions)) {
-		const entry = {
-			type: def.type === "subscription" ? "subscription" : def.type === "command" ? "command" : "query",
-			input: def.input._schema,
-			output: def.output._schema
-		};
-		if (def.error) entry.error = def.error._schema;
-		mapped[name] = entry;
-	}
-	const manifest = {
-		version: 1,
-		procedures: mapped
+//#region src/validation/index.ts
+function validateInput(schema, data) {
+	const errors = validate(schema, data, {
+		maxDepth: 32,
+		maxErrors: 10
+	});
+	return {
+		valid: errors.length === 0,
+		errors
 	};
-	if (channels && Object.keys(channels).length > 0) manifest.channels = channels;
-	return manifest;
+}
+function formatValidationErrors(errors) {
+	return errors.map((e) => {
+		return `${e.instancePath.length > 0 ? e.instancePath.join("/") : "(root)"} (schema: ${e.schemaPath.join("/")})`;
+	}).join("; ");
 }
 
 //#endregion
@@ -193,26 +190,111 @@ var SeamError = class extends Error {
 };
 
 //#endregion
-//#region src/validation/index.ts
-function validateInput(schema, data) {
-	const errors = validate(schema, data, {
-		maxDepth: 32,
-		maxErrors: 10
-	});
+//#region src/context.ts
+/** Parse extract rule into source type and key, e.g. "header:authorization" -> { source: "header", key: "authorization" } */
+function parseExtractRule(rule) {
+	const idx = rule.indexOf(":");
+	if (idx === -1) throw new Error(`Invalid extract rule "${rule}": expected "source:key" format`);
+	const source = rule.slice(0, idx);
+	const key = rule.slice(idx + 1);
+	if (!source || !key) throw new Error(`Invalid extract rule "${rule}": source and key must be non-empty`);
 	return {
-		valid: errors.length === 0,
-		errors
+		source,
+		key
 	};
 }
-function formatValidationErrors(errors) {
-	return errors.map((e) => {
-		return `${e.instancePath.length > 0 ? e.instancePath.join("/") : "(root)"} (schema: ${e.schemaPath.join("/")})`;
-	}).join("; ");
+/** Collect all header names needed by the context config */
+function contextExtractKeys(config) {
+	const keys = [];
+	for (const field of Object.values(config)) {
+		const { source, key } = parseExtractRule(field.extract);
+		if (source === "header") keys.push(key);
+	}
+	return [...new Set(keys)];
+}
+/**
+* Resolve raw strings into validated context object.
+*
+* For each requested key:
+* - If raw value is null/missing -> pass null to JTD; schema decides via nullable()
+* - If schema expects string -> use raw value directly
+* - If schema expects object -> JSON.parse then validate
+*/
+function resolveContext(config, raw, requestedKeys) {
+	const result = {};
+	for (const key of requestedKeys) {
+		const field = config[key];
+		if (!field) throw new SeamError("CONTEXT_ERROR", `Context field "${key}" is not defined in router context config`, 400);
+		const { source, key: extractKey } = parseExtractRule(field.extract);
+		const rawValue = raw[source === "header" ? extractKey : extractKey] ?? null;
+		let value;
+		if (rawValue === null) value = null;
+		else {
+			const schema = field.schema._schema;
+			const isStringSchema = "type" in schema && schema.type === "string" && !("nullable" in schema && schema.nullable);
+			const isNullableStringSchema = "type" in schema && schema.type === "string" && "nullable" in schema && schema.nullable;
+			if (isStringSchema || isNullableStringSchema) value = rawValue;
+			else try {
+				value = JSON.parse(rawValue);
+			} catch {
+				throw new SeamError("CONTEXT_ERROR", `Context field "${key}": failed to parse value as JSON`, 400);
+			}
+		}
+		const validation = validateInput(field.schema._schema, value);
+		if (!validation.valid) throw new SeamError("CONTEXT_ERROR", `Context field "${key}" validation failed: ${formatValidationErrors(validation.errors)}`, 400);
+		result[key] = value;
+	}
+	return result;
+}
+
+//#endregion
+//#region src/manifest/index.ts
+function normalizeInvalidates(targets) {
+	return targets.map((t) => {
+		if (typeof t === "string") return { query: t };
+		const normalized = { query: t.query };
+		if (t.mapping) normalized.mapping = Object.fromEntries(Object.entries(t.mapping).map(([k, v]) => [k, typeof v === "string" ? { from: v } : v]));
+		return normalized;
+	});
+}
+function buildManifest(definitions, channels, contextConfig, transportDefaults) {
+	const mapped = {};
+	for (const [name, def] of Object.entries(definitions)) {
+		const k = def.kind ?? def.type;
+		const kind = k === "upload" ? "upload" : k === "stream" ? "stream" : k === "subscription" ? "subscription" : k === "command" ? "command" : "query";
+		const entry = {
+			kind,
+			input: def.input._schema
+		};
+		if (kind === "stream") entry.chunkOutput = def.output._schema;
+		else entry.output = def.output._schema;
+		if (def.error) entry.error = def.error._schema;
+		if (kind === "command" && def.invalidates && def.invalidates.length > 0) entry.invalidates = normalizeInvalidates(def.invalidates);
+		if (def.context && def.context.length > 0) entry.context = def.context;
+		const defAny = def;
+		if (defAny.transport) entry.transport = defAny.transport;
+		if (defAny.suppress) entry.suppress = defAny.suppress;
+		if (defAny.cache !== void 0) entry.cache = defAny.cache;
+		mapped[name] = entry;
+	}
+	const context = {};
+	if (contextConfig) for (const [key, field] of Object.entries(contextConfig)) context[key] = {
+		extract: field.extract,
+		schema: field.schema._schema
+	};
+	const manifest = {
+		version: 2,
+		context,
+		procedures: mapped,
+		transportDefaults: transportDefaults ?? {}
+	};
+	if (channels && Object.keys(channels).length > 0) manifest.channels = channels;
+	return manifest;
 }
 
 //#endregion
 //#region src/router/handler.ts
-async function handleRequest(procedures, procedureName, rawBody, validateOutput) {
+async function handleRequest(procedures, procedureName, rawBody, validateOutput, ctx) {
 	const procedure = procedures.get(procedureName);
 	if (!procedure) return {
 		status: 404,
@@ -224,7 +306,10 @@ async function handleRequest(procedures, procedureName, rawBody, validateOutput)
 		body: new SeamError("VALIDATION_ERROR", `Input validation failed: ${formatValidationErrors(validation.errors)}`).toJSON()
 	};
 	try {
-		const result = await procedure.handler({ input: rawBody });
+		const result = await procedure.handler({
+			input: rawBody,
+			ctx: ctx ?? {}
+		});
 		if (validateOutput) {
 			const outValidation = validateInput(procedure.outputSchema, result);
 			if (!outValidation.valid) return {
@@ -250,9 +335,10 @@ async function handleRequest(procedures, procedureName, rawBody, validateOutput)
 		};
 	}
 }
-async function handleBatchRequest(procedures, calls, validateOutput) {
+async function handleBatchRequest(procedures, calls, validateOutput, ctxResolver) {
 	return { results: await Promise.all(calls.map(async (call) => {
-		const result = await handleRequest(procedures, call.procedure, call.input, validateOutput);
+		const ctx = ctxResolver ? ctxResolver(call.procedure) : void 0;
+		const result = await handleRequest(procedures, call.procedure, call.input, validateOutput, ctx);
 		if (result.status === 200) return {
 			ok: true,
 			data: result.body.data
@@ -263,12 +349,15 @@ async function handleBatchRequest(procedures, calls, validateOutput) {
 		};
 	})) };
 }
-async function* handleSubscription(subscriptions, name, rawInput, validateOutput) {
+async function* handleSubscription(subscriptions, name, rawInput, validateOutput, ctx) {
 	const sub = subscriptions.get(name);
 	if (!sub) throw new SeamError("NOT_FOUND", `Subscription '${name}' not found`);
 	const validation = validateInput(sub.inputSchema, rawInput);
 	if (!validation.valid) throw new SeamError("VALIDATION_ERROR", `Input validation failed: ${formatValidationErrors(validation.errors)}`);
-	for await (const value of sub.handler({ input: rawInput })) {
+	for await (const value of sub.handler({
+		input: rawInput,
+		ctx: ctx ?? {}
+	})) {
 		if (validateOutput) {
 			const outValidation = validateInput(sub.outputSchema, value);
 			if (!outValidation.valid) throw new SeamError("INTERNAL_ERROR", `Output validation failed: ${formatValidationErrors(outValidation.errors)}`);
@@ -276,17 +365,140 @@ async function* handleSubscription(subscriptions, name, rawInput, validateOutput
 		yield value;
 	}
 }
+async function handleUploadRequest(uploads, procedureName, rawBody, file, validateOutput, ctx) {
+	const upload = uploads.get(procedureName);
+	if (!upload) return {
+		status: 404,
+		body: new SeamError("NOT_FOUND", `Procedure '${procedureName}' not found`).toJSON()
+	};
+	const validation = validateInput(upload.inputSchema, rawBody);
+	if (!validation.valid) return {
+		status: 400,
+		body: new SeamError("VALIDATION_ERROR", `Input validation failed: ${formatValidationErrors(validation.errors)}`).toJSON()
+	};
+	try {
+		const result = await upload.handler({
+			input: rawBody,
+			file,
+			ctx: ctx ?? {}
+		});
+		if (validateOutput) {
+			const outValidation = validateInput(upload.outputSchema, result);
+			if (!outValidation.valid) return {
+				status: 500,
+				body: new SeamError("INTERNAL_ERROR", `Output validation failed: ${formatValidationErrors(outValidation.errors)}`).toJSON()
+			};
+		}
+		return {
+			status: 200,
+			body: {
+				ok: true,
+				data: result
+			}
+		};
+	} catch (error) {
+		if (error instanceof SeamError) return {
+			status: error.status,
+			body: error.toJSON()
+		};
+		return {
+			status: 500,
+			body: new SeamError("INTERNAL_ERROR", error instanceof Error ? error.message : "Unknown error").toJSON()
+		};
+	}
+}
+async function* handleStream(streams, name, rawInput, validateOutput, ctx) {
+	const stream = streams.get(name);
+	if (!stream) throw new SeamError("NOT_FOUND", `Stream '${name}' not found`);
+	const validation = validateInput(stream.inputSchema, rawInput);
+	if (!validation.valid) throw new SeamError("VALIDATION_ERROR", `Input validation failed: ${formatValidationErrors(validation.errors)}`);
+	for await (const value of stream.handler({
+		input: rawInput,
+		ctx: ctx ?? {}
+	})) {
+		if (validateOutput) {
+			const outValidation = validateInput(stream.chunkOutputSchema, value);
+			if (!outValidation.valid) throw new SeamError("INTERNAL_ERROR", `Output validation failed: ${formatValidationErrors(outValidation.errors)}`);
+		}
+		yield value;
+	}
+}
+
+//#endregion
+//#region src/page/projection.ts
+/** Set a nested field by dot-separated path, creating intermediate objects as needed. */
+function setNestedField(target, path, value) {
+	const parts = path.split(".");
+	let current = target;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const key = parts[i];
+		if (!(key in current) || typeof current[key] !== "object" || current[key] === null) current[key] = {};
+		current = current[key];
+	}
+	current[parts[parts.length - 1]] = value;
+}
+/** Get a nested field by dot-separated path. */
+function getNestedField(source, path) {
+	const parts = path.split(".");
+	let current = source;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+}
+/** Prune a single value according to its projected field paths. */
+function pruneValue(value, fields) {
+	const arrayFields = [];
+	const plainFields = [];
+	for (const f of fields) if (f === "$") return value;
+	else if (f.startsWith("$.")) arrayFields.push(f.slice(2));
+	else plainFields.push(f);
+	if (arrayFields.length > 0 && Array.isArray(value)) return value.map((item) => {
+		if (typeof item !== "object" || item === null) return item;
+		const pruned = {};
+		for (const field of arrayFields) {
+			const val = getNestedField(item, field);
+			if (val !== void 0) setNestedField(pruned, field, val);
+		}
+		return pruned;
+	});
+	if (plainFields.length > 0 && typeof value === "object" && value !== null) {
+		const source = value;
+		const pruned = {};
+		for (const field of plainFields) {
+			const val = getNestedField(source, field);
+			if (val !== void 0) setNestedField(pruned, field, val);
+		}
+		return pruned;
+	}
+	return value;
+}
+/** Prune data to only include projected fields. Missing projection = keep all. */
+function applyProjection(data, projections) {
+	if (!projections) return data;
+	const result = {};
+	for (const [key, value] of Object.entries(data)) {
+		const fields = projections[key];
+		if (!fields) result[key] = value;
+		else result[key] = pruneValue(value, fields);
+	}
+	return result;
+}
 
 //#endregion
 //#region src/page/handler.ts
 /** Execute loaders, returning keyed results */
-async function executeLoaders(loaders, params, procedures) {
+async function executeLoaders(loaders, params, procedures, searchParams) {
 	const entries = Object.entries(loaders);
 	const results = await Promise.all(entries.map(async ([key, loader]) => {
-		const { procedure, input } = loader(params);
+		const { procedure, input } = loader(params, searchParams);
 		const proc = procedures.get(procedure);
 		if (!proc) throw new SeamError("INTERNAL_ERROR", `Procedure '${procedure}' not found`);
-		return [key, await proc.handler({ input })];
+		return [key, await proc.handler({
+			input,
+			ctx: {}
+		})];
 	}));
 	return Object.fromEntries(results);
 }
@@ -306,15 +518,16 @@ function lookupMessages(config, routePattern, locale) {
 	}
 	return config.messages[locale]?.[routeHash] ?? {};
 }
-async function handlePageRequest(page, params, procedures, i18nOpts) {
+async function handlePageRequest(page, params, procedures, i18nOpts, searchParams) {
 	try {
 		const t0 = performance.now();
 		const layoutChain = page.layoutChain ?? [];
 		const locale = i18nOpts?.locale;
-		const loaderResults = await Promise.all([...layoutChain.map((layout) => executeLoaders(layout.loaders, params, procedures)), executeLoaders(page.loaders, params, procedures)]);
+		const loaderResults = await Promise.all([...layoutChain.map((layout) => executeLoaders(layout.loaders, params, procedures, searchParams)), executeLoaders(page.loaders, params, procedures, searchParams)]);
 		const t1 = performance.now();
 		const allData = {};
 		for (const result of loaderResults) Object.assign(allData, result);
+		const prunedData = applyProjection(allData, page.projections);
 		let composedTemplate = selectTemplate(page.template, page.localeTemplates, locale);
 		for (let i = layoutChain.length - 1; i >= 0; i--) {
 			const layout = layoutChain[i];
@@ -345,7 +558,7 @@ async function handlePageRequest(page, params, procedures, i18nOpts) {
 			}
 			i18nOptsJson = JSON.stringify(i18nData);
 		}
-		const html = renderPage(composedTemplate, JSON.stringify(allData), JSON.stringify(config), i18nOptsJson);
+		const html = renderPage(composedTemplate, JSON.stringify(prunedData), JSON.stringify(config), i18nOptsJson);
 		const t2 = performance.now();
 		return {
 			status: 200,
@@ -517,10 +730,65 @@ function defaultStrategies() {
 }
 
 //#endregion
-//#region src/router/index.ts
-function isSubscriptionDef(def) {
-	return "type" in def && def.type === "subscription";
+//#region src/router/categorize.ts
+function resolveKind(name, def) {
+	if ("kind" in def && def.kind) return def.kind;
+	if ("type" in def && def.type) {
+		console.warn(`[seam] "${name}": "type" field in procedure definition is deprecated, use "kind" instead`);
+		return def.type;
+	}
+	return "query";
+}
+/** Split a flat definition map into typed procedure/subscription/stream maps */
+function categorizeProcedures(definitions, contextConfig) {
+	const procedureMap = /* @__PURE__ */ new Map();
+	const subscriptionMap = /* @__PURE__ */ new Map();
+	const streamMap = /* @__PURE__ */ new Map();
+	const uploadMap = /* @__PURE__ */ new Map();
+	const kindMap = /* @__PURE__ */ new Map();
+	for (const [name, def] of Object.entries(definitions)) {
+		const kind = resolveKind(name, def);
+		kindMap.set(name, kind);
+		const contextKeys = def.context ?? [];
+		if (contextConfig && contextKeys.length > 0) {
+			for (const key of contextKeys) if (!(key in contextConfig)) throw new Error(`Procedure "${name}" references undefined context field "${key}"`);
+		}
+		if (kind === "upload") uploadMap.set(name, {
+			inputSchema: def.input._schema,
+			outputSchema: def.output._schema,
+			contextKeys,
+			handler: def.handler
+		});
+		else if (kind === "stream") streamMap.set(name, {
+			inputSchema: def.input._schema,
+			chunkOutputSchema: def.output._schema,
+			contextKeys,
+			handler: def.handler
+		});
+		else if (kind === "subscription") subscriptionMap.set(name, {
+			inputSchema: def.input._schema,
+			outputSchema: def.output._schema,
+			contextKeys,
+			handler: def.handler
+		});
+		else procedureMap.set(name, {
+			inputSchema: def.input._schema,
+			outputSchema: def.output._schema,
+			contextKeys,
+			handler: def.handler
+		});
+	}
+	return {
+		procedureMap,
+		subscriptionMap,
+		streamMap,
+		uploadMap,
+		kindMap
+	};
 }
+
+//#endregion
+//#region src/router/index.ts
 /** Build the resolve strategy list from options */
 function buildStrategies(opts) {
 	const strategies = opts?.resolve ?? defaultStrategies();
@@ -534,6 +802,7 @@ function registerI18nQuery(procedureMap, config) {
 	procedureMap.set("__seam_i18n_query", {
 		inputSchema: {},
 		outputSchema: {},
+		contextKeys: [],
 		handler: ({ input }) => {
 			const { route, locale } = input;
 			const messages = lookupI18nMessages(config, route, locale);
@@ -553,19 +822,72 @@ function lookupI18nMessages(config, routeHash, locale) {
 	}
 	return config.messages[locale]?.[routeHash] ?? {};
 }
-function createRouter(procedures, opts) {
-	const procedureMap = /* @__PURE__ */ new Map();
-	const subscriptionMap = /* @__PURE__ */ new Map();
-	for (const [name, def] of Object.entries(procedures)) if (isSubscriptionDef(def)) subscriptionMap.set(name, {
-		inputSchema: def.input._schema,
-		outputSchema: def.output._schema,
-		handler: def.handler
-	});
-	else procedureMap.set(name, {
-		inputSchema: def.input._schema,
-		outputSchema: def.output._schema,
-		handler: def.handler
+/** Collect channel metadata from channel results for manifest */
+function collectChannelMeta(channels) {
+	if (!channels || channels.length === 0) return void 0;
+	return Object.fromEntries(channels.map((ch) => {
+		const firstKey = Object.keys(ch.procedures)[0] ?? "";
+		return [firstKey.includes(".") ? firstKey.slice(0, firstKey.indexOf(".")) : firstKey, ch.channelMeta];
+	}));
+}
+/** Resolve context for a procedure, returning undefined if no context needed */
+function resolveCtxFor(map, name, rawCtx, extractKeys, ctxConfig) {
+	if (!rawCtx || extractKeys.length === 0) return void 0;
+	const proc = map.get(name);
+	if (!proc || proc.contextKeys.length === 0) return void 0;
+	return resolveContext(ctxConfig, rawCtx, proc.contextKeys);
+}
+/** Resolve locale and match page route */
+async function matchAndHandlePage(pageMatcher, procedureMap, i18nConfig, strategies, hasUrlPrefix, path, headers) {
+	let pathLocale = null;
+	let routePath = path;
+	if (hasUrlPrefix && i18nConfig) {
+		const segments = path.split("/").filter(Boolean);
+		const localeSet = new Set(i18nConfig.locales);
+		const first = segments[0];
+		if (first && localeSet.has(first)) {
+			pathLocale = first;
+			routePath = "/" + segments.slice(1).join("/") || "/";
+		}
+	}
+	let locale;
+	if (i18nConfig) locale = resolveChain(strategies, {
+		url: headers?.url ?? "",
+		pathLocale,
+		cookie: headers?.cookie,
+		acceptLanguage: headers?.acceptLanguage,
+		locales: i18nConfig.locales,
+		defaultLocale: i18nConfig.default
 	});
+	const match = pageMatcher.match(routePath);
+	if (!match) return null;
+	let searchParams;
+	if (headers?.url) try {
+		const url = new URL(headers.url, "http://localhost");
+		if (url.search) searchParams = url.searchParams;
+	} catch {}
+	const i18nOpts = locale && i18nConfig ? {
+		locale,
+		config: i18nConfig,
+		routePattern: match.pattern
+	} : void 0;
+	return handlePageRequest(match.value, match.params, procedureMap, i18nOpts, searchParams);
+}
+/** Catch context resolution errors and return them as HandleResult */
+function resolveCtxSafe(map, name, rawCtx, extractKeys, ctxConfig) {
+	try {
+		return { ctx: resolveCtxFor(map, name, rawCtx, extractKeys, ctxConfig) };
+	} catch (err) {
+		if (err instanceof SeamError) return { error: {
+			status: err.status,
+			body: err.toJSON()
+		} };
+		throw err;
+	}
+}
+function createRouter(procedures, opts) {
+	const ctxConfig = opts?.context ?? {};
+	const { procedureMap, subscriptionMap, streamMap, uploadMap, kindMap } = categorizeProcedures(procedures, Object.keys(ctxConfig).length > 0 ? ctxConfig : void 0);
 	const shouldValidateOutput = opts?.validateOutput ?? (typeof process !== "undefined" && process.env.NODE_ENV !== "production");
 	const pageMatcher = new RouteMatcher();
 	const pages = opts?.pages;
@@ -573,54 +895,41 @@ function createRouter(procedures, opts) {
 	const i18nConfig = opts?.i18n ?? null;
 	const { strategies, hasUrlPrefix } = buildStrategies(opts);
 	if (i18nConfig) registerI18nQuery(procedureMap, i18nConfig);
-	const channelsMeta = opts?.channels && opts.channels.length > 0 ? Object.fromEntries(opts.channels.map((ch) => {
-		const firstKey = Object.keys(ch.procedures)[0] ?? "";
-		return [firstKey.includes(".") ? firstKey.slice(0, firstKey.indexOf(".")) : firstKey, ch.channelMeta];
-	})) : void 0;
+	const channelsMeta = collectChannelMeta(opts?.channels);
+	const extractKeys = contextExtractKeys(ctxConfig);
 	return {
 		procedures,
 		hasPages: !!pages && Object.keys(pages).length > 0,
+		contextExtractKeys() {
+			return extractKeys;
+		},
 		manifest() {
-			return buildManifest(procedures, channelsMeta);
+			return buildManifest(procedures, channelsMeta, ctxConfig, opts?.transportDefaults);
 		},
-		handle(procedureName, body) {
-			return handleRequest(procedureMap, procedureName, body, shouldValidateOutput);
+		async handle(procedureName, body, rawCtx) {
+			const { ctx, error } = resolveCtxSafe(procedureMap, procedureName, rawCtx, extractKeys, ctxConfig);
+			if (error) return error;
+			return handleRequest(procedureMap, procedureName, body, shouldValidateOutput, ctx);
 		},
-		handleBatch(calls) {
-			return handleBatchRequest(procedureMap, calls, shouldValidateOutput);
+		handleBatch(calls, rawCtx) {
+			return handleBatchRequest(procedureMap, calls, shouldValidateOutput, rawCtx ? (name) => resolveCtxFor(procedureMap, name, rawCtx, extractKeys, ctxConfig) ?? {} : void 0);
 		},
-		handleSubscription(name, input) {
-			return handleSubscription(subscriptionMap, name, input, shouldValidateOutput);
+		handleSubscription(name, input, rawCtx) {
+			return handleSubscription(subscriptionMap, name, input, shouldValidateOutput, resolveCtxFor(subscriptionMap, name, rawCtx, extractKeys, ctxConfig));
 		},
-		async handlePage(path, headers) {
-			let pathLocale = null;
-			let routePath = path;
-			if (hasUrlPrefix && i18nConfig) {
-				const segments = path.split("/").filter(Boolean);
-				const localeSet = new Set(i18nConfig.locales);
-				const first = segments[0];
-				if (first && localeSet.has(first)) {
-					pathLocale = first;
-					routePath = "/" + segments.slice(1).join("/") || "/";
-				}
-			}
-			let locale;
-			if (i18nConfig) locale = resolveChain(strategies, {
-				url: headers?.url ?? "",
-				pathLocale,
-				cookie: headers?.cookie,
-				acceptLanguage: headers?.acceptLanguage,
-				locales: i18nConfig.locales,
-				defaultLocale: i18nConfig.default
-			});
-			const match = pageMatcher.match(routePath);
-			if (!match) return null;
-			const i18nOpts = locale && i18nConfig ? {
-				locale,
-				config: i18nConfig,
-				routePattern: match.pattern
-			} : void 0;
-			return handlePageRequest(match.value, match.params, procedureMap, i18nOpts);
+		handleStream(name, input, rawCtx) {
+			return handleStream(streamMap, name, input, shouldValidateOutput, resolveCtxFor(streamMap, name, rawCtx, extractKeys, ctxConfig));
+		},
+		async handleUpload(name, body, file, rawCtx) {
+			const { ctx, error } = resolveCtxSafe(uploadMap, name, rawCtx, extractKeys, ctxConfig);
+			if (error) return error;
+			return handleUploadRequest(uploadMap, name, body, file, shouldValidateOutput, ctx);
+		},
+		getKind(name) {
+			return kindMap.get(name) ?? null;
+		},
+		handlePage(path, headers) {
+			return matchAndHandlePage(pageMatcher, procedureMap, i18nConfig, strategies, hasUrlPrefix, path, headers);
 		}
 	};
 }
@@ -661,7 +970,7 @@ function createChannel(name, def) {
 	const channelInputSchema = def.input._schema;
 	for (const [msgName, msgDef] of Object.entries(def.incoming)) {
 		const command = {
-			type: "command",
+			kind: "command",
 			input: { _schema: mergeObjectSchemas(channelInputSchema, msgDef.input._schema) },
 			output: msgDef.output,
 			handler: msgDef.handler
@@ -671,7 +980,7 @@ function createChannel(name, def) {
 	}
 	const unionSchema = buildOutgoingUnionSchema(def.outgoing);
 	const subscription = {
-		type: "subscription",
+		kind: "subscription",
 		input: def.input,
 		output: { _schema: unionSchema },
 		handler: def.subscribe
@@ -688,13 +997,15 @@ function createChannel(name, def) {
 	}
 	const outgoingMeta = {};
 	for (const [eventName, node] of Object.entries(def.outgoing)) outgoingMeta[eventName] = node._schema;
+	const channelMeta = {
+		input: channelInputSchema,
+		incoming: incomingMeta,
+		outgoing: outgoingMeta
+	};
+	if (def.transport) channelMeta.transport = def.transport;
 	return {
 		procedures,
-		channelMeta: {
-			input: channelInputSchema,
-			incoming: incomingMeta,
-			outgoing: outgoingMeta
-		}
+		channelMeta
 	};
 }
 
@@ -775,6 +1086,10 @@ async function handleStaticAsset(assetPath, staticDir) {
 function sseDataEvent(data) {
 	return `event: data\ndata: ${JSON.stringify(data)}\n\n`;
 }
+/** Format an SSE data event with a sequence id (for streams) */
+function sseDataEventWithId(data, id) {
+	return `event: data\nid: ${id}\ndata: ${JSON.stringify(data)}\n\n`;
+}
 /** Format an SSE error event */
 function sseErrorEvent(code, message, transient = false) {
 	return `event: error\ndata: ${JSON.stringify({
@@ -787,16 +1102,30 @@ function sseErrorEvent(code, message, transient = false) {
 function sseCompleteEvent() {
 	return "event: complete\ndata: {}\n\n";
 }
-async function* sseStream(router, name, input) {
+async function* sseStream(router, name, input, rawCtx) {
+	try {
+		for await (const value of router.handleSubscription(name, input, rawCtx)) yield sseDataEvent(value);
+		yield sseCompleteEvent();
+	} catch (error) {
+		if (error instanceof SeamError) yield sseErrorEvent(error.code, error.message);
+		else yield sseErrorEvent("INTERNAL_ERROR", error instanceof Error ? error.message : "Unknown error");
+	}
+}
+async function* sseStreamForStream(router, name, input, signal, rawCtx) {
+	const gen = router.handleStream(name, input, rawCtx);
+	if (signal) signal.addEventListener("abort", () => {
+		gen.return(void 0);
+	}, { once: true });
 	try {
-		for await (const value of router.handleSubscription(name, input)) yield sseDataEvent(value);
+		let seq = 0;
+		for await (const value of gen) yield sseDataEventWithId(value, seq++);
 		yield sseCompleteEvent();
 	} catch (error) {
 		if (error instanceof SeamError) yield sseErrorEvent(error.code, error.message);
 		else yield sseErrorEvent("INTERNAL_ERROR", error instanceof Error ? error.message : "Unknown error");
 	}
 }
-async function handleBatchHttp(req, router, hashToName) {
+async function handleBatchHttp(req, router, hashToName, rawCtx) {
 	let body;
 	try {
 		body = await req.body();
@@ -810,45 +1139,62 @@ async function handleBatchHttp(req, router, hashToName) {
 	}));
 	return jsonResponse(200, {
 		ok: true,
-		data: await router.handleBatch(calls)
+		data: await router.handleBatch(calls, rawCtx)
 	});
 }
+/** Resolve hash -> original name when obfuscation is active. Returns null on miss. */
+function resolveHashName(hashToName, name) {
+	if (!hashToName) return name;
+	return hashToName.get(name) ?? null;
+}
 function createHttpHandler(router, opts) {
 	const hashToName = opts?.rpcHashMap ? new Map(Object.entries(opts.rpcHashMap.procedures).map(([n, h]) => [h, n])) : null;
 	if (hashToName) hashToName.set("__seam_i18n_query", "__seam_i18n_query");
 	const batchHash = opts?.rpcHashMap?.batch ?? null;
+	const ctxExtractKeys = router.contextExtractKeys();
 	return async (req) => {
 		const url = new URL(req.url, "http://localhost");
 		const { pathname } = url;
+		const rawCtx = ctxExtractKeys.length > 0 && req.header ? Object.fromEntries(ctxExtractKeys.map((k) => [k, req.header?.(k) ?? null])) : void 0;
 		if (req.method === "GET" && pathname === MANIFEST_PATH) {
 			if (opts?.rpcHashMap) return errorResponse(403, "FORBIDDEN", "Manifest disabled");
 			return jsonResponse(200, router.manifest());
 		}
 		if (pathname.startsWith(PROCEDURE_PREFIX)) {
-			let name = pathname.slice(17);
-			if (!name) return errorResponse(404, "NOT_FOUND", "Empty procedure name");
+			const rawName = pathname.slice(17);
+			if (!rawName) return errorResponse(404, "NOT_FOUND", "Empty procedure name");
 			if (req.method === "POST") {
-				if (name === "_batch" || batchHash && name === batchHash) return handleBatchHttp(req, router, hashToName);
-				if (hashToName) {
-					const resolved = hashToName.get(name);
-					if (!resolved) return errorResponse(404, "NOT_FOUND", "Not found");
-					name = resolved;
-				}
+				if (rawName === "_batch" || batchHash && rawName === batchHash) return handleBatchHttp(req, router, hashToName, rawCtx);
+				const name = resolveHashName(hashToName, rawName);
+				if (!name) return errorResponse(404, "NOT_FOUND", "Not found");
 				let body;
 				try {
 					body = await req.body();
 				} catch {
 					return errorResponse(400, "VALIDATION_ERROR", "Invalid JSON body");
 				}
-				const result = await router.handle(name, body);
+				if (router.getKind(name) === "stream") {
+					const controller = new AbortController();
+					return {
+						status: 200,
+						headers: SSE_HEADER,
+						stream: sseStreamForStream(router, name, body, controller.signal, rawCtx),
+						onCancel: () => controller.abort()
+					};
+				}
+				if (router.getKind(name) === "upload") {
+					if (!req.file) return errorResponse(400, "VALIDATION_ERROR", "Upload requires multipart/form-data");
+					const file = await req.file();
+					if (!file) return errorResponse(400, "VALIDATION_ERROR", "Upload requires file in multipart body");
+					const result = await router.handleUpload(name, body, file, rawCtx);
+					return jsonResponse(result.status, result.body);
+				}
+				const result = await router.handle(name, body, rawCtx);
 				return jsonResponse(result.status, result.body);
 			}
 			if (req.method === "GET") {
-				if (hashToName) {
-					const resolved = hashToName.get(name);
-					if (!resolved) return errorResponse(404, "NOT_FOUND", "Not found");
-					name = resolved;
-				}
+				const name = resolveHashName(hashToName, rawName);
+				if (!name) return errorResponse(404, "NOT_FOUND", "Not found");
 				const rawInput = url.searchParams.get("input");
 				let input;
 				try {
@@ -859,7 +1205,7 @@ function createHttpHandler(router, opts) {
 				return {
 					status: 200,
 					headers: SSE_HEADER,
-					stream: sseStream(router, name, input)
+					stream: sseStream(router, name, input, rawCtx)
 				};
 			}
 		}
@@ -895,13 +1241,19 @@ async function drainStream(stream, write) {
 function toWebResponse(result) {
 	if ("stream" in result) {
 		const stream = result.stream;
+		const onCancel = result.onCancel;
 		const encoder = new TextEncoder();
-		const readable = new ReadableStream({ async start(controller) {
-			await drainStream(stream, (chunk) => {
-				controller.enqueue(encoder.encode(chunk));
-			});
-			controller.close();
-		} });
+		const readable = new ReadableStream({
+			async start(controller) {
+				await drainStream(stream, (chunk) => {
+					controller.enqueue(encoder.encode(chunk));
+				});
+				controller.close();
+			},
+			cancel() {
+				onCancel?.();
+			}
+		});
 		return new Response(readable, {
 			status: result.status,
 			headers: result.headers
@@ -916,11 +1268,11 @@ function toWebResponse(result) {
 //#endregion
 //#region src/page/build-loader.ts
 function buildLoaderFn(config) {
-	return (params) => {
+	return (params, searchParams) => {
 		const input = {};
 		if (config.params) for (const [key, mapping] of Object.entries(config.params)) {
-			const raw = params[key];
-			input[key] = mapping.type === "int" ? Number(raw) : raw;
+			const raw = mapping.from === "query" ? searchParams?.get(key) ?? void 0 : params[key];
+			if (raw !== void 0) input[key] = mapping.type === "int" ? Number(raw) : raw;
 		}
 		return {
 			procedure: config.procedure,
@@ -951,42 +1303,19 @@ function loadLocaleTemplates(entry, distDir) {
 	return result;
 }
 /** Resolve parent chain for a layout, returning outer-to-inner order */
-function resolveLayoutChain(layoutId, layoutEntries, templates, localeTemplatesMap) {
+function resolveLayoutChain(layoutId, layoutEntries, getTemplates) {
 	const chain = [];
 	let currentId = layoutId;
 	while (currentId) {
 		const entry = layoutEntries[currentId];
 		if (!entry) break;
+		const { template, localeTemplates } = getTemplates(currentId, entry);
 		chain.push({
 			id: currentId,
-			template: templates[currentId] ?? "",
-			localeTemplates: localeTemplatesMap[currentId],
-			loaders: buildLoaderFns(entry.loaders ?? {})
-		});
-		currentId = entry.parent;
-	}
-	chain.reverse();
-	return chain;
-}
-/** Resolve layout chain with lazy template getters (re-read from disk on each access) */
-function resolveLayoutChainDev(layoutId, layoutEntries, distDir, defaultLocale) {
-	const chain = [];
-	let currentId = layoutId;
-	while (currentId) {
-		const entry = layoutEntries[currentId];
-		if (!entry) break;
-		const layoutTemplatePath = join(distDir, resolveTemplatePath(entry, defaultLocale));
-		const def = {
-			id: currentId,
-			template: "",
-			localeTemplates: entry.templates ? makeLocaleTemplateGetters(entry.templates, distDir) : void 0,
+			template,
+			localeTemplates,
 			loaders: buildLoaderFns(entry.loaders ?? {})
-		};
-		Object.defineProperty(def, "template", {
-			get: () => readFileSync(layoutTemplatePath, "utf-8"),
-			enumerable: true
 		});
-		chain.push(def);
 		currentId = entry.parent;
 	}
 	chain.reverse();
@@ -1077,7 +1406,10 @@ function loadBuildOutput(distDir) {
 	for (const [path, entry] of Object.entries(manifest.routes)) {
 		const template = readFileSync(join(distDir, resolveTemplatePath(entry, defaultLocale)), "utf-8");
 		const loaders = buildLoaderFns(entry.loaders);
-		const layoutChain = entry.layout ? resolveLayoutChain(entry.layout, layoutEntries, layoutTemplates, layoutLocaleTemplates) : [];
+		const layoutChain = entry.layout ? resolveLayoutChain(entry.layout, layoutEntries, (id) => ({
+			template: layoutTemplates[id] ?? "",
+			localeTemplates: layoutLocaleTemplates[id]
+		})) : [];
 		const i18nKeys = mergeI18nKeys(entry, layoutEntries);
 		pages[path] = {
 			template,
@@ -1087,7 +1419,8 @@ function loadBuildOutput(distDir) {
 			headMeta: entry.head_meta,
 			dataId: manifest.data_id,
 			i18nKeys,
-			pageAssets: entry.assets
+			pageAssets: entry.assets,
+			projections: entry.projections
 		};
 	}
 	return pages;
@@ -1102,7 +1435,18 @@ function loadBuildOutputDev(distDir) {
 	for (const [path, entry] of Object.entries(manifest.routes)) {
 		const templatePath = join(distDir, resolveTemplatePath(entry, defaultLocale));
 		const loaders = buildLoaderFns(entry.loaders);
-		const layoutChain = entry.layout ? resolveLayoutChainDev(entry.layout, layoutEntries, distDir, defaultLocale) : [];
+		const layoutChain = entry.layout ? resolveLayoutChain(entry.layout, layoutEntries, (id, layoutEntry) => {
+			const tmplPath = join(distDir, resolveTemplatePath(layoutEntry, defaultLocale));
+			const def = {
+				template: "",
+				localeTemplates: layoutEntry.templates ? makeLocaleTemplateGetters(layoutEntry.templates, distDir) : void 0
+			};
+			Object.defineProperty(def, "template", {
+				get: () => readFileSync(tmplPath, "utf-8"),
+				enumerable: true
+			});
+			return def;
+		}) : [];
 		const localeTemplates = entry.templates ? makeLocaleTemplateGetters(entry.templates, distDir) : void 0;
 		const i18nKeys = mergeI18nKeys(entry, layoutEntries);
 		const page = {
@@ -1112,7 +1456,8 @@ function loadBuildOutputDev(distDir) {
 			layoutChain,
 			dataId: manifest.data_id,
 			i18nKeys,
-			pageAssets: entry.assets
+			pageAssets: entry.assets,
+			projections: entry.projections
 		};
 		Object.defineProperty(page, "template", {
 			get: () => readFileSync(templatePath, "utf-8"),
@@ -1361,26 +1706,58 @@ function createStaticHandler(opts) {
 function watchReloadTrigger(distDir, onReload) {
 	const triggerPath = join(distDir, ".reload-trigger");
 	let watcher = null;
+	let closed = false;
+	let pending = [];
+	const notify = () => {
+		onReload();
+		const batch = pending;
+		pending = [];
+		for (const p of batch) p.resolve();
+	};
+	const nextReload = () => {
+		if (closed) return Promise.reject(/* @__PURE__ */ new Error("watcher closed"));
+		return new Promise((resolve, reject) => {
+			pending.push({
+				resolve,
+				reject
+			});
+		});
+	};
+	const closeAll = () => {
+		closed = true;
+		const batch = pending;
+		pending = [];
+		const err = /* @__PURE__ */ new Error("watcher closed");
+		for (const p of batch) p.reject(err);
+	};
 	try {
-		watcher = watch(triggerPath, () => onReload());
+		watcher = watch(triggerPath, () => notify());
 	} catch {
 		const dirWatcher = watch(distDir, (_event, filename) => {
 			if (filename === ".reload-trigger") {
 				dirWatcher.close();
-				watcher = watch(triggerPath, () => onReload());
-				onReload();
+				watcher = watch(triggerPath, () => notify());
+				notify();
 			}
 		});
-		return { close() {
-			dirWatcher.close();
-			watcher?.close();
-		} };
+		return {
+			close() {
+				dirWatcher.close();
+				watcher?.close();
+				closeAll();
+			},
+			nextReload
+		};
 	}
-	return { close() {
-		watcher?.close();
-	} };
+	return {
+		close() {
+			watcher?.close();
+			closeAll();
+		},
+		nextReload
+	};
 }
 
 //#endregion
-export { SeamError, createChannel, createDevProxy, createHttpHandler, createRouter, createStaticHandler, defaultStrategies, definePage, drainStream, fromAcceptLanguage, fromCallback, fromCookie, fromUrlPrefix, fromUrlQuery, loadBuildOutput, loadBuildOutputDev, loadI18nMessages, loadRpcHashMap, resolveChain, serialize, sseCompleteEvent, sseDataEvent, sseErrorEvent, startChannelWs, t, toWebResponse, watchReloadTrigger };
+export { SeamError, createChannel, createDevProxy, createHttpHandler, createRouter, createStaticHandler, defaultStrategies, definePage, drainStream, fromAcceptLanguage, fromCallback, fromCookie, fromUrlPrefix, fromUrlQuery, loadBuildOutput, loadBuildOutputDev, loadI18nMessages, loadRpcHashMap, resolveChain, serialize, sseCompleteEvent, sseDataEvent, sseDataEventWithId, sseErrorEvent, startChannelWs, t, toWebResponse, watchReloadTrigger };
 //# sourceMappingURL=index.js.map