@technomoron/api-server-base 2.0.0-beta.21 → 2.0.0-beta.23

package/dist/cjs/server/src/upload/tus-module.cjs

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TusUploadModule = void 0;
+const api_server_base_js_1 = require("../api-server-base.cjs");
+const memory_js_1 = require("./memory.cjs");
+const TUS_VERSION = '1.0.0';
+function parseNonNegativeInt(raw, headerName) {
+    const value = Array.isArray(raw) ? raw[0] : raw;
+    const parsed = Number.parseInt(String(value ?? ''), 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        throw new api_server_base_js_1.ApiError({ code: 400, message: `Missing or invalid ${headerName} header` });
+    }
+    return parsed;
+}
+function parseUploadLength(raw) {
+    return parseNonNegativeInt(raw, 'Upload-Length');
+}
+function parseOffset(raw) {
+    return parseNonNegativeInt(raw, 'Upload-Offset');
+}
+function decodeMetadata(raw) {
+    const source = Array.isArray(raw) ? raw[0] : raw;
+    const input = String(source ?? '').trim();
+    if (!input) {
+        return {};
+    }
+    const out = {};
+    for (const pair of input.split(',')) {
+        const trimmed = pair.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const [key, encoded = ''] = trimmed.split(' ');
+        if (!key) {
+            continue;
+        }
+        try {
+            out[key] = Buffer.from(encoded, 'base64').toString('utf8');
+        }
+        catch {
+            out[key] = '';
+        }
+    }
+    return out;
+}
+async function readChunk(request, maxBytes) {
+    if (Buffer.isBuffer(request.body)) {
+        return request.body;
+    }
+    if (typeof request.body === 'string') {
+        return Buffer.from(request.body);
+    }
+    // Fastify only sets request.body when the Content-Type parser fires.
+    // Fall back to reading the raw stream, but enforce the same size cap to
+    // prevent bodyLimit from being bypassed by omitting the Content-Type header.
+    const parts = [];
+    let total = 0;
+    for await (const chunk of request.raw) {
+        const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+        total += buf.length;
+        if (total > maxBytes) {
+            throw new api_server_base_js_1.ApiError({ code: 413, message: 'Upload chunk exceeds maximum chunk size' });
+        }
+        parts.push(buf);
+    }
+    return Buffer.concat(parts);
+}
+function setTusHeaders(reply, supportsTermination = false) {
+    reply.header('Tus-Resumable', TUS_VERSION);
+    reply.header('Tus-Version', TUS_VERSION);
+    reply.header('Tus-Extension', supportsTermination ? 'creation,termination' : 'creation');
+}
+function toLocation(basePath, uploadId) {
+    const normalized = basePath.endsWith('/') ? basePath.slice(0, -1) : basePath;
+    return `${normalized}/${uploadId}`;
+}
+class TusUploadModule extends api_server_base_js_1.ApiModule {
+    constructor(options = {}) {
+        super({ namespace: '' });
+        const rawPath = options.basePath?.trim() || '/api/v1/upload';
+        this.basePath = rawPath.startsWith('/') ? rawPath : `/${rawPath}`;
+        this.chunkMaxBytes = options.chunkMaxBytes ?? 64 * 1024 * 1024;
+        this.uploadMaxBytes = options.uploadMaxBytes ?? 10 * 1024 * 1024 * 1024; // 10 GiB
+        this.store = options.store ?? new memory_js_1.MemoryTusUploadStore();
+        this.auth = options.auth;
+        this.onUploadComplete = options.onUploadComplete;
+    }
+    onMount() {
+        this.installTusRoutes();
+    }
+    /**
+     * Authenticate the request if an auth config was provided.
+     * Returns false and sends a 401/403 response if auth fails, so the caller
+     * can bail out early with `if (!await this.checkAuth(request, reply)) return`.
+     */
+    async checkAuth(request, reply) {
+        if (!this.auth) {
+            return null;
+        }
+        try {
+            const apiReq = await this.server.resolveRequest(request, reply, this.auth);
+            return apiReq.tokenData?.uid != null ? String(apiReq.tokenData.uid) : null;
+        }
+        catch (error) {
+            const code = error instanceof api_server_base_js_1.ApiError ? error.code : 401;
+            const message = error instanceof api_server_base_js_1.ApiError ? error.message : 'Unauthorized';
+            reply.code(code).send({ success: false, code, message, data: null, errors: {} });
+            return false;
+        }
+    }
+    authFailed(result) {
+        // When auth is configured and checkAuth catches an error, it returns
+        // `false as unknown as string` after sending a response.  We distinguish
+        // that from a legitimate `null` (no auth configured / no uid in token)
+        // by checking the exact `false` sentinel.
+        return result === false;
+    }
+    verifyOwnership(upload, authUserId, reply) {
+        if (upload.userId && authUserId && upload.userId !== authUserId) {
+            reply
+                .code(403)
+                .send({ success: false, code: 403, message: 'Upload belongs to another user', data: null, errors: {} });
+            return false;
+        }
+        return true;
+    }
+    installTusRoutes() {
+        const app = this.server.fastify;
+        const hasTermination = typeof this.store.deleteUpload === 'function';
+        try {
+            app.addContentTypeParser('application/offset+octet-stream', { parseAs: 'buffer' }, (_req, body, done) => {
+                done(null, body);
+            });
+        }
+        catch (error) {
+            // Parser may already be present when mounting multiple upload modules.
+            const message = error instanceof Error ? error.message : '';
+            if (!message.includes('already registered') && !message.includes('already exists')) {
+                throw error;
+            }
+        }
+        app.options(this.basePath, async (_request, reply) => {
+            setTusHeaders(reply, hasTermination);
+            reply.code(204).send();
+        });
+        app.post(this.basePath, async (request, reply) => {
+            const authUserId = await this.checkAuth(request, reply);
+            if (this.authFailed(authUserId))
+                return;
+            setTusHeaders(reply, hasTermination);
+            const length = parseUploadLength(request.headers['upload-length']);
+            if (length <= 0) {
+                reply.code(400).send({
+                    success: false,
+                    code: 400,
+                    message: 'Upload-Length must be greater than zero',
+                    data: null,
+                    errors: {}
+                });
+                return;
+            }
+            if (length > this.uploadMaxBytes) {
+                reply.code(413).send({
+                    success: false,
+                    code: 413,
+                    message: `Upload-Length exceeds the maximum allowed size of ${this.uploadMaxBytes} bytes`,
+                    data: null,
+                    errors: {}
+                });
+                return;
+            }
+            const metadata = decodeMetadata(request.headers['upload-metadata']);
+            const created = await this.store.createUpload({ length, metadata, userId: authUserId ?? undefined });
+            reply.header('Location', toLocation(this.basePath, created.id));
+            reply.header('Upload-Offset', String(created.offset));
+            reply.code(201).send();
+        });
+        app.head(`${this.basePath}/:uploadId`, async (request, reply) => {
+            const authUserId = await this.checkAuth(request, reply);
+            if (this.authFailed(authUserId))
+                return;
+            setTusHeaders(reply, hasTermination);
+            const uploadId = String(request.params.uploadId ?? '');
+            const upload = await this.store.getUpload(uploadId);
+            if (!upload) {
+                reply.code(404).send();
+                return;
+            }
+            if (!this.verifyOwnership(upload, authUserId, reply))
+                return;
+            reply.header('Upload-Offset', String(upload.offset));
+            reply.header('Upload-Length', String(upload.length));
+            reply.code(200).send();
+        });
+        app.patch(`${this.basePath}/:uploadId`, { bodyLimit: this.chunkMaxBytes }, async (request, reply) => {
+            const authUserId = await this.checkAuth(request, reply);
+            if (this.authFailed(authUserId))
+                return;
+            setTusHeaders(reply, hasTermination);
+            const uploadId = String(request.params.uploadId ?? '');
+            const upload = await this.store.getUpload(uploadId);
+            if (!upload) {
+                reply.code(404).send();
+                return;
+            }
+            if (!this.verifyOwnership(upload, authUserId, reply))
+                return;
+            const offset = parseOffset(request.headers['upload-offset']);
+            if (offset !== upload.offset) {
+                reply.header('Upload-Offset', String(upload.offset));
+                reply.code(409).send();
+                return;
+            }
+            const chunk = await readChunk(request, this.chunkMaxBytes);
+            try {
+                const updated = await this.store.appendUpload({ uploadId, offset, chunk });
+                reply.header('Upload-Offset', String(updated.offset));
+                if (updated.completedAt && this.onUploadComplete) {
+                    try {
+                        await this.onUploadComplete(updated);
+                    }
+                    catch (completionError) {
+                        console.error('[TusUploadModule] onUploadComplete callback failed', completionError);
+                    }
+                }
+                reply.code(204).send();
+            }
+            catch (error) {
+                if (error instanceof memory_js_1.TusUploadOffsetError) {
+                    reply.header('Upload-Offset', String(error.currentOffset));
+                    reply.code(409).send();
+                    return;
+                }
+                if (error instanceof memory_js_1.TusUploadExceedsLengthError) {
+                    reply.code(413).send({
+                        success: false,
+                        code: 413,
+                        message: 'Upload chunk exceeds declared upload length',
+                        data: null,
+                        errors: {}
+                    });
+                    return;
+                }
+                throw error;
+            }
+        });
+        app.delete(`${this.basePath}/:uploadId`, async (request, reply) => {
+            const authUserId = await this.checkAuth(request, reply);
+            if (this.authFailed(authUserId))
+                return;
+            setTusHeaders(reply, hasTermination);
+            const uploadId = String(request.params.uploadId ?? '');
+            if (!this.store.deleteUpload) {
+                reply.header('Allow', 'OPTIONS, POST, HEAD, PATCH');
+                reply.code(405).send();
+                return;
+            }
+            const upload = await this.store.getUpload(uploadId);
+            if (!upload) {
+                reply.code(404).send();
+                return;
+            }
+            if (!this.verifyOwnership(upload, authUserId, reply))
+                return;
+            const deleted = await this.store.deleteUpload(uploadId);
+            reply.code(deleted ? 204 : 404).send();
+        });
+    }
+}
+exports.TusUploadModule = TusUploadModule;

package/dist/cjs/server/src/upload/tus-module.d.ts

@@ -0,0 +1,38 @@
+import { ApiModule, type ApiAuthClass, type ApiAuthType, type ApiServer } from '../api-server-base.js';
+import type { TusUploadRecord, TusUploadStore } from './types.js';
+export interface TusUploadModuleOptions {
+    basePath?: string;
+    store?: TusUploadStore;
+    chunkMaxBytes?: number;
+    /** Maximum allowed value for Upload-Length. Defaults to 10 GiB. */
+    uploadMaxBytes?: number;
+    /**
+     * Authentication requirement for all TUS routes.
+     * When omitted, routes are public (no authentication enforced).
+     * Use `{ type: 'yes', req: 'any' }` to require a valid session.
+     */
+    auth?: {
+        type: ApiAuthType;
+        req?: ApiAuthClass;
+    };
+    onUploadComplete?: (upload: TusUploadRecord) => Promise<void> | void;
+}
+export declare class TusUploadModule extends ApiModule<ApiServer> {
+    private readonly basePath;
+    private readonly chunkMaxBytes;
+    private readonly uploadMaxBytes;
+    private readonly store;
+    private readonly auth?;
+    private readonly onUploadComplete?;
+    constructor(options?: TusUploadModuleOptions);
+    onMount(): void;
+    /**
+     * Authenticate the request if an auth config was provided.
+     * Returns false and sends a 401/403 response if auth fails, so the caller
+     * can bail out early with `if (!await this.checkAuth(request, reply)) return`.
+     */
+    private checkAuth;
+    private authFailed;
+    private verifyOwnership;
+    private installTusRoutes;
+}

package/dist/cjs/server/src/upload/types.d.ts

@@ -0,0 +1,8 @@
+import type { TusAppendInput, TusCreateUploadInput, TusUploadRecord } from '#common';
+export type { TusAppendInput, TusCreateUploadInput, TusMetadata, TusUploadRecord } from '#common';
+export interface TusUploadStore {
+    createUpload(input: TusCreateUploadInput): Promise<TusUploadRecord>;
+    getUpload(uploadId: string): Promise<TusUploadRecord | null>;
+    appendUpload(input: TusAppendInput): Promise<TusUploadRecord>;
+    deleteUpload?(uploadId: string): Promise<boolean>;
+}

package/dist/cjs/{user/base.js → server/src/user/base.cjs}

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserStore = void 0;
 const node_crypto_1 = require("node:crypto");
 const bcryptjs_1 = __importDefault(require("bcryptjs"));
+/** Base contract for user persistence backends. */
 class UserStore {
     constructor(opts = {}) {
         this.toPublicUser = opts.toPublic ?? ((u) => u);

package/dist/cjs/{user → server/src/user}/base.d.ts

@@ -1,5 +1,6 @@
 import type { CreateUserInput, PublicUserMapper, UpdateUserInput } from './types.js';
 import type { AuthIdentifier } from '../auth-api/types.js';
+/** Base contract for user persistence backends. */
 export declare abstract class UserStore<User, PublicUser> {
     protected readonly toPublicUser: PublicUserMapper<User, PublicUser>;
     private readonly bcryptRounds;
@@ -13,14 +14,22 @@ export declare abstract class UserStore<User, PublicUser> {
     protected hashPassword(plain: string): Promise<string>;
     verifyPassword(plain: string, hashed: string): Promise<boolean>;
     protected normalizeUserInput(input: Partial<CreateUserInput>): CreateUserInput;
+    /** Find a user by id/login/email identifier. */
     abstract findUser(identifier: AuthIdentifier | string): Promise<User | null>;
+    /** Find a user by primary id only. */
     abstract findById(id: AuthIdentifier): Promise<User | null>;
+    /** Find a user by login or email value. */
     abstract findByLoginOrEmail(loginOrEmail: string): Promise<User | null>;
+    /** Create a new user record. */
     abstract createUser(input: CreateUserInput): Promise<User>;
     abstract upsertUser(input: CreateUserInput): Promise<User>;
+    /** Update selected user fields. */
     abstract updateUser(id: AuthIdentifier, patch: UpdateUserInput): Promise<User>;
+    /** Persist a password hash for the given user id. */
     abstract setPasswordHash(id: AuthIdentifier, hash: string): Promise<void>;
+    /** Extract the password hash from a user record. */
     abstract getPasswordHash(user: User): string | null;
+    /** Extract the stable user identifier from a user record. */
     abstract getUserId(user: User): AuthIdentifier;
     toPublic(user: User): PublicUser;
 }

package/dist/cjs/{user/memory.js → server/src/user/memory.cjs}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MemoryUserStore = void 0;
-const user_id_js_1 = require("../auth-api/user-id.js");
-const base_js_1 = require("./base.js");
+const user_id_js_1 = require("../auth-api/user-id.cjs");
+const base_js_1 = require("./base.cjs");
 function cloneUser(user) {
     return { ...user };
 }
@@ -44,11 +44,15 @@ class MemoryUserStore extends base_js_1.UserStore {
             }
             const loginId = this.loginToId.get(identifier);
             if (loginId !== undefined) {
-                return cloneUser(this.usersById.get(loginId));
+                const loginUser = this.usersById.get(loginId);
+                if (loginUser)
+                    return cloneUser(loginUser);
             }
             const emailId = this.emailToId.get(identifier);
             if (emailId !== undefined) {
-                return cloneUser(this.usersById.get(emailId));
+                const emailUser = this.usersById.get(emailId);
+                if (emailUser)
+                    return cloneUser(emailUser);
             }
         }
         return null;
@@ -64,7 +68,19 @@ class MemoryUserStore extends base_js_1.UserStore {
         }
     }
     async findByLoginOrEmail(loginOrEmail) {
-        return this.findUser(loginOrEmail);
+        const loginId = this.loginToId.get(loginOrEmail);
+        if (loginId !== undefined) {
+            const loginUser = this.usersById.get(loginId);
+            if (loginUser)
+                return cloneUser(loginUser);
+        }
+        const emailId = this.emailToId.get(loginOrEmail);
+        if (emailId !== undefined) {
+            const emailUser = this.usersById.get(emailId);
+            if (emailUser)
+                return cloneUser(emailUser);
+        }
+        return null;
     }
     async createUser(input) {
         const normalizedInput = this.normalizeUserInput(input);
@@ -118,9 +134,12 @@ class MemoryUserStore extends base_js_1.UserStore {
                     throw new Error(`User with email ${updates.email} already exists`);
                 }
             }
-            if (normalizedInput.password) {
+            if (normalizedInput.password && normalizedInput.password.length > 0) {
                 updates.password = await this.hashPassword(normalizedInput.password);
             }
+            else {
+                updates.password = existing.password;
+            }
             this.persistUser(updates);
             return cloneUser(updates);
         }
@@ -132,9 +151,12 @@ class MemoryUserStore extends base_js_1.UserStore {
             throw new Error(`User ${String(id)} not found`);
         }
         const updates = { ...user, ...patch };
-        if (patch.password) {
+        if (patch.password && patch.password.length > 0) {
             updates.password = await this.hashPassword(patch.password);
         }
+        else {
+            updates.password = user.password;
+        }
         this.persistUser(updates);
         return cloneUser(updates);
     }

package/dist/cjs/{user/sequelize.js → server/src/user/sequelize.cjs}

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SequelizeUserStore = exports.AuthUserModel = void 0;
 exports.initAuthUserModel = initAuthUserModel;
 const sequelize_1 = require("sequelize");
-const user_id_js_1 = require("../auth-api/user-id.js");
-const sequelize_utils_js_1 = require("../sequelize-utils.js");
-const base_js_1 = require("./base.js");
+const user_id_js_1 = require("../auth-api/user-id.cjs");
+const sequelize_utils_js_1 = require("../sequelize-utils.cjs");
+const base_js_1 = require("./base.cjs");
 class AuthUserModel extends sequelize_1.Model {
 }
 exports.AuthUserModel = AuthUserModel;
@@ -120,11 +120,22 @@ class SequelizeUserStore extends base_js_1.UserStore {
                 throw new Error(`User ${String(providedId)} not found`);
             }
             const next = { ...normalized };
-            if (normalized.password) {
+            if (normalized.password && normalized.password.length > 0) {
                 next.password = await this.hashPassword(normalized.password);
             }
+            else {
+                delete next.password;
+            }
             await model.set(next);
-            await model.save();
+            try {
+                await model.save();
+            }
+            catch (error) {
+                if (error instanceof sequelize_1.UniqueConstraintError) {
+                    throw new Error(`User with login ${normalized.login} or email ${normalized.email} already exists`);
+                }
+                throw error;
+            }
             return this.toUserRecord(model);
         }
         return this.createUser(input);
@@ -135,15 +146,29 @@ class SequelizeUserStore extends base_js_1.UserStore {
             throw new Error(`User ${String(id)} not found`);
         }
         const updates = { ...patch };
-        if (patch.password) {
+        if (patch.password && patch.password.length > 0) {
             updates.password = await this.hashPassword(patch.password);
         }
+        else {
+            delete updates.password;
+        }
         await model.set(updates);
-        await model.save();
+        try {
+            await model.save();
+        }
+        catch (error) {
+            if (error instanceof sequelize_1.UniqueConstraintError) {
+                throw new Error(`User with login or email already exists`);
+            }
+            throw error;
+        }
         return this.toUserRecord(model);
     }
     async setPasswordHash(id, hash) {
-        await this.Users.update({ password: hash }, { where: { user_id: this.normalizeUserId(id) } });
+        const [affected] = await this.Users.update({ password: hash }, { where: { user_id: this.normalizeUserId(id) } });
+        if (affected === 0) {
+            throw new Error(`User ${String(id)} not found`);
+        }
     }
     getPasswordHash(user) {
         return user.password;

package/dist/cjs/server/src/user/types.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/esm/common/types.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Shared type definitions used by both api-server-base and api-client-base.
+ * This file contains only `type`/`interface` declarations — no runtime code.
+ * Both packages reference these types via `import type`. Note that TypeScript
+ * does NOT inline `import type` references in emitted `.d.ts` files — the
+ * path aliases persist. Source files therefore keep inline type definitions
+ * to avoid broken references for consumers of the published packages.
+ */
+export type AuthIdentifier = string | number;
+export type SafeUser = Record<string, unknown>;
+export interface ApiResponseData<T = unknown> {
+    success: boolean;
+    code: number;
+    message: string;
+    data: T | null;
+    errors: Record<string, string>;
+}
+export interface AuthTokenData<User = SafeUser> {
+    accessToken?: string;
+    refreshToken?: string;
+    user?: User;
+}
+export interface WhoAmIResponseData<User = SafeUser, UserId extends AuthIdentifier = AuthIdentifier> {
+    user: User;
+    isImpersonating: boolean;
+    realUser?: User | null;
+    realUserId?: UserId | null;
+}
+export interface LogoutResponseData {
+    revoked: number;
+}
+export type TokenStatus = 'active' | 'expired' | 'revoked';
+export interface Token {
+    accessToken: string;
+    refreshToken: string;
+    userId: string;
+    expires?: Date;
+    issuedAt?: Date;
+    lastSeenAt?: Date;
+    status?: TokenStatus;
+    ruid?: string;
+    clientId?: string;
+    /**
+     * Optional session partition key. Token stores may use `domain` and `fingerprint`
+     * to replace previous sessions that match the same bucket.
+     */
+    domain?: string;
+    /**
+     * Optional device/session fingerprint used together with `domain` for session bucketing.
+     */
+    fingerprint?: string;
+    label?: string;
+    browser?: string;
+    device?: string;
+    ip?: string;
+    os?: string;
+    scope?: string[];
+    loginType?: string;
+    refreshTtlSeconds?: number;
+    sessionCookie?: boolean;
+}
+export interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface OAuthClient {
+    clientId: string;
+    clientSecret?: string;
+    hasSecret?: boolean;
+    firstParty?: boolean;
+    metadata?: Record<string, unknown>;
+    name?: string;
+    redirectUris: string[];
+    scope?: string[];
+}
+export interface AuthCodeData {
+    code: string;
+    clientId: string;
+    codeChallenge?: string;
+    codeChallengeMethod?: 'plain' | 'S256';
+    expiresAt: Date;
+    metadata?: Record<string, unknown>;
+    redirectUri?: string;
+    scope?: string[];
+    userId: AuthIdentifier;
+}
+export type AuthCode = AuthCodeData;
+export type AuthCodeRequest = Omit<AuthCodeData, 'code' | 'expiresAt'> & {
+    code?: string;
+    expiresInSeconds?: number;
+};
+export interface OAuthStartParams {
+    provider: string;
+    redirectUri?: string;
+    scope?: string | string[];
+    state?: string;
+    extras?: Record<string, unknown>;
+}
+export interface OAuthStartResult extends Record<string, unknown> {
+    url: string;
+    state?: string;
+    codeVerifier?: string;
+}
+export interface OAuthCallbackParams {
+    provider: string;
+    query: Record<string, string | string[]>;
+    body: Record<string, unknown>;
+}
+export interface OAuthCallbackResult<PublicUser> extends Record<string, unknown> {
+    user: PublicUser;
+    tokens?: {
+        accessToken: string;
+        refreshToken: string;
+    };
+}
+export type TusMetadata = Record<string, string>;
+export interface TusUploadRecord {
+    id: string;
+    length: number;
+    offset: number;
+    metadata: TusMetadata;
+    userId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    completedAt?: Date;
+}
+export interface TusCreateUploadInput {
+    id?: string;
+    length: number;
+    metadata: TusMetadata;
+    userId?: string;
+}
+export interface TusAppendInput {
+    uploadId: string;
+    offset: number;
+    chunk: Buffer;
+}

package/dist/esm/common/types.js

@@ -0,0 +1,9 @@
+/**
+ * Shared type definitions used by both api-server-base and api-client-base.
+ * This file contains only `type`/`interface` declarations — no runtime code.
+ * Both packages reference these types via `import type`. Note that TypeScript
+ * does NOT inline `import type` references in emitted `.d.ts` files — the
+ * path aliases persist. Source files therefore keep inline type definitions
+ * to avoid broken references for consumers of the published packages.
+ */
+export {};