@augmentd-labs/canvas-edge 0.0.0-stage → 0.4.1

package/node_modules/canvas-stored/src/sync/SyncQueue.js

@@ -0,0 +1,111 @@
+import { Worker } from 'worker_threads';
+import { EventEmitter } from 'events';
+import cacache from 'cacache';
+import Debug from 'debug';
+
+const debug = Debug('stored:sync');
+
+/**
+ * Background sync queue for remote backend writes.
+ *
+ * Every job is `{ id, cacheRoot, cacheKey, targets[] }` — the bytes already
+ * sit in the cache under `cacheKey`; each target gets a copy. Two lanes:
+ *   - `driver: 'file'` targets are streamed by a lazily-spawned worker thread
+ *     (disk-to-disk copy is the one thing worth taking off the event loop);
+ *   - every other driver is committed IN-PROCESS through its live backend
+ *     (`backend.commit(key, cachePath)`): network uploads are async I/O, and
+ *     the driver's credentials, token and path cache live on the main thread.
+ * One `synced` event per job carries the merged results of both lanes.
+ */
+export default class SyncQueue extends EventEmitter {
+    #worker = null;
+    #seq = 0;
+    #pending = new Map(); // seq → resolve(results) for in-flight worker jobs
+    #resolveBackend;
+
+    /** @param {{ resolveBackend?: (name:string) => object|undefined }} [options] */
+    constructor({ resolveBackend = null } = {}) {
+        super();
+        this.#resolveBackend = typeof resolveBackend === 'function' ? resolveBackend : () => undefined;
+    }
+
+    enqueue(job) {
+        const targets = Array.isArray(job?.targets) ? job.targets : [];
+        const viaWorker = targets.filter((t) => t.driver === 'file');
+        const inProcess = targets.filter((t) => t.driver !== 'file');
+        const lanes = [];
+        if (viaWorker.length) lanes.push(this.#viaWorker({ ...job, targets: viaWorker }));
+        if (inProcess.length) lanes.push(this.#inProcess(job, inProcess));
+        if (!lanes.length) return;
+
+        Promise.all(lanes)
+            .then((parts) => {
+                const results = parts.flat();
+                debug(`Sync complete: ${String(job.id).slice(0, 19)}... → ${results.map((r) => `${r.backend}:${r.success}`).join(', ')}`);
+                this.emit('synced', { id: job.id, results });
+            })
+            .catch((err) => this.emit('error', err));
+    }
+
+    async stop() {
+        if (this.#worker) {
+            await this.#worker.terminate();
+            this.#worker = null;
+        }
+        // Jobs the worker never answered must not hang their `synced` forever.
+        for (const [seq, resolve] of this.#pending) {
+            this.#pending.delete(seq);
+            resolve([]);
+        }
+    }
+
+    #viaWorker(job) {
+        if (!this.#worker) this.#spawnWorker();
+        const seq = ++this.#seq;
+        return new Promise((resolve) => {
+            this.#pending.set(seq, resolve);
+            this.#worker.postMessage({ seq, ...job });
+        });
+    }
+
+    async #inProcess({ cacheRoot, cacheKey }, targets) {
+        const info = await cacache.get.info(cacheRoot, cacheKey).catch(() => null);
+        if (!info) {
+            return targets.map((t) => ({ backend: t.name, key: t.key, success: false, error: 'Cache read failed: entry not found' }));
+        }
+        const results = [];
+        for (const target of targets) {
+            const backend = this.#resolveBackend(target.name);
+            if (!backend || typeof backend.commit !== 'function') {
+                results.push({ backend: target.name, key: target.key, success: false, error: `Backend not registered: ${target.name}` });
+                continue;
+            }
+            try {
+                await backend.commit(target.key, info.path);
+                results.push({ backend: target.name, key: target.key, success: true });
+            } catch (err) {
+                debug(`In-process sync to ${target.name}:${target.key} failed: ${err.message}`);
+                results.push({ backend: target.name, key: target.key, success: false, error: err.message });
+            }
+        }
+        return results;
+    }
+
+    #spawnWorker() {
+        this.#worker = new Worker(new URL('./worker.js', import.meta.url));
+        this.#worker.on('message', (msg) => {
+            const resolve = this.#pending.get(msg.seq);
+            if (resolve) {
+                this.#pending.delete(msg.seq);
+                resolve(msg.results || []);
+                return;
+            }
+            // No correlation (foreign/legacy message) — surface as-is.
+            this.emit('synced', msg);
+        });
+        this.#worker.on('error', (err) => {
+            debug(`Worker error: ${err.message}`);
+            this.emit('error', err);
+        });
+    }
+}

package/node_modules/canvas-stored/src/sync/keys.js

@@ -0,0 +1,140 @@
+import picomatch from 'picomatch';
+
+/**
+ * Key hygiene shared by the mirror engine and the canvas driver. Keys are
+ * relative, '/'-separated paths in NFC — the spelling the hub uses on the
+ * wire (`docs/sync-protocol.md`). Everything a device filesystem can produce
+ * that the hub (or the other platform) would refuse is caught here and
+ * surfaced as a `skip {reason}` instead of a silent loss.
+ */
+
+// Mirror-side defaults on top of the hub's effective exclusions.
+export const MIRROR_IGNORE_DEFAULTS = Object.freeze([
+    '.workspace/**',
+    '.stored-tmp/**',
+    '**/.DS_Store',
+    '**/Thumbs.db',
+    '**/desktop.ini',
+    '**/~$*',
+    '**/*.tmp',
+    '**/*.part',
+    '**/*.crdownload',
+    '**/.~lock.*#',
+    '**/*.swp',
+]);
+
+const MAX_KEY_BYTES = 4096;
+const MAX_SEGMENT_BYTES = 255;
+const WINDOWS_RESERVED = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\..*)?$/i;
+// eslint-disable-next-line no-control-regex
+const WINDOWS_ILLEGAL = /[<>:"|?*\x00-\x1f]/;
+
+/** NFC + '/' separators, no empty / leading / trailing segments. */
+export function normalizeKey(key) {
+    return String(key ?? '')
+        .normalize('NFC')
+        .replace(/\\/g, '/')
+        .split('/')
+        .filter((s) => s.length > 0)
+        .join('/');
+}
+
+/**
+ * Why a (normalized) key cannot be synced, or null when it can. Reasons:
+ * `empty`, `nul`, `traversal`, `absolute`, `too-long`, `segment-too-long`,
+ * `reserved-name`, `illegal-chars`, `trailing-dot-or-space`.
+ */
+export function validateKey(key) {
+    if (typeof key !== 'string' || key.length === 0) return 'empty';
+    if (key.includes('\0')) return 'nul';
+    if (key.startsWith('/') || /^[a-zA-Z]:[\\/]/.test(key)) return 'absolute';
+    if (Buffer.byteLength(key, 'utf8') > MAX_KEY_BYTES) return 'too-long';
+    for (const seg of key.split('/')) {
+        if (seg === '' || seg === '.' || seg === '..') return 'traversal';
+        if (Buffer.byteLength(seg, 'utf8') > MAX_SEGMENT_BYTES) return 'segment-too-long';
+        if (WINDOWS_RESERVED.test(seg)) return 'reserved-name';
+        if (WINDOWS_ILLEGAL.test(seg)) return 'illegal-chars';
+        if (/[. ]$/.test(seg)) return 'trailing-dot-or-space';
+    }
+    return null;
+}
+
+const matcherCache = new WeakMap();
+function matcherFor(patterns) {
+    const list = (Array.isArray(patterns) ? patterns : [patterns]).filter((p) => typeof p === 'string' && p.trim());
+    if (!list.length) return null;
+    if (Array.isArray(patterns)) {
+        const cached = matcherCache.get(patterns);
+        if (cached) return cached;
+    }
+    // "dir/**" also prunes "dir" itself (same convention as the file driver).
+    const globs = list.flatMap((p) => (p.endsWith('/**') ? [p, p.slice(0, -3)] : [p]));
+    const match = picomatch(globs, { dot: true });
+    if (Array.isArray(patterns)) matcherCache.set(patterns, match);
+    return match;
+}
+
+/** Does `key` match any of the ignore globs (picomatch, dotfiles included)? */
+export function isIgnored(key, patterns = MIRROR_IGNORE_DEFAULTS) {
+    const k = normalizeKey(key);
+    if (!k) return false;
+    const match = matcherFor(patterns);
+    if (!match) return false;
+    if (match(k)) return true;
+    // A pattern naming a directory covers everything under it.
+    const parts = k.split('/');
+    for (let i = 1; i < parts.length; i += 1) {
+        if (match(parts.slice(0, i).join('/'))) return true;
+    }
+    return false;
+}
+
+/**
+ * Selective sync: `prefixes` is a list of key prefixes (`Docs`, `Photos/2024/`)
+ * or picomatch globs. Empty/absent = everything. A prefix covers itself and
+ * the subtree under it.
+ */
+export function matchesPrefixes(key, prefixes) {
+    const list = (Array.isArray(prefixes) ? prefixes : [prefixes]).filter((p) => typeof p === 'string' && p.trim());
+    if (!list.length) return true;
+    const k = normalizeKey(key);
+    for (const raw of list) {
+        const p = normalizeKey(raw);
+        if (!p) return true;
+        if (/[*?[\]{}!]/.test(p)) {
+            // A glob covers the keys it matches and everything under a
+            // directory it matches (`Photos/20*` → `Photos/2024/a.jpg`).
+            const match = picomatch(p, { dot: true });
+            if (match(k)) return true;
+            const parts = k.split('/');
+            for (let i = 1; i < parts.length; i += 1) if (match(parts.slice(0, i).join('/'))) return true;
+            continue;
+        }
+        if (k === p || k.startsWith(`${p}/`)) return true;
+    }
+    return false;
+}
+
+const pad = (n) => String(n).padStart(2, '0');
+
+/**
+ * Dropbox-style conflict copy name:
+ * `<stem> (conflict from <device> <YYYY-MM-DD HHmm>).<ext>` (UTC), in the
+ * same directory as `key`. Matches canvas-fuse's `conflict_copy_key`.
+ */
+export function conflictKey(key, deviceName, date = new Date()) {
+    const k = normalizeKey(key);
+    const slash = k.lastIndexOf('/');
+    const dir = slash >= 0 ? k.slice(0, slash) : null;
+    const name = slash >= 0 ? k.slice(slash + 1) : k;
+    const dot = name.lastIndexOf('.');
+    const stem = dot > 0 ? name.slice(0, dot) : name;
+    const ext = dot > 0 ? name.slice(dot + 1) : null;
+    const at = date instanceof Date ? date : new Date(date);
+    const stamp = `${at.getUTCFullYear()}-${pad(at.getUTCMonth() + 1)}-${pad(at.getUTCDate())} ${pad(at.getUTCHours())}${pad(at.getUTCMinutes())}`;
+    const device = String(deviceName || 'device').replace(/[/\\]/g, '_');
+    const leaf = ext ? `${stem} (conflict from ${device} ${stamp}).${ext}` : `${stem} (conflict from ${device} ${stamp})`;
+    return dir ? `${dir}/${leaf}` : leaf;
+}
+
+export default { normalizeKey, validateKey, isIgnored, matchesPrefixes, conflictKey, MIRROR_IGNORE_DEFAULTS };

package/node_modules/canvas-stored/src/sync/worker.js

@@ -0,0 +1,52 @@
+import { parentPort } from 'worker_threads';
+import cacache from 'cacache';
+import { createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import { pipeline } from 'stream/promises';
+import { dirname, join } from 'path';
+
+// memoize:false — never hold blobs (up to 20GB) in the worker's RAM; stream
+// straight from the cache content store to each target.
+const CACHE_OPTS = { memoize: false };
+
+parentPort.on('message', async ({ seq, id, cacheRoot, cacheKey, targets }) => {
+    const results = [];
+
+    // Confirm the entry exists before fanning out (cheap index lookup, no read).
+    const info = await cacache.get.info(cacheRoot, cacheKey).catch(() => null);
+    if (!info) {
+        for (const target of targets) {
+            results.push({ backend: target.name, success: false, error: 'Cache read failed: entry not found' });
+        }
+        parentPort.postMessage({ seq, id, results });
+        return;
+    }
+
+    for (const target of targets) {
+        try {
+            switch (target.driver) {
+                case 'file': {
+                    const filePath = join(target.root, target.key);
+                    await mkdir(dirname(filePath), { recursive: true });
+                    // Fresh read stream per target — streams are single-use and
+                    // we never materialize the blob in memory.
+                    await pipeline(
+                        cacache.get.stream(cacheRoot, cacheKey, CACHE_OPTS),
+                        createWriteStream(filePath),
+                    );
+                    results.push({ backend: target.name, key: target.key, success: true });
+                    break;
+                }
+                // Non-file drivers (gdrive, …) are committed in-process by the
+                // SyncQueue through their live backend instance — they never
+                // reach this worker. Anything else here is a routing bug.
+                default:
+                    results.push({ backend: target.name, success: false, error: `Unknown driver: ${target.driver}` });
+            }
+        } catch (err) {
+            results.push({ backend: target.name, success: false, error: err.message });
+        }
+    }
+
+    parentPort.postMessage({ seq, id, results });
+});

package/node_modules/canvas-stored/src/utils/checksum.js

@@ -0,0 +1,32 @@
+import crypto from 'crypto';
+import fs from 'fs';
+
+export function checksumBuffer(buffer, algorithms = ['sha256']) {
+    const checksums = {};
+    for (const algo of algorithms) {
+        checksums[algo] = crypto.createHash(algo).update(buffer).digest('hex');
+    }
+    return checksums;
+}
+
+export async function checksumStream(stream, algorithms = ['sha256']) {
+    const hashes = algorithms.map(algo => ({ algo, hash: crypto.createHash(algo) }));
+
+    for await (const chunk of stream) {
+        for (const { hash } of hashes) hash.update(chunk);
+    }
+
+    const checksums = {};
+    for (const { algo, hash } of hashes) {
+        checksums[algo] = hash.digest('hex');
+    }
+    return checksums;
+}
+
+export function checksumFile(filePath, algorithms = ['sha256']) {
+    return checksumStream(fs.createReadStream(filePath), algorithms);
+}
+
+export function formatId(checksums, primaryAlgo = 'sha256') {
+    return `${primaryAlgo}:${checksums[primaryAlgo]}`;
+}

package/node_modules/canvas-stored/src/utils/common.js

@@ -0,0 +1,37 @@
+import fs from 'fs';
+import path from 'path';
+
+const DEFAULT_ROOT = './.stored';
+
+/** Resolve layout: `<root>/{index,cache,data}` with per-subdir overrides. */
+export function resolveStoredPaths(config = {}) {
+    const root = path.resolve(config.root ?? DEFAULT_ROOT);
+    return {
+        root,
+        index: path.resolve(config.index?.path ?? path.join(root, 'index')),
+        cache: path.resolve(config.cache?.path ?? path.join(root, 'cache')),
+        data: path.resolve(config.data?.path ?? path.join(root, 'data')),
+    };
+}
+
+export function isJson(input) {
+    if (typeof input !== 'object' || input === null) return false;
+    try {
+        JSON.stringify(input);
+        return true;
+    } catch { return false; }
+}
+
+export function isFile(input) {
+    if (typeof input !== 'string') return false;
+    try { return fs.statSync(input).isFile(); }
+    catch { return false; }
+}
+
+export function isBuffer(input) {
+    return Buffer.isBuffer(input);
+}
+
+export function isStream(input) {
+    return input && typeof input.pipe === 'function';
+}

package/node_modules/canvas-stored/src/utils/mime.js

@@ -0,0 +1,107 @@
+import { fileTypeFromBuffer, fileTypeFromFile } from 'file-type';
+import { open } from 'fs/promises';
+import path from 'path';
+
+// Extension-based MIME types for common text/code files (magic bytes don't work for these)
+const TEXT_MIME_TYPES = {
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.json': 'application/json',
+    '.xml': 'application/xml',
+    '.html': 'text/html',
+    '.htm': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.mjs': 'text/javascript',
+    '.ts': 'text/typescript',
+    '.tsx': 'text/typescript',
+    '.jsx': 'text/javascript',
+    '.yaml': 'text/yaml',
+    '.yml': 'text/yaml',
+    '.csv': 'text/csv',
+    '.log': 'text/plain',
+    '.sh': 'text/x-shellscript',
+    '.bash': 'text/x-shellscript',
+    '.zsh': 'text/x-shellscript',
+    '.py': 'text/x-python',
+    '.rb': 'text/x-ruby',
+    '.go': 'text/x-go',
+    '.rs': 'text/x-rust',
+    '.c': 'text/x-c',
+    '.h': 'text/x-c',
+    '.cpp': 'text/x-c++',
+    '.hpp': 'text/x-c++',
+    '.java': 'text/x-java',
+    '.sql': 'text/x-sql',
+    '.ini': 'text/plain',
+    '.conf': 'text/plain',
+    '.cfg': 'text/plain',
+    '.env': 'text/plain',
+    '.toml': 'text/toml',
+};
+
+// Heuristic: is this buffer plausibly UTF-8 text? No NUL bytes and >=95%
+// printable / whitespace. Cheap fallback for files without magic bytes or a
+// known extension (e.g. .ips, .rules, random log files).
+function looksLikeText(buf) {
+    if (!buf || buf.length === 0) return false;
+    let printable = 0;
+    for (let i = 0; i < buf.length; i++) {
+        const b = buf[i];
+        if (b === 0) return false;
+        if (b === 9 || b === 10 || b === 13 || (b >= 32 && b < 127) || b >= 128) printable++;
+    }
+    return printable / buf.length >= 0.95;
+}
+
+async function sniffHead(input, bytes = 4096) {
+    if (Buffer.isBuffer(input)) return input.subarray(0, bytes);
+    const fh = await open(input, 'r');
+    try {
+        const out = Buffer.alloc(bytes);
+        const { bytesRead } = await fh.read(out, 0, bytes, 0);
+        return out.subarray(0, bytesRead);
+    } finally { await fh.close(); }
+}
+
+// Streaming variant: detect from an already-captured head buffer (first few KB)
+// plus the storage key's extension. Used by the streaming put path where the
+// full blob is never materialized.
+export async function detectMimeFromHead(head, key) {
+    try {
+        if (head && head.length) {
+            const result = await fileTypeFromBuffer(head);
+            if (result?.mime) return result.mime;
+        }
+        if (typeof key === 'string') {
+            const ext = path.extname(key).toLowerCase();
+            if (TEXT_MIME_TYPES[ext]) return TEXT_MIME_TYPES[ext];
+        }
+        if (head && looksLikeText(head)) return 'text/plain';
+        return 'application/octet-stream';
+    } catch {
+        return 'application/octet-stream';
+    }
+}
+
+export async function detectMimeType(input) {
+    try {
+        const result = Buffer.isBuffer(input)
+            ? await fileTypeFromBuffer(input)
+            : await fileTypeFromFile(input);
+        if (result?.mime) return result.mime;
+
+        if (typeof input === 'string') {
+            const ext = path.extname(input).toLowerCase();
+            if (TEXT_MIME_TYPES[ext]) return TEXT_MIME_TYPES[ext];
+        }
+
+        const head = await sniffHead(input).catch(() => null);
+        if (head && looksLikeText(head)) return 'text/plain';
+
+        return 'application/octet-stream';
+    } catch {
+        return 'application/octet-stream';
+    }
+}
+

package/node_modules/canvas-stored/src/utils/mount.js

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import Debug from 'debug';
+
+const debug = Debug('stored:mount');
+
+/**
+ * Filesystem types served over the network. A backend rooted on one of these is
+ * `remote: true` — the bytes are reachable through a POSIX path, but every
+ * assumption that makes local disk cheap (inotify, free stat, fast full-file
+ * hashing) is off.
+ *
+ * `fuse.*` is matched by prefix: sshfs, rclone, s3fs and friends are all remote
+ * regardless of the transport they wrap.
+ */
+const REMOTE_FSTYPES = new Set([
+    'cifs', 'smbfs', 'smb3',
+    'nfs', 'nfs4',
+    'afpfs', 'afp',
+    'ncpfs', 'coda',
+    '9p', 'ceph', 'glusterfs', 'lustre', 'beegfs', 'ocfs2', 'gfs2',
+    'davfs', 'davfs2', 'webdav',
+]);
+
+const REMOTE_FSTYPE_PREFIXES = ['fuse.'];
+
+/** `\040`-style octal escapes are how /proc/mounts encodes spaces and tabs. */
+function unescapeMountField(value) {
+    return String(value).replace(/\\(\d{3})/g, (_, oct) => String.fromCharCode(parseInt(oct, 8)));
+}
+
+export function isRemoteFstype(fstype) {
+    if (!fstype) return false;
+    const type = String(fstype).toLowerCase();
+    if (REMOTE_FSTYPES.has(type)) return true;
+    return REMOTE_FSTYPE_PREFIXES.some((prefix) => type.startsWith(prefix));
+}
+
+/**
+ * Read the kernel mount table. Linux only — every other platform returns [] and
+ * detection degrades to "assume local unless configured otherwise".
+ * @returns {Array<{ source: string, mountpoint: string, fstype: string }>}
+ */
+function readMountTable() {
+    if (process.platform !== 'linux') return [];
+    let raw;
+    try {
+        raw = fs.readFileSync('/proc/mounts', 'utf8');
+    } catch (err) {
+        debug(`Cannot read /proc/mounts: ${err.message}`);
+        return [];
+    }
+    const rows = [];
+    for (const line of raw.split('\n')) {
+        if (!line) continue;
+        const [source, mountpoint, fstype] = line.split(' ');
+        if (!mountpoint || !fstype) continue;
+        rows.push({
+            source: unescapeMountField(source),
+            mountpoint: unescapeMountField(mountpoint),
+            fstype: fstype.toLowerCase(),
+        });
+    }
+    return rows;
+}
+
+/**
+ * Which mount serves `absPath`? The longest mountpoint that is a path-prefix of
+ * it wins (a bind/overlay nested inside another mount must beat its parent).
+ *
+ * Deliberately synchronous and dependency-free: this runs in the FileBackend
+ * constructor, where a subprocess (`findmnt`) or an async hop would force every
+ * caller of `addBackend()` to become async. Reading /proc/mounts is a single
+ * cheap read of a kernel-generated file.
+ *
+ * @param {string} absPath Absolute, ideally already-realpath'd directory.
+ * @returns {{ remote: boolean, transport: string|null, source: string|null, mountpoint: string|null }}
+ */
+export function detectMountSync(absPath) {
+    const unknown = { remote: false, transport: null, source: null, mountpoint: null };
+    if (!absPath || typeof absPath !== 'string') return unknown;
+
+    const target = path.resolve(absPath);
+    const table = readMountTable();
+    if (!table.length) return unknown;
+
+    let best = null;
+    for (const row of table) {
+        const mp = row.mountpoint;
+        const covers = mp === '/' ? true : (target === mp || target.startsWith(mp + path.sep));
+        if (!covers) continue;
+        if (!best || mp.length > best.mountpoint.length) best = row;
+    }
+    if (!best) return unknown;
+
+    const remote = isRemoteFstype(best.fstype);
+    debug(`${target} → ${best.fstype} on ${best.mountpoint} (${remote ? 'remote' : 'local'})`);
+    return { remote, transport: best.fstype, source: best.source, mountpoint: best.mountpoint };
+}

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@augmentd-labs/canvas-edge",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.1",
+  "description": "Canvas device runtime: folder mirrors (canvas-stored Mirror engine) + edge tunnel client (dist artifact)",
+  "license": "AGPL-3.0-or-later",
+  "type": "module",
+  "bin": {
+    "canvas-edge": "bin/canvas-edge"
+  },
+  "exports": {
+    ".": "./src/index.js",
+    "./client": "./src/EdgeClient.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "NOTICE"
+  ],
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "dependencies": {
+    "@augmentd-labs/canvas-protocol": "^0.4.0",
+    "canvas-stored": "1.9.1",
+    "cacache": "^20.0.4",
+    "chokidar": "^5.0.0",
+    "debug": "^4.4.3",
+    "eventemitter2": "^6.4.9",
+    "exifr": "^7.1.3",
+    "file-type": "^21.3.3",
+    "fs-extra": "^11.3.4",
+    "image-size": "^2.0.2",
+    "imap": "^0.8.19",
+    "lmdb": "^3.5.2",
+    "music-metadata": "^11.9.0",
+    "picomatch": "^2.3.1",
+    "fastify": "^4.29.1",
+    "pino": "^10.3.1",
+    "socket.io-client": "^4.8.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/canvas-ui/canvas-common.git",
+    "directory": "runtimes/edge"
+  },
+  "bundleDependencies": [
+    "canvas-stored"
+  ],
+  "canvasRev": "0dbc541",
+  "canvasSource": "runtimes/edge"
+}