@vibesdotdev/storage 0.0.2 → 1.0.0-rc.4

package/src/server/manifest-route.ts

@@ -1,319 +0,0 @@
-/**
- * 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

@@ -1,17 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,264 +0,0 @@
-/**
- * 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()
-				}
-			})
-		);
-	}
-});