@bardioc/app-sdk 0.4.11 → 1.0.0

package/dist/contract.js

@@ -0,0 +1,150 @@
+import * as z from 'zod/mini';
+export const PROTOCOL_VERSION = 1;
+const DEFAULT_TIMEOUT_MS = 30_000;
+const MAX_MENU_DEPTH = 3;
+const call = (input) => ({
+    returns: (timeoutMs = DEFAULT_TIMEOUT_MS) => ({
+        kind: 'call',
+        input,
+        timeoutMs,
+    }),
+});
+const stream = (input) => ({
+    emits: () => ({ kind: 'stream', input, timeoutMs: DEFAULT_TIMEOUT_MS }),
+});
+const text = z.string().check(z.minLength(1));
+const optionalText = z.optional(z.string());
+const optionalFlag = z.optional(z.boolean());
+const count = z.int().check(z.gte(0));
+// Checked by brand: a transferred buffer belongs to whichever realm received it.
+const bytes = z.custom(value => Object.prototype.toString.call(value) === '[object ArrayBuffer]', { message: 'Expected an ArrayBuffer' });
+// Resolved like the BFF resolves it, so `/x/../auth` cannot reach the shell's session.
+const isAppPath = (path) => path.startsWith('/') && !/^\/auth(\/|$)/i.test(new URL(path, 'http://bff').pathname);
+const Command = z.strictObject({
+    id: text,
+    title: optionalText,
+    disabled: optionalFlag,
+    checked: optionalFlag,
+});
+const MenuItem = z.lazy(() => z.discriminatedUnion('type', [
+    z.strictObject({
+        type: z.literal('command'),
+        commandId: text,
+        label: optionalText,
+        leftIcon: optionalText,
+        separatorAbove: optionalFlag,
+        shortcut: optionalText,
+        variant: z.optional(z.enum(['default', 'destructive'])),
+    }),
+    z.strictObject({
+        type: z.literal('submenu'),
+        label: text,
+        leftIcon: optionalText,
+        separatorAbove: optionalFlag,
+        contentWidth: optionalText,
+        items: z.array(MenuItem),
+    }),
+]));
+const depthOf = (items) => Math.max(0, ...items.map(item => (item.type === 'submenu' ? 1 + depthOf(item.items) : 1)));
+const MenuRoot = z.strictObject({
+    label: text,
+    kind: z.optional(z.enum(['app', 'menu'])),
+    leftIcon: optionalText,
+    contentWidth: optionalText,
+    items: z.array(MenuItem),
+});
+const Menu = z.array(MenuRoot).check(z.refine(roots => roots.every(root => depthOf(root.items) <= MAX_MENU_DEPTH), {
+    message: `menus nest at most ${MAX_MENU_DEPTH} levels deep`,
+}));
+const Notify = z.strictObject({
+    message: text,
+    level: z.enum(['success', 'error', 'info', 'warning']),
+});
+const Shortcut = z.strictObject({
+    code: text,
+    ctrlKey: z.boolean(),
+    metaKey: z.boolean(),
+    altKey: z.boolean(),
+    shiftKey: z.boolean(),
+});
+const BffRequest = z
+    .strictObject({
+    path: z
+        .string()
+        .check(z.refine(isAppPath, { message: 'path must start with / outside /auth' })),
+    method: z.optional(z.enum(['GET', 'POST', 'PUT', 'PATCH', 'DELETE'])),
+    body: z.optional(z.unknown()),
+    contentType: optionalText,
+    scopeId: z.optional(text),
+    scopePolicy: z.optional(z.enum(['none', 'optional', 'required'])),
+})
+    .check(z.refine(({ scopeId, scopePolicy }) => !(scopeId && scopePolicy === 'none'), {
+    message: 'scopePolicy none takes no scopeId',
+}));
+const IdbKey = z.strictObject({ store: text, key: text });
+const IdbPut = z.strictObject({ store: text, key: text, value: z.unknown() });
+const IdbQuery = z.strictObject({
+    store: text,
+    prefix: optionalText,
+    limit: z.optional(count),
+});
+const GraphFilter = z.strictObject({ types: z.array(text).check(z.minLength(1)) });
+const AppSource = z.enum(['uploaded', 'dev']);
+const AppId = z.strictObject({ id: text });
+const AppRecord = z.strictObject({
+    id: text,
+    name: text,
+    version: text,
+    launchUrl: text,
+    source: AppSource,
+    description: optionalText,
+    icon: optionalText,
+    appId: optionalText,
+    bundleSize: z.optional(count),
+    fileCount: z.optional(count),
+});
+const AppUpload = z.strictObject({
+    alias: text,
+    name: text,
+    files: z.array(z.strictObject({ path: text, content: bytes })).check(z.minLength(1)),
+    appId: optionalText,
+    source: z.optional(AppSource),
+});
+export const GRAPH_EVENT_TYPES = [
+    'CREATE',
+    'REPLACE',
+    'UPDATE',
+    'CONNECT',
+    'DISCONNECT',
+    'DELETE',
+    'WRITE_TIMESERIES',
+];
+/** Methods an app calls on its host. */
+export const APP_METHODS = {
+    'ui.notify': call(Notify).returns(),
+    'ui.setCommands': call(z.strictObject({ commands: z.array(Command) })).returns(),
+    'ui.setMenu': call(z.strictObject({ menu: z.nullable(Menu) })).returns(),
+    'ui.setActiveTab': call(z.strictObject({ activeTab: z.nullable(z.string()) })).returns(),
+    'ui.shortcut': call(Shortcut).returns(),
+    'bff.request': call(BffRequest).returns(60_000),
+    'events.graph': stream(GraphFilter).emits(),
+    'idb.get': call(IdbKey).returns(),
+    'idb.put': call(IdbPut).returns(),
+    'idb.delete': call(IdbKey).returns(),
+    'idb.query': call(IdbQuery).returns(),
+    'apps.list': call(z.undefined()).returns(),
+    'apps.get': call(AppId).returns(),
+    'apps.save': call(AppRecord).returns(),
+    'apps.delete': call(AppId).returns(),
+    'apps.upload': call(AppUpload).returns(120_000),
+    'apps.launch': call(AppId).returns(),
+};
+/** Methods a host calls on its app. */
+export const HOST_METHODS = {
+    'ui.command': call(z.strictObject({ id: text })).returns(),
+};
+/** The BFF event-stream filter matching any of `types`. */
+export function graphEventFilter(types) {
+    const predicates = types.map(type => `(element.ogit/_type=${type})`);
+    return predicates.length > 1 ? `|${predicates.join('')}` : predicates.join('');
+}

package/dist/dev-idb.d.ts

@@ -0,0 +1,10 @@
+import type { AppMethods, IdbEntry, Params } from './contract.js';
+type In<K extends keyof AppMethods> = Params<AppMethods[K]>;
+/** The host's app storage, kept in this browser's IndexedDB while running standalone. */
+export declare function devIdb(appId: string): {
+    get: ({ store, key }: In<"idb.get">) => Promise<IdbEntry<unknown> | null>;
+    put: ({ store, key, value }: In<"idb.put">) => Promise<void>;
+    delete: ({ store, key }: In<"idb.delete">) => Promise<void>;
+    query: ({ store, prefix, limit }: In<"idb.query">) => Promise<IdbEntry<unknown>[]>;
+};
+export {};

package/dist/dev-idb.js

@@ -0,0 +1,42 @@
+const ENTRIES = 'entries';
+// Sorts after every key that starts with a given prefix.
+const PREFIX_END = String.fromCharCode(0xffff);
+const settled = (request) => new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+});
+function open(name) {
+    const request = indexedDB.open(name, 1);
+    request.onupgradeneeded = () => request.result.createObjectStore(ENTRIES, { keyPath: ['store', 'key'] });
+    return settled(request);
+}
+const toEntry = ({ key, value, updatedAt }) => ({ key, value, updatedAt });
+/** The host's app storage, kept in this browser's IndexedDB while running standalone. */
+export function devIdb(appId) {
+    // Opened on first use: most apps never touch their store.
+    let db;
+    const entries = async (mode) => {
+        db ??= open(`bardioc-dev:${appId}`);
+        return (await db).transaction(ENTRIES, mode).objectStore(ENTRIES);
+    };
+    return {
+        get: async ({ store, key }) => {
+            const row = await settled((await entries('readonly')).get([store, key]));
+            return row ? toEntry(row) : null;
+        },
+        put: async ({ store, key, value }) => {
+            const row = { store, key, value, updatedAt: Date.now() };
+            await settled((await entries('readwrite')).put(row));
+        },
+        delete: async ({ store, key }) => {
+            await settled((await entries('readwrite')).delete([store, key]));
+        },
+        query: async ({ store, prefix = '', limit }) => {
+            if (limit === 0)
+                return [];
+            const range = IDBKeyRange.bound([store, prefix], [store, prefix + PREFIX_END]);
+            const rows = await settled((await entries('readonly')).getAll(range, limit));
+            return rows.map(toEntry);
+        },
+    };
+}

package/dist/dev-proxy.js

@@ -1,4 +1,5 @@
 import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
 import { resolveDevAuthEnv } from './dev-auth-env.js';
 // BFF mount of the dynamic relay to published REST backends.
 const RELAY_PATH_PREFIX = '/relay';
@@ -113,12 +114,16 @@ export function createDevAuthProxyHandler(options) {
             sendJson(res, 400, { error: 'invalid_body' }, { allowOrigin, requestOrigin });
             return;
         }
+        // A client that goes away (a closed event stream) ends the upstream request too.
+        const upstream = new AbortController();
+        res.on('close', () => upstream.abort());
         try {
             const upstreamRes = await fetch(upstreamUrl, {
                 method: req.method ?? 'GET',
                 headers,
                 body: body.length > 0 ? new Uint8Array(body) : undefined,
                 cache: 'no-store',
+                signal: upstream.signal,
             });
             applyCors(res, allowOrigin, requestOrigin);
             res.statusCode = upstreamRes.status;
@@ -127,11 +132,20 @@ export function createDevAuthProxyHandler(options) {
             if (upstreamContentType) {
                 res.setHeader('Content-Type', upstreamContentType);
             }
-            const responseBody = Buffer.from(await upstreamRes.arrayBuffer());
-            res.end(responseBody);
+            // Streamed, so server-sent events reach the app as they arrive.
+            if (upstreamRes.body) {
+                for await (const chunk of Readable.fromWeb(upstreamRes.body)) {
+                    res.write(chunk);
+                }
+            }
+            res.end();
         }
         catch {
-            sendJson(res, 502, { error: 'upstream_unavailable' }, { allowOrigin, requestOrigin });
+            // Once streaming, the only failure left is the client leaving.
+            if (res.headersSent)
+                res.end();
+            else
+                sendJson(res, 502, { error: 'upstream_unavailable' }, { allowOrigin, requestOrigin });
         }
     };
 }

package/dist/dev.d.ts

@@ -1,14 +1,18 @@
-export interface DevBridgeOptions {
-    /** Base URL prepended to SDK transport paths. Defaults to `/rest`. */
-    apiBaseUrl?: string;
-    /**
-     * The app's ogit/Auth/Application id, sent as X-App-ID on scoped calls like the host
-     * does. Needed for `transport.backend(...)`: the relay authorizes on the exchanged app
-     * identity and refuses calls without it.
-     */
-    appId?: string;
-    debug?: boolean;
-}
+import { type HostHandlers } from './serve.js';
 export declare function isInsideIframe(): boolean;
 export declare function isDevStandalone(): boolean;
-export declare function installDevBridge(options?: DevBridgeOptions): () => void;
+export interface DevHostOptions {
+    /** The app's manifest id, handed to the app as `context.appId`. */
+    appId: string;
+    /** The app's ogit/Auth/Application id, sent as `X-App-ID` on scoped calls; defaults to `appId`. */
+    clientId?: string;
+    /** Where the dev-auth proxy answers `/rest`. Default: `/rest` on this origin. */
+    apiBaseUrl?: string;
+}
+/** The dev host's answers to every app method. */
+export declare function devHandlers({ appId, clientId, apiBaseUrl, }: DevHostOptions): HostHandlers;
+/**
+ * Stands in for the host while the app runs standalone in development: `connect()` reaches it
+ * the way it reaches the host, and BFF calls go through the dev-auth proxy.
+ */
+export declare function installDevHost(options: DevHostOptions): () => void;

package/dist/dev.js

@@ -1,132 +1,114 @@
-import { SDK_MSG } from './protocol.js';
-function getBaseUrl(baseUrl) {
-    return baseUrl ?? '/rest';
-}
+import { GRAPH_EVENT_TYPES, graphEventFilter, } from './contract.js';
+import { devIdb } from './dev-idb.js';
+import { BardiocError } from './errors.js';
+import { acceptApp, serve } from './serve.js';
 export function isInsideIframe() {
-    const currentWindow = globalThis;
-    return currentWindow.parent !== currentWindow;
+    return window.parent !== window;
 }
 export function isDevStandalone() {
-    const metaEnv = import.meta.env;
-    return Boolean(metaEnv?.DEV) && !isInsideIframe();
+    const env = import.meta.env;
+    return Boolean(env?.DEV) && !isInsideIframe();
 }
-export function installDevBridge(options = {}) {
-    const apiBaseUrl = getBaseUrl(options.apiBaseUrl);
-    const appId = options.appId?.trim() || undefined;
-    const debug = options.debug ?? false;
-    const origin = window.location.origin;
-    const log = (...args) => {
-        if (debug) {
-            console.log('[bardioc-dev-bridge]', ...args);
-        }
-    };
-    function reply(id, payload) {
-        window.postMessage({ type: SDK_MSG.RESPONSE, id, payload }, origin);
+async function readBody(response) {
+    const type = response.headers.get('content-type') ?? '';
+    if (type.includes('application/json')) {
+        const text = await response.text();
+        return text ? JSON.parse(text) : null;
     }
-    function replyError(id, error) {
-        window.postMessage({ type: SDK_MSG.RESPONSE, id, payload: null, error }, origin);
-    }
-    function ack(id, payload) {
-        window.postMessage({ type: SDK_MSG.INIT_ACK, id, payload }, origin);
-    }
-    async function handleTransport(payload) {
-        const headers = new Headers();
-        const body = payload.body == null
-            ? undefined
-            : payload.contentType === 'application/json'
-                ? JSON.stringify(payload.body)
-                : payload.body;
-        if (body && payload.contentType) {
-            headers.set('Content-Type', payload.contentType);
-        }
-        // BFF rejects /bardioc/ calls without this CSRF marker header.
-        headers.set('X-Requested-With', 'XMLHttpRequest');
-        // Mirror the host bridge: a required scope without an id is rejected locally, and a
-        // resolved scope id is always forwarded regardless of policy. Standalone has no
-        // instance, so there is no instance-based fallback here.
-        const resolvedScopeId = payload.scopeId;
-        if (payload.scopePolicy === 'required' && !resolvedScopeId) {
-            throw new Error('Scope ID is required');
+    if (type === '' || type.startsWith('text/'))
+        return (await response.text()) || null;
+    return response.blob();
+}
+const unavailable = () => {
+    throw new BardiocError('unavailable', 'Installed apps live in the Bardioc host');
+};
+/** The dev host's answers to every app method. */
+export function devHandlers({ appId, clientId = appId, apiBaseUrl = '/rest', }) {
+    const idb = devIdb(appId);
+    const request = async ({ path, method = 'GET', body, contentType, scopeId, scopePolicy }, signal) => {
+        if (scopePolicy === 'required' && !scopeId) {
+            throw new BardiocError('invalid', 'scopeId is required: a dev session has no instance');
         }
-        if (resolvedScopeId) {
-            headers.set('X-Scope-ID', resolvedScopeId);
-            // The BFF app-token exchange rejects X-App-ID without X-Scope-ID, so a scopeless
-            // call goes out as the user, exactly as the host sends it.
-            if (appId) {
-                headers.set('X-App-ID', appId);
-            }
+        const headers = new Headers({ 'X-Requested-With': 'XMLHttpRequest' });
+        if (contentType && body !== undefined)
+            headers.set('Content-Type', contentType);
+        if (scopeId) {
+            headers.set('X-Scope-ID', scopeId);
+            headers.set('X-App-ID', clientId);
         }
-        const url = `${apiBaseUrl}${payload.path}`;
-        log('[transport]', payload.method ?? 'GET', url);
-        const response = await fetch(url, {
-            method: payload.method ?? 'GET',
+        const encoded = contentType === 'application/json' ? JSON.stringify(body) : body;
+        const response = await fetch(`${apiBaseUrl}${path}`, {
+            method,
             headers,
-            body,
+            body: body === undefined ? undefined : encoded,
             credentials: 'include',
             cache: 'no-store',
+            signal,
         });
-        const contentType = response.headers.get('content-type') ?? '';
-        if (!response.ok) {
-            const text = await response.text();
-            const responsePayload = contentType.includes('application/json') && text ? JSON.parse(text) : text;
-            const err = new Error(`Transport ${payload.path} failed: ${response.status}`);
-            Object.assign(err, { status: response.status, responsePayload });
-            throw err;
-        }
-        // Same response typing as the host: JSON is parsed, empty/plain text becomes a string,
-        // anything binary (zip, octet-stream, images/svg, …) round-trips as a Blob.
-        if (contentType.includes('application/json')) {
-            const text = await response.text();
-            return text ? JSON.parse(text) : null;
-        }
-        if (contentType === '' || contentType.startsWith('text/')) {
-            const text = await response.text();
-            return text || null;
-        }
-        return response.blob();
-    }
-    async function handleKernelProxy(payload) {
-        if (payload.kernelType === 'PING') {
-            return { pong: true };
-        }
-        if (payload.kernelType === 'GET_SESSION_STATE') {
-            return { authenticated: true };
-        }
-        throw new Error(`Kernel message ${payload.kernelType} not supported in dev bridge`);
-    }
-    async function onMessage(event) {
-        if (event.origin !== origin) {
-            return;
-        }
-        const data = event.data;
-        if (!data || typeof data.type !== 'string' || !data.id) {
-            return;
-        }
-        if (data.type === SDK_MSG.RESPONSE || data.type === SDK_MSG.INIT_ACK) {
-            return;
-        }
-        log('handle', data.type, data.id);
-        try {
-            switch (data.type) {
-                case SDK_MSG.INIT:
-                    ack(data.id, { appId: null, instanceId: null });
-                    return;
-                case SDK_MSG.NOTIFY:
-                    return;
-                case SDK_MSG.TRANSPORT:
-                    reply(data.id, await handleTransport(data.payload));
-                    return;
-                case SDK_MSG.KERNEL_PROXY:
-                    reply(data.id, await handleKernelProxy(data.payload));
-                    return;
-                default:
-                    replyError(data.id, `Dev bridge does not implement ${data.type}`);
-            }
-        }
-        catch (error) {
-            replyError(data.id, error instanceof Error ? error.message : 'unknown error');
+        const payload = await readBody(response);
+        if (!response.ok)
+            throw BardiocError.fromStatus(response.status, `HTTP ${response.status}`, payload);
+        return payload;
+    };
+    const graphEvents = ({ types }, emit) => {
+        const query = new URLSearchParams({ filter: graphEventFilter(types) });
+        const source = new EventSource(`${apiBaseUrl}/events?${query}`, { withCredentials: true });
+        for (const type of GRAPH_EVENT_TYPES) {
+            source.addEventListener(type, event => emit(JSON.parse(event.data)));
         }
-    }
-    window.addEventListener('message', onMessage);
-    return () => window.removeEventListener('message', onMessage);
+        return () => source.close();
+    };
+    return {
+        'ui.notify': () => undefined,
+        'ui.setCommands': () => undefined,
+        'ui.setMenu': () => undefined,
+        'ui.setActiveTab': () => undefined,
+        'ui.shortcut': () => undefined,
+        'bff.request': request,
+        'events.graph': graphEvents,
+        'idb.get': idb.get,
+        'idb.put': idb.put,
+        'idb.delete': idb.delete,
+        'idb.query': idb.query,
+        'apps.list': unavailable,
+        'apps.get': unavailable,
+        'apps.save': unavailable,
+        'apps.delete': unavailable,
+        'apps.upload': unavailable,
+        'apps.launch': unavailable,
+    };
+}
+const DARK = '(prefers-color-scheme: dark)';
+const osConfig = () => ({
+    theme: matchMedia(DARK).matches ? 'dark' : 'light',
+    language: navigator.language.split('-')[0] ?? 'en',
+    tabId: 'dev',
+    windowId: 'dev',
+    instanceId: null,
+});
+/**
+ * Stands in for the host while the app runs standalone in development: `connect()` reaches it
+ * the way it reaches the host, and BFF calls go through the dev-auth proxy.
+ */
+export function installDevHost(options) {
+    const handlers = devHandlers(options);
+    const context = () => ({ appId: options.appId, host: 'dev', osConfig: osConfig() });
+    let connection;
+    const stopAccepting = acceptApp({
+        source: () => window,
+        origin: location.origin,
+        context,
+        onConnect: port => {
+            connection?.close();
+            connection = serve(port, handlers);
+        },
+    });
+    const scheme = matchMedia(DARK);
+    const onSchemeChange = () => connection?.emit('context.changed', context());
+    scheme.addEventListener('change', onSchemeChange);
+    return () => {
+        stopAccepting();
+        scheme.removeEventListener('change', onSchemeChange);
+        connection?.close();
+    };
 }

package/dist/errors.d.ts

@@ -1,27 +1,26 @@
-/** Base SDK error class with structured error information */
-export declare class SdkError extends Error {
-    code: string;
-    statusCode?: number | undefined;
-    context?: Record<string, unknown> | undefined;
-    constructor(message: string, code: string, statusCode?: number | undefined, context?: Record<string, unknown> | undefined);
+export type ErrorCode = 'invalid' | 'unauthenticated' | 'forbidden' | 'not_found' | 'conflict' | 'rate_limited' | 'unavailable' | 'timeout' | 'cancelled' | 'protocol' | 'internal';
+/** An error as it crosses the wire. */
+export interface WireError {
+    code: ErrorCode;
+    message: string;
+    status?: number;
+    details?: unknown;
 }
-/** Request timeout error */
-export declare class TimeoutError extends SdkError {
-    constructor(operation: string, timeoutMs: number);
-}
-/** Network/HTTP error (4xx, 5xx) */
-export declare class NetworkError extends SdkError {
-    constructor(message: string, statusCode: number);
-}
-/** Invalid parameters or validation error */
-export declare class ValidationError extends SdkError {
-    constructor(message: string, field?: string);
-}
-/** Missing permissions error */
-export declare class PermissionError extends SdkError {
-    constructor(permission: string);
-}
-/** Entity not found error (404) */
-export declare class EntityNotFoundError extends SdkError {
-    constructor(id: string);
+/** The one error every SDK and host operation rejects with. */
+export declare class BardiocError extends Error {
+    readonly code: ErrorCode;
+    readonly name = "BardiocError";
+    readonly status?: number;
+    readonly details?: unknown;
+    readonly method?: string;
+    constructor(code: ErrorCode, message: string, options?: {
+        status?: number;
+        details?: unknown;
+        method?: string;
+    });
+    /** Classifies an HTTP failure by its status. */
+    static fromStatus(status: number, message: string, details?: unknown): BardiocError;
+    static from(error: unknown): BardiocError;
+    static fromWire({ code, message, status, details }: WireError, method?: string): BardiocError;
+    toWire(): WireError;
 }

package/dist/errors.js

@@ -1,57 +1,42 @@
-/** Base SDK error class with structured error information */
-export class SdkError extends Error {
+const STATUS_CODES = {
+    400: 'invalid',
+    401: 'unauthenticated',
+    403: 'forbidden',
+    404: 'not_found',
+    408: 'timeout',
+    409: 'conflict',
+    422: 'invalid',
+    429: 'rate_limited',
+    504: 'timeout',
+};
+/** The one error every SDK and host operation rejects with. */
+export class BardiocError extends Error {
     code;
-    statusCode;
-    context;
-    constructor(message, code, statusCode, context) {
+    name = 'BardiocError';
+    status;
+    details;
+    method;
+    constructor(code, message, options = {}) {
         super(message);
         this.code = code;
-        this.statusCode = statusCode;
-        this.context = context;
-        this.name = 'SdkError';
-        Object.setPrototypeOf(this, SdkError.prototype);
+        this.status = options.status;
+        this.details = options.details;
+        this.method = options.method;
     }
-}
-/** Request timeout error */
-export class TimeoutError extends SdkError {
-    constructor(operation, timeoutMs) {
-        super(`Operation '${operation}' timed out after ${timeoutMs}ms`, 'TIMEOUT', undefined, {
-            operation,
-            timeoutMs,
-        });
-        this.name = 'TimeoutError';
-        Object.setPrototypeOf(this, TimeoutError.prototype);
-    }
-}
-/** Network/HTTP error (4xx, 5xx) */
-export class NetworkError extends SdkError {
-    constructor(message, statusCode) {
-        super(message, 'NETWORK_ERROR', statusCode);
-        this.name = 'NetworkError';
-        Object.setPrototypeOf(this, NetworkError.prototype);
+    /** Classifies an HTTP failure by its status. */
+    static fromStatus(status, message, details) {
+        const code = STATUS_CODES[status] ?? (status >= 500 ? 'unavailable' : 'invalid');
+        return new BardiocError(code, message, { status, details });
     }
-}
-/** Invalid parameters or validation error */
-export class ValidationError extends SdkError {
-    constructor(message, field) {
-        super(message, 'VALIDATION_ERROR', 400, field ? { field } : undefined);
-        this.name = 'ValidationError';
-        Object.setPrototypeOf(this, ValidationError.prototype);
+    static from(error) {
+        if (error instanceof BardiocError)
+            return error;
+        return new BardiocError('internal', error instanceof Error ? error.message : String(error));
     }
-}
-/** Missing permissions error */
-export class PermissionError extends SdkError {
-    constructor(permission) {
-        super(`Missing required permission: ${permission}`, 'PERMISSION_ERROR', 403, { permission });
-        this.name = 'PermissionError';
-        Object.setPrototypeOf(this, PermissionError.prototype);
+    static fromWire({ code, message, status, details }, method) {
+        return new BardiocError(code, message, { status, details, method });
     }
-}
-/** Entity not found error (404) */
-export class EntityNotFoundError extends SdkError {
-    constructor(id) {
-        super(`Entity not found: ${id}`, 'ENTITY_NOT_FOUND', 404, { id });
-        this.name = 'EntityNotFoundError';
-        Object.setPrototypeOf(this, EntityNotFoundError.prototype);
+    toWire() {
+        return { code: this.code, message: this.message, status: this.status, details: this.details };
     }
 }