@vibesdotdev/storage 0.0.2 → 1.0.0-rc.3

package/dist/svelte/storage-explorer-runtime.js

@@ -0,0 +1,251 @@
+import { buildStorageRef } from '@vibesdotdev/storage/schemas';
+import { STORAGE_EXPLORER_CAPABILITY_ID, projectStorageTargetForRenderer, storageExplorerCapabilityKind } from '@vibesdotdev/storage/client';
+import { CapabilityError, CaughtFailureSchema } from '@vibesdotdev/kernel';
+import { storageSurfaceFailure } from "../client/storage-failure.js";
+import { resolvePlatformStorageExplorer, resolvePlatformStorageProviders } from "./platform-storage-port.js";
+async function createPlatformStorageExplorerClient(runtime) {
+    const storage = await resolvePlatformStorageExplorer(runtime);
+    const resolveTarget = async (providerId) => {
+        const target = (await storage.drives()).find((entry) => entry.providerId === providerId);
+        if (!target) {
+            throw new Error(`Storage provider "${providerId}" is not available.`);
+        }
+        return target;
+    };
+    return {
+        async status() {
+            // Browser session state is owned by the host. Without a projected
+            // device-session owner, proceed and let the Platform request classify
+            // authentication precisely.
+            return { state: 'unknown' };
+        },
+        async listTargets(scope) {
+            const { projectId, ...filter } = scope ?? {};
+            const hasFilter = Object.values(filter).some((value) => value !== undefined);
+            return (await storage.drives({
+                projectId,
+                filter: hasFilter ? filter : undefined
+            })).map(projectStorageTargetForRenderer);
+        },
+        async listDrives(providerId) {
+            const target = await resolveTarget(providerId);
+            return storage.browse.listDrives(target.adapterId, target.config);
+        },
+        async listEntries(providerId, driveId, path) {
+            const target = await resolveTarget(providerId);
+            return storage.browse.list(target.adapterId, driveId, path && path.length > 0 ? path : undefined, target.config);
+        },
+        async search(providerId, driveId, query, options) {
+            const target = await resolveTarget(providerId);
+            if (!storage.search) {
+                throw new Error('Platform client does not expose storage.search.');
+            }
+            return storage.search.search(target.adapterId, driveId, query, options, target.config);
+        },
+        async resolveObjectUrl(providerId, driveId, key, options) {
+            const target = await resolveTarget(providerId);
+            const scopedTarget = driveId && driveId !== 'root' ? { ...target, namespace: driveId } : target;
+            return storage.objects.url(scopedTarget, key, options);
+        },
+        async upload(target, key, file) {
+            await storage.objects.upload(target, key, file, {
+                contentType: file.type || undefined
+            });
+        },
+        async delete(target, key) {
+            await storage.objects.delete(target, key);
+        }
+    };
+}
+/**
+ * Resolve the storage owner capability. Native hosts require the projected
+ * owner; web hosts may fall back to the canonical Platform client.
+ */
+export async function resolveStorageExplorerClient(runtime, transport = 'auto') {
+    if (runtime.hasKind(storageExplorerCapabilityKind.id)) {
+        try {
+            const capability = await runtime
+                .query(storageExplorerCapabilityKind.id)
+                .withId(STORAGE_EXPLORER_CAPABILITY_ID)
+                .resolve();
+            if (capability)
+                return capability;
+        }
+        catch (error) {
+            const failure = CaughtFailureSchema.parse(error);
+            // Only a capability no plugin registered may fall back to the Platform
+            // client; a projection that exists but fails to resolve is carried.
+            if (!(failure instanceof Error && CapabilityError.isAbsenceOf(failure, storageExplorerCapabilityKind.id, STORAGE_EXPLORER_CAPABILITY_ID))) {
+                throw new CapabilityError('DESKTOP_STORAGE_RUNTIME_UNAVAILABLE: reconnect the Vibes Desktop runtime.', 'UNAVAILABLE', {
+                    reason: 'storage-explorer-runtime-unavailable',
+                    retryable: true,
+                    cause: failure
+                });
+            }
+        }
+    }
+    if (transport === 'runtime-projection') {
+        throw new CapabilityError('DESKTOP_STORAGE_RUNTIME_UNAVAILABLE: the Vibes Desktop runtime did not project storage/explorer.', 'UNAVAILABLE', {
+            reason: 'storage-explorer-runtime-unavailable',
+            retryable: true
+        });
+    }
+    return createPlatformStorageExplorerClient(runtime);
+}
+const SIGNED_OUT = {
+    kind: 'signed-out',
+    message: 'Connect Vibes Cloud to browse account storage on this Mac.'
+};
+const RUNTIME_UNAVAILABLE = {
+    kind: 'runtime-unavailable',
+    message: 'Vibes Desktop could not reach its local runtime. Reconnect the runtime and try again.'
+};
+const LOCATION_UNAVAILABLE = {
+    kind: 'location-unavailable',
+    message: 'That storage location is no longer available. Refresh your connections and try again.'
+};
+const UNKNOWN_FAILURE = {
+    kind: 'unknown',
+    message: 'Cloud files could not be loaded. Check your connection and try again.'
+};
+const SESSION_UNREPORTED = {
+    kind: 'unknown',
+    message: 'The device session could not report its state.'
+};
+/** The machine token an untyped error that crossed an RPC boundary leads with (its message's first word). */
+function machineTokenOf(failure) {
+    return failure instanceof Error ? /^([A-Z][A-Z0-9_]+):/.exec(failure.message)?.[1] : undefined;
+}
+/**
+ * Classify owner/runtime failures so the surface can offer the correct
+ * recovery action: by the failure's code and reason (and HTTP status), and,
+ * for an error that crossed an RPC boundary untyped, by its leading machine
+ * token only, never by matching prose.
+ */
+export function classifyStorageExplorerError(cause) {
+    const failure = CaughtFailureSchema.parse(cause);
+    const typed = storageSurfaceFailure(failure);
+    if (typed.code === 'AUTH_REQUIRED')
+        return SIGNED_OUT;
+    if (typed.reason === 'storage-explorer-status-failed')
+        return SESSION_UNREPORTED;
+    if (typed.reason === 'storage-explorer-runtime-unavailable' || typed.reason === 'storage-explorer-client-unavailable')
+        return RUNTIME_UNAVAILABLE;
+    if (typed.reason === 'storage-target-unavailable')
+        return LOCATION_UNAVAILABLE;
+    const token = machineTokenOf(failure);
+    if (token === 'DESKTOP_STORAGE_RUNTIME_UNAVAILABLE' || token === 'VIBES_CLOUD_CLIENT_UNAVAILABLE')
+        return RUNTIME_UNAVAILABLE;
+    if (token === 'STORAGE_TARGET_UNAVAILABLE')
+        return LOCATION_UNAVAILABLE;
+    return UNKNOWN_FAILURE;
+}
+/** Present owner/runtime errors as setup or reconnect actions, never raw RPC/HTTP noise. */
+export function describeStorageExplorerError(cause) {
+    return classifyStorageExplorerError(cause).message;
+}
+export function createStorageExplorerBrowseClient(target, resolveClient) {
+    return {
+        listDrives: async () => (await resolveClient()).listDrives(target.providerId),
+        listEntries: async (_adapterId, driveId, path) => (await resolveClient()).listEntries(target.providerId, driveId, path)
+    };
+}
+/** Enumerate the scope's storage drives (vibes + connected + SharePoint),
+ *  narrowed by the scope filter (everything by default). */
+export async function resolveScopeDrives(scope, client) {
+    return client.listTargets(scope);
+}
+/** Resolve a serving URL for an entry (download / share / preview). */
+export async function resolveObjectUrl(target, entry, opts, client, driveId) {
+    return client.resolveObjectUrl(target.providerId, driveId ?? target.namespace ?? null, entry.path, opts);
+}
+/** Upload a file at `key` (a drive-relative path) into the target. */
+export async function uploadObject(target, key, file, client) {
+    if (!client.upload) {
+        throw new Error('Storage uploads are not available through this runtime.');
+    }
+    await client.upload(target, key, file);
+}
+/** Delete an entry from its drive. */
+export async function deleteEntry(target, entry, client) {
+    if (!client.delete) {
+        throw new Error('Storage deletion is not available through this runtime.');
+    }
+    await client.delete(target, entry.path);
+}
+/**
+ * Search entries within a search-capable adapter (e.g. SharePoint via Graph
+ * content search). Mirrors `resolveScopeDrives` / `resolveObjectUrl` in style.
+ *
+ * @param target  The selected drive (from `resolveScopeDrives`) — provides
+ *                adapterId + config; IDOR-checked server-side like browse.
+ * @param driveId The active drive within the adapter (e.g. a SharePoint site).
+ * @param query   Search string (min 1 char).
+ * @param opts    Optional subtree scope + result limit.
+ */
+export async function searchStorageEntries(target, driveId, query, opts, client) {
+    return client.search(target.providerId, driveId, query, opts);
+}
+/**
+ * Whether the given target's adapter declares the `search` capability.
+ * Used by the explorer to show/hide the search box without a round-trip.
+ * Adapters that support search: SharePoint (delegated + app-only).
+ * R2, S3, GCS do NOT support search.
+ */
+export function targetSupportsSearch(target) {
+    if (!target)
+        return false;
+    return target.adapterId === 'sharepoint';
+}
+/** A scope a provider can be connected into, surfaced in the connect dialog.
+ *  `canAdmin` gates org/project/team scopes (you can only connect org storage
+ *  if you administer that org). Personal is always connectable. */
+/** External object-store provider connect input (S3 / R2 / GCS). */
+/** Provision a vibes-managed (`vibes_r2`) drive — no user credentials. Personal
+ *  always; org-scoped when the caller administers the org (admin-gated + made
+ *  idempotent server-side). */
+/** Connect an external object-store provider (S3/R2/GCS) through the platform
+ *  client (client → cloud-api), not a bespoke fetch. `scope.organizationId`
+ *  connects a shared org drive (admin-gated server-side). */
+export async function connectExternalProvider(runtime, input) {
+    const providers = await resolvePlatformStorageProviders(runtime);
+    await providers.createProvider(input);
+}
+/** Provision a vibes-managed shared drive (no credentials) into a scope. The
+ *  server skips the external-storage billing gate, admin-gates org scopes on the
+ *  caller's `orgs`-claim role, and is idempotent per org. */
+export async function provisionVibesProvider(runtime, input) {
+    const providers = await resolvePlatformStorageProviders(runtime);
+    await providers.createProvider({
+        name: input.name,
+        type: 'vibes_r2',
+        scope: input.scope
+    });
+}
+/** Build the Microsoft (SharePoint/OneDrive) connect URL for a scope. Personal →
+ *  delegated per-user sign-in; org → admin-consent (once that flow lands). The
+ *  explorer passes the absolute platform origin so org apps reach it cross-app. */
+export function microsoftConnectUrl(platformOrigin, returnTo, scope, authOrigin) {
+    // Org admin → admin-consent: consent the (multi-tenant) vibes app into the
+    // org's OWN tenant, enabling the org-wide app-only SharePoint drive. (Lives on
+    // platform-web, which owns the per-org tenant store.)
+    if (scope && scope.kind === 'org' && scope.id && scope.canAdmin) {
+        const params = new URLSearchParams({ org: scope.id, returnTo });
+        return `${platformOrigin}/auth/microsoft/adminconsent?${params.toString()}`;
+    }
+    // Personal (and non-admin) → LINK the user's Microsoft account via auth-web's
+    // Better Auth flow (`/connect`), which owns the OAuth round-trip + offline_access
+    // token lifecycle. The delegated Microsoft integration reads the resulting tokens
+    // off the account row. `returnTo` must be ABSOLUTE (cross-origin redirect back).
+    const base = authOrigin || platformOrigin;
+    const params = new URLSearchParams({ provider: 'microsoft', returnTo });
+    return `${base}/connect?${params.toString()}`;
+}
+/**
+ * A portable storage entity reference for AI flows:
+ * `storage://{providerId}/{driveId}/{key}`. The chat/AI worker resolves it
+ * lazily (head/get) at run time — nothing is copied up front.
+ */
+export function storageRef(target, driveId, key) {
+    return buildStorageRef(target.providerId, driveId, key);
+}

package/dist/svelte/storage-explorer.load.d.ts

@@ -0,0 +1,22 @@
+import type { StorageExplorerEnvironment } from '../schemas/explorer/views.ts';
+export type { StorageExplorerEnvironment } from '../schemas/explorer/views.ts';
+/**
+ * Server `load` helper for the StorageExplorer surface.
+ *
+ * The surface-package primitive an org app's `+page.server.ts` calls, with the
+ * request's runtime, to get the mount data the explorer needs: the platform
+ * and auth origins, each the declared `infra/service` primary origin in the
+ * environment selected by its runtime-resolved target port. The app
+ * passes the result to `<StorageExplorer>` as its explicit origin input and
+ * supplies only ITS org preferences (scope narrowing, labels, `decorate` /
+ * `contextActions` / `onAiAction`, theme) as props/snippets — no origin or
+ * transport logic in the app. The component does the heavy lifting
+ * (enumeration, browse, upload, preview) through the runtime client.
+ *
+ * A service the runtime does not declare is refused `service-undeclared` by
+ * the infra owner; nothing is guessed from the request's hostname.
+ */
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+/** Resolve the StorageExplorer's origins on the request's runtime. */
+export declare function loadStorageExplorerEnvironment(runtime: RuntimeRef): Promise<StorageExplorerEnvironment>;
+//# sourceMappingURL=storage-explorer.load.d.ts.map

package/dist/svelte/storage-explorer.load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-explorer.load.d.ts","sourceRoot":"","sources":["../../src/svelte/storage-explorer.load.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E,YAAY,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAC;AAC/E;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAmB,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAIvE,sEAAsE;AACtE,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAgB7G"}

package/dist/svelte/storage-explorer.load.js

@@ -0,0 +1,37 @@
+/**
+ * Server `load` helper for the StorageExplorer surface.
+ *
+ * The surface-package primitive an org app's `+page.server.ts` calls, with the
+ * request's runtime, to get the mount data the explorer needs: the platform
+ * and auth origins, each the declared `infra/service` primary origin in the
+ * environment selected by its runtime-resolved target port. The app
+ * passes the result to `<StorageExplorer>` as its explicit origin input and
+ * supplies only ITS org preferences (scope narrowing, labels, `decorate` /
+ * `contextActions` / `onAiAction`, theme) as props/snippets — no origin or
+ * transport logic in the app. The component does the heavy lifting
+ * (enumeration, browse, upload, preview) through the runtime client.
+ *
+ * A service the runtime does not declare is refused `service-undeclared` by
+ * the infra owner; nothing is guessed from the request's hostname.
+ */
+import { CapabilityError } from '@vibesdotdev/kernel';
+import { ServiceTargetSchema } from '@vibesdotdev/infra-contracts';
+import { parseAdapterInput } from "../adapters/parse-adapter-input.js";
+/** Resolve the StorageExplorer's origins on the request's runtime. */
+export async function loadStorageExplorerEnvironment(runtime) {
+    const primaryOrigin = async (ownerApp) => {
+        const query = runtime.hasKind('infra/service') ?
+            runtime.query('infra/service').withId(ownerApp) : undefined;
+        if (!query || query.descriptors().length === 0) {
+            throw new CapabilityError('No infra/service is declared for the owner app.', 'NOT_FOUND', {
+                reason: 'service-undeclared', retryable: false, details: { serviceId: ownerApp }
+            });
+        }
+        const target = parseAdapterInput(ServiceTargetSchema, await (await query.resolve()).target('primary'), {
+            message: 'The service target answer is invalid.', code: 'INTERNAL', reason: 'service-target-invalid'
+        });
+        return target.origin;
+    };
+    const [platformOrigin, authOrigin] = await Promise.all([primaryOrigin('platform'), primaryOrigin('auth')]);
+    return { platformOrigin, authOrigin };
+}

package/dist/svelte/storage-refs-runtime.d.ts

@@ -0,0 +1,36 @@
+import { type StorageRefList } from '../schemas/explorer/refs.ts';
+export { StorageRefKindSchema, StorageRefSchema, StorageRefListSchema, type StorageRefKind, type StorageRef, type StorageRefList } from '../schemas/explorer/refs.ts';
+/**
+ * Owned storage references (pins / recents / folder-links) — offline-first.
+ *
+ * A `StorageRef` records a user's reference to a storage location (a pinned
+ * SharePoint folder, a recently-browsed path, a folder linked to a job). Unlike
+ * the SQL-backed job records (which need a sqlite.wasm browser adapter),
+ * references are stored via the DOCUMENT path (`StorageManifest`), which is NOT
+ * SQL-coupled — so they're genuinely offline-first today: written to
+ * `storage.idb` locally and mirrored to `storage.cloud-api` when online, all
+ * runtime-resolved (no per-app endpoints in features).
+ *
+ * The store consumes a small `RefsBackend` (load/save a ref list) so its logic
+ * is unit-testable without a runtime; `createManifestRefsBackend(runtime)` is the real
+ * StorageManifest-backed implementation.
+ */
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import { type StorageManifestDescriptor } from '@vibesdotdev/storage/schemas';
+/** Stable id for a (adapter, drive, path) reference. */
+export declare function storageRefId(adapterId: string, driveId: string, path: string): string;
+/**
+ * `storage/manifest` descriptor for owned references. Document-shaped
+ * (`dataType: 'objects'` — a single ref-list document per scope). Offline-first
+ * adapters: `storage.idb` (browser-local) + `storage.cloud-api` (sync). Routes
+ * through the platform catch-all (`ownerApp: 'platform'`, no bespoke endpoint).
+ */
+export declare const storageRefsManifestDescriptor: StorageManifestDescriptor;
+/** Persistence seam the store depends on — load/save the full ref list. */
+export interface RefsBackend {
+    load(): Promise<StorageRefList>;
+    save(refs: StorageRefList): Promise<void>;
+}
+/** Real backend: a runtime-resolved StorageManifest (idb local-first → cloud-api sync). */
+export declare function createManifestRefsBackend(runtime: VibesRuntime): RefsBackend;
+//# sourceMappingURL=storage-refs-runtime.d.ts.map

package/dist/svelte/storage-refs-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-refs-runtime.d.ts","sourceRoot":"","sources":["../../src/svelte/storage-refs-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AACxF,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,KAAK,cAAc,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,6BAA6B,CAAC;AACtK;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD,OAAO,EAEN,KAAK,yBAAyB,EAC9B,MAAM,8BAA8B,CAAC;AAEtC,wDAAwD;AACxD,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAErF;AAED;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,yBAqBzC,CAAC;AAEJ,2EAA2E;AAC3E,MAAM,WAAW,WAAW;IAC3B,IAAI,IAAI,OAAO,CAAC,cAAc,CAAC,CAAC;IAChC,IAAI,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED,2FAA2F;AAC3F,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,YAAY,GAAG,WAAW,CAU5E"}

package/dist/svelte/storage-refs-runtime.js

@@ -0,0 +1,47 @@
+import { StorageRefListSchema } from "../schemas/explorer/refs.js";
+export { StorageRefKindSchema, StorageRefSchema, StorageRefListSchema } from "../schemas/explorer/refs.js";
+import { StorageManifest } from '@vibesdotdev/storage';
+import { StorageManifestDescriptorSchema } from '@vibesdotdev/storage/schemas';
+/** Stable id for a (adapter, drive, path) reference. */
+export function storageRefId(adapterId, driveId, path) {
+    return `${adapterId}:${driveId}:${path}`;
+}
+/**
+ * `storage/manifest` descriptor for owned references. Document-shaped
+ * (`dataType: 'objects'` — a single ref-list document per scope). Offline-first
+ * adapters: `storage.idb` (browser-local) + `storage.cloud-api` (sync). Routes
+ * through the platform catch-all (`ownerApp: 'platform'`, no bespoke endpoint).
+ */
+export const storageRefsManifestDescriptor = StorageManifestDescriptorSchema.parse({
+    kind: 'storage/manifest',
+    id: 'platform.storage.refs',
+    namespace: 'platform.storage.refs',
+    schema: StorageRefListSchema,
+    dataType: 'objects',
+    allowedAdapters: ['storage.idb', 'storage.cloud-api'],
+    defaultAdapter: 'storage.idb',
+    adapterConfig: {
+        // `endpoint` is the explicit per-namespace path the `storage.cloud-api`
+        // adapter resolves to (else it derives `/api/storage/{namespace}`, which
+        // wouldn't match the platform catch-all). `user` binds the document to
+        // the signed-in user via `event.locals.user.id` in the catch-all.
+        'storage.cloud-api': {
+            ownerApp: 'platform',
+            endpoint: '/api/storage/user/platform.storage.refs'
+        }
+    },
+    scope: 'global',
+    version: 1
+});
+/** Real backend: a runtime-resolved StorageManifest (idb local-first → cloud-api sync). */
+export function createManifestRefsBackend(runtime) {
+    const manifest = new StorageManifest(storageRefsManifestDescriptor, { runtime });
+    return {
+        async load() {
+            return (await manifest.load()) ?? [];
+        },
+        async save(refs) {
+            await manifest.save(refs);
+        }
+    };
+}

package/dist/svelte/storage-runtime.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Storage-provider runtime helpers.
+ *
+ * Resolve the runtime's Platform client (`runtime/client#platform`) through
+ * the Storage-declared port so cross-app surfaces (creative, chat, knowledge,
+ * etc.) can list / select / create the user's storage providers without
+ * re-implementing the HTTP client or importing Platform.
+ */
+import type { CreateStorageProviderInput, StorageProvider, StorageProviderDetail } from '@vibesdotdev/storage/schemas/storage-provider';
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+/**
+ * Where a store gets its runtime: a component's `getRuntimeSvelteContext()`
+ * captured at init (`await source.load()` when a call needs it).
+ */
+export interface StorageRuntimeSource {
+    load(): Promise<VibesRuntime>;
+}
+export type StorageProviderOption = StorageProvider;
+export type StorageProviderDetailOption = StorageProviderDetail;
+export type StorageProviderType = CreateStorageProviderInput['type'];
+export interface PlatformStorageClient {
+    listProviders(): Promise<StorageProviderOption[]>;
+    createProvider(input: CreateStorageProviderInput): Promise<StorageProviderDetail>;
+    deleteProvider(providerId: string): Promise<void>;
+}
+export declare function resolvePlatformStorageClient(runtime: VibesRuntime, client?: PlatformStorageClient): Promise<PlatformStorageClient>;
+export declare function loadStorageProviders(runtime: VibesRuntime, client?: PlatformStorageClient): Promise<StorageProviderOption[]>;
+export declare function pickDefaultProvider(providers: StorageProviderOption[]): StorageProviderOption | undefined;
+export declare function describeProviderType(type: string): string;
+//# sourceMappingURL=storage-runtime.d.ts.map

package/dist/svelte/storage-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-runtime.d.ts","sourceRoot":"","sources":["../../src/svelte/storage-runtime.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EACX,0BAA0B,EAC1B,eAAe,EACf,qBAAqB,EACrB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAIxD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACpC,IAAI,IAAI,OAAO,CAAC,YAAY,CAAC,CAAC;CAC9B;AAED,MAAM,MAAM,qBAAqB,GAAG,eAAe,CAAC;AACpD,MAAM,MAAM,2BAA2B,GAAG,qBAAqB,CAAC;AAChE,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,CAAC,MAAM,CAAC,CAAC;AAErE,MAAM,WAAW,qBAAqB;IACrC,aAAa,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAClD,cAAc,CACb,KAAK,EAAE,0BAA0B,GAC/B,OAAO,CAAC,qBAAqB,CAAC,CAAC;IAClC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClD;AAED,wBAAsB,4BAA4B,CACjD,OAAO,EAAE,YAAY,EACrB,MAAM,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,CAAC,CAgBhC;AAED,wBAAsB,oBAAoB,CACzC,OAAO,EAAE,YAAY,EACrB,MAAM,CAAC,EAAE,qBAAqB,GAC5B,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAGlC;AAED,wBAAgB,mBAAmB,CAClC,SAAS,EAAE,qBAAqB,EAAE,GAChC,qBAAqB,GAAG,SAAS,CAKnC;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEzD"}

package/dist/svelte/storage-runtime.js

@@ -0,0 +1,39 @@
+/**
+ * Storage-provider runtime helpers.
+ *
+ * Resolve the runtime's Platform client (`runtime/client#platform`) through
+ * the Storage-declared port so cross-app surfaces (creative, chat, knowledge,
+ * etc.) can list / select / create the user's storage providers without
+ * re-implementing the HTTP client or importing Platform.
+ */
+import { getStorageProviderTypeShortLabel } from "./storage-display.js";
+import { resolvePlatformStorageProviders } from "./platform-storage-port.js";
+export async function resolvePlatformStorageClient(runtime, client) {
+    if (client)
+        return client;
+    const providers = await resolvePlatformStorageProviders(runtime);
+    return {
+        async listProviders() {
+            const result = await providers.listProviders();
+            return result.providers;
+        },
+        async createProvider(input) {
+            const result = await providers.createProvider(input);
+            return result.provider;
+        },
+        async deleteProvider(providerId) {
+            await providers.deleteProvider(providerId);
+        }
+    };
+}
+export async function loadStorageProviders(runtime, client) {
+    const resolved = await resolvePlatformStorageClient(runtime, client);
+    return resolved.listProviders();
+}
+export function pickDefaultProvider(providers) {
+    return (providers.find((p) => p.isDefault && p.isActive) ??
+        providers.find((p) => p.isActive));
+}
+export function describeProviderType(type) {
+    return getStorageProviderTypeShortLabel(type);
+}

package/dist/svelte/storage-svelte.plugin.d.ts

@@ -0,0 +1,40 @@
+export declare const storageSvelteToolWidgetDescriptors: readonly [{
+    id: string;
+    kind: "tools/ui";
+    name: string;
+    description: string;
+    surfaces: ["web"];
+    role: "widget";
+    targetToolId: string;
+    targetId: string;
+    tags: string[];
+    enabled: true;
+    placement?: "inline" | "top" | "bottom" | undefined;
+}, {
+    id: string;
+    kind: "tools/ui";
+    name: string;
+    description: string;
+    surfaces: ["web"];
+    role: "widget";
+    targetToolId: string;
+    targetId: string;
+    tags: string[];
+    enabled: true;
+    placement?: "inline" | "top" | "bottom" | undefined;
+}, {
+    id: string;
+    kind: "tools/ui";
+    name: string;
+    description: string;
+    surfaces: ["web"];
+    role: "widget";
+    targetToolId: string;
+    targetId: string;
+    tags: string[];
+    enabled: true;
+    placement?: "inline" | "top" | "bottom" | undefined;
+}];
+export declare const storageSveltePlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default storageSveltePlugin;
+//# sourceMappingURL=storage-svelte.plugin.d.ts.map

package/dist/svelte/storage-svelte.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-svelte.plugin.d.ts","sourceRoot":"","sources":["../../src/svelte/storage-svelte.plugin.ts"],"names":[],"mappings":"AAuBA,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIrC,CAAC;AAMX,eAAO,MAAM,mBAAmB,6CAwB9B,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/svelte/storage-svelte.plugin.js

@@ -0,0 +1,50 @@
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import { createStorageSvelteToolWidgetDescriptor, createStorageSvelteToolWidgetLoader, registerStorageSvelteToolWidget } from "./tool-widgets/runtime.js";
+const storageBrowseToolWidget = createStorageSvelteToolWidgetDescriptor({
+    toolId: 'storage.browse',
+    name: 'Storage Browse Svelte Widget',
+    description: 'Renders storage.browse drive and folder listings in Svelte chat.'
+});
+const storageCopyToolWidget = createStorageSvelteToolWidgetDescriptor({
+    toolId: 'storage.copy',
+    name: 'Storage Copy Svelte Widget',
+    description: 'Renders storage.copy source/target results in Svelte chat.'
+});
+const storageSearchToolWidget = createStorageSvelteToolWidgetDescriptor({
+    toolId: 'storage.search',
+    name: 'Storage Search Svelte Widget',
+    description: 'Renders storage.search matches in Svelte chat.'
+});
+export const storageSvelteToolWidgetDescriptors = [
+    storageBrowseToolWidget,
+    storageCopyToolWidget,
+    storageSearchToolWidget
+];
+const browseLoader = () => import('./tool-widgets/StorageBrowseToolCard.svelte');
+const copyLoader = () => import('./tool-widgets/StorageCopyToolCard.svelte');
+const searchLoader = () => import('./tool-widgets/StorageSearchToolCard.svelte');
+export const storageSveltePlugin = createRuntimePlugin({
+    id: '@vibesdotdev/storage/svelte',
+    name: 'Storage Svelte',
+    description: 'Svelte/browser storage tool cards. Platform upload chat widgets: @vibesdotdev/platform/svelte/storage/plugin.',
+    descriptors: [
+        // `tools/ui` is owned by @vibesdotdev/tools. Register without a hard
+        // plugin dependency — the runtime queues descriptors for pending kinds.
+        storageBrowseToolWidget,
+        storageCopyToolWidget,
+        storageSearchToolWidget
+    ],
+    loaders: [
+        createStorageSvelteToolWidgetLoader(storageBrowseToolWidget, browseLoader),
+        createStorageSvelteToolWidgetLoader(storageCopyToolWidget, copyLoader),
+        createStorageSvelteToolWidgetLoader(storageSearchToolWidget, searchLoader)
+    ],
+    async onRegister() {
+        await Promise.all([
+            registerStorageSvelteToolWidget(storageBrowseToolWidget, browseLoader),
+            registerStorageSvelteToolWidget(storageCopyToolWidget, copyLoader),
+            registerStorageSvelteToolWidget(storageSearchToolWidget, searchLoader)
+        ]);
+    }
+});
+export default storageSveltePlugin;

package/dist/svelte/storage-upload-runtime.d.ts

@@ -0,0 +1,8 @@
+export type { StorageUploadStatus } from '../schemas/explorer/views.ts';
+/**
+ * Upload presentation helpers shared by Storage's upload chip and Platform's
+ * upload surfaces (`@vibesdotdev/platform/svelte/storage`), which own the
+ * upload transport itself.
+ */
+export declare function formatStorageFileSize(bytes: number): string;
+//# sourceMappingURL=storage-upload-runtime.d.ts.map

package/dist/svelte/storage-upload-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-upload-runtime.d.ts","sourceRoot":"","sources":["../../src/svelte/storage-upload-runtime.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACxE;;;;GAIG;AAEH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAI3D"}

package/dist/svelte/storage-upload-runtime.js

@@ -0,0 +1,12 @@
+/**
+ * Upload presentation helpers shared by Storage's upload chip and Platform's
+ * upload surfaces (`@vibesdotdev/platform/svelte/storage`), which own the
+ * upload transport itself.
+ */
+export function formatStorageFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(0)} KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/dist/svelte/stores/index.d.ts

@@ -0,0 +1,4 @@
+export { StorageProvidersStore, createStorageProvidersStore, type StorageProvidersStoreOptions } from './storage-providers.svelte.ts';
+export { StorageBrowseStore, createStorageBrowseStore, type StorageBrowseStoreOptions } from './storage-browse.svelte.ts';
+export { StorageRefsStore, createStorageRefsStore, type StorageRefsStoreOptions } from './storage-refs.svelte.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/svelte/stores/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/svelte/stores/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,qBAAqB,EACrB,2BAA2B,EAC3B,KAAK,4BAA4B,EACjC,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EACN,kBAAkB,EAClB,wBAAwB,EACxB,KAAK,yBAAyB,EAC9B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EACN,gBAAgB,EAChB,sBAAsB,EACtB,KAAK,uBAAuB,EAC5B,MAAM,0BAA0B,CAAC"}

package/dist/svelte/stores/index.js

@@ -0,0 +1,3 @@
+export { StorageProvidersStore, createStorageProvidersStore } from "./storage-providers.svelte.js";
+export { StorageBrowseStore, createStorageBrowseStore } from "./storage-browse.svelte.js";
+export { StorageRefsStore, createStorageRefsStore } from "./storage-refs.svelte.js";