dineway 0.1.3

package/dist/placeholder-B3knXwNc.mjs

@@ -0,0 +1,267 @@
+import { encode } from "blurhash";
+import { imageSize } from "image-size";
+
+//#region src/media/normalize.ts
+const INTERNAL_MEDIA_PREFIX = "/_dineway/api/media/file/";
+const URL_PATTERN = /^https?:\/\//;
+/**
+* Normalize a media field value into a consistent MediaValue shape.
+*
+* - `null`/`undefined` → `null`
+* - Bare URL string → `{ provider: "external", id: "", src: url }`
+* - Bare internal media URL → resolved via local provider's `get()`
+* - Object with `provider` + `id` → enriched with missing fields from provider
+*/
+async function normalizeMediaValue(value, getProvider) {
+	if (value == null) return null;
+	if (typeof value === "string") return normalizeStringUrl(value, getProvider);
+	if (!isRecord(value)) return null;
+	if (!("id" in value) && !("src" in value)) return null;
+	const provider = (typeof value.provider === "string" ? value.provider : void 0) || "local";
+	const id = typeof value.id === "string" ? value.id : "";
+	if (provider === "external") return recordToMediaValue(value);
+	const result = {
+		...recordToMediaValue(value),
+		provider
+	};
+	if (provider === "local") delete result.src;
+	const needsDimensions = result.width == null || result.height == null;
+	const needsStorageKey = provider === "local" && !result.meta?.storageKey;
+	const needsFileInfo = !result.mimeType || !result.filename;
+	if (!(needsDimensions || needsStorageKey || needsFileInfo) || !id) return result;
+	const mediaProvider = getProvider(provider);
+	if (!mediaProvider?.get) return result;
+	let providerItem;
+	try {
+		providerItem = await mediaProvider.get(id);
+	} catch {
+		return result;
+	}
+	if (!providerItem) return result;
+	return mergeProviderData(result, providerItem);
+}
+function normalizeStringUrl(url, getProvider) {
+	if (url.startsWith(INTERNAL_MEDIA_PREFIX)) return resolveInternalUrl(url, getProvider);
+	if (URL_PATTERN.test(url)) return Promise.resolve({
+		provider: "external",
+		id: "",
+		src: url
+	});
+	return Promise.resolve({
+		provider: "external",
+		id: "",
+		src: url
+	});
+}
+async function resolveInternalUrl(url, getProvider) {
+	const storageKey = url.slice(25);
+	const localProvider = getProvider("local");
+	if (!localProvider?.get) return {
+		provider: "external",
+		id: "",
+		src: url
+	};
+	let item;
+	try {
+		item = await localProvider.get(storageKey);
+	} catch {
+		return {
+			provider: "external",
+			id: "",
+			src: url
+		};
+	}
+	if (!item) return {
+		provider: "external",
+		id: "",
+		src: url
+	};
+	return {
+		provider: "local",
+		id: item.id,
+		filename: item.filename,
+		mimeType: item.mimeType,
+		width: item.width,
+		height: item.height,
+		alt: item.alt,
+		meta: item.meta
+	};
+}
+/**
+* Merge provider data into an existing MediaValue, preserving caller-supplied fields.
+* Caller `alt` takes priority over provider `alt` (per-usage, not per-image).
+*/
+function mergeProviderData(existing, item) {
+	const result = { ...existing };
+	if (result.width == null && item.width != null) result.width = item.width;
+	if (result.height == null && item.height != null) result.height = item.height;
+	if (!result.filename && item.filename) result.filename = item.filename;
+	if (!result.mimeType && item.mimeType) result.mimeType = item.mimeType;
+	if (!result.alt && item.alt) result.alt = item.alt;
+	if (item.meta) result.meta = {
+		...item.meta,
+		...result.meta
+	};
+	return result;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Extract known MediaValue fields from a runtime-checked record.
+* Avoids unsafe `as MediaValue` cast by reading each property explicitly.
+*/
+function recordToMediaValue(obj) {
+	const result = { id: typeof obj.id === "string" ? obj.id : "" };
+	if (typeof obj.provider === "string") result.provider = obj.provider;
+	if (typeof obj.src === "string") result.src = obj.src;
+	if (typeof obj.previewUrl === "string") result.previewUrl = obj.previewUrl;
+	if (typeof obj.filename === "string") result.filename = obj.filename;
+	if (typeof obj.mimeType === "string") result.mimeType = obj.mimeType;
+	if (typeof obj.width === "number") result.width = obj.width;
+	if (typeof obj.height === "number") result.height = obj.height;
+	if (typeof obj.alt === "string") result.alt = obj.alt;
+	if (isRecord(obj.meta)) result.meta = obj.meta;
+	return result;
+}
+
+//#endregion
+//#region src/media/placeholder.ts
+/**
+* Image Placeholder Generation
+*
+* Generates blurhash and dominant color from image buffers for LQIP support.
+* Decodes images via jpeg-js (pure JS) and upng-js (pure JS, uses pako for
+* deflate). No Node-specific dependencies — works in Workers and Node SSR.
+*/
+const SUPPORTED_TYPES = {
+	"image/jpeg": "jpeg",
+	"image/jpg": "jpeg",
+	"image/png": "png"
+};
+/** Max width for blurhash input. Encode is O(w*h*components), so downsample first. */
+const MAX_ENCODE_WIDTH = 32;
+/** Max decoded RGBA size (32 MB). Images exceeding this skip placeholder generation. */
+const MAX_DECODED_BYTES = 32 * 1024 * 1024;
+/**
+* Decode a JPEG buffer into raw RGBA pixel data.
+*/
+async function decodeJpeg(buffer) {
+	const { decode } = await import("jpeg-js");
+	const result = decode(buffer, { useTArray: true });
+	return {
+		width: result.width,
+		height: result.height,
+		data: result.data
+	};
+}
+/**
+* Decode a PNG buffer into raw RGBA pixel data.
+* Uses upng-js (pure JS with pako deflate) — no Node zlib dependency.
+*/
+async function decodePng(buffer) {
+	const UPNG = (await import("upng-js")).default;
+	const img = UPNG.decode(buffer.buffer);
+	const frames = UPNG.toRGBA8(img);
+	const rgba = new Uint8Array(frames[0]);
+	return {
+		width: img.width,
+		height: img.height,
+		data: rgba
+	};
+}
+/**
+* Extract the dominant color from RGBA pixel data.
+* Simple average of all non-transparent pixels.
+*/
+function extractDominantColor(data, width, height) {
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	let count = 0;
+	const len = width * height * 4;
+	for (let i = 0; i < len; i += 4) {
+		if (data[i + 3] < 128) continue;
+		r += data[i];
+		g += data[i + 1];
+		b += data[i + 2];
+		count++;
+	}
+	if (count === 0) return "rgb(0,0,0)";
+	return `rgb(${Math.round(r / count)},${Math.round(g / count)},${Math.round(b / count)})`;
+}
+/**
+* Read image dimensions from headers without decoding pixel data.
+*/
+function getImageDimensions(buffer) {
+	try {
+		const result = imageSize(buffer);
+		if (result.width != null && result.height != null) return {
+			width: result.width,
+			height: result.height
+		};
+		return null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Generate blurhash and dominant color from an image buffer.
+* Returns null for non-image MIME types or on failure.
+*
+* @param dimensions - Optional pre-known dimensions. Used as a fallback when
+*   image-size cannot parse the buffer (e.g. truncated headers). When the
+*   decoded size (width * height * 4) exceeds MAX_DECODED_BYTES, placeholder
+*   generation is skipped to avoid OOM on memory-constrained runtimes.
+*/
+async function generatePlaceholder(buffer, mimeType, dimensions) {
+	const format = SUPPORTED_TYPES[mimeType];
+	if (!format) return null;
+	try {
+		const dims = getImageDimensions(buffer) ?? dimensions;
+		if (dims && dims.width * dims.height * 4 > MAX_DECODED_BYTES) return null;
+		const { width, height, data } = format === "jpeg" ? await decodeJpeg(buffer) : await decodePng(buffer);
+		if (width === 0 || height === 0) return null;
+		let encodePixels;
+		let encodeWidth;
+		let encodeHeight;
+		if (width > MAX_ENCODE_WIDTH) {
+			const scale = MAX_ENCODE_WIDTH / width;
+			encodeWidth = MAX_ENCODE_WIDTH;
+			encodeHeight = Math.max(1, Math.round(height * scale));
+			encodePixels = downsample(data, width, height, encodeWidth, encodeHeight);
+		} else {
+			encodeWidth = width;
+			encodeHeight = height;
+			encodePixels = new Uint8ClampedArray(data.buffer, data.byteOffset, data.byteLength);
+		}
+		return {
+			blurhash: encode(encodePixels, encodeWidth, encodeHeight, 4, 3),
+			dominantColor: extractDominantColor(data, width, height)
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Nearest-neighbor downsample of RGBA pixel data.
+*/
+function downsample(src, srcW, srcH, dstW, dstH) {
+	const dst = new Uint8ClampedArray(dstW * dstH * 4);
+	for (let y = 0; y < dstH; y++) {
+		const srcY = Math.floor(y * srcH / dstH);
+		for (let x = 0; x < dstW; x++) {
+			const srcX = Math.floor(x * srcW / dstW);
+			const srcIdx = (srcY * srcW + srcX) * 4;
+			const dstIdx = (y * dstW + x) * 4;
+			dst[dstIdx] = src[srcIdx];
+			dst[dstIdx + 1] = src[srcIdx + 1];
+			dst[dstIdx + 2] = src[srcIdx + 2];
+			dst[dstIdx + 3] = src[srcIdx + 3];
+		}
+	}
+	return dst;
+}
+
+//#endregion
+export { normalizeMediaValue as n, generatePlaceholder as t };

package/dist/placeholder-bOx1xCTY.d.mts

@@ -0,0 +1,283 @@
+//#region src/media/types.d.ts
+/**
+ * Media Provider Types
+ *
+ * Media providers are pluggable sources for browsing, uploading, and embedding media.
+ * They enable integration with external services (Unsplash, Cloudinary, Mux, etc.)
+ * alongside the built-in local media library.
+ */
+/**
+ * Serializable media provider configuration descriptor
+ * Returned by provider config functions (e.g., unsplash(), mux())
+ */
+interface MediaProviderDescriptor<TConfig = Record<string, unknown>> {
+  /** Unique identifier, used in MediaValue.provider */
+  id: string;
+  /** Display name for admin UI */
+  name: string;
+  /** Icon for tab UI (emoji or URL) */
+  icon?: string;
+  /** Module path exporting createMediaProvider function */
+  entrypoint: string;
+  /** Optional React component module for custom admin UI */
+  adminModule?: string;
+  /** Capability flags determine UI behavior */
+  capabilities: MediaProviderCapabilities;
+  /** Serializable config passed to createMediaProvider at runtime */
+  config: TConfig;
+}
+/**
+ * Provider capabilities determine what UI elements to show
+ */
+interface MediaProviderCapabilities {
+  /** Can list/browse media */
+  browse: boolean;
+  /** Supports text search */
+  search: boolean;
+  /** Can upload new media */
+  upload: boolean;
+  /** Can delete media */
+  delete: boolean;
+}
+/**
+ * Options for listing media
+ */
+interface MediaListOptions {
+  /** Pagination cursor */
+  cursor?: string;
+  /** Max items to return (default 20) */
+  limit?: number;
+  /** Search query (if capabilities.search is true) */
+  query?: string;
+  /** Filter by MIME type prefix, e.g., "image/", "video/" */
+  mimeType?: string;
+}
+/**
+ * Result from listing media
+ */
+interface MediaListResult {
+  items: MediaProviderItem[];
+  nextCursor?: string;
+}
+/**
+ * A media item as returned by a provider
+ * This is the provider's view of the item, before it's selected
+ */
+interface MediaProviderItem {
+  /** Provider-specific ID */
+  id: string;
+  /** Original filename */
+  filename: string;
+  /** MIME type */
+  mimeType: string;
+  /** File size in bytes (if known) */
+  size?: number;
+  /** Dimensions (for images/video) */
+  width?: number;
+  height?: number;
+  /** Accessibility text */
+  alt?: string;
+  /** Preview URL for admin UI thumbnail */
+  previewUrl?: string;
+  /** Provider-specific metadata */
+  meta?: Record<string, unknown>;
+}
+/**
+ * Input for uploading media
+ */
+interface MediaUploadInput {
+  file: File;
+  filename: string;
+  alt?: string;
+}
+/**
+ * Options for generating embed
+ */
+interface EmbedOptions {
+  /** Desired width (provider may use for optimization) */
+  width?: number;
+  /** Desired height */
+  height?: number;
+  /** Image format preference */
+  format?: "webp" | "avif" | "jpeg" | "png" | "auto";
+}
+/**
+ * Embed result types
+ */
+type EmbedResult = ImageEmbed | VideoEmbed | AudioEmbed | ComponentEmbed;
+interface ImageEmbed {
+  type: "image";
+  src: string;
+  srcset?: string;
+  sizes?: string;
+  width?: number;
+  height?: number;
+  alt?: string;
+  /** Base URL without transforms, for responsive image generation */
+  cdnBaseUrl?: string;
+  /** For providers with URL-based transforms (Cloudinary, imgix) */
+  getSrc?: (opts: {
+    width?: number;
+    height?: number;
+    format?: string;
+  }) => string;
+}
+interface VideoEmbed {
+  type: "video";
+  /** Single source URL */
+  src?: string;
+  /** Multiple sources for format fallback */
+  sources?: Array<{
+    src: string;
+    type: string;
+  }>;
+  /** Poster/thumbnail image */
+  poster?: string;
+  width?: number;
+  height?: number;
+  /** Player controls */
+  controls?: boolean;
+  autoplay?: boolean;
+  muted?: boolean;
+  loop?: boolean;
+  playsinline?: boolean;
+  preload?: "none" | "metadata" | "auto";
+  crossorigin?: "anonymous" | "use-credentials";
+}
+interface AudioEmbed {
+  type: "audio";
+  src?: string;
+  sources?: Array<{
+    src: string;
+    type: string;
+  }>;
+  controls?: boolean;
+  autoplay?: boolean;
+  muted?: boolean;
+  loop?: boolean;
+  preload?: "none" | "metadata" | "auto";
+}
+interface ComponentEmbed {
+  type: "component";
+  /** Package to import from, e.g., "@mux/player-react" */
+  package: string;
+  /** Named export (default export if not specified) */
+  export?: string;
+  /** Props to pass to the component */
+  props: Record<string, unknown>;
+}
+/**
+ * Options for thumbnail generation
+ */
+interface ThumbnailOptions {
+  /** Desired width */
+  width?: number;
+  /** Desired height */
+  height?: number;
+}
+/**
+ * Runtime media provider interface
+ * Implemented by provider entrypoints
+ */
+interface MediaProvider {
+  /**
+   * List/search media items
+   */
+  list(options: MediaListOptions): Promise<MediaListResult>;
+  /**
+   * Get a single item by ID (optional, for refresh/validation)
+   */
+  get?(id: string): Promise<MediaProviderItem | null>;
+  /**
+   * Upload new media (if capabilities.upload is true)
+   */
+  upload?(input: MediaUploadInput): Promise<MediaProviderItem>;
+  /**
+   * Delete media (if capabilities.delete is true)
+   */
+  delete?(id: string): Promise<void>;
+  /**
+   * Get embed information for rendering this media item
+   * Called at runtime when rendering content
+   */
+  getEmbed(value: MediaValue, options?: EmbedOptions): Promise<EmbedResult> | EmbedResult;
+  /**
+   * Get a thumbnail URL for admin display
+   * For images: returns a resized image URL
+   * For videos: returns a poster/thumbnail URL
+   */
+  getThumbnailUrl?(id: string, mimeType?: string, options?: ThumbnailOptions): string;
+}
+/**
+ * Function signature for provider entrypoint modules
+ */
+type CreateMediaProviderFn<TConfig = Record<string, unknown>> = (config: TConfig) => MediaProvider;
+/**
+ * Media value stored in content fields
+ * This is what gets persisted when media is selected
+ *
+ * For backwards compatibility:
+ * - `provider` defaults to "local" if not specified
+ * - `src` is supported for legacy data or external URLs
+ */
+interface MediaValue {
+  /** Provider ID, e.g., "local", "unsplash", "mux" (defaults to "local") */
+  provider?: string;
+  /** Provider-specific item ID */
+  id: string;
+  /** Direct URL (for local media or legacy data) */
+  src?: string;
+  /** Preview URL for admin display (external providers) */
+  previewUrl?: string;
+  /** Cached metadata for display without runtime lookup */
+  filename?: string;
+  mimeType?: string;
+  width?: number;
+  height?: number;
+  alt?: string;
+  /** Provider-specific data needed for embedding */
+  meta?: Record<string, unknown>;
+}
+/**
+ * Convert a MediaProviderItem to a MediaValue for storage
+ */
+declare function mediaItemToValue(providerId: string, item: MediaProviderItem): MediaValue;
+//#endregion
+//#region src/media/normalize.d.ts
+/**
+ * Normalize a media field value into a consistent MediaValue shape.
+ *
+ * - `null`/`undefined` → `null`
+ * - Bare URL string → `{ provider: "external", id: "", src: url }`
+ * - Bare internal media URL → resolved via local provider's `get()`
+ * - Object with `provider` + `id` → enriched with missing fields from provider
+ */
+declare function normalizeMediaValue(value: unknown, getProvider: (id: string) => MediaProvider | undefined): Promise<MediaValue | null>;
+//#endregion
+//#region src/media/placeholder.d.ts
+/**
+ * Image Placeholder Generation
+ *
+ * Generates blurhash and dominant color from image buffers for LQIP support.
+ * Decodes images via jpeg-js (pure JS) and upng-js (pure JS, uses pako for
+ * deflate). No Node-specific dependencies — works in Workers and Node SSR.
+ */
+interface PlaceholderData {
+  blurhash: string;
+  dominantColor: string;
+}
+/**
+ * Generate blurhash and dominant color from an image buffer.
+ * Returns null for non-image MIME types or on failure.
+ *
+ * @param dimensions - Optional pre-known dimensions. Used as a fallback when
+ *   image-size cannot parse the buffer (e.g. truncated headers). When the
+ *   decoded size (width * height * 4) exceeds MAX_DECODED_BYTES, placeholder
+ *   generation is skipped to avoid OOM on memory-constrained runtimes.
+ */
+declare function generatePlaceholder(buffer: Uint8Array, mimeType: string, dimensions?: {
+  width: number;
+  height: number;
+}): Promise<PlaceholderData | null>;
+//#endregion
+export { MediaValue as _, ComponentEmbed as a, mediaItemToValue as b, EmbedResult as c, MediaListResult as d, MediaProvider as f, MediaUploadInput as g, MediaProviderItem as h, AudioEmbed as i, ImageEmbed as l, MediaProviderDescriptor as m, generatePlaceholder as n, CreateMediaProviderFn as o, MediaProviderCapabilities as p, normalizeMediaValue as r, EmbedOptions as s, PlaceholderData as t, MediaListOptions as u, ThumbnailOptions as v, VideoEmbed as y };

package/dist/plugin-utils.d.mts

@@ -0,0 +1,57 @@
+//#region src/plugin-utils.d.ts
+/**
+ * Shared utilities for plugin admin UIs.
+ *
+ * Plugin admin components (`admin.tsx`) run inside the Dineway admin dashboard.
+ * This module provides the common helpers they all need: API fetching with CSRF
+ * protection, response envelope unwrapping, and type narrowing.
+ *
+ * Import as: `import { apiFetch, parseApiResponse, isRecord } from "dineway/plugin-utils";`
+ */
+/**
+ * Fetch wrapper that adds the `X-Dineway-Request` CSRF protection header.
+ *
+ * All plugin admin API calls should use this instead of raw `fetch()`.
+ * State-changing endpoints reject requests without this header.
+ */
+declare function apiFetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+/**
+ * Parse an API response, unwrapping the `{ data: T }` envelope.
+ *
+ * All plugin API routes return success responses wrapped in `{ data: ... }`
+ * by `apiSuccess()`. This helper unwraps that envelope and handles errors.
+ *
+ * On error responses (non-2xx), throws an Error with the server's message
+ * (from `{ error: { message } }`) or the fallback message.
+ *
+ * @example
+ * ```ts
+ * const res = await apiFetch("/_dineway/api/plugins/my-plugin/items");
+ * const { items } = await parseApiResponse<{ items: Item[] }>(res, "Failed to load items");
+ * ```
+ */
+declare function parseApiResponse<T>(response: Response, fallbackMessage?: string): Promise<T>;
+/**
+ * Extract the error message from a failed API response.
+ *
+ * Error responses use the shape `{ error: { code, message } }`. This helper
+ * parses that body and returns the message, falling back to the provided default.
+ * Swallows JSON parse failures gracefully.
+ *
+ * @example
+ * ```ts
+ * if (!res.ok) {
+ *   setError(await getErrorMessage(res, "Failed to save"));
+ *   return;
+ * }
+ * ```
+ */
+declare function getErrorMessage(response: Response, fallback: string): Promise<string>;
+/**
+ * Narrow `unknown` to a plain object record.
+ *
+ * Useful for safely inspecting untyped API responses before accessing properties.
+ */
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+//#endregion
+export { apiFetch, getErrorMessage, isRecord, parseApiResponse };

package/dist/plugin-utils.mjs

@@ -0,0 +1,77 @@
+//#region src/plugin-utils.ts
+/**
+* Shared utilities for plugin admin UIs.
+*
+* Plugin admin components (`admin.tsx`) run inside the Dineway admin dashboard.
+* This module provides the common helpers they all need: API fetching with CSRF
+* protection, response envelope unwrapping, and type narrowing.
+*
+* Import as: `import { apiFetch, parseApiResponse, isRecord } from "dineway/plugin-utils";`
+*/
+/**
+* Fetch wrapper that adds the `X-Dineway-Request` CSRF protection header.
+*
+* All plugin admin API calls should use this instead of raw `fetch()`.
+* State-changing endpoints reject requests without this header.
+*/
+function apiFetch(input, init) {
+	const headers = new Headers(init?.headers);
+	headers.set("X-Dineway-Request", "1");
+	return fetch(input, {
+		...init,
+		headers
+	});
+}
+/**
+* Parse an API response, unwrapping the `{ data: T }` envelope.
+*
+* All plugin API routes return success responses wrapped in `{ data: ... }`
+* by `apiSuccess()`. This helper unwraps that envelope and handles errors.
+*
+* On error responses (non-2xx), throws an Error with the server's message
+* (from `{ error: { message } }`) or the fallback message.
+*
+* @example
+* ```ts
+* const res = await apiFetch("/_dineway/api/plugins/my-plugin/items");
+* const { items } = await parseApiResponse<{ items: Item[] }>(res, "Failed to load items");
+* ```
+*/
+async function parseApiResponse(response, fallbackMessage = "Request failed") {
+	if (!response.ok) throw new Error(await getErrorMessage(response, `${fallbackMessage}: ${response.statusText}`));
+	return (await response.json()).data;
+}
+/**
+* Extract the error message from a failed API response.
+*
+* Error responses use the shape `{ error: { code, message } }`. This helper
+* parses that body and returns the message, falling back to the provided default.
+* Swallows JSON parse failures gracefully.
+*
+* @example
+* ```ts
+* if (!res.ok) {
+*   setError(await getErrorMessage(res, "Failed to save"));
+*   return;
+* }
+* ```
+*/
+async function getErrorMessage(response, fallback) {
+	const body = await response.json().catch(() => ({}));
+	if (isRecord(body) && isRecord(body.error)) {
+		const msg = body.error.message;
+		if (typeof msg === "string") return msg;
+	}
+	return fallback;
+}
+/**
+* Narrow `unknown` to a plain object record.
+*
+* Useful for safely inspecting untyped API responses before accessing properties.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+export { apiFetch, getErrorMessage, isRecord, parseApiResponse };

package/dist/plugins/adapt-sandbox-entry.d.mts

@@ -0,0 +1,21 @@
+import "../types-DkvMXalq.mjs";
+import { wn as PluginDescriptor } from "../index-C-jx21qs.mjs";
+import "../runner-B5l1JfOj.mjs";
+import { $ as StandardPluginDefinition, J as ResolvedPlugin } from "../types-D38djUXv.mjs";
+import "../validate-DVKJJ-M_.mjs";
+
+//#region src/plugins/adapt-sandbox-entry.d.ts
+/**
+ * Adapt a standard-format plugin definition into a ResolvedPlugin.
+ *
+ * This is the core of the unified plugin format. It takes the `{ hooks, routes }`
+ * export from a standard plugin and produces a ResolvedPlugin that can enter the
+ * HookPipeline alongside native plugins.
+ *
+ * @param definition - The standard plugin definition (from definePlugin() or raw export)
+ * @param descriptor - The plugin descriptor with id, version, capabilities, etc.
+ * @returns A ResolvedPlugin compatible with HookPipeline
+ */
+declare function adaptSandboxEntry(definition: StandardPluginDefinition, descriptor: PluginDescriptor): ResolvedPlugin;
+//#endregion
+export { adaptSandboxEntry };