@terminal3/t3n-sdk 0.2.1

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

@@ -0,0 +1,61 @@
+/**
+ * Error classes for T3n SDK
+ */
+/**
+ * Base error class for T3n SDK errors
+ */
+export declare class T3nError extends Error {
+    readonly code?: string | undefined;
+    constructor(message: string, code?: string | undefined);
+}
+/**
+ * Error thrown when session is in invalid state for operation
+ */
+export declare class SessionStateError extends T3nError {
+    readonly currentState: string;
+    constructor(message: string, currentState: string);
+}
+/**
+ * Error thrown during authentication process
+ */
+export declare class AuthenticationError extends T3nError {
+    readonly authMethod?: string | undefined;
+    constructor(message: string, authMethod?: string | undefined);
+}
+/**
+ * Error thrown during handshake process
+ */
+export declare class HandshakeError extends T3nError {
+    constructor(message: string);
+}
+/**
+ * Error thrown during RPC communication
+ */
+export declare class RpcError extends T3nError {
+    readonly rpcMethod?: string | undefined;
+    readonly httpStatus?: number | undefined;
+    constructor(message: string, rpcMethod?: string | undefined, httpStatus?: number | undefined);
+}
+/**
+ * Error thrown when WASM operations fail
+ */
+export declare class WasmError extends T3nError {
+    readonly operation?: string | undefined;
+    readonly payload?: unknown | undefined;
+    constructor(message: string, operation?: string | undefined, payload?: unknown | undefined);
+}
+/**
+ * Decode WASM error message from comma-separated byte array format
+ * WASM errors often come as "83,101,114,100,101..." which represents ASCII bytes
+ *
+ * @param errorMessage - The error message string that may contain comma-separated bytes
+ * @returns Decoded error message if it was encoded, otherwise original message
+ */
+export declare function decodeWasmErrorMessage(errorMessage: string): string;
+/**
+ * Extract and decode error from WASM ComponentError
+ *
+ * @param error - The error object from WASM
+ * @returns Decoded error message
+ */
+export declare function extractWasmError(error: unknown): string;

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

@@ -0,0 +1,9 @@
+/**
+ * Utility exports for T3n SDK
+ */
+export * from "./crypto";
+export * from "./contract-version";
+export * from "./errors";
+export * from "./logger";
+export * from "./redaction";
+export * from "./session";

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

@@ -0,0 +1,102 @@
+/**
+ * Logger interface and implementations for T3n SDK
+ *
+ * Provides hierarchical log level control (DEBUG, INFO, WARN, ERROR) with
+ * global defaults and per-component override capabilities.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import { getLogger, setGlobalLogLevel, LogLevel } from '@t3n-sdk/logger';
+ *
+ * // Use the global logger (defaults to ERROR level)
+ * const logger = getLogger();
+ * logger.error("This will be logged");
+ * logger.debug("This will NOT be logged by default");
+ *
+ * // Enable debug logging globally
+ * setGlobalLogLevel(LogLevel.DEBUG);
+ * const debugLogger = getLogger();
+ * debugLogger.debug("This will now be logged");
+ *
+ * // Create a logger with a specific level (overrides global)
+ * const infoLogger = createLogger(LogLevel.INFO);
+ * infoLogger.info("This will be logged");
+ * infoLogger.debug("This will NOT be logged");
+ * ```
+ *
+ * ## Log Levels
+ *
+ * - `DEBUG` (0): Most verbose, logs everything
+ * - `INFO` (1): Logs info, warnings, and errors
+ * - `WARN` (2): Logs warnings and errors only
+ * - `ERROR` (3): Logs errors only (default)
+ */
+/**
+ * Log levels in hierarchical order (lower values = more verbose)
+ */
+export declare enum LogLevel {
+    DEBUG = 0,
+    INFO = 1,
+    WARN = 2,
+    ERROR = 3
+}
+/**
+ * Logger interface for SDK debugging and monitoring
+ */
+export interface Logger {
+    /**
+     * Log a debug message (most verbose)
+     * @param args - Arguments to log
+     */
+    debug(...args: any[]): void;
+    /**
+     * Log an info message
+     * @param args - Arguments to log
+     */
+    info(...args: any[]): void;
+    /**
+     * Log a warning message
+     * @param args - Arguments to log
+     */
+    warn(...args: any[]): void;
+    /**
+     * Log an error message (least verbose)
+     * @param args - Arguments to log
+     */
+    error(...args: any[]): void;
+}
+/**
+ * Set the global default log level for all components
+ *
+ * This affects all loggers created without an explicit log level.
+ * The default global log level is LogLevel.ERROR (only errors are logged).
+ *
+ * @param level - The log level to set as default for all components
+ *
+ * @example
+ * ```typescript
+ * // Enable debug logging globally
+ * setGlobalLogLevel(LogLevel.DEBUG);
+ *
+ * // Only log errors (default)
+ * setGlobalLogLevel(LogLevel.ERROR);
+ * ```
+ */
+export declare function setGlobalLogLevel(level: LogLevel): void;
+/**
+ * Get the current global log level
+ * @returns The current global log level (default: LogLevel.ERROR)
+ */
+export declare function getGlobalLogLevel(): LogLevel;
+/**
+ * Create a logger instance with the specified log level
+ * @param level - The log level for this logger. If not provided, defaults to the global log level (LogLevel.ERROR).
+ * @returns Logger instance configured with the specified or default log level
+ */
+export declare function createLogger(level?: LogLevel): Logger;
+/**
+ * Get a logger instance using the global log level
+ * @returns Logger instance with global log level (default: LogLevel.ERROR)
+ */
+export declare function getLogger(): Logger;

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

@@ -0,0 +1,13 @@
+/**
+ * Secret redaction utilities for T3n SDK
+ *
+ * Provides functions to redact sensitive information before logging
+ */
+/**
+ * Redact secrets from values before logging
+ */
+export declare function redactSecrets(value: any): any;
+/**
+ * Redact secrets from a JSON string
+ */
+export declare function redactSecretsFromJson(jsonString: string): string;

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

@@ -0,0 +1,37 @@
+/**
+ * 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/wasm/index.d.ts

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

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

@@ -0,0 +1,105 @@
+/**
+ * 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 if handshake not ready to finalize
+     */
+    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 if authentication not ready to finalize
+     */
+    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 if authentication not ready to finalize
+     */
+    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 nonce - Nonce to use for encryption
+     * @param plaintext - Data to encrypt
+     * @returns Promise with encrypted bytes
+     */
+    encrypt(session: Uint8Array, nonce: 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 handshake operations */
+    flow: {
+        handshake: ClientHandshake;
+        auth: ClientAuth;
+        execute: ClientExecute;
+    };
+    session: SessionCrypto;
+}

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

@@ -0,0 +1,43 @@
+/**
+ * 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, any>;
+    /** 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>;

package/dist/wasm/generated/interfaces/component-session-client-auth.d.ts

@@ -0,0 +1,12 @@
+/** @module Interface component:session/client-auth@0.1.0 **/
+export function next(state: State | undefined, action: HostToGuest): NewState;
+export function finish(state: State): Did;
+export type GuestToHost = Uint8Array;
+export type State = Uint8Array;
+export type HostToGuest = Uint8Array;
+export type Did = Uint8Array;
+export type Error = Uint8Array;
+export interface NewState {
+  state: State,
+  request: GuestToHost,
+}

package/dist/wasm/generated/interfaces/component-session-client-handshake.d.ts

@@ -0,0 +1,12 @@
+/** @module Interface component:session/client-handshake@0.1.0 **/
+export function next(state: State | undefined, action: HostToGuest): NewState;
+export function finish(state: State): SessionState;
+export type GuestToHost = Uint8Array;
+export type State = Uint8Array;
+export type HostToGuest = Uint8Array;
+export type SessionState = Uint8Array;
+export type Error = Uint8Array;
+export interface NewState {
+  state: State,
+  request: GuestToHost,
+}

package/dist/wasm/generated/interfaces/component-session-server-auth.d.ts

@@ -0,0 +1,12 @@
+/** @module Interface component:session/server-auth@0.1.0 **/
+export function next(state: State | undefined, action: HostToGuest): NewState;
+export function finish(state: State): Did;
+export type GuestToHost = Uint8Array;
+export type State = Uint8Array;
+export type HostToGuest = Uint8Array;
+export type Did = Uint8Array;
+export type Error = Uint8Array;
+export interface NewState {
+  state: State,
+  request: GuestToHost,
+}

package/dist/wasm/generated/interfaces/component-session-server-handshake.d.ts

@@ -0,0 +1,12 @@
+/** @module Interface component:session/server-handshake@0.1.0 **/
+export function next(state: State | undefined, action: HostToGuest): NewState;
+export function finish(state: State): SessionState;
+export type GuestToHost = Uint8Array;
+export type State = Uint8Array;
+export type HostToGuest = Uint8Array;
+export type SessionState = Uint8Array;
+export type Error = Uint8Array;
+export interface NewState {
+  state: State,
+  request: GuestToHost,
+}

package/dist/wasm/generated/interfaces/component-session-session.d.ts

@@ -0,0 +1,8 @@
+/** @module Interface component:session/session@0.1.0 **/
+export function encrypt(session: Session, nonce: Nonce, plaintext: Plaintext): Ciphertext;
+export function decrypt(session: Session, ciphertext: Ciphertext): Plaintext;
+export type Error = Uint8Array;
+export type Session = Uint8Array;
+export type Plaintext = Uint8Array;
+export type Ciphertext = Uint8Array;
+export type Nonce = Uint8Array;

package/dist/wasm/generated/interfaces/wasi-cli-environment.d.ts

@@ -0,0 +1,2 @@
+/** @module Interface wasi:cli/environment@0.2.4 **/
+export function getEnvironment(): Array<[string, string]>;

package/dist/wasm/generated/interfaces/wasi-cli-exit.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/exit@0.2.4 **/
+export function exit(status: Result<void, void>): void;
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/dist/wasm/generated/interfaces/wasi-cli-stderr.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stderr@0.2.4 **/
+export function getStderr(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

package/dist/wasm/generated/interfaces/wasi-cli-stdin.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stdin@0.2.4 **/
+export function getStdin(): InputStream;
+export type InputStream = import('./wasi-io-streams.js').InputStream;

package/dist/wasm/generated/interfaces/wasi-cli-stdout.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:cli/stdout@0.2.4 **/
+export function getStdout(): OutputStream;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;

package/dist/wasm/generated/interfaces/wasi-clocks-wall-clock.d.ts

@@ -0,0 +1,5 @@
+/** @module Interface wasi:clocks/wall-clock@0.2.4 **/
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}

package/dist/wasm/generated/interfaces/wasi-filesystem-preopens.d.ts

@@ -0,0 +1,3 @@
+/** @module Interface wasi:filesystem/preopens@0.2.4 **/
+export function getDirectories(): Array<[Descriptor, string]>;
+export type Descriptor = import('./wasi-filesystem-types.js').Descriptor;

package/dist/wasm/generated/interfaces/wasi-filesystem-types.d.ts

@@ -0,0 +1,124 @@
+/** @module Interface wasi:filesystem/types@0.2.4 **/
+export function filesystemErrorCode(err: Error): ErrorCode | undefined;
+export type Error = import('./wasi-io-streams.js').Error;
+/**
+ * # Variants
+ * 
+ * ## `"access"`
+ * 
+ * ## `"would-block"`
+ * 
+ * ## `"already"`
+ * 
+ * ## `"bad-descriptor"`
+ * 
+ * ## `"busy"`
+ * 
+ * ## `"deadlock"`
+ * 
+ * ## `"quota"`
+ * 
+ * ## `"exist"`
+ * 
+ * ## `"file-too-large"`
+ * 
+ * ## `"illegal-byte-sequence"`
+ * 
+ * ## `"in-progress"`
+ * 
+ * ## `"interrupted"`
+ * 
+ * ## `"invalid"`
+ * 
+ * ## `"io"`
+ * 
+ * ## `"is-directory"`
+ * 
+ * ## `"loop"`
+ * 
+ * ## `"too-many-links"`
+ * 
+ * ## `"message-size"`
+ * 
+ * ## `"name-too-long"`
+ * 
+ * ## `"no-device"`
+ * 
+ * ## `"no-entry"`
+ * 
+ * ## `"no-lock"`
+ * 
+ * ## `"insufficient-memory"`
+ * 
+ * ## `"insufficient-space"`
+ * 
+ * ## `"not-directory"`
+ * 
+ * ## `"not-empty"`
+ * 
+ * ## `"not-recoverable"`
+ * 
+ * ## `"unsupported"`
+ * 
+ * ## `"no-tty"`
+ * 
+ * ## `"no-such-device"`
+ * 
+ * ## `"overflow"`
+ * 
+ * ## `"not-permitted"`
+ * 
+ * ## `"pipe"`
+ * 
+ * ## `"read-only"`
+ * 
+ * ## `"invalid-seek"`
+ * 
+ * ## `"text-file-busy"`
+ * 
+ * ## `"cross-device"`
+ */
+export type ErrorCode = 'access' | 'would-block' | 'already' | 'bad-descriptor' | 'busy' | 'deadlock' | 'quota' | 'exist' | 'file-too-large' | 'illegal-byte-sequence' | 'in-progress' | 'interrupted' | 'invalid' | 'io' | 'is-directory' | 'loop' | 'too-many-links' | 'message-size' | 'name-too-long' | 'no-device' | 'no-entry' | 'no-lock' | 'insufficient-memory' | 'insufficient-space' | 'not-directory' | 'not-empty' | 'not-recoverable' | 'unsupported' | 'no-tty' | 'no-such-device' | 'overflow' | 'not-permitted' | 'pipe' | 'read-only' | 'invalid-seek' | 'text-file-busy' | 'cross-device';
+export type Filesize = bigint;
+export type OutputStream = import('./wasi-io-streams.js').OutputStream;
+/**
+ * # Variants
+ * 
+ * ## `"unknown"`
+ * 
+ * ## `"block-device"`
+ * 
+ * ## `"character-device"`
+ * 
+ * ## `"directory"`
+ * 
+ * ## `"fifo"`
+ * 
+ * ## `"symbolic-link"`
+ * 
+ * ## `"regular-file"`
+ * 
+ * ## `"socket"`
+ */
+export type DescriptorType = 'unknown' | 'block-device' | 'character-device' | 'directory' | 'fifo' | 'symbolic-link' | 'regular-file' | 'socket';
+export type LinkCount = bigint;
+export type Datetime = import('./wasi-clocks-wall-clock.js').Datetime;
+export interface DescriptorStat {
+  type: DescriptorType,
+  linkCount: LinkCount,
+  size: Filesize,
+  dataAccessTimestamp?: Datetime,
+  dataModificationTimestamp?: Datetime,
+  statusChangeTimestamp?: Datetime,
+}
+
+export class Descriptor {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  writeViaStream(offset: Filesize): OutputStream;
+  appendViaStream(): OutputStream;
+  getType(): DescriptorType;
+  stat(): DescriptorStat;
+}

package/dist/wasm/generated/interfaces/wasi-io-error.d.ts

@@ -0,0 +1,8 @@
+/** @module Interface wasi:io/error@0.2.4 **/
+
+export class Error {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+}

package/dist/wasm/generated/interfaces/wasi-io-streams.d.ts

@@ -0,0 +1,28 @@
+/** @module Interface wasi:io/streams@0.2.4 **/
+export type Error = import('./wasi-io-error.js').Error;
+export type StreamError = StreamErrorLastOperationFailed | StreamErrorClosed;
+export interface StreamErrorLastOperationFailed {
+  tag: 'last-operation-failed',
+  val: Error,
+}
+export interface StreamErrorClosed {
+  tag: 'closed',
+}
+
+export class InputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+}
+
+export class OutputStream {
+  /**
+   * This type does not have a public constructor.
+   */
+  private constructor();
+  checkWrite(): bigint;
+  write(contents: Uint8Array): void;
+  blockingWriteAndFlush(contents: Uint8Array): void;
+  blockingFlush(): void;
+}

package/dist/wasm/generated/session.d.ts

@@ -0,0 +1,16 @@
+// world root:component/root
+export type * as WasiCliEnvironment024 from './interfaces/wasi-cli-environment.js'; // import wasi:cli/environment@0.2.4
+export type * as WasiCliExit024 from './interfaces/wasi-cli-exit.js'; // import wasi:cli/exit@0.2.4
+export type * as WasiCliStderr024 from './interfaces/wasi-cli-stderr.js'; // import wasi:cli/stderr@0.2.4
+export type * as WasiCliStdin024 from './interfaces/wasi-cli-stdin.js'; // import wasi:cli/stdin@0.2.4
+export type * as WasiCliStdout024 from './interfaces/wasi-cli-stdout.js'; // import wasi:cli/stdout@0.2.4
+export type * as WasiClocksWallClock024 from './interfaces/wasi-clocks-wall-clock.js'; // import wasi:clocks/wall-clock@0.2.4
+export type * as WasiFilesystemPreopens024 from './interfaces/wasi-filesystem-preopens.js'; // import wasi:filesystem/preopens@0.2.4
+export type * as WasiFilesystemTypes024 from './interfaces/wasi-filesystem-types.js'; // import wasi:filesystem/types@0.2.4
+export type * as WasiIoError024 from './interfaces/wasi-io-error.js'; // import wasi:io/error@0.2.4
+export type * as WasiIoStreams024 from './interfaces/wasi-io-streams.js'; // import wasi:io/streams@0.2.4
+export * as clientAuth from './interfaces/component-session-client-auth.js'; // export component:session/client-auth@0.1.0
+export * as serverAuth from './interfaces/component-session-server-auth.js'; // export component:session/server-auth@0.1.0
+export * as clientHandshake from './interfaces/component-session-client-handshake.js'; // export component:session/client-handshake@0.1.0
+export * as serverHandshake from './interfaces/component-session-server-handshake.js'; // export component:session/server-handshake@0.1.0
+export * as session from './interfaces/component-session-session.js'; // export component:session/session@0.1.0