@oaath/server 0.1.0 → 0.3.0

package/dist/service-J51bOVe6.d.ts

@@ -0,0 +1,483 @@
+import { b as RelayClock, i as AuthorizationDecisionOutcome, o as AuthorizationOwnerRoute, t as RelayStore } from "./interface-DHpwP0wr.js";
+import { c as OwnerPhoneRevocationDecision, d as OwnerPhonePermissionApprovals, m as RelayCaller, n as OwnerPhonePushProjection, p as RelayAuthentication, r as OwnerPhoneRequestProjection } from "./projection-B7IB9irs.js";
+import { t as RelayKms } from "./kms-BWkywdJM.js";
+import { PermissionRequest, ServiceAccount, ServiceBootstrap } from "@oaath/protocol";
+//#region src/authorization/decision.d.ts
+type AuthorizationDecisionCommand =
+/** The owner supplies a request-bound approval artifact; the client claims it once. */
+Readonly<{
+  outcome: "approved";
+  artifact: string;
+}> | Readonly<{
+  outcome: "rejected";
+}>;
+interface SubmitAuthorizationDecisionInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  readonly kms: RelayKms;
+  /** Authenticated `owner` caller; only the bound subject may decide. */
+  readonly caller: RelayCaller;
+  readonly requestId: string;
+  readonly command: AuthorizationDecisionCommand;
+  readonly codeTtlMs: number;
+}
+type SubmittedAuthorizationDecision = Readonly<{
+  outcome: "approved";
+  decidedAt: number;
+  /** Released exactly once, here. Only its SHA-256 is stored. */
+  code: string;
+  artifactId: string;
+  redirectUri: string;
+  codeExpiresAt: number;
+}> | Readonly<{
+  outcome: "rejected";
+  decidedAt: number;
+}>;
+declare function submitAuthorizationDecision(input: SubmitAuthorizationDecisionInput): Promise<SubmittedAuthorizationDecision>;
+//#endregion
+//#region src/authorization/request.d.ts
+/** Resolves once at creation; existing requests never follow later routing changes. */
+interface RelayOwnerRouting {
+  resolveOwner(caller: Readonly<RelayCaller>, request: Readonly<{
+    requestId: string;
+    requestedScope: string;
+  }>): Promise<Readonly<AuthorizationOwnerRoute> | null>;
+}
+interface CreateAuthorizationRequestInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  /** Authenticated `client` caller; it owns `clientId` and `subject`. */
+  readonly caller: RelayCaller;
+  readonly ownerRouting: RelayOwnerRouting;
+  readonly redirectUri: string;
+  readonly codeChallenge: string;
+  readonly requestedScope: string;
+  readonly requestTtlMs: number;
+}
+interface CreatedAuthorizationRequest {
+  /** Non-secret comparison code shown by the approving phone. */
+  readonly matchCode: string;
+  readonly requestId: string;
+  readonly expiresAt: number;
+}
+interface AuthorizationState {
+  readonly requestId: string;
+  readonly clientId: string;
+  readonly redirectUri: string;
+  readonly requestedScope: string;
+  readonly expiresAt: number;
+  readonly expired: boolean;
+  readonly decision: Readonly<{
+    outcome: AuthorizationDecisionOutcome;
+    decidedAt: number;
+  }> | null;
+}
+declare function createAuthorizationRequest(input: CreateAuthorizationRequestInput): Promise<CreatedAuthorizationRequest>;
+interface FetchAuthorizationRequestInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  /** Authenticated `owner` caller; only the bound subject may read the request. */
+  readonly caller: RelayCaller;
+  readonly requestId: string;
+}
+/** Read for the approving owner. */
+declare function fetchAuthorizationRequest(input: FetchAuthorizationRequestInput): Promise<AuthorizationState>;
+//#endregion
+//#region src/directory/records.d.ts
+declare const OAATH_SERVICE_DIRECTORY_VERSION: "oaath.service-directory/v1";
+interface DirectoryWorkspace {
+  readonly workspaceId: string;
+  readonly kind: "personal" | "team";
+}
+interface DirectoryApplication {
+  readonly clientId: string;
+  readonly applicationId: string;
+  readonly applicationName: string;
+}
+/** Membership names the authenticated application/user pair, not owner authority. */
+interface DirectoryMembership {
+  readonly workspaceId: string;
+  readonly clientId: string;
+  readonly subject: string;
+}
+/** Enrollment identity used to route owner work; private key material is never stored here. */
+interface DirectoryOwnerDevice {
+  readonly workspaceId: string;
+  readonly ownerDeviceId: string;
+  readonly subject: string;
+}
+interface DirectoryAccount extends ServiceAccount {
+  readonly workspaceId: string;
+  readonly accountId: string;
+  readonly ownerDeviceId: string;
+  readonly chainIds: readonly number[];
+}
+/** A preference; current membership is checked again whenever it is resolved. */
+interface DirectorySelection extends DirectoryMembership {
+  readonly accountId: string;
+}
+interface ServiceDirectoryDocument {
+  readonly version: typeof OAATH_SERVICE_DIRECTORY_VERSION;
+  readonly workspaces: readonly Readonly<DirectoryWorkspace>[];
+  readonly applications: readonly Readonly<DirectoryApplication>[];
+  readonly memberships: readonly Readonly<DirectoryMembership>[];
+  readonly ownerDevices: readonly Readonly<DirectoryOwnerDevice>[];
+  readonly accounts: readonly Readonly<DirectoryAccount>[];
+  readonly selections: readonly Readonly<DirectorySelection>[];
+}
+//#endregion
+//#region src/native/authentication.d.ts
+declare const OAATH_OWNER_DEVICE_CREDENTIAL_VERSION: "oaath.owner-device-credential/v1";
+type OwnerDeviceReference = Pick<DirectoryOwnerDevice, "workspaceId" | "ownerDeviceId">;
+/** Authentication binding captured at issuance; contains no bearer or owner key. */
+interface OwnerDeviceCredentialRecord extends DirectoryOwnerDevice {
+  readonly version: typeof OAATH_OWNER_DEVICE_CREDENTIAL_VERSION;
+  readonly credentialHash: string;
+  readonly revoked: boolean;
+}
+interface OwnerDeviceCredentialStore {
+  /** Null means absent. Unreadable or unavailable storage must throw. */
+  read(credentialHash: string): Promise<unknown>;
+  /** Insert an immutable binding once. Never replace a revoked record. */
+  insert(record: Readonly<OwnerDeviceCredentialRecord>): Promise<boolean>;
+  /** Atomically revoke all credentials already issued for this device. Idempotent. */
+  revoke(device: Readonly<OwnerDeviceReference>): Promise<void>;
+}
+interface OwnerDeviceAuthentication extends RelayAuthentication {
+  authenticate(request: Request): Promise<Readonly<RelayCaller> | null>;
+  /**
+   * Deployment administration only, after authenticated pairing/enrollment.
+   * Returns a fresh 32-byte base64url bearer after its hash is stored. A lost
+   * write response throws; nothing is returned and no write is retried.
+   */
+  issue(device: Readonly<OwnerDeviceReference>): Promise<string>;
+  /** Revokes relay access only. Does not uninstall permissions or delete keys/accounts. */
+  revoke(device: Readonly<OwnerDeviceReference>): Promise<void>;
+}
+/**
+ * One active -> revoked transition per credential hash, separate from account
+ * authority. Directory identity is checked at issuance and authentication;
+ * an issued credential can never be retargeted to a changed owner subject.
+ * No cache, operation lane, retries or owned connections. Recreated instances
+ * read the same stores. The deployment owns pool shutdown and pairing delivery.
+ * Explicit later issuance creates a new credential; it cannot revive an old one.
+ */
+declare function createOwnerDeviceAuthentication(options: {
+  readonly store: OwnerDeviceCredentialStore;
+  readonly directory: Pick<ServiceDirectory, "read">;
+}): Readonly<OwnerDeviceAuthentication>;
+/** Ephemeral deployment adapter; the authentication service owns no local cache. */
+declare function createMemoryOwnerDeviceCredentialStore(): OwnerDeviceCredentialStore;
+//#endregion
+//#region src/native/decision.d.ts
+interface SubmitOwnerPhoneDecisionInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  readonly kms: RelayKms;
+  /** Authenticated `owner` caller; only the bound subject may decide. */
+  readonly caller: RelayCaller;
+  /** `operationId` from `projectOwnerPhoneRequest`. */
+  readonly operationId: string;
+  readonly command: AuthorizationDecisionCommand;
+  readonly codeTtlMs: number;
+  readonly permissionApprovals?: OwnerPhonePermissionApprovals;
+}
+interface OwnerPhoneDecision {
+  readonly operationId: string;
+  /** The stored outcome, which on a replay may differ from the command sent. */
+  readonly outcome: AuthorizationDecisionOutcome;
+  readonly decidedAt: number;
+  /** `decided` performed the transition; `replayed` answered the stored one. */
+  readonly settlement: "decided" | "replayed";
+  /** One-time release material, on the deciding call only. */
+  readonly release: SubmittedAuthorizationDecision | null;
+}
+declare function submitOwnerPhoneDecision(input: SubmitOwnerPhoneDecisionInput): Promise<OwnerPhoneDecision>;
+//#endregion
+//#region src/native/display.d.ts
+/** Bounded base64url match code length. 48 bits is plenty to compare by eye. */
+declare const NATIVE_DISPLAY_PAYLOAD_LENGTH = 8;
+//#endregion
+//#region src/native/inbox.d.ts
+declare const OAATH_NATIVE_INBOX_VERSION: "oaath.native-inbox/v1";
+interface OwnerPhoneInbox {
+  readonly version: typeof OAATH_NATIVE_INBOX_VERSION;
+  readonly requests: readonly Readonly<OwnerPhonePushProjection>[];
+}
+/** The store owns transaction resources; this read prepares, signs and submits nothing. */
+declare function listOwnerPhoneRequests(input: {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  readonly caller: RelayCaller;
+}): Promise<Readonly<OwnerPhoneInbox>>;
+//#endregion
+//#region src/revocation/service.d.ts
+interface RequestOwnerPhoneRevocationInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  readonly kms: RelayKms;
+  readonly directory: Pick<ServiceDirectory, "resolveRevocationOwner">;
+  /** Deployment-authenticated original application/member. */
+  readonly caller: RelayCaller;
+  readonly grantId: string;
+  readonly chainId: number;
+  readonly requestTtlMs: number;
+  /**
+   * Deployment uses prepareKernelPermissionRevocation to verify the retained Kernel
+   * capability, read target-chain state, and choose effect/root nonce/gas.
+   * Receives the retained approval plaintext; never log or expose it to clients.
+   * Preparation must not reserve a nonce or execution lane; concurrent
+   * preparations may lose admission.
+   * Returns the SDK signingRequest only. Must not sign or submit an operation.
+   */
+  readonly prepare: (input: Readonly<{
+    request: Readonly<PermissionRequest>;
+    artifact: string;
+    chainId: number;
+  }>) => Promise<unknown>;
+}
+interface OwnerPhoneRevocationStatus {
+  readonly grantId: string;
+  readonly chainId: number;
+  readonly operationId: string;
+  /** Relay timestamp in milliseconds. */
+  readonly expiresAt: number;
+  /** Custody status only, never submission or grant revocation completion. */
+  readonly status: "pending" | "approved" | "rejected" | "expired";
+}
+type ClientRevocationInput = Pick<RequestOwnerPhoneRevocationInput, "store" | "clock" | "caller" | "grantId" | "chainId">;
+/** Authenticated metadata lookup. It never prepares, opens KMS custody or submits. */
+declare function fetchClientPhoneRevocation(input: ClientRevocationInput): Promise<Readonly<OwnerPhoneRevocationStatus>>;
+/**
+ * Returns the current grant/chain request before touching preparation or KMS.
+ * Only positively expired, undecided custody may be replaced. Approved custody
+ * remains immutable even after expiry: operation evidence owns any replacement.
+ * Pure preparation runs outside the transaction; final admission locks the
+ * original grant again so concurrent callers share the winner's exact request.
+ */
+declare function requestOwnerPhoneRevocation(input: RequestOwnerPhoneRevocationInput): Promise<Readonly<OwnerPhoneRevocationStatus & {
+  created: boolean;
+}>>;
+interface OwnerRevocationInput {
+  readonly store: RelayStore;
+  readonly clock: RelayClock;
+  readonly caller: RelayCaller;
+  readonly operationId: string;
+}
+declare function fetchOwnerPhoneRevocation(input: OwnerRevocationInput): Promise<OwnerPhoneRequestProjection>;
+declare function submitOwnerPhoneRevocationDecision(input: OwnerRevocationInput & {
+  readonly kms: RelayKms;
+  readonly command: AuthorizationDecisionCommand;
+}): Promise<OwnerPhoneRevocationDecision>;
+//#endregion
+//#region src/security/rate-limit.d.ts
+/**
+ * Optional deployment-owned limiter port.
+ *
+ * There is no default limiter: an unset port means no limiting, and the relay
+ * never invents a policy the deployment did not choose. A limiter that fails is
+ * treated as `limited`, because an unreadable limiter is not permission.
+ *
+ * @author taek <leekt216@gmail.com>
+ */
+interface RelayRateLimitInput {
+  /** Stable route name, never a credential-bearing URL. */
+  readonly route: string;
+  readonly clientId: string | null;
+}
+interface RelayRateLimiter {
+  /** Resolves to `"allowed"` or `"limited"`. Anything else is `limited`. */
+  check(input: RelayRateLimitInput): Promise<unknown>;
+}
+//#endregion
+//#region src/session-signer/kms-provider.d.ts
+interface SessionSignerIdentity {
+  readonly clientId: string;
+  readonly subject: string;
+  readonly deviceId: string;
+}
+interface SessionSignerSignRequest extends SessionSignerIdentity {
+  /** The exact 32-byte hash to sign; never a message to interpret. */
+  readonly hash: `0x${string}`;
+}
+interface RelaySessionSignerProvider {
+  /**
+   * The operator credential for one authenticated identity, creating the key
+   * on first use. Idempotent: the same identity always answers the same
+   * credential.
+   */
+  readonly credential: (request: Readonly<SessionSignerIdentity>) => Promise<unknown>;
+  /** One ECDSA signature over one exact hash, under that identity's key. */
+  readonly sign: (request: Readonly<SessionSignerSignRequest>) => Promise<unknown>;
+}
+declare function createKmsSessionSignerProvider(input: {
+  readonly kms: RelayKms;
+}): RelaySessionSignerProvider;
+//#endregion
+//#region src/relay/handler.d.ts
+/**
+ * One deployment-injected chain execution surface the relay serves to clients.
+ * Each port takes exactly one captured request value and answers with the
+ * evidence it owns; the relay never interprets the payload beyond exact wire
+ * hygiene, so port meaning stays with its SDK owner.
+ */
+interface RelayChainPort {
+  readonly gas?: Readonly<{
+    enableVerificationGasFloor: bigint;
+  }>;
+  readonly chainId: number;
+  readonly reads: (request: unknown) => Promise<unknown>;
+  readonly observation: (request: unknown) => Promise<unknown>;
+  readonly bundler: (request: unknown) => Promise<unknown>;
+  readonly quote: (request: unknown) => Promise<unknown>;
+  /** Opens, sends, and settles one submission in one call; never retried here. */
+  readonly submission: (request: unknown) => Promise<unknown>;
+  /** Finalized per-grant usage evidence, or null when this chain serves none. */
+  readonly usage: ((request: unknown) => Promise<unknown>) | null;
+  readonly feePayer: Readonly<{
+    address: `0x${string}`;
+    balance: string;
+  }> | null;
+  /** Authenticated commitment to one exact ERC-7902 static paymaster, or null. */
+  readonly staticPaymasterConfigurationHash: `0x${string}` | null;
+}
+/** Selection resolved from the deployment's membership and account records. */
+interface RelayBootstrapSelection {
+  readonly application: Readonly<Pick<ServiceBootstrap["application"], "applicationId" | "applicationName">>;
+  readonly context: ServiceBootstrap["context"];
+  readonly account: ServiceBootstrap["account"];
+  readonly ownerValidator: `0x${string}` | null;
+  readonly chainIds: readonly number[];
+}
+/** Called for each authenticated bootstrap request; null means no assigned account. */
+interface RelayBootstrapConfiguration {
+  readonly resolve: (caller: Readonly<RelayCaller>) => Promise<Readonly<RelayBootstrapSelection> | null>;
+}
+/**
+ * Remote session-key custody, declared once for the deployment: the mode and
+ * provider identity are served through the bootstrap document, and the same
+ * provider answers the `/session-signers` routes. For `oaath_hosted` the
+ * provider is typically `createKmsSessionSignerProvider`; for
+ * `application_backend` it is the deployment's own authenticated port to the
+ * integrating application's signer — never a client-supplied endpoint.
+ */
+interface RelaySessionSignerConfiguration {
+  readonly mode: "application_backend" | "oaath_hosted";
+  readonly providerId: string;
+  readonly provider: Readonly<RelaySessionSignerProvider>;
+}
+/** Authenticated identity and one opaque ERC-7677 params tuple. */
+interface RelayPaymasterServiceRequest {
+  readonly caller: Readonly<{
+    clientId: string;
+    subject: string;
+  }>;
+  readonly params: unknown;
+  readonly signal: AbortSignal;
+}
+/**
+ * One deployment-owned paymaster provider. The relay exposes only these two
+ * closed ERC-7677 operations and invokes the selected method once.
+ */
+interface RelayPaymasterServiceProvider {
+  readonly getPaymasterStubData: (request: Readonly<RelayPaymasterServiceRequest>) => Promise<unknown>;
+  readonly getPaymasterData: (request: Readonly<RelayPaymasterServiceRequest>) => Promise<unknown>;
+}
+interface RelayPaymasterServiceConfiguration {
+  readonly chainId: number;
+  readonly providerId: string;
+  /** Hard response deadline; the provider also receives its abort signal. */
+  readonly requestTimeoutMs: number;
+  readonly provider: Readonly<RelayPaymasterServiceProvider>;
+}
+interface RelayHandlerOptions {
+  /** Enables application-initiated phone revocation; preparation never signs or submits. */
+  readonly revocations?: Readonly<Pick<RequestOwnerPhoneRevocationInput, "directory" | "prepare">>;
+  /** Enables canonical permission approval through the owner phone. */
+  readonly permissionApprovals?: OwnerPhonePermissionApprovals;
+  readonly store: RelayStore;
+  readonly authentication: RelayAuthentication;
+  /** Required. Resolves an approving device independently of the requesting member. */
+  readonly ownerRouting: RelayOwnerRouting;
+  readonly kms: RelayKms;
+  readonly clock: RelayClock;
+  /** Optional. There is no default limiter. */
+  readonly rateLimit?: RelayRateLimiter;
+  readonly requestTtlMs?: number;
+  readonly codeTtlMs?: number;
+  readonly maxBodyBytes?: number;
+  /** Optional URL-only bootstrap surface; requires `chains` as well. */
+  readonly bootstrap?: Readonly<RelayBootstrapConfiguration>;
+  /** Optional chain execution relays; required when `bootstrap` is served. */
+  readonly chains?: readonly Readonly<RelayChainPort>[];
+  /** Optional remote session-key custody; requires `bootstrap` as well. */
+  readonly sessionSigner?: Readonly<RelaySessionSignerConfiguration>;
+  /**
+   * Optional deployment-owned paymaster services, at most one per chain.
+   * Configuration requires both bootstrap and a deployment rate limiter.
+   */
+  readonly paymasterServices?: readonly Readonly<RelayPaymasterServiceConfiguration>[];
+}
+type RelayHandler = (request: Request) => Promise<Response>;
+declare function createRelayHandler(options: RelayHandlerOptions): RelayHandler;
+//#endregion
+//#region src/directory/service.d.ts
+interface ServiceDirectorySnapshot {
+  readonly revision: number;
+  readonly directory: Readonly<ServiceDirectoryDocument>;
+}
+/** One atomic row. A failed/ambiguous write is never automatically retried. */
+interface ServiceDirectoryStore {
+  read(): Promise<unknown>;
+  /** Null expects absence; otherwise replace exactly this revision and advance it by one. */
+  compareAndSwap(expectedRevision: number | null, directory: Readonly<ServiceDirectoryDocument>): Promise<boolean>;
+}
+/** Deployment-authenticated pairing result; contains public identity only. */
+interface EnrollOwnerDeviceInput {
+  readonly expectedRevision: number;
+  readonly device: Readonly<DirectoryOwnerDevice>;
+  readonly accounts: readonly Readonly<DirectoryAccount>[];
+}
+interface ServiceDirectory extends RelayBootstrapConfiguration, RelayOwnerRouting {
+  read(): Promise<Readonly<ServiceDirectorySnapshot> | null>;
+  /** Admission for the original permission context, restricted to its configured chains. */
+  resolveRevocationOwner(caller: Readonly<RelayCaller>, input: Readonly<{
+    requestId: string;
+    requestedScope: string;
+    chainId: number;
+  }>): Promise<Readonly<AuthorizationOwnerRoute> | null>;
+  /** Deployment administration capability, never an unauthenticated HTTP endpoint. */
+  replace(input: {
+    readonly expectedRevision: number | null;
+    readonly directory: unknown;
+  }): Promise<boolean>;
+  /**
+   * Atomically enroll a new P-256 phone and its Kernel accounts in one workspace.
+   * The deployment authenticates pairing and assigns the owner subject first.
+   * No membership, authentication credential, or onchain operation is created.
+   * False means the expected revision lost; read before a fresh admin decision.
+   */
+  enrollOwnerDevice(input: Readonly<EnrollOwnerDeviceInput>): Promise<boolean>;
+  /** False means a concurrent directory write won; read current state before choosing again. */
+  selectAccount(caller: Readonly<RelayCaller>, selection: {
+    readonly workspaceId: string;
+    readonly accountId: string;
+  }): Promise<boolean>;
+}
+/**
+ * Owns membership/account selection and atomic phone enrollment over one
+ * versioned directory document. Enrollment moves absent device/accounts to
+ * jointly registered identities; it cannot overwrite them. Its single CAS is
+ * the persisted evidence and cleanup owner: a lost response causes no retry,
+ * and a recreated reader sees the whole enrollment or none of it.
+ * Writes use compare-and-swap; bootstrap/admission reads never reserve resources.
+ * A reload reads durable state afresh. Member removal blocks new admission but
+ * does not revoke grants or delete operation evidence. The deployment owns store
+ * resources and cleanup; this service owns no connections and retries no writes.
+ */
+declare function createServiceDirectory(store: ServiceDirectoryStore): Readonly<ServiceDirectory>;
+/** Ephemeral deployment/test store; the service captures every read and write boundary. */
+declare function createMemoryServiceDirectoryStore(): ServiceDirectoryStore;
+//#endregion
+export { FetchAuthorizationRequestInput as $, listOwnerPhoneRequests as A, createMemoryOwnerDeviceCredentialStore as B, RequestOwnerPhoneRevocationInput as C, submitOwnerPhoneRevocationDecision as D, requestOwnerPhoneRevocation as E, OAATH_OWNER_DEVICE_CREDENTIAL_VERSION as F, DirectoryOwnerDevice as G, DirectoryAccount as H, OwnerDeviceAuthentication as I, OAATH_SERVICE_DIRECTORY_VERSION as J, DirectorySelection as K, OwnerDeviceCredentialRecord as L, OwnerPhoneDecision as M, SubmitOwnerPhoneDecisionInput as N, OAATH_NATIVE_INBOX_VERSION as O, submitOwnerPhoneDecision as P, CreatedAuthorizationRequest as Q, OwnerDeviceCredentialStore as R, OwnerPhoneRevocationStatus as S, fetchOwnerPhoneRevocation as T, DirectoryApplication as U, createOwnerDeviceAuthentication as V, DirectoryMembership as W, AuthorizationState as X, ServiceDirectoryDocument as Y, CreateAuthorizationRequestInput as Z, SessionSignerIdentity as _, createMemoryServiceDirectoryStore as a, SubmittedAuthorizationDecision as at, RelayRateLimitInput as b, RelayBootstrapSelection as c, RelayPaymasterServiceConfiguration as d, RelayOwnerRouting as et, RelayPaymasterServiceProvider as f, RelaySessionSignerProvider as g, createRelayHandler as h, ServiceDirectoryStore as i, SubmitAuthorizationDecisionInput as it, NATIVE_DISPLAY_PAYLOAD_LENGTH as j, OwnerPhoneInbox as k, RelayHandler as l, RelaySessionSignerConfiguration as m, ServiceDirectory as n, fetchAuthorizationRequest as nt, createServiceDirectory as o, submitAuthorizationDecision as ot, RelayPaymasterServiceRequest as p, DirectoryWorkspace as q, ServiceDirectorySnapshot as r, AuthorizationDecisionCommand as rt, RelayBootstrapConfiguration as s, EnrollOwnerDeviceInput as t, createAuthorizationRequest as tt, RelayHandlerOptions as u, SessionSignerSignRequest as v, fetchClientPhoneRevocation as w, RelayRateLimiter as x, createKmsSessionSignerProvider as y, OwnerDeviceReference as z };
+//# sourceMappingURL=service-J51bOVe6.d.ts.map

package/dist/service-J51bOVe6.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-J51bOVe6.d.ts","names":[],"sources":["../src/authorization/decision.ts","../src/authorization/request.ts","../src/directory/records.ts","../src/native/authentication.ts","../src/native/decision.ts","../src/native/display.ts","../src/native/inbox.ts","../src/revocation/service.ts","../src/security/rate-limit.ts","../src/session-signer/kms-provider.ts","../src/relay/handler.ts","../src/directory/service.ts"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oaath/server",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "OAAth deployable relay and PostgreSQL boundary.",
   "type": "module",
   "sideEffects": false,
@@ -23,40 +23,71 @@
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
+      "oaath-source": {
+        "types": "./src/index.ts",
+        "default": "./src/index.ts"
+      },
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
     "./postgres": {
+      "oaath-source": {
+        "types": "./src/postgres.ts",
+        "node": "./src/postgres.ts"
+      },
       "types": "./dist/postgres.d.ts",
       "node": "./dist/postgres.js"
     },
     "./native": {
+      "oaath-source": {
+        "types": "./src/native.ts",
+        "default": "./src/native.ts"
+      },
       "types": "./dist/native.d.ts",
       "default": "./dist/native.js"
     },
     "./apns": {
+      "oaath-source": {
+        "types": "./src/apns.ts",
+        "node": "./src/apns.ts"
+      },
       "types": "./dist/apns.d.ts",
       "node": "./dist/apns.js"
+    },
+    "./kernel": {
+      "oaath-source": {
+        "types": "./src/kernel.ts",
+        "default": "./src/kernel.ts"
+      },
+      "types": "./dist/kernel.d.ts",
+      "default": "./dist/kernel.js"
     }
   },
   "files": [
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsdown",
+    "prepack": "bun run build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:postgres": "OAATH_REQUIRE_POSTGRES=1 vitest run test/postgres.test.ts test/restart.test.ts test/service-directory-postgres.test.ts test/revocation-service.test.ts test/revocation-executor.test.ts test/native-inbox.test.ts test/owner-device-authentication-postgres.test.ts",
+    "release:publish": "bun publish --access public --tolerate-republish",
+    "release:check": "bun pm pack --dry-run"
+  },
   "dependencies": {
     "@noble/curves": "1.9.1",
     "@noble/hashes": "2.2.0",
+    "@oaath/protocol": "0.3.0",
     "pg": "8.22.0",
-    "@oaath/protocol": "0.1.0"
+    "@oaath/sdk": "0.3.0"
   },
   "devDependencies": {
     "@types/node": "22.13.0",
     "@types/pg": "8.20.3"
   },
-  "scripts": {
-    "build": "tsdown",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:postgres": "OAATH_REQUIRE_POSTGRES=1 vitest run test/postgres.test.ts test/restart.test.ts"
+  "publishConfig": {
+    "access": "public"
   }
-}
+}