iii-sdk 0.19.7 → 0.20.0

package/dist/{utils-e84Qph-9.d.mts → types-pzKubHk_.d.cts}

@@ -1,4 +1,5 @@
 import { Readable, Writable } from "node:stream";
+import { HttpInvocationConfig } from "@iii-dev/helpers/http";
 
 //#region src/iii-types.d.ts
 declare enum MessageType {
@@ -18,6 +19,11 @@ type RegisterTriggerTypeMessage = {
   id: string;
   description: string;
 };
+type ErrorBody = {
+  code: string;
+  message: string;
+  stacktrace?: string;
+};
 type RegisterTriggerMessage = {
   message_type: MessageType.RegisterTrigger;
   id: string;
@@ -26,35 +32,6 @@ type RegisterTriggerMessage = {
   config: unknown;
   metadata?: Record<string, unknown>;
 };
-/**
- * Authentication configuration for HTTP-invoked functions.
- *
- * - `hmac` -- HMAC signature verification using a shared secret.
- * - `bearer` -- Bearer token authentication.
- * - `api_key` -- API key sent via a custom header.
- */
-type HttpAuthConfig = {
-  type: 'hmac';
-  secret_key: string;
-} | {
-  type: 'bearer';
-  token_key: string;
-} | {
-  type: 'api_key';
-  header: string;
-  value_key: string;
-};
-/**
- * Configuration for registering an HTTP-invoked function (Lambda, Cloudflare
- * Workers, etc.) instead of a local handler.
- */
-type HttpInvocationConfig = {
-  /** URL to invoke. */url: string; /** HTTP method. Defaults to `POST`. */
-  method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'; /** Timeout in milliseconds. */
-  timeout_ms?: number; /** Custom headers to send with the request. */
-  headers?: Record<string, string>; /** Authentication configuration. */
-  auth?: HttpAuthConfig;
-};
 type RegisterFunctionFormat = {
   /**
    * The name of the parameter
@@ -119,30 +96,6 @@ type TriggerAction = {
 } | {
   type: 'void';
 };
-/**
- * Input passed to the RBAC auth function during WebSocket upgrade.
- * Contains the HTTP headers, query parameters, and client IP from the
- * connecting worker's upgrade request.
- */
-type AuthInput = {
-  /** HTTP headers from the WebSocket upgrade request. */headers: Record<string, string>; /** Query parameters from the upgrade URL. Each key maps to an array of values to support repeated keys. */
-  query_params: Record<string, string[]>; /** IP address of the connecting client. */
-  ip_address: string;
-};
-/**
- * Return value from the RBAC auth function. Controls which functions the
- * authenticated worker can invoke and what context is forwarded to the
- * middleware.
- */
-type AuthResult = {
-  /** Additional function IDs to allow beyond the `expose_functions` config. */allowed_functions: string[]; /** Function IDs to deny even if they match `expose_functions`. Takes precedence over allowed. */
-  forbidden_functions: string[]; /** Trigger type IDs the worker may register triggers for. When omitted, all types are allowed. */
-  allowed_trigger_types?: string[]; /** Whether the worker may register new trigger types. */
-  allow_trigger_type_registration: boolean; /** Whether the worker may register new functions. Defaults to `true` if omitted. */
-  allow_function_registration?: boolean; /** Arbitrary context forwarded to the middleware function on every invocation. */
-  context: Record<string, unknown>; /** Optional prefix applied to all function IDs registered by this worker. */
-  function_registration_prefix?: string;
-};
 /**
  * Input passed to the RBAC middleware function on every function invocation
  * through the RBAC port. The middleware can inspect, modify, or reject the
@@ -155,80 +108,7 @@ type MiddlewareFunctionInput = {
   context: Record<string, unknown>;
 };
 /**
- * Input passed to the `on_trigger_type_registration_function_id` hook
- * when a worker attempts to register a new trigger type through the RBAC port.
- * Return an {@link OnTriggerTypeRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnTriggerTypeRegistrationInput = {
-  /** ID of the trigger type being registered. */trigger_type_id: string; /** Human-readable description of the trigger type. */
-  description: string; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_trigger_type_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnTriggerTypeRegistrationResult = {
-  /** Mapped trigger type ID. */trigger_type_id?: string; /** Mapped description. */
-  description?: string;
-};
-/**
- * Input passed to the `on_trigger_registration_function_id` hook
- * when a worker attempts to register a trigger through the RBAC port.
- * Return an {@link OnTriggerRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnTriggerRegistrationInput = {
-  /** ID of the trigger being registered. */trigger_id: string; /** Trigger type identifier. */
-  trigger_type: string; /** ID of the function this trigger is bound to. */
-  function_id: string; /** Trigger-specific configuration. */
-  config: unknown; /** Arbitrary metadata attached to the trigger. */
-  metadata?: Record<string, unknown>; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_trigger_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnTriggerRegistrationResult = {
-  /** Mapped trigger ID. */trigger_id?: string; /** Mapped trigger type. */
-  trigger_type?: string; /** Mapped function ID. */
-  function_id?: string; /** Mapped trigger configuration. */
-  config?: unknown;
-};
-/**
- * Input passed to the `on_function_registration_function_id` hook
- * when a worker attempts to register a function through the RBAC port.
- * Return an {@link OnFunctionRegistrationResult} with the (possibly mapped)
- * fields, or throw to deny the registration.
- */
-type OnFunctionRegistrationInput = {
-  /** ID of the function being registered. */function_id: string; /** Human-readable description of the function. */
-  description?: string; /** Arbitrary metadata attached to the function. */
-  metadata?: Record<string, unknown>; /** Auth context from `AuthResult.context` for this session. */
-  context: Record<string, unknown>;
-};
-/**
- * Result returned from the `on_function_registration_function_id` hook.
- * All fields are optional -- omitted fields keep the original value from the
- * registration request.
- */
-type OnFunctionRegistrationResult = {
-  /** Mapped function ID. */function_id?: string; /** Mapped description. */
-  description?: string; /** Mapped metadata. */
-  metadata?: Record<string, unknown>;
-};
-/**
- * Result returned when a function is invoked with `TriggerAction.Enqueue`.
- */
-type EnqueueResult = {
-  /** Unique receipt ID for the enqueued message. */messageReceiptId: string;
-};
-/**
- * Request object passed to {@link ISdk.trigger}.
+ * Request object passed to {@link IIIClient.trigger}.
  *
  * @typeParam TInput - Type of the payload.
  */
@@ -357,7 +237,7 @@ type TriggerConfig<TConfig> = {
 };
 /**
  * Handler interface for custom trigger types. Passed to
- * `ISdk.registerTriggerType`.
+ * `IIIClient.registerTriggerType`.
  *
  * @typeParam TConfig - Type of the trigger-specific configuration.
  *
@@ -397,7 +277,7 @@ type RegisterTriggerInput = Omit<RegisterTriggerMessage, 'message_type' | 'id'>;
 type RegisterFunctionInput = Omit<RegisterFunctionMessage, 'message_type'>;
 type RegisterFunctionOptions = Omit<RegisterFunctionMessage, 'message_type' | 'id'>;
 type RegisterTriggerTypeInput = Omit<RegisterTriggerTypeMessage, 'message_type'>;
-interface ISdk {
+interface IIIClient {
   /**
    * Registers a new trigger. A trigger is a way to invoke a function when a certain event occurs.
    * @param trigger - The trigger to register
@@ -405,7 +285,7 @@ interface ISdk {
    *
    * @example
    * ```typescript
-   * const trigger = iii.registerTrigger({
+   * const trigger = worker.registerTrigger({
    *   type: 'cron',
    *   function_id: 'my-service::process-batch',
    *   config: { expression: '0 *\/5 * * * * *' },
@@ -426,14 +306,14 @@ interface ISdk {
    * @example
    * ```typescript
    * // Local handler
-   * const ref = iii.registerFunction(
+   * const ref = worker.registerFunction(
    *   'greet',
    *   async (data: { name: string }) => ({ message: `Hello, ${data.name}!` }),
    *   { description: 'Returns a greeting' },
    * )
    *
    * // HTTP invocation
-   * const lambdaRef = iii.registerFunction(
+   * const lambdaRef = worker.registerFunction(
    *   'external::my-lambda',
    *   {
    *     url: 'https://abc123.lambda-url.us-east-1.on.aws',
@@ -458,7 +338,7 @@ interface ISdk {
    * @example
    * ```typescript
    * // Synchronous invocation
-   * const result = await iii.trigger<{ name: string }, { message: string }>({
+   * const result = await worker.trigger<{ name: string }, { message: string }>({
    *   function_id: 'greet',
    *   payload: { name: 'World' },
    *   timeoutMs: 5000,
@@ -466,14 +346,14 @@ interface ISdk {
    * console.log(result.message) // "Hello, World!"
    *
    * // Fire-and-forget
-   * await iii.trigger({
+   * await worker.trigger({
    *   function_id: 'send-email',
    *   payload: { to: 'user@example.com' },
    *   action: TriggerAction.Void(),
    * })
    *
    * // Enqueue for async processing
-   * const receipt = await iii.trigger({
+   * const receipt = await worker.trigger({
    *   function_id: 'process-order',
    *   payload: { orderId: '123' },
    *   action: TriggerAction.Enqueue({ queue: 'orders' }),
@@ -491,12 +371,12 @@ interface ISdk {
    * ```typescript
    * type CronConfig = { expression: string }
    *
-   * iii.registerTriggerType<CronConfig>(
+   * worker.registerTriggerType<CronConfig>(
    *   { id: 'cron', description: 'Fires on a cron schedule' },
    *   {
    *     async registerTrigger({ id, function_id, config }) {
    *       startCronJob(id, config.expression, () =>
-   *         iii.trigger({ function_id, payload: {} }),
+   *         worker.trigger({ function_id, payload: {} }),
    *       )
    *     },
    *     async unregisterTrigger({ id }) {
@@ -513,7 +393,7 @@ interface ISdk {
    *
    * @example
    * ```typescript
-   * iii.unregisterTriggerType({ id: 'cron', description: 'Fires on a cron schedule' })
+   * worker.unregisterTriggerType({ id: 'cron', description: 'Fires on a cron schedule' })
    * ```
    */
   unregisterTriggerType(triggerType: RegisterTriggerTypeInput): void;
@@ -523,7 +403,7 @@ interface ISdk {
    * @example
    * ```typescript
    * process.on('SIGTERM', async () => {
-   *   await iii.shutdown()
+   *   await worker.shutdown()
    *   process.exit(0)
    * })
    * ```
@@ -531,14 +411,14 @@ interface ISdk {
   shutdown(): Promise<void>;
 }
 /**
- * Handle returned by {@link ISdk.registerTrigger}. Use `unregister()` to
+ * Handle returned by {@link IIIClient.registerTrigger}. Use `unregister()` to
  * remove the trigger from the engine.
  */
 type Trigger = {
   /** Removes this trigger from the engine. */unregister(): void;
 };
 /**
- * Handle returned by {@link ISdk.registerFunction}. Contains the function's
+ * Handle returned by {@link IIIClient.registerFunction}. Contains the function's
  * `id` and an `unregister()` method.
  */
 type FunctionRef = {
@@ -546,7 +426,7 @@ type FunctionRef = {
   unregister: () => void;
 };
 /**
- * Typed handle returned by {@link ISdk.registerTriggerType}.
+ * Typed handle returned by {@link IIIClient.registerTriggerType}.
  *
  * Provides convenience methods to register triggers and functions scoped
  * to this trigger type, so callers don't need to repeat the `type` field.
@@ -557,12 +437,12 @@ type FunctionRef = {
  * ```typescript
  * type CronConfig = { expression: string }
  *
- * const cron = iii.registerTriggerType<CronConfig>(
+ * const cron = worker.registerTriggerType<CronConfig>(
  *   { id: 'cron', description: 'Fires on a cron schedule' },
  *   cronHandler,
  * )
  *
- * // Register a trigger — type is inferred as CronConfig
+ * // Register a trigger, type is inferred as CronConfig
  * cron.registerTrigger('my::fn', { expression: '0 *\/5 * * * * *' })
  *
  * // Register a function and bind a trigger in one call
@@ -619,89 +499,22 @@ type InternalHttpRequest<TBody = unknown> = {
   request_body: ChannelReader;
 };
 /**
- * Response object passed to HTTP function handlers. Use `status()` and
+ * Response object passed to streaming function handlers. Use `status()` and
  * `headers()` to set response metadata, write to `stream` for streaming
  * responses, and call `close()` when done.
  */
-type HttpResponse = {
+type StreamResponse = {
   /** Set the HTTP status code. */status: (statusCode: number) => void; /** Set response headers. */
   headers: (headers: Record<string, string>) => void; /** Writable stream for the response body. */
   stream: NodeJS.WritableStream; /** Close the response. */
   close: () => void;
 };
 /**
- * Incoming HTTP request received by a function registered with an HTTP trigger.
- *
- * @typeParam TBody - Type of the parsed request body.
- */
-type HttpRequest<TBody = unknown> = Omit<InternalHttpRequest<TBody>, 'response'>;
-/**
- * Alias for {@link HttpRequest}. Represents an incoming API request.
+ * Incoming streaming request received by a function registered with a stream trigger.
  *
  * @typeParam TBody - Type of the parsed request body.
  */
-type ApiRequest<TBody = unknown> = HttpRequest<TBody>;
-/**
- * Structured API response returned from HTTP function handlers.
- *
- * @typeParam TStatus - HTTP status code literal type.
- * @typeParam TBody - Type of the response body.
- *
- * @example
- * ```typescript
- * const response: ApiResponse = {
- *   status_code: 200,
- *   headers: { 'content-type': 'application/json' },
- *   body: { message: 'ok' },
- * }
- * ```
- */
-type ApiResponse<TStatus extends number = number, TBody = string | Buffer | Record<string, unknown>> = {
-  /** HTTP status code. */status_code: TStatus; /** Response headers. */
-  headers?: Record<string, string>; /** Response body. */
-  body?: TBody;
-};
-//#endregion
-//#region src/utils.d.ts
-/**
- * Helper that wraps an HTTP-style handler (with separate `req`/`res` arguments)
- * into the function handler format expected by the SDK.
- *
- * @param callback - Async handler receiving an {@link HttpRequest} and {@link HttpResponse}.
- * @returns A function handler compatible with {@link ISdk.registerFunction}.
- *
- * @example
- * ```typescript
- * import { http } from 'iii-sdk'
- *
- * iii.registerFunction(
- *   'my-api',
- *   http(async (req, res) => {
- *     res.status(200)
- *     res.headers({ 'content-type': 'application/json' })
- *     res.stream.end(JSON.stringify({ hello: 'world' }))
- *     res.close()
- *   }),
- * )
- * ```
- */
-declare const http: (callback: (req: HttpRequest, res: HttpResponse) => Promise<void | ApiResponse>) => (req: InternalHttpRequest) => Promise<void | ApiResponse>;
-/**
- * Type guard that checks if a value is a {@link StreamChannelRef}.
- *
- * @param value - Value to check.
- * @returns `true` if the value is a valid `StreamChannelRef`.
- */
-declare const isChannelRef: (value: unknown) => value is StreamChannelRef;
-/**
- * Recursively extract all {@link StreamChannelRef} values from a JSON-like
- * input, returning each match paired with its dotted/bracketed path. Mirrors
- * the Rust SDK's `extract_channel_refs`.
- *
- * @param data - Arbitrary JSON-like value.
- * @returns Array of `[path, ref]` tuples. Empty when no refs are found.
- */
-declare const extractChannelRefs: (data: unknown) => Array<[string, StreamChannelRef]>;
+type StreamRequest<TBody = unknown> = Omit<InternalHttpRequest<TBody>, 'response'>;
 //#endregion
-export { MessageType as A, RegisterTriggerTypeMessage as B, ChannelReader as C, EnqueueResult as D, AuthResult as E, OnTriggerRegistrationResult as F, TriggerRequest as H, OnTriggerTypeRegistrationInput as I, OnTriggerTypeRegistrationResult as L, OnFunctionRegistrationInput as M, OnFunctionRegistrationResult as N, HttpAuthConfig as O, OnTriggerRegistrationInput as P, RegisterFunctionMessage as R, ChannelItem as S, AuthInput as T, StreamChannelRef as V, Trigger as _, ApiResponse as a, TriggerHandler as b, HttpRequest as c, InternalHttpRequest as d, RegisterFunctionInput as f, RemoteFunctionHandler as g, RegisterTriggerTypeInput as h, ApiRequest as i, MiddlewareFunctionInput as j, HttpInvocationConfig as k, HttpResponse as l, RegisterTriggerInput as m, http as n, Channel as o, RegisterFunctionOptions as p, isChannelRef as r, FunctionRef as s, extractChannelRefs as t, ISdk as u, TriggerTypeRef as v, ChannelWriter as w, ChannelDirection as x, TriggerConfig as y, RegisterTriggerMessage as z };
-//# sourceMappingURL=utils-e84Qph-9.d.mts.map
+export { RegisterFunctionFormat as C, StreamChannelRef as D, RegisterTriggerTypeMessage as E, TriggerRequest as O, MiddlewareFunctionInput as S, RegisterTriggerMessage as T, ChannelItem as _, RegisterFunctionInput as a, ErrorBody as b, RegisterTriggerTypeInput as c, StreamResponse as d, Trigger as f, ChannelDirection as g, TriggerHandler as h, InternalHttpRequest as i, RemoteFunctionHandler as l, TriggerConfig as m, FunctionRef as n, RegisterFunctionOptions as o, TriggerTypeRef as p, IIIClient as r, RegisterTriggerInput as s, Channel as t, StreamRequest as u, ChannelReader as v, RegisterFunctionMessage as w, MessageType as x, ChannelWriter as y };
+//# sourceMappingURL=types-pzKubHk_.d.cts.map

package/dist/types-pzKubHk_.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-pzKubHk_.d.cts","names":[],"sources":["../src/iii-types.ts","../src/channels.ts","../src/triggers.ts","../src/types.ts"],"mappings":"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"}

package/dist/utils-63wxBJg-.cjs

@@ -0,0 +1,121 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let node_fs = require("node:fs");
+node_fs = __toESM(node_fs);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
+
+//#region src/utils.ts
+/**
+* Returns a project identifier for telemetry, derived from the current working
+* directory. Reads `package.json` `name` if present at `cwd`; otherwise falls
+* back to the basename of `cwd`. Returns `undefined` only when both signals
+* are unavailable (e.g. cwd is the filesystem root).
+*
+* No directory walking, only inspects `cwd` itself, so the SDK never reads
+* files outside the user's explicit working directory.
+*/
+function detectProjectName(cwd = process.cwd()) {
+	try {
+		const manifest = node_path.join(cwd, "package.json");
+		if (node_fs.existsSync(manifest)) {
+			const parsed = JSON.parse(node_fs.readFileSync(manifest, "utf8"));
+			if (typeof parsed.name === "string") {
+				const trimmed = parsed.name.trim();
+				if (trimmed) return trimmed;
+			}
+		}
+	} catch {}
+	return node_path.basename(cwd).trim() || void 0;
+}
+/**
+* Type guard that checks if a value is a {@link StreamChannelRef}.
+*
+* @param value - Value to check.
+* @returns `true` if the value is a valid `StreamChannelRef`.
+*/
+const isChannelRef = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.channel_id === "string" && typeof maybe.access_key === "string" && (maybe.direction === "read" || maybe.direction === "write");
+};
+/**
+* Recursively extract all {@link StreamChannelRef} values from a JSON-like
+* input, returning each match paired with its dotted/bracketed path. Mirrors
+* the Rust SDK's `extract_channel_refs`.
+*
+* @param data - Arbitrary JSON-like value.
+* @returns Array of `[path, ref]` tuples. Empty when no refs are found.
+*/
+const extractChannelRefs = (data) => {
+	const refs = [];
+	extractRefsRecursive(data, "", refs);
+	return refs;
+};
+const extractRefsRecursive = (data, prefix, refs) => {
+	if (isChannelRef(data)) {
+		refs.push([prefix, data]);
+		return;
+	}
+	if (Array.isArray(data)) {
+		for (let i = 0; i < data.length; i++) {
+			const path = prefix === "" ? `[${i}]` : `${prefix}[${i}]`;
+			extractRefsRecursive(data[i], path, refs);
+		}
+		return;
+	}
+	if (typeof data !== "object" || data === null) return;
+	for (const [key, value] of Object.entries(data)) extractRefsRecursive(value, prefix === "" ? key : `${prefix}.${key}`, refs);
+};
+
+//#endregion
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'detectProjectName', {
+  enumerable: true,
+  get: function () {
+    return detectProjectName;
+  }
+});
+Object.defineProperty(exports, 'extractChannelRefs', {
+  enumerable: true,
+  get: function () {
+    return extractChannelRefs;
+  }
+});
+Object.defineProperty(exports, 'isChannelRef', {
+  enumerable: true,
+  get: function () {
+    return isChannelRef;
+  }
+});
+//# sourceMappingURL=utils-63wxBJg-.cjs.map

package/dist/utils-63wxBJg-.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-63wxBJg-.cjs","names":["path","fs"],"sources":["../src/utils.ts"],"sourcesContent":["import * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport type { StreamChannelRef } from './iii-types'\n\n/**\n * Returns a project identifier for telemetry, derived from the current working\n * directory. Reads `package.json` `name` if present at `cwd`; otherwise falls\n * back to the basename of `cwd`. Returns `undefined` only when both signals\n * are unavailable (e.g. cwd is the filesystem root).\n *\n * No directory walking, only inspects `cwd` itself, so the SDK never reads\n * files outside the user's explicit working directory.\n */\nexport function detectProjectName(cwd: string = process.cwd()): string | undefined {\n  try {\n    const manifest = path.join(cwd, 'package.json')\n    if (fs.existsSync(manifest)) {\n      const parsed = JSON.parse(fs.readFileSync(manifest, 'utf8')) as { name?: unknown }\n      if (typeof parsed.name === 'string') {\n        const trimmed = parsed.name.trim()\n        if (trimmed) return trimmed\n      }\n    }\n  } catch {\n    // fall through to directory-name fallback\n  }\n\n  const base = path.basename(cwd).trim()\n  return base || undefined\n}\n\n/**\n * Type guard that checks if a value is a {@link StreamChannelRef}.\n *\n * @param value - Value to check.\n * @returns `true` if the value is a valid `StreamChannelRef`.\n */\nexport const isChannelRef = (value: unknown): value is StreamChannelRef => {\n  if (typeof value !== 'object' || value === null) return false\n  const maybe = value as Partial<StreamChannelRef>\n  return (\n    typeof maybe.channel_id === 'string' &&\n    typeof maybe.access_key === 'string' &&\n    (maybe.direction === 'read' || maybe.direction === 'write')\n  )\n}\n\n/**\n * Recursively extract all {@link StreamChannelRef} values from a JSON-like\n * input, returning each match paired with its dotted/bracketed path. Mirrors\n * the Rust SDK's `extract_channel_refs`.\n *\n * @param data - Arbitrary JSON-like value.\n * @returns Array of `[path, ref]` tuples. Empty when no refs are found.\n */\nexport const extractChannelRefs = (data: unknown): Array<[string, StreamChannelRef]> => {\n  const refs: Array<[string, StreamChannelRef]> = []\n  extractRefsRecursive(data, '', refs)\n  return refs\n}\n\nconst extractRefsRecursive = (\n  data: unknown,\n  prefix: string,\n  refs: Array<[string, StreamChannelRef]>,\n): void => {\n  if (isChannelRef(data)) {\n    refs.push([prefix, data])\n    return\n  }\n  if (Array.isArray(data)) {\n    for (let i = 0; i < data.length; i++) {\n      const path = prefix === '' ? `[${i}]` : `${prefix}[${i}]`\n      extractRefsRecursive(data[i], path, refs)\n    }\n    return\n  }\n  if (typeof data !== 'object' || data === null) return\n\n  for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n    const path = prefix === '' ? key : `${prefix}.${key}`\n    extractRefsRecursive(value, path, refs)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,MAAc,QAAQ,KAAK,EAAsB;AACjF,KAAI;EACF,MAAM,WAAWA,UAAK,KAAK,KAAK,eAAe;AAC/C,MAAIC,QAAG,WAAW,SAAS,EAAE;GAC3B,MAAM,SAAS,KAAK,MAAMA,QAAG,aAAa,UAAU,OAAO,CAAC;AAC5D,OAAI,OAAO,OAAO,SAAS,UAAU;IACnC,MAAM,UAAU,OAAO,KAAK,MAAM;AAClC,QAAI,QAAS,QAAO;;;SAGlB;AAKR,QADaD,UAAK,SAAS,IAAI,CAAC,MAAM,IACvB;;;;;;;;AASjB,MAAa,gBAAgB,UAA8C;AACzE,KAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;CACxD,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,YAC5B,OAAO,MAAM,eAAe,aAC3B,MAAM,cAAc,UAAU,MAAM,cAAc;;;;;;;;;;AAYvD,MAAa,sBAAsB,SAAqD;CACtF,MAAM,OAA0C,EAAE;AAClD,sBAAqB,MAAM,IAAI,KAAK;AACpC,QAAO;;AAGT,MAAM,wBACJ,MACA,QACA,SACS;AACT,KAAI,aAAa,KAAK,EAAE;AACtB,OAAK,KAAK,CAAC,QAAQ,KAAK,CAAC;AACzB;;AAEF,KAAI,MAAM,QAAQ,KAAK,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,OAAO,WAAW,KAAK,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,EAAE;AACvD,wBAAqB,KAAK,IAAI,MAAM,KAAK;;AAE3C;;AAEF,KAAI,OAAO,SAAS,YAAY,SAAS,KAAM;AAE/C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAgC,CAExE,sBAAqB,OADR,WAAW,KAAK,MAAM,GAAG,OAAO,GAAG,OACd,KAAK"}

package/dist/utils-8G4hHqvZ.mjs

@@ -0,0 +1,69 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+//#region src/utils.ts
+/**
+* Returns a project identifier for telemetry, derived from the current working
+* directory. Reads `package.json` `name` if present at `cwd`; otherwise falls
+* back to the basename of `cwd`. Returns `undefined` only when both signals
+* are unavailable (e.g. cwd is the filesystem root).
+*
+* No directory walking, only inspects `cwd` itself, so the SDK never reads
+* files outside the user's explicit working directory.
+*/
+function detectProjectName(cwd = process.cwd()) {
+	try {
+		const manifest = path.join(cwd, "package.json");
+		if (fs.existsSync(manifest)) {
+			const parsed = JSON.parse(fs.readFileSync(manifest, "utf8"));
+			if (typeof parsed.name === "string") {
+				const trimmed = parsed.name.trim();
+				if (trimmed) return trimmed;
+			}
+		}
+	} catch {}
+	return path.basename(cwd).trim() || void 0;
+}
+/**
+* Type guard that checks if a value is a {@link StreamChannelRef}.
+*
+* @param value - Value to check.
+* @returns `true` if the value is a valid `StreamChannelRef`.
+*/
+const isChannelRef = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const maybe = value;
+	return typeof maybe.channel_id === "string" && typeof maybe.access_key === "string" && (maybe.direction === "read" || maybe.direction === "write");
+};
+/**
+* Recursively extract all {@link StreamChannelRef} values from a JSON-like
+* input, returning each match paired with its dotted/bracketed path. Mirrors
+* the Rust SDK's `extract_channel_refs`.
+*
+* @param data - Arbitrary JSON-like value.
+* @returns Array of `[path, ref]` tuples. Empty when no refs are found.
+*/
+const extractChannelRefs = (data) => {
+	const refs = [];
+	extractRefsRecursive(data, "", refs);
+	return refs;
+};
+const extractRefsRecursive = (data, prefix, refs) => {
+	if (isChannelRef(data)) {
+		refs.push([prefix, data]);
+		return;
+	}
+	if (Array.isArray(data)) {
+		for (let i = 0; i < data.length; i++) {
+			const path = prefix === "" ? `[${i}]` : `${prefix}[${i}]`;
+			extractRefsRecursive(data[i], path, refs);
+		}
+		return;
+	}
+	if (typeof data !== "object" || data === null) return;
+	for (const [key, value] of Object.entries(data)) extractRefsRecursive(value, prefix === "" ? key : `${prefix}.${key}`, refs);
+};
+
+//#endregion
+export { extractChannelRefs as n, isChannelRef as r, detectProjectName as t };
+//# sourceMappingURL=utils-8G4hHqvZ.mjs.map

package/dist/utils-8G4hHqvZ.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-8G4hHqvZ.mjs","names":[],"sources":["../src/utils.ts"],"sourcesContent":["import * as fs from 'node:fs'\nimport * as path from 'node:path'\nimport type { StreamChannelRef } from './iii-types'\n\n/**\n * Returns a project identifier for telemetry, derived from the current working\n * directory. Reads `package.json` `name` if present at `cwd`; otherwise falls\n * back to the basename of `cwd`. Returns `undefined` only when both signals\n * are unavailable (e.g. cwd is the filesystem root).\n *\n * No directory walking, only inspects `cwd` itself, so the SDK never reads\n * files outside the user's explicit working directory.\n */\nexport function detectProjectName(cwd: string = process.cwd()): string | undefined {\n  try {\n    const manifest = path.join(cwd, 'package.json')\n    if (fs.existsSync(manifest)) {\n      const parsed = JSON.parse(fs.readFileSync(manifest, 'utf8')) as { name?: unknown }\n      if (typeof parsed.name === 'string') {\n        const trimmed = parsed.name.trim()\n        if (trimmed) return trimmed\n      }\n    }\n  } catch {\n    // fall through to directory-name fallback\n  }\n\n  const base = path.basename(cwd).trim()\n  return base || undefined\n}\n\n/**\n * Type guard that checks if a value is a {@link StreamChannelRef}.\n *\n * @param value - Value to check.\n * @returns `true` if the value is a valid `StreamChannelRef`.\n */\nexport const isChannelRef = (value: unknown): value is StreamChannelRef => {\n  if (typeof value !== 'object' || value === null) return false\n  const maybe = value as Partial<StreamChannelRef>\n  return (\n    typeof maybe.channel_id === 'string' &&\n    typeof maybe.access_key === 'string' &&\n    (maybe.direction === 'read' || maybe.direction === 'write')\n  )\n}\n\n/**\n * Recursively extract all {@link StreamChannelRef} values from a JSON-like\n * input, returning each match paired with its dotted/bracketed path. Mirrors\n * the Rust SDK's `extract_channel_refs`.\n *\n * @param data - Arbitrary JSON-like value.\n * @returns Array of `[path, ref]` tuples. Empty when no refs are found.\n */\nexport const extractChannelRefs = (data: unknown): Array<[string, StreamChannelRef]> => {\n  const refs: Array<[string, StreamChannelRef]> = []\n  extractRefsRecursive(data, '', refs)\n  return refs\n}\n\nconst extractRefsRecursive = (\n  data: unknown,\n  prefix: string,\n  refs: Array<[string, StreamChannelRef]>,\n): void => {\n  if (isChannelRef(data)) {\n    refs.push([prefix, data])\n    return\n  }\n  if (Array.isArray(data)) {\n    for (let i = 0; i < data.length; i++) {\n      const path = prefix === '' ? `[${i}]` : `${prefix}[${i}]`\n      extractRefsRecursive(data[i], path, refs)\n    }\n    return\n  }\n  if (typeof data !== 'object' || data === null) return\n\n  for (const [key, value] of Object.entries(data as Record<string, unknown>)) {\n    const path = prefix === '' ? key : `${prefix}.${key}`\n    extractRefsRecursive(value, path, refs)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,kBAAkB,MAAc,QAAQ,KAAK,EAAsB;AACjF,KAAI;EACF,MAAM,WAAW,KAAK,KAAK,KAAK,eAAe;AAC/C,MAAI,GAAG,WAAW,SAAS,EAAE;GAC3B,MAAM,SAAS,KAAK,MAAM,GAAG,aAAa,UAAU,OAAO,CAAC;AAC5D,OAAI,OAAO,OAAO,SAAS,UAAU;IACnC,MAAM,UAAU,OAAO,KAAK,MAAM;AAClC,QAAI,QAAS,QAAO;;;SAGlB;AAKR,QADa,KAAK,SAAS,IAAI,CAAC,MAAM,IACvB;;;;;;;;AASjB,MAAa,gBAAgB,UAA8C;AACzE,KAAI,OAAO,UAAU,YAAY,UAAU,KAAM,QAAO;CACxD,MAAM,QAAQ;AACd,QACE,OAAO,MAAM,eAAe,YAC5B,OAAO,MAAM,eAAe,aAC3B,MAAM,cAAc,UAAU,MAAM,cAAc;;;;;;;;;;AAYvD,MAAa,sBAAsB,SAAqD;CACtF,MAAM,OAA0C,EAAE;AAClD,sBAAqB,MAAM,IAAI,KAAK;AACpC,QAAO;;AAGT,MAAM,wBACJ,MACA,QACA,SACS;AACT,KAAI,aAAa,KAAK,EAAE;AACtB,OAAK,KAAK,CAAC,QAAQ,KAAK,CAAC;AACzB;;AAEF,KAAI,MAAM,QAAQ,KAAK,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;GACpC,MAAM,OAAO,WAAW,KAAK,IAAI,EAAE,KAAK,GAAG,OAAO,GAAG,EAAE;AACvD,wBAAqB,KAAK,IAAI,MAAM,KAAK;;AAE3C;;AAEF,KAAI,OAAO,SAAS,YAAY,SAAS,KAAM;AAE/C,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,KAAgC,CAExE,sBAAqB,OADR,WAAW,KAAK,MAAM,GAAG,OAAO,GAAG,OACd,KAAK"}