@selvajs/server 0.2.0-beta.3 → 0.2.0-beta.4

package/src/definitions/definition-service.ts

@@ -1,247 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import type {
-	IDataProvider,
-	IStorageProvider,
-	RequestContext,
-	DefinitionRecord,
-	DefinitionFileExt,
-	DefinitionVersion,
-	UpdateMetadataInput,
-	UISchema
-} from '@selvajs/platform';
-import { ProviderError, definitionPaths } from '@selvajs/platform';
-
-/**
- * Input passed to `DefinitionService.create`. Carries everything the service
- * needs to assemble a `DefinitionRecord` plus orchestrate the v1 upload.
- *
- * Distinct from `CreateDefinitionInputSchema` exported by
- * `@selvajs/platform/definitions`, which validates the user-facing
- * HTTP body (no guid/ownerId — those are derived server-side).
- */
-export interface CreateDefinitionRecord {
-	guid: string;
-	projectId: string;
-	ownerId: string;
-	fileExt: DefinitionFileExt;
-	originalFilename?: string;
-	displayName: string;
-	description?: string;
-	category?: string;
-	tags?: string[];
-	coverImage?: string;
-	computeServerId?: string;
-}
-
-/**
- * Orchestrates writes that span IDataProvider + IStorageProvider for the
- * spec §6 versioning model. Lives in @selvajs/selva (not @selvajs/platform)
- * because it is application orchestration, not platform contract.
- *
- * Ordering rules:
- *
- *   create — metadata-first, then v1:
- *     1. Write record with status='pending', both pointers null
- *     2. Upload v1 blob to versions/v1.{ext}
- *     3. Insert DefinitionVersion row v1
- *     4. `attachInitialVersion` — atomically set live + draft pointers and
- *        flip status to 'draft' in a single store operation.
- *   Step 4 is one round-trip so a mid-flight failure can't leave a partial
- *   state (status='draft' with null pointers, or status='pending' with
- *   pointers set). If step 2 fails the record stays 'pending' with no
- *   blob and is filtered out of list endpoints by default.
- *
- *   uploadVersion — append-only:
- *     1. Reserve next versionNumber from the record's monotonic counter
- *     2. Upload blob to versions/v{N}.{ext}
- *     3. Insert DefinitionVersion row
- *     4. Advance draft pointer (live unchanged)
- *
- *   publish — pointer flip only, no blob writes.
- *
- *   deleteVersion — store enforces "not referenced by live/draft"; on
- *   success, delete the underlying blob.
- */
-export class DefinitionService {
-	constructor(
-		private data: IDataProvider,
-		private storage: IStorageProvider
-	) {}
-
-	async create(
-		ctx: RequestContext,
-		input: CreateDefinitionRecord,
-		file: Uint8Array,
-		schema: UISchema
-	): Promise<{ record: DefinitionRecord; version: DefinitionVersion }> {
-		const now = new Date().toISOString();
-		const actor = ctx.userId || input.ownerId;
-		const record: DefinitionRecord = {
-			guid: input.guid,
-			projectId: input.projectId,
-			ownerId: input.ownerId,
-			createdBy: actor,
-			updatedBy: actor,
-			displayName: input.displayName,
-			description: input.description,
-			category: input.category,
-			tags: input.tags,
-			coverImage: input.coverImage,
-			computeServerId: input.computeServerId,
-			status: 'pending',
-			solveCount: 0,
-			// v1 is created below with versionNumber 1, so the next upload reserves 2.
-			nextVersionNumber: 2,
-			liveVersionId: null,
-			draftVersionId: null,
-			createdAt: now,
-			updatedAt: now,
-			deletedAt: null
-		};
-
-		// 1. Metadata first — if this fails there's nothing to clean up.
-		await this.data.definitions.create(ctx, record);
-
-		// 2. v1 blob — if this fails the record stays 'pending' and is hidden
-		//    from default list queries.
-		const versionId = randomUUID();
-		const fileKey = definitionPaths.version(input.guid, 1, input.fileExt);
-		await this.storage.put(fileKey, file, 'application/octet-stream');
-
-		// 3. Version row.
-		const version: DefinitionVersion = {
-			id: versionId,
-			definitionId: input.guid,
-			versionNumber: 1,
-			fileExt: input.fileExt,
-			fileKey,
-			originalFilename: input.originalFilename,
-			uploadedBy: actor,
-			uploadedAt: now,
-			schema,
-			schemaExtractedAt: now
-		};
-		await this.data.definitions.createVersion(ctx, version);
-
-		// 4. Atomically point both channels at v1 and flip status='draft' in a
-		//    single store operation. Replaces three separate writes
-		//    (setLiveVersion + setDraftVersion + update) — see the class
-		//    header for why ordering matters here.
-		await this.data.definitions.attachInitialVersion(ctx, input.guid, versionId);
-
-		return {
-			record: { ...record, status: 'draft', liveVersionId: versionId, draftVersionId: versionId },
-			version
-		};
-	}
-
-	/**
-	 * Upload a new version of an existing definition. Writes the blob, inserts
-	 * the version row, and advances the draft pointer. `live` is unchanged —
-	 * use `publish` to promote.
-	 */
-	async uploadVersion(
-		ctx: RequestContext,
-		guid: string,
-		file: Uint8Array,
-		ext: DefinitionFileExt,
-		originalName: string,
-		schema: UISchema,
-		changeNote?: string
-	): Promise<DefinitionVersion> {
-		const existing = await this.data.definitions.get(ctx, guid);
-		if (!existing) throw new ProviderError(`Definition not found: ${guid}`, 404);
-
-		// Reserve the next version number from the record's monotonic counter — NOT
-		// max(existing)+1, which reused a number after delete-latest and collided
-		// the `fileKey` (stale blob served for new content). The counter only ever
-		// advances, so a delete-then-reupload gets a fresh number and fresh key.
-		const next = await this.data.definitions.reserveNextVersionNumber(ctx, guid);
-
-		const versionId = randomUUID();
-		const fileKey = definitionPaths.version(guid, next, ext);
-		await this.storage.put(fileKey, file, 'application/octet-stream');
-
-		const now = new Date().toISOString();
-		const actor = ctx.userId || existing.ownerId;
-		const version: DefinitionVersion = {
-			id: versionId,
-			definitionId: guid,
-			versionNumber: next,
-			fileExt: ext,
-			fileKey,
-			originalFilename: originalName,
-			uploadedBy: actor,
-			uploadedAt: now,
-			changeNote: changeNote?.trim() || undefined,
-			schema,
-			schemaExtractedAt: now
-		};
-		await this.data.definitions.createVersion(ctx, version);
-		await this.data.definitions.setDraftVersion(ctx, guid, versionId);
-
-		return version;
-	}
-
-	/**
-	 * Advance the live channel. If `versionId` is omitted, promotes the
-	 * current draft. Pass an arbitrary version id to roll forward/back —
-	 * spec §6 makes rollback a first-class operation.
-	 */
-	async publish(ctx: RequestContext, guid: string, versionId?: string): Promise<DefinitionVersion> {
-		const existing = await this.data.definitions.get(ctx, guid);
-		if (!existing) throw new ProviderError(`Definition not found: ${guid}`, 404);
-
-		const target = versionId ?? existing.draftVersionId;
-		if (!target) throw new ProviderError('No version to publish', 400);
-
-		const version = await this.data.definitions.getVersion(ctx, target);
-		if (!version || version.definitionId !== guid) {
-			throw new ProviderError(`Version '${target}' not found for this definition`, 404);
-		}
-
-		await this.data.definitions.setLiveVersion(ctx, guid, target);
-		// Flip status to 'published' the first time live moves off pending/draft.
-		if (existing.status === 'draft' || existing.status === 'pending') {
-			await this.data.definitions.update(ctx, guid, { status: 'published' });
-		}
-		return version;
-	}
-
-	async deleteVersion(ctx: RequestContext, guid: string, versionId: string): Promise<void> {
-		const version = await this.data.definitions.getVersion(ctx, versionId);
-		if (!version || version.definitionId !== guid) {
-			throw new ProviderError(`Version '${versionId}' not found for this definition`, 404);
-		}
-		// Store enforces the live/draft reference check; if it throws, blob stays.
-		await this.data.definitions.deleteVersion(ctx, versionId);
-		await this.storage.delete(version.fileKey);
-	}
-
-	async updateMeta(ctx: RequestContext, guid: string, patch: UpdateMetadataInput): Promise<void> {
-		await this.data.definitions.update(ctx, guid, patch);
-	}
-
-	async saveCoverImage(ctx: RequestContext, guid: string, imageData: Uint8Array): Promise<string> {
-		const path = definitionPaths.image(guid);
-		await this.storage.put(path, imageData, 'image/webp');
-		const url = this.storage.getPublicUrl(path);
-		await this.data.definitions.update(ctx, guid, { coverImage: url });
-		return url;
-	}
-
-	async delete(ctx: RequestContext, guid: string): Promise<void> {
-		// CONTRACT (spec §9): metadata is soft-deleted (preserved for audit,
-		// restorable by clearing `deleted_at`); blobs are HARD-deleted. The
-		// record is the audit trail; the blobs are storage cost.
-		//
-		// Order matters. Metadata first so the API immediately hides the
-		// record (RLS / `deleted_at IS NULL` filter). If the blob wipe then
-		// fails, the orphan storage is unreachable through the API — a
-		// retention sweep can clean it up later. The reverse order leaves a
-		// window where the record is still alive but its blobs are gone — a
-		// 404 source for any in-flight reader.
-		await this.data.definitions.delete(ctx, guid);
-		await this.storage.deletePrefix(definitionPaths.prefix(guid));
-	}
-}

package/src/definitions/index.ts

@@ -1,22 +0,0 @@
-// Definitions server slice — the write orchestration (DefinitionService), the
-// compute-schema extraction/validation gate, and the render loader. All
-// composition-root wiring (stores, warm-client cache, server resolution) is
-// injected; access gating stays with the calling app.
-
-export { DefinitionService, type CreateDefinitionRecord } from './definition-service.js';
-
-export {
-	fetchSchemaFromCompute,
-	assertSupportedSchemaVersion,
-	SchemaExtractionError
-} from './schema-extraction.js';
-
-export {
-	createDefinitionLoader,
-	DefinitionLoadError,
-	type DefinitionChannel,
-	type DefinitionLoader,
-	type DefinitionLoaderDeps,
-	type DefinitionLoadErrorKind,
-	type LoadedDefinition
-} from './load-for-render.js';

package/src/definitions/load-for-render.ts

@@ -1,272 +0,0 @@
-// Loader for "given a definition record, produce everything the client needs to
-// render its form and solve it": version resolution, blob fetch, compute-server
-// resolution, schema fetch (with the ADR 0005 staleness check), default merging.
-//
-// Access gating is intentionally NOT done here — the calling route decides
-// whether `ctx` is allowed to load this definition, since gates differ across
-// routes (project membership, segment ownership, share-token, admin override).
-//
-// Everything stateful is injected (`DefinitionLoaderDeps`): stores, server
-// resolution, the warm-client cache, and the schema fetcher — so any app built
-// on the engine can wire its own composition root.
-
-import type { GrasshopperClient } from '@selvajs/compute/grasshopper';
-import { UI_SCHEMA_VERSION, type UISchema } from '@selvajs/schemas';
-import type {
-	ComputeServerConfig,
-	DefinitionRecord,
-	DefinitionVersion,
-	IDefinitionStore,
-	IProjectStore,
-	IStorageProvider,
-	RequestContext
-} from '@selvajs/platform';
-import { fetchSchemaFromCompute } from './schema-extraction.js';
-
-export type DefinitionChannel = 'live' | 'draft';
-
-export interface LoadedDefinition {
-	version: DefinitionVersion;
-	definitionSource: Uint8Array;
-	computeServer: ComputeServerConfig;
-	schema: UISchema;
-}
-
-/**
- * Classified failure modes so callers can map to appropriate HTTP status:
- *   - 'data':           record references a version/blob that isn't there. (400)
- *   - 'missing-config': no compute server resolvable for this org/definition. (503)
- *   - 'connect':        compute server is configured but unreachable. (503)
- *   - 'schema':         compute responded but IO/schema phase failed. (500)
- */
-export type DefinitionLoadErrorKind = 'data' | 'missing-config' | 'connect' | 'schema';
-
-export class DefinitionLoadError extends Error {
-	constructor(
-		public readonly kind: DefinitionLoadErrorKind,
-		message: string,
-		public readonly cause?: unknown
-	) {
-		super(message);
-		this.name = 'DefinitionLoadError';
-	}
-}
-
-export interface DefinitionLoaderDeps {
-	storage: Pick<IStorageProvider, 'get'>;
-	definitions: Pick<IDefinitionStore, 'getVersion' | 'setVersionSchema'>;
-	projects: Pick<IProjectStore, 'getProject'>;
-	/** §3 resolution order: definition pin → org default override → global default. */
-	resolveServer: (
-		ctx: RequestContext,
-		orgId: string | null,
-		opts: { definitionPin: string | null }
-	) => Promise<ComputeServerConfig>;
-	/** Shared warm-client cache (ADR 0004: keyed by server id, definition-guid affinity header). */
-	getClient: (
-		server: ComputeServerConfig,
-		opts: { definitionGuid: string }
-	) => Promise<{ client: GrasshopperClient }>;
-	/** Schema extraction; defaults to `fetchSchemaFromCompute`. Injectable for tests. */
-	fetchSchema?: (bytes: Uint8Array, server: ComputeServerConfig) => Promise<UISchema>;
-	/**
-	 * Verbose IO diagnostics — when set, an unhealthy IO result (empty inputs /
-	 * parse / load errors) also dumps the raw /io wire shape so
-	 * casing/serialization mismatches are visible.
-	 */
-	computeDebug?: boolean;
-	/** Diagnostic sink; defaults to `console.warn`. */
-	onWarn?: (message: string, detail?: string) => void;
-}
-
-export type DefinitionLoader = (
-	ctx: RequestContext,
-	record: DefinitionRecord,
-	channel: DefinitionChannel,
-	explicitVersionId?: string | null
-) => Promise<LoadedDefinition>;
-
-/**
- * Build a definition loader over the injected stores/compute wiring.
- *
- * The returned function loads a definition's version blob + schema (with
- * merged compute defaults). By default it resolves the `channel` pointer
- * (live/draft); pass `explicitVersionId` to render an arbitrary historical
- * version instead — the caller must gate that behind edit permission
- * (editor-only, like the draft channel). Throws `DefinitionLoadError` for
- * classified failures so the caller can translate to HTTP status codes.
- */
-export function createDefinitionLoader(deps: DefinitionLoaderDeps): DefinitionLoader {
-	const {
-		storage,
-		definitions,
-		projects,
-		resolveServer,
-		getClient,
-		fetchSchema = fetchSchemaFromCompute,
-		computeDebug = false,
-		onWarn = (message, detail) => (detail ? console.warn(message, detail) : console.warn(message))
-	} = deps;
-
-	return async function loadDefinitionForRender(ctx, record, channel, explicitVersionId) {
-		const versionId =
-			explicitVersionId ?? (channel === 'draft' ? record.draftVersionId : record.liveVersionId);
-		if (!versionId)
-			throw new DefinitionLoadError(
-				'data',
-				`Definition '${record.guid}' has no ${channel} version`
-			);
-
-		const version = await definitions.getVersion(ctx, versionId);
-		if (!version) throw new DefinitionLoadError('data', `version missing for '${record.guid}'`);
-		// An explicitly requested version must belong to this definition.
-		if (version.definitionId !== record.guid)
-			throw new DefinitionLoadError('data', `version does not belong to '${record.guid}'`);
-
-		const definitionSource = await storage.get(version.fileKey);
-		if (!definitionSource)
-			throw new DefinitionLoadError(
-				'data',
-				`Definition file for '${record.guid}' not found on disk`
-			);
-
-		const project = await projects.getProject(ctx, record.projectId);
-		let computeServer: ComputeServerConfig;
-		try {
-			computeServer = await resolveServer(ctx, project?.orgId ?? null, {
-				definitionPin: record.computeServerId ?? null
-			});
-		} catch (err) {
-			throw new DefinitionLoadError(
-				'missing-config',
-				'No compute server configured for this definition',
-				err
-			);
-		}
-
-		// Only the client is used here (getIO); the entry's solve scheduler rides
-		// along unused.
-		let client: GrasshopperClient;
-		try {
-			client = (await getClient(computeServer, { definitionGuid: record.guid })).client;
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			throw new DefinitionLoadError(
-				'connect',
-				`Failed to connect to Rhino Compute server: ${message}`,
-				err
-			);
-		}
-
-		try {
-			// Prefer the schema cached on the version row (extracted + validated at
-			// upload) — but ONLY when its format version matches the app's. The
-			// stored schema is a disposable cache (ADR 0005): on a version mismatch
-			// (or a pre-caching row with no schema at all) re-extract from compute,
-			// whose C# SchemaMigrator emits the current format — the web side never
-			// migrates schemas itself. `getIO` is always needed to merge compute
-			// default values into the schema, cached or not.
-			const cachedSchema = version.schema as UISchema | undefined;
-			const freshCache =
-				cachedSchema && cachedSchema.schemaVersion === UI_SCHEMA_VERSION ? cachedSchema : null;
-			const [definition, fetchedSchema] = await Promise.all([
-				client.getIO(definitionSource),
-				freshCache ? Promise.resolve(freshCache) : fetchSchema(definitionSource, computeServer)
-			]);
-
-			// Persist the refreshed schema back onto the version row (best-effort —
-			// a viewer context may lack write access; the next editor render or the
-			// solve-time backfill will land it). Only when the re-extracted schema
-			// is at the app's current version: persisting an older format (compute
-			// plugin behind the app) would just go stale again next render.
-			if (!freshCache && fetchedSchema.schemaVersion === UI_SCHEMA_VERSION) {
-				definitions.setVersionSchema(ctx, version.id, fetchedSchema).catch((err) => {
-					onWarn(
-						`[loadForRender] schema cache refresh failed for version ${version.id}: ` +
-							`${err instanceof Error ? err.message : String(err)}`
-					);
-				});
-			}
-
-			if (!definition) {
-				throw new Error(`Failed to get definition IO — server returned undefined`);
-			}
-
-			// Surface IO health when something looks off: zero inputs, or the compute
-			// layer reported parse/load problems (e.g. an empty ValueList because its
-			// backing GH component didn't resolve → "Missing Definition Objects", or a
-			// PascalCase /io response the parser silently dropped to []). On a problem
-			// we also fetch the raw IO so the un-parsed wire shape is in the logs.
-			// Always-on warn (cheap, only fires on the unhappy path); the verbose raw
-			// dump is gated on `computeDebug`.
-			const ioParseErrors = (definition as { parseErrors?: unknown[] }).parseErrors ?? [];
-			const ioLoadErrors = (definition as { loadErrors?: unknown[] }).loadErrors ?? [];
-			const ioLooksBroken =
-				definition.inputs.length === 0 || ioParseErrors.length > 0 || ioLoadErrors.length > 0;
-			if (ioLooksBroken) {
-				onWarn(
-					`[loadForRender] IO health for '${record.guid}':`,
-					JSON.stringify({
-						inputCount: definition.inputs.length,
-						outputCount: definition.outputs?.length,
-						parseErrors: ioParseErrors,
-						loadErrors: ioLoadErrors,
-						loadWarnings: (definition as { loadWarnings?: unknown }).loadWarnings
-					})
-				);
-				if (computeDebug) {
-					const rawIO = await client
-						.getRawIO(definitionSource)
-						.catch((e) => ({ error: String(e) }));
-					onWarn('[loadForRender] raw /io:', JSON.stringify(rawIO).slice(0, 3000));
-				}
-			}
-
-			return {
-				version,
-				definitionSource,
-				computeServer,
-				schema: mergeComputeDefaults(fetchedSchema, definition.inputs)
-			};
-		} catch (err) {
-			if (err instanceof DefinitionLoadError) throw err;
-			const message = err instanceof Error ? err.message : String(err);
-			throw new DefinitionLoadError('schema', message, err);
-		}
-	};
-}
-
-// Merge default values from Compute definition into schema inputs.
-// Colors come back as "r,g,b" or "a,r,g,b" strings — convert to hex so the
-// color picker can consume them directly.
-function mergeComputeDefaults(
-	schema: UISchema,
-	computeInputs: Array<{ id?: string; paramType?: string; default?: unknown }>
-): UISchema {
-	const byParamId = new Map(computeInputs.map((input) => [input.id, input]));
-
-	return {
-		...schema,
-		inputs: schema.inputs.map((schemaInput) => {
-			const computeInput = byParamId.get(schemaInput.id);
-
-			if (computeInput?.paramType === 'Color' && computeInput.default !== undefined) {
-				const toHex = (value: number) => value.toString(16).padStart(2, '0');
-				const parts = String(computeInput.default)
-					.split(',')
-					.map((s) => parseInt(s.trim(), 10));
-
-				if (parts.length === 3) {
-					computeInput.default = `#${toHex(parts[0])}${toHex(parts[1])}${toHex(parts[2])}`;
-				} else if (parts.length === 4) {
-					computeInput.default = `#${toHex(parts[1])}${toHex(parts[2])}${toHex(parts[3])}`;
-				}
-			}
-
-			if (computeInput && computeInput.default !== undefined) {
-				return { ...schemaInput, default: computeInput.default };
-			}
-			return schemaInput;
-		})
-	};
-}

package/src/definitions/schema-extraction.ts

@@ -1,117 +0,0 @@
-// Shared compute-schema extraction. One implementation used by:
-//   - upload routes (validate-and-cache gate — no upload without a valid schema)
-//   - the render path (falls back to live extraction for un-cached or stale
-//     versions; see load-for-render.ts and ADR 0005)
-//   - the temporary solve-time backfill bridge (see the app's specs/SchemaCaching.md)
-//
-// Extraction IS validation: a `.gh` with no valid "Schema" output, or an
-// unreachable compute server, throws here and the caller rejects the upload.
-
-import { camelcaseKeys } from '@selvajs/compute/core';
-import { UI_SCHEMA_VERSION, type UISchema } from '@selvajs/schemas';
-import type { ComputeServerConfig } from '@selvajs/platform';
-
-/** Thrown when compute is reachable but the definition yields no usable schema. */
-export class SchemaExtractionError extends Error {
-	constructor(
-		public readonly kind: 'unreachable' | 'invalid' | 'unsupported',
-		message: string
-	) {
-		super(message);
-		this.name = 'SchemaExtractionError';
-	}
-}
-
-function parseSemver(version: string): [number, number, number] | null {
-	const m = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
-	return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : null;
-}
-
-/**
- * Plugin↔app compat gate: reject a schema emitted by a NEWER plugin than this
- * app was built against — its shape may contain constructs the renderer does
- * not know. Older (or missing) versions pass: the compute-side C# migrator
- * always emits its own current version, and an older shape only lacks
- * optional additions.
- */
-export function assertSupportedSchemaVersion(schema: UISchema): void {
-	const version = schema.schemaVersion;
-	if (!version) return; // pre-2.12.0 plugin — older than the app, fine
-	const extracted = parseSemver(version);
-	const supported = parseSemver(UI_SCHEMA_VERSION);
-	if (!extracted || !supported) return;
-	const newer =
-		extracted[0] > supported[0] ||
-		(extracted[0] === supported[0] &&
-			(extracted[1] > supported[1] ||
-				(extracted[1] === supported[1] && extracted[2] > supported[2])));
-	if (newer) {
-		throw new SchemaExtractionError(
-			'unsupported',
-			`This definition was authored with a newer Selva plugin (schema format ${version}); ` +
-				`this server supports schema format ≤ ${UI_SCHEMA_VERSION}. Update the server, or ` +
-				`re-save the definition with a matching plugin version.`
-		);
-	}
-}
-
-/**
- * Fetch the UI schema from Rhino Compute's `/grasshopper/schema` endpoint (no
- * solve required). Throws `SchemaExtractionError` so callers can map to the
- * right HTTP status (503 unreachable / 422 invalid or unsupported).
- */
-export async function fetchSchemaFromCompute(
-	definitionBytes: Uint8Array,
-	server: ComputeServerConfig
-): Promise<UISchema> {
-	const schemaUrl = new URL('/grasshopper/schema', server.serverUrl).toString();
-
-	const formData = new FormData();
-	const blob = new Blob([new Uint8Array(definitionBytes)], { type: 'application/octet-stream' });
-	formData.append('file', blob, 'definition.gh');
-
-	const headers: Record<string, string> = {};
-	if (server.apiKey) {
-		headers['RhinoComputeKey'] = server.apiKey;
-	}
-
-	let response: Response;
-	try {
-		response = await fetch(schemaUrl, { method: 'POST', headers, body: formData });
-	} catch (err) {
-		throw new SchemaExtractionError(
-			'unreachable',
-			`Compute server is unreachable: ${err instanceof Error ? err.message : String(err)}`
-		);
-	}
-
-	if (!response.ok) {
-		throw new SchemaExtractionError(
-			'unreachable',
-			`Schema endpoint returned ${response.status}: ${response.statusText}`
-		);
-	}
-
-	// Compute returns [{ FileName, Schemas }] with PascalCase wrapper keys only.
-	// The schema contents are already camelCase from our C# serializer, so we only
-	// need a shallow camelcase per wrapper to normalize FileName→fileName,
-	// Schemas→schemas (shallow camelcaseKeys is a no-op on arrays, so each
-	// element is normalized individually). deep:true would mangle user-defined
-	// option names (e.g. "Display3d" → "display3d").
-	const raw = await response.json();
-	const results = (Array.isArray(raw) ? raw : [raw]).map((r) => camelcaseKeys(r)) as {
-		schemas: UISchema[];
-	}[];
-	const schemas = results.flatMap((r) => r.schemas ?? []);
-
-	if (schemas.length === 0) {
-		throw new SchemaExtractionError(
-			'invalid',
-			'No schemas found in definition.\n\n' +
-				'In Grasshopper, verify a Context Bake component with the output name "Schema" is present and wired to the solver.'
-		);
-	}
-
-	assertSupportedSchemaVersion(schemas[0]);
-	return schemas[0];
-}