@moneysiren/app 0.1.0-alpha.9

package/dist/packages/db/src/schema.js

@@ -0,0 +1,120 @@
+export const REQUIRED_TABLES = [
+    "providers",
+    "provider_accounts",
+    "usage_snapshots",
+    "billing_snapshots",
+    "service_health_snapshots",
+    "cost_estimates",
+    "alerts",
+    "report_runs",
+];
+export const INITIAL_SCHEMA_SQL = `
+PRAGMA foreign_keys = ON;
+
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  id TEXT PRIMARY KEY,
+  applied_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS providers (
+  id TEXT PRIMARY KEY,
+  provider_key TEXT NOT NULL UNIQUE,
+  display_name TEXT NOT NULL,
+  connector_version TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS provider_accounts (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  account_label TEXT NOT NULL,
+  account_ref TEXT NOT NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  UNIQUE(provider_id, account_ref)
+);
+
+CREATE TABLE IF NOT EXISTS usage_snapshots (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  provider_account_id TEXT REFERENCES provider_accounts(id) ON DELETE SET NULL,
+  collected_at TEXT NOT NULL,
+  service TEXT NOT NULL,
+  metric TEXT NOT NULL,
+  unit TEXT NOT NULL,
+  value REAL NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS billing_snapshots (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  provider_account_id TEXT REFERENCES provider_accounts(id) ON DELETE SET NULL,
+  collected_at TEXT NOT NULL,
+  period_start TEXT NOT NULL,
+  period_end TEXT NOT NULL,
+  amount_minor INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS service_health_snapshots (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  collected_at TEXT NOT NULL,
+  service TEXT NOT NULL,
+  region TEXT,
+  status TEXT NOT NULL,
+  message TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS cost_estimates (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+  provider_account_id TEXT REFERENCES provider_accounts(id) ON DELETE SET NULL,
+  collected_at TEXT NOT NULL,
+  period_start TEXT NOT NULL,
+  period_end TEXT NOT NULL,
+  estimated_amount_minor INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  confidence TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS alerts (
+  id TEXT PRIMARY KEY,
+  provider_id TEXT REFERENCES providers(id) ON DELETE SET NULL,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  severity TEXT NOT NULL,
+  category TEXT NOT NULL,
+  title TEXT NOT NULL,
+  message TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE TABLE IF NOT EXISTS report_runs (
+  id TEXT PRIMARY KEY,
+  created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  report_date TEXT NOT NULL,
+  language TEXT NOT NULL,
+  delivery_target TEXT NOT NULL,
+  status TEXT NOT NULL,
+  metadata_json TEXT NOT NULL DEFAULT '{}'
+);
+
+CREATE INDEX IF NOT EXISTS idx_usage_snapshots_collected_at ON usage_snapshots(collected_at);
+CREATE INDEX IF NOT EXISTS idx_billing_snapshots_period ON billing_snapshots(period_start, period_end);
+CREATE INDEX IF NOT EXISTS idx_service_health_snapshots_collected_at ON service_health_snapshots(collected_at);
+CREATE INDEX IF NOT EXISTS idx_cost_estimates_period ON cost_estimates(period_start, period_end);
+CREATE INDEX IF NOT EXISTS idx_alerts_created_at ON alerts(created_at);
+`.trim();
+export const READ_MODEL_INDEX_SQL = `
+CREATE INDEX IF NOT EXISTS idx_billing_snapshots_latest_logical
+  ON billing_snapshots(provider_id, provider_account_id, period_start, period_end, currency, collected_at, id);
+CREATE INDEX IF NOT EXISTS idx_cost_estimates_latest_logical
+  ON cost_estimates(provider_id, provider_account_id, period_start, period_end, currency, collected_at, id);
+`.trim();
+//# sourceMappingURL=schema.js.map

package/dist/packages/db/src/sqlite-bin.d.ts

@@ -0,0 +1,3 @@
+export declare const SQLITE_BIN_ENV_KEY = "MONEYSIREN_SQLITE_BIN";
+export declare function resolveSqliteBin(env?: NodeJS.ProcessEnv): string;
+//# sourceMappingURL=sqlite-bin.d.ts.map

package/dist/packages/db/src/sqlite-bin.js

@@ -0,0 +1,16 @@
+import { existsSync } from "node:fs";
+export const SQLITE_BIN_ENV_KEY = "MONEYSIREN_SQLITE_BIN";
+const DEFAULT_POSIX_SQLITE_BIN = "/usr/bin/sqlite3";
+const PATH_SQLITE_BIN = "sqlite3";
+const WINDOWS_PATH_SQLITE_BIN = "sqlite3.exe";
+export function resolveSqliteBin(env = process.env) {
+    const configuredBin = env[SQLITE_BIN_ENV_KEY]?.trim();
+    if (configuredBin !== undefined && configuredBin.length > 0) {
+        return configuredBin;
+    }
+    if (existsSync(DEFAULT_POSIX_SQLITE_BIN)) {
+        return DEFAULT_POSIX_SQLITE_BIN;
+    }
+    return process.platform === "win32" ? WINDOWS_PATH_SQLITE_BIN : PATH_SQLITE_BIN;
+}
+//# sourceMappingURL=sqlite-bin.js.map

package/dist/packages/local-api/src/index.d.ts

@@ -0,0 +1,2 @@
+export { startLocalApiServer, type LocalApiReaders, type LocalApiServer, type LocalApiServerOptions, } from "./server.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/local-api/src/index.js

@@ -0,0 +1,2 @@
+export { startLocalApiServer, } from "./server.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/local-api/src/server.d.ts

@@ -0,0 +1,36 @@
+import { type Server } from "node:http";
+import { type NotificationPreferences, type ReadTrayMenuModelOptions } from "../../view-model/src/index.js";
+import { type LocalRuntime, type RuntimeLockOptions } from "../../runtime/src/index.js";
+export interface LocalApiReaders {
+    readSummary: () => Promise<unknown>;
+    readTodayLiveView: () => Promise<unknown>;
+    readNotificationDigest: () => Promise<unknown>;
+    readTrayMenuModel: () => Promise<unknown>;
+    readNotificationPreferences: () => Promise<NotificationPreferences>;
+    writeNotificationPreferences: (preferences: NotificationPreferences) => Promise<NotificationPreferences>;
+}
+export interface LocalApiServerOptions {
+    host?: string;
+    port?: number;
+    now?: () => Date;
+    version?: string;
+    viewModel?: ReadTrayMenuModelOptions;
+    readers?: Partial<LocalApiReaders>;
+    runtimeLock?: false | RuntimeLockOptions;
+    preferences?: {
+        cwd?: string;
+        env?: Record<string, string | undefined>;
+        path?: string;
+    };
+    localSessionToken?: string;
+}
+export interface LocalApiServer {
+    server: Server;
+    host: string;
+    port: number;
+    baseUrl: string;
+    runtime: LocalRuntime;
+    close: () => Promise<void>;
+}
+export declare function startLocalApiServer(options?: LocalApiServerOptions): Promise<LocalApiServer>;
+//# sourceMappingURL=server.d.ts.map

package/dist/packages/local-api/src/server.js

@@ -0,0 +1,310 @@
+import { createServer } from "node:http";
+import { parseNotificationPreferences, readNotificationDigest, readNotificationPreferencesFile, readOperationsOverview, readTodayLiveView, readTrayMenuModel, writeNotificationPreferencesFile, } from "../../view-model/src/index.js";
+import { assertLoopbackHost, isLoopbackHost, removeRuntimeLock, writeRuntimeLock, } from "../../runtime/src/index.js";
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 47831;
+const DEFAULT_VERSION = "0.1.0-alpha.9";
+export async function startLocalApiServer(options = {}) {
+    const host = options.host ?? DEFAULT_HOST;
+    const requestedPort = options.port ?? DEFAULT_PORT;
+    const version = options.version ?? DEFAULT_VERSION;
+    const now = options.now ?? (() => new Date());
+    assertLoopbackHost(host);
+    let runtime = {
+        pid: process.pid,
+        port: requestedPort,
+        baseUrl: `http://${host}:${requestedPort}`,
+        startedAt: now().toISOString(),
+        version,
+    };
+    const readers = createReaders(options, now);
+    const server = createServer((request, response) => {
+        void handleRequest(request, response, {
+            readers,
+            runtime: () => runtime,
+            localSessionToken: options.localSessionToken,
+        });
+    });
+    const port = await listenWithPortFallback(server, requestedPort, host);
+    const baseUrl = `http://${host}:${port}`;
+    runtime = {
+        ...runtime,
+        port,
+        baseUrl,
+    };
+    if (options.runtimeLock !== false) {
+        try {
+            await writeRuntimeLock(runtime, options.runtimeLock ?? {});
+        }
+        catch (error) {
+            await closeServer(server);
+            throw error;
+        }
+    }
+    return {
+        server,
+        host,
+        port,
+        baseUrl,
+        runtime,
+        close: async () => {
+            await closeServer(server);
+            if (options.runtimeLock !== false) {
+                await removeRuntimeLock(options.runtimeLock ?? {});
+            }
+        },
+    };
+}
+async function handleRequest(request, response, context) {
+    if (!applyLocalCors(request, response) || !assertLocalHostRequest(request, response)) {
+        return;
+    }
+    if (request.method === "OPTIONS") {
+        response.writeHead(204);
+        response.end();
+        return;
+    }
+    const url = requestUrl(request);
+    if (request.method === "PUT" && url.pathname === "/api/local/notification-preferences") {
+        if (!hasValidLocalSessionToken(request, context.localSessionToken)) {
+            sendJson(response, 401, localError("local_session_required", "A local session token is required for write endpoints."));
+            return;
+        }
+        try {
+            const preferences = parseNotificationPreferences(await readJsonBody(request));
+            sendJson(response, 200, {
+                generatedAt: new Date().toISOString(),
+                localOnly: true,
+                secretsReturned: false,
+                preferences: await context.readers.writeNotificationPreferences(preferences),
+            });
+        }
+        catch (error) {
+            sendJson(response, 400, localError("invalid_preferences", error instanceof Error ? error.message : "Invalid notification preferences."));
+        }
+        return;
+    }
+    if (request.method !== "GET") {
+        sendJson(response, 405, localError("method_not_allowed", "Only GET requests are supported for this endpoint."));
+        return;
+    }
+    if (url.pathname === "/api/local/health") {
+        sendJson(response, 200, {
+            generatedAt: new Date().toISOString(),
+            localOnly: true,
+            secretsReturned: false,
+            status: "ok",
+            loopbackOnly: true,
+            runtime: context.runtime(),
+        });
+        return;
+    }
+    if (url.pathname === "/api/local/runtime") {
+        sendJson(response, 200, {
+            generatedAt: new Date().toISOString(),
+            localOnly: true,
+            secretsReturned: false,
+            runtime: context.runtime(),
+        });
+        return;
+    }
+    if (url.pathname === "/api/local/summary") {
+        sendJson(response, 200, await context.readers.readSummary());
+        return;
+    }
+    if (url.pathname === "/api/local/today-live") {
+        sendJson(response, 200, await context.readers.readTodayLiveView());
+        return;
+    }
+    if (url.pathname === "/api/local/notification-digest") {
+        sendJson(response, 200, await context.readers.readNotificationDigest());
+        return;
+    }
+    if (url.pathname === "/api/local/tray-menu") {
+        sendJson(response, 200, await context.readers.readTrayMenuModel());
+        return;
+    }
+    if (url.pathname === "/api/local/notification-preferences") {
+        sendJson(response, 200, {
+            generatedAt: new Date().toISOString(),
+            localOnly: true,
+            secretsReturned: false,
+            preferences: await context.readers.readNotificationPreferences(),
+        });
+        return;
+    }
+    sendJson(response, 404, localError("not_found", "Endpoint not found."));
+}
+function createReaders(options, now) {
+    const viewModel = options.now === undefined
+        ? options.viewModel ?? {}
+        : {
+            ...(options.viewModel ?? {}),
+            now,
+        };
+    const preferenceOptions = notificationPreferenceFileOptions(options);
+    const readNotificationPreferences = options.readers?.readNotificationPreferences ??
+        (() => readNotificationPreferencesFile(preferenceOptions));
+    return {
+        readSummary: options.readers?.readSummary ?? (() => readOperationsOverview(viewModel)),
+        readTodayLiveView: options.readers?.readTodayLiveView ?? (() => readTodayLiveView(viewModel)),
+        readNotificationDigest: options.readers?.readNotificationDigest ?? (async () => readNotificationDigest({
+            ...viewModel,
+            notificationPreferences: await readNotificationPreferences(),
+        })),
+        readTrayMenuModel: options.readers?.readTrayMenuModel ?? (async () => readTrayMenuModel({
+            ...viewModel,
+            notificationPreferences: await readNotificationPreferences(),
+        })),
+        readNotificationPreferences,
+        writeNotificationPreferences: options.readers?.writeNotificationPreferences ??
+            ((preferences) => writeNotificationPreferencesFile(preferences, preferenceOptions)),
+    };
+}
+function notificationPreferenceFileOptions(options) {
+    const runtimeLock = options.runtimeLock === false ? undefined : options.runtimeLock;
+    const fileOptions = {};
+    const cwd = options.preferences?.cwd ?? runtimeLock?.cwd;
+    const env = options.preferences?.env ?? runtimeLock?.env;
+    const path = options.preferences?.path;
+    if (cwd !== undefined) {
+        fileOptions.cwd = cwd;
+    }
+    if (env !== undefined) {
+        fileOptions.env = env;
+    }
+    if (path !== undefined) {
+        fileOptions.path = path;
+    }
+    return fileOptions;
+}
+function applyLocalCors(request, response) {
+    const origin = request.headers.origin;
+    if (origin === undefined) {
+        return true;
+    }
+    if (!isLoopbackOrigin(origin)) {
+        sendJson(response, 403, localError("forbidden_origin", "Only loopback browser origins are allowed."));
+        return false;
+    }
+    response.setHeader("Access-Control-Allow-Origin", origin);
+    response.setHeader("Access-Control-Allow-Methods", "GET, PUT, OPTIONS");
+    response.setHeader("Access-Control-Allow-Headers", "Content-Type, X-MoneySiren-Local-Session");
+    response.setHeader("Vary", "Origin");
+    return true;
+}
+function hasValidLocalSessionToken(request, expectedToken) {
+    if (expectedToken === undefined || expectedToken.trim().length === 0) {
+        return false;
+    }
+    return request.headers["x-moneysiren-local-session"] === expectedToken;
+}
+async function readJsonBody(request) {
+    let body = "";
+    for await (const chunk of request) {
+        body += String(chunk);
+        if (body.length > 64_000) {
+            throw new Error("Local API request body is too large.");
+        }
+    }
+    return body.trim().length === 0 ? {} : JSON.parse(body);
+}
+function assertLocalHostRequest(request, response) {
+    const host = request.headers.host;
+    if (host === undefined || isLoopbackHost(hostnameFromHeader(host))) {
+        return true;
+    }
+    sendJson(response, 403, localError("forbidden_host", "Only loopback host headers are allowed."));
+    return false;
+}
+function requestUrl(request) {
+    return new URL(request.url ?? "/", `http://${request.headers.host ?? DEFAULT_HOST}`);
+}
+function sendJson(response, status, payload) {
+    response.statusCode = status;
+    response.setHeader("Content-Type", "application/json; charset=utf-8");
+    response.setHeader("Cache-Control", "no-store");
+    response.setHeader("X-Content-Type-Options", "nosniff");
+    response.end(`${JSON.stringify(payload)}\n`);
+}
+function localError(code, message) {
+    return {
+        generatedAt: new Date().toISOString(),
+        localOnly: true,
+        secretsReturned: false,
+        error: {
+            code,
+            message,
+        },
+    };
+}
+function isLoopbackOrigin(origin) {
+    try {
+        const parsed = new URL(origin);
+        return (parsed.protocol === "http:" || parsed.protocol === "https:") && isLoopbackHost(parsed.hostname);
+    }
+    catch {
+        return false;
+    }
+}
+function hostnameFromHeader(host) {
+    if (host.startsWith("[")) {
+        return host.slice(1, host.indexOf("]"));
+    }
+    return host.split(":")[0] ?? host;
+}
+async function listenWithPortFallback(server, port, host) {
+    if (port === 0) {
+        await listen(server, port, host);
+        return listenedPort(server, port);
+    }
+    const maxAttempts = 20;
+    let nextPort = port;
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        try {
+            await listen(server, nextPort, host);
+            return listenedPort(server, nextPort);
+        }
+        catch (error) {
+            if (!isAddressInUseError(error)) {
+                throw error;
+            }
+            nextPort += 1;
+        }
+    }
+    throw new Error(`No available MoneySiren local API port near ${port}.`);
+}
+function listen(server, port, host) {
+    return new Promise((resolve, reject) => {
+        const onError = (error) => {
+            server.off("listening", onListening);
+            reject(error);
+        };
+        const onListening = () => {
+            server.off("error", onError);
+            resolve();
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(port, host);
+    });
+}
+function listenedPort(server, fallbackPort) {
+    const address = server.address();
+    return typeof address === "object" && address !== null ? address.port : fallbackPort;
+}
+function isAddressInUseError(error) {
+    return error instanceof Error && "code" in error && error.code === "EADDRINUSE";
+}
+function closeServer(server) {
+    return new Promise((resolve, reject) => {
+        server.close((error) => {
+            if (error !== undefined) {
+                reject(error);
+                return;
+            }
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/packages/report/src/daily.d.ts

@@ -0,0 +1,24 @@
+export { renderKoreanDailyReport } from "./korean.js";
+export type DailyReportLanguage = "ko";
+export interface DailyReportInput {
+    reportDate: string;
+    generatedAt: string;
+    providerSummaries: readonly DailyProviderSummary[];
+    reportRunStatus: "rendered" | "sent" | "error";
+}
+export interface DailyProviderSummary {
+    provider: string;
+    displayName: string;
+    syncStatus: "ok" | "partial" | "error";
+    usageSnapshotCount: number;
+    billingSnapshotCount: number;
+    healthStatus: "ok" | "degraded" | "down" | "unknown";
+    estimatedAmountMinor: number;
+    currency: string;
+    alertCount: number;
+}
+export interface RenderDailyReportOptions {
+    lang: DailyReportLanguage;
+}
+export declare function renderDailyReport(input: DailyReportInput, options: RenderDailyReportOptions): string;
+//# sourceMappingURL=daily.d.ts.map

package/dist/packages/report/src/daily.js

@@ -0,0 +1,9 @@
+import { renderKoreanDailyReport } from "./korean.js";
+export { renderKoreanDailyReport } from "./korean.js";
+export function renderDailyReport(input, options) {
+    if (options.lang === "ko") {
+        return renderKoreanDailyReport(input);
+    }
+    throw new Error(`Unsupported daily report language: ${String(options.lang)}`);
+}
+//# sourceMappingURL=daily.js.map

package/dist/packages/report/src/index.d.ts

@@ -0,0 +1,4 @@
+export { renderDailyReport, type DailyProviderSummary, type DailyReportInput, type DailyReportLanguage, type RenderDailyReportOptions, } from "./daily.js";
+export { renderKoreanDailyReport } from "./korean.js";
+export { buildSlackReportPayload, sendSlackReport, SlackReportDeliveryError, type SendSlackReportOptions, type SlackReportDeliveryResult, type SlackReportPayload, type SlackReportTransport, type SlackReportTransportRequest, type SlackReportTransportResponse, } from "./slack.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/report/src/index.js

@@ -0,0 +1,4 @@
+export { renderDailyReport, } from "./daily.js";
+export { renderKoreanDailyReport } from "./korean.js";
+export { buildSlackReportPayload, sendSlackReport, SlackReportDeliveryError, } from "./slack.js";
+//# sourceMappingURL=index.js.map

package/dist/packages/report/src/korean.d.ts

@@ -0,0 +1,3 @@
+import type { DailyReportInput } from "./daily.js";
+export declare function renderKoreanDailyReport(input: DailyReportInput): string;
+//# sourceMappingURL=korean.d.ts.map

package/dist/packages/report/src/korean.js

@@ -0,0 +1,62 @@
+export function renderKoreanDailyReport(input) {
+    const lines = [
+        "*MoneySiren 일일 리포트*",
+        `- 날짜 ${input.reportDate}`,
+        `- 생성 ${input.generatedAt}`,
+        `- 리포트 상태 ${translateReportStatus(input.reportRunStatus)}`,
+        "",
+    ];
+    if (input.providerSummaries.length === 0) {
+        lines.push("---", "*요약*", "- 수집된 공급자 데이터가 없습니다.");
+        return lines.join("\n");
+    }
+    for (const summary of input.providerSummaries) {
+        lines.push("---", ...renderProviderSummary(summary), "");
+    }
+    return lines.join("\n").trimEnd();
+}
+function renderProviderSummary(summary) {
+    return [
+        `*${summary.displayName}*`,
+        `- 동기화 상태 ${translateSyncStatus(summary.syncStatus)}`,
+        `- 사용량 스냅샷 ${summary.usageSnapshotCount}건`,
+        `- 청구 스냅샷 ${summary.billingSnapshotCount}건`,
+        `- 서비스 상태 ${translateHealthStatus(summary.healthStatus)}`,
+        `- 예상 비용 ${formatMinorCurrency(summary.estimatedAmountMinor, summary.currency)}`,
+        `- 알림 ${summary.alertCount}건`,
+    ];
+}
+function translateReportStatus(status) {
+    if (status === "rendered") {
+        return "생성됨";
+    }
+    if (status === "sent") {
+        return "전송됨";
+    }
+    return "오류";
+}
+function translateSyncStatus(status) {
+    if (status === "ok") {
+        return "정상";
+    }
+    if (status === "partial") {
+        return "부분 성공";
+    }
+    return "오류";
+}
+function translateHealthStatus(status) {
+    if (status === "ok") {
+        return "정상";
+    }
+    if (status === "degraded") {
+        return "저하";
+    }
+    if (status === "down") {
+        return "중단";
+    }
+    return "알 수 없음";
+}
+function formatMinorCurrency(amountMinor, currency) {
+    return `${currency} ${(amountMinor / 100).toFixed(2)}`;
+}
+//# sourceMappingURL=korean.js.map

package/dist/packages/report/src/slack.d.ts

@@ -0,0 +1,34 @@
+export interface SlackReportPayload {
+    text: string;
+    mrkdwn: true;
+}
+export interface SlackReportTransportRequest {
+    webhookUrl: string;
+    payload: SlackReportPayload;
+    signal: AbortSignal;
+}
+export interface SlackReportTransportResponse {
+    ok: boolean;
+    status: number;
+    body?: string;
+}
+export type SlackReportTransport = (request: SlackReportTransportRequest) => Promise<SlackReportTransportResponse>;
+export interface SendSlackReportOptions {
+    webhookUrl: string;
+    text: string;
+    transport?: SlackReportTransport;
+    timeoutMs?: number;
+}
+export interface SlackReportDeliveryResult {
+    status: "sent";
+    statusCode: number;
+}
+export declare class SlackReportDeliveryError extends Error {
+    readonly statusCode?: number;
+    constructor(message: string, options?: {
+        statusCode?: number;
+    });
+}
+export declare function buildSlackReportPayload(text: string): SlackReportPayload;
+export declare function sendSlackReport(options: SendSlackReportOptions): Promise<SlackReportDeliveryResult>;
+//# sourceMappingURL=slack.d.ts.map