@terminal3/t3n-sdk 3.3.0 → 3.4.1

package/dist/src/utils/session.d.ts

@@ -1,37 +0,0 @@
-/**
- * Session validation utilities for T3n SDK
- */
-import { Logger } from "./logger";
-/**
- * Validation result for session bytes
- */
-export interface SessionValidationResult {
-    /** Whether the session bytes are valid JSON */
-    isValidJSON: boolean;
-    /** Whether the parsed result is a string */
-    isString: boolean;
-    /** Whether the parsed result is a DID string */
-    isDID: boolean;
-    /** Whether the parsed result is an object with a 'secret' property */
-    hasSecret: boolean;
-    /** Type of the 'secret' property if it exists */
-    secretType?: string;
-    /** Whether the 'secret' is an array */
-    secretIsArray?: boolean;
-    /** Length of the 'secret' array if it's an array */
-    secretLength?: number | string;
-    /** Preview of the session text (first 100 chars) */
-    sessionPreview?: string;
-    /** Any error that occurred during validation */
-    error?: string;
-}
-/**
- * Validate and analyze session bytes format
- * Handles both JSON objects and DID strings safely
- *
- * @param sessionBytes - The session bytes to validate
- * @param logger - Logger instance for debug/error output
- * @param context - Optional context for logging
- * @returns Validation result object
- */
-export declare function validateSessionBytes(sessionBytes: Uint8Array, logger: Logger, context?: string): SessionValidationResult;

package/dist/src/utils/shape.d.ts

@@ -1,30 +0,0 @@
-/**
- * Runtime shape guards for SDK response decoding.
- *
- * The contract layer is the source of truth for response shapes, but the
- * SDK's typed wrappers (`result as T`) are pure compile-time casts that
- * silently accept anything if a contract drifts or returns an unexpected
- * payload past the heuristic refusal-string check. `assertShape` lets the
- * outermost SDK boundary throw a deterministic, named error at the call
- * site rather than letting callers reach for `.admins` on `undefined`
- * deep in their own code.
- *
- * Predicates are intentionally shallow — they validate the immediate
- * top-level structure (object kind, presence/type of leading fields)
- * but do not deeply validate nested elements (e.g. each `UserGrant`
- * inside `OrgContractGrants.grants`). Deep validation would be brittle
- * against benign contract additions; shallow guards catch the failure
- * modes that actually surface as runtime crashes (null/string/missing
- * top-level field).
- */
-/** Narrowing helper: value is a non-null object record. */
-export declare function isObject(value: unknown): value is Record<string, unknown>;
-/**
- * Run a type-predicate guard against `value` and throw a named error if
- * it fails. Returns the value typed as `T` on success.
- *
- * @param where - call-site identifier included in the thrown error
- *   message (e.g. `'org-policy-get'`) so operators can grep logs back
- *   to the offending RPC.
- */
-export declare function assertShape<T>(value: unknown, guard: (v: unknown) => v is T, where: string): T;

package/dist/src/wasm/index.d.ts

@@ -1,5 +0,0 @@
-/**
- * WASM integration exports for T3n SDK
- */
-export * from "./interface";
-export * from "./loader";

package/dist/src/wasm/interface.d.ts

@@ -1,110 +0,0 @@
-/**
- * WASM Component Interface - Mirrors the WIT specification exactly
- *
- * This interface works with completely opaque byte arrays, just like the WIT interface.
- * The TypeScript SDK doesn't know about internal state machine phases or details.
- */
-/**
- * Result type for WASM next() operations
- */
-export interface WasmNextResult {
-    state: Uint8Array;
-    request: Uint8Array;
-}
-/**
- * Client handshake operations - completely opaque byte arrays only
- */
-export interface ClientHandshake {
-    /**
-     * Process next step in handshake
-     * @param state - Current handshake state (null for initial call)
-     * @param action - Action to process (opaque bytes)
-     * @returns Promise with new state and request to send
-     */
-    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
-    /**
-     * Attempt to finalize handshake
-     * @param state - Current handshake state
-     * @returns Promise with session bytes if successful
-     * @throws Error containing "not yet finalized" if the state machine
-     *         has not reached its terminal phase. The SDK runtime treats
-     *         this as the loop's "keep going" signal, not a real error.
-     */
-    finish(state: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * Client authentication operations - completely opaque byte arrays only
- */
-export interface ClientAuth {
-    /**
-     * Process next step in authentication
-     * @param state - Current auth state (null for initial call)
-     * @param action - Action to process (opaque bytes)
-     * @returns Promise with new state and request to send
-     */
-    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
-    /**
-     * Attempt to finalize authentication
-     * @param state - Current auth state
-     * @returns Promise with DID bytes if successful
-     * @throws Error containing "not yet finalized" if the state machine
-     *         has not reached its terminal phase. The SDK runtime treats
-     *         this as the loop's "keep going" signal, not a real error.
-     */
-    finish(state: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * Client authentication operations - completely opaque byte arrays only
- */
-export interface ClientExecute {
-    /**
-     * Process next step in authentication
-     * @param state - Current auth state (null for initial call)
-     * @param action - Action to process (opaque bytes)
-     * @returns Promise with new state and request to send
-     */
-    next(state: Uint8Array | null, action: Uint8Array): Promise<WasmNextResult>;
-    /**
-     * Attempt to finalize authentication
-     * @param state - Current auth state
-     * @returns Promise with DID bytes if successful
-     * @throws Error containing "not yet finalized" if the state machine
-     *         has not reached its terminal phase. The SDK runtime treats
-     *         this as the loop's "keep going" signal, not a real error.
-     */
-    finish(state: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * Session encryption/decryption operations - completely opaque byte arrays only
- */
-export interface SessionCrypto {
-    /**
-     * Encrypt plaintext using session
-     * @param session - Session state (opaque bytes)
-     * @param plaintext - Data to encrypt
-     * @returns Promise with encrypted bytes
-     */
-    encrypt(session: Uint8Array, plaintext: Uint8Array): Promise<Uint8Array>;
-    /**
-     * Decrypt ciphertext using session
-     * @param session - Session state (opaque bytes)
-     * @param ciphertext - Data to decrypt
-     * @returns Promise with decrypted bytes
-     */
-    decrypt(session: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * Main WASM Component interface - mirrors the WIT interface exactly
- *
- * This is completely opaque to the TypeScript layer. All state machine logic,
- * authentication flows, and cryptographic operations are handled in WASM.
- */
-export interface WasmComponent {
-    /** Client-side state machines exported by the WASM component. */
-    flow: {
-        handshake: ClientHandshake;
-        auth: ClientAuth;
-        execute: ClientExecute;
-    };
-    session: SessionCrypto;
-}

package/dist/src/wasm/loader.d.ts

@@ -1,43 +0,0 @@
-/**
- * WASM Component Loader
- *
- * This module provides utilities for loading and initializing the WASM component.
- * The actual WASM loading implementation will depend on the build system and
- * deployment environment.
- */
-import { WasmComponent } from "./interface";
-import { Logger } from "../utils/logger";
-/**
- * Configuration for WASM component loading
- */
-export interface WasmLoadConfig {
-    /** Path or URL to the WASM module */
-    wasmPath?: string;
-    /** Custom fetch function for loading WASM */
-    fetchFn?: typeof fetch;
-    /** Additional initialization options */
-    initOptions?: Record<string, unknown>;
-    /** Optional logger instance - if not provided, uses global default */
-    logger?: Logger;
-}
-/**
- * Load and initialize the T3n WASM component
- *
- * @param config - Optional configuration for loading the WASM component
- * @returns Promise that resolves to the initialized WASM component
- *
- * @example
- * ```typescript
- * const wasmComponent = await loadWasmComponent({
- *   wasmPath: '/path/to/t3n.wasm'
- * });
- * ```
- */
-export declare function loadWasmComponent(config?: WasmLoadConfig): Promise<WasmComponent>;
-/**
- * Load the real T3n WASM component
- *
- * @param logger - Logger instance for WASM operations
- * @returns Promise that resolves to the initialized WASM component
- */
-export declare function loadRealWasmComponent(logger: Logger): Promise<WasmComponent>;