@thingd/sdk 0.72.0 → 0.74.2

package/dist/memory/index.d.ts

@@ -0,0 +1,7 @@
+export { InMemoryThingStore } from "../client/in-memory-thing-store.js";
+/**
+ * Open a pure in-memory thingd connection.
+ * Browser-safe — no Node.js dependencies.
+ */
+export declare const openMemoryThingD: () => Promise<import("../client/http-thing-store.js").HttpThingStore | import("../client/in-memory-thing-store.js").InMemoryThingStore>;
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAExE;;;GAGG;AACH,eAAO,MAAM,gBAAgB,yIAAyC,CAAC"}

package/dist/memory/index.js

@@ -0,0 +1,7 @@
+import { openThingD } from "../client/thingd.js";
+export { InMemoryThingStore } from "../client/in-memory-thing-store.js";
+/**
+ * Open a pure in-memory thingd connection.
+ * Browser-safe — no Node.js dependencies.
+ */
+export const openMemoryThingD = () => openThingD({ driver: "memory" });

package/dist/rest/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+type SortField = "id" | "collection" | "created_at" | "updated_at" | "version";
+type SortDirection = "asc" | "desc";
+type LocalSortBy = {
+    field: SortField;
+    direction?: SortDirection;
+};
+export declare function readBody(req: IncomingMessage, maxSize?: number): Promise<string>;
+export declare function sendJson(res: ServerResponse, status: number, data: unknown): void;
+export declare function sendData(res: ServerResponse, data: unknown): void;
+export declare function sendDataList(res: ServerResponse, data: unknown[], total?: number): void;
+export declare function sendError(res: ServerResponse, status: number, code: string, message: string): void;
+export declare function parseSortBy(params: URLSearchParams): LocalSortBy | undefined;
+export declare function parseFilter(params: URLSearchParams): Record<string, unknown> | undefined;
+export declare function parseIntParam(value: string | null): number | undefined;
+export {};
+//# sourceMappingURL=helpers.d.ts.map

package/dist/rest/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/rest/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,KAAK,SAAS,GAAG,IAAI,GAAG,YAAY,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAC;AAC/E,KAAK,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC;AAEpC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,SAAS,CAAC;IACjB,SAAS,CAAC,EAAE,aAAa,CAAC;CAC3B,CAAC;AAIF,wBAAgB,QAAQ,CAAC,GAAG,EAAE,eAAe,EAAE,OAAO,SAAgB,GAAG,OAAO,CAAC,MAAM,CAAC,CAavF;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAGjF;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAEjE;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAEvF;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,GACd,IAAI,CAEN;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,WAAW,GAAG,SAAS,CAY5E;AAED,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAWxF;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,SAAS,CAMtE"}

package/dist/rest/helpers.js

@@ -0,0 +1,60 @@
+const MAX_BODY_SIZE = 524_288; // 512KB
+export function readBody(req, maxSize = MAX_BODY_SIZE) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.on("data", (chunk) => {
+            body += chunk.toString();
+            if (body.length > maxSize) {
+                req.destroy(new Error(`Request body exceeds ${maxSize} bytes`));
+                reject(new Error(`Request body exceeds ${maxSize} bytes`));
+            }
+        });
+        req.on("end", () => resolve(body));
+        req.on("error", reject);
+    });
+}
+export function sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+}
+export function sendData(res, data) {
+    sendJson(res, 200, { data });
+}
+export function sendDataList(res, data, total) {
+    sendJson(res, 200, { data, ...(total !== undefined ? { total } : {}) });
+}
+export function sendError(res, status, code, message) {
+    sendJson(res, status, { error: { code, message } });
+}
+export function parseSortBy(params) {
+    const sort = params.get("sortBy");
+    if (!sort) {
+        return undefined;
+    }
+    const parts = sort.split(":");
+    const field = parts[0];
+    const dir = parts[1] ?? "asc";
+    if (!field) {
+        return undefined;
+    }
+    return { field: field, direction: dir };
+}
+export function parseFilter(params) {
+    const filter = {};
+    let hasFilter = false;
+    params.forEach((value, key) => {
+        if (key.startsWith("filter.")) {
+            const field = key.slice(7);
+            filter[field] = value;
+            hasFilter = true;
+        }
+    });
+    return hasFilter ? filter : undefined;
+}
+export function parseIntParam(value) {
+    if (!value) {
+        return undefined;
+    }
+    const n = Number(value);
+    return Number.isNaN(n) ? undefined : n;
+}

package/dist/rest/index.d.ts

@@ -0,0 +1,3 @@
+export { parseFilter, parseIntParam, parseSortBy, readBody, sendData, sendDataList, sendError, sendJson, } from "./helpers.js";
+export { handleRestRequest } from "./server.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/rest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/rest/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,WAAW,EACX,aAAa,EACb,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,QAAQ,GACT,MAAM,cAAc,CAAC;AACtB,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC"}

package/dist/rest/index.js

@@ -0,0 +1,2 @@
+export { parseFilter, parseIntParam, parseSortBy, readBody, sendData, sendDataList, sendError, sendJson, } from "./helpers.js";
+export { handleRestRequest } from "./server.js";

package/dist/rest/server.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { ThingD } from "../thingd.js";
+export declare function handleRestRequest(db: ThingD, req: IncomingMessage, res: ServerResponse, pathname: string): Promise<void>;
+//# sourceMappingURL=server.d.ts.map

package/dist/rest/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/rest/server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AA0C3C,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,MAAM,EACV,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAkff"}

package/dist/rest/server.js

@@ -0,0 +1,472 @@
+import { SDK_VERSION } from "../version.js";
+import { parseFilter, parseIntParam, parseSortBy, readBody, sendData, sendDataList, sendError, } from "./helpers.js";
+function matchRoute(pathname, pattern) {
+    const patternParts = pattern.split("/");
+    const pathParts = pathname.split("/");
+    if (patternParts.length !== pathParts.length) {
+        return null;
+    }
+    const match = {};
+    for (let i = 0; i < patternParts.length; i++) {
+        const pp = patternParts[i] ?? "";
+        const xp = pathParts[i] ?? "";
+        if (pp.startsWith(":")) {
+            const key = pp.slice(1);
+            match[key] = xp;
+        }
+        else if (pp !== xp) {
+            return null;
+        }
+    }
+    return match;
+}
+export async function handleRestRequest(db, req, res, pathname) {
+    const method = req.method ?? "GET";
+    const url = new URL(req.url || "/", `http://${req.headers.host || "localhost"}`);
+    try {
+        // ─── Health ──────────────────────────────────────────────────
+        if (pathname === "/v1/health" && method === "GET") {
+            const [objects, events, links, queues, collections, streams] = await Promise.all([
+                db.countObjects(),
+                db.countEvents(),
+                db.countLinks(),
+                db.listQueues(),
+                db.listCollections(),
+                db.listStreams(),
+            ]);
+            sendData(res, {
+                status: "ok",
+                version: SDK_VERSION,
+                counts: {
+                    objects,
+                    events,
+                    links,
+                    queues: queues.length,
+                    collections: collections.length,
+                    streams: streams.length,
+                },
+            });
+            return;
+        }
+        // ─── Counts ──────────────────────────────────────────────────
+        if (pathname === "/v1/counts/objects" && method === "GET") {
+            sendData(res, { count: await db.countObjects() });
+            return;
+        }
+        const collectionCountMatch = pathname.match(/^\/v1\/counts\/objects\/([^/]+)$/);
+        if (collectionCountMatch && method === "GET" && collectionCountMatch[1]) {
+            const collection = decodeURIComponent(collectionCountMatch[1]);
+            sendData(res, { count: await db.countObjectsInCollection(collection) });
+            return;
+        }
+        if (pathname === "/v1/counts/events" && method === "GET") {
+            sendData(res, { count: await db.countEvents() });
+            return;
+        }
+        if (pathname === "/v1/counts/links" && method === "GET") {
+            sendData(res, { count: await db.countLinks() });
+            return;
+        }
+        // ─── Collections / Streams / Queues ──────────────────────────
+        if (pathname === "/v1/collections" && method === "GET") {
+            sendDataList(res, await db.listCollections());
+            return;
+        }
+        // GET /v1/collections/schema — all schemas
+        if (pathname === "/v1/collections/schema" && method === "GET") {
+            sendDataList(res, await db.schema());
+            return;
+        }
+        // GET /v1/collections/:name/schema — single schema
+        const schemaMatch = matchRoute(pathname, "/v1/collections/:name/schema");
+        if (schemaMatch?.name && method === "GET") {
+            const schemas = await db.schema(schemaMatch.name);
+            if (schemas.length === 0) {
+                sendError(res, 404, "not_found", `Collection '${schemaMatch.name}' not found or has no objects`);
+                return;
+            }
+            sendData(res, schemas[0]);
+            return;
+        }
+        if (pathname === "/v1/streams" && method === "GET") {
+            sendDataList(res, await db.listStreams());
+            return;
+        }
+        if (pathname === "/v1/queues" && method === "GET") {
+            sendDataList(res, await db.listQueues());
+            return;
+        }
+        // ─── Indexes ─────────────────────────────────────────────────
+        if (pathname === "/v1/indexes" && method === "GET") {
+            sendDataList(res, await db.listIndexes());
+            return;
+        }
+        if (pathname === "/v1/indexes" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            await db.createIndex(body.collection, body.field);
+            sendData(res, { created: true });
+            return;
+        }
+        // ─── Objects ─────────────────────────────────────────────────
+        // GET /v1/objects?collection=...&filter.x=...&sortBy=...&limit=...&offset=...
+        if (pathname === "/v1/objects" && method === "GET") {
+            const collection = url.searchParams.get("collection");
+            if (!collection) {
+                sendError(res, 400, "bad_request", "Query parameter 'collection' is required");
+                return;
+            }
+            const filter = parseFilter(url.searchParams);
+            const sortBy = parseSortBy(url.searchParams);
+            const limit = parseIntParam(url.searchParams.get("limit"));
+            const offset = parseIntParam(url.searchParams.get("offset"));
+            const objects = await db.listObjects(collection, { filter, sortBy, limit, offset });
+            sendDataList(res, objects);
+            return;
+        }
+        // PUT /v1/objects/:collection/:id
+        const objMatch = matchRoute(pathname, "/v1/objects/:collection/:id");
+        if (objMatch?.collection && objMatch?.id && method === "PUT") {
+            const body = JSON.parse(await readBody(req));
+            body.id = objMatch.id;
+            const result = await db.put(objMatch.collection, body);
+            sendData(res, result);
+            return;
+        }
+        // GET /v1/objects/:collection/:id
+        if (objMatch?.collection && objMatch?.id && method === "GET") {
+            const result = await db.get(objMatch.collection, objMatch.id);
+            if (!result) {
+                sendError(res, 404, "not_found", `Object '${objMatch.id}' not found in collection '${objMatch.collection}'`);
+                return;
+            }
+            sendData(res, result);
+            return;
+        }
+        // DELETE /v1/objects/:collection/:id
+        if (objMatch?.collection && objMatch?.id && method === "DELETE") {
+            const result = await db.delete(objMatch.collection, objMatch.id);
+            sendData(res, result);
+            return;
+        }
+        // GET /v1/objects/batch?collection=...
+        if (pathname === "/v1/objects/batch" && method === "GET") {
+            const collection = url.searchParams.get("collection");
+            if (!collection) {
+                sendError(res, 400, "bad_request", "Query parameter 'collection' is required");
+                return;
+            }
+            const body = JSON.parse(await readBody(req));
+            const ids = Array.isArray(body) ? body : body.ids;
+            if (!Array.isArray(ids)) {
+                sendError(res, 400, "bad_request", "Body must be an array or { ids: [...] }");
+                return;
+            }
+            const objects = await db.getBatch(collection, ids);
+            sendDataList(res, objects);
+            return;
+        }
+        // PUT /v1/objects/batch?collection=...
+        if (pathname === "/v1/objects/batch" && method === "PUT") {
+            const collection = url.searchParams.get("collection");
+            if (!collection) {
+                sendError(res, 400, "bad_request", "Query parameter 'collection' is required");
+                return;
+            }
+            const body = JSON.parse(await readBody(req));
+            const objects = Array.isArray(body) ? body : body.objects;
+            if (!Array.isArray(objects)) {
+                sendError(res, 400, "bad_request", "Body must be an array or { objects: [...] }");
+                return;
+            }
+            const result = await db.putBatch(collection, objects);
+            sendData(res, result);
+            return;
+        }
+        // DELETE /v1/objects/batch?collection=...
+        if (pathname === "/v1/objects/batch" && method === "DELETE") {
+            const collection = url.searchParams.get("collection");
+            if (!collection) {
+                sendError(res, 400, "bad_request", "Query parameter 'collection' is required");
+                return;
+            }
+            const body = JSON.parse(await readBody(req));
+            const ids = Array.isArray(body) ? body : body.ids;
+            if (!Array.isArray(ids)) {
+                sendError(res, 400, "bad_request", "Body must be an array or { ids: [...] }");
+                return;
+            }
+            const count = await db.deleteBatch(collection, ids);
+            sendData(res, { deleted: count });
+            return;
+        }
+        // ─── Search ──────────────────────────────────────────────────
+        if (pathname === "/v1/search" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.query) {
+                sendError(res, 400, "bad_request", "Field 'query' is required");
+                return;
+            }
+            const results = await db.search(body.query, {
+                collections: body.collections,
+                limit: body.limit,
+                filter: body.filter,
+            });
+            sendData(res, results);
+            return;
+        }
+        // ─── Vector Search ──────────────────────────────────────────
+        if (pathname === "/v1/search/vector" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.collection) {
+                sendError(res, 400, "bad_request", "Field 'collection' is required");
+                return;
+            }
+            if (!body.vector || !Array.isArray(body.vector)) {
+                sendError(res, 400, "bad_request", "Field 'vector' must be an array of numbers");
+                return;
+            }
+            const results = await db.vectorSearch(body.collection, body.vector, {
+                topK: body.topK,
+                filter: body.filter,
+            });
+            sendData(res, results);
+            return;
+        }
+        // ─── Aggregate ──────────────────────────────────────────────
+        if (pathname === "/v1/aggregate" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.collection) {
+                sendError(res, 400, "bad_request", "Field 'collection' is required");
+                return;
+            }
+            if (!body.function) {
+                sendError(res, 400, "bad_request", "Field 'function' is required");
+                return;
+            }
+            let result;
+            switch (body.function) {
+                case "sum":
+                    result = await db.aggregate.sum(body.collection, body.field ?? "", {
+                        groupBy: body.groupBy,
+                        filter: body.filter,
+                    });
+                    break;
+                case "avg":
+                    result = await db.aggregate.avg(body.collection, body.field ?? "", {
+                        groupBy: body.groupBy,
+                        filter: body.filter,
+                    });
+                    break;
+                case "min":
+                    result = await db.aggregate.min(body.collection, body.field ?? "", {
+                        groupBy: body.groupBy,
+                        filter: body.filter,
+                    });
+                    break;
+                case "max":
+                    result = await db.aggregate.max(body.collection, body.field ?? "", {
+                        groupBy: body.groupBy,
+                        filter: body.filter,
+                    });
+                    break;
+                default:
+                    result = await db.aggregate.count(body.collection, {
+                        groupBy: body.groupBy,
+                        filter: body.filter,
+                    });
+                    break;
+            }
+            sendData(res, result);
+            return;
+        }
+        if (pathname === "/v1/aggregate/timeseries" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.collection) {
+                sendError(res, 400, "bad_request", "Field 'collection' is required");
+                return;
+            }
+            if (!body.function) {
+                sendError(res, 400, "bad_request", "Field 'function' is required");
+                return;
+            }
+            if (!body.bucket) {
+                sendError(res, 400, "bad_request", "Field 'bucket' is required");
+                return;
+            }
+            const result = await db.timeseries(body.collection, {
+                function: body.function,
+                bucket: body.bucket,
+                field: body.field,
+                filter: body.filter,
+                from: body.from,
+                to: body.to,
+            });
+            sendData(res, result);
+            return;
+        }
+        // ─── NLQ ──────────────────────────────────────────────────
+        if (pathname === "/v1/nlq" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.question) {
+                sendError(res, 400, "bad_request", "Field 'question' is required");
+                return;
+            }
+            const result = await db.nlq.query(body.question, {
+                collection: body.collection,
+            });
+            sendData(res, result);
+            return;
+        }
+        // ─── Events ──────────────────────────────────────────────────
+        // POST /v1/events/:stream
+        const streamMatch = matchRoute(pathname, "/v1/events/:stream");
+        if (streamMatch?.stream && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.type) {
+                sendError(res, 400, "bad_request", "Field 'type' is required");
+                return;
+            }
+            const event = await db.events.append(streamMatch.stream, body);
+            sendData(res, event);
+            return;
+        }
+        // GET /v1/events?stream=...&fromSequence=...&limit=...&since=...
+        if (pathname === "/v1/events" && method === "GET") {
+            const stream = url.searchParams.get("stream") ?? undefined;
+            const fromSequence = parseIntParam(url.searchParams.get("fromSequence"));
+            const limit = parseIntParam(url.searchParams.get("limit"));
+            const since = url.searchParams.get("since") ?? undefined;
+            const events = await db.events.list(stream, { fromSequence, limit, since });
+            sendDataList(res, events);
+            return;
+        }
+        // ─── Queues ──────────────────────────────────────────────────
+        // POST /v1/queues/:queue/push
+        const pushMatch = matchRoute(pathname, "/v1/queues/:queue/push");
+        if (pushMatch?.queue && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            const job = await db.queue(pushMatch.queue).push(body.payload ?? body, {
+                idempotencyKey: body.idempotencyKey,
+                maxAttempts: body.maxAttempts,
+                delayMs: body.delayMs,
+            });
+            sendData(res, job);
+            return;
+        }
+        // POST /v1/queues/:queue/claim
+        const claimMatch = matchRoute(pathname, "/v1/queues/:queue/claim");
+        if (claimMatch?.queue && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            const job = await db.queue(claimMatch.queue).claim({
+                leaseMs: body.leaseMs,
+            });
+            if (!job) {
+                sendData(res, null);
+                return;
+            }
+            sendData(res, job);
+            return;
+        }
+        // POST /v1/queues/:queue/ack
+        const ackMatch = matchRoute(pathname, "/v1/queues/:queue/ack");
+        if (ackMatch?.queue && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            const result = await db.queue(ackMatch.queue).ack(body.jobId);
+            if (!result.ok) {
+                sendError(res, 400, result.reason, `Ack failed: ${result.reason}`);
+                return;
+            }
+            sendData(res, result.job);
+            return;
+        }
+        // POST /v1/queues/:queue/nack
+        const nackMatch = matchRoute(pathname, "/v1/queues/:queue/nack");
+        if (nackMatch?.queue && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            const result = await db.queue(nackMatch.queue).nack(body.jobId, {
+                delayMs: body.delayMs,
+                error: body.error,
+            });
+            if (!result.ok) {
+                sendError(res, 400, result.reason, `Nack failed: ${result.reason}`);
+                return;
+            }
+            sendData(res, result.job);
+            return;
+        }
+        // GET /v1/queues/:queue/jobs
+        const jobsMatch = matchRoute(pathname, "/v1/queues/:queue/jobs");
+        if (jobsMatch?.queue && method === "GET") {
+            const jobs = await db.queue(jobsMatch.queue).list();
+            sendDataList(res, jobs);
+            return;
+        }
+        // GET /v1/queues/:queue/dead
+        const deadMatch = matchRoute(pathname, "/v1/queues/:queue/dead");
+        if (deadMatch?.queue && method === "GET") {
+            const jobs = await db.queue(deadMatch.queue).dead();
+            sendDataList(res, jobs);
+            return;
+        }
+        // ─── Links ───────────────────────────────────────────────────
+        // POST /v1/links
+        if (pathname === "/v1/links" && method === "POST") {
+            const body = JSON.parse(await readBody(req));
+            if (!body.fromRef || !body.linkType || !body.toRef) {
+                sendError(res, 400, "bad_request", "Fields 'fromRef', 'linkType', 'toRef' are required");
+                return;
+            }
+            const link = await db.links.create(body.fromRef, body.linkType, body.toRef, body.weight, body.metadataJson);
+            sendData(res, link);
+            return;
+        }
+        // GET /v1/links?id=...
+        if (pathname === "/v1/links" && method === "GET") {
+            const id = url.searchParams.get("id");
+            if (id) {
+                const link = await db.links.get(id);
+                if (!link) {
+                    sendError(res, 404, "not_found", `Link '${id}' not found`);
+                    return;
+                }
+                sendData(res, link);
+                return;
+            }
+            // Neighbors query
+            const reference = url.searchParams.get("reference");
+            if (reference) {
+                const direction = url.searchParams.get("direction") ?? "Both";
+                const linkType = url.searchParams.get("linkType") ?? undefined;
+                const limit = parseIntParam(url.searchParams.get("limit"));
+                const neighbors = await db.links.neighbors(reference, direction, { linkType, limit });
+                sendDataList(res, neighbors);
+                return;
+            }
+            sendError(res, 400, "bad_request", "Query parameter 'id' or 'reference' is required");
+            return;
+        }
+        // DELETE /v1/links/:id
+        const linkDeleteMatch = matchRoute(pathname, "/v1/links/:id");
+        if (linkDeleteMatch?.id && method === "DELETE") {
+            const deleted = await db.links.delete(linkDeleteMatch.id);
+            sendData(res, { deleted });
+            return;
+        }
+        // GET /v1/links/:id
+        if (linkDeleteMatch?.id && method === "GET") {
+            const link = await db.links.get(linkDeleteMatch.id);
+            if (!link) {
+                sendError(res, 404, "not_found", `Link '${linkDeleteMatch.id}' not found`);
+                return;
+            }
+            sendData(res, link);
+            return;
+        }
+        // ─── 404 ─────────────────────────────────────────────────────
+        sendError(res, 404, "not_found", `No route for ${method} ${pathname}`);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        sendError(res, 500, "internal_error", message);
+    }
+}

package/dist/scheduler.d.ts

@@ -0,0 +1,28 @@
+import type { Schedule, ScheduleIntervalOptions, ScheduleOnceOptions, ScheduleOptions, SchedulerEventType, SchedulerFacade, SchedulerListener, SchedulerStats, ThingStore } from "./types.js";
+export declare class Scheduler implements SchedulerFacade {
+    private readonly store;
+    private handlers;
+    private listeners;
+    private heartbeatTimer;
+    private running;
+    private started;
+    constructor(store: ThingStore);
+    schedule(id: string, options: ScheduleOptions): Promise<Schedule>;
+    scheduleOnce(id: string, options: ScheduleOnceOptions): Promise<Schedule>;
+    scheduleInterval(id: string, options: ScheduleIntervalOptions): Promise<Schedule>;
+    get(id: string): Promise<Schedule | null>;
+    list(): Promise<Schedule[]>;
+    pause(id: string): Promise<Schedule>;
+    resume(id: string): Promise<Schedule>;
+    remove(id: string): Promise<boolean>;
+    run(id: string): Promise<void>;
+    stats(): Promise<SchedulerStats>;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    on(event: SchedulerEventType, listener: SchedulerListener): void;
+    off(event: SchedulerEventType, listener: SchedulerListener): void;
+    private emit;
+    private heartbeat;
+    private executeSchedule;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../src/scheduler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EAIR,uBAAuB,EACvB,mBAAmB,EACnB,eAAe,EACf,kBAAkB,EAClB,eAAe,EACf,iBAAiB,EACjB,cAAc,EAEd,UAAU,EACX,MAAM,YAAY,CAAC;AAqJpB,qBAAa,SAAU,YAAW,eAAe;IAOnC,OAAO,CAAC,QAAQ,CAAC,KAAK;IANlC,OAAO,CAAC,QAAQ,CAAsC;IACtD,OAAO,CAAC,SAAS,CAAyD;IAC1E,OAAO,CAAC,cAAc,CAA+C;IACrE,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,OAAO,CAAS;IAExB,YAA6B,KAAK,EAAE,UAAU,EAAI;IAE5C,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,QAAQ,CAAC,CA+BtE;IAEK,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAoB9E;IAEK,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,QAAQ,CAAC,CAqBtF;IAEK,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAG9C;IAEK,IAAI,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC,CAGhC;IAEK,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CASzC;IAEK,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAU1C;IAEK,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAIzC;IAEK,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAUnC;IAEK,KAAK,IAAI,OAAO,CAAC,cAAc,CAAC,CAiBrC;IAEK,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAsB3B;IAEK,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAY1B;IAED,EAAE,CAAC,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAK/D;IAED,GAAG,CAAC,KAAK,EAAE,kBAAkB,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAEhE;IAED,OAAO,CAAC,IAAI;YASE,SAAS;YAuBT,eAAe;CAyG9B"}