@absolutejs/sync-bus-redis 0.0.1

package/README.md

@@ -0,0 +1,119 @@
+# @absolutejs/sync-bus-redis
+
+Redis pub/sub `ClusterBus` for
+[@absolutejs/sync](https://github.com/absolutejs/sync). Sibling to
+[`@absolutejs/sync-bus-pg`](../bus-pg) — same `ClusterBus` contract,
+different transport.
+
+## When to use Redis vs Postgres
+
+| Concern | `sync-bus-redis` | `sync-bus-pg` |
+|---|---|---|
+| Payload size | No cap — JSON through | 8KB NOTIFY cap (spill-table fallback) |
+| Fan-out latency at 10+ subscribers | In-memory, low | WAL-replicated, higher |
+| Geo-replication | Native (Redis Cluster, ElastiCache, Memorystore, Upstash) | Heavy ops (PG logical replication) |
+| Delivery semantics | At-most-once (no message retention) | At-most-once (NOTIFY) + spill rows for oversized |
+| Already in your stack? | If yes → win-win | If yes → win-win |
+
+**The headline tradeoff.** Redis is in-memory pub/sub — a subscriber
+that's disconnected when a message fires misses it. For
+cross-instance resume past shard reboot, pair with
+`engine.exportChangeLog()` / `importChangeLog()` (sync 1.19.0+)
+regardless of which bus you use.
+
+## Install
+
+```sh
+bun add @absolutejs/sync @absolutejs/sync-bus-redis
+# Plus a Redis client — bring your own:
+bun add ioredis            # OR
+bun add redis              # node-redis v4+
+```
+
+The adapter has no hard runtime dep on a specific Redis client.
+
+## Usage with `ioredis`
+
+```ts
+import { Redis } from 'ioredis';
+import { createSyncEngine } from '@absolutejs/sync/engine';
+import { createRedisClusterBus } from '@absolutejs/sync-bus-redis';
+
+const publisher = new Redis(process.env.REDIS_URL!);
+const subscriberClient = new Redis(process.env.REDIS_URL!);
+
+// ioredis: a subscribed connection can't issue other commands.
+// Bridge its EventEmitter API into our (channel, listener) shape:
+const subscriber = {
+  subscribe: async (channel: string, listener: (msg: string) => void) => {
+    await subscriberClient.subscribe(channel);
+    const handler = (chan: string, msg: string) => {
+      if (chan === channel) listener(msg);
+    };
+    subscriberClient.on('message', handler);
+    return async () => {
+      subscriberClient.off('message', handler);
+      await subscriberClient.unsubscribe(channel);
+    };
+  },
+};
+
+const bus = createRedisClusterBus({ publisher, subscriber });
+const engine = createSyncEngine({ instanceId: 'shard-A' });
+await engine.connectCluster(bus);
+```
+
+## Usage with `node-redis` v4+
+
+```ts
+import { createClient } from 'redis';
+import { createRedisClusterBus } from '@absolutejs/sync-bus-redis';
+
+const publisher = createClient({ url: process.env.REDIS_URL });
+const subscriberClient = publisher.duplicate();
+await Promise.all([publisher.connect(), subscriberClient.connect()]);
+
+// node-redis: subscribe takes a callback directly.
+const subscriber = {
+  subscribe: async (channel: string, listener: (msg: string) => void) => {
+    await subscriberClient.subscribe(channel, listener);
+    return async () => {
+      await subscriberClient.unsubscribe(channel);
+    };
+  },
+};
+
+const bus = createRedisClusterBus({ publisher, subscriber });
+```
+
+## API
+
+```ts
+createRedisClusterBus({
+  publisher,         // RedisPublisher — publish(channel, message)
+  subscriber,        // RedisSubscriber — subscribe(channel, listener) → unsubscribe fn
+  channel?,          // default 'absolutejs_sync_cluster'
+  onError?,          // logger for parse / delivery failures
+});
+```
+
+Returns `ClusterBus & { metrics() }`. Pass to `engine.connectCluster(bus)`.
+
+### `bus.metrics()`
+
+```ts
+{
+  published: number;             // PUBLISH calls
+  received: number;              // messages parsed + delivered to onMessage
+  publishErrors: number;         // publisher.publish() rejections
+  subscribeErrors: number;       // JSON.parse failures on incoming messages
+  totalSubscribersReached: number; // sum of counts Redis returned from PUBLISH
+                                 // — a drop to 0 when you expect peers signals
+                                 // subscriber disconnects (partition, restart)
+}
+```
+
+## License
+
+[Apache 2.0](../LICENSE). Tier B substrate-adjacent under the
+AbsoluteJS licensing policy — rides `@absolutejs/sync` (BSL Tier A).

package/dist/index.d.ts

@@ -0,0 +1,117 @@
+/**
+ * @absolutejs/sync-bus-redis — Redis pub/sub `ClusterBus` for
+ * `@absolutejs/sync`. Cross-instance fan-out via PUBLISH/SUBSCRIBE.
+ *
+ * **Why Redis (vs the `sync-bus-pg` sibling).**
+ *
+ *   - **No payload cap.** Postgres `NOTIFY` is capped at 8000 bytes,
+ *     forcing `sync-bus-pg` into a spill-table dance for large batches.
+ *     Redis PUBLISH has no equivalent limit — JSON straight through.
+ *   - **Lower latency at fan-out.** Redis pub/sub is in-memory; PG
+ *     `LISTEN/NOTIFY` rides the WAL replication path. For multi-shard
+ *     fan-out (10+ subscribers), Redis is typically faster.
+ *   - **Better geo-replication story.** Redis Cluster / Redis
+ *     Enterprise / managed Redis (ElastiCache, Memorystore, Upstash)
+ *     all geo-replicate natively. Postgres logical replication is
+ *     possible but heavier ops.
+ *
+ * **Why NOT Redis (when to use `sync-bus-pg` instead).**
+ *
+ *   - **At-most-once delivery.** Redis pub/sub does NOT durably store
+ *     messages. A subscriber that's disconnected when a message fires
+ *     misses it. If you need a durable cluster bus for replay across
+ *     shard reboot, use `sync-bus-pg` (which has the spill table) and
+ *     pair with `engine.exportChangeLog()` / `importChangeLog()` for
+ *     post-reboot resume.
+ *   - **Already have Postgres in your stack.** Adding Redis just for
+ *     the cluster bus is a new dependency to operate.
+ *
+ * **Client compatibility.**
+ *
+ * The adapter takes a narrow interface (`publisher.publish(channel,
+ * message)` and `subscriber.subscribe(channel, listener)`) so it works
+ * with any 2026-era Redis client:
+ *
+ *   - `ioredis`: `const redis = new Redis(url); const sub = redis.duplicate();`
+ *   - `node-redis` v4+: `const client = createClient({ url }); const sub = client.duplicate();`
+ *
+ * Each pub/sub-using consumer needs TWO connections — one for
+ * publishing (your existing client), one for subscribing (a duplicate
+ * dedicated to the subscription, because Redis prohibits other
+ * commands on a subscribed connection). Pass both to
+ * `createRedisClusterBus({ publisher, subscriber })`.
+ *
+ * See `README.md` for `ioredis` and `node-redis` adapter snippets.
+ */
+import type { ClusterBus } from '@absolutejs/sync/engine';
+/**
+ * Minimal Redis publisher contract. Both `ioredis` and `node-redis` v4
+ * structurally satisfy this (`publish(channel, message)` is the
+ * canonical signature; both return a Promise that resolves to the
+ * number of subscribers that received the message).
+ */
+export type RedisPublisher = {
+    publish: (channel: string, message: string) => Promise<number | unknown>;
+};
+/**
+ * Minimal Redis subscriber contract. The shape diverges between
+ * ioredis (EventEmitter-based) and node-redis (callback-based);
+ * `RedisSubscriber` is the lowest-common-denominator:
+ *
+ *   - `subscribe(channel, listener)` registers `listener` for messages
+ *     on `channel` AND returns an unsubscribe function. The listener
+ *     receives the raw message string.
+ *
+ * The README shows how to wrap ioredis (where you'd call
+ * `subscriber.on('message', handler)` once and route by channel) and
+ * node-redis (where `subscribe(channel, listener)` is the SDK call
+ * directly).
+ */
+export type RedisSubscriber = {
+    subscribe: (channel: string, listener: (message: string) => void) => Promise<() => Promise<void>>;
+};
+export type CreateRedisClusterBusOptions = {
+    /** The Redis client used for `publish()` calls. */
+    publisher: RedisPublisher;
+    /** The Redis subscriber. MUST be a dedicated connection (a
+     *  `duplicate()` of your main client) — Redis forbids other
+     *  commands on a subscribed connection. */
+    subscriber: RedisSubscriber;
+    /**
+     * Channel name. Defaults to `'absolutejs_sync_cluster'`. Two
+     * engines on the same Redis can scope themselves to different
+     * channels by overriding this.
+     */
+    channel?: string;
+    /**
+     * Called when message parsing / delivery fails. Defaults to
+     * `console.warn`. Note that Redis pub/sub doesn't surface delivery
+     * failures on the publisher side — `publish()` resolves to the
+     * count of subscribers that received the message (or 0); a 0 count
+     * does NOT fire onError (Redis treats "no subscribers" as success).
+     */
+    onError?: (error: unknown) => void;
+};
+/**
+ * Cumulative metrics since `createRedisClusterBus()`. Same shape
+ * style as `sync-bus-pg`'s — minus the spill-table fields (Redis
+ * has no equivalent).
+ */
+export type RedisClusterBusMetrics = {
+    published: number;
+    received: number;
+    publishErrors: number;
+    subscribeErrors: number;
+    /**
+     * Cumulative count of subscribers reached on the publisher side.
+     * Returned by Redis's PUBLISH. Use it as a rough "is the cluster
+     * still wired up" signal — a drop to 0 when you expect peers means
+     * subscribers disconnected (replication lag, network partition).
+     */
+    totalSubscribersReached: number;
+};
+export type RedisClusterBus = ClusterBus & {
+    metrics: () => RedisClusterBusMetrics;
+};
+export declare const createRedisClusterBus: (options: CreateRedisClusterBusOptions) => RedisClusterBus;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,yBAAyB,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG;IAC5B,OAAO,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,OAAO,CAAC,CAAC;CACzE,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,eAAe,GAAG;IAC7B,SAAS,EAAE,CACV,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,KAC/B,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IAC1C,mDAAmD;IACnD,SAAS,EAAE,cAAc,CAAC;IAC1B;;+CAE2C;IAC3C,UAAU,EAAE,eAAe,CAAC;IAC5B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACnC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB;;;;;OAKG;IACH,uBAAuB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,UAAU,GAAG;IAC1C,OAAO,EAAE,MAAM,sBAAsB,CAAC;CACtC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GACjC,SAAS,4BAA4B,KACnC,eA+CF,CAAC"}

package/dist/index.js

@@ -0,0 +1,48 @@
+// @bun
+// src/index.ts
+var createRedisClusterBus = (options) => {
+  const channel = options.channel ?? "absolutejs_sync_cluster";
+  const onError = options.onError ?? ((error) => console.warn("[sync-bus-redis]", error));
+  const counters = {
+    publishErrors: 0,
+    published: 0,
+    received: 0,
+    subscribeErrors: 0,
+    totalSubscribersReached: 0
+  };
+  return {
+    metrics: () => ({ ...counters }),
+    publish: async (message) => {
+      try {
+        const serialized = JSON.stringify(message);
+        const result = await options.publisher.publish(channel, serialized);
+        if (typeof result === "number") {
+          counters.totalSubscribersReached += result;
+        }
+        counters.published += 1;
+      } catch (error) {
+        counters.publishErrors += 1;
+        throw error;
+      }
+    },
+    subscribe: async (onMessage) => {
+      const listener = (raw) => {
+        try {
+          const parsed = JSON.parse(raw);
+          counters.received += 1;
+          onMessage(parsed);
+        } catch (error) {
+          counters.subscribeErrors += 1;
+          onError(error);
+        }
+      };
+      return options.subscriber.subscribe(channel, listener);
+    }
+  };
+};
+export {
+  createRedisClusterBus
+};
+
+//# debugId=0C163B79C3CB22BF64756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../src/index.ts"],
+  "sourcesContent": [
+    "/**\n * @absolutejs/sync-bus-redis — Redis pub/sub `ClusterBus` for\n * `@absolutejs/sync`. Cross-instance fan-out via PUBLISH/SUBSCRIBE.\n *\n * **Why Redis (vs the `sync-bus-pg` sibling).**\n *\n *   - **No payload cap.** Postgres `NOTIFY` is capped at 8000 bytes,\n *     forcing `sync-bus-pg` into a spill-table dance for large batches.\n *     Redis PUBLISH has no equivalent limit — JSON straight through.\n *   - **Lower latency at fan-out.** Redis pub/sub is in-memory; PG\n *     `LISTEN/NOTIFY` rides the WAL replication path. For multi-shard\n *     fan-out (10+ subscribers), Redis is typically faster.\n *   - **Better geo-replication story.** Redis Cluster / Redis\n *     Enterprise / managed Redis (ElastiCache, Memorystore, Upstash)\n *     all geo-replicate natively. Postgres logical replication is\n *     possible but heavier ops.\n *\n * **Why NOT Redis (when to use `sync-bus-pg` instead).**\n *\n *   - **At-most-once delivery.** Redis pub/sub does NOT durably store\n *     messages. A subscriber that's disconnected when a message fires\n *     misses it. If you need a durable cluster bus for replay across\n *     shard reboot, use `sync-bus-pg` (which has the spill table) and\n *     pair with `engine.exportChangeLog()` / `importChangeLog()` for\n *     post-reboot resume.\n *   - **Already have Postgres in your stack.** Adding Redis just for\n *     the cluster bus is a new dependency to operate.\n *\n * **Client compatibility.**\n *\n * The adapter takes a narrow interface (`publisher.publish(channel,\n * message)` and `subscriber.subscribe(channel, listener)`) so it works\n * with any 2026-era Redis client:\n *\n *   - `ioredis`: `const redis = new Redis(url); const sub = redis.duplicate();`\n *   - `node-redis` v4+: `const client = createClient({ url }); const sub = client.duplicate();`\n *\n * Each pub/sub-using consumer needs TWO connections — one for\n * publishing (your existing client), one for subscribing (a duplicate\n * dedicated to the subscription, because Redis prohibits other\n * commands on a subscribed connection). Pass both to\n * `createRedisClusterBus({ publisher, subscriber })`.\n *\n * See `README.md` for `ioredis` and `node-redis` adapter snippets.\n */\n\nimport type { ClusterBus, ClusterMessage } from '@absolutejs/sync/engine';\n\n/**\n * Minimal Redis publisher contract. Both `ioredis` and `node-redis` v4\n * structurally satisfy this (`publish(channel, message)` is the\n * canonical signature; both return a Promise that resolves to the\n * number of subscribers that received the message).\n */\nexport type RedisPublisher = {\n\tpublish: (channel: string, message: string) => Promise<number | unknown>;\n};\n\n/**\n * Minimal Redis subscriber contract. The shape diverges between\n * ioredis (EventEmitter-based) and node-redis (callback-based);\n * `RedisSubscriber` is the lowest-common-denominator:\n *\n *   - `subscribe(channel, listener)` registers `listener` for messages\n *     on `channel` AND returns an unsubscribe function. The listener\n *     receives the raw message string.\n *\n * The README shows how to wrap ioredis (where you'd call\n * `subscriber.on('message', handler)` once and route by channel) and\n * node-redis (where `subscribe(channel, listener)` is the SDK call\n * directly).\n */\nexport type RedisSubscriber = {\n\tsubscribe: (\n\t\tchannel: string,\n\t\tlistener: (message: string) => void\n\t) => Promise<() => Promise<void>>;\n};\n\nexport type CreateRedisClusterBusOptions = {\n\t/** The Redis client used for `publish()` calls. */\n\tpublisher: RedisPublisher;\n\t/** The Redis subscriber. MUST be a dedicated connection (a\n\t *  `duplicate()` of your main client) — Redis forbids other\n\t *  commands on a subscribed connection. */\n\tsubscriber: RedisSubscriber;\n\t/**\n\t * Channel name. Defaults to `'absolutejs_sync_cluster'`. Two\n\t * engines on the same Redis can scope themselves to different\n\t * channels by overriding this.\n\t */\n\tchannel?: string;\n\t/**\n\t * Called when message parsing / delivery fails. Defaults to\n\t * `console.warn`. Note that Redis pub/sub doesn't surface delivery\n\t * failures on the publisher side — `publish()` resolves to the\n\t * count of subscribers that received the message (or 0); a 0 count\n\t * does NOT fire onError (Redis treats \"no subscribers\" as success).\n\t */\n\tonError?: (error: unknown) => void;\n};\n\n/**\n * Cumulative metrics since `createRedisClusterBus()`. Same shape\n * style as `sync-bus-pg`'s — minus the spill-table fields (Redis\n * has no equivalent).\n */\nexport type RedisClusterBusMetrics = {\n\tpublished: number;\n\treceived: number;\n\tpublishErrors: number;\n\tsubscribeErrors: number;\n\t/**\n\t * Cumulative count of subscribers reached on the publisher side.\n\t * Returned by Redis's PUBLISH. Use it as a rough \"is the cluster\n\t * still wired up\" signal — a drop to 0 when you expect peers means\n\t * subscribers disconnected (replication lag, network partition).\n\t */\n\ttotalSubscribersReached: number;\n};\n\nexport type RedisClusterBus = ClusterBus & {\n\tmetrics: () => RedisClusterBusMetrics;\n};\n\nexport const createRedisClusterBus = (\n\toptions: CreateRedisClusterBusOptions\n): RedisClusterBus => {\n\tconst channel = options.channel ?? 'absolutejs_sync_cluster';\n\tconst onError =\n\t\toptions.onError ?? ((error) => console.warn('[sync-bus-redis]', error));\n\n\tconst counters: RedisClusterBusMetrics = {\n\t\tpublishErrors: 0,\n\t\tpublished: 0,\n\t\treceived: 0,\n\t\tsubscribeErrors: 0,\n\t\ttotalSubscribersReached: 0\n\t};\n\n\treturn {\n\t\tmetrics: () => ({ ...counters }),\n\t\tpublish: async (message: ClusterMessage): Promise<void> => {\n\t\t\ttry {\n\t\t\t\tconst serialized = JSON.stringify(message);\n\t\t\t\tconst result = await options.publisher.publish(\n\t\t\t\t\tchannel,\n\t\t\t\t\tserialized\n\t\t\t\t);\n\t\t\t\tif (typeof result === 'number') {\n\t\t\t\t\tcounters.totalSubscribersReached += result;\n\t\t\t\t}\n\t\t\t\tcounters.published += 1;\n\t\t\t} catch (error) {\n\t\t\t\tcounters.publishErrors += 1;\n\t\t\t\tthrow error;\n\t\t\t}\n\t\t},\n\t\tsubscribe: async (\n\t\t\tonMessage: (message: ClusterMessage) => void\n\t\t): Promise<() => Promise<void>> => {\n\t\t\tconst listener = (raw: string): void => {\n\t\t\t\ttry {\n\t\t\t\t\tconst parsed = JSON.parse(raw) as ClusterMessage;\n\t\t\t\t\tcounters.received += 1;\n\t\t\t\t\tonMessage(parsed);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tcounters.subscribeErrors += 1;\n\t\t\t\t\tonError(error);\n\t\t\t\t}\n\t\t\t};\n\t\t\treturn options.subscriber.subscribe(channel, listener);\n\t\t}\n\t};\n};\n"
+  ],
+  "mappings": ";;AA6HO,IAAM,wBAAwB,CACpC,YACqB;AAAA,EACrB,MAAM,UAAU,QAAQ,WAAW;AAAA,EACnC,MAAM,UACL,QAAQ,YAAY,CAAC,UAAU,QAAQ,KAAK,oBAAoB,KAAK;AAAA,EAEtE,MAAM,WAAmC;AAAA,IACxC,eAAe;AAAA,IACf,WAAW;AAAA,IACX,UAAU;AAAA,IACV,iBAAiB;AAAA,IACjB,yBAAyB;AAAA,EAC1B;AAAA,EAEA,OAAO;AAAA,IACN,SAAS,OAAO,KAAK,SAAS;AAAA,IAC9B,SAAS,OAAO,YAA2C;AAAA,MAC1D,IAAI;AAAA,QACH,MAAM,aAAa,KAAK,UAAU,OAAO;AAAA,QACzC,MAAM,SAAS,MAAM,QAAQ,UAAU,QACtC,SACA,UACD;AAAA,QACA,IAAI,OAAO,WAAW,UAAU;AAAA,UAC/B,SAAS,2BAA2B;AAAA,QACrC;AAAA,QACA,SAAS,aAAa;AAAA,QACrB,OAAO,OAAO;AAAA,QACf,SAAS,iBAAiB;AAAA,QAC1B,MAAM;AAAA;AAAA;AAAA,IAGR,WAAW,OACV,cACkC;AAAA,MAClC,MAAM,WAAW,CAAC,QAAsB;AAAA,QACvC,IAAI;AAAA,UACH,MAAM,SAAS,KAAK,MAAM,GAAG;AAAA,UAC7B,SAAS,YAAY;AAAA,UACrB,UAAU,MAAM;AAAA,UACf,OAAO,OAAO;AAAA,UACf,SAAS,mBAAmB;AAAA,UAC5B,QAAQ,KAAK;AAAA;AAAA;AAAA,MAGf,OAAO,QAAQ,WAAW,UAAU,SAAS,QAAQ;AAAA;AAAA,EAEvD;AAAA;",
+  "debugId": "0C163B79C3CB22BF64756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "@absolutejs/sync-bus-redis",
+	"version": "0.0.1",
+	"description": "Redis pub/sub ClusterBus for @absolutejs/sync — cross-instance fan-out via PUBLISH/SUBSCRIBE. Sibling to @absolutejs/sync-bus-pg; faster fanout, better geo-replication story. Works with any Redis client (ioredis, node-redis, etc.) via a narrow tag-template interface.",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/absolutejs/sync-adapters.git",
+		"directory": "redis"
+	},
+	"main": "./dist/index.js",
+	"module": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"type": "module",
+	"license": "Apache-2.0",
+	"author": "Alex Kahn",
+	"publishConfig": {
+		"access": "public"
+	},
+	"keywords": [
+		"absolutejs",
+		"sync",
+		"cluster",
+		"redis",
+		"pubsub",
+		"horizontal-scale",
+		"multi-region"
+	],
+	"scripts": {
+		"build": "rm -rf dist && bun build src/index.ts --outdir dist --sourcemap --target=bun --external @absolutejs/sync && tsc --project tsconfig.build.json",
+		"test": "bun test",
+		"typecheck": "tsc --noEmit",
+		"format": "prettier --write \"./**/*.{ts,json,md}\"",
+		"release": "bun run format && bun run build && bun publish"
+	},
+	"peerDependencies": {
+		"@absolutejs/sync": ">= 1.17.0"
+	},
+	"devDependencies": {
+		"@absolutejs/sync": "^1.21.0",
+		"@types/bun": "1.3.14",
+		"prettier": "3.5.3",
+		"typescript": "5.8.3"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md"
+	]
+}