@axium/storage 0.7.9 → 0.8.0

package/dist/{client.d.ts → client/api.d.ts}

@@ -1,4 +1,4 @@
-import type { StorageItemMetadata, StorageItemUpdate, UserStorage, UserStorageInfo } from './common.js';
+import type { StorageItemMetadata, StorageItemUpdate, UserStorage, UserStorageInfo } from '../common.js';
 export declare function parseItem(result: StorageItemMetadata): StorageItemMetadata;
 export interface UploadOptions {
     parentId?: string;

package/dist/{client.js → client/api.js}

@@ -1,4 +1,4 @@
-import { fetchAPI, token } from '@axium/client/requests';
+import { fetchAPI, prefix, token } from '@axium/client/requests';
 async function _upload(method, url, data, extraHeaders = {}) {
     const init = {
         method,
@@ -30,16 +30,24 @@ export function parseItem(result) {
         result.trashedAt = new Date(result.trashedAt);
     return result;
 }
+function rawStorage(fileId) {
+    const raw = '/raw/storage' + (fileId ? '/' + fileId : '');
+    if (prefix[0] == '/')
+        return raw;
+    const url = new URL(prefix);
+    url.pathname = raw;
+    return url;
+}
 export async function uploadItem(file, opt = {}) {
     const headers = {};
     if (opt.parentId)
         headers['x-parent'] = opt.parentId;
     if (opt.name)
         headers['x-name'] = opt.name;
-    return parseItem(await _upload('PUT', '/raw/storage', file, headers));
+    return parseItem(await _upload('PUT', rawStorage(), file, headers));
 }
 export async function updateItem(fileId, data) {
-    return parseItem(await _upload('POST', '/raw/storage/' + fileId, data));
+    return parseItem(await _upload('POST', rawStorage(fileId), data));
 }
 export async function getItemMetadata(fileId) {
     const result = await fetchAPI('GET', 'storage/item/:id', undefined, fileId);
@@ -55,7 +63,7 @@ export async function getDirectoryMetadata(parentId) {
     return result;
 }
 export async function downloadItem(fileId) {
-    const response = await fetch('/raw/storage/' + fileId, {
+    const response = await fetch(rawStorage(fileId), {
         headers: token ? { Authorization: 'Bearer ' + token } : {},
     });
     if (!response.ok)

package/dist/client/cli.d.ts

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

package/dist/client/cli.js

@@ -0,0 +1,124 @@
+import { configDir, session } from '@axium/client/cli/config';
+import { formatBytes } from '@axium/core/format';
+import * as io from '@axium/core/node/io';
+import { Option, program } from 'commander';
+import { statSync, unlinkSync } from 'node:fs';
+import { stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { styleText } from 'node:util';
+import { getUserStorage, getUserStorageInfo, getUserStorageRoot } from './api.js';
+import { config, saveConfig } from './config.js';
+import { walkItems } from './paths.js';
+import { computeDelta, doSync, fetchSyncItems } from './sync.js';
+const cli = program.command('files').helpGroup('Plugins:').description('CLI integration for @axium/storage');
+cli.command('usage')
+    .description('Show your usage')
+    .action(async () => {
+    const { limits, usage } = await getUserStorageInfo(session().userId);
+    console.log(`Items: ${usage.items} ${limits.user_items ? ' / ' + limits.user_items : ''}`);
+    console.log(`Space: ${formatBytes(usage.bytes)} ${limits.user_size ? ' / ' + formatBytes(limits.user_size * 1_000_000) : ''}`);
+});
+cli.command('ls')
+    .alias('list')
+    .description('List the contents of a folder')
+    .action(() => {
+    io.error('Not implemented yet.');
+});
+cli.command('status')
+    .option('-v, --verbose', 'Show more details')
+    .option('--refresh', 'Force refresh metadata from the server')
+    .action(async (opt) => {
+    console.log(styleText('bold', `${config.sync.length} synced folder(s):`));
+    for (const sync of config.sync) {
+        if (opt.refresh)
+            await fetchSyncItems(sync.itemId, sync.name);
+        const delta = computeDelta(sync.itemId, sync.localPath);
+        if (opt.verbose) {
+            console.log(styleText('underline', sync.localPath + ':'));
+            if (delta.synced.length == delta.items.length && !delta.localOnly.length) {
+                console.log('\t' + styleText('blueBright', 'All files are synced!'));
+                continue;
+            }
+            for (const { _path } of delta.localOnly)
+                console.log('\t' + styleText('green', '+ ' + _path));
+            for (const { path } of delta.remoteOnly)
+                console.log('\t' + styleText('red', '- ' + path));
+            for (const { path, modifiedAt } of delta.modified) {
+                const outdated = modifiedAt.getTime() > statSync(join(sync.localPath, path)).mtime.getTime();
+                console.log('\t' + styleText('yellow', '~ ' + path) + (outdated ? ' (outdated)' : ''));
+            }
+        }
+        else {
+            console.log(sync.localPath + ':', Object.entries(delta)
+                .map(([name, items]) => `${styleText('blueBright', items.length.toString())} ${name}`)
+                .join(', '));
+        }
+    }
+});
+cli.command('add')
+    .description('Add a folder to be synced')
+    .argument('<path>', 'local path to the folder to sync')
+    .argument('<remote>', 'remote folder path')
+    .action(async (localPath, remoteName) => {
+    localPath = resolve(localPath);
+    for (const sync of config.sync) {
+        if (sync.localPath == localPath || localPath.startsWith(sync.localPath + '/'))
+            io.exit('This local path is already being synced.');
+        if (sync.remotePath == remoteName || remoteName.startsWith(sync.remotePath + '/'))
+            io.exit('This remote path is already being synced.');
+    }
+    const { userId } = session();
+    const local = await stat(localPath).catch(e => io.exit(e.toString()));
+    if (!local.isDirectory())
+        io.exit('Local path is not a directory.');
+    /**
+     * @todo Add an endpoint to fetch directories (maybe with the full paths?)
+     */
+    const allItems = remoteName.includes('/') ? (await getUserStorage(userId)).items : await getUserStorageRoot(userId);
+    const remote = walkItems(remoteName, allItems);
+    if (!remote)
+        io.exit('Could not resolve remote path.');
+    if (remote.type != 'inode/directory')
+        io.exit('Remote path is not a directory.');
+    config.sync.push({
+        name: remote.name,
+        itemId: remote.id,
+        localPath,
+        lastSynced: new Date(),
+        remotePath: remoteName,
+    });
+    await fetchSyncItems(remote.id);
+    saveConfig();
+});
+cli.command('unsync')
+    .alias('remove-sync')
+    .alias('rm-sync')
+    .description('Stop syncing a folder')
+    .argument('<path>', 'local path to the folder to stop syncing')
+    .action((localPath) => {
+    localPath = resolve(localPath);
+    const index = config.sync.findIndex(sync => sync.localPath == localPath);
+    if (index == -1)
+        io.exit('This local path is not being synced.');
+    unlinkSync(join(configDir, 'sync', config.sync[index].itemId + '.json'));
+    config.sync.splice(index, 1);
+    saveConfig();
+});
+cli.command('sync')
+    .description('Sync files')
+    .addOption(new Option('--delete', 'Delete local/remote files that were deleted remotely/locally')
+    .choices(['local', 'remote', 'none'])
+    .default('none'))
+    .option('-d, --dry-run', 'Show what would be done, but do not make any changes')
+    .argument('[sync]', 'The name of the Sync to sync')
+    .action(async (name, opt) => {
+    if (name) {
+        const sync = config.sync.find(s => s.name == name);
+        if (!sync)
+            io.exit('Can not find a Sync with that name.');
+        await doSync(sync, opt);
+    }
+    else
+        for (const sync of config.sync)
+            await doSync(sync, opt);
+});

package/dist/client/config.d.ts

@@ -0,0 +1,15 @@
+import * as z from 'zod';
+declare const ClientStorageConfig: z.ZodObject<{
+    sync: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        itemId: z.ZodUUID;
+        localPath: z.ZodString;
+        lastSynced: z.ZodCoercedDate<unknown>;
+        remotePath: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export interface ClientStorageConfig extends z.infer<typeof ClientStorageConfig> {
+}
+export declare let config: ClientStorageConfig;
+export declare function saveConfig(): void;
+export {};

package/dist/client/config.js

@@ -0,0 +1,21 @@
+import { configDir } from '@axium/client/cli/config';
+import { debug, writeJSON } from '@axium/core/node/io';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path/posix';
+import * as z from 'zod';
+import { Sync } from './sync.js';
+const ClientStorageConfig = z.looseObject({
+    sync: Sync.array(),
+});
+const configPath = join(configDir, 'storage.json');
+export let config = { sync: [] };
+try {
+    config = ClientStorageConfig.parse(JSON.parse(readFileSync(configPath, 'utf-8')));
+}
+catch (e) {
+    debug('Could not load @axium/storage config: ' + (e instanceof z.core.$ZodError ? z.prettifyError(e) : e.message));
+}
+export function saveConfig() {
+    writeJSON(configPath, config);
+    debug('Saved @axium/storage config.');
+}

package/dist/client/hooks.d.ts

@@ -0,0 +1 @@
+export declare function run(): Promise<void>;

package/dist/client/hooks.js

@@ -0,0 +1,6 @@
+import { config } from './config.js';
+import { doSync } from './sync.js';
+export async function run() {
+    for (const sync of config.sync)
+        await doSync(sync, { delete: 'none', dryRun: false });
+}

package/dist/client/index.d.ts

@@ -0,0 +1 @@
+export * from './api.js';

package/dist/client/index.js

@@ -0,0 +1 @@
+export * from './api.js';

package/dist/client/paths.d.ts

@@ -0,0 +1,2 @@
+import type { StorageItemMetadata } from '../common.js';
+export declare function walkItems(path: string, items: StorageItemMetadata[]): StorageItemMetadata | null;

package/dist/client/paths.js

@@ -0,0 +1,16 @@
+export function walkItems(path, items) {
+    const resolved = [];
+    let currentItem = null, currentParentId = null;
+    const target = path.split('/').filter(p => p);
+    for (const part of target) {
+        for (const item of items) {
+            if (item.parentId != currentParentId || item.name != part)
+                continue;
+            currentItem = item;
+            currentParentId = item.id;
+            resolved.push(part);
+            break;
+        }
+    }
+    return currentItem;
+}

package/dist/client/sync.d.ts

@@ -0,0 +1,55 @@
+import * as fs from 'node:fs';
+import * as z from 'zod';
+import '../polyfills.js';
+/**
+ * A Sync is a storage item that has been selected for synchronization by the user.
+ * Importantly, it is *only* the "top-level" item.
+ * This means if a user selects a directory to sync, only that directory is a Sync.
+ *
+ * `Sync`s are client-side in nature, the server does not care about them.
+ * (we could do something fancy server-side at a later date)
+ */
+export declare const Sync: z.ZodObject<{
+    name: z.ZodString;
+    itemId: z.ZodUUID;
+    localPath: z.ZodString;
+    lastSynced: z.ZodCoercedDate<unknown>;
+    remotePath: z.ZodString;
+}, z.core.$strip>;
+export interface Sync extends z.infer<typeof Sync> {
+}
+/** Local metadata about a storage item to sync */
+export declare const LocalItem: z.ZodObject<{
+    id: z.ZodUUID;
+    path: z.ZodString;
+    modifiedAt: z.ZodCoercedDate<unknown>;
+    hash: z.ZodOptional<z.ZodNullable<z.ZodCustomStringFormat<"hex">>>;
+}, z.core.$strip>;
+export interface LocalItem extends z.infer<typeof LocalItem> {
+}
+export declare function fetchSyncItems(id: string, folderName?: string): Promise<LocalItem[]>;
+export declare function getItems(id: string): LocalItem[];
+export declare function setItems(id: string, items: LocalItem[]): void;
+/** Metadata about a synced storage item. */
+export interface ItemMetadata {
+}
+/** Computed metadata about changes */
+export interface Delta {
+    synced: LocalItem[];
+    modified: LocalItem[];
+    remoteOnly: LocalItem[];
+    items: LocalItem[];
+    _items: Map<string, LocalItem>;
+    localOnly: (fs.Dirent<string> & {
+        _path: string;
+    })[];
+}
+/**
+ * Computes the changes between the local and remote, in the direction of the remote.
+ */
+export declare function computeDelta(id: string, localPath: string): Delta;
+export interface SyncOptions {
+    delete: 'local' | 'remote' | 'none';
+    dryRun: boolean;
+}
+export declare function doSync(sync: Sync, opt: SyncOptions): Promise<void>;

package/dist/client/sync.js

@@ -0,0 +1,205 @@
+import { configDir, saveConfig } from '@axium/client/cli/config';
+import { fetchAPI } from '@axium/client/requests';
+import * as io from '@axium/core/node/io';
+import { createHash } from 'node:crypto';
+import * as fs from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { pick } from 'utilium';
+import * as z from 'zod';
+import '../polyfills.js';
+import { deleteItem, downloadItem, updateItem, uploadItem } from './api.js';
+import mime from 'mime';
+/**
+ * A Sync is a storage item that has been selected for synchronization by the user.
+ * Importantly, it is *only* the "top-level" item.
+ * This means if a user selects a directory to sync, only that directory is a Sync.
+ *
+ * `Sync`s are client-side in nature, the server does not care about them.
+ * (we could do something fancy server-side at a later date)
+ */
+export const Sync = z.object({
+    name: z.string(),
+    itemId: z.uuid(),
+    localPath: z.string(),
+    lastSynced: z.coerce.date(),
+    remotePath: z.string(),
+});
+/** Local metadata about a storage item to sync */
+export const LocalItem = z.object({
+    id: z.uuid(),
+    path: z.string(),
+    modifiedAt: z.coerce.date(),
+    hash: z.hex().length(128).nullish(),
+});
+export async function fetchSyncItems(id, folderName) {
+    io.start('Fetching ' + (folderName ?? id));
+    try {
+        const items = await fetchAPI('GET', 'storage/directory/:id/recursive', null, id);
+        const localItems = items.map(item => pick(item, 'id', 'path', 'modifiedAt', 'hash'));
+        fs.mkdirSync(join(configDir, 'sync'), { recursive: true });
+        io.writeJSON(join(configDir, 'sync', id + '.json'), localItems);
+        io.done();
+        return localItems;
+    }
+    catch (e) {
+        io.exit(e.message);
+    }
+}
+export function getItems(id) {
+    const items = JSON.parse(fs.readFileSync(join(configDir, 'sync', id + '.json'), 'utf-8'));
+    const { error, data } = LocalItem.array().safeParse(items);
+    if (error)
+        throw z.prettifyError(error);
+    return data;
+}
+export function setItems(id, items) {
+    fs.mkdirSync(join(configDir, 'sync'), { recursive: true });
+    io.writeJSON(join(configDir, 'sync', id + '.json'), items);
+}
+/**
+ * Computes the changes between the local and remote, in the direction of the remote.
+ */
+export function computeDelta(id, localPath) {
+    const items = new Map(getItems(id).map(i => [i.path, i]));
+    const itemsSet = new Set(items.keys());
+    const files = new Map(fs.readdirSync(localPath, { recursive: true, encoding: 'utf8', withFileTypes: true }).map(d => {
+        const _path = relative(localPath, join(d.parentPath, d.name));
+        return [_path, Object.assign(d, { _path })];
+    }));
+    const synced = itemsSet.intersection(files);
+    const modified = new Set(synced.keys().filter(path => {
+        const full = join(localPath, path);
+        const hash = fs.statSync(full).isDirectory() ? null : createHash('BLAKE2b512').update(fs.readFileSync(full)).digest().toHex();
+        return hash != items.get(path)?.hash;
+    }));
+    const delta = {
+        _items: items,
+        items: Array.from(items.values()),
+        synced: Array.from(synced.difference(modified)).map(p => items.get(p)),
+        modified: Array.from(modified).map(p => items.get(p)),
+        localOnly: Array.from(new Set(files.keys()).difference(items)).map(p => files.get(p)),
+        remoteOnly: Array.from(itemsSet.difference(files)).map(p => items.get(p)),
+    };
+    Object.defineProperty(delta, '_items', { enumerable: false });
+    return delta;
+}
+export async function doSync(sync, opt) {
+    await fetchSyncItems(sync.itemId, sync.name);
+    const delta = computeDelta(sync.itemId, sync.localPath);
+    const { _items } = delta;
+    if (opt.delete == 'local')
+        delta.localOnly.reverse(); // so directories come after
+    for (const dirent of delta.localOnly) {
+        if (opt.delete == 'local') {
+            io.start('Deleting ' + dirent._path);
+            try {
+                if (opt.dryRun)
+                    process.stdout.write('(dry run) ');
+                else {
+                    fs.unlinkSync(join(sync.localPath, dirent._path));
+                    _items.delete(dirent._path);
+                }
+                io.done();
+            }
+            catch (e) {
+                io.error(e.message);
+            }
+            continue;
+        }
+        const uploadOpts = {
+            parentId: dirname(dirent._path) == '.' ? sync.itemId : _items.get(dirname(dirent._path))?.id,
+            name: dirent.name,
+        };
+        io.start('Uploading ' + dirent._path);
+        try {
+            if (opt.dryRun)
+                process.stdout.write('(dry run) ');
+            else if (dirent.isDirectory()) {
+                const dir = await uploadItem(new Blob([], { type: 'inode/directory' }), uploadOpts);
+                _items.set(dirent._path, Object.assign(pick(dir, 'id', 'modifiedAt'), { path: dirent._path, hash: null }));
+            }
+            else {
+                const type = mime.getType(dirent._path) || 'application/octet-stream';
+                const content = fs.readFileSync(join(sync.localPath, dirent._path));
+                const file = await uploadItem(new Blob([content], { type }), uploadOpts);
+                _items.set(dirent._path, Object.assign(pick(file, 'id', 'modifiedAt', 'hash'), { path: dirent._path }));
+            }
+            io.done();
+        }
+        catch (e) {
+            io.error(e.message);
+        }
+    }
+    if (opt.delete == 'remote')
+        delta.remoteOnly.reverse();
+    for (const item of delta.remoteOnly) {
+        if (opt.delete == 'remote') {
+            io.start('Deleting ' + item.path);
+            try {
+                if (opt.dryRun)
+                    process.stdout.write('(dry run) ');
+                else {
+                    await deleteItem(item.id);
+                    _items.delete(item.path);
+                }
+                io.done();
+            }
+            catch (e) {
+                io.error(e.message);
+            }
+            continue;
+        }
+        io.start('Downloading ' + item.path);
+        try {
+            const fullPath = join(sync.localPath, item.path);
+            if (opt.dryRun)
+                process.stdout.write('(dry run) ');
+            else if (!item.hash) {
+                fs.mkdirSync(fullPath, { recursive: true });
+            }
+            else {
+                const blob = await downloadItem(item.id);
+                const content = await blob.bytes();
+                fs.writeFileSync(fullPath, content);
+            }
+            io.done();
+        }
+        catch (e) {
+            io.error(e.message);
+        }
+    }
+    for (const item of delta.modified) {
+        io.start('Updating ' + item.path);
+        try {
+            const content = fs.readFileSync(join(sync.localPath, item.path));
+            const type = mime.getType(item.path) || 'application/octet-stream';
+            if (item.modifiedAt.getTime() > fs.statSync(join(sync.localPath, item.path)).mtime.getTime()) {
+                if (opt.dryRun)
+                    process.stdout.write('(dry run) ');
+                else {
+                    const blob = await downloadItem(item.id);
+                    const content = await blob.bytes();
+                    fs.writeFileSync(join(sync.localPath, item.path), content);
+                }
+                console.log('server.');
+            }
+            else {
+                if (opt.dryRun)
+                    process.stdout.write('(dry run) ');
+                else {
+                    const updated = await updateItem(item.id, new Blob([content], { type }));
+                    _items.set(item.path, Object.assign(pick(updated, 'id', 'modifiedAt', 'hash'), { path: item.path }));
+                }
+                console.log('local.');
+            }
+        }
+        catch (e) {
+            io.error(e.message);
+        }
+    }
+    if (opt.dryRun)
+        return;
+    setItems(sync.itemId, Array.from(_items.values()));
+    sync.lastSynced = new Date();
+    saveConfig();
+}

package/dist/common.d.ts

@@ -14,6 +14,15 @@ declare module '@axium/core/api' {
         'users/:id/storage/shared': {
             GET: StorageItemMetadata[];
         };
+        storage: {
+            OPTIONS: StoragePublicConfig & {
+                syncProtocolVersion: number;
+                batchFormatVersion: number;
+            };
+        };
+        'storage/batch': {
+            POST: [StorageBatchUpdate[], StorageItemMetadata[]];
+        };
         'storage/item/:id': {
             GET: StorageItemMetadata;
             DELETE: StorageItemMetadata;
@@ -22,8 +31,31 @@ declare module '@axium/core/api' {
         'storage/directory/:id': {
             GET: StorageItemMetadata[];
         };
+        'storage/directory/:id/recursive': {
+            GET: (StorageItemMetadata & {
+                path: string;
+            })[];
+        };
     }
 }
+export interface StoragePublicConfig {
+    /** Configuration for batch updates */
+    batch: {
+        /** Whether to enable sending multiple files per request */
+        enabled: boolean;
+        /** Maximum number of items that can be included in a single batch update */
+        max_items: number;
+        /** Maximum size in KiB per item */
+        max_item_size: number;
+    };
+    /** Whether to split files larger than `max_transfer_size` into multiple chunks */
+    chunk: boolean;
+    /** Maximum size in MiB per transfer/request */
+    max_transfer_size: number;
+    /** Maximum number of chunks */
+    max_chunks: number;
+}
+export declare const syncProtocolVersion = 0;
 export interface StorageLimits {
     /** The maximum size per item in MB */
     item_size: number;
@@ -70,3 +102,31 @@ export interface StorageItemMetadata<T extends Record<string, unknown> = Record<
     type: string;
     metadata: T;
 }
+/**
+ * Formats:
+ *
+ * **v0**:
+ * - Metadata transferred using JSON
+ * - `x-batch-header-size` HTTP header used to determine batch header size
+ * - Binary data appended after batch header
+ */
+export declare const batchFormatVersion = 0;
+export declare const BatchedContentChange: z.ZodObject<{
+    offset: z.ZodInt;
+    size: z.ZodInt;
+}, z.core.$strip>;
+export declare const StorageBatchUpdate: z.ZodObject<{
+    deleted: z.ZodArray<z.ZodUUID>;
+    metadata: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        owner: z.ZodOptional<z.ZodUUID>;
+        trash: z.ZodOptional<z.ZodBoolean>;
+        publicPermission: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    content: z.ZodRecord<z.ZodUUID, z.ZodObject<{
+        offset: z.ZodInt;
+        size: z.ZodInt;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export interface StorageBatchUpdate extends z.infer<typeof StorageBatchUpdate> {
+}

package/dist/common.js

@@ -1,4 +1,5 @@
 import * as z from 'zod';
+export const syncProtocolVersion = 0;
 /**
  * An update to file metadata.
  */
@@ -10,3 +11,22 @@ export const StorageItemUpdate = z
     publicPermission: z.number().min(0).max(5),
 })
     .partial();
+/**
+ * Formats:
+ *
+ * **v0**:
+ * - Metadata transferred using JSON
+ * - `x-batch-header-size` HTTP header used to determine batch header size
+ * - Binary data appended after batch header
+ */
+export const batchFormatVersion = 0;
+export const BatchedContentChange = z.object({
+    /** Offset in request body */
+    offset: z.int().nonnegative(),
+    size: z.int().nonnegative(),
+});
+export const StorageBatchUpdate = z.object({
+    deleted: z.uuid().array(),
+    metadata: z.record(z.uuid(), StorageItemUpdate),
+    content: z.record(z.uuid(), BatchedContentChange),
+});

package/dist/polyfills.d.ts

@@ -24,7 +24,7 @@ declare global {
          */
         fromHex: (string: string) => Uint8Array;
     }
-    interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+    interface Uint8Array {
         /**
          * Converts the `Uint8Array` to a base64-encoded string.
          * @param options If provided, sets the alphabet and padding behavior used.

package/dist/polyfills.js

@@ -7,14 +7,14 @@ https://github.com/microsoft/TypeScript/issues/61695
 
 @todo Remove when TypeScript 5.9 is released
 */
-import { output } from '@axium/server/io';
+import { debug } from '@axium/core/node/io';
 Uint8Array.prototype.toHex ??=
-    (output.warn('Using a polyfill of Uint8Array.prototype.toHex'),
+    (debug('Using a polyfill of Uint8Array.prototype.toHex'),
         function toHex() {
             return [...this].map(b => b.toString(16).padStart(2, '0')).join('');
         });
 Uint8Array.fromHex ??=
-    (output.warn('Using a polyfill of Uint8Array.fromHex'),
+    (debug('Using a polyfill of Uint8Array.fromHex'),
         function fromHex(hex) {
             const bytes = new Uint8Array(hex.length / 2);
             for (let i = 0; i < hex.length; i += 2) {

package/dist/server/api.d.ts

@@ -0,0 +1 @@
+import '../polyfills.js';