@ambasada/village 0.8.1 → 0.8.2

package/dist/receipt.d.ts

@@ -3,7 +3,7 @@
  * by the village, committing to the buyer, seller, offering, amount and the SHA-256 of the exact body.
  * The seller checks it offline against `<api>/.well-known/jwks.json` (cached), no round-trip.
  */
-import { type HeaderSource, type Jwk } from "./sdk/platform.js";
+import { type HeaderSource, type Jwk } from "@ambasada/sdk/platform";
 import type { CheckoutReceiptClaims, ReceiptClaims } from "./types.js";
 export declare const RECEIPT_HEADER = "x-village-receipt";
 export type KeySource = Jwk[] | (() => Promise<Jwk[]>);

package/dist/webhook.d.ts

@@ -8,7 +8,7 @@
  *
  * This module wraps the protocol functions with the SDK's error type and event shape.
  */
-import { type HeaderSource } from "./sdk/platform.js";
+import { type HeaderSource } from "@ambasada/sdk/platform";
 import type { WebhookEvent } from "./types.js";
 /** The three Standard Webhooks headers. */
 export declare const WEBHOOK_HEADERS: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ambasada/village",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "The Hack A Ton add-on for Ambasada apps: TON checkout, receipts, offerings, LLM, the agent, the market; CLI commands and the local bank.",
   "type": "module",
   "license": "MIT",
@@ -26,14 +26,16 @@
   "engines": {
     "node": ">=22"
   },
+  "dependencies": {
+    "@ambasada/sdk": "^0.8.2"
+  },
   "devDependencies": {
     "@types/node": "^22.20.5",
     "esbuild": "^0.28.2",
     "typescript": "~5.9.3",
     "vitest": "^4.1.12",
     "@ambasada/protocol": "0.1.0",
-    "@ambasada/sdk": "0.8.1",
-    "@ambasada/cli": "0.8.1"
+    "@ambasada/cli": "0.8.2"
   },
   "author": "CENTYSO (https://centyso.com)",
   "homepage": "https://ambasada.id",

package/dist/sdk/apps.d.ts

@@ -1,110 +0,0 @@
-/**
- * Notifications for every mini app (docs/MINI-APPS.md §7). The hub tells your app who turned notifications
- * on through a signed webhook; you keep `token ↔ your user` and send with that token:
- *
- *   POST /api/ambasada/webhook → const event = await ambasada.apps.verifyWebhook(req)   // AppEvent
- *                                if (event.event === "notifications_enabled") save(event.user, event.token)
- *   anywhere                   → await ambasada.apps.notify({ notification_id, title, body, url, tokens: [token] })
- *
- * The app secret signs both directions: `AMBASADA_APP_SECRET` (the deploy injects it on ambasada.dev; the hub
- * dashboard shows it for apps hosted elsewhere; `ambasada dev` sets a fake one and plays the hub).
- * WebCrypto only; the wire format is in @ambasada/protocol (packages/protocol/src/apps.ts).
- */
-import type { HeaderSource } from "./headers.js";
-export declare const APP_SIGNATURE_HEADER = "x-ambasada-signature";
-export declare const APP_TIMESTAMP_HEADER = "x-ambasada-timestamp";
-export type AppEventType = "notifications_enabled" | "notifications_disabled" | "app_added" | "app_removed" | "ping";
-/** What the hub POSTs to your webhook. `token` comes with notifications_enabled (and app_added when notifications are on). */
-export type AppEvent = {
-    event: "notifications_enabled";
-    app: string;
-    token: string;
-    user: string;
-    at: string;
-} | {
-    event: "notifications_disabled";
-    app: string;
-    user: string;
-    token?: string;
-    at: string;
-} | {
-    event: "app_added";
-    app: string;
-    user: string;
-    token?: string;
-    at: string;
-} | {
-    event: "app_removed";
-    app: string;
-    user: string;
-    token?: string;
-    at: string;
-} | {
-    event: "ping";
-    app: string;
-    at: string;
-};
-export type NotificationCategory = "transactional" | "social" | "marketing";
-export interface AppNotifyInput {
-    /** ≤ 128; (person, id) is deduped by the hub for 24 h. */
-    notification_id: string;
-    /** ≤ 40: the whole headline. */
-    title: string;
-    /** ≤ 140. */
-    body: string;
-    /** A path on your app (`/orders/184`) or a URL on its origin. */
-    url: string;
-    /** Notification tokens from `notifications_enabled`, ≤ 100 per call. */
-    tokens?: string[];
-    /** Ambasada user ids, for Verified apps with the identity scope. */
-    users?: string[];
-    /** Default "transactional", the only one Listed apps may send. */
-    category?: NotificationCategory;
-    /** Replaces an earlier unread push with the same key. */
-    collapse_key?: string;
-    ttl_seconds?: number;
-}
-export interface AppNotifyResult {
-    sent: string[];
-    /** Gone (the person turned notifications off or removed the app): forget them. */
-    invalid: string[];
-    rate_limited: string[];
-}
-/** The `x-ambasada-signature` value for a delivery (`v1=<hex>`): for tests and your own fake hub. */
-export declare const signAppWebhook: (secret: string, timestamp: number, body: string) => Promise<string>;
-/** Timestamp + signature headers for `body`, as the hub sends them. */
-export declare const appWebhookHeaders: (secret: string, body: string, timestamp?: number) => Promise<Record<string, string>>;
-export interface AppsConfig {
-    /** `AMBASADA_APP_SECRET`. */
-    appSecret?: string;
-    /** `AMBASADA_HUB_URL`, else https://hub.ambasada.id. */
-    hubUrl?: string;
-    /** Your app's origin, for the same-origin `url` rule: `AMBASADA_APP_ORIGIN`, else `PUBLIC_URL`. */
-    origin?: string;
-    fetch?: typeof fetch;
-}
-/** A fetch `Request`, or the raw body and headers exactly as received. */
-export type WebhookInput = Request | {
-    body: string | Uint8Array;
-    headers: HeaderSource;
-};
-export declare class AmbasadaApps {
-    private readonly config;
-    constructor(config: () => AppsConfig);
-    /** True when the app has its secret (hosted on ambasada.dev, `ambasada dev`, or set by hand). */
-    get configured(): boolean;
-    /**
-     * Verifies a webhook from the hub (signature, 5-minute window) and returns the event, or throws
-     * `WebhookInvalidError` (answer it with `error.toResponse()`, a 400). Read nothing from the request before.
-     */
-    verifyWebhook(input: WebhookInput, secret?: string, options?: {
-        toleranceSeconds?: number;
-        now?: number;
-    }): Promise<AppEvent>;
-    /**
-     * Sends a push to the people behind `tokens` (or `users`, for Verified apps with `identity`) through the hub.
-     * Checks the limits first (title ≤ 40, body ≤ 140, id ≤ 128, ≤ 100 recipients, `url` on your origin) and
-     * throws `AmbasadaError("INVALID_REQUEST")` before sending anything. Tokens in `invalid` are gone: forget them.
-     */
-    notify(input: AppNotifyInput): Promise<AppNotifyResult>;
-}

package/dist/sdk/auth.d.ts

@@ -1,132 +0,0 @@
-/**
- * "Sign in with Ambasada" (docs/AUTH.md): OAuth 2.0 authorization code + PKCE against Ambasada ID,
- * for products hosted at https://<slug>.ambasada.dev. The deploy injects AMBASADA_AUTH_CLIENT_ID,
- * AMBASADA_AUTH_CLIENT_SECRET and AMBASADA_AUTH_ISSUER; `ambasada dev` injects fake ones that point at
- * the mock. Four fetch handlers, WebCrypto only, no dependencies:
- *
- *   GET /api/auth/login     → return ambasada.auth.login(req, { returnTo: "/" })
- *   GET /api/auth/callback  → return ambasada.auth.callback(req)
- *   GET /api/auth/logout    → return ambasada.auth.logout(req)
- *   anywhere                → const user = await ambasada.auth.user(req)   // AmbasadaUser | null
- *
- * The session is an HttpOnly cookie holding the signed public profile (HMAC-SHA256 under a key
- * derived from the client secret), host-only (`__Host-` on https), so no other *.ambasada.dev product
- * can read, set or forge it. No access token is kept.
- *
- * Silent sign-in inside the Ambasada app (docs/MINI-APPS.md §5): the page asks the shell for a short-lived
- * token (`auth.getToken()` from @ambasada/miniapp) and POSTs it here; the same session cookie comes back:
- *
- *   POST /api/auth/shell { token } → return ambasada.auth.shell(req)                      // { user } + cookie
- *   anywhere                       → const who = await ambasada.auth.verifyShellToken(token) // { user_id, name, avatar }
- */
-/** The person signed in, as `GET /v1/auth/profile` returns them. */
-export interface AmbasadaUser {
-    /** Ambasada ID user id (`user_…`): stable, use it as your user key. */
-    id: string;
-    name: string | null;
-    avatar_url: string | null;
-    /** Has the builder flag on their Ambasada ID. */
-    builder: boolean;
-    builder_since: string | null;
-    member_since: string | null;
-    /** Their pass at the current event, if any. */
-    pass: "builder" | "visitor" | "staff" | null;
-    /** Only when you asked for it (`login(req, { email: true })`) and they agreed. */
-    email?: string | null;
-}
-export interface AuthConfig {
-    clientId?: string;
-    clientSecret?: string;
-    issuer?: string;
-    /** Who a shell token must be for (`aud`): your app id and origin. The request's origin is added in `shell()`. */
-    audiences?: string[];
-    /** The hub, for the full profile behind a shell token (`/api/apps/profile`). */
-    hubUrl?: string;
-    /** Where `/v1/auth/profile` lives (the Ambasada API). */
-    apiUrl: string;
-    /** Your public origin if the Worker sees another host (behind a proxy). Default: the request's origin. */
-    publicUrl?: string;
-    fetch?: typeof fetch;
-}
-export interface LoginOptions {
-    /** Path on your site to land on after signing in (default "/"). Only same-site paths are honored. */
-    returnTo?: string;
-    /** Also ask for their email (the consent screen says so). */
-    email?: boolean;
-}
-export declare const AUTH_PATHS: {
-    readonly login: "/api/auth/login";
-    readonly callback: "/api/auth/callback";
-    readonly logout: "/api/auth/logout";
-    readonly shell: "/api/auth/shell";
-};
-/** How long a sign-in lasts (the cookie holds a profile snapshot; signing in again refreshes it). */
-export declare const SESSION_TTL_S: number;
-export declare function b64url(bytes: Uint8Array): string;
-/** PKCE (RFC 7636): a random verifier and its S256 challenge. */
-export declare function pkce(): Promise<{
-    verifier: string;
-    challenge: string;
-}>;
-export declare function pkceChallenge(verifier: string): Promise<string>;
-/** `<payload>.<signature>`, both base64url; the payload is JSON with `exp` (seconds). */
-export declare function signCookie(secret: string, purpose: string, payload: Record<string, unknown>): Promise<string>;
-/** The payload if the signature is ours and it has not expired; null otherwise. */
-export declare function verifyCookie<T extends {
-    exp: number;
-}>(secret: string, purpose: string, value: string | null | undefined, now?: number): Promise<T | null>;
-/** A fetch `Request`, or anything with its headers (Next: `{ headers: await headers() }`). */
-export type WithHeaders = Pick<Request, "headers">;
-export declare function readCookie(req: WithHeaders, name: string): string | null;
-/**
- * A relative path on this site, or "/". No open redirects: "//evil", "/\\evil", "https://…" are refused, and so is
- * any control character (browsers drop tabs and newlines, so "/\t/evil" would become "//evil").
- */
-export declare function safeReturnTo(value: string | null | undefined): string;
-/** Who a verified shell token is for. Name and avatar are what Ambasada ID had when the shell minted it. */
-export interface ShellUser {
-    user_id: string;
-    name: string | null;
-    avatar: string | null;
-}
-/** JWKS cache per issuer: 1 hour, refreshed once early when a token names a key we don't have. */
-export declare const JWKS_TTL_MS = 3600000;
-/** For tests. */
-export declare function clearJwksCache(): void;
-export declare class AmbasadaAuth {
-    private readonly config;
-    constructor(config: () => AuthConfig);
-    /** True when the product has credentials (hosted on ambasada.dev, or `ambasada dev`). */
-    get configured(): boolean;
-    private settings;
-    /** Redirects to Ambasada ID (consent screen) with PKCE; a short-lived signed cookie holds the state. */
-    login(req: Request, options?: LoginOptions): Promise<Response>;
-    /**
-     * Ambasada ID sends the person back here: checks the state, exchanges the code (with the PKCE
-     * verifier and the client secret), reads their profile from the Ambasada API, sets the session cookie
-     * and redirects to `returnTo`. A refused consent goes back to `returnTo` signed out.
-     */
-    callback(req: Request): Promise<Response>;
-    /** Whoever is signed in on this request, or null (also null when sign-in is not set up). */
-    user(req: WithHeaders): Promise<AmbasadaUser | null>;
-    /**
-     * Verifies a shell token (Clerk JWT template `ambasada-miniapp`, RS256, 60 s) against
-     * `<AMBASADA_AUTH_ISSUER>/.well-known/jwks.json` (cached 1 h): signature, expiry, issuer, and that its `aud`
-     * is this app (its id or origin). Returns who it is, or throws `AmbasadaError("UNAUTHORIZED")`.
-     */
-    verifyShellToken(token: string, options?: {
-        audience?: string | string[];
-        now?: number;
-    }): Promise<ShellUser>;
-    /**
-     * Silent sign-in: `POST /api/auth/shell` with `{ "token": "<auth.getToken() token>" }` (or `Authorization: Bearer`).
-     * Verifies it, reads the full profile from the hub (falling back to what the token carries) and sets the same
-     * session cookie as `callback()`, so a person signed in inside the app and one signed in on the web look the same.
-     * Answers `{ user }`.
-     */
-    shell(req: Request): Promise<Response>;
-    /** Clears the session and redirects to `returnTo` (default "/"). Signs out of this product only. */
-    logout(req: Request, options?: {
-        returnTo?: string;
-    }): Response;
-}

package/dist/sdk/client.d.ts

@@ -1,106 +0,0 @@
-import { AmbasadaApps } from "./apps.js";
-import { AmbasadaAuth } from "./auth.js";
-import type { FileOptions, Jwk, StoredFile, StoreList, StoreWrite } from "./types.js";
-export declare const DEFAULT_API_URL = "https://api.ambasada.dev";
-export interface AmbasadaOptions {
-    /** Project key (`vk_…` from developer.ambasada.dev, or `ambasada login`). Default: `AMBASADA_API_KEY`. */
-    apiKey?: string;
-    /** Default: `AMBASADA_API_URL`, else https://api.ambasada.dev. `ambasada dev` serves http://localhost:8788. */
-    apiUrl?: string;
-    /** Your app's id. Default: `AMBASADA_APP_ID`, else looked up once with the API key. */
-    project?: string;
-    /** Signing keys; default: `<apiUrl>/.well-known/jwks.json`, cached 10 minutes. */
-    keys?: Jwk[] | (() => Promise<Jwk[]>);
-    /** Custom fetch (tests, proxies). */
-    fetch?: typeof fetch;
-    /** Per-request timeout in ms (default 45 s). */
-    timeoutMs?: number;
-    /** Extra env source, e.g. a Worker's `env`. Default: `process.env` where it exists. */
-    env?: Record<string, unknown>;
-    /** Sign in with Ambasada credentials. Default: `AMBASADA_AUTH_CLIENT_ID`, `_CLIENT_SECRET`, `_ISSUER`, and `PUBLIC_URL`. */
-    auth?: {
-        clientId?: string;
-        clientSecret?: string;
-        issuer?: string;
-        publicUrl?: string;
-    };
-    /** Mini-app platform (notifications). Default: `AMBASADA_APP_SECRET`, `AMBASADA_HUB_URL`, `AMBASADA_APP_ORIGIN` (else `PUBLIC_URL`). */
-    app?: {
-        secret?: string;
-        hubUrl?: string;
-        origin?: string;
-        id?: string;
-    };
-}
-export type Method = "GET" | "POST" | "PUT" | "DELETE";
-export interface RequestOptions {
-    body?: unknown;
-    raw?: NonNullable<RequestInit["body"]>;
-    headers?: Record<string, string | undefined>;
-    query?: Record<string, string | number | undefined>;
-    auth?: boolean;
-    signal?: AbortSignal;
-    /** Retry once on a network error (only safe with an idempotency key). */
-    retry?: boolean;
-}
-export interface RawResponse {
-    status: number;
-    headers: Headers;
-    json: unknown;
-}
-/**
- * The Ambasada client. `import { ambasada } from "@ambasada/sdk"` gives one configured from the
- * environment; `createAmbasada({ env })` makes another (e.g. from a Worker's `env`).
- */
-export declare class Ambasada {
-    protected readonly options: AmbasadaOptions;
-    private keyLoader?;
-    private projectPromise?;
-    constructor(options?: AmbasadaOptions);
-    protected env(name: string): string | undefined;
-    get apiUrl(): string;
-    protected get apiKey(): string;
-    /**
-     * Sign in with Ambasada (docs/AUTH.md): `login(req)`, `callback(req)`, `user(req)`, `logout(req)`.
-     * Credentials come with the deploy to ambasada.dev, and from `ambasada dev` locally.
-     */
-    readonly auth: AmbasadaAuth;
-    private get appOrigin();
-    private get hubUrl();
-    /**
-     * The mini-app platform (docs/MINI-APPS.md §7): `verifyWebhook(req)` for the hub's app events and
-     * `notify({ … })` to push to people who turned notifications on. Uses `AMBASADA_APP_SECRET`.
-     */
-    readonly apps: AmbasadaApps;
-    protected send(method: Method, path: string, opts?: RequestOptions): Promise<RawResponse>;
-    protected call<T>(method: Method, path: string, opts?: RequestOptions): Promise<T>;
-    /** Your app's id (from options, `AMBASADA_APP_ID`, or the project the API key belongs to). */
-    project(): Promise<string>;
-    /** The API's signing keys (`/.well-known/jwks.json`, cached). */
-    keys(): Promise<Jwk[]>;
-    readonly files: {
-        /**
-         * Stores bytes, a Blob, or a URL to copy (`POST /v1/files`). Returns a public URL. For an app's own
-         * uploads prefer its bucket, `env.FILES` (docs/STORAGE.md).
-         */
-        put: (data: Uint8Array | ArrayBuffer | Blob | string, options?: FileOptions) => Promise<StoredFile>;
-    };
-    /**
-     * Your project's JSON key-value store (`/v1/store`): 1 MB per project (keys + values), free. For more,
-     * use the app's own D1, KV and R2 (docs/STORAGE.md).
-     */
-    readonly store: {
-        /** The value, or null when the key is not set. */
-        get: <T = unknown>(key: string) => Promise<T | null>;
-        /** Saves any JSON value (fails with INVALID_REQUEST when the store would pass 1 MB). */
-        set: (key: string, value: unknown) => Promise<StoreWrite>;
-        /** `set` under its other name. */
-        put: (key: string, value: unknown) => Promise<StoreWrite>;
-        /** True when the key existed. */
-        delete: (key: string) => Promise<boolean>;
-        /** Keys (up to 1000, optionally under a prefix) and how much of the 1 MB is used. */
-        list: (prefix?: string) => Promise<StoreList>;
-    };
-}
-export declare function cachedKeys(load: () => Promise<Jwk[]>, ttlMs?: number): () => Promise<Jwk[]>;
-export declare function createAmbasada(options?: AmbasadaOptions): Ambasada;

package/dist/sdk/define.d.ts

@@ -1,19 +0,0 @@
-/**
- * `ambasada.config.ts` (docs/PLATFORM.md §3). Types and checks only; the CLI reads the values
- * (`ambasada dev`, `deploy`, `link`, `check`). Add-ons add their own keys (the village: `idea`, `offerings`, `agent`).
- */
-export interface AppConfig {
-    /** The app's slug (lowercase): it lives at https://<id>.ambasada.dev. */
-    id: string;
-    /** Display name. */
-    name: string;
-    /** One line about the app: the manifest's subtitle and description (`ambasada init` writes them from it). */
-    description?: string;
-    /** Where the app runs; `ambasada link` sets it when you host elsewhere. */
-    product?: {
-        url?: string;
-    };
-    /** Add-ons to load besides the ones found in node_modules (package names, e.g. "@ambasada/village"). */
-    addons?: string[];
-}
-export declare function defineApp<T extends AppConfig>(config: T): T;

package/dist/sdk/errors.d.ts

@@ -1,94 +0,0 @@
-/**
- * Typed errors. Every Ambasada API failure is `{ "error": { "code", "message", ... } }` with a code
- * from `@ambasada/protocol` (packages/protocol/src/errors.ts); the SDK turns it into an `AmbasadaError`
- * with the same `code`, so you branch on `error.code` instead of parsing messages:
- *
- *   try { await ambasada.store.set("settings", value) }
- *   catch (e) { if (isAmbasadaError(e, "INVALID_REQUEST")) … }
- *
- * The list mirrors the protocol (a unit test keeps them in sync), plus codes the in-flight API
- * streams add (checkout, utilities, agent) and a few SDK-side ones (`NETWORK`, `CONFIG`,
- * `RECEIPT_INVALID`, `WEBHOOK_INVALID`).
- */
-export declare const ERROR_STATUS: {
-    readonly INSUFFICIENT_FUNDS: 402;
-    readonly OFFLINE: 503;
-    readonly TIMEOUT: 504;
-    readonly SCHEMA_INVALID: 502;
-    readonly CAP_BUYER_HOURLY: 429;
-    readonly CAP_SELLER_RATE: 429;
-    readonly DEAL_EXHAUSTED: 409;
-    readonly DEPTH_EXCEEDED: 422;
-    readonly BUDGET_EXCEEDED: 402;
-    readonly UPSTREAM_ERROR: 502;
-    readonly PRICE_ABOVE_MAX: 409;
-    readonly SELF_PURCHASE: 403;
-    readonly INVALID_REQUEST: 400;
-    readonly UNAUTHORIZED: 401;
-    readonly NOT_FOUND: 404;
-    readonly CONFLICT: 409;
-    readonly IDEMPOTENCY_CONFLICT: 422;
-    readonly IDEMPOTENCY_IN_PROGRESS: 409;
-    readonly HOLD_NOT_ACTIVE: 409;
-    readonly INTERNAL: 500;
-    readonly CAP_PER_PAYMENT: 403;
-    readonly CAP_BUYER_DAILY: 429;
-    readonly CAP_PAYEE_DAILY: 429;
-    readonly CAP_VISITOR_DAILY: 429;
-    readonly APPROVAL_REQUIRED: 403;
-    readonly APPROVAL_INVALID: 403;
-    readonly APPROVALS_PENDING: 429;
-    readonly PROVIDER_BUDGET: 503;
-    readonly PROVIDER_DENIED: 502;
-    readonly FROZEN: 403;
-    readonly CAP_INBOX_RATE: 429;
-    readonly NETWORK: 0;
-    readonly CONFIG: 0;
-    readonly RECEIPT_INVALID: 402;
-    readonly WEBHOOK_INVALID: 400;
-};
-/** A known error code. Servers may add codes before the SDK knows them, so `code` is `ErrorCode | string`. */
-export type ErrorCode = keyof typeof ERROR_STATUS;
-export interface ErrorDetails {
-    /** Present on Pay errors once a call id was assigned. */
-    call_id?: string;
-    /** Always false on Pay errors: a failed call never moves money. */
-    charged?: false;
-    /** True when funds had been held for the call and were released. */
-    refunded?: boolean;
-    /** HTTP status the seller returned, for UPSTREAM_ERROR / SCHEMA_INVALID. */
-    upstream_status?: number;
-    /** APPROVAL_REQUIRED: retry with `{ approval: approvalId }` once the team approved it. */
-    approval_id?: string;
-    [key: string]: unknown;
-}
-export declare class AmbasadaError extends Error {
-    readonly code: ErrorCode | (string & {});
-    /** HTTP status (0 when the request never got an answer). */
-    readonly status: number;
-    readonly details: ErrorDetails;
-    constructor(code: ErrorCode | (string & {}), message: string, status?: number, details?: ErrorDetails);
-    /** `instanceof AmbasadaError` holds across bundled copies; subclasses keep the usual prototype check. */
-    static [Symbol.hasInstance](value: unknown): boolean;
-    get callId(): string | undefined;
-    get refunded(): boolean;
-    get approvalId(): string | undefined;
-    /** The wire shape, e.g. to pass an error on from your own endpoint. */
-    toJSON(): {
-        error: {
-            code: string;
-            message: string;
-        } & ErrorDetails;
-    };
-    /** A `Response` with the wire shape and status (402 for receipt problems). */
-    toResponse(): Response;
-}
-export type WebhookFailure = "missing_headers" | "bad_timestamp" | "too_old" | "too_new" | "bad_signature" | "bad_secret" | "bad_body";
-/** A signed webhook (app events, payments) failed its check. */
-export declare class WebhookInvalidError extends AmbasadaError {
-    readonly reason: WebhookFailure;
-    constructor(reason: WebhookFailure, message: string);
-}
-export declare function isAmbasadaError(value: unknown, code?: ErrorCode | (string & {})): value is AmbasadaError;
-/** Builds an AmbasadaError from an API response body (or a non-JSON failure). */
-export declare function errorFromResponse(status: number, body: unknown, fallback: string): AmbasadaError;

package/dist/sdk/headers.d.ts

@@ -1,3 +0,0 @@
-/** Header lookup that works on a fetch `Headers` and on a Node / Express header record. */
-export type HeaderSource = Headers | Record<string, string | string[] | undefined | null>;
-export declare function getHeader(headers: HeaderSource, name: string): string | null;

package/dist/sdk/platform.d.ts

@@ -1,20 +0,0 @@
-/**
- * The platform surface of @ambasada/sdk, without the 0.7 village names (`index.ts` adds those).
- * `@ambasada/village` builds on this module.
- */
-import { Ambasada } from "./client.js";
-export { Ambasada, createAmbasada, DEFAULT_API_URL } from "./client.js";
-export type { AmbasadaOptions } from "./client.js";
-export * from "./errors.js";
-export type * from "./types.js";
-export { getHeader } from "./headers.js";
-export type { HeaderSource } from "./headers.js";
-export { defineApp } from "./define.js";
-export type { AppConfig } from "./define.js";
-export { AmbasadaAuth, AUTH_PATHS, JWKS_TTL_MS, SESSION_TTL_S } from "./auth.js";
-export type { AmbasadaUser, AuthConfig, LoginOptions, ShellUser, WithHeaders } from "./auth.js";
-export { AmbasadaApps, APP_SIGNATURE_HEADER, APP_TIMESTAMP_HEADER, appWebhookHeaders, signAppWebhook } from "./apps.js";
-export type { AppEvent, AppEventType, AppNotifyInput, AppNotifyResult, AppsConfig, NotificationCategory, WebhookInput } from "./apps.js";
-/** The default client, configured from the environment at call time. */
-export declare const ambasada: Ambasada;
-export default ambasada;

package/dist/sdk/types.d.ts

@@ -1,40 +0,0 @@
-/** Wire types of the platform API. */
-/** Ed25519 public key as served by `/.well-known/jwks.json`. */
-export interface Jwk {
-    kty: "OKP";
-    crv: "Ed25519";
-    x: string;
-    d?: string;
-    kid?: string;
-    alg?: "EdDSA";
-    use?: "sig";
-}
-export interface FileOptions {
-    contentType?: string;
-    ttlSeconds?: number;
-}
-/** `POST /v1/files`. */
-export interface StoredFile {
-    id: string;
-    url: string;
-    size?: number;
-    content_type?: string;
-    cost?: number;
-    call_id?: string;
-}
-export interface StoreKey {
-    key: string;
-    size: number;
-    updated_at: string;
-}
-export interface StoreList {
-    keys: StoreKey[];
-    used_bytes: number;
-    limit_bytes: number;
-}
-export interface StoreWrite {
-    key: string;
-    size: number;
-    used_bytes: number;
-    limit_bytes: number;
-}