@fireweaveai/server-sdk-cjs 0.0.0-reserve.0 → 0.0.0-stage

package/dist/infrastructure/adapters/local.d.ts

@@ -1,108 +0,0 @@
-/**
- * Local development adapter — the DEV substrate for a scaffolded harness.
- *
- * It is the counterpart to {@link FireweaveRemoteAdapter}: prod evaluates
- * control points against fw-server, dev evaluates them here, in-process, with
- * no network and no credentials. Because it satisfies the same
- * {@link BackendAdapter} port, the dev branch of a harness runs through the
- * same {@link FireweaveRuntime} as prod — inheriting identical lifecycle
- * gating and context canonicalization. That symmetry is the point: dev/prod
- * skew in the harness is exactly what the harness exists to prevent.
- *
- * Resolution policy is deliberately minimal:
- *
- * - a key present in `devFlags` resolves to its mapped value with reason
- *   `STATIC` — the only supported way to turn a control point ON (or force it
- *   OFF) on a laptop;
- * - every other key MISSES (`{ found: false, reason: 'DEFAULT' }`), which the
- *   runtime turns into the caller's own default with reason `DEFAULT` — not
- *   an error (spec/modes.md "Behaviour per mode": local's unknown-key row is
- *   deliberately `default`/`DEFAULT`, unlike remote's `default`/`ERROR`/
- *   `ControlPointNotFound`).
- *
- * Call-site defaults stay `false` under RAMP-1. Never write
- * `fw.flag(key, true)` to dogfood locally — that same `true` is the production
- * fallback when the control point is absent from the provider, so it silently
- * ships the ON branch. Use `devFlags` instead.
- *
- * Runtime portability: pure computation, no I/O, no env, no Node globals — so
- * it runs unchanged on Node, Bun, and Deno (ADR-0008), and is covered by
- * `test/unit/runtime-portability.test.ts`.
- */
-import type { AdapterResolution, AdapterRuntimeFeatures, BackendAdapter, RegisterTargetOptions, RegisterTargetResult, ResolveOptions } from '../../application/ports.js';
-import type { TargetKind } from '../../domain/target.js';
-import type { CanonicalContext } from '../../domain/types.js';
-export interface FireweaveLocalAdapterOptions {
-    /**
-     * Per-key boolean overrides. A present key resolves to its mapped value with
-     * reason `STATIC`; an absent key misses so the caller's default is used.
-     */
-    readonly devFlags?: Record<string, boolean>;
-    /**
-     * Sink for the local `registerTarget` trace. Defaults to `console.info`.
-     * Injectable so tests assert the call without capturing stdout, and so a
-     * host that owns its logging can route it.
-     */
-    readonly log?: (message: string) => void;
-}
-/** A target recorded by {@link FireweaveLocalAdapter.registerTarget}. */
-export interface LocalRegisteredTarget {
-    readonly targetingKey: string;
-    readonly kind: TargetKind;
-    readonly properties: Record<string, unknown>;
-    readonly environment?: string;
-}
-export declare class FireweaveLocalAdapter implements BackendAdapter {
-    /**
-     * Not `inmemory` — that name belongs to {@link InMemoryAdapter}, the fixture
-     * adapter conformance runs against. This is a distinct dev substrate, and
-     * `capabilities.get()` should report it as such rather than impersonate one.
-     */
-    readonly name: "other";
-    private readonly devFlags;
-    private readonly log;
-    private readonly targets;
-    private closed;
-    constructor(options?: FireweaveLocalAdapterOptions);
-    initialize(_signal?: AbortSignal): Promise<void>;
-    /**
-     * A `devFlags` hit reports `enabled: true` alongside `reason: 'STATIC'`.
-     * Reporting `enabled: false` for an override of `false` would make the
-     * runtime label the decision `DISABLED` (runtime.ts, reason resolution),
-     * which means "the control point exists but is switched off upstream" — not
-     * what a local override expresses.
-     *
-     * `flagType: 'boolean'` is declared honestly. Reading an overridden key as a
-     * string or number therefore yields TYPE_MISMATCH rather than silently
-     * handing back the default: `devFlags` is `Record<string, boolean>`, so such
-     * a read is a genuine call-site mistake and is better surfaced than hidden.
-     *
-     * A miss carries `reason: 'DEFAULT'` on the `{ found: false }` resolution —
-     * the signal `FireweaveRuntime.evaluate` (runtime.ts) reads to return the
-     * caller's default with reason `DEFAULT` instead of falling through to its
-     * generic ControlPointNotFound/ERROR mapping (spec/modes.md).
-     */
-    resolve(controlPointKey: string, _context: CanonicalContext, _options?: ResolveOptions): Promise<AdapterResolution>;
-    /**
-     * Records the target in-process and traces it, rather than reporting
-     * `UnsupportedCapability`.
-     *
-     * The capability previously reported Unsupported so that a dev harness could
-     * not *silently* look registered — the failure being guarded against is a
-     * developer believing their targeting works because nothing objected. A
-     * recorded target plus an explicit `[fireweave:local]` line preserves that
-     * guarantee by a different route: nothing is silent, and local dev can now
-     * exercise targeting rules offline instead of only in production.
-     *
-     * The trace names the mode, so a line appearing in a production log is
-     * itself the signal that something booted in local mode by mistake.
-     *
-     * No network call is made and nothing reaches fw-server.
-     */
-    registerTarget(targetingKey: string, options?: RegisterTargetOptions): Promise<RegisterTargetResult>;
-    /** Targets recorded this process, for assertions and dev inspection. */
-    getRegisteredTargets(): readonly LocalRegisteredTarget[];
-    shutdown(): Promise<void>;
-    isClosed(): boolean;
-    features(): AdapterRuntimeFeatures;
-}

package/dist/infrastructure/adapters/local.js

@@ -1,105 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FireweaveLocalAdapter = void 0;
-class FireweaveLocalAdapter {
-    /**
-     * Not `inmemory` — that name belongs to {@link InMemoryAdapter}, the fixture
-     * adapter conformance runs against. This is a distinct dev substrate, and
-     * `capabilities.get()` should report it as such rather than impersonate one.
-     */
-    name = 'other';
-    devFlags;
-    log;
-    targets = new Map();
-    closed = false;
-    constructor(options = {}) {
-        this.devFlags = { ...(options.devFlags ?? {}) };
-        this.log = options.log ?? ((m) => console.info(m));
-    }
-    async initialize(_signal) {
-        // Nothing to connect to. Kept async to satisfy the port.
-    }
-    /**
-     * A `devFlags` hit reports `enabled: true` alongside `reason: 'STATIC'`.
-     * Reporting `enabled: false` for an override of `false` would make the
-     * runtime label the decision `DISABLED` (runtime.ts, reason resolution),
-     * which means "the control point exists but is switched off upstream" — not
-     * what a local override expresses.
-     *
-     * `flagType: 'boolean'` is declared honestly. Reading an overridden key as a
-     * string or number therefore yields TYPE_MISMATCH rather than silently
-     * handing back the default: `devFlags` is `Record<string, boolean>`, so such
-     * a read is a genuine call-site mistake and is better surfaced than hidden.
-     *
-     * A miss carries `reason: 'DEFAULT'` on the `{ found: false }` resolution —
-     * the signal `FireweaveRuntime.evaluate` (runtime.ts) reads to return the
-     * caller's default with reason `DEFAULT` instead of falling through to its
-     * generic ControlPointNotFound/ERROR mapping (spec/modes.md).
-     */
-    async resolve(controlPointKey, _context, _options) {
-        const override = this.devFlags[controlPointKey];
-        if (override === undefined)
-            return { found: false, reason: 'DEFAULT' };
-        return {
-            found: true,
-            enabled: true,
-            value: override,
-            variant: override ? 'on' : 'off',
-            reason: 'STATIC',
-            flagType: 'boolean',
-        };
-    }
-    /**
-     * Records the target in-process and traces it, rather than reporting
-     * `UnsupportedCapability`.
-     *
-     * The capability previously reported Unsupported so that a dev harness could
-     * not *silently* look registered — the failure being guarded against is a
-     * developer believing their targeting works because nothing objected. A
-     * recorded target plus an explicit `[fireweave:local]` line preserves that
-     * guarantee by a different route: nothing is silent, and local dev can now
-     * exercise targeting rules offline instead of only in production.
-     *
-     * The trace names the mode, so a line appearing in a production log is
-     * itself the signal that something booted in local mode by mistake.
-     *
-     * No network call is made and nothing reaches fw-server.
-     */
-    async registerTarget(targetingKey, options = {}) {
-        const kind = options.kind ?? 'user';
-        const properties = { ...(options.properties ?? {}) };
-        const target = {
-            targetingKey,
-            kind,
-            properties,
-            ...(options.environment === undefined ? {} : { environment: options.environment }),
-        };
-        this.targets.set(targetingKey, target);
-        this.log(`[fireweave:local] registerTarget ${kind} ${targetingKey} ` +
-            `${JSON.stringify(properties)} — recorded in-process, NOT sent to fw-server`);
-        return { ok: true };
-    }
-    /** Targets recorded this process, for assertions and dev inspection. */
-    getRegisteredTargets() {
-        return [...this.targets.values()];
-    }
-    async shutdown() {
-        this.closed = true;
-    }
-    isClosed() {
-        return this.closed;
-    }
-    features() {
-        return {
-            remoteEvaluation: false,
-            localEvaluation: true,
-            localOnly: true,
-            // No exposure sink exists locally; claiming otherwise would make
-            // capabilities.get() advertise emission that silently goes nowhere.
-            exposureEmission: false,
-            sideEffectFreeReads: true,
-            groupAnalytics: false,
-        };
-    }
-}
-exports.FireweaveLocalAdapter = FireweaveLocalAdapter;

package/dist/infrastructure/adapters/remote.d.ts

@@ -1,74 +0,0 @@
-import type { AdapterResolution, AdapterRuntimeFeatures, BackendAdapter, RegisterTargetOptions, RegisterTargetResult, ResolveOptions } from '../../application/ports.js';
-import type { CanonicalContext, Exposure, Signal } from '../../domain/types.js';
-type FetchLike = (url: string, init?: {
-    method?: string;
-    headers?: Record<string, string>;
-    body?: string;
-    signal?: AbortSignal;
-}) => Promise<{
-    status: number;
-    text(): Promise<string>;
-    json(): Promise<unknown>;
-}>;
-export interface FireweaveRemoteAdapterOptions {
-    /**
-     * fw-server base URL (e.g. https://fw.example.com or http://127.0.0.1:3901).
-     * Required — never read from the environment (spec/modes.md "The SDK reads
-     * no environment variables. Credentials arrive as explicit options.").
-     */
-    apiUrl?: string;
-    /**
-     * Fireweave project/runtime key (project-api-key_…).
-     * Required — never read from the environment (spec/modes.md "The SDK reads
-     * no environment variables. Credentials arrive as explicit options.").
-     */
-    apiKey?: string;
-    /**
-     * SSRF allowlist override. Default: hostname of `apiUrl` + loopback.
-     * Pass `['*']` to opt out of host pinning.
-     */
-    allowedHosts?: readonly string[];
-    /** Per-request timeout for evaluate/capture (default 3000 ms). */
-    requestTimeoutMs?: number;
-    /** Deadline for flush during shutdown (default 10 000 ms). */
-    shutdownTimeoutMs?: number;
-    /** Injected fetch (tests). */
-    fetch?: FetchLike;
-}
-export declare class FireweaveRemoteAdapter implements BackendAdapter {
-    readonly name: "fireweave";
-    private readonly options;
-    private apiUrl;
-    private apiKey;
-    private closed;
-    private ready;
-    private readonly pending;
-    private readonly fetchImpl;
-    constructor(options?: FireweaveRemoteAdapterOptions);
-    initialize(_signal?: AbortSignal): Promise<void>;
-    resolve(controlPointKey: string, context: CanonicalContext, options?: ResolveOptions): Promise<AdapterResolution>;
-    /**
-     * Register a user or device so flag rules can target its DURABLE properties.
-     *
-     * Call once per login / device provisioning, then send the same
-     * `targetingKey` on evaluate. Per-request `attributes` still override the
-     * stored properties for a single evaluation — the two identity paths compose
-     * (see spec/remote-protocol.md § Two identity paths).
-     *
-     * Never throws for transport failures: registration sits in login paths, and
-     * an analytics call must not break sign-in. Retried ONCE when the error
-     * taxonomy marks the failure retryable (network / timeout / backend); a
-     * rejected payload or bad key is not retried, since it would be rejected
-     * identically. The result object reports what happened for callers that
-     * want to log it.
-     */
-    registerTarget(targetingKey: string, options?: RegisterTargetOptions): Promise<RegisterTargetResult>;
-    recordExposure(exposure: Exposure): void;
-    recordSignal(signal: Signal): void;
-    flush(): Promise<void>;
-    shutdown(): Promise<void>;
-    features(): AdapterRuntimeFeatures;
-    private toResolution;
-    private requestJson;
-}
-export {};

package/dist/infrastructure/adapters/remote.js

@@ -1,373 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FireweaveRemoteAdapter = void 0;
-/**
- * Fireweave remote backend adapter (ADR-0005) — **default production path**.
- *
- * Speaks only the vendor-neutral Fireweave remote protocol to fw-server:
- *   POST /v1/control-points/evaluate
- *   POST /v1/capture
- *   POST /v1/targets/register
- *
- * Auth: Authorization: Bearer <project key> (project-api-key_…).
- * Which backend fw-server forwards to is fw-server's concern: no vendor SDK,
- * key, or host ever enters the application process.
- *
- * See spec/remote-protocol.md.
- */
-const errors_js_1 = require("../../domain/errors.js");
-const hosts_js_1 = require("../hosts.js");
-const validation_js_1 = require("../../domain/validation.js");
-const DEFAULT_ADAPTER_SHUTDOWN_TIMEOUT_MS = 10000;
-const DEFAULT_REQUEST_TIMEOUT_MS = 3000;
-const EVALUATE_PATH = '/v1/control-points/evaluate';
-const CAPTURE_PATH = '/v1/capture';
-const REGISTER_TARGET_PATH = '/v1/targets/register';
-function mapHttpStatus(status) {
-    if (status === 401)
-        return new errors_js_1.FireweaveError('Authentication');
-    if (status === 403)
-        return new errors_js_1.FireweaveError('Authorization');
-    if (status === 429)
-        return new errors_js_1.FireweaveError('RateLimited');
-    if (status >= 500)
-        return new errors_js_1.FireweaveError('BackendUnavailable');
-    return new errors_js_1.FireweaveError('BackendUnavailable');
-}
-/**
- * `apiUrl`/`apiKey` come from `options` only — never the environment
- * (spec/modes.md "The SDK reads no environment variables. Credentials
- * arrive as explicit options.", unscoped).
- */
-function resolveCredentials(options) {
-    const apiUrl = (options.apiUrl ?? '').replace(/\/+$/, '');
-    const apiKey = options.apiKey ?? '';
-    return { apiUrl, apiKey };
-}
-function defaultAllowedHostsFor(apiUrl) {
-    try {
-        const hostname = new URL(apiUrl).hostname;
-        const hosts = [hostname, 'localhost', '127.0.0.1', '::1'];
-        if (hostname === '[::1]')
-            hosts.push('::1');
-        return hosts;
-    }
-    catch {
-        return ['localhost', '127.0.0.1', '::1'];
-    }
-}
-function reasonToAdapter(reason) {
-    const allowed = new Set([
-        'STATIC',
-        'DEFAULT',
-        'TARGETING_MATCH',
-        'SPLIT',
-        'CACHED',
-        'STALE',
-        'DISABLED',
-        'UNKNOWN',
-        'ERROR',
-    ]);
-    return allowed.has(reason) ? reason : undefined;
-}
-class FireweaveRemoteAdapter {
-    name = 'fireweave';
-    options;
-    apiUrl = '';
-    apiKey = '';
-    closed = false;
-    ready = false;
-    pending = [];
-    fetchImpl;
-    constructor(options = {}) {
-        this.options = { ...options };
-        this.fetchImpl = options.fetch ?? globalThis.fetch;
-    }
-    async initialize(_signal) {
-        if (this.closed)
-            throw new errors_js_1.FireweaveError('AlreadyClosed');
-        const { apiUrl, apiKey } = resolveCredentials(this.options);
-        if (!apiUrl || !apiKey) {
-            throw new errors_js_1.FireweaveError('Configuration');
-        }
-        let url;
-        try {
-            url = new URL(apiUrl);
-        }
-        catch {
-            throw new errors_js_1.FireweaveError('Configuration');
-        }
-        if (url.protocol !== 'http:' && url.protocol !== 'https:') {
-            throw new errors_js_1.FireweaveError('Configuration');
-        }
-        if (url.protocol === 'http:' && !(0, hosts_js_1.isLoopbackHostname)(url.hostname)) {
-            throw new errors_js_1.FireweaveError('Configuration');
-        }
-        const allow = this.options.allowedHosts !== undefined && this.options.allowedHosts.length > 0
-            ? this.options.allowedHosts
-            : defaultAllowedHostsFor(apiUrl);
-        (0, hosts_js_1.assertHostAllowed)(apiUrl, allow);
-        this.apiUrl = apiUrl.replace(/\/+$/, '');
-        this.apiKey = apiKey;
-        this.ready = true;
-    }
-    async resolve(controlPointKey, context, options) {
-        if (this.closed)
-            throw new errors_js_1.FireweaveError('AlreadyClosed');
-        if (!this.ready)
-            throw new errors_js_1.FireweaveError('NotReady');
-        const targetingKeyResult = (0, validation_js_1.validateTargetingKey)(context.targetingKey, true);
-        if (!targetingKeyResult.ok)
-            throw targetingKeyResult.error;
-        const targetingKey = targetingKeyResult.value ?? '';
-        const attributes = {};
-        for (const [k, v] of Object.entries(context.attributes)) {
-            if (k === 'groups' || k === 'groupProperties' || k.startsWith('$') || k.startsWith('fireweave.')) {
-                continue;
-            }
-            attributes[k] = v;
-        }
-        const body = {
-            targetingKey,
-            controlPointKeys: [controlPointKey],
-        };
-        if (Object.keys(attributes).length > 0)
-            body['attributes'] = attributes;
-        if (context.groups !== undefined)
-            body['groups'] = context.groups;
-        if (context.groupProperties !== undefined)
-            body['groupProperties'] = context.groupProperties;
-        const response = await this.requestJson(EVALUATE_PATH, body, options?.signal);
-        const item = response.decisions?.find((d) => d.controlPointKey === controlPointKey);
-        if (item === undefined) {
-            const missing = { found: false };
-            if (response.quotaLimited === true)
-                missing.quotaLimited = true;
-            return missing;
-        }
-        return this.toResolution(item, response.quotaLimited === true);
-    }
-    /**
-     * Register a user or device so flag rules can target its DURABLE properties.
-     *
-     * Call once per login / device provisioning, then send the same
-     * `targetingKey` on evaluate. Per-request `attributes` still override the
-     * stored properties for a single evaluation — the two identity paths compose
-     * (see spec/remote-protocol.md § Two identity paths).
-     *
-     * Never throws for transport failures: registration sits in login paths, and
-     * an analytics call must not break sign-in. Retried ONCE when the error
-     * taxonomy marks the failure retryable (network / timeout / backend); a
-     * rejected payload or bad key is not retried, since it would be rejected
-     * identically. The result object reports what happened for callers that
-     * want to log it.
-     */
-    async registerTarget(targetingKey, options = {}) {
-        if (this.closed)
-            return { ok: false, error: new errors_js_1.FireweaveError('AlreadyClosed') };
-        if (!this.ready)
-            return { ok: false, error: new errors_js_1.FireweaveError('NotReady') };
-        const targetingKeyResult = (0, validation_js_1.validateTargetingKey)(targetingKey, true);
-        if (!targetingKeyResult.ok)
-            return { ok: false, error: targetingKeyResult.error };
-        const body = { targetingKey };
-        if (options.kind !== undefined)
-            body['kind'] = options.kind;
-        if (options.environment !== undefined)
-            body['environment'] = options.environment;
-        if (options.properties !== undefined && Object.keys(options.properties).length > 0) {
-            body['properties'] = options.properties;
-        }
-        let lastError;
-        for (let attempt = 0; attempt < 2; attempt += 1) {
-            try {
-                await this.requestJson(REGISTER_TARGET_PATH, body, options.signal);
-                return { ok: true };
-            }
-            catch (err) {
-                lastError =
-                    err instanceof errors_js_1.FireweaveError ? err : new errors_js_1.FireweaveError('BackendUnavailable');
-                if (!lastError.retryable)
-                    break;
-            }
-        }
-        return { ok: false, ...(lastError !== undefined ? { error: lastError } : {}) };
-    }
-    recordExposure(exposure) {
-        if (this.closed || !this.ready)
-            return;
-        const event = {
-            type: 'exposure',
-            targetingKey: exposure.targetingKey,
-            controlPointKey: exposure.controlPointKey,
-            value: exposure.value,
-        };
-        if (exposure.variant !== undefined)
-            event.variant = exposure.variant;
-        if (exposure.rolloutId !== undefined)
-            event.rolloutId = exposure.rolloutId;
-        if (exposure.changeId !== undefined)
-            event.changeId = exposure.changeId;
-        if (exposure.stampId !== undefined)
-            event.stampId = exposure.stampId;
-        this.pending.push(event);
-    }
-    recordSignal(signal) {
-        if (this.closed || !this.ready)
-            return;
-        const event = {
-            type: 'signal',
-            targetingKey: signal.targetingKey ?? signal.rolloutId ?? 'fireweave-sdk',
-            name: signal.name,
-            properties: {
-                kind: signal.kind,
-                ...(signal.status !== undefined ? { status: signal.status } : {}),
-                ...(signal.errorKind !== undefined ? { errorKind: signal.errorKind } : {}),
-                ...(signal.message !== undefined ? { message: signal.message } : {}),
-                ...(signal.value !== undefined ? { value: signal.value } : {}),
-            },
-        };
-        if (signal.controlPointKey !== undefined)
-            event.controlPointKey = signal.controlPointKey;
-        if (signal.variant !== undefined)
-            event.variant = signal.variant;
-        if (signal.rolloutId !== undefined)
-            event.rolloutId = signal.rolloutId;
-        if (signal.changeId !== undefined)
-            event.changeId = signal.changeId;
-        if (signal.stampId !== undefined)
-            event.stampId = signal.stampId;
-        if (signal.timestamp !== undefined)
-            event.timestamp = signal.timestamp;
-        this.pending.push(event);
-    }
-    async flush() {
-        if (this.closed || !this.ready || this.pending.length === 0)
-            return;
-        const batch = this.pending.splice(0, this.pending.length);
-        try {
-            await this.requestJson(CAPTURE_PATH, { events: batch });
-        }
-        catch {
-            // flush failures must not throw into shutdown paths; re-queue best-effort
-            this.pending.unshift(...batch);
-        }
-    }
-    async shutdown() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        // The race timer is cleared once the flush wins; left armed, it held the
-        // process open for up to shutdownTimeoutMs after a clean shutdown.
-        let timer;
-        try {
-            const timeout = this.options.shutdownTimeoutMs ?? DEFAULT_ADAPTER_SHUTDOWN_TIMEOUT_MS;
-            await Promise.race([
-                this.flush(),
-                new Promise((resolve) => {
-                    timer = setTimeout(resolve, timeout);
-                }),
-            ]);
-        }
-        catch {
-            // never throw from shutdown
-        }
-        finally {
-            if (timer !== undefined)
-                clearTimeout(timer);
-        }
-        this.ready = false;
-    }
-    features() {
-        return {
-            remoteEvaluation: true,
-            localEvaluation: false,
-            localOnly: false,
-            exposureEmission: true,
-            sideEffectFreeReads: true,
-            groupAnalytics: true,
-        };
-    }
-    toResolution(item, quotaLimited) {
-        if (item.found === false) {
-            const missing = { found: false };
-            if (quotaLimited)
-                missing.quotaLimited = true;
-            return missing;
-        }
-        const resolution = {
-            found: true,
-            value: item.value,
-            enabled: item.enabled ?? true,
-        };
-        if (item.variant != null)
-            resolution.variant = item.variant;
-        const reason = reasonToAdapter(item.reason);
-        if (reason !== undefined)
-            resolution.reason = reason;
-        if (item.payload !== undefined)
-            resolution.payload = item.payload;
-        const meta = item.controlPointMetadata ?? {};
-        if (typeof meta['fireweave.controlPointVersion'] === 'number') {
-            resolution.version = meta['fireweave.controlPointVersion'];
-        }
-        if (typeof meta['fireweave.vendorControlPointId'] === 'number') {
-            resolution.vendorControlPointId = meta['fireweave.vendorControlPointId'];
-        }
-        if (typeof meta['fireweave.reasonCode'] === 'string') {
-            resolution.reasonCode = meta['fireweave.reasonCode'];
-        }
-        if (quotaLimited || meta['fireweave.quotaLimited'] === true) {
-            resolution.quotaLimited = true;
-        }
-        return resolution;
-    }
-    async requestJson(path, body, outerSignal) {
-        const timeoutMs = this.options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), timeoutMs);
-        const onOuterAbort = () => controller.abort();
-        if (outerSignal !== undefined) {
-            if (outerSignal.aborted)
-                controller.abort();
-            else
-                outerSignal.addEventListener('abort', onOuterAbort, { once: true });
-        }
-        try {
-            let response;
-            try {
-                response = await this.fetchImpl(`${this.apiUrl}${path}`, {
-                    method: 'POST',
-                    headers: {
-                        'content-type': 'application/json',
-                        authorization: `Bearer ${this.apiKey}`,
-                    },
-                    body: JSON.stringify(body),
-                    signal: controller.signal,
-                });
-            }
-            catch (err) {
-                const aborted = err instanceof Error && err.name === 'AbortError';
-                throw aborted ? new errors_js_1.FireweaveError('Timeout') : new errors_js_1.FireweaveError('Network');
-            }
-            if (response.status >= 400) {
-                throw mapHttpStatus(response.status);
-            }
-            let parsed;
-            try {
-                parsed = await response.json();
-            }
-            catch {
-                throw new errors_js_1.FireweaveError('MalformedResponse');
-            }
-            return parsed;
-        }
-        finally {
-            clearTimeout(timer);
-            if (outerSignal !== undefined) {
-                outerSignal.removeEventListener('abort', onOuterAbort);
-            }
-        }
-    }
-}
-exports.FireweaveRemoteAdapter = FireweaveRemoteAdapter;

package/dist/infrastructure/hosts.d.ts

@@ -1,18 +0,0 @@
-/**
- * Canonical default host allowlist.
- *
- * v3 replaced the third-party analytics hostnames this list used to carry
- * (ADR-0006) with Fireweave's own fw-server hostnames. The security property is
- * unchanged — an unconfigured allowlist still denies everything it does not name
- * — but the *contents* changed: code doing
- * `allowedHosts: [...DEFAULT_ALLOWED_HOSTS, …]` no longer reaches the former
- * vendor endpoints, which is the intent.
- */
-export declare const DEFAULT_ALLOWED_HOSTS: readonly string[];
-/** True for loopback hostnames (http and test stubs are permitted here). */
-export declare function isLoopbackHostname(hostname: string): boolean;
-/**
- * Validate a backend host URL against the allowlist.
- * Throws FireweaveError('Configuration') — fixed message, no host echo.
- */
-export declare function assertHostAllowed(host: string, allowedHosts?: readonly string[]): void;