@jaypie/fabric 0.1.0

package/dist/esm/http/index.js

@@ -0,0 +1,1775 @@
+import { BadRequestError, UnauthorizedError, isJaypieError } from '@jaypie/errors';
+
+/**
+ * Meta-modeling Constants
+ */
+// =============================================================================
+// Constants
+// =============================================================================
+/** Root organizational unit */
+/** Fabric version - used to identify pre-instantiated Services */
+const FABRIC_VERSION = "0.1.0";
+
+/**
+ * Date Type Conversion for @jaypie/fabric
+ *
+ * Adds Date as a supported type in the fabric type system.
+ * Follows the same conversion patterns as String, Number, Boolean.
+ */
+/**
+ * Convert a value to a Date
+ *
+ * Supported inputs:
+ * - Date: returned as-is (validated)
+ * - Number: treated as Unix timestamp (milliseconds)
+ * - String: parsed via Date constructor (ISO 8601, etc.)
+ * - Object with value property: unwrapped and converted
+ *
+ * @throws BadRequestError if value cannot be converted to valid Date
+ */
+function fabricDate(value) {
+    // Already a Date
+    if (value instanceof Date) {
+        if (Number.isNaN(value.getTime())) {
+            throw new BadRequestError("Invalid Date value");
+        }
+        return value;
+    }
+    // Null/undefined
+    if (value === null || value === undefined) {
+        throw new BadRequestError("Cannot convert null or undefined to Date");
+    }
+    // Object with value property (fabric pattern)
+    if (typeof value === "object" && value !== null && "value" in value) {
+        return fabricDate(value.value);
+    }
+    // Number (timestamp in milliseconds)
+    if (typeof value === "number") {
+        if (Number.isNaN(value)) {
+            throw new BadRequestError("Cannot convert NaN to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new BadRequestError(`Cannot convert ${value} to Date`);
+        }
+        return date;
+    }
+    // String (ISO 8601 or parseable format)
+    if (typeof value === "string") {
+        // Empty string is invalid
+        if (value.trim() === "") {
+            throw new BadRequestError("Cannot convert empty string to Date");
+        }
+        const date = new Date(value);
+        if (Number.isNaN(date.getTime())) {
+            throw new BadRequestError(`Cannot convert "${value}" to Date`);
+        }
+        return date;
+    }
+    // Boolean cannot be converted to Date
+    if (typeof value === "boolean") {
+        throw new BadRequestError("Cannot convert boolean to Date");
+    }
+    // Arrays - attempt single element extraction
+    if (Array.isArray(value)) {
+        if (value.length === 1) {
+            return fabricDate(value[0]);
+        }
+        throw new BadRequestError(`Cannot convert array with ${value.length} elements to Date`);
+    }
+    throw new BadRequestError(`Cannot convert ${typeof value} to Date`);
+}
+/**
+ * Type guard for Date type in schema definitions
+ */
+function isDateType(type) {
+    return type === Date;
+}
+
+// Fabric functions for @jaypie/fabric
+/**
+ * Try to parse a string as JSON if it looks like JSON
+ * Returns the parsed value or the original string if not JSON
+ */
+function tryParseJson(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+        (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch {
+            // Not valid JSON, return original
+            return value;
+        }
+    }
+    return value;
+}
+/**
+ * Unwrap arrays and objects to get to the scalar value
+ * - Single-element arrays unwrap to their element
+ * - Objects with value property unwrap to that value
+ * - Recursively unwraps nested structures
+ */
+function unwrapToScalar(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Unwrap single-element arrays
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return undefined;
+        }
+        if (value.length === 1) {
+            return unwrapToScalar(value[0]);
+        }
+        throw new BadRequestError("Cannot convert multi-value array to scalar");
+    }
+    // Unwrap objects with value property
+    if (typeof value === "object") {
+        const obj = value;
+        if ("value" in obj) {
+            return unwrapToScalar(obj.value);
+        }
+        throw new BadRequestError("Object must have a value attribute");
+    }
+    return value;
+}
+/**
+ * Prepare a value for scalar conversion by parsing JSON strings and unwrapping
+ */
+function prepareForScalarConversion(value) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    // Try to parse JSON strings
+    if (typeof value === "string") {
+        const parsed = tryParseJson(value);
+        if (parsed !== value) {
+            // Successfully parsed, unwrap the result
+            return unwrapToScalar(parsed);
+        }
+        return value;
+    }
+    // Unwrap arrays and objects
+    if (Array.isArray(value) || typeof value === "object") {
+        return unwrapToScalar(value);
+    }
+    return value;
+}
+/**
+ * Convert a value to a boolean
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "true" becomes true
+ * - String "false" becomes false
+ * - Strings that parse to numbers: positive = true, zero or negative = false
+ * - Numbers: positive = true, zero or negative = false
+ * - Boolean passes through
+ */
+function fabricBoolean(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return true;
+        }
+        if (lower === "false") {
+            return false;
+        }
+        // Try to parse as number
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new BadRequestError(`Cannot convert "${prepared}" to Boolean`);
+        }
+        return num > 0;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to Boolean");
+        }
+        return prepared > 0;
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to Boolean`);
+}
+/**
+ * Convert a value to a number
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - String "true" becomes 1
+ * - String "false" becomes 0
+ * - Strings that parse to numbers use those values
+ * - Strings that parse to NaN throw BadRequestError
+ * - Boolean true becomes 1, false becomes 0
+ * - Number passes through
+ */
+function fabricNumber(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to Number");
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? 1 : 0;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        const lower = prepared.toLowerCase();
+        if (lower === "true") {
+            return 1;
+        }
+        if (lower === "false") {
+            return 0;
+        }
+        const num = parseFloat(prepared);
+        if (isNaN(num)) {
+            throw new BadRequestError(`Cannot convert "${prepared}" to Number`);
+        }
+        return num;
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to Number`);
+}
+/**
+ * Convert a value to a string
+ * - Arrays, objects, and JSON strings are unwrapped first
+ * - String "" becomes undefined
+ * - Boolean true becomes "true", false becomes "false"
+ * - Number converts to string representation
+ * - String passes through
+ */
+function fabricString(value) {
+    // Prepare value by parsing JSON and unwrapping arrays/objects
+    const prepared = prepareForScalarConversion(value);
+    if (prepared === undefined || prepared === null) {
+        return undefined;
+    }
+    if (typeof prepared === "string") {
+        if (prepared === "") {
+            return undefined;
+        }
+        return prepared;
+    }
+    if (typeof prepared === "boolean") {
+        return prepared ? "true" : "false";
+    }
+    if (typeof prepared === "number") {
+        if (isNaN(prepared)) {
+            throw new BadRequestError("Cannot convert NaN to String");
+        }
+        return String(prepared);
+    }
+    throw new BadRequestError(`Cannot convert ${typeof prepared} to String`);
+}
+/**
+ * Convert a value to an array
+ * - Non-arrays become arrays containing that value
+ * - Arrays of a single value become that value (unwrapped)
+ * - Multi-value arrays throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricArray(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (Array.isArray(value)) {
+        // Arrays pass through (single-element unwrapping happens when converting FROM array)
+        return value;
+    }
+    // Non-arrays become single-element arrays
+    return [value];
+}
+/**
+ * Convert a value to an object with a value property
+ * - Scalars become { value: scalar }
+ * - Arrays become { value: array }
+ * - Objects with a value attribute pass through
+ * - Objects without a value attribute throw BadRequestError
+ * - undefined/null become undefined
+ */
+function fabricObject(value) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    // Check if already an object (but not an array)
+    if (typeof value === "object" && !Array.isArray(value)) {
+        const obj = value;
+        if ("value" in obj) {
+            return obj;
+        }
+        throw new BadRequestError("Object must have a value attribute");
+    }
+    // Scalars and arrays become { value: ... }
+    return { value };
+}
+/**
+ * Check if a type is a typed array (e.g., [String], [Number], [], etc.)
+ */
+function isTypedArrayType(type) {
+    return Array.isArray(type);
+}
+/**
+ * Split a string on comma or tab delimiters for typed array conversion.
+ * Only splits if the string contains commas or tabs.
+ * Returns the original value if not a string or no delimiters found.
+ */
+function splitStringForArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    // Check for comma or tab delimiters
+    if (value.includes(",")) {
+        return value.split(",").map((s) => s.trim());
+    }
+    if (value.includes("\t")) {
+        return value.split("\t").map((s) => s.trim());
+    }
+    return value;
+}
+/**
+ * Try to parse a string as JSON for array context.
+ * Returns parsed value if it's an array, otherwise returns original.
+ */
+function tryParseJsonArray(value) {
+    if (typeof value !== "string") {
+        return value;
+    }
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Not valid JSON, fall through
+        }
+    }
+    return value;
+}
+/**
+ * Get the element type from a typed array type
+ * Returns undefined for untyped arrays ([])
+ */
+function getArrayElementType(type) {
+    if (type.length === 0) {
+        return undefined; // Untyped array
+    }
+    const elementType = type[0];
+    // Handle constructor types
+    if (elementType === Boolean)
+        return "boolean";
+    if (elementType === Number)
+        return "number";
+    if (elementType === String)
+        return "string";
+    if (elementType === Object)
+        return "object";
+    // Handle string types
+    if (elementType === "boolean")
+        return "boolean";
+    if (elementType === "number")
+        return "number";
+    if (elementType === "string")
+        return "string";
+    if (elementType === "object")
+        return "object";
+    // Handle shorthand types
+    if (elementType === "")
+        return "string"; // "" shorthand for String
+    if (typeof elementType === "object" &&
+        elementType !== null &&
+        Object.keys(elementType).length === 0) {
+        return "object"; // {} shorthand for Object
+    }
+    throw new BadRequestError(`Unknown array element type: ${String(elementType)}`);
+}
+/**
+ * Convert a value to a typed array
+ * - Tries to parse JSON arrays first
+ * - Splits strings on comma/tab if present
+ * - Wraps non-arrays in an array
+ * - Converts each element to the specified element type
+ */
+function fabricTypedArray(value, elementType) {
+    // Try to parse JSON array first
+    let processed = tryParseJsonArray(value);
+    // If still a string, try to split on comma/tab
+    processed = splitStringForArray(processed);
+    // Convert to array (wraps non-arrays)
+    const array = fabricArray(processed);
+    if (array === undefined) {
+        return undefined;
+    }
+    // If no element type specified, return as-is
+    if (elementType === undefined) {
+        return array;
+    }
+    // Convert each element to the element type
+    return array.map((element, index) => {
+        try {
+            switch (elementType) {
+                case "boolean":
+                    return fabricBoolean(element);
+                case "number":
+                    return fabricNumber(element);
+                case "object":
+                    return fabricObject(element);
+                case "string":
+                    return fabricString(element);
+                default:
+                    throw new BadRequestError(`Unknown element type: ${elementType}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof BadRequestError) {
+                throw new BadRequestError(`Cannot convert array element at index ${index}: ${error.message}`);
+            }
+            throw error;
+        }
+    });
+}
+/**
+ * Fabric a value to the specified type
+ */
+function fabric(value, type) {
+    // Check for Date type first
+    if (isDateType(type)) {
+        return fabricDate(value);
+    }
+    // Check for typed array types
+    if (isTypedArrayType(type)) {
+        const elementType = getArrayElementType(type);
+        return fabricTypedArray(value, elementType);
+    }
+    const normalizedType = normalizeType(type);
+    switch (normalizedType) {
+        case "array":
+            return fabricArray(value);
+        case "boolean":
+            return fabricBoolean(value);
+        case "number":
+            return fabricNumber(value);
+        case "object":
+            return fabricObject(value);
+        case "string":
+            return fabricString(value);
+        default:
+            throw new BadRequestError(`Unknown type: ${String(type)}`);
+    }
+}
+/**
+ * Normalize type to string representation
+ */
+function normalizeType(type) {
+    if (type === Array || type === "array") {
+        return "array";
+    }
+    if (type === Boolean || type === "boolean") {
+        return "boolean";
+    }
+    if (type === Number || type === "number") {
+        return "number";
+    }
+    if (type === Object || type === "object") {
+        return "object";
+    }
+    if (type === String || type === "string") {
+        return "string";
+    }
+    throw new BadRequestError(`Unknown type: ${String(type)}`);
+}
+
+// Service for @jaypie/fabric
+/**
+ * Check if a single-element array is a typed array type constructor.
+ */
+function isTypedArrayConstructor(element) {
+    return (element === Boolean ||
+        element === Number ||
+        element === String ||
+        element === Object ||
+        element === "boolean" ||
+        element === "number" ||
+        element === "string" ||
+        element === "object" ||
+        element === "" ||
+        (typeof element === "object" &&
+            element !== null &&
+            !(element instanceof RegExp) &&
+            Object.keys(element).length === 0));
+}
+/**
+ * Check if a type is a validated string type (array of string literals and/or RegExp).
+ * Distinguishes from typed arrays like [String], [Number], etc.
+ */
+function isValidatedStringType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated string
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are strings or RegExp
+    return type.every((item) => typeof item === "string" || item instanceof RegExp);
+}
+/**
+ * Check if a type is a validated number type (array of number literals).
+ * Distinguishes from typed arrays like [Number], etc.
+ */
+function isValidatedNumberType(type) {
+    if (!Array.isArray(type)) {
+        return false;
+    }
+    // Empty array is untyped array, not validated number
+    if (type.length === 0) {
+        return false;
+    }
+    // Single-element arrays with type constructors are typed arrays
+    if (type.length === 1 && isTypedArrayConstructor(type[0])) {
+        return false;
+    }
+    // Check that all elements are numbers
+    return type.every((item) => typeof item === "number");
+}
+/**
+ * Parse input string as JSON if it's a string
+ */
+function parseInput(input) {
+    if (input === undefined || input === null) {
+        return {};
+    }
+    if (typeof input === "string") {
+        if (input === "") {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(input);
+            if (typeof parsed !== "object" ||
+                parsed === null ||
+                Array.isArray(parsed)) {
+                throw new BadRequestError("Input must be an object");
+            }
+            return parsed;
+        }
+        catch (error) {
+            if (error instanceof BadRequestError) {
+                throw error;
+            }
+            throw new BadRequestError("Invalid JSON input");
+        }
+    }
+    if (typeof input === "object" && !Array.isArray(input)) {
+        return input;
+    }
+    throw new BadRequestError("Input must be an object or JSON string");
+}
+/**
+ * Run validation on a value (supports async validators)
+ */
+async function runValidation(value, validate, fieldName) {
+    if (typeof validate === "function") {
+        const result = await validate(value);
+        if (result === false) {
+            throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (validate instanceof RegExp) {
+        if (typeof value !== "string" || !validate.test(value)) {
+            throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+        }
+    }
+    else if (Array.isArray(validate)) {
+        // Check if value matches any item in the array
+        for (const item of validate) {
+            if (item instanceof RegExp) {
+                if (typeof value === "string" && item.test(value)) {
+                    return; // Match found
+                }
+            }
+            else if (typeof item === "function") {
+                try {
+                    const result = await item(value);
+                    if (result !== false) {
+                        return; // Match found
+                    }
+                }
+                catch {
+                    // Continue to next item
+                }
+            }
+            else if (value === item) {
+                return; // Scalar match found
+            }
+        }
+        throw new BadRequestError(`Validation failed for field "${fieldName}"`);
+    }
+}
+/**
+ * Check if a field is required
+ * A field is required unless it has a default OR required is explicitly false
+ */
+function isFieldRequired(definition) {
+    if (definition.required === false) {
+        return false;
+    }
+    if (definition.default !== undefined) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Process a single field through conversion and validation
+ */
+async function processField(fieldName, value, definition) {
+    // Apply default if value is undefined
+    let processedValue = value;
+    if (processedValue === undefined && definition.default !== undefined) {
+        processedValue = definition.default;
+    }
+    // Determine actual type and validation
+    let actualType = definition.type;
+    let validation = definition.validate;
+    // Handle bare RegExp shorthand: /regex/
+    if (definition.type instanceof RegExp) {
+        actualType = String;
+        validation = definition.type; // The RegExp becomes the validation
+    }
+    // Handle validated string shorthand: ["value1", "value2"] or [/regex/]
+    else if (isValidatedStringType(definition.type)) {
+        actualType = String;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Handle validated number shorthand: [1, 2, 3]
+    else if (isValidatedNumberType(definition.type)) {
+        actualType = Number;
+        validation = definition.type; // The array becomes the validation
+    }
+    // Fabric to target type
+    const convertedValue = fabric(processedValue, actualType);
+    // Check if required field is missing
+    if (convertedValue === undefined && isFieldRequired(definition)) {
+        throw new BadRequestError(`Missing required field "${fieldName}"`);
+    }
+    // Run validation if provided
+    if (validation !== undefined && convertedValue !== undefined) {
+        await runValidation(convertedValue, validation, fieldName);
+    }
+    return convertedValue;
+}
+/**
+ * Fabric a service function
+ *
+ * Service builds a function that initiates a "controller" step that:
+ * - Parses the input if it is a string to object
+ * - Fabrics each input field to its type
+ * - Calls the validation function or regular expression or checks the array
+ * - Calls the service function and returns the response
+ *
+ * The returned function has config properties for introspection.
+ */
+function fabricService(config) {
+    const { input: inputDefinitions, service } = config;
+    const handler = async (rawInput, context) => {
+        // Parse input (handles string JSON)
+        const parsedInput = parseInput(rawInput);
+        // If no input definitions, pass through to service or return parsed input
+        if (!inputDefinitions) {
+            if (service) {
+                return service(parsedInput, context);
+            }
+            return parsedInput;
+        }
+        // Process all fields in parallel
+        const entries = Object.entries(inputDefinitions);
+        const processedValues = await Promise.all(entries.map(([fieldName, definition]) => processField(fieldName, parsedInput[fieldName], definition)));
+        // Build processed input object
+        const processedInput = {};
+        entries.forEach(([fieldName], index) => {
+            processedInput[fieldName] = processedValues[index];
+        });
+        // Return processed input if no service, otherwise call service
+        if (service) {
+            return service(processedInput, context);
+        }
+        return processedInput;
+    };
+    // Attach config properties directly to handler for flat access
+    const typedHandler = handler;
+    typedHandler.$fabric = FABRIC_VERSION;
+    if (config.alias !== undefined)
+        typedHandler.alias = config.alias;
+    if (config.description !== undefined)
+        typedHandler.description = config.description;
+    if (config.input !== undefined)
+        typedHandler.input = config.input;
+    if (config.service !== undefined)
+        typedHandler.service = config.service;
+    return typedHandler;
+}
+
+/**
+ * Extract token from Authorization header
+ * Removes "Bearer " prefix (case insensitive) and strips whitespace
+ *
+ * Examples:
+ * - "Bearer eyJhbGc..." → "eyJhbGc..."
+ * - "bearer eyJhbGc..." → "eyJhbGc..."
+ * - "BEARER eyJhbGc..." → "eyJhbGc..."
+ * - "eyJhbGc..." → "eyJhbGc..."
+ * - "  eyJhbGc...  " → "eyJhbGc..."
+ */
+function extractToken(authHeader) {
+    if (!authHeader) {
+        return "";
+    }
+    let token = authHeader.trim();
+    // Remove "Bearer " prefix (case insensitive)
+    const bearerRegex = /^bearer\s+/i;
+    if (bearerRegex.test(token)) {
+        token = token.replace(bearerRegex, "");
+    }
+    return token.trim();
+}
+/**
+ * Get authorization header from Headers object
+ */
+function getAuthHeader(headers) {
+    return headers.get("authorization");
+}
+/**
+ * Validate authorization and return auth context
+ *
+ * @param headers - Request headers
+ * @param config - Authorization configuration (function or false)
+ * @returns Auth context from the authorization function, or undefined if public
+ * @throws UnauthorizedError if authorization fails
+ */
+async function validateAuthorization(headers, config) {
+    // Public endpoint - no authorization required
+    if (config === false) {
+        return undefined;
+    }
+    const authHeader = getAuthHeader(headers);
+    const token = extractToken(authHeader);
+    // If authorization is required but no token provided
+    if (!token) {
+        throw new UnauthorizedError("Authorization header required");
+    }
+    // Call the authorization function
+    const authFunction = config;
+    return authFunction(token);
+}
+/**
+ * Check if authorization is required
+ */
+function isAuthorizationRequired(config) {
+    return config !== false;
+}
+
+/**
+ * Default HTTP transformation function
+ * Merges query parameters with body (body takes precedence)
+ */
+const defaultHttpTransform = ({ body, query, }) => {
+    const queryObject = Object.fromEntries(query.entries());
+    const bodyObject = typeof body === "object" && body !== null ? body : {};
+    return {
+        ...queryObject,
+        ...bodyObject,
+    };
+};
+/**
+ * Parse query string into URLSearchParams
+ */
+function parseQueryString(queryString) {
+    // Remove leading ? if present
+    const normalized = queryString.startsWith("?")
+        ? queryString.slice(1)
+        : queryString;
+    return new URLSearchParams(normalized);
+}
+/**
+ * Parse path parameters from a URL path using a route pattern
+ * @param path - The actual URL path (e.g., "/users/123")
+ * @param pattern - The route pattern (e.g., "/users/:id")
+ * @returns Object with extracted parameters
+ */
+function parsePathParams(path, pattern) {
+    const params = {};
+    const pathParts = path.split("/").filter(Boolean);
+    const patternParts = pattern.split("/").filter(Boolean);
+    for (let i = 0; i < patternParts.length; i++) {
+        const patternPart = patternParts[i];
+        const pathPart = pathParts[i];
+        if (patternPart.startsWith(":")) {
+            // Extract parameter name (remove : prefix and ? suffix for optional params)
+            const paramName = patternPart.slice(1).replace("?", "");
+            if (pathPart !== undefined) {
+                params[paramName] = pathPart;
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Parse request body from string or return as-is if already parsed
+ */
+function parseBody(body) {
+    if (typeof body === "string") {
+        try {
+            return JSON.parse(body);
+        }
+        catch {
+            // Return as-is if not valid JSON
+            return body;
+        }
+    }
+    return body;
+}
+/**
+ * Create HTTP context from raw request data
+ */
+function createHttpContext(options) {
+    const { body = {}, headers = {}, method = "GET", path = "/", queryString = "", params = {}, } = options;
+    // Normalize headers to Headers object
+    const normalizedHeaders = headers instanceof Headers
+        ? headers
+        : new Headers(headers);
+    return {
+        body: parseBody(body),
+        headers: normalizedHeaders,
+        method: method.toUpperCase(),
+        path,
+        query: parseQueryString(queryString),
+        params,
+    };
+}
+/**
+ * Apply HTTP transformation to get service input
+ */
+async function transformHttpToInput(context, transform = defaultHttpTransform) {
+    return transform(context);
+}
+
+/**
+ * Check if a value is a fabricService (has $fabric property)
+ */
+function isFabricService(value) {
+    return (typeof value === "function" &&
+        "$fabric" in value &&
+        typeof value.$fabric === "string");
+}
+/**
+ * Create an HTTP-aware fabric service
+ *
+ * Extends fabricService with:
+ * - HTTP context transformation (body, headers, method, path, query, params)
+ * - Authorization handling (token extraction from Authorization header)
+ * - CORS configuration (enabled by default)
+ *
+ * Accepts either:
+ * - Inline service definition (with `service` function)
+ * - Pre-built `fabricService` instance (via `service` property)
+ */
+function fabricHttp(config) {
+    const { authorization = false, cors = true, http = defaultHttpTransform, service: serviceConfig, stream = false, ...baseConfig } = config;
+    // Resolve the underlying service
+    let underlyingService;
+    if (isFabricService(serviceConfig)) {
+        // Pre-built fabricService - merge configs
+        underlyingService = serviceConfig;
+        // Merge base config properties from the pre-built service
+        if (baseConfig.alias === undefined &&
+            underlyingService.alias !== undefined) {
+            baseConfig.alias = underlyingService.alias;
+        }
+        if (baseConfig.description === undefined &&
+            underlyingService.description !== undefined) {
+            baseConfig.description = underlyingService.description;
+        }
+        if (baseConfig.input === undefined &&
+            underlyingService.input !== undefined) {
+            baseConfig.input = underlyingService.input;
+        }
+    }
+    else {
+        // Inline service definition or plain function
+        const serviceFunction = serviceConfig;
+        underlyingService = fabricService({
+            ...baseConfig,
+            service: serviceFunction,
+        });
+    }
+    // Create the HTTP handler that processes HTTP context
+    const httpHandler = async (input, context) => {
+        // If context has HTTP info, process authorization
+        // (HTTP context is added by the adapter layer like fabricExpress)
+        if (context?.http && authorization !== false) {
+            const authResult = await validateAuthorization(context.http.headers, authorization);
+            // Add auth result to context
+            context.auth = authResult;
+        }
+        // Call the underlying service
+        return underlyingService(input, context);
+    };
+    // Create the HTTP service with all properties
+    const httpService = httpHandler;
+    // Copy properties from config (which may have been merged with underlying service)
+    httpService.$fabric = underlyingService.$fabric;
+    // Use baseConfig values (which include overrides) or fall back to underlying service
+    const resolvedAlias = baseConfig.alias ?? underlyingService.alias;
+    const resolvedDescription = baseConfig.description ?? underlyingService.description;
+    const resolvedInput = baseConfig.input ?? underlyingService.input;
+    if (resolvedAlias !== undefined) {
+        httpService.alias = resolvedAlias;
+    }
+    if (resolvedDescription !== undefined) {
+        httpService.description = resolvedDescription;
+    }
+    if (resolvedInput !== undefined) {
+        httpService.input = resolvedInput;
+    }
+    if (underlyingService.service !== undefined) {
+        httpService.service = underlyingService.service;
+    }
+    // Add HTTP-specific properties
+    httpService.authorization = authorization;
+    httpService.cors = cors;
+    httpService.http = http;
+    httpService.stream = stream;
+    return httpService;
+}
+/**
+ * Check if a service is an HTTP service (has http, authorization, cors properties)
+ */
+function isFabricHttpService(value) {
+    return (isFabricService(value) &&
+        "authorization" in value &&
+        "cors" in value &&
+        "http" in value &&
+        "stream" in value);
+}
+
+/**
+ * Default CORS configuration
+ */
+const DEFAULT_CORS_CONFIG = {
+    origin: "*",
+    credentials: false,
+    headers: ["Content-Type", "Authorization"],
+    exposeHeaders: [],
+    maxAge: 86400, // 24 hours
+};
+/**
+ * Default allowed methods for CORS
+ */
+const DEFAULT_CORS_METHODS = [
+    "GET",
+    "POST",
+    "DELETE",
+    "OPTIONS",
+];
+/**
+ * Normalize CORS option to CorsConfig
+ * - true → default config
+ * - false → disabled (returns undefined)
+ * - CorsConfig → merged with defaults
+ */
+function normalizeCorsConfig(option) {
+    // Undefined or true → use defaults
+    if (option === undefined || option === true) {
+        return { ...DEFAULT_CORS_CONFIG };
+    }
+    // False → disabled
+    if (option === false) {
+        return undefined;
+    }
+    // Merge with defaults
+    return {
+        ...DEFAULT_CORS_CONFIG,
+        ...option,
+    };
+}
+/**
+ * Get the allowed origin for a request
+ * @param config - CORS configuration
+ * @param requestOrigin - Origin header from request
+ * @returns The origin to allow, or undefined if not allowed
+ */
+function getAllowedOrigin(config, requestOrigin) {
+    const { origin } = config;
+    // Wildcard allows all
+    if (origin === "*") {
+        return "*";
+    }
+    // No origin in request
+    if (!requestOrigin) {
+        return undefined;
+    }
+    // Array of allowed origins
+    if (Array.isArray(origin)) {
+        if (origin.includes(requestOrigin)) {
+            return requestOrigin;
+        }
+        return undefined;
+    }
+    // Single origin string
+    if (origin === requestOrigin) {
+        return requestOrigin;
+    }
+    return undefined;
+}
+/**
+ * Build CORS headers for a response
+ * @param config - CORS configuration
+ * @param requestOrigin - Origin header from request
+ * @param methods - Allowed HTTP methods
+ * @returns Object with CORS headers, or empty object if CORS is disabled
+ */
+function buildCorsHeaders(config, requestOrigin, methods = DEFAULT_CORS_METHODS) {
+    if (!config) {
+        return {};
+    }
+    const headers = {};
+    // Access-Control-Allow-Origin
+    const allowedOrigin = getAllowedOrigin(config, requestOrigin);
+    if (allowedOrigin) {
+        headers["Access-Control-Allow-Origin"] = allowedOrigin;
+    }
+    // Access-Control-Allow-Methods
+    headers["Access-Control-Allow-Methods"] = methods.join(", ");
+    // Access-Control-Allow-Headers
+    if (config.headers && config.headers.length > 0) {
+        headers["Access-Control-Allow-Headers"] = config.headers.join(", ");
+    }
+    // Access-Control-Allow-Credentials
+    if (config.credentials) {
+        headers["Access-Control-Allow-Credentials"] = "true";
+    }
+    // Access-Control-Expose-Headers
+    if (config.exposeHeaders && config.exposeHeaders.length > 0) {
+        headers["Access-Control-Expose-Headers"] = config.exposeHeaders.join(", ");
+    }
+    // Access-Control-Max-Age
+    if (config.maxAge !== undefined) {
+        headers["Access-Control-Max-Age"] = String(config.maxAge);
+    }
+    return headers;
+}
+/**
+ * Check if request is a CORS preflight request
+ */
+function isPreflightRequest(method, headers) {
+    return (method.toUpperCase() === "OPTIONS" &&
+        headers.has("access-control-request-method"));
+}
+/**
+ * Build preflight response headers
+ * Includes all CORS headers needed for preflight response
+ */
+function buildPreflightHeaders(config, requestOrigin, requestMethod, requestHeaders, methods = DEFAULT_CORS_METHODS) {
+    if (!config) {
+        return {};
+    }
+    const headers = buildCorsHeaders(config, requestOrigin, methods);
+    // Include requested headers in response if not already covered
+    if (requestHeaders) {
+        const requestedHeaders = requestHeaders.split(",").map((h) => h.trim());
+        const allowedHeaders = config.headers || [];
+        const combinedHeaders = [
+            ...new Set([...allowedHeaders, ...requestedHeaders]),
+        ];
+        headers["Access-Control-Allow-Headers"] = combinedHeaders.join(", ");
+    }
+    return headers;
+}
+
+/**
+ * Default HTTP methods for fabric services
+ */
+const DEFAULT_HTTP_METHODS = ["GET", "POST", "DELETE"];
+// #endregion
+// #region Streaming
+/**
+ * HTTP stream event types for SSE/NDJSON streaming
+ */
+var HttpStreamEventType;
+(function (HttpStreamEventType) {
+    /** Stream complete */
+    HttpStreamEventType["Complete"] = "complete";
+    /** Final response data */
+    HttpStreamEventType["Data"] = "data";
+    /** Error event */
+    HttpStreamEventType["Error"] = "error";
+    /** Fabric progress message (from sendMessage) */
+    HttpStreamEventType["Message"] = "message";
+    /** Keep-alive signal (no content) */
+    HttpStreamEventType["Noop"] = "noop";
+    /** LLM text chunk */
+    HttpStreamEventType["Text"] = "text";
+    /** LLM tool call event */
+    HttpStreamEventType["ToolCall"] = "tool_call";
+    /** LLM tool result event */
+    HttpStreamEventType["ToolResult"] = "tool_result";
+})(HttpStreamEventType || (HttpStreamEventType = {}));
+// #endregion
+
+// FabricHttpServer - Standalone Lambda/server for multi-service HTTP routing
+/**
+ * Check if event is API Gateway v2 format
+ */
+function isApiGatewayV2Event(event) {
+    return "requestContext" in event && "http" in event.requestContext;
+}
+/**
+ * Check if entry is a FabricHttpServerRoute (has service property)
+ */
+function isRouteConfig(entry) {
+    return (typeof entry === "object" &&
+        entry !== null &&
+        "service" in entry &&
+        isFabricHttpService(entry.service));
+}
+/**
+ * Extract request data from API Gateway event (v1 or v2)
+ */
+function extractRequestData(event) {
+    if (isApiGatewayV2Event(event)) {
+        // API Gateway v2 (HTTP API)
+        return {
+            body: event.body ?? null,
+            headers: event.headers ?? {},
+            method: event.requestContext.http.method,
+            path: event.rawPath,
+            queryString: event.rawQueryString ?? "",
+            pathParams: event.pathParameters ?? {},
+        };
+    }
+    else {
+        // API Gateway v1 (REST API)
+        const v1Event = event;
+        // Convert query params to query string
+        const queryParams = v1Event.queryStringParameters ?? {};
+        const queryString = new URLSearchParams(queryParams).toString();
+        return {
+            body: v1Event.body,
+            headers: v1Event.headers ?? {},
+            method: v1Event.httpMethod,
+            path: v1Event.path,
+            queryString,
+            pathParams: v1Event.pathParameters ?? {},
+        };
+    }
+}
+/**
+ * Match a request path against a route pattern
+ * Returns extracted params if matched, undefined if not
+ */
+function matchRoute(requestPath, route) {
+    const requestSegments = requestPath.split("/").filter(Boolean);
+    const routeSegments = route.segments;
+    // Check segment count (allow route to have optional params)
+    if (requestSegments.length < routeSegments.filter((s) => !s.endsWith("?")).length) {
+        return undefined;
+    }
+    if (requestSegments.length > routeSegments.length) {
+        return undefined;
+    }
+    const params = {};
+    for (let i = 0; i < routeSegments.length; i++) {
+        const routeSegment = routeSegments[i];
+        const requestSegment = requestSegments[i];
+        if (routeSegment.startsWith(":")) {
+            // Parameter segment
+            const paramName = routeSegment.slice(1).replace("?", "");
+            const isOptional = routeSegment.endsWith("?");
+            if (requestSegment !== undefined) {
+                params[paramName] = requestSegment;
+            }
+            else if (!isOptional) {
+                return undefined; // Required param missing
+            }
+        }
+        else {
+            // Literal segment - must match exactly
+            if (requestSegment !== routeSegment) {
+                return undefined;
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Find matching route for a request
+ */
+function findRoute(path, method, routes, prefix) {
+    // Remove prefix from path if present
+    let normalizedPath = path;
+    if (prefix && normalizedPath.startsWith(prefix)) {
+        normalizedPath = normalizedPath.slice(prefix.length) || "/";
+    }
+    // Find first matching route
+    for (const route of routes) {
+        // Check method first
+        if (!route.methods.includes(method.toUpperCase())) {
+            continue;
+        }
+        // Try to match path
+        const params = matchRoute(normalizedPath, route);
+        if (params !== undefined) {
+            return { route, params };
+        }
+    }
+    return undefined;
+}
+/**
+ * Find route by path only (ignoring method) for 405 responses
+ */
+function findRouteByPath(path, routes, prefix) {
+    let normalizedPath = path;
+    if (prefix && normalizedPath.startsWith(prefix)) {
+        normalizedPath = normalizedPath.slice(prefix.length) || "/";
+    }
+    for (const route of routes) {
+        const params = matchRoute(normalizedPath, route);
+        if (params !== undefined) {
+            return route;
+        }
+    }
+    return undefined;
+}
+/**
+ * Build API Gateway response
+ */
+function buildResponse(statusCode, body, headers = {}) {
+    return {
+        statusCode,
+        headers: {
+            "Content-Type": "application/json",
+            ...headers,
+        },
+        body: JSON.stringify(body),
+    };
+}
+/**
+ * Apply CORS headers to response headers object
+ */
+function applyCorsHeaders(responseHeaders, corsHeaders) {
+    for (const [key, value] of Object.entries(corsHeaders)) {
+        if (value !== undefined) {
+            responseHeaders[key] = value;
+        }
+    }
+}
+/**
+ * Create a standalone HTTP server for Lambda
+ *
+ * Routes multiple FabricHttpService instances without Express:
+ * - Parses API Gateway v1 and v2 events
+ * - Matches routes by path pattern and HTTP method
+ * - Handles CORS preflight and response headers
+ * - Returns JSON:API formatted responses
+ *
+ * @example
+ * ```typescript
+ * import { FabricHttpServer } from "@jaypie/fabric/http";
+ * import { lambdaHandler } from "@jaypie/lambda";
+ *
+ * const server = FabricHttpServer({
+ *   services: [
+ *     userService,
+ *     { service: productService, path: "/products/:id", methods: ["GET", "PUT"] },
+ *   ],
+ *   prefix: "/api",
+ * });
+ *
+ * export const handler = lambdaHandler(server);
+ * ```
+ */
+function FabricHttpServer(config) {
+    const { services, authorization: serverAuthorization, cors: serverCors = true, prefix, } = config;
+    // Build routes from services
+    const routes = [];
+    const registeredServices = [];
+    for (const entry of services) {
+        let service;
+        let path;
+        let methods;
+        if (isRouteConfig(entry)) {
+            service = entry.service;
+            path = entry.path;
+            methods = entry.methods;
+        }
+        else if (isFabricHttpService(entry)) {
+            service = entry;
+        }
+        else {
+            throw new Error("FabricHttpServer: Each service entry must be a FabricHttpService or { service: FabricHttpService }");
+        }
+        // Determine path from config or service alias
+        const routePath = path ?? (service.alias ? `/${service.alias}` : "/");
+        // Parse route segments
+        const segments = routePath.split("/").filter(Boolean);
+        routes.push({
+            path: routePath,
+            segments,
+            methods: methods ?? DEFAULT_HTTP_METHODS,
+            service,
+        });
+        registeredServices.push(service);
+    }
+    // Normalize server-level CORS config
+    const serverCorsConfig = normalizeCorsConfig(serverCors);
+    /**
+     * Main request handler
+     */
+    const handler = async (event) => {
+        // Extract request data from API Gateway event
+        const { body, headers, method, path: requestPath, queryString, pathParams } = extractRequestData(event);
+        // Normalize headers to Headers object for consistency
+        const headersObj = new Headers(headers);
+        const origin = headersObj.get("origin");
+        // Collect all methods for matched path (for 405 and OPTIONS)
+        const pathRoute = findRouteByPath(requestPath, routes, prefix);
+        const allowedMethods = pathRoute?.methods ?? [];
+        // Handle CORS preflight
+        if (isPreflightRequest(method, headersObj)) {
+            const preflightHeaders = buildPreflightHeaders(serverCorsConfig, origin, headersObj.get("access-control-request-method"), headersObj.get("access-control-request-headers"), allowedMethods.length > 0 ? allowedMethods : DEFAULT_HTTP_METHODS);
+            const responseHeaders = {};
+            applyCorsHeaders(responseHeaders, preflightHeaders);
+            return {
+                statusCode: 204,
+                headers: responseHeaders,
+                body: "",
+            };
+        }
+        // Build CORS headers for response
+        const corsHeaders = buildCorsHeaders(serverCorsConfig, origin, allowedMethods);
+        const responseHeaders = {
+            "Content-Type": "application/json",
+        };
+        applyCorsHeaders(responseHeaders, corsHeaders);
+        // Find matching route
+        const match = findRoute(requestPath, method, routes, prefix);
+        // 404 - No route found
+        if (!match && !pathRoute) {
+            const errorResponse = {
+                errors: [
+                    {
+                        status: 404,
+                        title: "Not Found",
+                        detail: `No route matches ${requestPath}`,
+                    },
+                ],
+            };
+            return buildResponse(404, errorResponse, responseHeaders);
+        }
+        // 405 - Path exists but method not allowed
+        if (!match && pathRoute) {
+            const errorResponse = {
+                errors: [
+                    {
+                        status: 405,
+                        title: "Method Not Allowed",
+                        detail: `${method} is not allowed for ${requestPath}`,
+                    },
+                ],
+            };
+            responseHeaders["Allow"] = pathRoute.methods.join(", ");
+            return buildResponse(405, errorResponse, responseHeaders);
+        }
+        // We have a match
+        const { route, params } = match;
+        const service = route.service;
+        try {
+            // Create HTTP context
+            const httpContext = createHttpContext({
+                body,
+                headers,
+                method,
+                path: requestPath,
+                queryString,
+                params: { ...pathParams, ...params },
+            });
+            // Transform to service input
+            const input = await transformHttpToInput(httpContext, service.http);
+            // Build service context
+            const serviceContext = {
+                http: httpContext,
+            };
+            // Call the service
+            const result = await service(input, serviceContext);
+            // Build success response
+            const successResponse = {
+                data: result,
+            };
+            return buildResponse(200, successResponse, responseHeaders);
+        }
+        catch (error) {
+            // Handle errors
+            const jaypieError = isJaypieError(error);
+            const status = jaypieError ? error.status : 500;
+            const title = jaypieError
+                ? error.title
+                : "Internal Server Error";
+            const detail = error instanceof Error ? error.message : String(error);
+            const errorResponse = {
+                errors: [
+                    {
+                        status,
+                        title,
+                        detail: status === 500 ? undefined : detail,
+                    },
+                ],
+            };
+            return buildResponse(status, errorResponse, responseHeaders);
+        }
+    };
+    // Attach metadata to handler
+    const server = handler;
+    server.services = registeredServices;
+    server.prefix = prefix;
+    server.routes = routes;
+    return server;
+}
+/**
+ * Check if a value is a FabricHttpServer
+ */
+function isFabricHttpServer(value) {
+    return (typeof value === "function" &&
+        "services" in value &&
+        Array.isArray(value.services) &&
+        "routes" in value &&
+        Array.isArray(value.routes));
+}
+
+// #region Constants
+/**
+ * Default stream configuration
+ */
+const DEFAULT_STREAM_CONFIG = {
+    format: "ndjson",
+    heartbeat: 15000,
+    includeTools: true,
+};
+// #endregion
+// #region Stream Config
+/**
+ * Normalize stream option to StreamConfig
+ * - true → default config (NDJSON format, tools included)
+ * - false/undefined → disabled (returns undefined)
+ */
+function normalizeStreamConfig(option) {
+    if (option === true) {
+        return { ...DEFAULT_STREAM_CONFIG };
+    }
+    return undefined;
+}
+/**
+ * Check if streaming is enabled
+ */
+function isStreamingEnabled(option) {
+    return option === true;
+}
+// #endregion
+// #region Event Formatting
+/**
+ * Format a stream event as SSE (Server-Sent Events)
+ *
+ * SSE format:
+ * event: <type>
+ * data: <json>
+ *
+ */
+function formatSseEvent(event) {
+    const eventType = event.stream;
+    const data = JSON.stringify(event);
+    return `event: ${eventType}\ndata: ${data}\n\n`;
+}
+/**
+ * Format a stream event as NDJSON (Newline-Delimited JSON)
+ */
+function formatNdjsonEvent(event) {
+    return JSON.stringify(event) + "\n";
+}
+/**
+ * Format a stream event based on config
+ */
+function formatStreamEvent(event, config) {
+    if (config.format === "ndjson") {
+        return formatNdjsonEvent(event);
+    }
+    return formatSseEvent(event);
+}
+/**
+ * Get content-type header for stream format
+ */
+function getStreamContentType(config) {
+    if (config.format === "ndjson") {
+        return "application/x-ndjson";
+    }
+    return "text/event-stream";
+}
+// #endregion
+// #region Event Creators
+/**
+ * Create a message event (progress update)
+ */
+function createMessageEvent(content, level) {
+    const event = {
+        stream: HttpStreamEventType.Message,
+        content,
+    };
+    if (level !== undefined) {
+        event.level = level;
+    }
+    return event;
+}
+/**
+ * Create a text event (LLM text chunk)
+ */
+function createTextEvent(content) {
+    return {
+        stream: HttpStreamEventType.Text,
+        content,
+    };
+}
+/**
+ * Create a tool call event
+ */
+function createToolCallEvent(toolCall) {
+    return {
+        stream: HttpStreamEventType.ToolCall,
+        toolCall,
+    };
+}
+/**
+ * Create a tool result event
+ */
+function createToolResultEvent(toolResult) {
+    return {
+        stream: HttpStreamEventType.ToolResult,
+        toolResult,
+    };
+}
+/**
+ * Create a data event (final response)
+ */
+function createDataEvent(data) {
+    return {
+        stream: HttpStreamEventType.Data,
+        data,
+    };
+}
+/**
+ * Create an error event
+ */
+function createErrorEvent(error) {
+    return {
+        stream: HttpStreamEventType.Error,
+        error,
+    };
+}
+/**
+ * Create a complete event
+ */
+function createCompleteEvent() {
+    return {
+        stream: HttpStreamEventType.Complete,
+    };
+}
+/**
+ * Create a noop event (keep-alive signal)
+ */
+function createNoopEvent() {
+    return {
+        stream: HttpStreamEventType.Noop,
+    };
+}
+/**
+ * Create a stream context with streaming capabilities
+ *
+ * @param writer - Function to write stream events
+ * @param baseContext - Base service context to extend
+ * @returns Extended context with stream methods
+ */
+function createStreamContext(writer, baseContext) {
+    const streamEvent = (event) => {
+        try {
+            writer(event);
+        }
+        catch {
+            // Swallow errors in stream writer (connection may be closed)
+        }
+    };
+    const streamText = (content) => {
+        streamEvent(createTextEvent(content));
+    };
+    // Create sendMessage that streams as message events
+    const sendMessage = (message) => {
+        try {
+            const event = createMessageEvent(message.content, message.level);
+            writer(event);
+        }
+        catch {
+            // Swallow errors
+        }
+    };
+    return {
+        ...baseContext,
+        sendMessage,
+        streamEvent,
+        streamText,
+    };
+}
+// #endregion
+// #region Async Generator Utilities
+/**
+ * Check if a value is an async iterable
+ */
+function isAsyncIterable(value) {
+    return (value !== null && typeof value === "object" && Symbol.asyncIterator in value);
+}
+/**
+ * Collect all events from an async iterable into an array
+ * Useful for testing
+ */
+async function collectStreamEvents(stream) {
+    const events = [];
+    for await (const event of stream) {
+        events.push(event);
+    }
+    return events;
+}
+/**
+ * Create an async generator that yields events and returns final data
+ */
+async function* wrapServiceForStreaming(serviceResult) {
+    // If result is already an async iterable, pass through
+    if (isAsyncIterable(serviceResult)) {
+        yield* serviceResult;
+        return;
+    }
+    // Otherwise, wrap single result as data event
+    yield createDataEvent(serviceResult);
+    yield createCompleteEvent();
+}
+// #endregion
+// #region LLM Stream Integration
+/**
+ * LLM stream chunk types (matches @jaypie/llm LlmStreamChunkType)
+ * Defined locally to avoid hard dependency on @jaypie/llm
+ */
+const LLM_CHUNK_TYPES = {
+    Done: "done",
+    Error: "error",
+    Text: "text",
+    ToolCall: "tool_call",
+    ToolResult: "tool_result",
+};
+/**
+ * Convert an LLM stream chunk to HTTP stream event
+ * Returns undefined for chunks that should be filtered out
+ */
+function llmChunkToHttpEvent(chunk, options) {
+    const { includeTools = false } = options ?? {};
+    switch (chunk.type) {
+        case LLM_CHUNK_TYPES.Text:
+            if (chunk.content !== undefined) {
+                return createTextEvent(chunk.content);
+            }
+            return undefined;
+        case LLM_CHUNK_TYPES.ToolCall:
+            if (!includeTools)
+                return undefined;
+            if (chunk.toolCall) {
+                return createToolCallEvent(chunk.toolCall);
+            }
+            return undefined;
+        case LLM_CHUNK_TYPES.ToolResult:
+            if (!includeTools)
+                return undefined;
+            if (chunk.toolResult) {
+                return createToolResultEvent(chunk.toolResult);
+            }
+            return undefined;
+        case LLM_CHUNK_TYPES.Error:
+            if (chunk.error) {
+                return createErrorEvent(chunk.error);
+            }
+            return undefined;
+        case LLM_CHUNK_TYPES.Done:
+            return createCompleteEvent();
+        default:
+            // Unknown chunk type - skip
+            return undefined;
+    }
+}
+/**
+ * Pipe an LLM stream (from @jaypie/llm Llm.stream()) to HTTP stream events
+ *
+ * @example
+ * ```typescript
+ * import Llm from "@jaypie/llm";
+ * import { pipeLlmStream } from "@jaypie/fabric/http";
+ *
+ * const llmStream = Llm.stream("Tell me a story");
+ * for await (const event of pipeLlmStream(llmStream)) {
+ *   yield event; // or writer(event)
+ * }
+ * ```
+ */
+async function* pipeLlmStream(llmStream, options) {
+    for await (const chunk of llmStream) {
+        const event = llmChunkToHttpEvent(chunk, options);
+        if (event !== undefined) {
+            yield event;
+        }
+    }
+}
+/**
+ * Pipe an LLM stream to a stream writer function
+ *
+ * @example
+ * ```typescript
+ * import Llm from "@jaypie/llm";
+ * import { pipeLlmStreamToWriter } from "@jaypie/fabric/http";
+ *
+ * const llmStream = Llm.stream("Tell me a story");
+ * await pipeLlmStreamToWriter(llmStream, (event) => {
+ *   res.write(formatSseEvent(event));
+ * });
+ * ```
+ */
+async function pipeLlmStreamToWriter(llmStream, writer, options) {
+    for await (const event of pipeLlmStream(llmStream, options)) {
+        await writer(event);
+    }
+}
+// #endregion
+
+export { DEFAULT_CORS_CONFIG, DEFAULT_CORS_METHODS, DEFAULT_HTTP_METHODS, DEFAULT_STREAM_CONFIG, FabricHttpServer, HttpStreamEventType, buildCorsHeaders, buildPreflightHeaders, collectStreamEvents, createCompleteEvent, createDataEvent, createErrorEvent, createHttpContext, createMessageEvent, createNoopEvent, createStreamContext, createTextEvent, createToolCallEvent, createToolResultEvent, defaultHttpTransform, extractToken, fabricHttp, formatNdjsonEvent, formatSseEvent, formatStreamEvent, getAllowedOrigin, getAuthHeader, getStreamContentType, isAsyncIterable, isAuthorizationRequired, isFabricHttpServer, isFabricHttpService, isPreflightRequest, isStreamingEnabled, llmChunkToHttpEvent, normalizeCorsConfig, normalizeStreamConfig, parseBody, parsePathParams, parseQueryString, pipeLlmStream, pipeLlmStreamToWriter, transformHttpToInput, validateAuthorization, wrapServiceForStreaming };
+//# sourceMappingURL=index.js.map