@lusor/sdk 0.0.0-stage → 1.0.0

package/dist/core/fetcher/getResponseBody.js

@@ -0,0 +1,66 @@
+import { fromJson } from "../json.js";
+import { getBinaryResponse } from "./BinaryResponse.js";
+// Pins the upstream Response so undici's FinalizationRegistry can't GC it and cancel the body stream.
+function retainResponse(target, response) {
+    Object.defineProperty(target, "__fern_response_ref", {
+        value: response,
+        enumerable: false,
+        configurable: true,
+        writable: false,
+    });
+}
+export async function getResponseBody(response, responseType) {
+    switch (responseType) {
+        case "binary-response":
+            return getBinaryResponse(response);
+        case "blob":
+            return await response.blob();
+        case "arrayBuffer":
+            return await response.arrayBuffer();
+        case "sse":
+            if (response.body == null) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "body-is-null",
+                        statusCode: response.status,
+                    },
+                };
+            }
+            retainResponse(response.body, response);
+            return response.body;
+        case "streaming":
+            if (response.body == null) {
+                return {
+                    ok: false,
+                    error: {
+                        reason: "body-is-null",
+                        statusCode: response.status,
+                    },
+                };
+            }
+            retainResponse(response.body, response);
+            return response.body;
+        case "text":
+            return await response.text();
+    }
+    // if responseType is "json" or not specified, try to parse as JSON
+    const text = await response.text();
+    if (text.length > 0) {
+        try {
+            const responseBody = fromJson(text);
+            return responseBody;
+        }
+        catch (_err) {
+            return {
+                ok: false,
+                error: {
+                    reason: "non-json",
+                    statusCode: response.status,
+                    rawBody: text,
+                },
+            };
+        }
+    }
+    return undefined;
+}

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

@@ -0,0 +1,13 @@
+export type { APIResponse } from "./APIResponse.js";
+export type { BinaryResponse } from "./BinaryResponse.js";
+export type { EndpointMetadata } from "./EndpointMetadata.js";
+export { EndpointSupplier } from "./EndpointSupplier.js";
+export type { Fetcher, FetchFunction } from "./Fetcher.js";
+export { fetcher } from "./Fetcher.js";
+export { getHeader } from "./getHeader.js";
+export { HttpResponsePromise } from "./HttpResponsePromise.js";
+export type { PassthroughRequest } from "./makePassthroughRequest.js";
+export { makePassthroughRequest } from "./makePassthroughRequest.js";
+export type { RawResponse, WithRawResponse } from "./RawResponse.js";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.js";
+export { Supplier } from "./Supplier.js";

package/dist/core/fetcher/index.js

@@ -0,0 +1,7 @@
+export { EndpointSupplier } from "./EndpointSupplier.js";
+export { fetcher } from "./Fetcher.js";
+export { getHeader } from "./getHeader.js";
+export { HttpResponsePromise } from "./HttpResponsePromise.js";
+export { makePassthroughRequest } from "./makePassthroughRequest.js";
+export { abortRawResponse, toRawResponse, unknownRawResponse } from "./RawResponse.js";
+export { Supplier } from "./Supplier.js";

package/dist/core/fetcher/makePassthroughRequest.d.ts

@@ -0,0 +1,49 @@
+import { type LogConfig, type Logger } from "../logging/logger.js";
+import { Supplier } from "./Supplier.js";
+export declare namespace PassthroughRequest {
+    /**
+     * Per-request options that can override the SDK client defaults.
+     */
+    interface RequestOptions {
+        /** Override the default timeout for this request (in seconds). */
+        timeoutInSeconds?: number;
+        /** Override the default number of retries for this request. */
+        maxRetries?: number;
+        /** Additional headers to include in this request. */
+        headers?: Record<string, string>;
+        /** Abort signal for this request. */
+        abortSignal?: AbortSignal;
+    }
+    /**
+     * SDK client configuration used by the passthrough fetch method.
+     */
+    interface ClientOptions {
+        /** The base URL or environment for the client. */
+        environment?: Supplier<string>;
+        /** Override the base URL. */
+        baseUrl?: Supplier<string>;
+        /** Default headers to include in requests. */
+        headers?: Record<string, unknown>;
+        /** Default maximum time to wait for a response in seconds. */
+        timeoutInSeconds?: number;
+        /** Default number of times to retry the request. Defaults to 2. */
+        maxRetries?: number;
+        /** A custom fetch function. */
+        fetch?: typeof fetch;
+        /** Logging configuration. */
+        logging?: LogConfig | Logger;
+        /** A function that returns auth headers. */
+        getAuthHeaders?: () => Promise<Record<string, string>>;
+    }
+}
+/**
+ * Makes a passthrough HTTP request using the SDK's configuration (auth, retry, logging, etc.)
+ * while mimicking the standard `fetch` API.
+ *
+ * @param input - The URL, path, or Request object. If a relative path, it will be resolved against the configured base URL.
+ * @param init - Standard RequestInit options (method, headers, body, signal, etc.)
+ * @param clientOptions - SDK client options (auth, default headers, logging, etc.)
+ * @param requestOptions - Per-request overrides (timeout, retries, extra headers, abort signal).
+ * @returns A standard Response object.
+ */
+export declare function makePassthroughRequest(input: Request | string | URL, init: RequestInit | undefined, clientOptions: PassthroughRequest.ClientOptions, requestOptions?: PassthroughRequest.RequestOptions): Promise<Response>;

package/dist/core/fetcher/makePassthroughRequest.js

@@ -0,0 +1,144 @@
+import { createLogger } from "../logging/logger.js";
+import { join } from "../url/join.js";
+import { EndpointSupplier } from "./EndpointSupplier.js";
+import { getFetchFn } from "./getFetchFn.js";
+import { makeRequest } from "./makeRequest.js";
+import { redactUrl } from "./redactUrl.js";
+import { requestWithRetries } from "./requestWithRetries.js";
+import { Supplier } from "./Supplier.js";
+/**
+ * Makes a passthrough HTTP request using the SDK's configuration (auth, retry, logging, etc.)
+ * while mimicking the standard `fetch` API.
+ *
+ * @param input - The URL, path, or Request object. If a relative path, it will be resolved against the configured base URL.
+ * @param init - Standard RequestInit options (method, headers, body, signal, etc.)
+ * @param clientOptions - SDK client options (auth, default headers, logging, etc.)
+ * @param requestOptions - Per-request overrides (timeout, retries, extra headers, abort signal).
+ * @returns A standard Response object.
+ */
+export async function makePassthroughRequest(input, init, clientOptions, requestOptions) {
+    const logger = createLogger(clientOptions.logging);
+    // Extract URL and default init properties from Request object if provided
+    let url;
+    let effectiveInit = init;
+    if (input instanceof Request) {
+        url = input.url;
+        // If no explicit init provided, extract properties from the Request object
+        if (init == null) {
+            effectiveInit = {
+                method: input.method,
+                headers: Object.fromEntries(input.headers.entries()),
+                body: input.body,
+                signal: input.signal,
+                credentials: input.credentials,
+                cache: input.cache,
+                redirect: input.redirect,
+                referrer: input.referrer,
+                integrity: input.integrity,
+                mode: input.mode,
+            };
+        }
+    }
+    else {
+        url = input instanceof URL ? input.toString() : input;
+    }
+    // Resolve the base URL
+    const baseUrl = (clientOptions.baseUrl != null ? await Supplier.get(clientOptions.baseUrl) : undefined) ??
+        (clientOptions.environment != null ? await Supplier.get(clientOptions.environment) : undefined);
+    // Determine the full URL
+    let fullUrl;
+    if (url.startsWith("http://") || url.startsWith("https://")) {
+        fullUrl = url;
+    }
+    else if (baseUrl != null) {
+        fullUrl = join(baseUrl, url);
+    }
+    else {
+        fullUrl = url;
+    }
+    // Merge headers: SDK default headers -> auth headers -> user-provided headers
+    const mergedHeaders = {};
+    // Apply SDK default headers (resolve suppliers)
+    if (clientOptions.headers != null) {
+        for (const [key, value] of Object.entries(clientOptions.headers)) {
+            const resolved = await EndpointSupplier.get(value, { endpointMetadata: {} });
+            if (resolved != null) {
+                mergedHeaders[key.toLowerCase()] = `${resolved}`;
+            }
+        }
+    }
+    // Apply auth headers, but only when the resolved URL targets the configured base URL.
+    // This prevents the SDK's credentials from leaking to an unrelated host when a caller
+    // passes an absolute cross-origin URL into the passthrough fetch escape hatch.
+    if (clientOptions.getAuthHeaders != null && targetsBaseUrl(fullUrl, baseUrl)) {
+        const authHeaders = await clientOptions.getAuthHeaders();
+        for (const [key, value] of Object.entries(authHeaders)) {
+            mergedHeaders[key.toLowerCase()] = value;
+        }
+    }
+    // Apply user-provided headers from init
+    if (effectiveInit?.headers != null) {
+        const initHeaders = effectiveInit.headers instanceof Headers
+            ? Object.fromEntries(effectiveInit.headers.entries())
+            : Array.isArray(effectiveInit.headers)
+                ? Object.fromEntries(effectiveInit.headers)
+                : effectiveInit.headers;
+        for (const [key, value] of Object.entries(initHeaders)) {
+            if (value != null) {
+                mergedHeaders[key.toLowerCase()] = value;
+            }
+        }
+    }
+    // Apply per-request option headers (highest priority)
+    if (requestOptions?.headers != null) {
+        for (const [key, value] of Object.entries(requestOptions.headers)) {
+            mergedHeaders[key.toLowerCase()] = value;
+        }
+    }
+    const method = effectiveInit?.method ?? "GET";
+    const body = effectiveInit?.body;
+    const timeoutInSeconds = requestOptions?.timeoutInSeconds ?? clientOptions.timeoutInSeconds;
+    const timeoutMs = timeoutInSeconds != null ? timeoutInSeconds * 1000 : undefined;
+    // Modified by Lusor: only reads retry by default, as for the generated methods
+    // (overrides.yml). A write is attempted once unless this request sets maxRetries.
+    const maxRetries = requestOptions?.maxRetries ??
+        (["GET", "HEAD", "OPTIONS"].includes(method.toUpperCase()) ? clientOptions.maxRetries : 0);
+    const abortSignal = requestOptions?.abortSignal ?? effectiveInit?.signal ?? undefined;
+    const fetchFn = clientOptions.fetch ?? (await getFetchFn());
+    if (logger.isDebug()) {
+        logger.debug("Making passthrough HTTP request", {
+            method,
+            url: redactUrl(fullUrl),
+            hasBody: body != null,
+        });
+    }
+    const response = await requestWithRetries(async () => makeRequest(fetchFn, fullUrl, method, mergedHeaders, body ?? undefined, timeoutMs, abortSignal, effectiveInit?.credentials === "include", undefined, // duplex
+    false), maxRetries);
+    if (logger.isDebug()) {
+        logger.debug("Passthrough HTTP request completed", {
+            method,
+            url: redactUrl(fullUrl),
+            statusCode: response.status,
+        });
+    }
+    return response;
+}
+/**
+ * Returns true when the resolved request URL points at the same origin as the
+ * configured base URL. Relative paths are always joined onto the base URL, so
+ * they resolve to the base origin and return true. Absolute URLs only match when
+ * their origin equals the base origin. When there is no base URL to compare
+ * against, or either value is not a parseable absolute URL, this returns false so
+ * auth headers are not attached.
+ */
+function targetsBaseUrl(fullUrl, baseUrl) {
+    if (baseUrl == null) {
+        return false;
+    }
+    try {
+        return new URL(fullUrl).origin === new URL(baseUrl).origin;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/fetcher/makeRequest.d.ts

@@ -0,0 +1,6 @@
+export declare function isCacheNoStoreSupported(): boolean;
+/**
+ * Reset the cached result of `isCacheNoStoreSupported`. Exposed for testing only.
+ */
+export declare function resetCacheNoStoreSupported(): void;
+export declare const makeRequest: (fetchFn: (url: string, init: RequestInit) => Promise<Response>, url: string, method: string, headers: Headers | Record<string, string>, requestBody: BodyInit | undefined, timeoutMs?: number, abortSignal?: AbortSignal, withCredentials?: boolean, duplex?: "half", disableCache?: boolean) => Promise<Response>;

package/dist/core/fetcher/makeRequest.js

@@ -0,0 +1,57 @@
+import { anySignal, getTimeoutSignal } from "./signals.js";
+/**
+ * Cached result of checking whether the current runtime supports
+ * the `cache` option in `Request`. Some runtimes (e.g. Cloudflare Workers)
+ * throw a TypeError when this option is used.
+ */
+let _cacheNoStoreSupported;
+export function isCacheNoStoreSupported() {
+    if (_cacheNoStoreSupported != null) {
+        return _cacheNoStoreSupported;
+    }
+    try {
+        new Request("http://localhost", { cache: "no-store" });
+        _cacheNoStoreSupported = true;
+    }
+    catch {
+        _cacheNoStoreSupported = false;
+    }
+    return _cacheNoStoreSupported;
+}
+/**
+ * Reset the cached result of `isCacheNoStoreSupported`. Exposed for testing only.
+ */
+export function resetCacheNoStoreSupported() {
+    _cacheNoStoreSupported = undefined;
+}
+export const makeRequest = async (fetchFn, url, method, headers, requestBody, timeoutMs, abortSignal, withCredentials, duplex, disableCache) => {
+    const signals = [];
+    let timeoutAbortId;
+    if (timeoutMs != null) {
+        const { signal, abortId } = getTimeoutSignal(timeoutMs);
+        timeoutAbortId = abortId;
+        signals.push(signal);
+    }
+    if (abortSignal != null) {
+        signals.push(abortSignal);
+    }
+    const newSignals = anySignal(signals);
+    // Modified by Lusor: clear the timeout timer on every exit path.
+    try {
+        return await fetchFn(url, {
+            method: method,
+            headers,
+            body: requestBody,
+            signal: newSignals,
+            credentials: withCredentials ? "include" : undefined,
+            // @ts-ignore
+            duplex,
+            ...(disableCache && isCacheNoStoreSupported() ? { cache: "no-store" } : {}),
+        });
+    }
+    finally {
+        if (timeoutAbortId != null) {
+            clearTimeout(timeoutAbortId);
+        }
+    }
+};

package/dist/core/fetcher/redactUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const SENSITIVE_QUERY_PARAMS: Set<string>;
+export declare function redactUrl(url: string): string;

package/dist/core/fetcher/redactUrl.js

@@ -0,0 +1,84 @@
+export const SENSITIVE_QUERY_PARAMS = new Set([
+    "api_key",
+    "api-key",
+    "apikey",
+    "token",
+    "access_token",
+    "access-token",
+    "auth_token",
+    "auth-token",
+    "password",
+    "passwd",
+    "secret",
+    "api_secret",
+    "api-secret",
+    "apisecret",
+    "key",
+    "session",
+    "session_id",
+    "session-id",
+]);
+export function redactUrl(url) {
+    const protocolIndex = url.indexOf("://");
+    if (protocolIndex === -1)
+        return url;
+    const afterProtocol = protocolIndex + 3;
+    // Find the first delimiter that marks the end of the authority section
+    const pathStart = url.indexOf("/", afterProtocol);
+    let queryStart = url.indexOf("?", afterProtocol);
+    let fragmentStart = url.indexOf("#", afterProtocol);
+    const firstDelimiter = Math.min(pathStart === -1 ? url.length : pathStart, queryStart === -1 ? url.length : queryStart, fragmentStart === -1 ? url.length : fragmentStart);
+    // Find the LAST @ before the delimiter (handles multiple @ in credentials)
+    let atIndex = -1;
+    for (let i = afterProtocol; i < firstDelimiter; i++) {
+        if (url[i] === "@") {
+            atIndex = i;
+        }
+    }
+    if (atIndex !== -1) {
+        url = `${url.slice(0, afterProtocol)}[REDACTED]@${url.slice(atIndex + 1)}`;
+    }
+    // Recalculate queryStart since url might have changed
+    queryStart = url.indexOf("?");
+    if (queryStart === -1)
+        return url;
+    fragmentStart = url.indexOf("#", queryStart);
+    const queryEnd = fragmentStart !== -1 ? fragmentStart : url.length;
+    const queryString = url.slice(queryStart + 1, queryEnd);
+    if (queryString.length === 0)
+        return url;
+    // FAST PATH: Quick check if any sensitive keywords present
+    // Using indexOf is faster than regex for simple substring matching
+    const lower = queryString.toLowerCase();
+    const hasSensitive = lower.includes("token") ||
+        lower.includes("key") ||
+        lower.includes("password") ||
+        lower.includes("passwd") ||
+        lower.includes("secret") ||
+        lower.includes("session") ||
+        lower.includes("auth");
+    if (!hasSensitive) {
+        return url;
+    }
+    // SLOW PATH: Parse and redact
+    const redactedParams = [];
+    const params = queryString.split("&");
+    for (const param of params) {
+        const equalIndex = param.indexOf("=");
+        if (equalIndex === -1) {
+            redactedParams.push(param);
+            continue;
+        }
+        const key = param.slice(0, equalIndex);
+        let shouldRedact = SENSITIVE_QUERY_PARAMS.has(key.toLowerCase());
+        if (!shouldRedact && key.includes("%")) {
+            try {
+                const decodedKey = decodeURIComponent(key);
+                shouldRedact = SENSITIVE_QUERY_PARAMS.has(decodedKey.toLowerCase());
+            }
+            catch { }
+        }
+        redactedParams.push(shouldRedact ? `${key}=[REDACTED]` : param);
+    }
+    return url.slice(0, queryStart + 1) + redactedParams.join("&") + url.slice(queryEnd);
+}

package/dist/core/fetcher/requestWithRetries.d.ts

@@ -0,0 +1 @@
+export declare function requestWithRetries(requestFn: () => Promise<Response>, maxRetries?: number): Promise<Response>;

package/dist/core/fetcher/requestWithRetries.js

@@ -0,0 +1,56 @@
+const INITIAL_RETRY_DELAY = 1000; // in milliseconds
+const MAX_RETRY_DELAY = 60000; // in milliseconds
+const DEFAULT_MAX_RETRIES = 2;
+const JITTER_FACTOR = 0.2; // 20% random jitter
+function isRetryableStatusCode(statusCode) {
+    return [408, 429, 502, 503, 504].includes(statusCode);
+}
+function addPositiveJitter(delay) {
+    const jitterMultiplier = 1 + Math.random() * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function addSymmetricJitter(delay) {
+    const jitterMultiplier = 1 + (Math.random() - 0.5) * JITTER_FACTOR;
+    return delay * jitterMultiplier;
+}
+function getRetryDelayFromHeaders(response, retryAttempt) {
+    const retryAfter = response.headers.get("Retry-After");
+    if (retryAfter) {
+        const retryAfterSeconds = parseInt(retryAfter, 10);
+        if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds > 0) {
+            return Math.min(retryAfterSeconds * 1000, MAX_RETRY_DELAY);
+        }
+        const retryAfterDate = new Date(retryAfter);
+        if (!Number.isNaN(retryAfterDate.getTime())) {
+            const delay = retryAfterDate.getTime() - Date.now();
+            if (delay > 0) {
+                return Math.min(Math.max(delay, 0), MAX_RETRY_DELAY);
+            }
+        }
+    }
+    const rateLimitReset = response.headers.get("X-RateLimit-Reset");
+    if (rateLimitReset) {
+        const resetTime = parseInt(rateLimitReset, 10);
+        if (!Number.isNaN(resetTime)) {
+            const delay = resetTime * 1000 - Date.now();
+            if (delay > 0) {
+                return addPositiveJitter(Math.min(delay, MAX_RETRY_DELAY));
+            }
+        }
+    }
+    return addSymmetricJitter(Math.min(INITIAL_RETRY_DELAY * 2 ** retryAttempt, MAX_RETRY_DELAY));
+}
+export async function requestWithRetries(requestFn, maxRetries = DEFAULT_MAX_RETRIES) {
+    let response = await requestFn();
+    for (let i = 0; i < maxRetries; ++i) {
+        if (isRetryableStatusCode(response.status)) {
+            const delay = getRetryDelayFromHeaders(response, i);
+            await new Promise((resolve) => setTimeout(resolve, delay));
+            response = await requestFn();
+        }
+        else {
+            break;
+        }
+    }
+    return response;
+}

package/dist/core/fetcher/signals.d.ts

@@ -0,0 +1,5 @@
+export declare function getTimeoutSignal(timeoutMs: number): {
+    signal: AbortSignal;
+    abortId: ReturnType<typeof setTimeout>;
+};
+export declare function anySignal(...args: AbortSignal[] | [AbortSignal[]]): AbortSignal;

package/dist/core/fetcher/signals.js

@@ -0,0 +1,29 @@
+const TIMEOUT = "timeout";
+export function getTimeoutSignal(timeoutMs) {
+    const controller = new AbortController();
+    // Modified by Lusor: abort with an AbortError so the fetcher reports a timeout.
+    const abortId = setTimeout(() => controller.abort(new DOMException(TIMEOUT, "AbortError")), timeoutMs);
+    return { signal: controller.signal, abortId };
+}
+export function anySignal(...args) {
+    const signals = (args.length === 1 && Array.isArray(args[0]) ? args[0] : args);
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(signal?.reason);
+            return controller.signal;
+        }
+        signal.addEventListener("abort", () => controller.abort(signal?.reason), {
+            signal: controller.signal,
+        });
+        // Re-check after adding listener: the signal may have aborted
+        // between the initial `signal.aborted` check and the `addEventListener`
+        // call above. If it did, the abort event was already dispatched and
+        // the listener will never fire — we must manually abort.
+        if (signal.aborted) {
+            controller.abort(signal?.reason);
+            return controller.signal;
+        }
+    }
+    return controller.signal;
+}

package/dist/core/headers.d.ts

@@ -0,0 +1,2 @@
+export declare function mergeHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;
+export declare function mergeOnlyDefinedHeaders(...headersArray: (Record<string, unknown> | null | undefined)[]): Record<string, unknown>;

package/dist/core/headers.js

@@ -0,0 +1,27 @@
+export function mergeHeaders(...headersArray) {
+    const result = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        }
+        else if (insensitiveKey in result) {
+            delete result[insensitiveKey];
+        }
+    }
+    return result;
+}
+export function mergeOnlyDefinedHeaders(...headersArray) {
+    const result = {};
+    for (const [key, value] of headersArray
+        .filter((headers) => headers != null)
+        .flatMap((headers) => Object.entries(headers))) {
+        const insensitiveKey = key.toLowerCase();
+        if (value != null) {
+            result[insensitiveKey] = value;
+        }
+    }
+    return result;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./auth/index.js";
+export * from "./base64.js";
+export * from "./fetcher/index.js";
+export * as logging from "./logging/index.js";
+export * from "./runtime/index.js";
+export * from "./stream/index.js";
+export * as url from "./url/index.js";

package/dist/core/index.js

@@ -0,0 +1,7 @@
+export * from "./auth/index.js";
+export * from "./base64.js";
+export * from "./fetcher/index.js";
+export * as logging from "./logging/index.js";
+export * from "./runtime/index.js";
+export * from "./stream/index.js";
+export * as url from "./url/index.js";

package/dist/core/json.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export declare const toJson: (value: unknown, replacer?: (this: unknown, key: string, value: unknown) => unknown, space?: string | number) => string;
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export declare function fromJson<T = unknown>(text: string, reviver?: (this: unknown, key: string, value: unknown) => unknown): T;

package/dist/core/json.js

@@ -0,0 +1,19 @@
+/**
+ * Serialize a value to JSON
+ * @param value A JavaScript value, usually an object or array, to be converted.
+ * @param replacer A function that transforms the results.
+ * @param space Adds indentation, white space, and line break characters to the return-value JSON text to make it easier to read.
+ * @returns JSON string
+ */
+export const toJson = (value, replacer, space) => {
+    return JSON.stringify(value, replacer, space);
+};
+/**
+ * Parse JSON string to object, array, or other type
+ * @param text A valid JSON string.
+ * @param reviver A function that transforms the results. This function is called for each member of the object. If a member contains nested objects, the nested objects are transformed before the parent object is.
+ * @returns Parsed object, array, or other type
+ */
+export function fromJson(text, reviver) {
+    return JSON.parse(text, reviver);
+}

package/dist/core/logging/exports.d.ts

@@ -0,0 +1,18 @@
+import * as logger from "./logger.js";
+export declare namespace logging {
+    /**
+     * Configuration for logger instances.
+     */
+    type LogConfig = logger.LogConfig;
+    type LogLevel = logger.LogLevel;
+    const LogLevel: typeof logger.LogLevel;
+    type ILogger = logger.ILogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    type ConsoleLogger = logger.ConsoleLogger;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    const ConsoleLogger: typeof logger.ConsoleLogger;
+}

package/dist/core/logging/exports.js

@@ -0,0 +1,9 @@
+import * as logger from "./logger.js";
+export var logging;
+(function (logging) {
+    logging.LogLevel = logger.LogLevel;
+    /**
+     * Console logger implementation that outputs to the console.
+     */
+    logging.ConsoleLogger = logger.ConsoleLogger;
+})(logging || (logging = {}));

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

@@ -0,0 +1 @@
+export * from "./logger.js";

package/dist/core/logging/index.js

@@ -0,0 +1 @@
+export * from "./logger.js";