@vibesdotdev/integrations-redis 0.0.0-stage → 1.0.0-rc.2

package/LICENSE

@@ -0,0 +1,126 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             VIBES DEV LLC
+Licensed Work:        @vibesdotdev/integrations-kafka
+                      The Licensed Work is (c) 2026 VIBES DEV LLC.
+Additional Use Grant: In this grant, "Vibes Platform" means the hosted services VIBES DEV LLC
+                      operates at vibes.dev and its subdomains.
+
+                      You may make production use of the Licensed Work, including commercial
+                      use, subject to the limits below. Permitted production use includes:
+                      building, operating and selling your own applications, agents and services
+                      on or with the Vibes Platform; self-hosting the Licensed Work for use inside
+                      your own organization; and providing consulting, integration or development
+                      services to clients who build on the Vibes Platform.
+
+                      The production use permitted above does not include use that:
+
+                      (a) offers third parties a hosted, managed or embedded service that
+                          substitutes for the Vibes Platform or a material part of it (including
+                          agent hosting; fleet, sandbox or container provisioning; package
+                          registry; source hosting and continuous integration; and managed AI,
+                          storage, secrets or messaging), where the Licensed Work provides a
+                          material part of that service's value and that service earns more than
+                          US$1,000,000 in gross revenue in any twelve-month period;
+                      (b) sells, rents, sublicenses or white-labels the Licensed Work, or access
+                          to Vibes Platform functionality, as a product in its own right;
+                      (c) removes, disables or works around entitlement checks, usage metering,
+                          quotas or plan limits, or reaches Vibes Platform features the user's
+                          account is not entitled to;
+                      (d) scrapes, bulk-exports or harvests data or content from the Vibes
+                          Platform or its users other than through documented interfaces and
+                          within their terms, or uses outputs or data obtained from the Vibes
+                          Platform to train or improve a product that competes with it;
+                      (e) violates applicable law, infringes anyone's rights, commits fraud or
+                          deception, conducts unlawful surveillance or harassment, distributes
+                          malware, or accesses systems without authorization; or
+                      (f) violates applicable antitrust or competition law.
+
+                      A written permission from the Licensor extends this grant.
+Change Date:          Four years from the date the Licensed Work is published.
+Change License:       MIT
+
+For information about alternative licensing arrangements for the Licensed Work,
+contact VIBES DEV LLC through https://vibes.dev.
+
+Notice
+
+The Business Source License (this document, or the "License") is not an Open
+Source license. However, the Licensed Work will eventually be made available
+under an Open Source License, as stated in this License.
+
+-----------------------------------------------------------------------------
+
+Business Source License 1.1
+
+License text copyright © 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited
+production use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN “AS IS” BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License’s text to license
+your works, and to refer to it using the trademark “Business Source License”,
+as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License’s text and the “Business
+Source License” name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where “compatible” means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text “None”.
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.

package/README.md

@@ -1,3 +1,22 @@
-# Temporary Holding Version
+# @vibesdotdev/integrations-redis
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Redis connections, command spans and the Workers scheduler lock (moved from `@vibesdotdev/logging` and `@vibesdotdev/workers`). The root and `./plugin` are isomorphic, with no static Redis SDK import; `redisPlugin` registers the `integrations.redis` config manifest and the `redis` runtime client.
+
+## Entrypoints
+
+| Import |
+|---|
+| `@vibesdotdev/integrations-redis` |
+| `@vibesdotdev/integrations-redis/plugin` |
+| `@vibesdotdev/integrations-redis/manager` |
+| `@vibesdotdev/integrations-redis/connections` |
+| `@vibesdotdev/integrations-redis/instrumented` |
+| `@vibesdotdev/integrations-redis/scheduler-lock` |
+| `@vibesdotdev/integrations-redis/client` |
+| `@vibesdotdev/integrations-redis/consumer-plugin` |
+
+`SPEC.md` in this directory is the package contract.
+
+## License
+
+BUSL-1.1. See `LICENSE`.

package/dist/client.d.ts

@@ -0,0 +1,10 @@
+import { BaseRuntimeClient } from '@vibesdotdev/kernel/client';
+import { RedisConnectionManager } from './manager.ts';
+import { RedisConnections } from './connections.ts';
+export declare class RedisClient extends BaseRuntimeClient {
+    readonly manager: RedisConnectionManager;
+    readonly purposes: RedisConnections;
+    protected onDispose(): Promise<void>;
+}
+export { getVibesClient, tryGetVibesClient } from '@vibesdotdev/kernel/client';
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,qBAAa,WAAY,SAAQ,iBAAiB;IACjD,QAAQ,CAAC,OAAO,yBAA4C;IAC5D,QAAQ,CAAC,QAAQ,mBAA0D;cAElD,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;CAGnD;AACD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/client.js

@@ -0,0 +1,12 @@
+import { BaseRuntimeClient } from '@vibesdotdev/kernel/client';
+import { RedisConnectionManager } from "./manager.js";
+import { RedisConnections } from "./connections.js";
+export class RedisClient extends BaseRuntimeClient {
+    manager = new RedisConnectionManager(this.runtime);
+    purposes = new RedisConnections(this.runtime, () => this.manager);
+    async onDispose() {
+        await this.purposes.dispose(this.manager);
+    }
+}
+export { getVibesClient, tryGetVibesClient } from '@vibesdotdev/kernel/client';
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEpD,MAAM,OAAO,WAAY,SAAQ,iBAAiB;IACxC,OAAO,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACnD,QAAQ,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAExD,KAAK,CAAC,SAAS;QACjC,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC;CACD;AACD,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/client.node.d.ts

@@ -0,0 +1,7 @@
+import { RedisClient } from './client.ts';
+import { RedisConnectionManager } from './manager.ts';
+export declare class NodeRedisClient extends RedisClient {
+    readonly manager: RedisConnectionManager;
+}
+export declare const impl: typeof NodeRedisClient;
+//# sourceMappingURL=client.node.d.ts.map

package/dist/client.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.node.d.ts","sourceRoot":"","sources":["../src/client.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAEtD,qBAAa,eAAgB,SAAQ,WAAW;IAC/C,SAAkB,OAAO,yBACgC;CACzD;AACD,eAAO,MAAM,IAAI,wBAAkB,CAAC"}

package/dist/client.node.js

@@ -0,0 +1,8 @@
+import IORedis from 'ioredis';
+import { RedisClient } from "./client.js";
+import { RedisConnectionManager } from "./manager.js";
+export class NodeRedisClient extends RedisClient {
+    manager = new RedisConnectionManager(this.runtime, (url, options) => url ? new IORedis(url, options) : new IORedis(options));
+}
+export const impl = NodeRedisClient;
+//# sourceMappingURL=client.node.js.map

package/dist/client.node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.node.js","sourceRoot":"","sources":["../src/client.node.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAEtD,MAAM,OAAO,eAAgB,SAAQ,WAAW;IAC7B,OAAO,GAAG,IAAI,sBAAsB,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,EAAE,CACrF,GAAG,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;CACzD;AACD,MAAM,CAAC,MAAM,IAAI,GAAG,eAAe,CAAC"}

package/dist/config.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Redis settings — the `integrations.redis` config manifest.
+ *
+ * Non-secret connection settings only; the URL (which carries the password)
+ * is the `REDIS_URL` credential, or a purpose's own `REDIS_<PURPOSE>_URL`.
+ * Declared as data with `createRuntimeAsset`; the runtime holds it until
+ * `config/manifest` registers.
+ */
+export { RedisSettingsSchema, type RedisSettings } from './schemas/settings.ts';
+export declare const REDIS_SETTINGS_MANIFEST_ID = "integrations.redis";
+/** The config owner's typed read contract for these settings. */
+export declare const redisSettingsManifest: {
+    id: string;
+    schema: import("zod/v4").ZodObject<{
+        maxRetriesPerRequest: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+        readinessTimeoutMs: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        purposes: import("zod/v4").ZodPrefault<import("zod/v4").ZodObject<{
+            cache: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            sessions: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            workers: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            pubsub: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            gpu_queue: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            model_registry: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+};
+export declare const redisSettingsDescriptor: {
+    kind: "config/manifest";
+    id: string;
+    name: string;
+    namespace: string;
+    description: string;
+    tier: string;
+    category: string;
+    schema: import("zod/v4").ZodObject<{
+        maxRetriesPerRequest: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+        readinessTimeoutMs: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+        purposes: import("zod/v4").ZodPrefault<import("zod/v4").ZodObject<{
+            cache: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            sessions: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            workers: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            pubsub: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            gpu_queue: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+            model_registry: import("zod/v4").ZodDefault<import("zod/v4").ZodObject<{
+                enableReadyCheck: import("zod/v4").ZodDefault<import("zod/v4").ZodBoolean>;
+                connectTimeout: import("zod/v4").ZodDefault<import("zod/v4").ZodNumber>;
+                maxRetriesPerRequest: import("zod/v4").ZodOptional<import("zod/v4").ZodNullable<import("zod/v4").ZodNumber>>;
+                autoResendUnfulfilledCommands: import("zod/v4").ZodOptional<import("zod/v4").ZodBoolean>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>;
+    fields: {
+        maxRetriesPerRequest: {
+            ui: {
+                label: string;
+                component: string;
+                group: string;
+            };
+        };
+        enableReadyCheck: {
+            ui: {
+                label: string;
+                component: string;
+                group: string;
+            };
+        };
+    };
+    groups: {
+        id: string;
+        label: string;
+    }[];
+    allowedAdapters: string[];
+    defaultAdapter: string;
+    scope: string;
+    customTables: boolean;
+    version: number;
+    internal: boolean;
+    context: {
+        surfaces: string[];
+    };
+    enabled: true;
+};
+export default redisSettingsDescriptor;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAAE,mBAAmB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAGhF,eAAO,MAAM,0BAA0B,uBAAuB,CAAC;AAE/D,iEAAiE;AACjE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAAkE,CAAC;AAErG,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBlC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/dist/config.js

@@ -0,0 +1,39 @@
+/**
+ * Redis settings — the `integrations.redis` config manifest.
+ *
+ * Non-secret connection settings only; the URL (which carries the password)
+ * is the `REDIS_URL` credential, or a purpose's own `REDIS_<PURPOSE>_URL`.
+ * Declared as data with `createRuntimeAsset`; the runtime holds it until
+ * `config/manifest` registers.
+ */
+import { RedisSettingsSchema } from "./schemas/settings.js";
+export { RedisSettingsSchema } from "./schemas/settings.js";
+import { createRuntimeAsset } from '@vibesdotdev/kernel';
+export const REDIS_SETTINGS_MANIFEST_ID = 'integrations.redis';
+/** The config owner's typed read contract for these settings. */
+export const redisSettingsManifest = { id: REDIS_SETTINGS_MANIFEST_ID, schema: RedisSettingsSchema };
+export const redisSettingsDescriptor = createRuntimeAsset({
+    kind: 'config/manifest',
+    id: REDIS_SETTINGS_MANIFEST_ID,
+    name: 'Redis',
+    namespace: 'integrations',
+    description: 'Redis client settings (the connection URL is the REDIS_URL secret)',
+    tier: 'user',
+    category: 'integrations',
+    schema: RedisSettingsSchema,
+    fields: {
+        maxRetriesPerRequest: { ui: { label: 'Retries per request', component: 'number', group: 'redis' } },
+        enableReadyCheck: { ui: { label: 'Ready check', component: 'switch', group: 'redis' } }
+    },
+    groups: [{ id: 'redis', label: 'Redis' }],
+    allowedAdapters: ['storage.localdb', 'storage.json'],
+    defaultAdapter: 'storage.localdb',
+    scope: 'auto',
+    customTables: false,
+    version: 1,
+    internal: false,
+    context: { surfaces: ['cli', 'tui'] },
+    enabled: true
+});
+export default redisSettingsDescriptor;
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,mBAAmB,EAAsB,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAEzD,MAAM,CAAC,MAAM,0BAA0B,GAAG,oBAAoB,CAAC;AAE/D,iEAAiE;AACjE,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,EAAE,EAAE,0BAA0B,EAAE,MAAM,EAAE,mBAAmB,EAAE,CAAC;AAErG,MAAM,CAAC,MAAM,uBAAuB,GAAG,kBAAkB,CAAC;IACzD,IAAI,EAAE,iBAAiB;IACvB,EAAE,EAAE,0BAA0B;IAC9B,IAAI,EAAE,OAAO;IACb,SAAS,EAAE,cAAc;IACzB,WAAW,EAAE,oEAAoE;IACjF,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,cAAc;IACxB,MAAM,EAAE,mBAAmB;IAC3B,MAAM,EAAE;QACP,oBAAoB,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,qBAAqB,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QACnG,gBAAgB,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;KACvF;IACD,MAAM,EAAE,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;IACzC,eAAe,EAAE,CAAC,iBAAiB,EAAE,cAAc,CAAC;IACpD,cAAc,EAAE,iBAAiB;IACjC,KAAK,EAAE,MAAM;IACb,YAAY,EAAE,KAAK;IACnB,OAAO,EAAE,CAAC;IACV,QAAQ,EAAE,KAAK;IACf,OAAO,EAAE,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,EAAE;IACrC,OAAO,EAAE,IAAI;CACb,CAAC,CAAC;AAEH,eAAe,uBAAuB,CAAC"}

package/dist/connections.d.ts

@@ -0,0 +1,56 @@
+import type Redis from 'ioredis';
+import { type RedisConnectionManager } from './manager.ts';
+import type { RuntimeRef } from '@vibesdotdev/kernel';
+import { type RedisConnectionConfig } from './schemas/connection.ts';
+export type { RedisConnectionConfig } from './schemas/connection.ts';
+export { REDIS_URL, redisPurposeUrlKey, resolveRedisUrl } from './manager.ts';
+export declare enum RedisConnectionPurpose {
+    CACHE = "cache",
+    SESSIONS = "sessions",
+    WORKERS = "workers",
+    PUBSUB = "pubsub",
+    GPU_QUEUE = "gpu_queue",
+    MODEL_REGISTRY = "model_registry"
+}
+/** The Redis connections of one runtime, one per purpose. */
+export declare class RedisConnections {
+    private readonly runtime;
+    private readonly ownedManager?;
+    private readonly pending;
+    private closing;
+    private connections;
+    private connectionConfigs;
+    constructor(runtime: RuntimeRef, ownedManager?: (() => RedisConnectionManager) | undefined);
+    private get manager();
+    /** Resolve `purpose`'s connection config on first use (its URL is a credential), never at import. */
+    private configFor;
+    /**
+     * Get or create a Redis connection for a specific purpose
+     * Returns null only on a declared build host, which never connects. A
+     * missing URL, a credential-store failure, or a Redis that refuses the
+     * connection rejects with a typed `UNAVAILABLE` error.
+     */
+    getConnection(purpose: RedisConnectionPurpose): Promise<Redis | null>;
+    private acquire;
+    /**
+     * Get configuration for a specific purpose
+     */
+    getConfig(purpose: RedisConnectionPurpose): Promise<RedisConnectionConfig>;
+    /**
+     * Close a specific connection
+     */
+    closeConnection(purpose: RedisConnectionPurpose): Promise<void>;
+    dispose(manager: RedisConnectionManager): Promise<void>;
+    /**
+     * Close all connections
+     */
+    closeAll(): Promise<void>;
+}
+export declare function redisConnectionsFor(runtime: RuntimeRef): RedisConnections;
+export declare function getCacheConnection(runtime: RuntimeRef): Promise<Redis | null>;
+export declare function getSessionsConnection(runtime: RuntimeRef): Promise<Redis | null>;
+export declare function getWorkersConnection(runtime: RuntimeRef): Promise<Redis | null>;
+export declare function getPubSubConnection(runtime: RuntimeRef): Promise<Redis | null>;
+export declare function getGPUQueueConnection(runtime: RuntimeRef): Promise<Redis | null>;
+export declare function getModelRegistryConnection(runtime: RuntimeRef): Promise<Redis | null>;
+//# sourceMappingURL=connections.d.ts.map

package/dist/connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","sourceRoot":"","sources":["../src/connections.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAEjC,OAAO,EAAyE,KAAK,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAClI,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAA+B,KAAK,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAClG,YAAY,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAErE,OAAO,EAAE,SAAS,EAAE,kBAAkB,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE9E,oBAAY,sBAAsB;IACjC,KAAK,UAAU;IACf,QAAQ,aAAa;IACrB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,SAAS,cAAc;IACvB,cAAc,mBAAmB;CACjC;AAED,6DAA6D;AAC7D,qBAAa,gBAAgB;IAMhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAAc,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;IALhF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4D;IACpF,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAwD;IAC3E,OAAO,CAAC,iBAAiB,CAAiE;gBAE7D,OAAO,EAAE,UAAU,EAAmB,YAAY,CAAC,GAAE,MAAM,sBAAsB,aAAA;IAE9G,OAAO,KAAK,OAAO,GAA6F;IAEhH,qGAAqG;YACvF,SAAS;IAcvB;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC;YAWvD,OAAO;IAkDrB;;OAEG;IACG,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIhF;;OAEG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAQ/D,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAa7D;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAM/B;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,gBAAgB,CAEzE;AAGD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAE7E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAEhF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAE/E;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAE9E;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAEhF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAErF"}

package/dist/connections.js

@@ -0,0 +1,166 @@
+import { getVibesClient } from '@vibesdotdev/kernel/client';
+import { RedisSettingsSchema, redisSettingsManifest } from "./config.js";
+import { CapabilityError, valueFreeFailure, settle, settleNow } from '@vibesdotdev/kernel';
+import { redisManagerFor, redisClientFor, resolveRedisUrl, isDeclaredBuildHost } from "./manager.js";
+import { RedisConnectionConfigSchema } from "./schemas/connection.js";
+export { REDIS_URL, redisPurposeUrlKey, resolveRedisUrl } from "./manager.js";
+export var RedisConnectionPurpose;
+(function (RedisConnectionPurpose) {
+    RedisConnectionPurpose["CACHE"] = "cache";
+    RedisConnectionPurpose["SESSIONS"] = "sessions";
+    RedisConnectionPurpose["WORKERS"] = "workers";
+    RedisConnectionPurpose["PUBSUB"] = "pubsub";
+    RedisConnectionPurpose["GPU_QUEUE"] = "gpu_queue";
+    RedisConnectionPurpose["MODEL_REGISTRY"] = "model_registry";
+})(RedisConnectionPurpose || (RedisConnectionPurpose = {}));
+/** The Redis connections of one runtime, one per purpose. */
+export class RedisConnections {
+    runtime;
+    ownedManager;
+    pending = new Map();
+    closing = false;
+    connections = new Map();
+    connectionConfigs = new Map();
+    constructor(runtime, ownedManager) {
+        this.runtime = runtime;
+        this.ownedManager = ownedManager;
+    }
+    get manager() { return this.ownedManager?.() ?? redisManagerFor(this.runtime); }
+    /** Resolve `purpose`'s connection config on first use (its URL is a credential), never at import. */
+    async configFor(purpose) {
+        const known = this.connectionConfigs.get(purpose);
+        if (known)
+            return known;
+        const url = await resolveRedisUrl(this.runtime, purpose);
+        const settings = await (await getVibesClient('config', this.runtime)).read(redisSettingsManifest);
+        const config = RedisConnectionConfigSchema.parse({
+            url,
+            options: settings.purposes[purpose],
+            readinessTimeoutMs: settings.readinessTimeoutMs
+        });
+        this.connectionConfigs.set(purpose, config);
+        return config;
+    }
+    /**
+     * Get or create a Redis connection for a specific purpose
+     * Returns null only on a declared build host, which never connects. A
+     * missing URL, a credential-store failure, or a Redis that refuses the
+     * connection rejects with a typed `UNAVAILABLE` error.
+     */
+    getConnection(purpose) {
+        if (this.closing)
+            return Promise.reject(new CapabilityError('Redis is disposing', 'CANCELLED', { reason: 'redis-disposing' }));
+        const pending = this.pending.get(purpose);
+        if (pending)
+            return pending;
+        const attempt = this.acquire(purpose).finally(() => {
+            if (this.pending.get(purpose) === attempt)
+                this.pending.delete(purpose);
+        });
+        this.pending.set(purpose, attempt);
+        return attempt;
+    }
+    async acquire(purpose) {
+        // A declared finite build (prerender) never connects.
+        if (isDeclaredBuildHost(this.runtime)) {
+            return null;
+        }
+        const existing = this.connections.get(purpose);
+        if (existing && existing.status !== 'end') {
+            await this.manager.waitForConnection(existing, this.runtime.lifecycle, this.connectionConfigs.get(purpose)?.readinessTimeoutMs);
+            return existing;
+        }
+        // A missing URL or a credential store failure propagates, typed.
+        const config = await this.configFor(purpose);
+        let connection;
+        const acquired = await settle(async () => {
+            // Create the connection through the manager this runtime owns
+            connection = this.manager.createConnection(this.runtime, config.url, config.options);
+            // Store in our map
+            this.connections.set(purpose, connection);
+            await this.manager.waitForConnection(connection, this.runtime.lifecycle, config.readinessTimeoutMs);
+            const readyConnection = connection;
+            await this.runtime.lifecycle.wait(signal => new Promise((resolve, reject) => {
+                const abort = () => reject(signal.reason);
+                if (signal.aborted) {
+                    abort();
+                    return;
+                }
+                signal.addEventListener('abort', abort, { once: true });
+                readyConnection.ping().then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+            }), { timeoutMs: config.readinessTimeoutMs ?? RedisSettingsSchema.parse({}).readinessTimeoutMs, reason: 'redis-ping' });
+            return connection;
+        });
+        if (acquired.ok)
+            return acquired.value;
+        if (this.connections.get(purpose) === connection)
+            this.connections.delete(purpose);
+        const failedConnection = connection;
+        const cleanup = failedConnection ? settleNow(() => failedConnection.disconnect()) : null;
+        const failure = valueFreeFailure(acquired.cause);
+        const cause = cleanup && !cleanup.ok
+            ? new AggregateError([failure, valueFreeFailure(cleanup.cause)], 'Redis acquisition and cleanup failed')
+            : failure;
+        throw new CapabilityError(`Redis connection for '${purpose}' failed`, 'UNAVAILABLE', { reason: 'redis-connection-failed', retryable: true, details: { purpose, disconnectFailure: cleanup !== null && !cleanup.ok }, cause });
+    }
+    /**
+     * Get configuration for a specific purpose
+     */
+    async getConfig(purpose) {
+        return this.configFor(purpose);
+    }
+    /**
+     * Close a specific connection
+     */
+    async closeConnection(purpose) {
+        const connection = this.connections.get(purpose);
+        if (connection) {
+            await connection.quit();
+            if (this.connections.get(purpose) === connection)
+                this.connections.delete(purpose);
+        }
+    }
+    async dispose(manager) {
+        this.closing = true;
+        this.connectionConfigs.clear();
+        await Promise.allSettled(this.pending.values());
+        try {
+            await manager.closeAllConnections();
+            this.connections.clear();
+        }
+        finally {
+            this.connectionConfigs.clear();
+            this.closing = false;
+        }
+    }
+    /**
+     * Close all connections
+     */
+    async closeAll() {
+        const closePromises = Array.from(this.connections.keys()).map((purpose) => this.closeConnection(purpose));
+        await Promise.all(closePromises);
+    }
+}
+export function redisConnectionsFor(runtime) {
+    return redisClientFor(runtime).purposes;
+}
+// Convenience functions for each purpose, on the runtime the caller was handed.
+export function getCacheConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.CACHE);
+}
+export function getSessionsConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.SESSIONS);
+}
+export function getWorkersConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.WORKERS);
+}
+export function getPubSubConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.PUBSUB);
+}
+export function getGPUQueueConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.GPU_QUEUE);
+}
+export function getModelRegistryConnection(runtime) {
+    return redisConnectionsFor(runtime).getConnection(RedisConnectionPurpose.MODEL_REGISTRY);
+}
+//# sourceMappingURL=connections.js.map