@naylence/advanced-security 0.4.4 → 0.4.6

package/dist/browser/index.cjs

@@ -2,8 +2,9 @@
 
 var factory = require('@naylence/factory');
 var runtime = require('@naylence/runtime');
-var sha256 = require('@noble/hashes/sha256');
+var sha2 = require('@noble/hashes/sha2');
 var core = require('@naylence/core');
+var yaml = require('yaml');
 var asn1Schema = require('@peculiar/asn1-schema');
 var asn1Csr = require('@peculiar/asn1-csr');
 var asn1X509 = require('@peculiar/asn1-x509');
@@ -25,6 +26,7 @@ var x509 = require('@peculiar/x509');
  */
 const MODULES = [
     "./security/auth/policy/advanced-authorization-policy-factory.js",
+    "./security/auth/policy/http-authorization-policy-source-factory.js",
     "./security/cert/default-ca-service-factory.js",
     "./security/cert/default-certificate-manager-factory.js",
     "./security/cert/trust-store/browser-trust-store-provider-factory.js",
@@ -42,6 +44,7 @@ const MODULES = [
 ];
 const MODULE_LOADERS = {
     "./security/auth/policy/advanced-authorization-policy-factory.js": () => Promise.resolve().then(function () { return advancedAuthorizationPolicyFactory; }),
+    "./security/auth/policy/http-authorization-policy-source-factory.js": () => Promise.resolve().then(function () { return httpAuthorizationPolicySourceFactory; }),
     "./security/cert/default-ca-service-factory.js": () => Promise.resolve().then(function () { return defaultCaServiceFactory; }),
     "./security/cert/default-certificate-manager-factory.js": () => Promise.resolve().then(function () { return defaultCertificateManagerFactory; }),
     "./security/cert/trust-store/browser-trust-store-provider-factory.js": () => Promise.resolve().then(function () { return browserTrustStoreProviderFactory; }),
@@ -58,7 +61,7 @@ const MODULE_LOADERS = {
     "./welcome/advanced-welcome-service-factory.js": () => Promise.resolve().then(function () { return advancedWelcomeServiceFactory; }),
 };
 
-const logger$h = runtime.getLogger("naylence.fame.security.encryption.encryption_manager_registry");
+const logger$i = runtime.getLogger("naylence.fame.security.encryption.encryption_manager_registry");
 class EncryptionManagerFactoryRegistry {
     constructor(autoDiscover = true) {
         this.factories = [];
@@ -80,7 +83,7 @@ class EncryptionManagerFactoryRegistry {
             let registeredCount = 0;
             for (const [factoryName, info] of extensionInfos) {
                 if (factoryName === "CompositeEncryptionManager") {
-                    logger$h.debug("skipping_composite_factory_to_avoid_circular_dependency", {
+                    logger$i.debug("skipping_composite_factory_to_avoid_circular_dependency", {
                         factory_name: factoryName,
                     });
                     continue;
@@ -90,7 +93,7 @@ class EncryptionManagerFactoryRegistry {
                         factory.ExtensionManager.getGlobalFactory(runtime.ENCRYPTION_MANAGER_FACTORY_BASE_TYPE, factoryName));
                     this.registerFactory(factoryInstance, { autoDiscovered: true });
                     registeredCount += 1;
-                    logger$h.debug("auto_discovered_factory", {
+                    logger$i.debug("auto_discovered_factory", {
                         factory_name: factoryName,
                         factory_class: factoryInstance.constructor.name,
                         algorithms: factoryInstance.getSupportedAlgorithms(),
@@ -99,21 +102,21 @@ class EncryptionManagerFactoryRegistry {
                     });
                 }
                 catch (error) {
-                    logger$h.warning("failed_to_auto_register_factory", {
+                    logger$i.warning("failed_to_auto_register_factory", {
                         factory_name: factoryName,
                         error: error instanceof Error ? error.message : String(error),
                     });
                 }
             }
             this.autoDiscovered = true;
-            logger$h.debug("completed_auto_discovery", {
+            logger$i.debug("completed_auto_discovery", {
                 registered_factories: registeredCount,
                 total_discovered: extensionInfos.size,
                 skipped_composite: true,
             });
         }
         catch (error) {
-            logger$h.warning("failed_auto_discovery_of_factories", {
+            logger$i.warning("failed_auto_discovery_of_factories", {
                 error: error instanceof Error ? error.message : String(error),
             });
         }
@@ -131,7 +134,7 @@ class EncryptionManagerFactoryRegistry {
             const existing = this.algorithmToFactory.get(algorithm);
             if (!existing || factory.getPriority() > existing.getPriority()) {
                 this.algorithmToFactory.set(algorithm, factory);
-                logger$h.debug("registered_algorithm_mapping", {
+                logger$i.debug("registered_algorithm_mapping", {
                     algorithm,
                     factory: factory.constructor.name,
                     priority: factory.getPriority(),
@@ -143,7 +146,7 @@ class EncryptionManagerFactoryRegistry {
         typeFactories.push(factory);
         typeFactories.sort((a, b) => b.getPriority() - a.getPriority());
         this.typeToFactories.set(encryptionType, typeFactories);
-        logger$h.debug("registered_encryption_manager_factory", {
+        logger$i.debug("registered_encryption_manager_factory", {
             factory: factory.constructor.name,
             encryption_type: encryptionType,
             algorithms: factory.getSupportedAlgorithms(),
@@ -159,14 +162,14 @@ class EncryptionManagerFactoryRegistry {
         this.ensureAutoDiscovery();
         for (const factory of this.factories) {
             if (factory.supportsOptions(opts ?? undefined)) {
-                logger$h.debug("found_factory_for_options", {
+                logger$i.debug("found_factory_for_options", {
                     factory: factory.constructor.name,
                     encryption_type: factory.getEncryptionType(),
                 });
                 return factory;
             }
         }
-        logger$h.debug("no_factory_found_for_options", { opts });
+        logger$i.debug("no_factory_found_for_options", { opts });
         return undefined;
     }
     getFactoriesByType(encryptionType) {
@@ -292,6 +295,7 @@ const SECURITY_PREFIX = "./security/";
 const SECURITY_MODULES = MODULES.filter((spec) => spec.startsWith(SECURITY_PREFIX));
 const EXTRA_MODULES = MODULES.filter((spec) => !spec.startsWith(SECURITY_PREFIX));
 const NODE_ONLY_MODULES = new Set([
+    "./security/auth/policy/http-authorization-policy-source-factory.js",
     "./security/cert/default-ca-service-factory.js",
     "./security/cert/trust-store/node-trust-store-provider-factory.js",
 ]);
@@ -572,12 +576,12 @@ async function registerAdvancedSecurityFactories(registrar = factory.Registry, o
 }
 
 // This file is auto-generated during build - do not edit manually
-// Generated from package.json version: 0.4.4
+// Generated from package.json version: 0.4.6
 /**
  * The package version, injected at build time.
  * @internal
  */
-const VERSION = '0.4.4';
+const VERSION = '0.4.6';
 
 async function registerAdvancedSecurityPluginFactories(registrar = factory.Registry) {
     await registerAdvancedSecurityFactories(registrar);
@@ -1921,7 +1925,7 @@ const secure_hash = (args) => {
     }
     // Use generateFingerprintSync from @naylence/core
     // This provides SHA-256 hashing, base62 encoding, and profanity filtering
-    return core.generateFingerprintSync(input_str, length, sha256.sha256);
+    return core.generateFingerprintSync(input_str, length, sha2.sha256);
 };
 // ============================================================
 // Pattern Helpers (BSL-only)
@@ -2461,8 +2465,86 @@ function evaluateAsBoolean(ast, context) {
  * Null handling semantics:
  * - Scope predicate builtins (has_scope, has_any_scope, has_all_scopes)
  *   return `false` when passed `null` for required args.
+ * - Security predicate builtins (is_signed, is_encrypted, is_encrypted_at_least)
+ *   return `false` when the envelope lacks the required security posture.
  * - Wrong non-null types still raise BuiltinError to surface real bugs.
  */
+/**
+ * Valid encryption levels for is_encrypted_at_least comparisons.
+ */
+const VALID_ENCRYPTION_LEVELS = [
+    "plaintext",
+    "channel",
+    "sealed",
+];
+/**
+ * Encryption level ordering for comparison.
+ * Higher number = stronger encryption.
+ */
+const ENCRYPTION_LEVEL_ORDER = {
+    plaintext: 0,
+    channel: 1,
+    sealed: 2,
+};
+/**
+ * Normalizes an encryption algorithm string to an EncryptionLevel.
+ *
+ * Mapping rules:
+ * - null/undefined => "plaintext" (no encryption present)
+ * - alg contains "-channel" => "channel" (e.g., "chacha20-poly1305-channel")
+ * - alg contains "-sealed" => "sealed" (explicit sealed marker)
+ * - alg matches ECDH-ES pattern with AEAD cipher => "sealed" (e.g., "ECDH-ES+A256GCM")
+ * - otherwise => "unknown"
+ *
+ * Currently supported algorithms:
+ * - Channel: "chacha20-poly1305-channel"
+ * - Sealed: "ECDH-ES+A256GCM"
+ *
+ * This helper is centralized to ensure consistent mapping across TS and Python.
+ */
+function normalizeEncryptionLevelFromAlg(alg) {
+    if (alg === null || alg === undefined) {
+        return "plaintext";
+    }
+    const algLower = alg.toLowerCase();
+    // Check for channel encryption (e.g., "chacha20-poly1305-channel")
+    // Must check before other patterns since channel suffix is explicit
+    if (algLower.includes("-channel")) {
+        return "channel";
+    }
+    // Check for explicit sealed marker
+    if (algLower.includes("-sealed")) {
+        return "sealed";
+    }
+    // ECDH-ES key agreement with AEAD cipher => sealed encryption
+    // Pattern: "ECDH-ES+A256GCM", "ECDH-ES+A128GCM", etc.
+    if (algLower.startsWith("ecdh-es") && algLower.includes("+a")) {
+        return "sealed";
+    }
+    return "unknown";
+}
+/**
+ * Creates security bindings from an envelope's sec header.
+ * Exposes only metadata, never raw values like sig.val or enc.val.
+ */
+function createSecurityBindings(sec) {
+    const sigPresent = sec?.sig !== undefined;
+    const encPresent = sec?.enc !== undefined;
+    return {
+        sig: {
+            present: sigPresent,
+            kid: sec?.sig?.kid ?? null,
+        },
+        enc: {
+            present: encPresent,
+            alg: sec?.enc?.alg ?? null,
+            kid: sec?.enc?.kid ?? null,
+            level: encPresent
+                ? normalizeEncryptionLevelFromAlg(sec?.enc?.alg ?? null)
+                : "plaintext",
+        },
+    };
+}
 /**
  * Checks if a value is null.
  */
@@ -2471,9 +2553,21 @@ function isNull(value) {
 }
 /**
  * Creates a function registry with auth helpers installed.
+ *
+ * This registry extends the base builtins with:
+ * - Scope builtins: has_scope, has_any_scope, has_all_scopes
+ * - Security builtins: is_signed, encryption_level, is_encrypted, is_encrypted_at_least
  */
-function createAuthFunctionRegistry(grantedScopes = []) {
-    const scopes = grantedScopes ?? [];
+function createAuthFunctionRegistry(grantedScopesOrOptions = []) {
+    // Handle both old signature (array) and new signature (options object)
+    const options = Array.isArray(grantedScopesOrOptions)
+        ? { grantedScopes: grantedScopesOrOptions }
+        : grantedScopesOrOptions;
+    const scopes = options.grantedScopes ?? [];
+    const secBindings = options.securityBindings ?? {
+        sig: { present: false},
+        enc: { level: "plaintext" },
+    };
     /**
      * Checks if any granted scope matches a pattern (using glob syntax).
      */
@@ -2529,11 +2623,85 @@ function createAuthFunctionRegistry(grantedScopes = []) {
         }
         return values.every((scope) => matchesScope(scope));
     };
+    // ============================================================
+    // Security posture builtins
+    // ============================================================
+    /**
+     * is_signed() -> bool
+     *
+     * Returns true if the envelope has a signature present.
+     * No arguments required.
+     */
+    const is_signed = (args) => {
+        assertArgCount(args, 0, "is_signed");
+        return secBindings.sig.present;
+    };
+    /**
+     * encryption_level() -> string
+     *
+     * Returns the normalized encryption level: "plaintext" | "channel" | "sealed" | "unknown"
+     * No arguments required.
+     */
+    const encryption_level = (args) => {
+        assertArgCount(args, 0, "encryption_level");
+        return secBindings.enc.level;
+    };
+    /**
+     * is_encrypted() -> bool
+     *
+     * Returns true if the encryption level is not "plaintext".
+     * This means the envelope has some form of encryption (channel, sealed, or unknown).
+     * No arguments required.
+     */
+    const is_encrypted = (args) => {
+        assertArgCount(args, 0, "is_encrypted");
+        return secBindings.enc.level !== "plaintext";
+    };
+    /**
+     * is_encrypted_at_least(level: string) -> bool
+     *
+     * Returns true if the envelope's encryption level meets or exceeds the required level.
+     *
+     * Level ordering: plaintext < channel < sealed
+     *
+     * Special handling:
+     * - "unknown" encryption level does NOT satisfy "channel" or "sealed" (conservative)
+     * - "plaintext" is always satisfied (any envelope meets at least plaintext)
+     * - null argument => false (predicate-style)
+     * - invalid level string => BuiltinError
+     */
+    const is_encrypted_at_least = (args) => {
+        assertArgCount(args, 1, "is_encrypted_at_least");
+        const requiredLevel = getArg(args, 0, "is_encrypted_at_least");
+        // Null-tolerant: return false if level is null
+        if (!assertStringOrNull(requiredLevel, "level", "is_encrypted_at_least")) {
+            return false;
+        }
+        // Validate required level
+        if (!VALID_ENCRYPTION_LEVELS.includes(requiredLevel)) {
+            throw new BuiltinError("is_encrypted_at_least", `level must be one of: ${VALID_ENCRYPTION_LEVELS.join(", ")}; got "${requiredLevel}"`);
+        }
+        const currentLevel = secBindings.enc.level;
+        const requiredOrder = ENCRYPTION_LEVEL_ORDER[requiredLevel] ?? 0;
+        const currentOrder = ENCRYPTION_LEVEL_ORDER[currentLevel];
+        // If current level is "unknown", it only satisfies "plaintext"
+        if (currentOrder === undefined) {
+            // "unknown" is treated as NOT meeting channel/sealed requirements
+            return requiredOrder === 0; // Only plaintext is satisfied by unknown
+        }
+        return currentOrder >= requiredOrder;
+    };
     return new Map([
         ...BUILTIN_FUNCTIONS,
+        // Scope builtins
         ["has_scope", has_scope],
         ["has_any_scope", has_any_scope],
         ["has_all_scopes", has_all_scopes],
+        // Security posture builtins
+        ["is_signed", is_signed],
+        ["encryption_level", encryption_level],
+        ["is_encrypted", is_encrypted],
+        ["is_encrypted_at_least", is_encrypted_at_least],
     ]);
 }
 /**
@@ -2676,19 +2844,33 @@ function extractClaims(context) {
 }
 /**
  * Creates a safe envelope subset for expression bindings.
+ *
+ * Exposes:
+ * - id, sid, traceId, corrId, flowId, to
+ * - frame: { type }
+ * - sec: { sig: { present, kid }, enc: { present, alg, kid, level } }
+ *
+ * IMPORTANT: Does NOT expose raw security values (sig.val, enc.val).
  */
 function createEnvelopeBindings(envelope) {
     const frame = envelope.frame;
     const envelopeRecord = envelope;
+    const sec = envelopeRecord.sec;
+    const securityBindings = createSecurityBindings(sec);
     return {
-        id: envelope.id ?? null,
-        traceId: envelopeRecord.traceId ?? null,
-        corrId: envelopeRecord.corrId ?? null,
-        flowId: envelopeRecord.flowId ?? null,
-        to: extractAddress(envelope) ?? null,
-        frame: frame
-            ? { type: frame.type ?? null }
-            : { type: null },
+        bindings: {
+            id: envelope.id ?? null,
+            sid: envelopeRecord.sid ?? null,
+            traceId: envelopeRecord.traceId ?? null,
+            corrId: envelopeRecord.corrId ?? null,
+            flowId: envelopeRecord.flowId ?? null,
+            to: extractAddress(envelope) ?? null,
+            frame: frame
+                ? { type: frame.type ?? null }
+                : { type: null },
+            sec: securityBindings,
+        },
+        securityBindings,
     };
 }
 /**
@@ -2842,11 +3024,12 @@ class AdvancedAuthorizationPolicy {
                 continue;
             }
             if (rule.whenAst) {
-                // Lazy initialization of expression bindings
+                // Lazy initialization of expression bindings and security context
                 if (!expressionBindings) {
+                    const envelopeResult = createEnvelopeBindings(envelope);
                     expressionBindings = {
                         claims: extractClaims(context),
-                        envelope: createEnvelopeBindings(envelope),
+                        envelope: envelopeResult.bindings,
                         delivery: createDeliveryBindings(context, resolvedAction),
                         node: createNodeBindings(node),
                         time: {
@@ -2854,9 +3037,13 @@ class AdvancedAuthorizationPolicy {
                             now_iso: new Date().toISOString(),
                         },
                     };
+                    // Create function registry with security bindings for security builtins
+                    functionRegistry = createAuthFunctionRegistry({
+                        grantedScopes,
+                        securityBindings: envelopeResult.securityBindings,
+                    });
                 }
-                const functions = functionRegistry ?? createAuthFunctionRegistry(grantedScopes);
-                functionRegistry = functions;
+                const functions = functionRegistry;
                 const evalContext = {
                     bindings: expressionBindings,
                     limits: this.expressionLimits,
@@ -3205,7 +3392,7 @@ function getModule() {
     }
     return modulePromise;
 }
-function normalizeConfig$5(config) {
+function normalizeConfig$6(config) {
     if (!config) {
         throw new Error("AdvancedAuthorizationPolicyFactory requires a configuration with a policyDefinition");
     }
@@ -3234,7 +3421,7 @@ function normalizeConfig$5(config) {
 /**
  * Factory metadata for registration.
  */
-const FACTORY_META$e = {
+const FACTORY_META$f = {
     base: runtime.AUTHORIZATION_POLICY_FACTORY_BASE_TYPE,
     key: "AdvancedAuthorizationPolicy",
 };
@@ -3253,7 +3440,7 @@ class AdvancedAuthorizationPolicyFactory extends runtime.AuthorizationPolicyFact
      * @returns The created authorization policy
      */
     async create(config) {
-        const normalized = normalizeConfig$5(config);
+        const normalized = normalizeConfig$6(config);
         const { AdvancedAuthorizationPolicy } = await getModule();
         return new AdvancedAuthorizationPolicy({
             policyDefinition: normalized.policyDefinition,
@@ -3266,10 +3453,493 @@ class AdvancedAuthorizationPolicyFactory extends runtime.AuthorizationPolicyFact
 var advancedAuthorizationPolicyFactory = /*#__PURE__*/Object.freeze({
     __proto__: null,
     AdvancedAuthorizationPolicyFactory: AdvancedAuthorizationPolicyFactory,
-    FACTORY_META: FACTORY_META$e,
+    FACTORY_META: FACTORY_META$f,
     default: AdvancedAuthorizationPolicyFactory
 });
 
+/**
+ * HTTP-based authorization policy source.
+ *
+ * Loads authorization policies from an HTTP endpoint supporting JSON or YAML.
+ * Supports bearer authentication via TokenProvider and HTTP caching via ETag.
+ *
+ * This is a Node.js-only implementation.
+ *
+ * @packageDocumentation
+ */
+const logger$h = runtime.getLogger("naylence.fame.security.auth.policy.http_authorization_policy_source");
+function isPlainObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function parseJson(content) {
+    const parsed = JSON.parse(content);
+    if (!isPlainObject(parsed)) {
+        throw new Error("Parsed JSON policy must be an object");
+    }
+    return parsed;
+}
+function parseYamlContent(content) {
+    const parsed = yaml.parse(content ?? "");
+    if (parsed == null) {
+        return {};
+    }
+    if (!isPlainObject(parsed)) {
+        throw new Error("Parsed YAML policy must be an object");
+    }
+    return parsed;
+}
+/**
+ * Detect whether content is JSON or YAML based on Content-Type header.
+ * Falls back to sniffing the content if Content-Type is not definitive.
+ */
+function detectFormat(contentType, content) {
+    if (contentType) {
+        const lower = contentType.toLowerCase();
+        if (lower.includes("application/json") ||
+            lower.includes("text/json")) {
+            return "json";
+        }
+        if (lower.includes("application/yaml") ||
+            lower.includes("application/x-yaml") ||
+            lower.includes("text/yaml") ||
+            lower.includes("text/x-yaml")) {
+            return "yaml";
+        }
+    }
+    // Sniff by first non-whitespace character
+    const trimmed = content.trimStart();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+        return "json";
+    }
+    // Default to YAML
+    return "yaml";
+}
+/**
+ * Parse Cache-Control header to extract max-age value.
+ */
+function parseMaxAge(cacheControl) {
+    if (!cacheControl) {
+        return undefined;
+    }
+    const match = cacheControl.match(/max-age\s*=\s*(\d+)/i);
+    if (match && match[1]) {
+        const seconds = parseInt(match[1], 10);
+        if (Number.isFinite(seconds) && seconds >= 0) {
+            return seconds;
+        }
+    }
+    return undefined;
+}
+/**
+ * An authorization policy source that loads policy definitions from an HTTP endpoint.
+ *
+ * Supports JSON and YAML formats, bearer authentication via TokenProvider,
+ * and HTTP caching via ETag and Cache-Control headers.
+ *
+ * This is a Node.js-only implementation that uses fetch.
+ */
+class HttpAuthorizationPolicySource {
+    constructor(options) {
+        this.cachedState = null;
+        this.inflightFetch = null;
+        if (!options.url || typeof options.url !== "string") {
+            throw new Error("HttpAuthorizationPolicySource requires a valid URL");
+        }
+        this.url = options.url;
+        this.method = options.method ?? "GET";
+        this.timeoutMs = options.timeoutMs ?? 30000;
+        this.headers = { ...options.headers };
+        this.tokenProvider = options.tokenProvider;
+        this.bearerPrefix = options.bearerPrefix ?? "Bearer ";
+        this.policyFactoryConfig = options.policyFactory;
+        this.cacheTtlMs = options.cacheTtlMs ?? 300000; // 5 minutes default
+    }
+    /**
+     * Loads the authorization policy from the configured HTTP endpoint.
+     *
+     * Returns a cached policy if still fresh (based on TTL or cache headers).
+     * Multiple concurrent calls are de-duplicated (single-flight pattern).
+     *
+     * @returns The loaded authorization policy
+     */
+    async loadPolicy() {
+        // Return cached policy if still fresh
+        if (this.cachedState && this.isCacheFresh()) {
+            logger$h.debug("returning_cached_policy", {
+                url: this.url,
+                fetchedAt: this.cachedState.metadata.fetchedAt,
+                expiresAt: this.cachedState.metadata.expiresAt,
+            });
+            return this.cachedState.policy;
+        }
+        // De-duplicate concurrent requests
+        if (this.inflightFetch) {
+            return this.inflightFetch;
+        }
+        this.inflightFetch = this.fetchPolicy(false);
+        try {
+            return await this.inflightFetch;
+        }
+        finally {
+            this.inflightFetch = null;
+        }
+    }
+    /**
+     * Forces a reload of the policy from the HTTP endpoint.
+     *
+     * Bypasses cache freshness checks and always fetches from the server.
+     * If the fetch fails, the existing cached policy is preserved and the error is thrown.
+     *
+     * @returns The reloaded authorization policy
+     */
+    async reloadPolicy() {
+        // Clear inflight to force a new request
+        this.inflightFetch = null;
+        return this.fetchPolicy(true);
+    }
+    /**
+     * Clears the cached policy, forcing a fresh fetch on the next loadPolicy() call.
+     */
+    clearCache() {
+        this.cachedState = null;
+        this.inflightFetch = null;
+    }
+    /**
+     * Returns metadata about the last successful fetch.
+     *
+     * Useful for verification, monitoring, or debugging.
+     */
+    getMetadata() {
+        return this.cachedState?.metadata;
+    }
+    /**
+     * Returns the raw policy definition from the last successful fetch.
+     *
+     * Useful for verification or reprocessing.
+     */
+    getRawDefinition() {
+        return this.cachedState?.rawDefinition;
+    }
+    isCacheFresh() {
+        if (!this.cachedState) {
+            return false;
+        }
+        const now = Date.now();
+        const { expiresAt } = this.cachedState.metadata;
+        if (expiresAt !== undefined) {
+            return now < expiresAt;
+        }
+        // No expiration info, check against default TTL
+        const fetchedAt = this.cachedState.metadata.fetchedAt;
+        return now < fetchedAt + this.cacheTtlMs;
+    }
+    async fetchPolicy(forceRefresh) {
+        logger$h.debug("fetching_policy", {
+            url: this.url,
+            method: this.method,
+            forceRefresh,
+        });
+        const requestHeaders = {
+            Accept: "application/json, application/yaml, text/yaml, */*",
+            ...this.headers,
+        };
+        // Add bearer token if token provider is configured
+        if (this.tokenProvider) {
+            try {
+                const token = await this.tokenProvider.getToken();
+                if (token && token.value) {
+                    requestHeaders["Authorization"] = `${this.bearerPrefix}${token.value}`;
+                    logger$h.debug("added_bearer_token", { url: this.url });
+                }
+            }
+            catch (error) {
+                logger$h.warning("token_provider_failed", {
+                    url: this.url,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                // Continue without token - let the server decide if auth is required
+            }
+        }
+        // Add If-None-Match header for conditional request if we have a cached ETag
+        // and this is not a forced refresh
+        if (!forceRefresh && this.cachedState?.metadata.etag) {
+            requestHeaders["If-None-Match"] = this.cachedState.metadata.etag;
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const response = await fetch(this.url, {
+                method: this.method,
+                headers: requestHeaders,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Handle 304 Not Modified - return cached policy
+            if (response.status === 304 && this.cachedState) {
+                logger$h.debug("policy_not_modified", {
+                    url: this.url,
+                    etag: this.cachedState.metadata.etag,
+                });
+                // Update freshness timestamps
+                const now = Date.now();
+                const cacheControl = response.headers.get("Cache-Control");
+                const maxAgeSeconds = parseMaxAge(cacheControl);
+                const expiresAt = maxAgeSeconds !== undefined
+                    ? now + maxAgeSeconds * 1000
+                    : now + this.cacheTtlMs;
+                this.cachedState = {
+                    ...this.cachedState,
+                    metadata: {
+                        ...this.cachedState.metadata,
+                        fetchedAt: now,
+                        maxAgeSeconds,
+                        expiresAt,
+                    },
+                };
+                return this.cachedState.policy;
+            }
+            if (!response.ok) {
+                const errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                logger$h.error("policy_fetch_failed", {
+                    url: this.url,
+                    status: response.status,
+                    statusText: response.statusText,
+                });
+                // If we have a cached policy, preserve it and throw
+                if (this.cachedState) {
+                    throw new Error(`Failed to fetch policy from ${this.url}: ${errorMessage}. ` +
+                        "Using last known good policy.");
+                }
+                throw new Error(`Failed to fetch policy from ${this.url}: ${errorMessage}`);
+            }
+            // Parse the response
+            const contentType = response.headers.get("Content-Type");
+            const content = await response.text();
+            const format = detectFormat(contentType, content);
+            let policyDefinition;
+            try {
+                if (format === "json") {
+                    policyDefinition = parseJson(content);
+                }
+                else {
+                    policyDefinition = parseYamlContent(content);
+                }
+            }
+            catch (parseError) {
+                const message = parseError instanceof Error
+                    ? parseError.message
+                    : String(parseError);
+                logger$h.error("policy_parse_failed", {
+                    url: this.url,
+                    format,
+                    error: message,
+                });
+                // Preserve cached policy on parse failure
+                if (this.cachedState) {
+                    throw new Error(`Failed to parse policy from ${this.url}: ${message}. ` +
+                        "Using last known good policy.");
+                }
+                throw new Error(`Failed to parse policy from ${this.url}: ${message}`);
+            }
+            logger$h.debug("parsed_policy_definition", {
+                url: this.url,
+                format,
+                hasType: "type" in policyDefinition,
+            });
+            // Build the policy using the factory
+            const policy = await this.buildPolicy(policyDefinition);
+            // Update cache
+            const now = Date.now();
+            const etag = response.headers.get("ETag") ?? undefined;
+            const cacheControl = response.headers.get("Cache-Control");
+            const maxAgeSeconds = parseMaxAge(cacheControl);
+            const expiresAt = maxAgeSeconds !== undefined
+                ? now + maxAgeSeconds * 1000
+                : now + this.cacheTtlMs;
+            this.cachedState = {
+                policy,
+                rawDefinition: policyDefinition,
+                metadata: {
+                    url: this.url,
+                    status: response.status,
+                    etag,
+                    fetchedAt: now,
+                    maxAgeSeconds,
+                    expiresAt,
+                },
+            };
+            logger$h.info("loaded_policy_from_http", {
+                url: this.url,
+                status: response.status,
+                format,
+                etag,
+                maxAgeSeconds,
+            });
+            return policy;
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.name === "AbortError") {
+                const timeoutError = new Error(`Request to ${this.url} timed out after ${this.timeoutMs}ms`);
+                logger$h.error("policy_fetch_timeout", {
+                    url: this.url,
+                    timeoutMs: this.timeoutMs,
+                });
+                // Preserve cached policy on timeout
+                if (this.cachedState) {
+                    throw timeoutError;
+                }
+                throw timeoutError;
+            }
+            throw error;
+        }
+    }
+    async buildPolicy(policyDefinition) {
+        // Determine the factory configuration to use
+        const factoryConfig = this.policyFactoryConfig ?? policyDefinition;
+        // Ensure we have a type field for the factory
+        if (!("type" in factoryConfig) || typeof factoryConfig.type !== "string") {
+            logger$h.warning("policy_type_missing_defaulting_to_basic", {
+                url: this.url,
+            });
+            factoryConfig.type = "BasicAuthorizationPolicy";
+        }
+        // Build the factory config with the policy definition
+        // The response content IS the policy definition, so we extract the type
+        // and wrap the remaining content as the policyDefinition
+        const { type: definitionType, ...restOfDefinition } = policyDefinition;
+        const resolvedType = typeof definitionType === "string" && definitionType.trim().length > 0
+            ? definitionType
+            : factoryConfig.type;
+        const mergedConfig = this.policyFactoryConfig != null
+            ? { ...this.policyFactoryConfig, policyDefinition }
+            : { type: resolvedType, policyDefinition: restOfDefinition };
+        const policy = await runtime.AuthorizationPolicyFactory.createAuthorizationPolicy(mergedConfig);
+        if (!policy) {
+            throw new Error(`Failed to create authorization policy from ${this.url}`);
+        }
+        return policy;
+    }
+}
+
+var httpAuthorizationPolicySource = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    HttpAuthorizationPolicySource: HttpAuthorizationPolicySource
+});
+
+/**
+ * Factory for creating HttpAuthorizationPolicySource instances.
+ *
+ * @packageDocumentation
+ */
+let httpModulePromise = null;
+async function getHttpModule() {
+    if (!httpModulePromise) {
+        httpModulePromise = Promise.resolve().then(function () { return httpAuthorizationPolicySource; });
+    }
+    return httpModulePromise;
+}
+function normalizeConfig$5(config) {
+    if (!config) {
+        throw new Error("HttpAuthorizationPolicySourceFactory requires a configuration with a url");
+    }
+    const candidate = config;
+    const url = candidate.url;
+    if (typeof url !== "string" || url.trim().length === 0) {
+        throw new Error("HttpAuthorizationPolicySourceConfig requires a non-empty url");
+    }
+    // Support both camelCase and snake_case
+    const method = candidate.method ?? "GET";
+    if (!["GET", "POST", "PUT"].includes(method)) {
+        throw new Error(`Invalid method "${String(method)}". Must be "GET", "POST", or "PUT"`);
+    }
+    const timeoutMs = candidate.timeout_ms ??
+        candidate.timeoutMs ??
+        30000;
+    if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("timeout_ms must be a positive number");
+    }
+    const headers = candidate.headers;
+    if (headers !== undefined && typeof headers !== "object") {
+        throw new Error("headers must be an object");
+    }
+    const tokenProviderConfig = candidate.token_provider ??
+        candidate.tokenProvider;
+    const bearerPrefix = candidate.bearer_prefix ??
+        candidate.bearerPrefix ??
+        "Bearer ";
+    const policyFactory = candidate.policy_factory ??
+        candidate.policyFactory;
+    const cacheTtlMs = candidate.cache_ttl_ms ??
+        candidate.cacheTtlMs ??
+        300000;
+    if (typeof cacheTtlMs !== "number" || !Number.isFinite(cacheTtlMs) || cacheTtlMs < 0) {
+        throw new Error("cache_ttl_ms must be a non-negative number");
+    }
+    return {
+        url: url.trim(),
+        method,
+        timeoutMs,
+        headers,
+        tokenProviderConfig,
+        bearerPrefix,
+        policyFactory,
+        cacheTtlMs,
+    };
+}
+/**
+ * Factory metadata for registration.
+ */
+const FACTORY_META$e = {
+    base: runtime.AUTHORIZATION_POLICY_SOURCE_FACTORY_BASE_TYPE,
+    key: "HttpAuthorizationPolicySource",
+};
+/**
+ * Factory for creating HttpAuthorizationPolicySource instances.
+ *
+ * This factory uses lazy loading to avoid pulling in Node.js-specific
+ * code (fetch operations) in browser environments where it may not work.
+ */
+class HttpAuthorizationPolicySourceFactory extends runtime.AuthorizationPolicySourceFactory {
+    constructor() {
+        super(...arguments);
+        this.type = "HttpAuthorizationPolicySource";
+    }
+    /**
+     * Creates an HttpAuthorizationPolicySource from the given configuration.
+     *
+     * @param config - Configuration specifying the policy URL and options
+     * @returns The created policy source
+     */
+    async create(config) {
+        const normalized = normalizeConfig$5(config);
+        // Create token provider if configured
+        let tokenProvider;
+        if (normalized.tokenProviderConfig) {
+            tokenProvider = await runtime.TokenProviderFactory.createTokenProvider(normalized.tokenProviderConfig);
+        }
+        const { HttpAuthorizationPolicySource } = await getHttpModule();
+        const options = {
+            url: normalized.url,
+            method: normalized.method,
+            timeoutMs: normalized.timeoutMs,
+            headers: normalized.headers,
+            tokenProvider,
+            bearerPrefix: normalized.bearerPrefix,
+            policyFactory: normalized.policyFactory,
+            cacheTtlMs: normalized.cacheTtlMs,
+        };
+        return new HttpAuthorizationPolicySource(options);
+    }
+}
+
+var httpAuthorizationPolicySourceFactory = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    FACTORY_META: FACTORY_META$e,
+    HttpAuthorizationPolicySourceFactory: HttpAuthorizationPolicySourceFactory,
+    default: HttpAuthorizationPolicySourceFactory
+});
+
 const logger$g = runtime.getLogger("naylence.fame.security.cert.util");
 const CACHE_LIMIT = 512;
 const OID_ED25519 = "1.3.101.112";