@scrawn/core 0.0.2

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Central configuration for the Scrawn SDK.
+ * All configuration values should be defined here for easy maintenance.
+ */
+export declare const ScrawnConfig: {
+    /**
+     * gRPC client configuration
+     */
+    readonly grpc: {
+        /**
+         * HTTP version to use for gRPC transport.
+         */
+        readonly httpVersion: "1.1";
+    };
+    /**
+     * Logging configuration
+     */
+    readonly logging: {
+        /**
+         * Enable debug logs
+         */
+        readonly enableDebug: false;
+    };
+};
+export type ScrawnConfig = typeof ScrawnConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,YAAY;IACvB;;OAEG;;QAED;;WAEG;;;IAKL;;OAEG;;QAED;;WAEG;;;CAGG,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC"}

package/dist/config.js

@@ -0,0 +1,25 @@
+/**
+ * Central configuration for the Scrawn SDK.
+ * All configuration values should be defined here for easy maintenance.
+ */
+export const ScrawnConfig = {
+    /**
+     * gRPC client configuration
+     */
+    grpc: {
+        /**
+         * HTTP version to use for gRPC transport.
+         */
+        httpVersion: '1.1',
+    },
+    /**
+     * Logging configuration
+     */
+    logging: {
+        /**
+         * Enable debug logs
+         */
+        enableDebug: false,
+    },
+};
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,CAAC,MAAM,YAAY,GAAG;IAC1B;;OAEG;IACH,IAAI,EAAE;QACJ;;WAEG;QACH,WAAW,EAAE,KAAc;KAE5B;IAED;;OAEG;IACH,OAAO,EAAE;QACP;;WAEG;QACH,WAAW,EAAE,KAAK;KACnB;CACO,CAAC"}

package/dist/core/auth/apiKeyAuth.d.ts

@@ -0,0 +1,67 @@
+import { AuthBase } from './baseAuth.js';
+import type { Scrawn } from '../scrawn.js';
+/**
+ * API key format: sk_ followed by 16 alphanumeric characters
+ * @example 'sk_abc123def456ghi7'
+ */
+export type ApiKeyFormat = `scrn_${string}`;
+/**
+ * Type guard to validate API key format
+ */
+export declare function isValidApiKey(key: string): key is ApiKeyFormat;
+/**
+ * Validates and returns a properly typed API key
+ * @throws Error if the API key format is invalid
+ */
+export declare function validateApiKey(key: string): ApiKeyFormat;
+/**
+ * Credentials structure for API key authentication.
+ */
+export type ApiKeyAuthCreds = {
+    apiKey: ApiKeyFormat;
+};
+/**
+ * Simple API key authentication method.
+ *
+ * Provides authentication using a static API key.
+ * This is the default authentication method registered by the SDK.
+ *
+ * @example
+ * ```typescript
+ * const auth = new ApiKeyAuth('sk_test_...');
+ * scrawn.registerAuthMethod('api', auth);
+ * ```
+ */
+export declare class ApiKeyAuth extends AuthBase<ApiKeyAuthCreds> {
+    /** Authentication method identifier */
+    name: "api";
+    /** Validated API key */
+    private validatedKey;
+    /**
+     * Creates a new API key authentication instance.
+     *
+     * @param apiKey - Your Scrawn API key (format: sk_<16 alphanumeric chars>)
+     * @throws Error if API key format is invalid
+     */
+    constructor(apiKey: string);
+    /**
+     * Initialize the API key auth method.
+     * No additional setup is required for API key authentication.
+     *
+     * @param scrawn - The Scrawn SDK instance (optional, unused)
+     */
+    init(scrawn?: Scrawn): Promise<void>;
+    /**
+     * Get the API key credentials.
+     *
+     * @returns A promise that resolves to an object containing the API key
+     *
+     * @example
+     * ```typescript
+     * const creds = await auth.getCreds();
+     * // { apiKey: 'sk_abc123def456ghi7' }
+     * ```
+     */
+    getCreds(): Promise<ApiKeyAuthCreds>;
+}
+//# sourceMappingURL=apiKeyAuth.d.ts.map

package/dist/core/auth/apiKeyAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiKeyAuth.d.ts","sourceRoot":"","sources":["../../../src/core/auth/apiKeyAuth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAK3C;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,QAAQ,MAAM,EAAE,CAAC;AAE5C;;GAEG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,IAAI,YAAY,CAE9D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,CAQxD;AAED;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,YAAY,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,qBAAa,UAAW,SAAQ,QAAQ,CAAC,eAAe,CAAC;IACvD,uCAAuC;IACvC,IAAI,EAAG,KAAK,CAAU;IAEtB,wBAAwB;IACxB,OAAO,CAAC,YAAY,CAAe;IAEnC;;;;;OAKG;gBACS,MAAM,EAAE,MAAM;IAK1B;;;;;OAKG;IACG,IAAI,CAAC,MAAM,CAAC,EAAE,MAAM;IAK1B;;;;;;;;;;OAUG;IACG,QAAQ,IAAI,OAAO,CAAC,eAAe,CAAC;CAG3C"}

package/dist/core/auth/apiKeyAuth.js

@@ -0,0 +1,71 @@
+import { AuthBase } from './baseAuth.js';
+import { ScrawnLogger } from '../../utils/logger.js';
+const log = new ScrawnLogger('Auth');
+/**
+ * Type guard to validate API key format
+ */
+export function isValidApiKey(key) {
+    return /^scrn_[a-zA-Z0-9]{32}$/.test(key);
+}
+/**
+ * Validates and returns a properly typed API key
+ * @throws Error if the API key format is invalid
+ */
+export function validateApiKey(key) {
+    if (!isValidApiKey(key)) {
+        log.error(`Invalid API key format: "${key}".`);
+        throw new Error(`Invalid API key format. Expected format: sk_<16 alphanumeric characters>. Got: ${key.substring(0, 10)}...`);
+    }
+    return key;
+}
+/**
+ * Simple API key authentication method.
+ *
+ * Provides authentication using a static API key.
+ * This is the default authentication method registered by the SDK.
+ *
+ * @example
+ * ```typescript
+ * const auth = new ApiKeyAuth('sk_test_...');
+ * scrawn.registerAuthMethod('api', auth);
+ * ```
+ */
+export class ApiKeyAuth extends AuthBase {
+    /**
+     * Creates a new API key authentication instance.
+     *
+     * @param apiKey - Your Scrawn API key (format: sk_<16 alphanumeric chars>)
+     * @throws Error if API key format is invalid
+     */
+    constructor(apiKey) {
+        super();
+        /** Authentication method identifier */
+        this.name = 'api';
+        this.validatedKey = validateApiKey(apiKey);
+    }
+    /**
+     * Initialize the API key auth method.
+     * No additional setup is required for API key authentication.
+     *
+     * @param scrawn - The Scrawn SDK instance (optional, unused)
+     */
+    async init(scrawn) {
+        // nothing extra for now
+        return;
+    }
+    /**
+     * Get the API key credentials.
+     *
+     * @returns A promise that resolves to an object containing the API key
+     *
+     * @example
+     * ```typescript
+     * const creds = await auth.getCreds();
+     * // { apiKey: 'sk_abc123def456ghi7' }
+     * ```
+     */
+    async getCreds() {
+        return { apiKey: this.validatedKey };
+    }
+}
+//# sourceMappingURL=apiKeyAuth.js.map

package/dist/core/auth/apiKeyAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apiKeyAuth.js","sourceRoot":"","sources":["../../../src/core/auth/apiKeyAuth.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,MAAM,CAAC,CAAC;AAQrC;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC5C,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,cAAc,CAAC,GAAW;IACxC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,CAAC;QACxB,GAAG,CAAC,KAAK,CAAC,4BAA4B,GAAG,IAAI,CAAC,CAAC;QAC/C,MAAM,IAAI,KAAK,CACb,kFAAkF,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAC5G,CAAC;IACJ,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AASD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,UAAW,SAAQ,QAAyB;IAOvD;;;;;OAKG;IACH,YAAY,MAAc;QACxB,KAAK,EAAE,CAAC;QAbV,uCAAuC;QACvC,SAAI,GAAG,KAAc,CAAC;QAapB,IAAI,CAAC,YAAY,GAAG,cAAc,CAAC,MAAM,CAAC,CAAC;IAC7C,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,CAAC,MAAe;QACxB,wBAAwB;QACxB,OAAO;IACT,CAAC;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,QAAQ;QACZ,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,CAAC;IACvC,CAAC;CACF"}

package/dist/core/auth/baseAuth.d.ts

@@ -0,0 +1,92 @@
+import type { Scrawn } from '../scrawn.js';
+/**
+ * Abstract base class for authentication methods.
+ *
+ * All authentication implementations must extend this class and implement the required methods.
+ * Auth methods are responsible for managing and providing credentials for API requests.
+ *
+ * @template TCreds - The type of credentials this auth method returns
+ *
+ * @example
+ * ```typescript
+ * type MyAuthCreds = { token: string };
+ *
+ * export class MyAuth extends AuthBase<MyAuthCreds> {
+ *   name = 'my_auth';
+ *
+ *   async init(scrawn: Scrawn) {
+ *     // Setup logic here
+ *   }
+ *
+ *   async getCreds(): Promise<MyAuthCreds> {
+ *     return { token: 'my_token' };
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class AuthBase<TCreds = unknown> {
+    /**
+     * Unique identifier for this authentication method.
+     * Used to register and reference the auth method (e.g., 'api', 'oauth').
+     */
+    abstract name: string;
+    /**
+     * Initialize the authentication method.
+     *
+     * Called once during SDK setup. Use this to perform any necessary
+     * initialization like token validation or refresh.
+     *
+     * @param scrawn - The Scrawn SDK instance
+     * @returns A promise that resolves when initialization is complete
+     */
+    abstract init(scrawn: Scrawn): Promise<void>;
+    /**
+     * Retrieve the current credentials for this authentication method.
+     *
+     * This method is called whenever an event needs to authenticate.
+     * Credentials are cached by the SDK, so this is typically only called once.
+     *
+     * @returns A promise that resolves to the credentials object
+     *
+     * @example
+     * ```typescript
+     * async getCreds(): Promise<MyAuthCreds> {
+     *   return { apiKey: this.apiKey };
+     * }
+     * ```
+     */
+    abstract getCreds(): Promise<TCreds>;
+    /**
+     * Optional hook that runs before each event is processed.
+     *
+     * Use this for operations that must happen before every request,
+     * such as token refresh checks or rate limiting.
+     *
+     * @returns A promise that resolves when the pre-run hook completes
+     *
+     * @example
+     * ```typescript
+     * async preRun() {
+     *   await this.refreshTokenIfNeeded();
+     * }
+     * ```
+     */
+    preRun?(): Promise<void>;
+    /**
+      * Optional hook that runs after each event is processed.
+      *
+      * Use this for cleanup operations or logging that should happen
+      * after every request completes.
+      *
+      * @returns A promise that resolves when the post-run hook completes
+      *
+      * @example
+      * ```typescript
+      * async postRun() {
+      *   await this.logRequestMetrics();
+      * }
+      * ```
+      */
+    postRun?(): Promise<void>;
+}
+//# sourceMappingURL=baseAuth.d.ts.map

package/dist/core/auth/baseAuth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseAuth.d.ts","sourceRoot":"","sources":["../../../src/core/auth/baseAuth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,8BAAsB,QAAQ,CAAC,MAAM,GAAG,OAAO;IAC7C;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAE5C;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CAAC,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;IAEpC;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;IAExB;;;;;;;;;;;;;;QAcI;IACF,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC;CAC5B"}

package/dist/core/auth/baseAuth.js

@@ -0,0 +1,28 @@
+/**
+ * Abstract base class for authentication methods.
+ *
+ * All authentication implementations must extend this class and implement the required methods.
+ * Auth methods are responsible for managing and providing credentials for API requests.
+ *
+ * @template TCreds - The type of credentials this auth method returns
+ *
+ * @example
+ * ```typescript
+ * type MyAuthCreds = { token: string };
+ *
+ * export class MyAuth extends AuthBase<MyAuthCreds> {
+ *   name = 'my_auth';
+ *
+ *   async init(scrawn: Scrawn) {
+ *     // Setup logic here
+ *   }
+ *
+ *   async getCreds(): Promise<MyAuthCreds> {
+ *     return { token: 'my_token' };
+ *   }
+ * }
+ * ```
+ */
+export class AuthBase {
+}
+//# sourceMappingURL=baseAuth.js.map

package/dist/core/auth/baseAuth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"baseAuth.js","sourceRoot":"","sources":["../../../src/core/auth/baseAuth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,OAAgB,QAAQ;CAoE7B"}

package/dist/core/grpc/client.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Type-safe gRPC client abstraction layer.
+ *
+ * This module provides the main entry point for making gRPC calls with
+ * full compile-time type safety and a beautiful fluent API.
+ *
+ * @example
+ * ```typescript
+ * const client = new GrpcClient('https://api.scrawn.dev');
+ *
+ * const response = await client
+ *   .newCall(EventService, 'registerEvent')
+ *   .addHeader('Authorization', `Bearer ${apiKey}`)
+ *   .addHeader('x-request-id', '123')
+ *   .addPayload({
+ *     type: EventType.SDK_CALL,
+ *     userId: 'user_123',
+ *     data: { case: 'sdkCall', value: new SDKCall({ sdkCallType: SDKCallType.RAW, debitAmount: 10 }) }
+ *   })
+ *   .request();
+ * ```
+ */
+import type { Transport } from '@connectrpc/connect';
+import type { ServiceType } from '@bufbuild/protobuf';
+import { RequestBuilder } from './requestBuilder.js';
+import type { ServiceMethodNames } from './types.js';
+/**
+ * Main gRPC client for making type-safe API calls.
+ *
+ * This class manages the underlying transport and provides a factory method
+ * for creating type-safe request builders. Each request builder is bound to
+ * a specific service and method, ensuring compile-time type safety.
+ *
+ * The client handles:
+ * - Transport configuration (HTTP/1.1)
+ * - Request building with fluent API
+ * - Header management (auth should be added via .addHeader())
+ * - Error handling and logging
+ *
+ * @example
+ * ```typescript
+ * // Initialize the client
+ * const client = new GrpcClient('https://api.scrawn.dev');
+ *
+ * // Fetch credentials from your auth system
+ * const creds = await getCredentials();
+ *
+ * // Make a call to EventService.registerEvent
+ * const eventResponse = await client
+ *   .newCall(EventService, 'registerEvent')
+ *   .addHeader('Authorization', `Bearer ${creds.apiKey}`)
+ *   .addPayload({ type: EventType.SDK_CALL, userId: 'u123', ... })
+ *   .request();
+ *
+ * // Make a call to AuthService.createAPIKey
+ * const authResponse = await client
+ *   .newCall(AuthService, 'createAPIKey')
+ *   .addHeader('Authorization', `Bearer ${creds.apiKey}`)
+ *   .addPayload({ name: 'My Key', expiresIn: 3600n })
+ *   .request();
+ * ```
+ */
+export declare class GrpcClient {
+    /** The underlying gRPC transport */
+    private readonly transport;
+    /** Base URL for API calls */
+    private readonly baseURL;
+    /**
+     * Create a new GrpcClient.
+     *
+     * @param baseURL - The base URL of the gRPC API (e.g., 'https://api.scrawn.dev')
+     *
+     * @example
+     * ```typescript
+     * const client = new GrpcClient('https://api.scrawn.dev');
+     * ```
+     */
+    constructor(baseURL: string);
+    /**
+     * Create a new request builder for a specific service method.
+     *
+     * This is the entry point for making gRPC calls. The method is fully type-safe:
+     * - Service parameter must be a valid gRPC service
+     * - Method name must exist on the service (autocomplete provided)
+     * - Payload type is inferred from the method
+     * - Response type is inferred from the method
+     *
+     * @template S - The gRPC service type (auto-inferred)
+     * @template M - The method name (auto-inferred and validated)
+     *
+     * @param service - The gRPC service definition (e.g., EventService, AuthService)
+     * @param method - The method name as a string literal (e.g., 'registerEvent', 'createAPIKey')
+     * @returns A new RequestBuilder for chaining headers, payload, and execution
+     *
+     * @example
+     * ```typescript
+     * // EventService.registerEvent
+     * const eventBuilder = client.newCall(EventService, 'registerEvent');
+     * // Payload type is RegisterEventRequest
+     * // Response type is RegisterEventResponse
+     *
+     * // AuthService.createAPIKey
+     * const authBuilder = client.newCall(AuthService, 'createAPIKey');
+     * // Payload type is CreateAPIKeyRequest
+     * // Response type is CreateAPIKeyResponse
+     *
+     * // Type error - method doesn't exist!
+     * // const invalid = client.newCall(EventService, 'nonExistentMethod');
+     * ```
+     */
+    newCall<S extends ServiceType, M extends ServiceMethodNames<S>>(service: S, method: M): RequestBuilder<S, M>;
+    /**
+     * Get the base URL of this client.
+     *
+     * @returns The base URL string
+     */
+    getBaseURL(): string;
+    /**
+     * Get the underlying transport (for advanced use cases).
+     *
+     * @returns The Connect transport instance
+     * @internal
+     */
+    getTransport(): Transport;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/core/grpc/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/core/grpc/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEtD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAKrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,qBAAa,UAAU;IACrB,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAY;IAEtC,6BAA6B;IAC7B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IAEjC;;;;;;;;;OASG;gBACS,OAAO,EAAE,MAAM;IAa3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,OAAO,CAAC,CAAC,SAAS,WAAW,EAAE,CAAC,SAAS,kBAAkB,CAAC,CAAC,CAAC,EAC5D,OAAO,EAAE,CAAC,EACV,MAAM,EAAE,CAAC,GACR,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;IAKvB;;;;OAIG;IACH,UAAU,IAAI,MAAM;IAIpB;;;;;OAKG;IACH,YAAY,IAAI,SAAS;CAG1B"}

package/dist/core/grpc/client.js

@@ -0,0 +1,138 @@
+/**
+ * Type-safe gRPC client abstraction layer.
+ *
+ * This module provides the main entry point for making gRPC calls with
+ * full compile-time type safety and a beautiful fluent API.
+ *
+ * @example
+ * ```typescript
+ * const client = new GrpcClient('https://api.scrawn.dev');
+ *
+ * const response = await client
+ *   .newCall(EventService, 'registerEvent')
+ *   .addHeader('Authorization', `Bearer ${apiKey}`)
+ *   .addHeader('x-request-id', '123')
+ *   .addPayload({
+ *     type: EventType.SDK_CALL,
+ *     userId: 'user_123',
+ *     data: { case: 'sdkCall', value: new SDKCall({ sdkCallType: SDKCallType.RAW, debitAmount: 10 }) }
+ *   })
+ *   .request();
+ * ```
+ */
+import { createConnectTransport } from '@connectrpc/connect-node';
+import { RequestBuilder } from './requestBuilder.js';
+import { ScrawnLogger } from '../../utils/logger.js';
+import { ScrawnConfig } from '../../config.js';
+const log = new ScrawnLogger('GrpcClient');
+/**
+ * Main gRPC client for making type-safe API calls.
+ *
+ * This class manages the underlying transport and provides a factory method
+ * for creating type-safe request builders. Each request builder is bound to
+ * a specific service and method, ensuring compile-time type safety.
+ *
+ * The client handles:
+ * - Transport configuration (HTTP/1.1)
+ * - Request building with fluent API
+ * - Header management (auth should be added via .addHeader())
+ * - Error handling and logging
+ *
+ * @example
+ * ```typescript
+ * // Initialize the client
+ * const client = new GrpcClient('https://api.scrawn.dev');
+ *
+ * // Fetch credentials from your auth system
+ * const creds = await getCredentials();
+ *
+ * // Make a call to EventService.registerEvent
+ * const eventResponse = await client
+ *   .newCall(EventService, 'registerEvent')
+ *   .addHeader('Authorization', `Bearer ${creds.apiKey}`)
+ *   .addPayload({ type: EventType.SDK_CALL, userId: 'u123', ... })
+ *   .request();
+ *
+ * // Make a call to AuthService.createAPIKey
+ * const authResponse = await client
+ *   .newCall(AuthService, 'createAPIKey')
+ *   .addHeader('Authorization', `Bearer ${creds.apiKey}`)
+ *   .addPayload({ name: 'My Key', expiresIn: 3600n })
+ *   .request();
+ * ```
+ */
+export class GrpcClient {
+    /**
+     * Create a new GrpcClient.
+     *
+     * @param baseURL - The base URL of the gRPC API (e.g., 'https://api.scrawn.dev')
+     *
+     * @example
+     * ```typescript
+     * const client = new GrpcClient('https://api.scrawn.dev');
+     * ```
+     */
+    constructor(baseURL) {
+        this.baseURL = baseURL;
+        log.info(`Initializing gRPC client for ${baseURL}`);
+        this.transport = createConnectTransport({
+            baseUrl: this.baseURL,
+            httpVersion: ScrawnConfig.grpc.httpVersion,
+        });
+        log.info('gRPC client initialized successfully');
+    }
+    /**
+     * Create a new request builder for a specific service method.
+     *
+     * This is the entry point for making gRPC calls. The method is fully type-safe:
+     * - Service parameter must be a valid gRPC service
+     * - Method name must exist on the service (autocomplete provided)
+     * - Payload type is inferred from the method
+     * - Response type is inferred from the method
+     *
+     * @template S - The gRPC service type (auto-inferred)
+     * @template M - The method name (auto-inferred and validated)
+     *
+     * @param service - The gRPC service definition (e.g., EventService, AuthService)
+     * @param method - The method name as a string literal (e.g., 'registerEvent', 'createAPIKey')
+     * @returns A new RequestBuilder for chaining headers, payload, and execution
+     *
+     * @example
+     * ```typescript
+     * // EventService.registerEvent
+     * const eventBuilder = client.newCall(EventService, 'registerEvent');
+     * // Payload type is RegisterEventRequest
+     * // Response type is RegisterEventResponse
+     *
+     * // AuthService.createAPIKey
+     * const authBuilder = client.newCall(AuthService, 'createAPIKey');
+     * // Payload type is CreateAPIKeyRequest
+     * // Response type is CreateAPIKeyResponse
+     *
+     * // Type error - method doesn't exist!
+     * // const invalid = client.newCall(EventService, 'nonExistentMethod');
+     * ```
+     */
+    newCall(service, method) {
+        log.debug(`Creating new request builder for ${service.typeName}.${method}`);
+        return new RequestBuilder(this.transport, service, method);
+    }
+    /**
+     * Get the base URL of this client.
+     *
+     * @returns The base URL string
+     */
+    getBaseURL() {
+        return this.baseURL;
+    }
+    /**
+     * Get the underlying transport (for advanced use cases).
+     *
+     * @returns The Connect transport instance
+     * @internal
+     */
+    getTransport() {
+        return this.transport;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/core/grpc/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../src/core/grpc/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAIH,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE/C,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,YAAY,CAAC,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,OAAO,UAAU;IAOrB;;;;;;;;;OASG;IACH,YAAY,OAAe;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QAEvB,GAAG,CAAC,IAAI,CAAC,gCAAgC,OAAO,EAAE,CAAC,CAAC;QAEpD,IAAI,CAAC,SAAS,GAAG,sBAAsB,CAAC;YACtC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,WAAW,EAAE,YAAY,CAAC,IAAI,CAAC,WAAW;SAC3C,CAAC,CAAC;QAEH,GAAG,CAAC,IAAI,CAAC,sCAAsC,CAAC,CAAC;IACnD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,OAAO,CACL,OAAU,EACV,MAAS;QAET,GAAG,CAAC,KAAK,CAAC,oCAAoC,OAAO,CAAC,QAAQ,IAAI,MAAM,EAAE,CAAC,CAAC;QAC5E,OAAO,IAAI,cAAc,CAAO,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IACnE,CAAC;IAED;;;;OAIG;IACH,UAAU;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED;;;;;OAKG;IACH,YAAY;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;CACF"}

package/dist/core/grpc/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * gRPC abstraction layer - Type-safe fluent API for gRPC calls.
+ *
+ * This module provides a beautiful, type-safe interface for making gRPC calls
+ * with automatic type inference, compile-time validation, and a fluent API.
+ *
+ * @module grpc
+ */
+export { GrpcClient } from './client.js';
+export { RequestBuilder } from './requestBuilder.js';
+export type { ServiceMethodNames, MethodInput, MethodOutput, Headers, RequestState, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/grpc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/grpc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EACV,kBAAkB,EAClB,WAAW,EACX,YAAY,EACZ,OAAO,EACP,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/core/grpc/index.js

@@ -0,0 +1,11 @@
+/**
+ * gRPC abstraction layer - Type-safe fluent API for gRPC calls.
+ *
+ * This module provides a beautiful, type-safe interface for making gRPC calls
+ * with automatic type inference, compile-time validation, and a fluent API.
+ *
+ * @module grpc
+ */
+export { GrpcClient } from './client.js';
+export { RequestBuilder } from './requestBuilder.js';
+//# sourceMappingURL=index.js.map

package/dist/core/grpc/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/grpc/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}