@derivesome/core 1.0.0

package/dist/esm/observable.js

@@ -0,0 +1,19 @@
+import { has } from "./common";
+export const OBSERVABLE = Symbol("Observable");
+export function observable(state, ps) {
+    const observe = (fn, options = {}) => {
+        if (options.immediate) {
+            fn(state.value);
+        }
+        return ps.subscribe(fn, options.cleanup);
+    };
+    return {
+        [OBSERVABLE]: true,
+        ...ps,
+        observe,
+    };
+}
+export function isObservable(x) {
+    return has(x, OBSERVABLE);
+}
+//# sourceMappingURL=observable.js.map

package/dist/esm/observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable.js","sourceRoot":"","sources":["../../src/observable.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAS/B,MAAM,CAAC,MAAM,UAAU,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC;AAQ/C,MAAM,UAAU,UAAU,CAAI,KAAe,EAAE,EAAa;IAC1D,MAAM,OAAO,GAAG,CACd,EAAmB,EACnB,UAA4B,EAAE,EAChB,EAAE;QAChB,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YACtB,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAClB,CAAC;QACD,OAAO,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3C,CAAC,CAAC;IAEF,OAAO;QACL,CAAC,UAAU,CAAC,EAAE,IAAI;QAClB,GAAG,EAAE;QACL,OAAO;KACR,CAAC;AACJ,CAAC;AAID,MAAM,UAAU,YAAY,CAAC,CAAU;IACrC,OAAO,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC;AAC5B,CAAC"}

package/dist/esm/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/esm/pubsub.d.ts

@@ -0,0 +1,11 @@
+import { Subscription, VoidFunction } from "./common/types";
+export interface PubSub<T> {
+    subscribers: Set<Subscription<T>>;
+    effects: Set<VoidFunction>;
+    publish: (value: T) => void;
+    subscribe: (fn: Subscription<T>, cleanup?: VoidFunction) => VoidFunction;
+    addEffect: (effect: VoidFunction, cleanup?: VoidFunction) => VoidFunction;
+    dispose: () => void;
+}
+export declare function pubsub<T>(): PubSub<T>;
+//# sourceMappingURL=pubsub.d.ts.map

package/dist/esm/pubsub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub.d.ts","sourceRoot":"","sources":["../../src/pubsub.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAG5D,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,WAAW,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,OAAO,EAAE,GAAG,CAAC,YAAY,CAAC,CAAC;IAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IAC5B,SAAS,EAAE,CAAC,EAAE,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IACzE,SAAS,EAAE,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;IAC1E,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED,wBAAgB,MAAM,CAAC,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,CA0DrC"}

package/dist/esm/pubsub.js

@@ -0,0 +1,47 @@
+import { Context } from "./context";
+export function pubsub() {
+    const subscribers = new Set();
+    const effects = new Set();
+    const trash = new Set();
+    const addTrash = (fn) => {
+        trash.add(fn);
+        return fn;
+    };
+    const publish = (value) => {
+        effects.forEach((fx) => {
+            Context.runEffect(fx);
+        });
+        subscribers.forEach((sub) => {
+            sub(value);
+        });
+    };
+    const addEffect = (effect, cleanup) => {
+        effects.add(effect);
+        return addTrash(() => {
+            effects.delete(effect);
+            cleanup?.();
+        });
+    };
+    const subscribe = (fn, cleanup) => {
+        subscribers.add(fn);
+        return addTrash(() => {
+            subscribers.delete(fn);
+            cleanup?.();
+        });
+    };
+    const dispose = () => {
+        trash.forEach((fn) => fn());
+        trash.clear();
+        subscribers.clear();
+        effects.clear();
+    };
+    return {
+        subscribers,
+        effects,
+        publish,
+        subscribe,
+        addEffect,
+        dispose,
+    };
+}
+//# sourceMappingURL=pubsub.js.map

package/dist/esm/pubsub.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pubsub.js","sourceRoot":"","sources":["../../src/pubsub.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAWpC,MAAM,UAAU,MAAM;IACpB,MAAM,WAAW,GAAG,IAAI,GAAG,EAAmB,CAAC;IAC/C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAgB,CAAC;IACxC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAgB,CAAC;IAEtC,MAAM,QAAQ,GAAG,CAAC,EAAgB,EAAgB,EAAE;QAClD,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QACd,OAAO,EAAE,CAAC;IACZ,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,CAAC,KAAQ,EAAQ,EAAE;QACjC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;YACrB,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;QACxB,CAAC,CAAC,CAAC;QACH,WAAW,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1B,GAAG,CAAC,KAAK,CAAC,CAAC;QACb,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,CAChB,MAAoB,EACpB,OAAsB,EACR,EAAE;QAChB,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QAEpB,OAAO,QAAQ,CAAC,GAAG,EAAE;YACnB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;YACvB,OAAO,EAAE,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,SAAS,GAAG,CAChB,EAAmB,EACnB,OAAsB,EACR,EAAE;QAChB,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAEpB,OAAO,QAAQ,CAAC,GAAG,EAAE;YACnB,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACvB,OAAO,EAAE,EAAE,CAAC;QACd,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,OAAO,GAAG,GAAS,EAAE;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;QAC5B,KAAK,CAAC,KAAK,EAAE,CAAC;QACd,WAAW,CAAC,KAAK,EAAE,CAAC;QACpB,OAAO,CAAC,KAAK,EAAE,CAAC;IAClB,CAAC,CAAC;IAEF,OAAO;QACL,WAAW;QACX,OAAO;QACP,OAAO;QACP,SAAS;QACT,SAAS;QACT,OAAO;KACR,CAAC;AACJ,CAAC"}

package/dist/esm/reference.d.ts

@@ -0,0 +1,15 @@
+import { Dispatch, Loose, SetStateAction } from "./common/types";
+import { Observable } from "./observable";
+export declare const REFERENCE: unique symbol;
+export type REFERENCE = typeof REFERENCE;
+export interface Reference<T> extends Observable<T> {
+    [REFERENCE]: true;
+    get: () => T;
+    set: Dispatch<SetStateAction<T>>;
+    peek: () => T;
+}
+export declare function ref<T>(value: T): Reference<T>;
+export declare function isReference(x: Loose): x is Reference<Loose>;
+export declare function isReference(x: unknown): x is Reference<unknown>;
+export declare function isReference<X extends Reference<unknown>>(x: X): x is X;
+//# sourceMappingURL=reference.d.ts.map

package/dist/esm/reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.d.ts","sourceRoot":"","sources":["../../src/reference.ts"],"names":[],"mappings":"AAGA,OAAO,EAAS,QAAQ,EAAE,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAGxE,OAAO,EAAc,UAAU,EAAE,MAAM,cAAc,CAAC;AAGtD,eAAO,MAAM,SAAS,eAAsB,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC;AAEzC,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,UAAU,CAAC,CAAC,CAAC;IACjD,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC,CAAC;IACb,GAAG,EAAE,QAAQ,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC,CAAC;CACf;AAED,wBAAgB,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAoC7C;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC;AAC7D,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAAC,OAAO,CAAC,CAAC;AACjE,wBAAgB,WAAW,CAAC,CAAC,SAAS,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC"}

package/dist/esm/reference.js

@@ -0,0 +1,44 @@
+import { has } from "./common";
+import { compare } from "./common/compare";
+import { isFunction } from "./common/is";
+import { Context } from "./context";
+import { observable } from "./observable";
+import { pubsub } from "./pubsub";
+export const REFERENCE = Symbol("Reference");
+export function ref(value) {
+    const ps = pubsub();
+    const state = { value };
+    const obs = observable(state, ps);
+    const addEffectDependency = (fx) => {
+        ps.addEffect(fx.run, fx.cleanup);
+    };
+    const get = () => {
+        const fx = Context.scope.current.effect;
+        if (fx)
+            addEffectDependency(fx);
+        return state.value;
+    };
+    const set = (fn) => {
+        const prev = state.value;
+        const next = isFunction(fn) ? fn(state.value) : fn;
+        if (!compare(next, prev)) {
+            state.value = next;
+            ps.publish(state.value);
+        }
+    };
+    const peek = () => {
+        return state.value;
+    };
+    return {
+        [REFERENCE]: true,
+        ...ps,
+        ...obs,
+        get,
+        set,
+        peek,
+    };
+}
+export function isReference(x) {
+    return has(x, REFERENCE);
+}
+//# sourceMappingURL=reference.js.map

package/dist/esm/reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reference.js","sourceRoot":"","sources":["../../src/reference.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,UAAU,EAAc,MAAM,cAAc,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC,MAAM,CAAC,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;AAU7C,MAAM,UAAU,GAAG,CAAI,KAAQ;IAC7B,MAAM,EAAE,GAAG,MAAM,EAAK,CAAC;IACvB,MAAM,KAAK,GAAa,EAAE,KAAK,EAAE,CAAC;IAClC,MAAM,GAAG,GAAG,UAAU,CAAI,KAAK,EAAE,EAAE,CAAC,CAAC;IAErC,MAAM,mBAAmB,GAAG,CAAC,EAAU,EAAE,EAAE;QACzC,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;IACnC,CAAC,CAAC;IAEF,MAAM,GAAG,GAAG,GAAM,EAAE;QAClB,MAAM,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QACxC,IAAI,EAAE;YAAE,mBAAmB,CAAC,EAAE,CAAC,CAAC;QAChC,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC,CAAC;IAEF,MAAM,GAAG,GAAgC,CAAC,EAAE,EAAE,EAAE;QAC9C,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC;QACzB,MAAM,IAAI,GAAG,UAAU,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACnD,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC;YACzB,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC;YACnB,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC1B,CAAC;IACH,CAAC,CAAC;IAEF,MAAM,IAAI,GAAG,GAAM,EAAE;QACnB,OAAO,KAAK,CAAC,KAAK,CAAC;IACrB,CAAC,CAAC;IAEF,OAAO;QACL,CAAC,SAAS,CAAC,EAAE,IAAI;QACjB,GAAG,EAAE;QACL,GAAG,GAAG;QACN,GAAG;QACH,GAAG;QACH,IAAI;KACL,CAAC;AACJ,CAAC;AAKD,MAAM,UAAU,WAAW,CAAC,CAAU;IACpC,OAAO,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;AAC3B,CAAC"}

package/dist/esm/utils/findRefs.d.ts

@@ -0,0 +1,3 @@
+import { Reference } from "../reference";
+export declare const findRefs: (x: unknown) => Reference<unknown>[];
+//# sourceMappingURL=findRefs.d.ts.map

package/dist/esm/utils/findRefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRefs.d.ts","sourceRoot":"","sources":["../../../src/utils/findRefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,SAAS,EAAE,MAAM,cAAc,CAAC;AAEtD,eAAO,MAAM,QAAQ,GAAI,GAAG,OAAO,KAAG,SAAS,CAAC,OAAO,CAAC,EAmBvD,CAAA"}

package/dist/esm/utils/findRefs.js

@@ -0,0 +1,19 @@
+import { isReference } from "../reference";
+export const findRefs = (x) => {
+    if (typeof x === 'undefined' || x === null)
+        return [];
+    if (isReference(x))
+        return [x];
+    if (Array.isArray(x)) {
+        return x.map(it => findRefs(it)).flat();
+    }
+    if (typeof x === 'object' && x !== null) {
+        const refs = [];
+        for (const [_k, v] of Object.entries(x)) {
+            refs.push(...findRefs(v));
+        }
+        return refs;
+    }
+    return [];
+};
+//# sourceMappingURL=findRefs.js.map

package/dist/esm/utils/findRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"findRefs.js","sourceRoot":"","sources":["../../../src/utils/findRefs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAa,MAAM,cAAc,CAAC;AAEtD,MAAM,CAAC,MAAM,QAAQ,GAAG,CAAC,CAAU,EAAwB,EAAE;IAE3D,IAAI,OAAO,CAAC,KAAK,WAAW,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,EAAE,CAAC;IACtD,IAAI,WAAW,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,CAAC;IAG/B,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACrB,OAAO,CAAC,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;IAC1C,CAAC;IAED,IAAI,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,EAAE,CAAC;QACxC,MAAM,IAAI,GAA8B,EAAE,CAAC;QAC3C,KAAK,MAAM,CAAC,EAAE,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;YACxC,IAAI,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,OAAO,EAAE,CAAC;AACZ,CAAC,CAAA"}

package/dist/esm/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './findRefs';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/dist/esm/utils/index.js

@@ -0,0 +1,2 @@
+export * from './findRefs';
+//# sourceMappingURL=index.js.map

package/dist/esm/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC"}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@derivesome/core",
+  "version": "1.0.0",
+  "description": "",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "typings": "./dist/cjs/index.d.ts",
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc -p tsconfig.json && echo '{\"type\":\"module\"}' > dist/esm/package.json && tsc -p tsconfig.cjs.json",
+    "format": "prettier ./src --write",
+    "check": "tsc -p ./tsconfig.json --noEmit"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.28.2",
+   "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+   },
+  "devDependencies": {
+    "@types/node": "^25.2.1",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}

package/package.json~

@@ -0,0 +1,42 @@
+{
+  "name": "@derivesome/core",
+  "version": "1.0.0",
+  "private": true,
+  "description": "",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/cjs/index.d.ts",
+  "typings": "./dist/cjs/index.d.ts",
+  "scripts": {
+    "test": "vitest",
+    "build": "tsc -p tsconfig.json && echo '{\"type\":\"module\"}' > dist/esm/package.json && tsc -p tsconfig.cjs.json",
+    "format": "prettier ./src --write",
+    "check": "tsc -p ./tsconfig.json --noEmit"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.28.2",
+   "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      },
+      "default": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+   },
+  "devDependencies": {
+    "@types/node": "^25.2.1",
+    "prettier": "^3.8.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
+  }
+}

package/src/array-proxy.ts

@@ -0,0 +1,94 @@
+import { PubSub, pubsub } from "./pubsub";
+import { VoidFunction } from "./common/types";
+
+export type ArrayMutation<T> =
+  | { type: "push"; items: T[] }
+  | { type: "pop"; removed: T | undefined }
+  | { type: "shift"; removed: T | undefined }
+  | { type: "unshift"; items: T[] }
+  | { type: "splice"; start: number; deleteCount: number; removed: T[]; added: T[] }
+  | { type: "sort" }
+  | { type: "reverse" }
+  | { type: "fill"; value: T; start: number; end: number }
+  | { type: "copyWithin"; target: number; start: number; end: number }
+  | { type: "set"; index: number; value: T };
+
+export class ArrayProxy<T> extends Array<T> {
+  readonly ps: PubSub<ArrayMutation<T>>;
+
+  constructor(...items: T[]) {
+    super(...items);
+    this.ps = pubsub<ArrayMutation<T>>();
+  }
+
+  subscribe(fn: (mutation: ArrayMutation<T>) => void, cleanup?: VoidFunction): VoidFunction {
+    return this.ps.subscribe(fn, cleanup);
+  }
+
+  override push(...items: T[]): number {
+    const result = super.push(...items);
+    this.ps.publish({ type: "push", items });
+    return result;
+  }
+
+  override pop(): T | undefined {
+    const removed = super.pop();
+    this.ps.publish({ type: "pop", removed });
+    return removed;
+  }
+
+  override shift(): T | undefined {
+    const removed = super.shift();
+    this.ps.publish({ type: "shift", removed });
+    return removed;
+  }
+
+  override unshift(...items: T[]): number {
+    const result = super.unshift(...items);
+    this.ps.publish({ type: "unshift", items });
+    return result;
+  }
+
+  override splice(start: number, deleteCount?: number, ...items: T[]): T[] {
+    const dc = deleteCount ?? this.length - start;
+    const removed = super.splice(start, dc, ...items);
+    this.ps.publish({ type: "splice", start, deleteCount: dc, removed, added: items });
+    return removed;
+  }
+
+  override sort(compareFn?: (a: T, b: T) => number): this {
+    super.sort(compareFn);
+    this.ps.publish({ type: "sort" });
+    return this;
+  }
+
+  override reverse(): this {
+    super.reverse();
+    this.ps.publish({ type: "reverse" });
+    return this;
+  }
+
+  override fill(value: T, start?: number, end?: number): this {
+    const s = start ?? 0;
+    const e = end ?? this.length;
+    super.fill(value, s, e);
+    this.ps.publish({ type: "fill", value, start: s, end: e });
+    return this;
+  }
+
+  override copyWithin(target: number, start: number, end?: number): this {
+    const e = end ?? this.length;
+    super.copyWithin(target, start, e);
+    this.ps.publish({ type: "copyWithin", target, start, end: e });
+    return this;
+  }
+
+  set(index: number, value: T): void {
+    this[index] = value;
+    this.ps.publish({ type: "set", index, value });
+  }
+
+  dispose(): void {
+    this.ps.dispose();
+  }
+}

package/src/common/array.ts

@@ -0,0 +1,72 @@
+export const range = (n: number): Array<number> =>
+  n <= 0 ? [] : Array.from(Array(Math.floor(n)).keys());
+
+export const enumerate = <T>(arr: T[]): Array<[number, T]> => {
+  return arr.map((v, i) => [i, v]);
+};
+
+export const zipMin = <A, B>(a: A[], b: B[]): Array<[A, B]> => {
+  const length = Math.min(a.length, b.length);
+  return range(length).map((i) => [a[i]!, b[i]!]);
+};
+
+export const zipMax = <A, B>(a: A[], b: B[]): Array<[A | undefined, B | undefined]> => {
+  const length = Math.max(a.length, b.length);
+  return range(length).map((i) => [a[i], b[i]]);
+};
+
+export const zipByKey = <A, B>(
+  a: A[],
+  b: B[],
+  getKey: <T extends A | B>(item: T) => PropertyKey | null,
+): { pairs: Array<[A, B]>, restA: A[], restB: B[] } => {
+  const keys = Array.from(
+    new Set(
+      [...a.map((x) => getKey(x)), ...b.map((x) => getKey(x))].filter(
+        (x) => x !== null,
+      ),
+    ),
+  );
+
+  const ma = new Map(
+    a
+      .map((x): [PropertyKey | null, A] => [getKey(x), x])
+      .filter(([k, _]) => k !== null),
+  );
+  const mb = new Map(
+    b
+      .map((x): [PropertyKey | null, B] => [getKey(x), x])
+      .filter(([k, _]) => k !== null),
+  );
+
+  const z: Array<[A, B]> = [];
+  const restA: A[] = [];
+  const restB: B[] = [];
+  const seenA = new Set<A>();
+  const seenB = new Set<B>();
+
+  for (const k of keys) {
+    const va = ma.get(k) ?? null;
+    const vb = mb.get(k) ?? null;
+
+    if (va !== null && vb === null) {
+      restA.push(va);
+      seenA.add(va);
+    } else if (va === null && vb !== null) {
+      restB.push(vb);
+      seenB.add(vb);
+    } else if (va !== null && vb !== null) {
+      z.push([va, vb]);
+      seenA.add(va);
+      seenB.add(vb);
+    }
+  }
+
+
+  return { pairs: z, restA, restB };
+};
+
+
+export const unique = <T>(arr: T[]): T[] => {
+  return Array.from(new Set<T>(arr));
+}

package/src/common/compare.ts

@@ -0,0 +1,3 @@
+export const compare = (a: unknown, b: unknown): boolean => {
+  return a === b;
+};

package/src/common/diff.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, assert } from 'vitest';
+import { diff } from './diff';
+
+describe('diff', () => {
+  it('should return empty array for identical primitives', () => {
+    assert.deepEqual(diff(1, 1), []);
+    assert.deepEqual(diff('hello', 'hello'), []);
+    assert.deepEqual(diff(true, true), []);
+  });
+
+  it('should detect changed primitives', () => {
+    const result = diff(1, 2);
+    assert.deepEqual(result, [
+      { type: 'changed', path: [], oldValue: 1, newValue: 2 },
+    ]);
+  });
+
+  it('should return empty array for identical objects', () => {
+    assert.deepEqual(diff({ a: 1, b: 2 }, { a: 1, b: 2 }), []);
+  });
+
+  it('should detect changed properties', () => {
+    const result = diff({ a: 1 }, { a: 2 });
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['a'], oldValue: 1, newValue: 2 },
+    ]);
+  });
+
+  it('should detect added properties', () => {
+    const result = diff({ a: 1 } as any, { a: 1, b: 2 } as any);
+    assert.deepEqual(result, [
+      { type: 'added', path: ['b'], newValue: 2 },
+    ]);
+  });
+
+  it('should detect removed properties', () => {
+    const result = diff({ a: 1, b: 2 } as any, { a: 1 } as any);
+    assert.deepEqual(result, [
+      { type: 'removed', path: ['b'], oldValue: 2 },
+    ]);
+  });
+
+  it('should handle nested object diffs', () => {
+    const a = { x: { y: { z: 1 } } };
+    const b = { x: { y: { z: 2 } } };
+    const result = diff(a, b);
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['x', 'y', 'z'], oldValue: 1, newValue: 2 },
+    ]);
+  });
+
+  it('should handle array element changes', () => {
+    const result = diff([1, 2, 3], [1, 9, 3]);
+    assert.deepEqual(result, [
+      { type: 'changed', path: [1], oldValue: 2, newValue: 9 },
+    ]);
+  });
+
+  it('should detect added array elements', () => {
+    const result = diff([1, 2], [1, 2, 3]);
+    assert.deepEqual(result, [
+      { type: 'added', path: [2], newValue: 3 },
+    ]);
+  });
+
+  it('should detect removed array elements', () => {
+    const result = diff([1, 2, 3], [1, 2]);
+    assert.deepEqual(result, [
+      { type: 'removed', path: [2], oldValue: 3 },
+    ]);
+  });
+
+  it('should handle nested arrays inside objects', () => {
+    const a = { items: [1, 2] };
+    const b = { items: [1, 3] };
+    const result = diff(a, b);
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['items', 1], oldValue: 2, newValue: 3 },
+    ]);
+  });
+
+  it('should detect type change from object to primitive', () => {
+    const result = diff({ a: { b: 1 } } as any, { a: 42 } as any);
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['a'], oldValue: { b: 1 }, newValue: 42 },
+    ]);
+  });
+
+  it('should detect type change from array to object', () => {
+    const result = diff({ a: [1, 2] } as any, { a: { x: 1 } } as any);
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['a'], oldValue: [1, 2], newValue: { x: 1 } },
+    ]);
+  });
+
+  it('should handle symbol keys', () => {
+    const sym = Symbol('test');
+    const a = { [sym]: 1 };
+    const b = { [sym]: 2 };
+    const result = diff(a, b);
+    assert.deepEqual(result, [
+      { type: 'changed', path: [sym], oldValue: 1, newValue: 2 },
+    ]);
+  });
+
+  it('should handle deeply nested mixed structures', () => {
+    const a = { users: [{ name: 'Alice', scores: [10, 20] }] };
+    const b = { users: [{ name: 'Alice', scores: [10, 30] }] };
+    const result = diff(a, b);
+    assert.deepEqual(result, [
+      { type: 'changed', path: ['users', 0, 'scores', 1], oldValue: 20, newValue: 30 },
+    ]);
+  });
+});

package/src/common/diff.ts

@@ -0,0 +1,85 @@
+import { isPlainObject } from './is';
+
+export type DiffType = 'added' | 'removed' | 'changed';
+
+export type Diff = {
+  type: DiffType;
+  path: PropertyKey[];
+  oldValue?: unknown;
+  newValue?: unknown;
+};
+
+export const diff = <T>(a: T, b: T): Diff[] => {
+  const diffs: Diff[] = [];
+  diffRecursive(a, b, [], diffs);
+  return diffs;
+};
+
+const diffRecursive = (a: unknown, b: unknown, path: PropertyKey[], diffs: Diff[]): void => {
+  if (a === b) return;
+
+  const aIsArray = Array.isArray(a);
+  const bIsArray = Array.isArray(b);
+
+  if (aIsArray && bIsArray) {
+    diffArrays(a, b, path, diffs);
+    return;
+  }
+
+  const aIsObject = isPlainObject(a);
+  const bIsObject = isPlainObject(b);
+
+  if (aIsObject && bIsObject) {
+    diffObjects(a, b, path, diffs);
+    return;
+  }
+
+  diffs.push({ type: 'changed', path, oldValue: a, newValue: b });
+};
+
+const diffObjects = (
+  a: Record<PropertyKey, unknown>,
+  b: Record<PropertyKey, unknown>,
+  path: PropertyKey[],
+  diffs: Diff[],
+): void => {
+  const aKeys = Reflect.ownKeys(a);
+  const bKeys = Reflect.ownKeys(b);
+  const bKeySet = new Set(bKeys);
+
+  for (const key of aKeys) {
+    const childPath = [...path, key];
+    if (!bKeySet.has(key)) {
+      diffs.push({ type: 'removed', path: childPath, oldValue: a[key] });
+    } else {
+      diffRecursive(a[key], b[key], childPath, diffs);
+    }
+  }
+
+  const aKeySet = new Set(aKeys);
+  for (const key of bKeys) {
+    if (!aKeySet.has(key)) {
+      diffs.push({ type: 'added', path: [...path, key], newValue: b[key] });
+    }
+  }
+};
+
+const diffArrays = (
+  a: unknown[],
+  b: unknown[],
+  path: PropertyKey[],
+  diffs: Diff[],
+): void => {
+  const maxLen = Math.max(a.length, b.length);
+
+  for (let i = 0; i < maxLen; i++) {
+    const childPath = [...path, i];
+    if (i >= a.length) {
+      diffs.push({ type: 'added', path: childPath, newValue: b[i] });
+    } else if (i >= b.length) {
+      diffs.push({ type: 'removed', path: childPath, oldValue: a[i] });
+    } else {
+      diffRecursive(a[i], b[i], childPath, diffs);
+    }
+  }
+};