@krishnadobhal/rewind-sdk-js 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Krishna Dobhal
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/dist/config.d.ts

@@ -0,0 +1,12 @@
+import type { RedactConfig } from './redact.ts';
+export type RewindConfig = {
+    /** Cassette store root. A directory; REWIND_SERVER switches the store instead. */
+    dir?: string;
+    redact?: RedactConfig;
+};
+/** Identity function giving config files type inference. */
+export declare function defineConfig(config: RewindConfig): RewindConfig;
+/** Store root used when nothing else says otherwise. */
+export declare const DEFAULT_DIR = ".rewind";
+/** Imports rewind.config.ts if the user wrote one. */
+export declare function loadConfig(path?: string): Promise<RewindConfig>;

package/dist/config.js

@@ -0,0 +1,30 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * One config surface: `rewind.config.ts`, overridden by the environment.
+ * Only what is read lives here — a knob nothing consumes is a promise the code breaks.
+ */
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/** Identity function giving config files type inference. */
+export function defineConfig(config) {
+    return config; // no validation yet, TypeScript is the check
+}
+/** Store root used when nothing else says otherwise. */
+export const DEFAULT_DIR = '.rewind';
+/** Imports rewind.config.ts if the user wrote one. */
+export async function loadConfig(path) {
+    const file = resolve(path ?? 'rewind.config.ts'); // absolute, import() needs it
+    if (!existsSync(file))
+        return {}; // unconfigured is valid, not an error
+    // Node strips types on import, so a .ts config needs no build step.
+    const module = (await import(__rewriteRelativeImportExtension(pathToFileURL(file).href)));
+    return module.default ?? {}; // a config with no default export is empty
+}

package/dist/emitter.d.ts

@@ -0,0 +1,44 @@
+import type { Cassette, Run, Step } from '@krishnadobhal/rewind-core/schema';
+import type { Store } from './store.ts';
+/** One queued write, in the shape the wire carries it. */
+export type BatchWrite = {
+    kind: 'run';
+    run: Run;
+} | {
+    kind: 'step';
+    step: Step;
+} | {
+    kind: 'cassette';
+    cassette: Cassette;
+};
+/** A store that writes somewhere slow — Postgres, an ingest API, S3. */
+export type AsyncStore = {
+    putRun(run: Run): Promise<void>;
+    appendStep(step: Step): Promise<void>;
+    putCassette(cassette: Cassette): Promise<void>;
+    putBatch?(writes: BatchWrite[]): Promise<void>;
+};
+export type EmitterOptions = {
+    target: AsyncStore;
+    /** Writes held before the newest are dropped. */
+    maxQueue?: number;
+    /** Writes sent in one call, when the target can take a batch. */
+    maxBatch?: number;
+    /** How long a write waits for company before the batch goes. */
+    batchMs?: number;
+    log?: (message: string, error: unknown) => void;
+};
+export type FlushResult = {
+    written: number;
+    dropped: number;
+    pending: number;
+};
+/** A Store that queues writes and drains them to a slow target. */
+export declare function bufferedStore(options: EmitterOptions): Store & {
+    flush: () => Promise<FlushResult>;
+    stats: {
+        written: number;
+        dropped: number;
+        queued: number;
+    };
+};

package/dist/emitter.js

@@ -0,0 +1,99 @@
+/** Sends one write through the target's individual methods. */
+function sendOne(target, write) {
+    if (write.kind === 'run')
+        return target.putRun(write.run);
+    if (write.kind === 'step')
+        return target.appendStep(write.step);
+    return target.putCassette(write.cassette);
+}
+/** A Store that queues writes and drains them to a slow target. */
+export function bufferedStore(options) {
+    const { target, maxQueue = 1000, maxBatch = 100, batchMs = 250 } = options;
+    const log = options.log ?? ((m, e) => console.warn(`[rewind] ${m}`, e));
+    const queue = [];
+    const stats = { written: 0, dropped: 0, queued: 0 };
+    let draining = null;
+    let timer = null;
+    let lastLoggedAt = 0;
+    /** Counts losses and says so at most once a minute. */
+    const drop = (count, why, error) => {
+        stats.dropped += count;
+        const now = Date.now();
+        if (now - lastLoggedAt < 60_000)
+            return;
+        lastLoggedAt = now;
+        log(`${why} (${stats.dropped} dropped)`, error);
+    };
+    /** Sends queued writes in order, batching when the target allows. */
+    const drain = async () => {
+        while (queue.length > 0) {
+            // Splice, not slice: a batch that fails is gone, not retried forever.
+            const batch = queue.splice(0, maxBatch);
+            stats.queued = queue.length;
+            if (target.putBatch) {
+                try {
+                    await target.putBatch(batch);
+                    stats.written += batch.length;
+                }
+                catch (error) {
+                    // One request carried all of them, so all of them were lost (I1).
+                    drop(batch.length, `${batch.length} writes failed`, error);
+                }
+                continue;
+            }
+            // No batch support: one at a time, in order, each guarded on its own. A single
+            // bad write must not take the rest of the batch with it — that is a property
+            // the local store had before batching existed.
+            for (const write of batch) {
+                try {
+                    await sendOne(target, write);
+                    stats.written++;
+                }
+                catch (error) {
+                    drop(1, `${write.kind} write failed`, error);
+                }
+            }
+        }
+    };
+    /** Starts a drain if one is not already running. */
+    const schedule = () => {
+        if (timer !== null || draining !== null)
+            return;
+        // Steps arrive in bursts; a short wait lets a whole node's worth queue up.
+        timer = setTimeout(() => {
+            timer = null;
+            draining = drain().finally(() => {
+                draining = null;
+                if (queue.length > 0)
+                    schedule(); // more arrived while we were away
+            });
+        }, batchMs);
+        timer.unref?.(); // never hold the process open on our account
+    };
+    /** Queues a write, or drops it if the queue is full. */
+    const push = (write) => {
+        if (queue.length >= maxQueue) {
+            // Drop the newest, not the oldest: the start of a run explains more than its end.
+            drop(1, `queue full at ${maxQueue}`, new Error('emitter backpressure'));
+            return;
+        }
+        queue.push(write);
+        stats.queued = queue.length;
+        schedule();
+    };
+    return {
+        stats,
+        putRun: (run) => push({ kind: 'run', run }),
+        appendStep: (step) => push({ kind: 'step', step }),
+        putCassette: (cassette) => push({ kind: 'cassette', cassette }),
+        async flush() {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            await draining; // let an in-flight drain finish before starting another
+            await drain();
+            return { written: stats.written, dropped: stats.dropped, pending: queue.length };
+        },
+    };
+}

package/dist/env.d.ts

@@ -0,0 +1,12 @@
+import type { Run } from '@krishnadobhal/rewind-core/schema';
+import { Recorder } from './recorder.ts';
+export declare const ENV_ENABLED = "REWIND_ENABLED";
+export declare const ENV_DIR = "REWIND_DIR";
+export declare const ENV_CONFIG = "REWIND_CONFIG";
+export declare const ENV_SERVER = "REWIND_SERVER";
+export declare const ENV_TOKEN = "REWIND_TOKEN";
+export declare const ENV_FILE = "REWIND_ENV_FILE";
+export declare function loadEnvFile(path?: string): void;
+/** Returns this process's recorder, opening it once. */
+export declare function recorderFromEnv(run?: Partial<Run>): Promise<Recorder | null>;
+export declare function resetRecorder(): void;

package/dist/env.js

@@ -0,0 +1,78 @@
+import { DEFAULT_DIR, loadConfig } from './config.js';
+import { bufferedStore } from './emitter.js';
+import { httpStore } from './http.js';
+import { Recorder } from './recorder.js';
+import { fileStore } from './store.js';
+export const ENV_ENABLED = 'REWIND_ENABLED';
+export const ENV_DIR = 'REWIND_DIR';
+export const ENV_CONFIG = 'REWIND_CONFIG';
+export const ENV_SERVER = 'REWIND_SERVER';
+export const ENV_TOKEN = 'REWIND_TOKEN';
+export const ENV_FILE = 'REWIND_ENV_FILE';
+// Loads a .env into process.env, once per process.
+let envFileLoaded = false;
+export function loadEnvFile(path) {
+    if (envFileLoaded)
+        return;
+    envFileLoaded = true;
+    const file = path ?? process.env[ENV_FILE] ?? '.env';
+    if (file === '0')
+        return; // explicitly opted out
+    try {
+        process.loadEnvFile(file);
+    }
+    catch {
+        // No .env is the normal case for a library consumer, not an error.
+    }
+}
+/** Where the store lives for this process. */
+async function storeRoot() {
+    const config = await loadConfig(process.env[ENV_CONFIG]); // may not exist
+    return process.env[ENV_DIR] ?? config.dir ?? DEFAULT_DIR; // flag beats config
+}
+let current = null;
+/** Returns this process's recorder, opening it once. */
+export async function recorderFromEnv(run) {
+    current ??= build(run); // first caller's metadata wins; later callers join the run
+    return current;
+}
+// Drops the memo so the next call opens a new run.
+export function resetRecorder() {
+    current = null;
+}
+function chooseStore(root) {
+    const url = process.env[ENV_SERVER];
+    if (url === undefined || url === '')
+        return { store: fileStore(root) };
+    const buffered = bufferedStore({
+        target: httpStore({ url, token: process.env[ENV_TOKEN] }),
+    });
+    return { store: buffered, flush: buffered.flush };
+}
+/** Opens the run: reads config, picks a store, starts recording. */
+async function build(run) {
+    loadEnvFile(); // before the check, so a .env can switch recording on
+    if (process.env[ENV_ENABLED] !== '1')
+        return null;
+    try {
+        const config = await loadConfig(process.env[ENV_CONFIG]); // may not exist
+        const { store, flush } = chooseStore(await storeRoot());
+        if (flush)
+            flushOnExit(flush);
+        return new Recorder({ store, redact: config.redact, run });
+    }
+    catch (error) {
+        // Fails open (I1): a broken config must not take the agent down.
+        console.warn('[rewind] recorder disabled:', error);
+        return null;
+    }
+}
+function flushOnExit(flush) {
+    let done = false;
+    process.on('beforeExit', () => {
+        if (done)
+            return; // beforeExit can fire more than once
+        done = true;
+        void flush().catch(() => { }); // failing to flush must not become an exception
+    });
+}

package/dist/http.d.ts

@@ -0,0 +1,9 @@
+import type { AsyncStore } from './emitter.ts';
+export type HttpStoreOptions = {
+    url: string;
+    token?: string;
+    timeoutMs?: number;
+    fetchImpl?: typeof fetch;
+};
+/** An AsyncStore that POSTs batches to an ingest server. */
+export declare function httpStore(options: HttpStoreOptions): AsyncStore;

package/dist/http.js

@@ -0,0 +1,27 @@
+/** An AsyncStore that POSTs batches to an ingest server. */
+export function httpStore(options) {
+    const { url, token, timeoutMs = 10_000 } = options;
+    const send = options.fetchImpl ?? globalThis.fetch;
+    const endpoint = `${url.replace(/\/$/, '')}/v1/ingest`;
+    /** POSTs one batch, throwing on anything but success. */
+    const post = async (writes) => {
+        // A hung server would otherwise hold the queue open until the process ends.
+        const abort = AbortSignal.timeout(timeoutMs);
+        const response = await send(endpoint, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) },
+            body: JSON.stringify({ writes }),
+            signal: abort,
+        });
+        if (!response.ok)
+            throw new Error(`ingest ${response.status} ${response.statusText}`);
+    };
+    return {
+        // The batch path is the one that runs; these three exist so the store still
+        // satisfies AsyncStore for a caller that bypasses the emitter.
+        putRun: (run) => post([{ kind: 'run', run }]),
+        appendStep: (step) => post([{ kind: 'step', step }]),
+        putCassette: (cassette) => post([{ kind: 'cassette', cassette }]),
+        putBatch: post,
+    };
+}

package/dist/middleware.d.ts

@@ -0,0 +1,26 @@
+import type { Recorder } from './recorder.ts';
+/** Anything with an invoke method — a model, a tool, a runnable. */
+type Invokable = {
+    invoke: (input: never, config?: never) => unknown;
+};
+export type WithRewindOptions<M, T> = {
+    model?: M;
+    tools?: T[];
+    /** Supplied by tests; otherwise from REWIND_ENABLED and friends. */
+    recorder?: Recorder | null;
+    /**
+     * Turns a recorded response back into the object the graph expects.
+     * Kept for the reader that hands cassettes back to a graph; recording ignores it.
+     */
+    revive?: (response: unknown) => unknown;
+};
+export type Rewind<M, T> = {
+    model: M;
+    tools: T[];
+    recorder: Recorder | null;
+    /** Wraps one more model or tool — `model`/`tools` are sugar over this. */
+    wrap: <X extends Invokable>(target: X) => X;
+};
+/** Wraps a model and tools so every call is recorded. */
+export declare function withRewind<M extends Invokable, T extends Invokable>(options?: WithRewindOptions<M, T>): Promise<Rewind<M, T>>;
+export {};

package/dist/middleware.js

@@ -0,0 +1,186 @@
+import { recorderFromEnv } from './env.js';
+/** Methods returning a new runnable that must stay wrapped. */
+const REWRAPPING = new Set(['bindTools', 'bind', 'withConfig', 'withRetry']);
+/** Wraps a model and tools so every call is recorded. */
+export async function withRewind(options = {}) {
+    const recorder = options.recorder ?? (await recorderFromEnv());
+    const tools = options.tools ?? [];
+    const model = options.model;
+    const session = { recorder, revive: options.revive ?? ((r) => r) };
+    // Not recording: hand back the originals, so an un-instrumented run costs nothing.
+    if (recorder === null) {
+        return { model, tools, recorder: null, wrap: (target) => target };
+    }
+    const wrap = (target) => wrapAny(target, session);
+    return { model: model && wrap(model), tools: tools.map(wrap), recorder, wrap };
+}
+/** Dispatches to the model or tool wrapper by shape. */
+function wrapAny(target, session) {
+    const t = unwrapModel(target); // a binding carries neither marker itself
+    // Models have _llmType/bindTools, tools have neither. Guessing wrong shows up as a
+    // `tool` step where a `model` step belongs.
+    const isModel = typeof t['_llmType'] === 'function' || typeof t['bindTools'] === 'function';
+    return isModel ? wrapModel(target, session) : wrapTool(target, session);
+}
+/** Proxies a chat model, turning each invoke into a step. */
+function wrapModel(model, session, bound = []) {
+    return new Proxy(model, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target); // target, not the proxy — getters recurse
+            if (prop === 'invoke') {
+                return (input, config) => observe(session, 'model', config, () => modelRequest(target, input, bound), () => value.call(target, input, config));
+            }
+            // bindTools returns a *new* runnable; unwrapped, the graph calls it directly.
+            if (REWRAPPING.has(prop) && typeof value === 'function') {
+                return (...args) => {
+                    const next = value.apply(target, args);
+                    const schemas = prop === 'bindTools' ? (providerTools(next) ?? args[0] ?? []) : bound;
+                    return wrapModel(next, session, schemas); // schemas are part of the identity
+                };
+            }
+            return typeof value === 'function' ? value.bind(target) : value;
+        },
+    });
+}
+/** Proxies a tool, turning each invoke into a step. */
+function wrapTool(tool, session) {
+    return new Proxy(tool, {
+        get(target, prop) {
+            const value = Reflect.get(target, prop, target);
+            if (prop !== 'invoke')
+                return typeof value === 'function' ? value.bind(target) : value;
+            const name = String(Reflect.get(target, 'name', target) ?? 'tool');
+            return (input, config) => observe(session, 'tool', config, () => ({ kind: 'tool', tool_name: name, args: toolArgs(input) }), // name + args, nothing else
+            () => value.call(target, input, config));
+        },
+    });
+}
+/** Answers a boundary crossing, and records what happened. */
+async function observe(session, kind, config, request, call) {
+    const node = nodeName(config);
+    const { recorder } = session;
+    const started = Date.now(); // real clock; the virtual one arrives with B3
+    try {
+        const response = await call();
+        recorder?.record({
+            node,
+            kind,
+            request: request(),
+            response: plain(response),
+            latency_ms: Date.now() - started,
+            ...usage(response),
+        });
+        return response;
+    }
+    catch (error) {
+        // A provider error is a recorded outcome, not a gap (B9).
+        recorder?.record({
+            node,
+            kind,
+            request: request(),
+            response: null,
+            latency_ms: Date.now() - started,
+            error: { message: String(error) },
+        });
+        throw error; // the graph's error handling is the graph's business
+    }
+}
+/** Reads the LangGraph node name out of the config. */
+function nodeName(config) {
+    const metadata = config?.metadata;
+    const fromGraph = metadata?.['langgraph_node']; // LangGraph sets this per node
+    if (typeof fromGraph === 'string')
+        return fromGraph;
+    const runName = config?.runName;
+    return runName ?? 'unknown'; // ponytail: a step with no node is still a step
+}
+/** Digs past Runnable bindings to the model underneath. */
+function unwrapModel(model) {
+    let m = model;
+    // Identity read off a binding gives model_id "unknown" — every model looks alike.
+    for (let depth = 0; depth < 8 && m && typeof m['_llmType'] !== 'function'; depth++) {
+        const inner = m['bound'];
+        if (inner === undefined || inner === null)
+            break;
+        m = inner;
+    }
+    return m;
+}
+/** Builds the canonical model request from an invoke. */
+function modelRequest(model, input, boundTools) {
+    const m = unwrapModel(model);
+    const llmType = m['_llmType']; // LangChain's provider discriminator
+    return {
+        kind: 'model',
+        provider: typeof llmType === 'function' ? String(llmType.call(m)) : 'unknown',
+        model_id: String(m['model'] ?? m['modelName'] ?? 'unknown'),
+        messages: messages(input),
+        tool_schemas: boundTools.map((tool, i) => toolSchema(tool, i)), // canonical() sorts these
+        ...pick(m, ['temperature', 'topP', 'topK', 'maxTokens']),
+    };
+}
+/** Flattens LangChain messages to plain role/content records. */
+function messages(input) {
+    const list = Array.isArray(input) ? input : [input]; // a bare message is a list of one
+    return list.map((message) => {
+        const m = message;
+        const getType = m['_getType']; // BaseMessage hides its role behind this
+        return {
+            role: typeof getType === 'function' ? String(getType.call(message)) : String(m['role'] ?? 'user'),
+            content: m['content'] ?? null,
+            ...pick(m, ['tool_calls', 'tool_call_id', 'name', 'id']), // ids become ordinals later
+        };
+    });
+}
+/** Unwraps a tool call's args from its envelope. */
+function toolArgs(input) {
+    const i = input;
+    // LangGraph passes the whole ToolCall; a direct caller passes bare args.
+    return i !== null && typeof i === 'object' && 'args' in i ? i['args'] : input;
+}
+/** Prefers the JSON-Schema tool dicts a binding carries. */
+function providerTools(bound) {
+    // What the model actually sees, and plain JSON unlike a raw Zod object.
+    const b = bound;
+    for (const tools of [b?.kwargs?.tools, b?.config?.tools]) {
+        if (Array.isArray(tools))
+            return tools;
+    }
+    return null;
+}
+/** Reduces a tool object to its identity fields. */
+function toolSchema(tool, index) {
+    const t = tool;
+    const fn = (t['function'] ?? t); // OpenAI nests, others are flat
+    return {
+        name: String(fn['name'] ?? `tool_${index}`),
+        description: fn['description'] ?? null,
+        // ponytail: a raw Zod object hashes as its internal _def, which a Zod upgrade
+        // invalidates. Models that convert on bindTools hit providerTools() instead.
+        schema: stable(fn['parameters'] ?? fn['input_schema'] ?? fn['schema'] ?? null),
+    };
+}
+/** Drops memoized fields that appear only after first use. */
+function stable(schema) {
+    if (schema === null || typeof schema !== 'object')
+        return schema;
+    // Zod fills `_cached` lazily: identity must not depend on how often it was used.
+    return JSON.parse(JSON.stringify(schema, (key, value) => (key === '_cached' ? undefined : value)));
+}
+/** Copies the keys that exist and are not null. */
+function pick(source, keys) {
+    const out = {};
+    for (const key of keys)
+        if (source[key] !== undefined && source[key] !== null)
+            out[key] = source[key];
+    return out;
+}
+/** Pulls token counts off a model response, if present. */
+function usage(response) {
+    const meta = response?.usage_metadata;
+    return typeof meta?.total_tokens === 'number' ? { tokens: meta.total_tokens } : {};
+}
+/** Strips class identity so the response serializes as data. */
+function plain(value) {
+    return value === undefined ? null : JSON.parse(JSON.stringify(value));
+}

package/dist/recorder.d.ts

@@ -0,0 +1,20 @@
+import type { Run } from '@krishnadobhal/rewind-core/schema';
+import type { Observation, RecorderOptions } from './types/recorder.ts';
+export type { Observation, RecorderOptions } from './types/recorder.ts';
+export declare class Recorder {
+    #private;
+    readonly run: Run;
+    readonly stats: {
+        dropped: number;
+        steps: number;
+    };
+    /** Opens a run and writes its row immediately. */
+    constructor(options: RecorderOptions);
+    /**
+     * Record one boundary crossing. Never throws.
+     * hash → redact → write cassette → append step → roll up totals.
+     */
+    record(observation: Observation): void;
+    /** Close the run out. Never throws. */
+    finish(outcome: Run['outcome'], status?: Run['status']): void;
+}

package/dist/recorder.js

@@ -0,0 +1,120 @@
+/**
+ * Runs inside the user's production agent and fails open : a store outage, a full
+ * disk, a serialization bug — none of them throw into the graph. The run goes `partial`.
+ */
+import { HASH_VERSION, reqHash } from '@krishnadobhal/rewind-core/hash';
+import { redact } from './redact.js';
+import { ulid } from './ulid.js';
+const LOG_INTERVAL_MS = 60_000;
+export class Recorder {
+    run;
+    stats = { dropped: 0, steps: 0 };
+    #store;
+    #redact;
+    #log;
+    #lastLoggedAt = 0;
+    #seq = 0;
+    /** Opens a run and writes its row immediately. */
+    constructor(options) {
+        this.#store = options.store;
+        this.#redact = options.redact ?? {};
+        this.#log = options.log ?? ((m, e) => console.warn(`[rewind] ${m}`, e));
+        this.run = {
+            run_id: ulid(),
+            thread_id: '',
+            graph_sha: '',
+            code_sha: '',
+            prompt_sha: '',
+            model_cfg: {},
+            seed: Math.floor(Math.random() * 2 ** 48), // under 2^53, Run.seed is a number
+            flags_snapshot: {},
+            hash_version: HASH_VERSION,
+            started_at: new Date().toISOString(),
+            ended_at: null,
+            status: 'complete',
+            outcome: null,
+            tokens: 0,
+            cost_usd: 0,
+            latency_ms: 0,
+            ...options.run, // caller overrides any default above
+        };
+        // Written before the first step, so a process that dies mid-run still leaves an
+        // inspectable trace instead of orphaned steps.
+        // Written up front so a crashed run still leaves a row behind.
+        this.#guard('putRun', () => this.#store.putRun(this.run));
+    }
+    /**
+     * Record one boundary crossing. Never throws.
+     * hash → redact → write cassette → append step → roll up totals.
+     */
+    record(observation) {
+        this.#guard('record', () => {
+            // Hashed before redaction: a digest of a secret is not the secret, and it keeps
+            // req_hash stable when the redaction config changes.
+            const hash = reqHash(observation.request);
+            const seq = this.#seq++; // claimed before any write can fail
+            // Request and response redact together, so a value in both gets one token.
+            const safe = redact({ request: observation.request, response: observation.response }, this.#redact);
+            const body = safe.value;
+            const cassette = {
+                hash,
+                hash_version: HASH_VERSION,
+                kind: observation.kind,
+                // Inline, not an s3:// ref — externalize when these outgrow a single file read.
+                request: JSON.stringify(body.request),
+                response: JSON.stringify(body.response),
+                chunks: null,
+                provider: observation.provider ?? null,
+                model_version: observation.model_version ?? null,
+                redaction_map: safe.map,
+                refcount: 1,
+                recorded_at: new Date().toISOString(),
+            };
+            this.#store.putCassette(cassette); // no-op if this hash exists already
+            const step = {
+                run_id: this.run.run_id,
+                // Arrival order until the deterministic scheduler owns `seq` (B6).
+                seq,
+                node: observation.node,
+                kind: observation.kind,
+                req_hash: hash,
+                cassette_ref: hash,
+                match_tier: 'recorded',
+                latency_ms: observation.latency_ms,
+                tokens: observation.tokens ?? null,
+                cost_usd: observation.cost_usd ?? null,
+                error: observation.error ?? null,
+            };
+            this.#store.appendStep(step);
+            // Rolled up here so finish() has totals without re-reading the steps.
+            this.stats.steps++;
+            this.run.tokens += observation.tokens ?? 0;
+            this.run.cost_usd += observation.cost_usd ?? 0;
+            this.run.latency_ms += observation.latency_ms;
+        });
+    }
+    /** Close the run out. Never throws. */
+    finish(outcome, status = 'complete') {
+        this.run.ended_at = new Date().toISOString();
+        this.run.outcome = outcome;
+        // An incomplete recording is never a replay source; the caller cannot override that.
+        this.run.status = this.stats.dropped > 0 ? 'partial' : status;
+        this.#guard('finish', () => this.#store.putRun(this.run));
+    }
+    /** The one place a store failure may land: count it, degrade the run, carry on. */
+    /** Runs fn, swallowing and counting any failure (I1). */
+    #guard(what, fn) {
+        try {
+            fn();
+        }
+        catch (error) {
+            this.stats.dropped++;
+            this.run.status = 'partial';
+            const now = Date.now(); // rate-limit the log, not the counter
+            if (now - this.#lastLoggedAt >= LOG_INTERVAL_MS) {
+                this.#lastLoggedAt = now;
+                this.#log(`${what} failed; run ${this.run.run_id} is partial (${this.stats.dropped} dropped)`, error);
+            }
+        }
+    }
+}

package/dist/redact.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Runs in the user's process, before anything is written. There is no read-time path.
+ * `redaction_map` holds token → matcher name, never the original value.
+ */
+import type { RedactConfig, RedactResult } from './types/redact.ts';
+export type { RedactConfig, RedactResult } from './types/redact.ts';
+/** Assemble the matcher list, then walk once. Returns a new tree; the input is untouched. */
+/** Redacts a value, returning it with a token map. */
+export declare function redact(value: unknown, config?: RedactConfig): RedactResult;

package/dist/redact.js

@@ -0,0 +1,101 @@
+/**
+ * Runs in the user's process, before anything is written. There is no read-time path.
+ * `redaction_map` holds token → matcher name, never the original value.
+ */
+/** Issuer prefixes: Visa, Mastercard, Amex, Discover, UnionPay, JCB. */
+const CARD_PREFIX = /^(?:4|5[1-5]|2[2-7]|3[47]|6(?:011|5)|62|35)/;
+/**
+ * Is this digit run actually a card number?
+ *
+ * A 13–19 digit run is card-*shaped*; a PRNG seed or an order number is too. Luhn alone
+ * lets one in ten through, so the issuer prefix has to agree as well. Over-redacting
+ * corrupts data the agent needs while protecting nothing.
+ */
+function card(digits) {
+    const only = digits.replace(/\D/g, '');
+    if (only.length < 13 || !CARD_PREFIX.test(only))
+        return false;
+    let sum = 0;
+    for (let i = 0; i < only.length; i++) {
+        // Double every second digit from the right; 10 or more folds to its digit sum.
+        let d = Number(only[only.length - 1 - i]);
+        if (i % 2 === 1)
+            d = d * 2 > 9 ? d * 2 - 9 : d * 2;
+        sum += d;
+    }
+    return sum % 10 === 0;
+}
+const PRESET = [
+    // Bounded per RFC 5321 (local part <= 64, each domain label <= 63) for speed, not
+    // correctness: an unbounded [\w.+-]+ backtracks across the whole string from every
+    // start position, so a long token in the same character class and no @ — base64,
+    // a JWT, a data URI — costs O(n^2). 20 KB of base64 took 324ms before, 5.6ms after.
+    ['email', /[\w.+-]{1,64}@[\w-]{1,63}(?:\.[\w-]{1,63})+/g],
+    ['token', /\b(?:Bearer\s+[\w.\-~+/]+=*|(?:sk|pk|rk)[-_](?:live|test)?[-_]?[A-Za-z0-9]{12,}|xox[baprs]-[\w-]{10,}|AKIA[0-9A-Z]{16}|eyJ[\w-]{8,}\.[\w-]{8,}\.[\w-]{8,})/g],
+    ['card', /\b(?:\d[ -]?){13,19}\b/g, card],
+    // Numbers are not all +1 555, so this takes grouped digits with an optional country
+    // code — covering UK `020 7946 0958` and most of Europe. The boundaries are the load
+    // -bearing part: without them it eats the digit groups inside a UUID, which corrupts
+    // ids the agent needs while protecting nothing.
+    ['phone', /(?<![\w-])(?:\+\d{1,3}[ .-]?)?(?:\(\d{2,4}\)|\d{2,4})[ .-]\d{3,4}[ .-]?\d{3,4}(?![\w-])/g],
+];
+class Tokens {
+    map = {}; // token → matcher name, no plaintext
+    #seen = new Map(); // original → token, for repeat values
+    #counts = new Map(); // per-matcher counter, gives the suffix
+    /** Same original → same token, so redacted text keeps its structure. */
+    for(original, matcher) {
+        let token = this.#seen.get(original);
+        if (token === undefined) {
+            const n = this.#counts.get(matcher) ?? 0;
+            this.#counts.set(matcher, n + 1);
+            token = `[redacted:${matcher}:${n}]`;
+            this.#seen.set(original, token);
+            this.map[token] = matcher;
+        }
+        return token;
+    }
+}
+/** Runs every matcher over one string, in order. */
+function redactString(input, matchers, tokens) {
+    let out = input; // rewritten once per matcher
+    for (const [name, pattern, accept] of matchers) {
+        // Fresh RegExp per call: a shared /g pattern carries lastIndex between strings.
+        out = out.replace(new RegExp(pattern.source, pattern.flags), (m) => 
+        // A refused match is left exactly as it was found.
+        accept && !accept(m) ? m : tokens.for(m, name));
+    }
+    return out;
+}
+/**
+ * Depth-first over the tree, building a dotted path as it descends. A configured
+ * `fields` path wins outright — the whole value goes, whatever shape it is — before
+ * any pattern gets a chance to run against it.
+ */
+/** Recurses the value, redacting strings and named fields. */
+function walk(value, path, ctx) {
+    if (ctx.fields.has(path)) { // whole value goes, whatever type it is
+        return value === undefined ? value : ctx.tokens.for(`${path}:${JSON.stringify(value)}`, 'field');
+    }
+    if (typeof value === 'string')
+        return redactString(value, ctx.matchers, ctx.tokens);
+    if (Array.isArray(value))
+        return value.map((v, i) => walk(v, `${path}[${i}]`, ctx));
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = walk(v, path === '' ? k : `${path}.${k}`, ctx);
+        }
+        return out;
+    }
+    return value;
+}
+/** Assemble the matcher list, then walk once. Returns a new tree; the input is untouched. */
+/** Redacts a value, returning it with a token map. */
+export function redact(value, config = {}) {
+    const matchers = config.preset === 'none' ? [] : [...PRESET]; // copy, PRESET is shared
+    (config.custom ?? []).forEach((re, i) => matchers.push([`custom:${i}`, re]));
+    const tokens = new Tokens(); // one map per call, numbering restarts
+    const redacted = walk(value, '', { matchers, fields: new Set(config.fields ?? []), tokens });
+    return { value: redacted, map: tokens.map };
+}

package/dist/store.d.ts

@@ -0,0 +1,19 @@
+import type { Cassette, Run, Step } from '@krishnadobhal/rewind-core/schema';
+export type Store = {
+    putRun(run: Run): void;
+    appendStep(step: Step): void;
+    putCassette(cassette: Cassette): void;
+};
+/** One recorded run: its metadata plus its ordered steps. */
+export type Trace = {
+    run: Run;
+    steps: Step[];
+};
+/** Creates a Store backed by a local directory. */
+export declare function fileStore(root: string): Store;
+/** Reads one run and its steps back off disk. */
+export declare function readTrace(root: string, runId: string): Trace | null;
+/** Lists run ids, oldest first, ULIDs sort by time. */
+export declare function listRuns(root: string): string[];
+/** Reads one cassette by its content hash. */
+export declare function readCassette(root: string, hash: string): Cassette | null;

package/dist/store.js

@@ -0,0 +1,57 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/** Creates a Store backed by a local directory. */
+export function fileStore(root) {
+    // Shared by putRun and putCassette, both whole-file writes.
+    const write = (path, body) => {
+        mkdirSync(dirname(path), { recursive: true }); // parents may not exist yet
+        writeFileSync(path, body);
+    };
+    return {
+        putRun(run) {
+            // Rewritten on finish, so the last write wins.
+            write(join(root, 'runs', run.run_id, 'run.json'), JSON.stringify(run, null, 2) + '\n');
+        },
+        appendStep(step) {
+            const path = join(root, 'runs', step.run_id, 'steps.jsonl');
+            mkdirSync(dirname(path), { recursive: true });
+            appendFileSync(path, JSON.stringify(step) + '\n'); // append-only, one step per line
+        },
+        putCassette(cassette) {
+            const path = join(root, 'cassettes', `${cassette.hash}.json`);
+            // Content-addressed and immutable: a corrected recording is a new
+            // cassette, never an overwrite of this one.
+            if (existsSync(path))
+                return;
+            write(path, JSON.stringify(cassette) + '\n');
+        },
+    };
+}
+function orNull(read) {
+    try {
+        return read();
+    }
+    catch {
+        return null; // unreadable, corrupt, or not the shape we expected
+    }
+}
+/** Reads one run and its steps back off disk. */
+export function readTrace(root, runId) {
+    const dir = join(root, 'runs', runId);
+    return orNull(() => {
+        const run = JSON.parse(readFileSync(join(dir, 'run.json'), 'utf8'));
+        const jsonl = existsSync(join(dir, 'steps.jsonl')) ? readFileSync(join(dir, 'steps.jsonl'), 'utf8') : '';
+        // Trim first: a trailing newline would split into one empty line.
+        const steps = jsonl.trim() === '' ? [] : jsonl.trim().split('\n').map((line) => JSON.parse(line));
+        return { run, steps };
+    });
+}
+/** Lists run ids, oldest first, ULIDs sort by time. */
+export function listRuns(root) {
+    // Not a directory is as good as empty: nothing has been recorded here.
+    return orNull(() => readdirSync(join(root, 'runs')).sort()) ?? [];
+}
+/** Reads one cassette by its content hash. */
+export function readCassette(root, hash) {
+    return orNull(() => JSON.parse(readFileSync(join(root, 'cassettes', `${hash}.json`), 'utf8')));
+}

package/dist/types/recorder.d.ts

@@ -0,0 +1,23 @@
+import type { RewindRequest } from '@krishnadobhal/rewind-core/request';
+import type { Run, StepKind } from '@krishnadobhal/rewind-core/schema';
+import type { RedactConfig } from './redact.ts';
+import type { Store } from './store.ts';
+/** One boundary crossing, as the SDK observes it. */
+export type Observation = {
+    node: string;
+    kind: StepKind;
+    request: RewindRequest;
+    response: unknown;
+    latency_ms: number;
+    tokens?: number;
+    cost_usd?: number;
+    error?: unknown;
+    provider?: string;
+    model_version?: string;
+};
+export type RecorderOptions = {
+    store: Store;
+    redact?: RedactConfig;
+    run?: Partial<Run>;
+    log?: (message: string, error: unknown) => void;
+};

package/dist/types/recorder.js

@@ -0,0 +1 @@
+export {};

package/dist/types/redact.d.ts

@@ -0,0 +1,9 @@
+export type RedactConfig = {
+    preset?: 'default' | 'none';
+    custom?: RegExp[];
+    fields?: string[];
+};
+export type RedactResult = {
+    value: unknown;
+    map: Record<string, string>;
+};

package/dist/types/redact.js

@@ -0,0 +1 @@
+export {};

package/dist/types/store.d.ts

@@ -0,0 +1,7 @@
+import type { Cassette, Run, Step } from '@krishnadobhal/rewind-core/schema';
+/** Two lifetimes: a run and its steps belong to one run, cassettes are shared. */
+export type Store = {
+    putRun(run: Run): void;
+    appendStep(step: Step): void;
+    putCassette(cassette: Cassette): void;
+};

package/dist/types/store.js

@@ -0,0 +1 @@
+export {};

package/dist/ulid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * ULID: 48-bit millisecond timestamp + 80 bits of randomness, base32.
+ * Lexicographic order is creation order, which is why DATA_MODEL.md picks it over UUIDv4.
+ */
+export declare function ulid(now?: number): string;

package/dist/ulid.js

@@ -0,0 +1,18 @@
+import { randomBytes } from 'node:crypto';
+/** Crockford base32 — no I, L, O or U, so ids survive being read aloud. */
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/**
+ * ULID: 48-bit millisecond timestamp + 80 bits of randomness, base32.
+ * Lexicographic order is creation order, which is why DATA_MODEL.md picks it over UUIDv4.
+ */
+export function ulid(now = Date.now()) {
+    // Least-significant symbol first, each one prepended, so the result reads big-endian.
+    let time = ''; // 10 symbols, most significant first
+    for (let t = now, i = 0; i < 10; i++, t = Math.floor(t / 32))
+        time = ALPHABET[t % 32] + time;
+    // 256 / 32 is exact, so a uniform byte gives a uniform symbol.
+    let rand = ''; // 16 symbols, 80 bits
+    for (const byte of randomBytes(16))
+        rand += ALPHABET[byte % 32];
+    return time + rand;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@krishnadobhal/rewind-sdk-js",
+  "version": "0.1.0",
+  "description": "Record every boundary an LLM agent crosses: withRewind, the recorder, the redactor, and the stores.",
+  "license": "Apache-2.0",
+  "author": "Krishna Dobhal",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/krishnadobhal/Rewind.git",
+    "directory": "packages/sdk-js"
+  },
+  "homepage": "https://github.com/krishnadobhal/Rewind#readme",
+  "bugs": "https://github.com/krishnadobhal/Rewind/issues",
+  "keywords": [
+    "rewind",
+    "langgraph",
+    "langchain",
+    "agents",
+    "record",
+    "observability"
+  ],
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./recorder": "./dist/recorder.js",
+    "./redact": "./dist/redact.js",
+    "./store": "./dist/store.js",
+    "./config": "./dist/config.js",
+    "./env": "./dist/env.js",
+    "./ulid": "./dist/ulid.js",
+    "./middleware": "./dist/middleware.js",
+    "./emitter": "./dist/emitter.js",
+    "./http": "./dist/http.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@krishnadobhal/rewind-core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.3"
+  }
+}