@peers-app/peers-sdk 0.1.4

package/dist/keys.test.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const keys_1 = require("./keys");
+describe('keys', () => {
+    it('should allow creating a new key pair', () => {
+        const keys = (0, keys_1.newKeys)();
+        expect(keys.publicKey).toBeTruthy();
+        expect(keys.secretKey).toBeTruthy();
+        expect(keys.publicBoxKey).toBeTruthy();
+    });
+    describe('message signing', () => {
+        it('should allow signing a message with a secret key and opening it with the corresponding public key', () => {
+            const keys = (0, keys_1.newKeys)();
+            const msg = 'hello world';
+            const signed = (0, keys_1.signMessageWithSecretKey)(msg, keys.secretKey);
+            expect(signed).toBeTruthy();
+            expect(signed).not.toEqual(msg);
+            const opened = (0, keys_1.openMessageWithPublicKey)(signed, keys.publicKey);
+            expect(opened).toEqual(msg);
+        });
+    });
+    describe('object signing', () => {
+        it('should allow signing an object with a secret key and opening it with the corresponding public key', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { hello: 'world' };
+            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
+            expect(signed).toBeTruthy();
+            expect(signed).not.toEqual(obj);
+            const opened = (0, keys_1.openSignedObject)(signed);
+            expect(opened).toEqual(obj);
+        });
+        it('should throw an error if the data changes after the signature', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { hello: 'world' };
+            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
+            expect(signed).toBeTruthy();
+            signed.contents = { hello: 'world2' };
+            expect(signed).not.toEqual(obj);
+            expect(() => (0, keys_1.openSignedObject)(signed)).toThrow(/signature/i);
+        });
+        it('should handle null and undefined gracefully', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = undefined;
+            const signed = (0, keys_1.signObjectWithSecretKey)(obj, keys.secretKey);
+            expect(signed).toBeTruthy();
+            expect(signed).not.toEqual(obj);
+            const opened = (0, keys_1.openSignedObject)(signed);
+            expect(opened).toEqual(obj);
+        });
+        it.each([false, true, 0, 1, 3.1415, "", "s"])(`should handle simple values: \`%s\``, (value) => {
+            const keys = (0, keys_1.newKeys)();
+            const signed = (0, keys_1.signObjectWithSecretKey)(value, keys.secretKey);
+            expect(signed).toBeTruthy();
+            expect(signed).not.toEqual(value);
+            const opened = (0, keys_1.openSignedObject)(signed);
+            expect(opened).toEqual(value);
+        });
+    });
+    describe('message boxing', () => {
+        it('should allow boxing data with a public key so it can only be opened with the secret key', () => {
+            const from = (0, keys_1.newKeys)();
+            const to = (0, keys_1.newKeys)();
+            const msg = 'hello world';
+            const boxed = (0, keys_1.boxDataWithKeys)(msg, to.publicBoxKey, from.secretKey);
+            expect(boxed).toBeTruthy();
+            const opened = (0, keys_1.openBoxWithSecretKey)(boxed, to.secretKey);
+            expect(opened).toEqual(msg);
+        });
+        it('should allow boxing objects', () => {
+            const from = (0, keys_1.newKeys)();
+            const to = (0, keys_1.newKeys)();
+            const msg = { hello: 'world' };
+            const boxed = (0, keys_1.boxDataWithKeys)(msg, to.publicBoxKey, from.secretKey);
+            expect(boxed).toBeTruthy();
+            const opened = (0, keys_1.openBoxWithSecretKey)(boxed, to.secretKey);
+            expect(opened).toEqual(msg);
+        });
+    });
+    describe('message encryption', () => {
+        it('should allow encrypting a message with a secret key so it can only be decrypted with that same secret key', () => {
+            const keys = (0, keys_1.newKeys)();
+            const msg = 'hello world';
+            const boxed = (0, keys_1.encryptData)(msg, keys.secretKey);
+            expect(boxed).toBeTruthy();
+            const opened = (0, keys_1.decryptData)(boxed, keys.secretKey);
+            expect(opened).toEqual(msg);
+        });
+        it('should allow encrypting objects', () => {
+            const keys = (0, keys_1.newKeys)();
+            const msg = { hello: 'world' };
+            const boxed = (0, keys_1.encryptData)(msg, keys.secretKey);
+            expect(boxed).toBeTruthy();
+            const opened = (0, keys_1.decryptData)(boxed, keys.secretKey);
+            expect(opened).toEqual(msg);
+        });
+    });
+    describe('loading keys', () => {
+        it('should allow loading keys from a secret key', () => {
+            const keys = (0, keys_1.newKeys)();
+            const loadedKeys = (0, keys_1.loadKeys)(keys.secretKey);
+            expect(loadedKeys.secretKey).toEqual(keys.secretKey);
+            expect(loadedKeys.publicKey).toEqual(keys.publicKey);
+            expect(loadedKeys.publicBoxKey).toEqual(keys.publicBoxKey);
+        });
+    });
+    describe('hashBytes', () => {
+        it('should hash buffer data consistently', () => {
+            const data = Buffer.from('Hello, World!', 'utf8');
+            const hash1 = (0, keys_1.hashBytes)(data);
+            const hash2 = (0, keys_1.hashBytes)(data);
+            expect(hash1).toBe(hash2);
+            expect(hash1).toBeTruthy();
+        });
+        it('should produce different hashes for different data', () => {
+            const data1 = Buffer.from('Hello, World!', 'utf8');
+            const data2 = Buffer.from('Hello, World?', 'utf8');
+            const hash1 = (0, keys_1.hashBytes)(data1);
+            const hash2 = (0, keys_1.hashBytes)(data2);
+            expect(hash1).not.toBe(hash2);
+        });
+        it('should work with binary data', () => {
+            // Create binary data with all byte values
+            const binaryData = Buffer.alloc(256);
+            for (let i = 0; i < 256; i++) {
+                binaryData[i] = i;
+            }
+            const hash = (0, keys_1.hashBytes)(binaryData);
+            expect(hash).toBeTruthy();
+            // Verify consistency
+            const hash2 = (0, keys_1.hashBytes)(binaryData);
+            expect(hash).toBe(hash2);
+        });
+        it('should be equivalent to hashValue for string data', () => {
+            const text = 'Hello, World!';
+            const stringBuffer = Buffer.from(text, 'utf8');
+            const bufferHash = (0, keys_1.hashBytes)(stringBuffer);
+            const stringHash = (0, keys_1.hashValue)(text);
+            expect(bufferHash).toBe(stringHash);
+        });
+        it('should handle empty buffer', () => {
+            const emptyBuffer = Buffer.alloc(0);
+            const hash = (0, keys_1.hashBytes)(emptyBuffer);
+            expect(hash).toBeTruthy();
+        });
+        it('should handle large buffers', () => {
+            // 1MB of data
+            const largeBuffer = Buffer.alloc(1024 * 1024, 'A');
+            const hash = (0, keys_1.hashBytes)(largeBuffer);
+            expect(hash).toBeTruthy();
+        });
+    });
+    describe('object signature embedding', () => {
+        it('should add signature to object and verify it successfully', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { name: 'test', value: 42 };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            expect(signedObj).toHaveProperty('signature');
+            expect(signedObj.name).toBe('test');
+            expect(signedObj.value).toBe(42);
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
+        });
+        it('should fail verification if object is modified after signing', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { name: 'test', value: 42 };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            signedObj.value = 999; // modify after signing
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(false);
+        });
+        it('should fail verification if signature is tampered with', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { name: 'test', value: 42 };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            signedObj.signature = signedObj.signature + 'tampered';
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(false);
+        });
+        it('should extract public key from signature', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { name: 'test', value: 42 };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(signedObj);
+            expect(extractedPublicKey).toBe(keys.publicKey);
+        });
+        it('should return undefined for malformed signature', () => {
+            const obj = { name: 'test', value: 42, signature: 'malformed' };
+            const extractedPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(obj);
+            expect(extractedPublicKey).toBeUndefined();
+        });
+        it('should handle objects with existing signature property', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = { name: 'test', value: 42, signature: 'old-signature' };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            expect(signedObj.signature).not.toBe('old-signature');
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
+        });
+        it('should work with complex nested objects', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = {
+                user: { name: 'Alice', age: 30 },
+                settings: { theme: 'dark', notifications: true },
+                data: [1, 2, 3, { nested: true }]
+            };
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
+            expect(signedObj.user.name).toBe('Alice');
+            expect(signedObj.data[3].nested).toBe(true);
+        });
+        it('should handle empty objects', () => {
+            const keys = (0, keys_1.newKeys)();
+            const obj = {};
+            const signedObj = (0, keys_1.addSignatureToObject)(obj, keys.secretKey);
+            expect((0, keys_1.isObjectSignatureValid)(signedObj)).toBe(true);
+            expect((0, keys_1.getPublicKeyFromObjectSignature)(signedObj)).toBe(keys.publicKey);
+        });
+    });
+});

package/dist/mentions.d.ts

@@ -0,0 +1,9 @@
+export type IMentionData = {
+    kind: string;
+    name: string;
+    id: string;
+    clickable?: boolean;
+};
+export declare const mentionRegex: () => RegExp;
+export declare const formatMention: (data: IMentionData) => string;
+export declare const getAllMentions: (markdown: string) => IMentionData[];

package/dist/mentions.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllMentions = exports.formatMention = exports.mentionRegex = void 0;
+// export const mentionRegex = () => /<(@user|@assistant|\$tool|\$workflow|\$event|\$task):([a-zA-Z0-9_-]+):([a-zA-Z0-9]{25})(:([a-zA-Z0-9]{25}))?>/;
+// export const mentionRegex = () => /<(@|$)([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]+):([a-zA-Z0-9]{25})(:([a-zA-Z0-9]{25}))?>/;
+const mentionRegex = () => /<(@|\$)([a-zA-Z0-9_-]+):([a-zA-Z0-9_-]+):([a-zA-Z0-9]{25})?>/;
+exports.mentionRegex = mentionRegex;
+const formatMention = (data) => {
+    let prefix = '$';
+    if (data.kind === 'assistant' || data.kind === 'user') {
+        prefix = '@';
+    }
+    let name = data.name.replace(/\s/g, '_');
+    // remove non-alphanumeric characters
+    name = name.replace(/[^a-zA-Z0-9_-]/g, '');
+    let mention = `<${prefix}${data.kind}:${name}:${data.id}`;
+    // if (data.kind === 'assistant') {
+    //   mention += `:${data.userId}`;
+    // }
+    mention += '>';
+    return mention;
+};
+exports.formatMention = formatMention;
+const getAllMentions = (markdown) => {
+    const mentions = [];
+    let lastIndex = 0;
+    let match;
+    let cnt = 0;
+    const regex = (0, exports.mentionRegex)();
+    while ((match = regex.exec(markdown)) !== null) {
+        cnt++;
+        markdown = markdown.slice(match.index + match[0].length);
+        const kind = match[2];
+        const name = match[3].replace(/_/g, ' ');
+        const id = match[4];
+        const data = {
+            kind: kind,
+            name,
+            id,
+        };
+        mentions.push(data);
+        lastIndex = regex.lastIndex;
+    }
+    return mentions;
+};
+exports.getAllMentions = getAllMentions;

package/dist/observable.d.ts

@@ -0,0 +1,19 @@
+type ObservableFn<T> = ((newValue?: T) => T);
+export type Subscription = {
+    dispose: () => void;
+};
+type ObservableProps<T> = {
+    subscribe: (subscriber: (newValue: T) => void) => Subscription;
+    notifySubscribers: (newValue?: T) => void;
+    subscriberCount: () => number;
+};
+export type Observable<T> = ObservableFn<T> & ObservableProps<T>;
+export declare function observable<T>(initialValue?: T): Observable<T>;
+export declare function computed<T>(fn: ({
+    read: () => T;
+    write?: (val: T) => void;
+}) | (() => T)): Observable<T>;
+export declare function isSubscribable(obj: any): obj is Observable<any>;
+export declare function unwrapObservable<T>(obj: T | Observable<T>): T;
+export declare function linkObservables<T>(obs1: Observable<T>, obs2: Observable<T>): Subscription;
+export {};

package/dist/observable.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observable = observable;
+exports.computed = computed;
+exports.isSubscribable = isSubscribable;
+exports.unwrapObservable = unwrapObservable;
+exports.linkObservables = linkObservables;
+const lodash_1 = require("lodash");
+const utils_1 = require("./utils");
+const _ = require("lodash");
+const runningComputes = {};
+function observable(initialValue) {
+    let value = initialValue;
+    const subscribers = [];
+    const obs = ((newValue) => {
+        Object.values(runningComputes).forEach(c => c.push(obs));
+        if (newValue !== undefined && newValue !== value) {
+            value = newValue;
+            obs.notifySubscribers();
+        }
+        // TODO - get typings to say if a value is passed in it's type T otherwise it's T | undefined
+        return value;
+    });
+    obs.notifySubscribers = (newValue) => {
+        if (newValue !== undefined) {
+            value = newValue;
+        }
+        subscribers.forEach(subscriber => subscriber(value)); // TODO fix typing here too
+    };
+    obs.subscribe = (subscriber) => {
+        subscribers.push(subscriber);
+        // if (value !== undefined) {
+        //   subscriber(value);
+        // }
+        return {
+            dispose: () => {
+                const iSub = subscribers.indexOf(subscriber);
+                if (iSub >= 0) {
+                    subscribers.splice(iSub, 1);
+                }
+            }
+        };
+    };
+    obs.subscriberCount = () => subscribers.length;
+    return obs;
+}
+function computed(fn) {
+    const read = _.isFunction(fn) ? fn : fn.read;
+    const write = _.isFunction(fn) ? undefined : fn.write;
+    // compute dependencies and initial value;
+    const dependencies = [];
+    const runId = (0, utils_1.newid)();
+    runningComputes[runId] = dependencies;
+    const _obs = observable(read());
+    delete runningComputes[runId];
+    let dirty = false;
+    const recompute = () => {
+        dirty = false;
+        return _obs(read());
+    };
+    const obs = (newValue) => {
+        if (newValue !== undefined) {
+            if (write) {
+                write(newValue);
+                return recompute();
+            }
+            else {
+                throw new Error('Computed value is readonly');
+            }
+        }
+        if (dirty) {
+            return recompute();
+        }
+        return _obs();
+    };
+    const onDepChange = () => {
+        if (_obs.subscriberCount() === 0) {
+            dirty = true;
+        }
+        else {
+            recompute();
+        }
+    };
+    // subscribe to dependencies
+    (0, lodash_1.uniq)(dependencies).forEach(dep => dep.subscribe(onDepChange));
+    Object.assign(obs, _obs);
+    return obs;
+}
+function isSubscribable(obj) {
+    return obj && typeof obj === 'function' && obj.subscribe && obj.notifySubscribers;
+}
+function unwrapObservable(obj) {
+    return isSubscribable(obj) ? obj() : obj;
+}
+function linkObservables(obs1, obs2) {
+    const sub1 = obs1.subscribe(value => {
+        if (value !== obs2()) {
+            obs2(value);
+        }
+    });
+    const sub2 = obs2.subscribe(value => {
+        if (value !== obs1()) {
+            obs1(value);
+        }
+    });
+    return {
+        dispose: () => {
+            sub1.dispose();
+            sub2.dispose();
+        }
+    };
+}

package/dist/observable.test.d.ts

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

package/dist/observable.test.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const observable_1 = require("./observable");
+describe('observable.ts', () => {
+    describe('observable', () => {
+        it('should be able to create an observable', () => {
+            const obs = (0, observable_1.observable)(3);
+            expect(obs()).toBe(3);
+        });
+        it('should be able to update an observable', () => {
+            const obs = (0, observable_1.observable)(3);
+            obs(4);
+            expect(obs()).toBe(4);
+        });
+        it('should be able to subscribe to an observable', () => {
+            const obs = (0, observable_1.observable)(3);
+            let value = 0;
+            const sub = obs.subscribe(newValue => {
+                value = newValue;
+            });
+            expect(value).toBe(0);
+            obs(4);
+            expect(value).toBe(4);
+            sub.dispose();
+            obs(5);
+            expect(value).toBe(4);
+        });
+        it('should return the value when writing to itself', () => {
+            const obs = (0, observable_1.observable)(3);
+            expect(obs(4)).toBe(4);
+        });
+    });
+    describe('computed', () => {
+        it('should be able to create a computed observable', () => {
+            const com = (0, observable_1.computed)(() => 3);
+            expect(com()).toBe(3);
+        });
+        it('should throw if trying to set value', () => {
+            const com = (0, observable_1.computed)(() => 3);
+            expect(() => com(4)).toThrow();
+        });
+        it('should be able to create a computed observable that depends on another observable', () => {
+            const obs1 = (0, observable_1.observable)(3);
+            const com1 = (0, observable_1.computed)(() => obs1() + 1);
+            expect(com1()).toBe(4);
+            obs1(5);
+            expect(com1()).toBe(6);
+        });
+        it('should be able to create a computed observable that depends on another computed observable', () => {
+            const obs1 = (0, observable_1.observable)(3);
+            const com1 = (0, observable_1.computed)(() => obs1() + 1);
+            const com2 = (0, observable_1.computed)(() => com1() + 1);
+            expect(com2()).toBe(5);
+            obs1(5);
+            expect(com2()).toBe(7);
+        });
+        it('should be able to create a computed observable that depends on another computed observable that depends on another computed observable', () => {
+            const obs1 = (0, observable_1.observable)(3);
+            const com1 = (0, observable_1.computed)(() => obs1() + 1);
+            const com2 = (0, observable_1.computed)(() => com1() + 1);
+            const com3 = (0, observable_1.computed)(() => com2() + 1);
+            expect(com3()).toBe(6);
+        });
+        it('should notify subscribers of new value when a dependency changes', () => {
+            const obs1 = (0, observable_1.observable)(3);
+            const com1 = (0, observable_1.computed)(() => obs1() + 1);
+            let newValue = 0;
+            com1.subscribe(val => {
+                newValue = val;
+            });
+            expect(com1()).toBe(4);
+            expect(newValue).toBe(0);
+            obs1(5);
+            expect(newValue).toBe(6);
+        });
+        it('should not notify subscribers of new value when a dependency changes if there are no subscribers', () => {
+            const obs1 = (0, observable_1.observable)(1);
+            let computeCount = 0;
+            const com1 = (0, observable_1.computed)(() => {
+                computeCount++;
+                return obs1() + 1;
+            });
+            let newValue = 0;
+            const sub = com1.subscribe(val => {
+                newValue = val;
+            });
+            expect(computeCount).toBe(1);
+            expect(com1()).toBe(2);
+            expect(newValue).toBe(0);
+            expect(computeCount).toBe(1);
+            obs1(2);
+            expect(computeCount).toBe(2);
+            expect(com1()).toBe(3);
+            expect(newValue).toBe(3);
+            sub.dispose();
+            obs1(3);
+            expect(computeCount).toBe(2);
+            expect(com1()).toBe(4);
+            expect(computeCount).toBe(3);
+            expect(com1()).toBe(4);
+        });
+        it('should only recompute value when a dependency changes if there are subscribers', () => {
+            const obs1 = (0, observable_1.observable)(1);
+            let recomputeCount = 0;
+            const com1 = (0, observable_1.computed)(() => {
+                recomputeCount++;
+                return obs1() + recomputeCount;
+            });
+            expect(com1()).toBe(2);
+            expect(recomputeCount).toBe(1);
+            expect(com1()).toBe(2);
+            expect(recomputeCount).toBe(1);
+            obs1(2);
+            expect(recomputeCount).toBe(1);
+            expect(obs1()).toBe(2);
+            expect(recomputeCount).toBe(1);
+            // NOTE the recomputeCount only changed when we inspected com1 (lazy evaluation)
+            //      this probably won't be used much right now but if we implement `deferCompute` this can have a big impact
+            expect(com1()).toBe(4);
+            expect(recomputeCount).toBe(2);
+        });
+        it('should immediately, and still only, recompute value when a dependency changes if there are subscribers', () => {
+            const obs1 = (0, observable_1.observable)(1);
+            let recomputeCount = 0;
+            const com1 = (0, observable_1.computed)(() => {
+                recomputeCount++;
+                return obs1() + recomputeCount;
+            });
+            let newValue = 0;
+            com1.subscribe(val => {
+                newValue = val;
+            });
+            expect(com1()).toBe(2);
+            expect(recomputeCount).toBe(1);
+            expect(newValue).toBe(0);
+            obs1(2);
+            expect(recomputeCount).toBe(2);
+            expect(newValue).toBe(4);
+            expect(recomputeCount).toBe(2);
+            expect(com1()).toBe(4);
+            expect(com1()).toBe(4);
+        });
+        it('notify should set the value and notify subscribers without recomputing', () => {
+            const obs1 = (0, observable_1.observable)(1);
+            let recomputeCount = 0;
+            const com1 = (0, observable_1.computed)(() => {
+                recomputeCount++;
+                return obs1() + recomputeCount;
+            });
+            let newValue = 0;
+            com1.subscribe(val => {
+                newValue = val;
+            });
+            expect(com1()).toBe(2);
+            expect(recomputeCount).toBe(1);
+            expect(newValue).toBe(0);
+            obs1(2);
+            expect(recomputeCount).toBe(2);
+            expect(newValue).toBe(4);
+            expect(recomputeCount).toBe(2);
+            expect(com1()).toBe(4);
+            expect(com1()).toBe(4);
+            com1.notifySubscribers(5);
+            expect(newValue).toBe(5);
+            expect(com1()).toBe(5);
+            expect(recomputeCount).toBe(2);
+        });
+        it('should allow configuring a write function', () => {
+            const obs1 = (0, observable_1.observable)(1);
+            const com1 = (0, observable_1.computed)({
+                read: () => obs1() + 1,
+                write: (val) => obs1(val),
+            });
+            expect(com1()).toBe(2);
+            com1(2);
+            expect(obs1()).toBe(2);
+            expect(com1()).toBe(3);
+            obs1(3);
+            expect(obs1()).toBe(3);
+            expect(com1()).toBe(4);
+        });
+    });
+});

package/dist/package-loader/get-require.d.ts

@@ -0,0 +1,10 @@
+type RequireFn = (id: string) => any;
+/**
+ * Get a safe require function.
+ *
+ * - Uses the injected one if provided
+ * - Falls back to Node's require in CJS
+ * - Falls back to createRequire in ESM
+ */
+export declare function getRequire(injected?: RequireFn): Promise<RequireFn>;
+export {};

package/dist/package-loader/get-require.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRequire = getRequire;
+/**
+ * Get a safe require function.
+ *
+ * - Uses the injected one if provided
+ * - Falls back to Node's require in CJS
+ * - Falls back to createRequire in ESM
+ */
+async function getRequire(injected) {
+    if (injected)
+        return injected;
+    // Try CommonJS require
+    if (typeof require === "function") {
+        return require;
+    }
+    // Try ESM fallback: createRequire(import.meta.url)
+    try {
+        const mod = await Promise.resolve().then(() => require("module"));
+        // Use import.meta.url if TS target supports it, else __filename
+        const urlOrPath = 
+        // @ts-ignore
+        typeof import.meta !== "undefined" && import.meta.url ? import.meta.url
+            : __filename;
+        return mod.createRequire(urlOrPath);
+    }
+    catch {
+        throw new Error("No require function available. You must provide one to the package loader.");
+    }
+}

package/dist/package-loader/index.d.ts

@@ -0,0 +1 @@
+export * from "./package-loader";

package/dist/package-loader/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./package-loader"), exports);

package/dist/package-loader/package-loader.d.ts

@@ -0,0 +1,16 @@
+import type { DataContext } from "../context/data-context";
+import type { IPeersPackage } from "../types/peers-package";
+import { IPackage } from "../data/packages";
+export declare class PackageLoader {
+    readonly dataContext: DataContext;
+    private packageInstances;
+    require: (<T>(module: string) => T) | undefined;
+    constructor(dataContext: DataContext);
+    loadAllPackages(opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    loadPackage(pkg: IPackage, opts?: {
+        force?: boolean;
+    }): Promise<IPeersPackage | null>;
+}
+export declare function setDefaultRequire(require: (<T>(module: string) => T)): void;