@ericsanchezok/synergy-util 2.4.4

package/dist/encode.d.ts

@@ -0,0 +1,4 @@
+export declare function base64Encode(value: string): string;
+export declare function base64Decode(value: string): string;
+export declare function hash(content: string, algorithm?: string): Promise<string>;
+export declare function checksum(content: string): string | undefined;

package/dist/encode.js

@@ -0,0 +1,28 @@
+export function base64Encode(value) {
+    const bytes = new TextEncoder().encode(value);
+    const binary = Array.from(bytes, (b) => String.fromCharCode(b)).join("");
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function base64Decode(value) {
+    const binary = atob(value.replace(/-/g, "+").replace(/_/g, "/"));
+    const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+    return new TextDecoder().decode(bytes);
+}
+export async function hash(content, algorithm = "SHA-256") {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(content);
+    const hashBuffer = await crypto.subtle.digest(algorithm, data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+    return hashHex;
+}
+export function checksum(content) {
+    if (!content)
+        return undefined;
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < content.length; i++) {
+        hash ^= content.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(36);
+}

package/dist/error.d.ts

@@ -0,0 +1,182 @@
+import z from "zod";
+export declare abstract class NamedError extends Error {
+    abstract schema(): z.core.$ZodType;
+    abstract toObject(): {
+        name: string;
+        data: any;
+    };
+    static create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+        new (data: z.input<Data>, options?: ErrorOptions): {
+            readonly name: Name;
+            readonly data: z.core.input<Data>;
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            toObject(): {
+                name: Name;
+                data: z.core.input<Data>;
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<Name>;
+            data: Data;
+        }, z.core.$strip>;
+        isInstance(input: any): input is InstanceType</*elided*/ any>;
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        };
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    };
+    static readonly Unknown: {
+        new (data: {
+            message: string;
+        }, options?: ErrorOptions): {
+            readonly name: "UnknownError";
+            readonly data: {
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"UnknownError">;
+            data: z.ZodObject<{
+                message: z.ZodString;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is {
+            readonly name: "UnknownError";
+            readonly data: {
+                message: string;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "UnknownError";
+                data: {
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.core.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: Name;
+                    data: z.core.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            isInstance(input: any): input is InstanceType</*elided*/ any>;
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): /*elided*/ any;
+            readonly Unknown: /*elided*/ any;
+            isError(value: unknown): value is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            stackTraceLimit: number;
+            prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+        };
+        readonly Unknown: /*elided*/ any;
+        isError(value: unknown): value is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        stackTraceLimit: number;
+        prepareStackTrace?: ((err: Error, stackTraces: NodeJS.CallSite[]) => any) | undefined;
+    };
+}

package/dist/error.js

@@ -0,0 +1,43 @@
+import z from "zod";
+export class NamedError extends Error {
+    static create(name, data) {
+        const schema = z
+            .object({
+            name: z.literal(name),
+            data,
+        })
+            .meta({
+            ref: name,
+        });
+        const result = class extends NamedError {
+            data;
+            static Schema = schema;
+            name = name;
+            constructor(data, options) {
+                const msg = data && typeof data === "object" && "message" in data && typeof data.message === "string"
+                    ? data.message
+                    : name;
+                super(msg, options);
+                this.data = data;
+                this.name = name;
+            }
+            static isInstance(input) {
+                return typeof input === "object" && "name" in input && input.name === name;
+            }
+            schema() {
+                return schema;
+            }
+            toObject() {
+                return {
+                    name: name,
+                    data: this.data,
+                };
+            }
+        };
+        Object.defineProperty(result, "name", { value: name });
+        return result;
+    }
+    static Unknown = NamedError.create("UnknownError", z.object({
+        message: z.string(),
+    }));
+}

package/dist/fn.d.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result): {
+    (input: z.infer<T>): Result;
+    force(input: z.infer<T>): Result;
+    schema: T;
+};

package/dist/fn.js

@@ -0,0 +1,9 @@
+export function fn(schema, cb) {
+    const result = (input) => {
+        const parsed = schema.parse(input);
+        return cb(parsed);
+    };
+    result.force = (input) => cb(input);
+    result.schema = schema;
+    return result;
+}

package/dist/identifier.d.ts

@@ -0,0 +1,5 @@
+export declare namespace Identifier {
+    function ascending(): string;
+    function descending(): string;
+    function create(descending: boolean, timestamp?: number): string;
+}

package/dist/identifier.js

@@ -0,0 +1,41 @@
+import { randomBytes } from "crypto";
+export var Identifier;
+(function (Identifier) {
+    const LENGTH = 26;
+    // State for monotonic ID generation
+    let lastTimestamp = 0;
+    let counter = 0;
+    function ascending() {
+        return create(false);
+    }
+    Identifier.ascending = ascending;
+    function descending() {
+        return create(true);
+    }
+    Identifier.descending = descending;
+    function randomBase62(length) {
+        const chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        let result = "";
+        const bytes = randomBytes(length);
+        for (let i = 0; i < length; i++) {
+            result += chars[bytes[i] % 62];
+        }
+        return result;
+    }
+    function create(descending, timestamp) {
+        const currentTimestamp = timestamp ?? Date.now();
+        if (currentTimestamp !== lastTimestamp) {
+            lastTimestamp = currentTimestamp;
+            counter = 0;
+        }
+        counter++;
+        let now = BigInt(currentTimestamp) * BigInt(0x1000) + BigInt(counter);
+        now = descending ? ~now : now;
+        const timeBytes = Buffer.alloc(6);
+        for (let i = 0; i < 6; i++) {
+            timeBytes[i] = Number((now >> BigInt(40 - 8 * i)) & BigInt(0xff));
+        }
+        return timeBytes.toString("hex") + randomBase62(LENGTH - 12);
+    }
+    Identifier.create = create;
+})(Identifier || (Identifier = {}));

package/dist/iife.d.ts

@@ -0,0 +1 @@
+export declare function iife<T>(fn: () => T): T;

package/dist/iife.js

@@ -0,0 +1,3 @@
+export function iife(fn) {
+    return fn();
+}

package/dist/json.d.ts

@@ -0,0 +1 @@
+export declare function parsePartialJson(raw: string): Record<string, any>;

package/dist/json.js

@@ -0,0 +1,209 @@
+export function parsePartialJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch { }
+    let text = raw;
+    if (/(?:^|[^\\])\\$/.test(text)) {
+        text = text.slice(0, -1);
+    }
+    const stack = [];
+    let inString = false;
+    let escaped = false;
+    let depth = 0;
+    let afterColon = false;
+    let lastSafeEnd = -1;
+    for (let i = 0; i < text.length; i++) {
+        const char = text[i];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (char === '"') {
+            if (inString) {
+                inString = false;
+                if (afterColon && depth === 1) {
+                    lastSafeEnd = i + 1;
+                    afterColon = false;
+                }
+            }
+            else {
+                inString = true;
+            }
+            continue;
+        }
+        if (inString)
+            continue;
+        if (char === "{") {
+            depth++;
+            stack.push("}");
+        }
+        else if (char === "[") {
+            depth++;
+            stack.push("]");
+        }
+        else if (char === "}" || char === "]") {
+            depth--;
+            stack.pop();
+            if (afterColon && depth === 1) {
+                lastSafeEnd = i + 1;
+                afterColon = false;
+            }
+        }
+        else if (char === ":" && depth === 1) {
+            afterColon = true;
+        }
+        else if (char === "," && depth === 1) {
+            lastSafeEnd = i;
+            afterColon = false;
+        }
+        else if (afterColon && depth === 1 && !/\s/.test(char)) {
+            let end = i;
+            while (end + 1 < text.length && /[^\s,}\]]/.test(text[end + 1]))
+                end++;
+            const token = text.slice(i, end + 1);
+            if (/^(?:true|false|null|-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?)$/.test(token)) {
+                lastSafeEnd = end + 1;
+                afterColon = false;
+                i = end;
+            }
+        }
+    }
+    const result = closeAndParse(text, inString, stack);
+    if (result !== undefined)
+        return result;
+    if (lastSafeEnd > 0) {
+        let safe = text.slice(0, lastSafeEnd).replace(/,\s*$/, "");
+        const safeStack = [];
+        let s = false;
+        let e = false;
+        for (let i = 0; i < safe.length; i++) {
+            const c = safe[i];
+            if (e) {
+                e = false;
+                continue;
+            }
+            if (c === "\\") {
+                e = true;
+                continue;
+            }
+            if (c === '"') {
+                s = !s;
+                continue;
+            }
+            if (s)
+                continue;
+            if (c === "{")
+                safeStack.push("}");
+            if (c === "[")
+                safeStack.push("]");
+            if (c === "}" || c === "]")
+                safeStack.pop();
+        }
+        while (safeStack.length)
+            safe += safeStack.pop();
+        try {
+            const result = JSON.parse(safe);
+            if (typeof result === "object" && result !== null)
+                return result;
+        }
+        catch { }
+    }
+    return {};
+}
+function closeAndParse(text, inString, stack) {
+    let base = text;
+    if (inString)
+        base += '"';
+    {
+        let closed = base;
+        const s = [...stack];
+        while (s.length)
+            closed += s.pop();
+        try {
+            const result = JSON.parse(closed);
+            if (typeof result === "object" && result !== null)
+                return result;
+        }
+        catch { }
+    }
+    let trimmed = base;
+    for (let attempt = 0; attempt < 10; attempt++) {
+        const lastCut = findLastCutPoint(trimmed);
+        if (lastCut < 0)
+            break;
+        trimmed = trimmed.slice(0, lastCut).replace(/[,:\s]+$/, "");
+        const closed = trimmed + computeClosers(trimmed);
+        try {
+            const result = JSON.parse(closed);
+            if (typeof result === "object" && result !== null)
+                return result;
+        }
+        catch { }
+    }
+    return undefined;
+}
+function findLastCutPoint(text) {
+    let inStr = false;
+    let esc = false;
+    let lastComma = -1;
+    let lastOpen = -1;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (esc) {
+            esc = false;
+            continue;
+        }
+        if (c === "\\") {
+            esc = true;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr)
+            continue;
+        if (c === ",")
+            lastComma = i;
+        if (c === "[" || c === "{")
+            lastOpen = i;
+    }
+    return lastComma > lastOpen ? lastComma : lastOpen > 0 ? lastOpen + 1 : -1;
+}
+function computeClosers(text) {
+    const stack = [];
+    let inStr = false;
+    let esc = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (esc) {
+            esc = false;
+            continue;
+        }
+        if (c === "\\") {
+            esc = true;
+            continue;
+        }
+        if (c === '"') {
+            inStr = !inStr;
+            continue;
+        }
+        if (inStr)
+            continue;
+        if (c === "{")
+            stack.push("}");
+        if (c === "[")
+            stack.push("]");
+        if (c === "}" || c === "]")
+            stack.pop();
+    }
+    let result = "";
+    while (stack.length)
+        result += stack.pop();
+    return result;
+}

package/dist/lazy.d.ts

@@ -0,0 +1 @@
+export declare function lazy<T>(fn: () => T): () => T;

package/dist/lazy.js

@@ -0,0 +1,11 @@
+export function lazy(fn) {
+    let value;
+    let loaded = false;
+    return () => {
+        if (loaded)
+            return value;
+        loaded = true;
+        value = fn();
+        return value;
+    };
+}

package/dist/model-limit.d.ts

@@ -0,0 +1,37 @@
+export declare namespace ModelLimit {
+    interface Info {
+        context: number;
+        input?: number;
+        output?: number;
+    }
+    interface TokenUsage {
+        input: number;
+        output: number;
+        reasoning: number;
+        cache: {
+            read: number;
+            write: number;
+        };
+    }
+    const OUTPUT_TOKEN_MAX = 32000;
+    /**
+     * Compute actual input tokens from a usage breakdown.
+     *
+     * For Anthropic-style providers, `input` excludes cached tokens — they are
+     * reported separately as `cache.read` (cache hit) and `cache.write` (first
+     * write). All three consume context window input space, so the true input
+     * footprint is their sum.
+     */
+    function actualInput(tokens: TokenUsage): number;
+    /**
+     * Compute how many tokens are available for input within a model's context.
+     *
+     * Shared-context models (most LLMs) allow input to fill the entire context
+     * window — the API enforces the limit at request time based on actual
+     * input + output, not at input time. So we don't reserve output space.
+     *
+     * If the model config specifies an explicit `input` limit, use it directly.
+     * Otherwise, the entire `context` window is usable for input.
+     */
+    function usableInput(limit?: Info): number;
+}

package/dist/model-limit.js

@@ -0,0 +1,35 @@
+export var ModelLimit;
+(function (ModelLimit) {
+    ModelLimit.OUTPUT_TOKEN_MAX = 32_000;
+    /**
+     * Compute actual input tokens from a usage breakdown.
+     *
+     * For Anthropic-style providers, `input` excludes cached tokens — they are
+     * reported separately as `cache.read` (cache hit) and `cache.write` (first
+     * write). All three consume context window input space, so the true input
+     * footprint is their sum.
+     */
+    function actualInput(tokens) {
+        return tokens.input + tokens.cache.read + tokens.cache.write;
+    }
+    ModelLimit.actualInput = actualInput;
+    /**
+     * Compute how many tokens are available for input within a model's context.
+     *
+     * Shared-context models (most LLMs) allow input to fill the entire context
+     * window — the API enforces the limit at request time based on actual
+     * input + output, not at input time. So we don't reserve output space.
+     *
+     * If the model config specifies an explicit `input` limit, use it directly.
+     * Otherwise, the entire `context` window is usable for input.
+     */
+    function usableInput(limit) {
+        if (!limit || limit.context === 0)
+            return 0;
+        if (typeof limit.input === "number" && limit.input > 0) {
+            return limit.input;
+        }
+        return limit.context;
+    }
+    ModelLimit.usableInput = usableInput;
+})(ModelLimit || (ModelLimit = {}));

package/dist/note-markdown.d.ts

@@ -0,0 +1,24 @@
+export declare namespace NoteMarkdown {
+    interface TipTapNode {
+        type: string;
+        attrs?: Record<string, any>;
+        content?: TipTapNode[];
+        text?: string;
+        marks?: Array<{
+            type: string;
+            attrs?: Record<string, any>;
+        }>;
+    }
+    export function toMarkdown(content: any): string;
+    export function fromMarkdown(markdown: string): TipTapNode;
+    /**
+     * Generate safe, escaped HTML snippet from Tiptap JSON for note card thumbnails.
+     * Produces a compact multi-block preview. Text is HTML-escaped, media is limited
+     * to trusted image sources, and no external HTML is rendered.
+     */
+    export function toPreviewHtml(content: any, options?: {
+        title?: string;
+        maxBlocks?: number;
+    }): string;
+    export {};
+}