@vibesdotdev/storage 0.0.1

package/src/server/manifest-route.ts

@@ -0,0 +1,319 @@
+/**
+ * Generic Storage Manifest Route Handler
+ *
+ * SvelteKit-friendly handler that serves the canonical HTTP surface
+ * for `storage/manifest` descriptors via `/api/storage/[id]`.
+ *
+ * The owning app mounts a single `[id]/+server.ts` that calls
+ * `createManifestRouteHandler({ appId, loaders })`. The handler:
+ *
+ *   1. Looks up the descriptor at `params.id` via the runtime
+ *      (`runtime.query('storage/manifest').withId(params.id)`).
+ *   2. Verifies the descriptor declares the running app as its owner
+ *      via `adapterConfig['storage.cloud-api'].ownerApp === appId`.
+ *      Cross-app callers get a 403, which keeps the contract clean
+ *      and prevents accidental data leaks from a borrower app being
+ *      asked to serve data it doesn't own.
+ *   3. Dispatches to a per-descriptor loader the app provides — one
+ *      function per descriptor for `load` / `save` / `delete`.
+ *      Loaders are the bridge between the owning app's local data
+ *      surface (D1 table, libsql, file, etc.) and the manifest's
+ *      wire shape that other apps consume via the `storage.cloud-api`
+ *      adapter.
+ *
+ * Loaders are registered explicitly per descriptor (not auto-discovered)
+ * so the owning app stays in control of validation, authorization, and
+ * the local data path. A descriptor without a loader returns 404.
+ *
+ * Framework-agnostic by design: the handler accepts a structural
+ * `ManifestRouteEvent` matching SvelteKit's `RequestEvent` shape but
+ * doesn't import `@sveltejs/kit`. Apps re-export the produced GET/PUT/
+ * DELETE/HEAD from a `+server.ts` file.
+ */
+
+import { getLogger } from '@vibesdotdev/logging';
+import type { StorageManifestDescriptor } from '../schemas/manifest-descriptor.ts';
+
+const logger = getLogger('storage.manifest-route');
+
+/**
+ * Structural type matching SvelteKit's `RequestEvent`. Keeps this
+ * module framework-agnostic. `locals` stays `unknown` because each
+ * app types its own `App.Locals` interface without an index signature —
+ * loaders cast it as needed.
+ */
+export interface ManifestRouteEvent {
+	params: Partial<Record<string, string>>;
+	request: Request;
+	url: URL;
+	locals: unknown;
+}
+
+export type ManifestOperation = 'read' | 'write' | 'delete';
+
+export interface ManifestLoader<T = unknown> {
+	/** Load the full manifest payload (typically a `Record<id, descriptor>`). */
+	load: (event: ManifestRouteEvent) => Promise<T | null>;
+	/** Optional write path; omit to make the descriptor read-only over HTTP. */
+	save?: (event: ManifestRouteEvent, data: T) => Promise<void>;
+	/** Optional delete path; omit to make the descriptor non-deletable over HTTP. */
+	delete?: (event: ManifestRouteEvent) => Promise<void>;
+	/**
+	 * Optional per-request authorization. Return `false` to send 403.
+	 * Default: allow all (the SvelteKit auth hooks have already gated
+	 * unauthenticated traffic before this handler runs).
+	 */
+	authorize?: (event: ManifestRouteEvent, op: ManifestOperation) => boolean | Promise<boolean>;
+	/** Optional zod schema for validating PUT bodies before the loader sees them. */
+	validate?: (data: unknown) => unknown;
+}
+
+export interface ManifestRouteOptions {
+	/** This app's id; must match `descriptor.adapterConfig['storage.cloud-api'].ownerApp`. */
+	appId: string;
+	/** Map of descriptor id → loader. Missing entries return 404. */
+	loaders: Record<string, ManifestLoader>;
+	/**
+	 * Resolver for the runtime descriptor lookup. Defaults to
+	 * `(id) => getVibesRuntime().query('storage/manifest').withId(id).firstDescriptor()`.
+	 * Override for tests.
+	 */
+	resolveDescriptor?: (id: string) => Promise<StorageManifestDescriptor | null>;
+	/**
+	 * Returns the expected `Authorization: Bearer <token>` for internal
+	 * cross-app calls. When the inbound request's bearer matches, loader
+	 * `authorize` hooks are bypassed and `event.locals.user` is augmented
+	 * with `{ id: 'system', isSuperuser: true, internal: true }` so loaders see
+	 * a system-admin actor. Lets one cloud worker fetch the manifests it
+	 * doesn't own from the owning worker's `[id]/+server.ts` without
+	 * forwarding the end-user's session cookie cross-origin.
+	 */
+	internalServiceToken?: () => string | null | undefined;
+}
+
+interface InternalLocals {
+	user: { id: string; email: string; isSuperuser: true; internal: true };
+}
+
+function tryAuthorizeInternal(
+	event: ManifestRouteEvent,
+	opts: ManifestRouteOptions
+): boolean {
+	const expected = opts.internalServiceToken?.()?.trim();
+	if (!expected) return false;
+	const header = event.request.headers.get('authorization');
+	if (!header || !header.toLowerCase().startsWith('bearer ')) return false;
+	const presented = header.slice(7).trim();
+	if (!presented || presented !== expected) return false;
+	const augmented: InternalLocals = {
+		user: { id: 'system', email: 'system@vibes.internal', isSuperuser: true, internal: true }
+	};
+	(event as { locals: unknown }).locals = augmented;
+	return true;
+}
+
+export type ManifestRouteHandlers = {
+	GET: (event: ManifestRouteEvent) => Promise<Response>;
+	PUT: (event: ManifestRouteEvent) => Promise<Response>;
+	DELETE: (event: ManifestRouteEvent) => Promise<Response>;
+	HEAD: (event: ManifestRouteEvent) => Promise<Response>;
+};
+
+function jsonResponse(status: number, body: unknown): Response {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { 'content-type': 'application/json' }
+	});
+}
+
+async function defaultResolveDescriptor(id: string): Promise<StorageManifestDescriptor | null> {
+	const { getVibesRuntime } = await import('@vibesdotdev/runtime');
+	const runtime = getVibesRuntime();
+	const scoped = runtime.query('storage/manifest').withId(id) as {
+		firstDescriptor?: () => StorageManifestDescriptor | null;
+	};
+	if (typeof scoped.firstDescriptor !== 'function') return null;
+	return scoped.firstDescriptor() ?? null;
+}
+
+function getOwnerApp(descriptor: StorageManifestDescriptor): string | null {
+	const raw = descriptor.adapterConfig?.['storage.cloud-api'];
+	if (!raw || typeof raw !== 'object') return null;
+	const value = (raw as Record<string, unknown>).ownerApp;
+	return typeof value === 'string' && value.length > 0 ? value : null;
+}
+
+async function resolveAndGate(
+	event: ManifestRouteEvent,
+	opts: ManifestRouteOptions
+): Promise<
+	| { ok: true; descriptor: StorageManifestDescriptor; loader: ManifestLoader }
+	| { ok: false; response: Response }
+> {
+	const id = event.params.id;
+	if (!id) return { ok: false, response: jsonResponse(400, { error: 'Missing descriptor id' }) };
+
+	const resolveDescriptor = opts.resolveDescriptor ?? defaultResolveDescriptor;
+	const descriptor = await resolveDescriptor(id);
+	if (!descriptor) {
+		return { ok: false, response: jsonResponse(404, { error: `Unknown storage descriptor: ${id}` }) };
+	}
+
+	const owner = getOwnerApp(descriptor);
+	if (!owner) {
+		return {
+			ok: false,
+			response: jsonResponse(403, {
+				error: `Descriptor '${id}' does not declare ownerApp. Cross-app HTTP access requires adapterConfig['storage.cloud-api'].ownerApp.`
+			})
+		};
+	}
+	if (owner !== opts.appId) {
+		return {
+			ok: false,
+			response: jsonResponse(403, {
+				error: `Descriptor '${id}' is owned by '${owner}', not '${opts.appId}'. Request the owning app's origin.`
+			})
+		};
+	}
+
+	const loader = opts.loaders[id];
+	if (!loader) {
+		return {
+			ok: false,
+			response: jsonResponse(404, {
+				error: `App '${opts.appId}' owns descriptor '${id}' but has not registered a loader for it.`
+			})
+		};
+	}
+
+	return { ok: true, descriptor, loader };
+}
+
+export function createManifestRouteHandler(opts: ManifestRouteOptions): ManifestRouteHandlers {
+	if (!opts.appId) throw new Error('createManifestRouteHandler: appId is required');
+
+	const authorize = async (
+		event: ManifestRouteEvent,
+		loader: ManifestLoader,
+		op: ManifestOperation,
+		internal: boolean
+	): Promise<boolean> => {
+		if (internal) return true;
+		if (!loader.authorize) return true;
+		try {
+			return await loader.authorize(event, op);
+		} catch (error) {
+			logger.warn(`authorize threw for ${event.params.id}`, {
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return false;
+		}
+	};
+
+	const GET = async (event: ManifestRouteEvent): Promise<Response> => {
+		const gated = await resolveAndGate(event, opts);
+		if (!gated.ok) return gated.response;
+
+		const internal = tryAuthorizeInternal(event, opts);
+		if (!(await authorize(event, gated.loader, 'read', internal))) {
+			return jsonResponse(403, { error: 'Forbidden' });
+		}
+
+		try {
+			const value = await gated.loader.load(event);
+			// `{ value }` matches the wire shape consumed by the cloud-api
+			// adapter's fetch client (see `cloud-api.fetch-client.ts:131`,
+			// `data.value` lookup). Keeping this in lockstep with the adapter
+			// means borrower apps get descriptor records back without bespoke
+			// translation per app.
+			return jsonResponse(200, { value });
+		} catch (error) {
+			logger.error(`load failed for ${event.params.id}`, {
+				error: error instanceof Error ? error.message : String(error)
+			});
+			return jsonResponse(500, { error: 'Failed to load manifest data' });
+		}
+	};
+
+	const HEAD = async (event: ManifestRouteEvent): Promise<Response> => {
+		const gated = await resolveAndGate(event, opts);
+		if (!gated.ok) {
+			return new Response(null, { status: gated.response.status });
+		}
+
+		const internal = tryAuthorizeInternal(event, opts);
+		if (!(await authorize(event, gated.loader, 'read', internal))) {
+			return new Response(null, { status: 403 });
+		}
+
+		try {
+			const data = await gated.loader.load(event);
+			return new Response(null, { status: data == null ? 404 : 200 });
+		} catch {
+			return new Response(null, { status: 500 });
+		}
+	};
+
+	const PUT = async (event: ManifestRouteEvent): Promise<Response> => {
+		const gated = await resolveAndGate(event, opts);
+		if (!gated.ok) return gated.response;
+
+		if (!gated.loader.save) {
+			return jsonResponse(405, { error: 'Descriptor is read-only over HTTP' });
+		}
+		const internal = tryAuthorizeInternal(event, opts);
+		if (!(await authorize(event, gated.loader, 'write', internal))) {
+			return jsonResponse(403, { error: 'Forbidden' });
+		}
+
+		let body: unknown;
+		try {
+			body = await event.request.json();
+		} catch {
+			return jsonResponse(400, { error: 'Body must be valid JSON' });
+		}
+
+		// Cloud-api fetch client wraps the payload as `{ value: data }`
+		// (see `cloud-api.fetch-client.ts:144`). Unwrap once on the server
+		// so loaders see the raw manifest record.
+		const unwrappedBody =
+			body && typeof body === 'object' && 'value' in (body as Record<string, unknown>)
+				? (body as Record<string, unknown>).value
+				: body;
+
+		try {
+			const validated = gated.loader.validate ? gated.loader.validate(unwrappedBody) : unwrappedBody;
+			await gated.loader.save(event, validated);
+			return jsonResponse(200, { ok: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			logger.error(`save failed for ${event.params.id}`, { error: message });
+			return jsonResponse(500, { error: 'Failed to save manifest data', detail: message });
+		}
+	};
+
+	const DELETE = async (event: ManifestRouteEvent): Promise<Response> => {
+		const gated = await resolveAndGate(event, opts);
+		if (!gated.ok) return gated.response;
+
+		if (!gated.loader.delete) {
+			return jsonResponse(405, { error: 'Descriptor is not deletable over HTTP' });
+		}
+		const internal = tryAuthorizeInternal(event, opts);
+		if (!(await authorize(event, gated.loader, 'delete', internal))) {
+			return jsonResponse(403, { error: 'Forbidden' });
+		}
+
+		try {
+			await gated.loader.delete(event);
+			return jsonResponse(200, { ok: true });
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			logger.error(`delete failed for ${event.params.id}`, { error: message });
+			return jsonResponse(500, { error: 'Failed to delete manifest data', detail: message });
+		}
+	};
+
+	return { GET, PUT, DELETE, HEAD };
+}

package/src/storage-policy.context.descriptor.ts

@@ -0,0 +1,17 @@
+import { createRuntimeAsset } from "@vibesdotdev/runtime/factory/asset";
+
+/**
+ * Storage Policy Context Descriptor
+ *
+ * Registers the storage/policy context kind with the runtime.
+ * This context provides storage policy resolution and overrides.
+ */
+export default createRuntimeAsset({
+  id: "storage/policy",
+  kind: "context",
+  name: "Storage Policy Context",
+  description:
+    "Provides storage policy resolution and runtime overrides for storage adapters",
+  tags: ["storage", "policy", "context"],
+  enabled: true,
+});

package/src/storage-policy.context.server.ts

@@ -0,0 +1,34 @@
+import type { StoragePolicyContext, StoragePolicy, StoragePolicyOverride } from './policy/types';
+
+/**
+ * Load Storage Policy Context
+ *
+ * Provides the default storage policy context for consumer environments.
+ * The runtime resolves the active adapter through scope-based selection;
+ * this context provides the fallback policy when no manifest-specific
+ * policy is registered.
+ *
+ * Apps can register a custom policy context through the runtime's context
+ * kind to override these defaults (e.g. cloud apps using API adapters).
+ */
+export async function loadStoragePolicyContext(): Promise<StoragePolicyContext> {
+	return {
+		resolveStoragePolicy: async (
+			namespace: string,
+			options?: Record<string, unknown>
+		): Promise<StoragePolicy> => {
+			return {
+				mode: 'persistent',
+				adapter: 'localdb',
+				namespace,
+				...options
+			};
+		},
+
+		resolveStoragePolicyOverrides: async (
+			_context: Record<string, unknown>
+		): Promise<StoragePolicyOverride> => {
+			return {};
+		}
+	};
+}

package/src/storage.plugin.ts

@@ -0,0 +1,264 @@
+/**
+ * Storage Plugin
+ *
+ * Registers storage/adapter, storage/manifest, and storage/record kinds with the runtime.
+ * This is the entry point for the storage module's runtime integration.
+ *
+ * Also registers storage-owned TUI surfaces during activation:
+ * - `storage.explorer` (tui/app)  — interactive storage browser
+ * - `storage.open`     (tui/command) — opens the explorer via `/storage`
+ */
+
+import { createRuntimePlugin, loader } from '@vibesdotdev/runtime';
+import { createRuntimeImplementation } from '@vibesdotdev/runtime/factory/implementation';
+import type { RuntimeImplementationWrapper } from '@vibesdotdev/runtime';
+import storagePolicyContextDescriptor from './storage-policy.context.descriptor';
+import { loadStoragePolicyContext } from './storage-policy.context.server';
+// CLI
+import storageGroup from './cli/storage.cli-group.descriptor.ts';
+import storageSyncGroup from './cli/storage.sync.cli-group.descriptor.ts';
+import storageList from './cli/commands/list/storage.list.cli-command.descriptor.ts';
+import storageSyncPull from './cli/commands/sync/pull/storage.sync.pull.cli-command.descriptor.ts';
+import storageSyncPush from './cli/commands/sync/push/storage.sync.push.cli-command.descriptor.ts';
+import storageSyncResolve from './cli/commands/sync/resolve/storage.sync.resolve.cli-command.descriptor.ts';
+import storageSyncStatus from './cli/commands/sync/status/storage.sync.status.cli-command.descriptor.ts';
+
+// TUI
+import storageExplorerDescriptor from './tui/storage-explorer.descriptor';
+import storageOpenDescriptor from './tui/storage-open.descriptor';
+
+// Docs
+import adaptersDescriptor from './docs/adapters.docs.descriptor';
+import recordsDescriptor from './docs/records.docs.descriptor';
+import syncDescriptor from './docs/sync.docs.descriptor';
+import manifestsDescriptor from './docs/manifests.docs.descriptor';
+
+import type { StorageRecordInterface } from './interfaces/record';
+import {
+	StorageAdapterDescriptorSchema,
+	type StorageAdapterDescriptor
+} from './schemas/adapter-descriptor';
+import { StorageManifestDescriptorSchema } from './schemas/manifest-descriptor';
+import { StorageRecordDescriptorSchema, type StorageRecordDescriptor } from './schemas/record';
+import { SyncBridgeDescriptorSchema } from './schemas/sync-bridge-descriptor';
+import { StorageTransformDescriptorSchema } from './transform/transform-descriptor';
+import { StorageManifest } from './manifest/base';
+import { storageRecordEvents } from './record/events';
+
+const storageRecordDefaultImplementation:
+	| (new (
+			descriptor: StorageRecordDescriptor,
+			context: { runtime: unknown; readonly [contextId: string]: unknown }
+	  ) => StorageRecordInterface<Record<string, unknown>>)
+	| undefined = (() => {
+	if (typeof globalThis !== 'undefined' && 'window' in globalThis) return undefined;
+	try {
+		const runtimeRequire = (
+			import.meta as ImportMeta & {
+				require?: (id: string) => {
+					StorageRecord: new (
+						descriptor: StorageRecordDescriptor,
+						context: { runtime: unknown; readonly [contextId: string]: unknown }
+					) => StorageRecordInterface<Record<string, unknown>>;
+				};
+			}
+		).require;
+		if (typeof runtimeRequire !== 'function') return undefined;
+		return runtimeRequire('./record/base.ts').StorageRecord;
+	} catch {
+		return undefined;
+	}
+})();
+
+// Kind definitions - types are inferred to work with AnyKindDefinition
+const storageAdapterKind = {
+	id: 'storage/adapter',
+	descriptorSchema: StorageAdapterDescriptorSchema,
+
+	/**
+	 * Resolution strategy: Find adapter matching hardware target.
+	 * Prefers persistent adapters over memory when available.
+	 *
+	 * No defaultImplementation — adapter packages register their own descriptor + loader
+	 * via their plugin (e.g. `storageAdapterMemoryPlugin`). Consumers must register at
+	 * least one adapter plugin matching their scope.
+	 */
+	resolve: (candidates: StorageAdapterDescriptor[], scope: { hardware: string }) => {
+		// Filter to candidates matching hardware
+		const matching = candidates.filter(
+			(d) => !d.hardware || d.hardware.length === 0 || d.hardware.includes(scope.hardware)
+		);
+
+		if (matching.length === 0) return undefined;
+
+		// Prefer persistent adapters
+		const persistent = matching.filter((d) => d.persistent);
+		if (persistent.length > 0) return persistent[0];
+
+		// Fall back to any matching
+		return matching[0];
+	}
+};
+
+const storageManifestKind = {
+	id: 'storage/manifest',
+	descriptorSchema: StorageManifestDescriptorSchema,
+	contexts: ['runtime/workspace-path'],
+
+	/**
+	 * Default implementation: StorageManifest
+	 *
+	 * Base class providing document operations (load, save, exists, delete).
+	 * Modules can extend this for custom methods.
+	 * Constructor signature: (descriptor, context) - context provides runtime access.
+	 */
+	defaultImplementation: StorageManifest
+
+	// No custom resolve - manifests are looked up by ID, not scope-based
+};
+
+const storageRecordKind = {
+	id: 'storage/record',
+	descriptorSchema: StorageRecordDescriptorSchema,
+	contexts: ['runtime/workspace-path', 'storage/policy'],
+	...(storageRecordDefaultImplementation
+		? { defaultImplementation: storageRecordDefaultImplementation }
+		: {})
+};
+
+const storageSyncBridgeKind = {
+	id: 'storage/sync-bridge',
+	descriptorSchema: SyncBridgeDescriptorSchema
+
+	// No defaultImplementation — SyncBridge is server/CLI only.
+	// Implementations are registered by the bun loader during discovery.
+};
+
+const storageTransformKind = {
+	id: 'storage/transform',
+	descriptorSchema: StorageTransformDescriptorSchema
+
+	// No defaultImplementation — transforms are plugin-registered per
+	// manifest. The wire shape is `{ fromRow, toRow? }` (see
+	// `./transform/transform-descriptor.ts`). Consumers resolve via
+	// `resolveStorageTransform(runtime, id)`.
+};
+
+function loadTuiImplementation<T>(kind: string, id: string, load: () => Promise<{ default: T }>) {
+	return async () => {
+		const mod = await load();
+		return createRuntimeImplementation({
+			kind,
+			id,
+			implementation: mod.default
+		});
+	};
+}
+
+/**
+ * Storage plugin - registers storage kinds with the runtime.
+ *
+ * Kinds registered:
+ * - `storage/adapter` - Storage backends. Adapter implementations live in sibling
+ *   packages (`storage-adapter-{memory,json,localdb,cloud-api,drizzle}`) and register
+ *   themselves via their own plugins. The storage core does not import them.
+ * - `storage/manifest` - Storable data type definitions
+ * - `storage/record` - Single-table CRUD operations with relations
+ * - `storage/sync-bridge` - Declarative runtime kind ↔ cloud CRUD sync
+ *
+ * @example
+ * ```ts
+ * import { getVibesRuntime } from '@vibesdotdev/runtime/factory/plugin';
+ * import storagePlugin from './storage.plugin';
+ *
+ * const runtime = getVibesRuntime();
+ * await runtime.registerPlugin(storagePlugin);
+ *
+ * // Now you can query storage adapters
+ * const adapter = await runtime.query('storage/adapter')
+ *   .forHardware('consumer')
+ *   .resolve();
+ * ```
+ */
+export default createRuntimePlugin({
+	id: 'storage',
+	name: 'Storage Module',
+	description: 'Interface-driven storage providers for document and repository-style storage',
+	dependencies: ['context'],
+	kinds: [
+		storageAdapterKind,
+		storageManifestKind,
+		storageRecordKind,
+		storageSyncBridgeKind,
+		storageTransformKind
+	],
+
+	descriptors: [
+		storageGroup,
+		storageSyncGroup,
+		storageList,
+		storageSyncPull,
+		storageSyncPush,
+		storageSyncResolve,
+		storageSyncStatus,
+		...storageRecordEvents,
+		adaptersDescriptor,
+		recordsDescriptor,
+		syncDescriptor,
+		manifestsDescriptor
+	],
+
+	loaders: [
+		loader('storage.list', () => import('./cli/commands/list/storage.list.cli-command.impl.js')),
+		loader('storage.sync.push', () =>
+			import('./cli/commands/sync/push/storage.sync.push.cli-command.impl.js')
+		),
+		loader('storage.sync.pull', () =>
+			import('./cli/commands/sync/pull/storage.sync.pull.cli-command.impl.js')
+		),
+		loader('storage.sync.status', () =>
+			import('./cli/commands/sync/status/storage.sync.status.cli-command.impl.js')
+		),
+		loader('storage.sync.resolve', () =>
+			import('./cli/commands/sync/resolve/storage.sync.resolve.cli-command.impl.js')
+		)
+	],
+
+	onRegister: async (runtime) => {
+		// Register storage-owned TUI surfaces only when the tui/* kinds are
+		// available. The standard bootstrap (see apps/cli-bin defaults.ts)
+		// loads tui before storage. Keeping this conditional lets minimal
+		// test setups register storage without spinning up the TUI stack.
+		if (runtime.hasKind('tui/app')) {
+			runtime.registerDescriptor('tui/app', storageExplorerDescriptor);
+			runtime.registerLoader(
+				'tui/app',
+				storageExplorerDescriptor.id,
+				loadTuiImplementation('tui/app', storageExplorerDescriptor.id, () =>
+					import('./tui/storage-explorer.impl.consumer')
+				)
+			);
+		}
+		if (runtime.hasKind('tui/command')) {
+			runtime.registerDescriptor('tui/command', storageOpenDescriptor);
+			runtime.registerLoader(
+				'tui/command',
+				storageOpenDescriptor.id,
+				loadTuiImplementation('tui/command', storageOpenDescriptor.id, () =>
+					import('./tui/storage-open.impl.consumer')
+				)
+			);
+		}
+		// Register storage policy context
+		runtime.registerDescriptor('context', storagePolicyContextDescriptor);
+		runtime.registerLoader('context', storagePolicyContextDescriptor.id, async () =>
+			createRuntimeImplementation({
+				kind: 'context',
+				id: storagePolicyContextDescriptor.id,
+				implementation: {
+					provide: async () => loadStoragePolicyContext()
+				}
+			})
+		);
+	}
+});