@vibesdotdev/storage 0.0.1 → 1.0.0-rc.3

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 VIBES DEV LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,75 +1,99 @@
 # @vibesdotdev/storage
 
-Universal storage primitive. Defines `storage/manifest` and `storage/adapter`
-runtime kinds, the `StorageManifest<T>` base, and the sync/policy/record
-abstractions. Adapters live in sibling packages and register themselves.
-
-## Quickstart
-
-### Define a storage manifest
-
-```ts
-import { z } from 'zod';
-import { createStorageManifest } from '@vibesdotdev/storage/manifest';
-
-export const sessions = createStorageManifest({
-  id: 'auth.sessions',
-  namespace: 'auth',
-  schema: z.object({
-    id: z.string(),
-    userId: z.string(),
-    expiresAt: z.string().datetime(),
-  }),
-  adapters: ['localdb', 'cloud-api'],
-});
+Storage manifests, record contracts, and runtime descriptors for Vibes data adapters.
+
+`StorageManifest<T>.partition(id)` creates a distinct encoded document namespace
+while retaining the manifest schema, adapter policy, and runtime context. The
+operation is deliberately limited to namespace-addressed document manifests:
+`customTables` must be false, and every allowed adapter's manifest configuration
+must be absent or empty (for example, `storage.idb: {}`). Explicit locators such
+as a JSON `filename` or cloud-api `endpoint` are rejected because they can alias
+all partitions back to one physical document.
+
+This package is part of the public Vibes framework package set. The source repository is private while the public repository split is being prepared, so package documentation is published on the Vibes docs site.
+
+Cloud persistence resolves service origins and credentials through the handed
+runtime. Configuration and endpoint registration preserve the adapter receiver;
+each opened store retains its own binding. Explicit API origins take precedence
+over the owning app's Infra service target. Adapter failures propagate and never
+reroute writes.
+
+Boundary schemas live in `src/schemas/` (backup contracts in `src/backup/schemas/`).
+Factory configuration is validated once at ingress: a malformed Drizzle
+persistence configuration refuses typed (`INVALID_INPUT` /
+`persistence-config-invalid`) before any driver or resource is used, while
+tables, relations, and drivers keep their identity. Cloud record batches
+validate whole before mutating (`record-batch-invalid`, no fallthrough to
+delete); migration bundles parse through their owning input schema; raw SQL
+input validates before driver dispatch on both raw-client paths; sync-state
+substrates resolve through the `storage/sync-state` runtime kind.
+Existing module imports remain supported through compatibility re-exports.
+Backup preflight deadlines preserve recoverable files; owned runtimes finish
+before their workspace fixtures are removed.
+
+Consumer hosts compose `./storage.consumer.plugin` after `./plugin` for both
+sync persistence and record-delivery reconciliation. Storage's CLI, TUI and
+explorer consumer entrypoints compose that slice, as does the supported
+`@vibesdotdev/plugins/core/consumer.plugin` host entrypoint for workers without CLI.
+Repeated composition is safe. The universal plugin retains browser persistence
+and runtime-owned clients, with no consumer persistence or reconciliation loader
+imports. Consumer hosts must compose the explicit slice; there is no universal
+consumer fallback. Composed tests prove sync persistence across runtime recreation
+and scheduled delivery through Workers.
+
+Record schema initialization resolves `storage.schema-coordination`, which uses
+LocalDB's database-path queue and `BEGIN IMMEDIATE` transactions. A process that
+boots several runtime roots against the same files must share one LocalDB pool
+with `createConnectionPool` and `shareConnectionPool`; memory handles remain
+independent. Failed migrations roll back and release the next queued operation.
+
+Run `bun run check`, `bun run test` (browser, isolated and main suites), and
+`bun run build` from this package. Unit tests import contracts in process;
+packaging belongs to build/export/release checks.
+
+## Install
+
+```sh
+bun add @vibesdotdev/storage
+# or
+npm install @vibesdotdev/storage
 ```
 
-### Load + save through the runtime
+Adapter configuration checks use `diagnoseStorageAdapterConfiguration` from `@vibesdotdev/storage/client/diagnose-adapter`. It resolves the registered adapter and reports actionable, value-free issues without opening a store, writing data, or resolving credentials.
 
-```ts
-import { StorageManifest } from '@vibesdotdev/storage';
+## Documentation
 
-const sessions = new StorageManifest('auth.sessions');
-await sessions.put({ id: 's1', userId: 'u1', expiresAt: '2026-12-31T00:00:00Z' });
-const session = await sessions.get('s1');
-```
-
-The runtime selects the adapter (`localdb` consumer-side, `cloud-api`
-cloud-side) based on scope. Feature code never branches on hardware.
-
-### Sync (local-first)
-
-When sync is enabled in runtime config, consumer writes mirror to the cloud
-adapter via `cloud-sync.consumer`. Sync state is tracked in a separate
-manifest so divergent writes are reconciled rather than silently merged.
-
-## Adapters
+- Package guide: https://docs.vibes.dev/storage
+- Vibes docs: https://docs.vibes.dev
 
-Storage core ships zero adapter implementations. Apps load the adapter
-packages their scope can support:
+## License
 
-- [`@vibesdotdev/storage-adapter-memory`](../storage-adapter-memory/) — tests/ephemeral
-- [`@vibesdotdev/storage-adapter-json`](../storage-adapter-json/) — local file-backed
-- [`@vibesdotdev/storage-adapter-localdb`](../storage-adapter-localdb/) — SQLite (Bun)
-- [`@vibesdotdev/storage-adapter-cloud-api`](../storage-adapter-cloud-api/) — hosted
-- [`@vibesdotdev/storage-adapter-drizzle`](../storage-adapter-drizzle/) — SQL via Drizzle
-- External integrations (SharePoint, etc.) → [`platform`](../platform/SPEC.md)
+MIT
 
-## CLI
+Manifest save hooks resolve persistence and save policy through `storage/sync-state`; consumer hosts compose `./storage.consumer.plugin`.
 
-```bash
-vibes storage list
-vibes storage status
-vibes storage sync run
-```
-
-## Test
-
-```bash
-bun run test
-```
+Drizzle persistence now keeps connection state on the runtime-owned
+`storage.drizzle-persistence` client. Disposal closes owned connections,
+including a connection returned by an outstanding open. Platform drivers can
+return an optional `close()` port for connections they transfer to Storage.
+Root and per-factory isolation remain independent. The kernel retains the
+client across reload registries: synchronous `getDb` reads the initialized root
+database through cold generations, plugin views and the dispatcher, with no
+asynchronous warm-up. The unchanged F1/F2 composed tests prove that identity.
+Registration stays lazy, including bare-root factory use; the kernel owns client
+disposal and Storage owns atomic initialization and connection cleanup. See the
+[Drizzle contract](src/adapters/drizzle/SPEC.md).
 
-## Docs
 
-- [SPEC.md](./SPEC.md) — package contract, owned surfaces, hard rules
-- [runtime](../runtime/SPEC.md), [config](../config/SPEC.md)
+Drizzle connections resolve `storage/libsql-provider` through the handed runtime:
+`createLibsqlDrizzleConnection(options, runtime)`. Compose an integration plugin
+registered with `createLibsqlProviderPlugin` from `./adapters/drizzle/providers`;
+installing the SDK alone does not register it. The integration owns SDK loading
+and Drizzle binding, Storage owns migration orchestration, and the host
+`filesystem/adapter` owns migration file reads. The portable barrel has no
+executable SDK or Node migrator imports. Existing `platformDrivers` keep their
+order, first-available short-circuit binding probes and method receivers through
+kernel registration. The D1 documentation example uses the integration driver
+and deployment-managed migrations; libSQL examples require an explicitly
+composed integration provider.
+See the [provider contract and external composition follow-up](src/adapters/drizzle/SPEC.md#drizzle-provider-composition).

package/dist/adapters/cloud-api/cloud-api.adapter.descriptor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Cloud API Storage Adapter Descriptor
+ *
+ * API-based storage for cloud-synced data.
+ * Consumer hardware uses this to sync with cloud backend.
+ */
+import type { StorageAdapterDescriptor } from '@vibesdotdev/storage/schemas/adapter-descriptor';
+declare const descriptor: StorageAdapterDescriptor;
+export default descriptor;
+//# sourceMappingURL=cloud-api.adapter.descriptor.d.ts.map

package/dist/adapters/cloud-api/cloud-api.adapter.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-api.adapter.descriptor.d.ts","sourceRoot":"","sources":["../../../src/adapters/cloud-api/cloud-api.adapter.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iDAAiD,CAAC;AAEhG,QAAA,MAAM,UAAU,EAAE,wBAiCjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/adapters/cloud-api/cloud-api.adapter.descriptor.js

@@ -0,0 +1,40 @@
+/**
+ * Cloud API Storage Adapter Descriptor
+ *
+ * API-based storage for cloud-synced data.
+ * Consumer hardware uses this to sync with cloud backend.
+ */
+const descriptor = {
+    id: 'storage.cloud-api',
+    kind: 'storage/adapter',
+    name: 'Cloud API Storage',
+    description: 'API-based storage for cloud sync. Consumer hardware uses this to sync data with cloud backend.',
+    tags: ['storage', 'cloud', 'api', 'sync', 'remote'],
+    hardware: ['consumer', 'cloud'], // Works on consumer (calling cloud) and cloud (self-hosted API)
+    enabled: true,
+    // Storage-specific fields
+    protocols: ['document', 'record'],
+    sourcePolicy: {
+        source: 'cloud-api',
+        locality: 'remote',
+        candidates: [{ source: 'cloud-api', priority: 100 }],
+        readThroughTtlSeconds: 300
+    },
+    basePathSemantics: 'unused',
+    capabilities: ['list', 'read', 'write'],
+    requiresPairSchema: false,
+    // Every origin comes from the manifest's ownerApp or apiEndpoint; without one it refuses.
+    requiresManifestBinding: true,
+    supportsTransactions: false,
+    supportsTTL: false,
+    supportsSearch: false,
+    supportsFTS: false,
+    persistent: true,
+    supportsSubscription: false,
+    supportsHierarchy: false,
+    supportsComputedFields: false,
+    supportsSideEffects: false,
+    supportsRawQueries: false
+};
+export default descriptor;
+//# sourceMappingURL=cloud-api.adapter.descriptor.js.map

package/dist/adapters/cloud-api/cloud-api.adapter.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-api.adapter.descriptor.js","sourceRoot":"","sources":["../../../src/adapters/cloud-api/cloud-api.adapter.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,MAAM,UAAU,GAA6B;IAC5C,EAAE,EAAE,mBAAmB;IACvB,IAAI,EAAE,iBAAiB;IACvB,IAAI,EAAE,mBAAmB;IACzB,WAAW,EACV,gGAAgG;IACjG,IAAI,EAAE,CAAC,SAAS,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC;IACnD,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC,EAAE,gEAAgE;IACjG,OAAO,EAAE,IAAI;IAEb,0BAA0B;IAC1B,SAAS,EAAE,CAAC,UAAU,EAAE,QAAQ,CAAC;IACjC,YAAY,EAAE;QACb,MAAM,EAAE,WAAW;QACnB,QAAQ,EAAE,QAAQ;QAClB,UAAU,EAAE,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,QAAQ,EAAE,GAAG,EAAE,CAAC;QACpD,qBAAqB,EAAE,GAAG;KAC1B;IACD,iBAAiB,EAAE,QAAQ;IAC3B,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;IACvC,kBAAkB,EAAE,KAAK;IACzB,0FAA0F;IAC1F,uBAAuB,EAAE,IAAI;IAC7B,oBAAoB,EAAE,KAAK;IAC3B,WAAW,EAAE,KAAK;IAClB,cAAc,EAAE,KAAK;IACrB,WAAW,EAAE,KAAK;IAClB,UAAU,EAAE,IAAI;IAChB,oBAAoB,EAAE,KAAK;IAC3B,iBAAiB,EAAE,KAAK;IACxB,sBAAsB,EAAE,KAAK;IAC7B,mBAAmB,EAAE,KAAK;IAC1B,kBAAkB,EAAE,KAAK;CACzB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/adapters/cloud-api/cloud-api.adapter.impl.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Cloud API Storage Adapter Implementation
+ *
+ * HTTP persistence for cloud-synced data: each store or record runs over the
+ * fetch transport (`cloud-api.fetch-client.ts`) bound to its own origin and
+ * credentials.
+ *
+ * One instance per runtime: the storage/adapter kind constructs this class
+ * with the runtime's kind context, so two roots never share one. Within a
+ * runtime, `configure()` replaces the configuration (never merges it with an
+ * earlier manifest's), and every store and record binds the configuration it
+ * was opened with, so one manifest never keeps another's origin or token.
+ *
+ * Safe to import in any environment (browser, server, worker).
+ */
+import { type KindContext } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import type { StorageAdapterInterface, StorageAdapterCapabilities, CloudAPIAdapterConfig, CloudSettingsClient, StorageHealthStatus } from '@vibesdotdev/storage/interfaces/adapter';
+import type { StorageDocumentStoreInterface } from '@vibesdotdev/storage/interfaces/document-store';
+import type { StorageKeyValueInterface } from '@vibesdotdev/storage/interfaces/key-value';
+import type { StorageRecordInterface } from '@vibesdotdev/storage/interfaces/record';
+import type { StorageRepositoryInterface, RepositoryOptions } from '@vibesdotdev/storage/interfaces/repository';
+import type { StorageRecordDescriptor } from '@vibesdotdev/storage/schemas/record';
+import { type CloudApiTransport, type CloudEndpointConfig } from './cloud-api.fetch-client.ts';
+declare class CloudAPIStorageAdapter implements StorageAdapterInterface<CloudAPIAdapterConfig> {
+    readonly id = "storage.cloud-api";
+    readonly capabilities: StorageAdapterCapabilities;
+    /** The configuration the next store or record opens with; replaced, never merged, by `configure()`. */
+    private binding;
+    /** Per-namespace and per-record scoped bindings preventing concurrent configure() races. */
+    private readonly namespaceBindings;
+    /** A test client every store and record uses instead of the fetch transport. */
+    private injected;
+    /** Endpoint declarations registered by manifests, for the health probe's transport. */
+    private readonly endpoints;
+    /** Constructed by the storage/adapter kind with the runtime's kind context; the binding carries each caller's runtime. */
+    constructor(_descriptor?: {
+        readonly id: string;
+    }, _context?: KindContext);
+    configure(config: CloudAPIAdapterConfig): void;
+    /** Use `client` for every store and record (tests). */
+    setClient(client: CloudSettingsClient | CloudApiTransport): void;
+    isConfigured(): boolean;
+    /**
+     * The origin of one binding, in order: an explicit `apiEndpoint`; else
+     * `ownerApp`'s declared `infra/service` origin for the service environment
+     * the handed runtime selects; else refuse `service-undeclared`. There is no
+     * environment `apiUrl` or `VIBES_API_URL` fallback (rc04 §2.4).
+     */
+    private originOf;
+    /**
+     * Per request: an explicit configured token, else the host's first-party
+     * service token (the `VIBES_INTERNAL_SERVICE_TOKEN` credential), else the
+     * caller's bearer (`resolveStorageCallerBearer`), all on the handed runtime.
+     */
+    private resolveApiToken;
+    /** The transport for one binding: the injected test client, else a fetch transport on the binding's origin. */
+    private transportFor;
+    /**
+     * Register a per-namespace endpoint (from a manifest's adapterConfig). A
+     * store reads its own manifest's endpoint; this registry serves the health
+     * probe.
+     */
+    registerEndpoint(namespace: string, endpoint: string): void;
+    registerEndpointConfig(namespace: string, config: CloudEndpointConfig): void;
+    documentStore<T, Manifest = undefined>(namespace: string, schema: z.ZodType<T>, manifest?: Manifest): StorageDocumentStoreInterface<T>;
+    keyValueStore<TKey, TValue>(_namespace: string, _keySchema: z.ZodType<TKey>, _valueSchema: z.ZodType<TValue>): StorageKeyValueInterface<TKey, TValue>;
+    repository<T>(_tableName: string, _schema: z.ZodType<T>, _options?: RepositoryOptions): StorageRepositoryInterface<T>;
+    /**
+     * A record bound to its own descriptor's configuration. Resolved through a
+     * kind context (a `StorageRecord`), it carries only the configured runtime
+     * and its descriptor's fields, exactly what that record configured, so a
+     * sibling record's configure() racing it cannot lend its origin or token.
+     */
+    record<T = unknown>(descriptor: StorageRecordDescriptor, context?: KindContext): StorageRecordInterface<T>;
+    /** The current configuration resolves to an origin (an explicit endpoint or a declared owner service). */
+    ensureReady(): Promise<void>;
+    getDatabaseConnection(): never;
+    initialize(): Promise<void>;
+    close(): Promise<void>;
+    healthCheck(): Promise<StorageHealthStatus>;
+}
+/** Create an isolated adapter instance (lifecycle, concurrency and isolation tests). */
+export declare function createCloudAPIStorageAdapter(): StorageAdapterInterface<CloudAPIAdapterConfig>;
+declare const _default: import("@vibesdotdev/kernel").RuntimeImplementationWrapper<typeof CloudAPIStorageAdapter>;
+export default _default;
+/**
+ * Create a Cloud API adapter whose every store and record uses `mockClient`
+ * (for testing).
+ */
+export declare function createTestCloudAPIAdapter(mockClient: CloudSettingsClient | CloudApiTransport): StorageAdapterInterface<CloudAPIAdapterConfig>;
+export { createMockCloudClient } from './cloud-api.test-utils.ts';
+//# sourceMappingURL=cloud-api.adapter.impl.d.ts.map

package/dist/adapters/cloud-api/cloud-api.adapter.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-api.adapter.impl.d.ts","sourceRoot":"","sources":["../../../src/adapters/cloud-api/cloud-api.adapter.impl.ts"],"names":[],"mappings":"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"}