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

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initFireweave = exports.FireweaveClient = exports.DEFAULT_SHUTDOWN_TIMEOUT_MS = exports.stableStringify = exports.FireweaveRuntime = exports.isLoopbackHostname = exports.assertHostAllowed = exports.DEFAULT_ALLOWED_HOSTS = exports.FireweaveLocalAdapter = exports.FireweaveRemoteAdapter = exports.InMemoryAdapter = exports.validateInitOptions = exports.validateTargetingKey = exports.validateContext = exports.validateDefaultValue = exports.validateControlPointKey = exports.canonicalizeContext = exports.resolvedContextView = exports.normalizeContextInput = exports.mergeContexts = exports.ALLOWED_FIREWEAVE_CONTEXT_KEYS = exports.DEFAULT_RESERVED_ATTRIBUTE_KEYS = exports.DEFAULT_CONTEXT_LIMITS = exports.isFireweaveError = exports.redactSecrets = exports.ERROR_TAXONOMY = exports.FireweaveError = void 0;
+/**
+ * @fireweaveai/server-sdk — Fireweave release-engineering SDK for server runtimes
+ * (Node, Bun, Deno).
+ *
+ * Exactly two v1 capabilities (spec/control-points.md): control points and
+ * target registration.
+ *
+ * Production default: {@link FireweaveRemoteAdapter} (Fireweave project key →
+ * fw-server). {@link InMemoryAdapter} for offline work and tests. The backend
+ * fw-server forwards to is fw-server's concern — no vendor SDK, key, or host
+ * appears in the application process (ADR-0005, ADR-0006).
+ */
+var errors_js_1 = require("./domain/errors.js");
+Object.defineProperty(exports, "FireweaveError", { enumerable: true, get: function () { return errors_js_1.FireweaveError; } });
+Object.defineProperty(exports, "ERROR_TAXONOMY", { enumerable: true, get: function () { return errors_js_1.ERROR_TAXONOMY; } });
+Object.defineProperty(exports, "redactSecrets", { enumerable: true, get: function () { return errors_js_1.redactSecrets; } });
+Object.defineProperty(exports, "isFireweaveError", { enumerable: true, get: function () { return errors_js_1.isFireweaveError; } });
+var context_js_1 = require("./domain/context.js");
+Object.defineProperty(exports, "DEFAULT_CONTEXT_LIMITS", { enumerable: true, get: function () { return context_js_1.DEFAULT_CONTEXT_LIMITS; } });
+Object.defineProperty(exports, "DEFAULT_RESERVED_ATTRIBUTE_KEYS", { enumerable: true, get: function () { return context_js_1.DEFAULT_RESERVED_ATTRIBUTE_KEYS; } });
+Object.defineProperty(exports, "ALLOWED_FIREWEAVE_CONTEXT_KEYS", { enumerable: true, get: function () { return context_js_1.ALLOWED_FIREWEAVE_CONTEXT_KEYS; } });
+Object.defineProperty(exports, "mergeContexts", { enumerable: true, get: function () { return context_js_1.mergeContexts; } });
+Object.defineProperty(exports, "normalizeContextInput", { enumerable: true, get: function () { return context_js_1.normalizeContextInput; } });
+Object.defineProperty(exports, "resolvedContextView", { enumerable: true, get: function () { return context_js_1.resolvedContextView; } });
+var validation_js_1 = require("./domain/validation.js");
+Object.defineProperty(exports, "canonicalizeContext", { enumerable: true, get: function () { return validation_js_1.canonicalizeContext; } });
+Object.defineProperty(exports, "validateControlPointKey", { enumerable: true, get: function () { return validation_js_1.validateControlPointKey; } });
+Object.defineProperty(exports, "validateDefaultValue", { enumerable: true, get: function () { return validation_js_1.validateDefaultValue; } });
+Object.defineProperty(exports, "validateContext", { enumerable: true, get: function () { return validation_js_1.validateContext; } });
+Object.defineProperty(exports, "validateTargetingKey", { enumerable: true, get: function () { return validation_js_1.validateTargetingKey; } });
+Object.defineProperty(exports, "validateInitOptions", { enumerable: true, get: function () { return validation_js_1.validateInitOptions; } });
+var inmemory_js_1 = require("./infrastructure/adapters/inmemory.js");
+Object.defineProperty(exports, "InMemoryAdapter", { enumerable: true, get: function () { return inmemory_js_1.InMemoryAdapter; } });
+var remote_js_1 = require("./infrastructure/adapters/remote.js");
+Object.defineProperty(exports, "FireweaveRemoteAdapter", { enumerable: true, get: function () { return remote_js_1.FireweaveRemoteAdapter; } });
+var local_js_1 = require("./infrastructure/adapters/local.js");
+Object.defineProperty(exports, "FireweaveLocalAdapter", { enumerable: true, get: function () { return local_js_1.FireweaveLocalAdapter; } });
+var hosts_js_1 = require("./infrastructure/hosts.js");
+Object.defineProperty(exports, "DEFAULT_ALLOWED_HOSTS", { enumerable: true, get: function () { return hosts_js_1.DEFAULT_ALLOWED_HOSTS; } });
+Object.defineProperty(exports, "assertHostAllowed", { enumerable: true, get: function () { return hosts_js_1.assertHostAllowed; } });
+Object.defineProperty(exports, "isLoopbackHostname", { enumerable: true, get: function () { return hosts_js_1.isLoopbackHostname; } });
+var runtime_js_1 = require("./application/runtime.js");
+Object.defineProperty(exports, "FireweaveRuntime", { enumerable: true, get: function () { return runtime_js_1.FireweaveRuntime; } });
+Object.defineProperty(exports, "stableStringify", { enumerable: true, get: function () { return runtime_js_1.stableStringify; } });
+Object.defineProperty(exports, "DEFAULT_SHUTDOWN_TIMEOUT_MS", { enumerable: true, get: function () { return runtime_js_1.DEFAULT_SHUTDOWN_TIMEOUT_MS; } });
+var client_js_1 = require("./application/client.js");
+Object.defineProperty(exports, "FireweaveClient", { enumerable: true, get: function () { return client_js_1.FireweaveClient; } });
+var mode_js_1 = require("./application/mode.js");
+Object.defineProperty(exports, "initFireweave", { enumerable: true, get: function () { return mode_js_1.initFireweave; } });

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

@@ -0,0 +1,77 @@
+/**
+ * Deterministic in-memory adapter for tests and conformance fixtures.
+ * Resolution model mirrors contracts/ fixture flag definitions: flags, variants,
+ * payloads, targeting by targeting key / person attributes / groups.
+ * Deliberately NO bucketing / percentage logic.
+ */
+import { type FireweaveErrorKind } from '../../domain/errors.js';
+import type { AdapterResolution, AdapterRuntimeFeatures, BackendAdapter, ResolveOptions } from '../../application/ports.js';
+import type { CanonicalContext, DecisionReason, Exposure, JsonValue, Signal } from '../../domain/types.js';
+export interface InMemoryFlagDefinition {
+    type: 'boolean' | 'string' | 'integer' | 'float' | 'object';
+    enabled: boolean;
+    value: JsonValue;
+    variant?: string;
+    variants?: string[];
+    payload?: JsonValue;
+    reason?: {
+        code?: string;
+        condition_index?: number;
+        description?: string;
+    };
+    metadata?: {
+        version?: number;
+        id?: number;
+    };
+    /** Canonical reason override (fixtures: "SPLIT"). */
+    fireweaveReason?: DecisionReason;
+    /** Served from last-good cache (stale scenarios). */
+    fromCache?: boolean;
+    /** Match only when all listed attributes deep-equal context attributes. */
+    matchAttribute?: Record<string, JsonValue>;
+    /** Match only when context groups contain these entries. */
+    matchGroups?: Record<string, string>;
+    /** Match only when person attributes contain these entries. */
+    matchPerson?: Record<string, JsonValue>;
+    /** Match only this exact targetingKey. */
+    matchTargetingKey?: string;
+}
+export interface InMemoryFault {
+    kind: FireweaveErrorKind;
+    metadata?: Record<string, string | number | boolean>;
+}
+export interface InMemoryAdapterOptions {
+    flags?: Record<string, InMemoryFlagDefinition>;
+    /** Fault to throw on every resolve (fault-mode conformance without HTTP). */
+    fault?: InMemoryFault;
+    /** Reject initialize() with this error kind. */
+    initError?: FireweaveErrorKind;
+    /** Delay initialize() until release() is called (cold-start tests). */
+    initGate?: {
+        promise: Promise<void>;
+    };
+}
+export declare class InMemoryAdapter implements BackendAdapter {
+    readonly name: "inmemory";
+    private flags;
+    private fault;
+    private readonly initError;
+    private readonly initGate;
+    private readonly exposures;
+    private readonly signals;
+    private closed;
+    constructor(options?: InMemoryAdapterOptions);
+    setFlags(flags: Record<string, InMemoryFlagDefinition>): void;
+    setFault(fault: InMemoryFault | undefined): void;
+    initialize(signal?: AbortSignal): Promise<void>;
+    resolve(controlPointKey: string, context: CanonicalContext, _options?: ResolveOptions): Promise<AdapterResolution>;
+    private matches;
+    recordExposure(exposure: Exposure): void;
+    getExposures(): readonly Exposure[];
+    recordSignal(signal: Signal): void;
+    getSignals(): readonly Signal[];
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    isClosed(): boolean;
+    features(): AdapterRuntimeFeatures;
+}

package/dist/infrastructure/adapters/inmemory.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryAdapter = void 0;
+/**
+ * Deterministic in-memory adapter for tests and conformance fixtures.
+ * Resolution model mirrors contracts/ fixture flag definitions: flags, variants,
+ * payloads, targeting by targeting key / person attributes / groups.
+ * Deliberately NO bucketing / percentage logic.
+ */
+const errors_js_1 = require("../../domain/errors.js");
+function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === undefined || b === undefined || a === null || b === null)
+        return false;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((v, i) => deepEqual(v, b[i]));
+    }
+    if (typeof a === 'object' && typeof b === 'object' && !Array.isArray(a) && !Array.isArray(b)) {
+        const ak = Object.keys(a);
+        const bk = Object.keys(b);
+        return ak.length === bk.length && ak.every((k) => deepEqual(a[k], b[k]));
+    }
+    return false;
+}
+class InMemoryAdapter {
+    name = 'inmemory';
+    flags;
+    fault;
+    initError;
+    initGate;
+    exposures = [];
+    signals = [];
+    closed = false;
+    constructor(options = {}) {
+        this.flags = new Map(Object.entries(options.flags ?? {}));
+        this.fault = options.fault;
+        this.initError = options.initError;
+        this.initGate = options.initGate;
+    }
+    setFlags(flags) {
+        this.flags = new Map(Object.entries(flags));
+    }
+    setFault(fault) {
+        this.fault = fault;
+    }
+    async initialize(signal) {
+        if (this.initError !== undefined) {
+            throw new errors_js_1.FireweaveError(this.initError);
+        }
+        if (this.initGate !== undefined) {
+            if (signal?.aborted)
+                throw new errors_js_1.FireweaveError('Timeout');
+            await this.initGate.promise;
+        }
+    }
+    async resolve(controlPointKey, context, _options) {
+        if (this.fault !== undefined) {
+            const opts = this.fault.metadata !== undefined ? { metadata: this.fault.metadata } : {};
+            throw new errors_js_1.FireweaveError(this.fault.kind, opts);
+        }
+        const def = this.flags.get(controlPointKey);
+        if (def === undefined) {
+            return { found: false };
+        }
+        if (!this.matches(def, context)) {
+            return { found: false };
+        }
+        const resolution = {
+            found: true,
+            enabled: def.enabled,
+            value: def.value,
+            flagType: def.type,
+        };
+        if (def.variant !== undefined)
+            resolution.variant = def.variant;
+        if (def.fireweaveReason !== undefined)
+            resolution.reason = def.fireweaveReason;
+        if (def.reason?.code !== undefined)
+            resolution.reasonCode = def.reason.code;
+        if (def.reason?.condition_index !== undefined)
+            resolution.conditionIndex = def.reason.condition_index;
+        if (def.metadata?.version !== undefined)
+            resolution.version = def.metadata.version;
+        if (def.metadata?.id !== undefined)
+            resolution.vendorControlPointId = def.metadata.id;
+        if (def.payload !== undefined)
+            resolution.payload = def.payload;
+        if (def.fromCache === true)
+            resolution.fromCache = true;
+        return resolution;
+    }
+    matches(def, context) {
+        if (def.matchTargetingKey !== undefined && context.targetingKey !== def.matchTargetingKey) {
+            return false;
+        }
+        if (def.matchAttribute !== undefined) {
+            for (const [k, v] of Object.entries(def.matchAttribute)) {
+                if (!deepEqual(context.attributes[k], v))
+                    return false;
+            }
+        }
+        if (def.matchPerson !== undefined) {
+            for (const [k, v] of Object.entries(def.matchPerson)) {
+                if (!deepEqual(context.attributes[k], v))
+                    return false;
+            }
+        }
+        if (def.matchGroups !== undefined) {
+            for (const [k, v] of Object.entries(def.matchGroups)) {
+                if (context.groups?.[k] !== v)
+                    return false;
+            }
+        }
+        return true;
+    }
+    recordExposure(exposure) {
+        this.exposures.push(exposure);
+    }
+    getExposures() {
+        return this.exposures;
+    }
+    recordSignal(signal) {
+        this.signals.push(signal);
+    }
+    getSignals() {
+        return this.signals;
+    }
+    async flush() {
+        // no-op: exposures stay queryable for tests
+    }
+    async shutdown() {
+        this.closed = true;
+    }
+    isClosed() {
+        return this.closed;
+    }
+    features() {
+        return {
+            remoteEvaluation: false,
+            localEvaluation: true,
+            localOnly: true,
+            exposureEmission: true,
+            sideEffectFreeReads: true,
+            groupAnalytics: true,
+        };
+    }
+}
+exports.InMemoryAdapter = InMemoryAdapter;

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

@@ -0,0 +1,108 @@
+/**
+ * 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

@@ -0,0 +1,105 @@
+"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

@@ -0,0 +1,74 @@
+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 {};