ahok-skill 1.3.1

package/dist/server/routes/temporal.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get_most_volatile = exports.compare_facts = exports.apply_decay = exports.get_temporal_stats = exports.search_temporal_facts = exports.get_subject_facts = exports.invalidate_temporal_fact = exports.update_temporal_fact = exports.get_predicate_history = exports.get_entity_timeline = exports.get_current_temporal_fact = exports.get_temporal_fact = exports.create_temporal_fact = void 0;
+exports.temporal = temporal;
+const store_1 = require("../../temporal_graph/store");
+const query_1 = require("../../temporal_graph/query");
+const timeline_1 = require("../../temporal_graph/timeline");
+const create_temporal_fact = async (req, res) => {
+    try {
+        const { subject, predicate, object, valid_from, confidence, metadata } = req.body;
+        if (!subject || !predicate || !object) {
+            return res.status(400).json({ error: 'Missing required fields: subject, predicate, object' });
+        }
+        const valid_from_date = valid_from ? new Date(valid_from) : new Date();
+        const conf = confidence !== undefined ? Math.max(0, Math.min(1, confidence)) : 1.0;
+        const id = await (0, store_1.insert_fact)(subject, predicate, object, valid_from_date, conf, metadata);
+        res.json({
+            id,
+            subject,
+            predicate,
+            object,
+            valid_from: valid_from_date.toISOString(),
+            confidence: conf,
+            message: 'Fact created successfully'
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error creating fact:', error);
+        res.status(500).json({ error: 'Failed to create fact' });
+    }
+};
+exports.create_temporal_fact = create_temporal_fact;
+const get_temporal_fact = async (req, res) => {
+    try {
+        const { subject, predicate, object, at, min_confidence } = req.query;
+        if (!subject && !predicate && !object) {
+            return res.status(400).json({ error: 'At least one of subject, predicate, or object is required' });
+        }
+        const at_date = at ? new Date(at) : new Date();
+        const min_conf = min_confidence ? parseFloat(min_confidence) : 0.1;
+        const facts = await (0, query_1.query_facts_at_time)(subject, predicate, object, at_date, min_conf);
+        res.json({
+            facts,
+            query: { subject, predicate, object, at: at_date.toISOString(), min_confidence: min_conf },
+            count: facts.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error querying facts:', error);
+        res.status(500).json({ error: 'Failed to query facts' });
+    }
+};
+exports.get_temporal_fact = get_temporal_fact;
+const get_current_temporal_fact = async (req, res) => {
+    try {
+        const { subject, predicate } = req.query;
+        if (!subject || !predicate) {
+            return res.status(400).json({ error: 'Both subject and predicate are required' });
+        }
+        const fact = await (0, query_1.get_current_fact)(subject, predicate);
+        if (!fact) {
+            return res.status(404).json({ error: 'No current fact found', subject, predicate });
+        }
+        res.json({ fact });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting current fact:', error);
+        res.status(500).json({ error: 'Failed to get current fact' });
+    }
+};
+exports.get_current_temporal_fact = get_current_temporal_fact;
+const get_entity_timeline = async (req, res) => {
+    try {
+        const { subject, predicate } = req.query;
+        if (!subject) {
+            return res.status(400).json({ error: 'Subject parameter is required' });
+        }
+        const timeline = await (0, timeline_1.get_subject_timeline)(subject, predicate);
+        res.json({
+            subject,
+            predicate,
+            timeline,
+            count: timeline.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting timeline:', error);
+        res.status(500).json({ error: 'Failed to get timeline' });
+    }
+};
+exports.get_entity_timeline = get_entity_timeline;
+const get_predicate_history = async (req, res) => {
+    try {
+        const { predicate, from, to } = req.query;
+        if (!predicate) {
+            return res.status(400).json({ error: 'Predicate parameter is required' });
+        }
+        const from_date = from ? new Date(from) : undefined;
+        const to_date = to ? new Date(to) : undefined;
+        const timeline = await (0, timeline_1.get_predicate_timeline)(predicate, from_date, to_date);
+        res.json({
+            predicate,
+            from: from_date?.toISOString(),
+            to: to_date?.toISOString(),
+            timeline,
+            count: timeline.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting predicate timeline:', error);
+        res.status(500).json({ error: 'Failed to get predicate timeline' });
+    }
+};
+exports.get_predicate_history = get_predicate_history;
+const update_temporal_fact = async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { confidence, metadata } = req.body;
+        if (!id) {
+            return res.status(400).json({ error: 'Fact ID is required' });
+        }
+        if (confidence === undefined && metadata === undefined) {
+            return res.status(400).json({ error: 'At least one of confidence or metadata must be provided' });
+        }
+        const conf = confidence !== undefined ? Math.max(0, Math.min(1, confidence)) : undefined;
+        await (0, store_1.update_fact)(id, conf, metadata);
+        res.json({ id, confidence: conf, metadata, message: 'Fact updated successfully' });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error updating fact:', error);
+        res.status(500).json({ error: 'Failed to update fact' });
+    }
+};
+exports.update_temporal_fact = update_temporal_fact;
+const invalidate_temporal_fact = async (req, res) => {
+    try {
+        const { id } = req.params;
+        const { valid_to } = req.body;
+        if (!id) {
+            return res.status(400).json({ error: 'Fact ID is required' });
+        }
+        const valid_to_date = valid_to ? new Date(valid_to) : new Date();
+        await (0, store_1.invalidate_fact)(id, valid_to_date);
+        res.json({ id, valid_to: valid_to_date.toISOString(), message: 'Fact invalidated successfully' });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error invalidating fact:', error);
+        res.status(500).json({ error: 'Failed to invalidate fact' });
+    }
+};
+exports.invalidate_temporal_fact = invalidate_temporal_fact;
+const get_subject_facts = async (req, res) => {
+    try {
+        const { subject } = req.params;
+        const { at, include_historical } = req.query;
+        if (!subject) {
+            return res.status(400).json({ error: 'Subject parameter is required' });
+        }
+        const at_date = at ? new Date(at) : undefined;
+        const include_hist = include_historical === 'true';
+        const facts = await (0, query_1.get_facts_by_subject)(subject, at_date, include_hist);
+        res.json({
+            subject,
+            at: at_date?.toISOString(),
+            include_historical: include_hist,
+            facts,
+            count: facts.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting subject facts:', error);
+        res.status(500).json({ error: 'Failed to get subject facts' });
+    }
+};
+exports.get_subject_facts = get_subject_facts;
+const search_temporal_facts = async (req, res) => {
+    try {
+        const { pattern, field = 'subject', at } = req.query;
+        if (!pattern) {
+            return res.status(400).json({ error: 'Pattern parameter is required' });
+        }
+        if (!['subject', 'predicate', 'object'].includes(field)) {
+            return res.status(400).json({ error: 'Field must be one of: subject, predicate, object' });
+        }
+        const at_date = at ? new Date(at) : undefined;
+        const facts = await (0, query_1.search_facts)(pattern, field, at_date);
+        res.json({
+            pattern,
+            field,
+            at: at_date?.toISOString(),
+            facts,
+            count: facts.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error searching facts:', error);
+        res.status(500).json({ error: 'Failed to search facts' });
+    }
+};
+exports.search_temporal_facts = search_temporal_facts;
+const get_temporal_stats = async (req, res) => {
+    try {
+        const active_facts = await (0, store_1.get_active_facts_count)();
+        const total_facts = await (0, store_1.get_total_facts_count)();
+        const historical_facts = total_facts - active_facts;
+        res.json({
+            active_facts,
+            historical_facts,
+            total_facts,
+            historical_percentage: total_facts > 0 ? ((historical_facts / total_facts) * 100).toFixed(2) + '%' : '0%'
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting stats:', error);
+        res.status(500).json({ error: 'Failed to get statistics' });
+    }
+};
+exports.get_temporal_stats = get_temporal_stats;
+const apply_decay = async (req, res) => {
+    try {
+        const { decay_rate = 0.01 } = req.body;
+        const updated = await (0, store_1.apply_confidence_decay)(decay_rate);
+        res.json({
+            decay_rate,
+            facts_updated: updated,
+            message: 'Confidence decay applied successfully'
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error applying decay:', error);
+        res.status(500).json({ error: 'Failed to apply confidence decay' });
+    }
+};
+exports.apply_decay = apply_decay;
+const compare_facts = async (req, res) => {
+    try {
+        const { subject, time1, time2 } = req.query;
+        if (!subject || !time1 || !time2) {
+            return res.status(400).json({ error: 'subject, time1, and time2 parameters are required' });
+        }
+        const t1 = new Date(time1);
+        const t2 = new Date(time2);
+        const comparison = await (0, timeline_1.compare_time_points)(subject, t1, t2);
+        res.json({
+            subject,
+            time1: t1.toISOString(),
+            time2: t2.toISOString(),
+            ...comparison,
+            summary: {
+                added: comparison.added.length,
+                removed: comparison.removed.length,
+                changed: comparison.changed.length,
+                unchanged: comparison.unchanged.length
+            }
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error comparing facts:', error);
+        res.status(500).json({ error: 'Failed to compare facts' });
+    }
+};
+exports.compare_facts = compare_facts;
+const get_most_volatile = async (req, res) => {
+    try {
+        const { subject, limit = 10 } = req.query;
+        const volatile = await (0, timeline_1.get_volatile_facts)(subject, parseInt(limit));
+        res.json({
+            subject,
+            limit: parseInt(limit),
+            volatile_facts: volatile,
+            count: volatile.length
+        });
+    }
+    catch (error) {
+        console.error('[TEMPORAL API] Error getting volatile facts:', error);
+        res.status(500).json({ error: 'Failed to get volatile facts' });
+    }
+};
+exports.get_most_volatile = get_most_volatile;
+function temporal(app) {
+    app.post('/api/temporal/fact', exports.create_temporal_fact);
+    app.get('/api/temporal/fact', exports.get_temporal_fact);
+    app.get('/api/temporal/fact/current', exports.get_current_temporal_fact);
+    app.patch('/api/temporal/fact/:id', exports.update_temporal_fact);
+    app.delete('/api/temporal/fact/:id', exports.invalidate_temporal_fact);
+    app.get('/api/temporal/timeline', exports.get_entity_timeline);
+    app.get('/api/temporal/subject/:subject', exports.get_subject_facts);
+    app.get('/api/temporal/search', exports.search_temporal_facts);
+    app.get('/api/temporal/compare', exports.compare_facts);
+    app.get('/api/temporal/stats', exports.get_temporal_stats);
+    app.post('/api/temporal/decay', exports.apply_decay);
+    app.get('/api/temporal/volatile', exports.get_most_volatile);
+}

package/dist/server/routes/users.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usr = void 0;
+const db_1 = require("../../core/db");
+const utils_1 = require("../../utils");
+const user_summary_1 = require("../../memory/user_summary");
+const usr = (app) => {
+    app.get("/users/:user_id/summary", async (req, res) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ error: "user_id required" });
+            const user = await db_1.q.get_user.get(user_id);
+            if (!user)
+                return res.status(404).json({ error: "user not found" });
+            res.json({
+                user_id: user.user_id,
+                summary: user.summary,
+                reflection_count: user.reflection_count,
+                updated_at: user.updated_at,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.post("/users/:user_id/summary/regenerate", async (req, res) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ err: "user_id required" });
+            await (0, user_summary_1.update_user_summary)(user_id);
+            const user = await db_1.q.get_user.get(user_id);
+            res.json({
+                ok: true,
+                user_id,
+                summary: user?.summary,
+                reflection_count: user?.reflection_count,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+    app.post("/users/summaries/regenerate-all", async (req, res) => {
+        try {
+            const result = await (0, user_summary_1.auto_update_user_summaries)();
+            res.json({ ok: true, updated: result.updated });
+        }
+        catch (err) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+    app.get("/users/:user_id/memories", async (req, res) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ err: "user_id required" });
+            const l = req.query.l ? parseInt(req.query.l) : 100;
+            const u = req.query.u ? parseInt(req.query.u) : 0;
+            const r = await db_1.q.all_mem_by_user.all(user_id, l, u);
+            const i = r.map((x) => ({
+                id: x.id,
+                content: x.content,
+                tags: (0, utils_1.p)(x.tags),
+                metadata: (0, utils_1.p)(x.meta),
+                created_at: x.created_at,
+                updated_at: x.updated_at,
+                last_seen_at: x.last_seen_at,
+                salience: x.salience,
+                decay_lambda: x.decay_lambda,
+                primary_sector: x.primary_sector,
+                version: x.version,
+            }));
+            res.json({ user_id, items: i });
+        }
+        catch (err) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+    app.delete("/users/:user_id/memories", async (req, res) => {
+        try {
+            const { user_id } = req.params;
+            if (!user_id)
+                return res.status(400).json({ err: "user_id required" });
+            const mems = await db_1.q.all_mem_by_user.all(user_id, 10000, 0);
+            let deleted = 0;
+            for (const m of mems) {
+                await db_1.q.del_mem.run(m.id);
+                await db_1.vector_store.deleteVectors(m.id);
+                await db_1.q.del_waypoints.run(m.id, m.id);
+                deleted++;
+            }
+            res.json({ ok: true, deleted });
+        }
+        catch (err) {
+            res.status(500).json({ err: err.message });
+        }
+    });
+};
+exports.usr = usr;

package/dist/server/routes/vercel.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vercel = vercel;
+const hsg_1 = require("../../memory/hsg");
+const utils_1 = require("../../utils");
+function vercel(app) {
+    // Simple memory query endpoint for Vercel AI SDK adapters
+    app.post("/query", async (req, res) => {
+        try {
+            const b = req.body || {};
+            const query = String(b.query || "").slice(0, 4000);
+            const user_id = b.user_id || req.query.user_id;
+            const k = Math.max(1, Math.min(32, Number(b.k) || 8));
+            if (!query)
+                return res.status(400).json({ err: "query" });
+            const startTime = b.startTime ? Number(b.startTime) : undefined;
+            const endTime = b.endTime ? Number(b.endTime) : undefined;
+            const matches = await (0, hsg_1.hsg_query)(query, k, { user_id, startTime, endTime });
+            const lines = matches.map((m) => `- (${(m.score ?? 0).toFixed(2)}) ${m.content}`);
+            const result = lines.join("\n");
+            res.json({
+                query,
+                user_id: user_id || null,
+                k,
+                result,
+                matches: matches.map((m) => ({
+                    id: m.id,
+                    content: m.content,
+                    score: m.score,
+                    sectors: m.sectors,
+                    primary_sector: m.primary_sector,
+                    last_seen_at: m.last_seen_at,
+                })),
+            });
+        }
+        catch (e) {
+            res.status(500).json({ err: "internal", msg: e?.message || String(e) });
+        }
+    });
+    // Simple memory store endpoint for chat transcripts or summaries
+    app.post("/memories", async (req, res) => {
+        try {
+            const b = req.body || {};
+            const content = String(b.content || "").trim();
+            const user_id = b.user_id || req.query.user_id;
+            const tags = Array.isArray(b.tags) ? b.tags : [];
+            const metadata = b.metadata || undefined;
+            if (!content)
+                return res.status(400).json({ err: "content" });
+            const r = await (0, hsg_1.add_hsg_memory)(content, (0, utils_1.j)(tags), metadata, user_id);
+            res.json(r);
+        }
+        catch (e) {
+            res.status(500).json({ err: "internal", msg: e?.message || String(e) });
+        }
+    });
+}

package/dist/server/server.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ *--------------------------------------------------------------------------------
+ *  ______     _          _ _            _  _
+ * |  ____|   | |        | | |          | || |
+ * | |__ _   _| |__   ___| | |_   __   _| || |_
+ * |  __| | | | '_ \ / _ \ | __|  \ \ / /__   _|
+ * | |  | |_| | |_) |  __/ | |_    \ V /   | |
+ * |_|   \__,_|_.__/ \___|_|\__|    \_/    |_|
+ *--------------------------------------------------------------------------------
+ *
+ * @website   -  https:
+ * @github    -  https:
+ * @discord   -  https:
+ *
+ * @author    -  Cavira
+ * @copyright -  2025 Cavira OSS
+ * @version   -  4.0.0
+ *
+ *--------------------------------------------------------------------------------
+ * server.js - Application webserver.
+ *--------------------------------------------------------------------------------
+**/
+const fs = require('fs');
+const path = require('path');
+const http = require('http');
+const WebSocket = require('ws');
+const { parse } = require('url');
+function server(config = {}) {
+    const ROUTES = [];
+    const WARES = [];
+    const WS_ROUTES = [];
+    const wss = new WebSocket.Server({ noServer: true });
+    const SERVER = http.createServer((req, res) => {
+        let u = parse(req.url, true);
+        req.query = u.query || {};
+        req.path = u.pathname;
+        req.hostname = (req.headers.host || '').split(':')[0].replace(/[^\w.-]/g, '');
+        req.ip = (req.socket.remoteAddress || '').replace(/[^\w.:]/g, '');
+        res.statusCode = 200;
+        res.status = (x) => {
+            res.statusCode = x;
+            return res;
+        };
+        res.json = (x) => {
+            res.writeHead(res.statusCode || 200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(x));
+        };
+        res.send = (x) => {
+            if (x === undefined || x === null)
+                x = '';
+            if (typeof x === 'object')
+                return res.json(x);
+            res.writeHead(res.statusCode || 200, { 'Content-Type': 'text/plain' });
+            res.end(String(x));
+        };
+        res.set = (k, v) => { res.setHeader(k, v); return res; };
+        let r = matchRoute(req.method.toUpperCase(), req.path);
+        req.params = r ? r.params : {};
+        let fns = [...WARES];
+        fns.push(r ? (req, res, next) => r.handler(req, res, next) : (_req, res) => res.status(404).end('404: Not Found'));
+        let i = 0;
+        let next = () => {
+            if (i < fns.length)
+                fns[i++](req, res, next);
+        };
+        next();
+    });
+    SERVER.on('upgrade', (req, socket, head) => {
+        let u = parse(req.url || '', true);
+        let path = u.pathname;
+        if (!path || path.includes('..') || /[\0-\x1F\x7F]/.test(path)) {
+            socket.destroy();
+            return;
+        }
+        for (let i = 0; i < WS_ROUTES.length; i++) {
+            let r = WS_ROUTES[i];
+            if (r.path === path) {
+                wss.handleUpgrade(req, socket, head, (ws) => {
+                    ws.req = req;
+                    r.handler(ws, req);
+                });
+                return;
+            }
+        }
+        socket.destroy();
+    });
+    const matchRoute = (a, b) => {
+        for (let i = 0; i < ROUTES.length; i++) {
+            let r = ROUTES[i];
+            if (r.method !== a && r.method !== 'ALL')
+                continue;
+            let p = r.path.split('/').filter(Boolean);
+            let u = b.split('/').filter(Boolean);
+            if (p.length !== u.length)
+                continue;
+            let params = {};
+            let matched = true;
+            for (let j = 0; j < p.length; j++) {
+                if (p[j].startsWith(':')) {
+                    params[p[j].slice(1)] = decodeURIComponent(u[j]);
+                }
+                else if (p[j] !== u[j]) {
+                    matched = false;
+                    break;
+                }
+            }
+            if (matched)
+                return { handler: r.handler, params };
+        }
+        return null;
+    };
+    const add = (a, b, c) => { ROUTES.push({ method: a.toUpperCase(), path: b, handler: c }); };
+    const use = (a) => { WARES.push(a); };
+    const listen = (a, b) => { SERVER.setTimeout(10000); SERVER.listen(a, b); };
+    const all = (a, b) => { add('ALL', a, b); };
+    const getRoutes = () => ROUTES.reduce((acc, { method, path }) => ((acc[method] = acc[method] || []).push(path), acc), {});
+    const serverStatic = (endpoint, dir) => {
+        const a = path.resolve(dir);
+        if (!fs.existsSync(a) || !fs.statSync(a).isDirectory()) {
+            console.error(`[STATIC] Directory not found or is not a directory: ${a}`);
+            return (req, res, next) => next();
+        }
+        let b = (endpoint.endsWith('/') ? endpoint : endpoint + '/');
+        return function staticMiddleware(req, res, next) {
+            if (req.method !== 'GET' && req.method !== 'HEAD')
+                return next();
+            if (!req.path.startsWith(b))
+                return next();
+            let c = path.join(a, req.path.substring(b.length));
+            let d = path.relative(a, c);
+            if (!(d && !d.startsWith('..') && !path.isAbsolute(d)))
+                return next();
+            fs.stat(c, (err, stats) => {
+                if (err || !stats.isFile())
+                    return next();
+                res.setHeader('Content-Type', getContentType(c));
+                fs.createReadStream(c).pipe(res);
+            });
+        };
+        function getContentType(a) {
+            switch (path.extname(a).toLowerCase()) {
+                case '.html': return 'text/html';
+                case '.js': return 'text/javascript';
+                case '.css': return 'text/css';
+                case '.json': return 'application/json';
+                case '.txt': return 'text/plain';
+                case '.ico': return 'image/x-icon';
+                case '.png': return 'image/png';
+                case '.webp': return 'image/webp';
+                case '.jpg': return 'image/jpeg';
+                case '.jpeg': return 'image/jpeg';
+                case '.gif': return 'image/gif';
+                case '.svg': return 'image/svg+xml';
+                default: return 'application/octet-stream';
+            }
+        }
+    };
+    use((req, res, next) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, x-api-key');
+        if (req.method === 'OPTIONS')
+            return res.status(204).send();
+        next();
+    });
+    use((req, res, next) => {
+        if (req.headers['content-type']?.includes('application/json')) {
+            let d = '';
+            let max = config.max_payload_size || 1_000_000;
+            req.on('data', e => {
+                d += e;
+                if (d.length > max) {
+                    res.status(413).end('Payload Too Large');
+                    req.destroy();
+                }
+            });
+            req.on('end', () => {
+                req.rawBody = d;
+                try {
+                    req.body = JSON.parse(d);
+                }
+                catch {
+                    req.body = null;
+                }
+                next();
+            });
+        }
+        else {
+            next();
+        }
+    });
+    return {
+        use,
+        listen,
+        all,
+        serverStatic,
+        routes: ROUTES,
+        getRoutes,
+        get: (a, b) => add('GET', a, b),
+        post: (a, b) => add('POST', a, b),
+        put: (a, b) => add('PUT', a, b),
+        delete: (a, b) => add('DELETE', a, b),
+        patch: (a, b) => add('PATCH', a, b),
+        options: (a, b) => add('OPTIONS', a, b),
+        head: (a, b) => add('HEAD', a, b),
+        all: (a, b) => add('ALL', a, b),
+        ws: (a, b) => WS_ROUTES.push({ path: a, handler: b })
+    };
+}
+module.exports = server;

package/dist/server.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./server/index.js");