@shelbyb/daywalker-sdk 0.1.4 → 0.3.0

package/dist/flags/node.js

@@ -0,0 +1,263 @@
+import { createHmac } from "node:crypto";
+import { EventEmitter } from "node:events";
+import { Evaluator, MemoryStore, evaluateFlag, parseContext } from "./engine/index.js";
+import { EventProcessor, SseClient, noopLogger } from "./common/index.js";
+import { assertSecureUrl } from "../config.js";
+/**
+ * Server-side client. One instance per process and SDK key.
+ *
+ *   const client = init(process.env.DEVPULSE_SDK_KEY!, { baseUrl });
+ *   await client.waitForInitialization({ timeoutMs: 5000 });
+ *   const enabled = await client.variation("new-checkout", { key: user.id, email: user.email }, false);
+ */
+export class DevPulseNodeClient extends EventEmitter {
+    sdkKey;
+    options;
+    store = new MemoryStore();
+    stream = null;
+    poller = null;
+    etag = null;
+    events = null;
+    initialized = false;
+    ready;
+    resolveReady;
+    rejectReady;
+    streamFailures = 0;
+    logger;
+    base;
+    constructor(sdkKey, options) {
+        super();
+        this.sdkKey = sdkKey;
+        this.options = options;
+        this.logger = options.logger ?? noopLogger;
+        this.base = options.baseUrl.replace(/\/$/, "");
+        this.ready = new Promise((res, rej) => {
+            this.resolveReady = res;
+            this.rejectReady = rej;
+        });
+        this.ready.catch(() => undefined);
+        if (options.initialData || options.offline) {
+            if (options.initialData)
+                this.store.replace(options.initialData);
+            this.markReady();
+            return;
+        }
+        // Checked once the SDK key will actually be sent (offline / fixture clients make no requests).
+        assertSecureUrl("baseUrl", options.baseUrl);
+        if (options.sendEvents !== false) {
+            this.events = new EventProcessor({
+                url: `${this.base}/sdk/v1/events`,
+                headers: { authorization: sdkKey },
+                flushIntervalMs: options.flushIntervalMs ?? 5000,
+                privateAttributes: options.privateAttributes,
+                allAttributesPrivate: options.allAttributesPrivate,
+                fetch: options.fetch,
+                logger: this.logger,
+            });
+        }
+        if (options.stream === false)
+            this.startPolling();
+        else
+            this.startStreaming();
+    }
+    headers() {
+        return { authorization: this.sdkKey, "user-agent": "DevPulseNode/0.1.0" };
+    }
+    startStreaming() {
+        this.stream = new SseClient({
+            url: `${this.base}/sdk/v1/server/stream`,
+            headers: () => this.headers(),
+            fetch: this.options.fetch,
+            onOpen: () => {
+                this.streamFailures = 0;
+                this.stopPolling();
+            },
+            onEvent: (ev) => this.onStreamEvent(ev.type, ev.data),
+            onError: (err) => {
+                this.logger.warn(`DevPulse stream error: ${err.message}`);
+                if (err.status === 401 || err.status === 403) {
+                    this.fail(new Error("Invalid SDK key"));
+                    return false;
+                }
+                // After repeated failures, poll so data stays fresh while we keep retrying the stream.
+                if (++this.streamFailures >= 3)
+                    this.startPolling();
+                return true;
+            },
+        });
+        this.stream.start();
+    }
+    startPolling() {
+        if (this.poller)
+            return;
+        const interval = Math.max(30_000, this.options.pollIntervalMs ?? 30_000);
+        const poll = async () => {
+            try {
+                const res = await (this.options.fetch ?? fetch)(`${this.base}/sdk/v1/server/flags`, { headers: { ...this.headers(), ...(this.etag ? { "if-none-match": this.etag } : {}) } });
+                if (res.status === 304)
+                    return this.markReady();
+                if (res.status === 401 || res.status === 403)
+                    return this.fail(new Error("Invalid SDK key"));
+                if (!res.ok)
+                    throw new Error(`Poll failed with ${res.status}`);
+                this.etag = res.headers.get("etag");
+                this.applyPut((await res.json()));
+            }
+            catch (err) {
+                this.logger.warn("DevPulse poll failed", err);
+            }
+        };
+        this.poller = setInterval(poll, interval);
+        this.poller.unref?.();
+        void poll();
+    }
+    stopPolling() {
+        if (this.poller)
+            clearInterval(this.poller);
+        this.poller = null;
+    }
+    onStreamEvent(type, data) {
+        try {
+            const payload = JSON.parse(data);
+            if (type === "put")
+                this.applyPut(payload.data);
+            else if (type === "patch" || type === "delete") {
+                const [, kind, key] = String(payload.path).split("/");
+                const isFlag = kind === "flags";
+                const prev = isFlag ? this.store.getFlag(key) : this.store.getSegment(key);
+                if (type === "patch")
+                    this.store.upsert(isFlag ? "flag" : "segment", payload.data);
+                else if (!prev || prev.version < payload.version)
+                    (isFlag ? this.store.flags : this.store.segments).delete(key);
+                if (isFlag)
+                    this.emitUpdate(key);
+                else
+                    for (const f of this.store.flags.values())
+                        if (JSON.stringify(f.rules).includes(`"${key}"`))
+                            this.emitUpdate(f.key);
+            }
+        }
+        catch (err) {
+            this.logger.error("Malformed stream event", err);
+        }
+    }
+    applyPut(data) {
+        const before = new Map([...this.store.flags.entries()].map(([k, f]) => [k, f.version]));
+        this.store.replace(data);
+        for (const [k, f] of this.store.flags)
+            if (before.get(k) !== f.version)
+                this.emitUpdate(k);
+        for (const k of before.keys())
+            if (!this.store.flags.has(k))
+                this.emitUpdate(k);
+        this.markReady();
+    }
+    emitUpdate(key) {
+        this.emit("update", { key });
+        this.emit(`update:${key}`, { key });
+    }
+    markReady() {
+        if (this.initialized)
+            return;
+        this.initialized = true;
+        this.resolveReady();
+        this.emit("ready");
+    }
+    fail(err) {
+        if (!this.initialized)
+            this.rejectReady(err);
+        this.emit("failed", err);
+    }
+    // ---------- Public API ----------
+    waitForInitialization(opts = {}) {
+        const ready = this.ready.then(() => this);
+        if (!opts.timeoutMs)
+            return ready;
+        return Promise.race([ready, new Promise((_, rej) => setTimeout(() => rej(new Error("DevPulse initialization timed out")), opts.timeoutMs).unref?.())]);
+    }
+    get isInitialized() {
+        return this.initialized;
+    }
+    /** Evaluate a flag locally. Never throws; returns `defaultValue` on any problem. */
+    variationDetailSync(key, context, defaultValue) {
+        if (!this.initialized)
+            return { value: defaultValue, variationIndex: null, reason: { kind: "ERROR", errorKind: "CLIENT_NOT_READY" } };
+        const { prerequisites, ...detail } = evaluateFlag(this.store, key, context, defaultValue);
+        const flag = this.store.getFlag(key);
+        let out = detail;
+        if (detail.reason.kind !== "ERROR" && defaultValue !== null && typeof defaultValue !== typeof detail.value) {
+            out = { value: defaultValue, variationIndex: null, reason: { kind: "ERROR", errorKind: "WRONG_TYPE" } };
+        }
+        if (this.events) {
+            for (const p of prerequisites)
+                this.events.recordEvaluation({ key: p.flag.key, context, value: p.detail.value, default: null, variation: p.detail.variationIndex, version: p.flag.version, reason: p.detail.reason, trackEvents: p.flag.trackEvents });
+            this.events.recordEvaluation({ key, context, value: out.value, default: defaultValue, variation: out.variationIndex, version: flag?.version, reason: out.reason, trackEvents: flag?.trackEvents });
+        }
+        return out;
+    }
+    variationSync(key, context, defaultValue) {
+        return this.variationDetailSync(key, context, defaultValue).value;
+    }
+    async variation(key, context, defaultValue) {
+        return this.variationSync(key, context, defaultValue);
+    }
+    async variationDetail(key, context, defaultValue) {
+        return this.variationDetailSync(key, context, defaultValue);
+    }
+    async boolVariation(key, context, defaultValue) {
+        return this.variation(key, context, defaultValue);
+    }
+    async stringVariation(key, context, defaultValue) {
+        return this.variation(key, context, defaultValue);
+    }
+    async numberVariation(key, context, defaultValue) {
+        return this.variation(key, context, defaultValue);
+    }
+    async jsonVariation(key, context, defaultValue) {
+        return this.variation(key, context, defaultValue);
+    }
+    /**
+     * Evaluate every flag for a context, e.g. to bootstrap a browser client
+     * during server rendering. Doesn't record analytics.
+     */
+    async allFlagsState(context, opts = {}) {
+        let ctx;
+        try {
+            ctx = parseContext(context);
+        }
+        catch {
+            return { valid: false, values: {}, toJSON: () => ({}) };
+        }
+        const evaluator = new Evaluator(this.store);
+        const state = {};
+        for (const f of this.store.flags.values()) {
+            if (opts.clientSideOnly && !f.clientSide)
+                continue;
+            const { detail } = evaluator.evaluate(f, ctx);
+            state[f.key] = { value: detail.value, variation: detail.variationIndex, version: f.version, ...(opts.withReasons ? { reason: detail.reason } : {}) };
+        }
+        return { valid: this.initialized, values: Object.fromEntries(Object.entries(state).map(([k, v]) => [k, v.value])), toJSON: () => state };
+    }
+    /** Secure mode hash for a context, for the browser SDK's `hash` option. */
+    secureModeHash(context) {
+        return createHmac("sha256", this.sdkKey).update(parseContext(context).canonicalKey).digest("hex");
+    }
+    track(key, context, data, metricValue) {
+        this.events?.track(key, context, data, metricValue);
+    }
+    identify(context) {
+        this.events?.identify(context);
+    }
+    async flush() {
+        await this.events?.flush();
+    }
+    async close() {
+        this.stream?.stop();
+        this.stopPolling();
+        await this.events?.close();
+        this.removeAllListeners();
+    }
+}
+export function init(sdkKey, options) {
+    return new DevPulseNodeClient(sdkKey, options);
+}

package/dist/flags/react.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from "react";
+import { type ClientOptions, type ContextInput, type DevPulseClient, type EvaluationDetail, type FlagSet, type FlagValue } from "./client.js";
+export type { ClientOptions, ContextInput, DevPulseClient, FlagSet, FlagValue };
+export interface DevPulseProviderProps {
+    clientSideId: string;
+    context: ContextInput;
+    options: ClientOptions;
+    /** Use an existing client instead of creating one. */
+    client?: DevPulseClient;
+    children: ReactNode;
+}
+/**
+ * Provides a DevPulse client to the tree. On the server (SSR/RSC streaming)
+ * no network connection is opened; flags come from `options.bootstrap`, so the
+ * first client render matches the server HTML. Changing `context` calls identify().
+ */
+export declare function DevPulseProvider({ clientSideId, context, options, client: external, children }: DevPulseProviderProps): import("react").JSX.Element;
+export declare function useDevPulseClient(): DevPulseClient;
+/** Current value of one flag; re-renders only when that flag changes. */
+export declare function useFlag<T extends FlagValue>(key: string, defaultValue: T): T;
+export declare function useFlagDetail<T extends FlagValue>(key: string, defaultValue: T): EvaluationDetail<T>;
+/** All flag values; re-renders when any flag changes. */
+export declare function useFlags(): Record<string, FlagValue>;
+/** True once flags have loaded (always true when bootstrapped). */
+export declare function useFlagsReady(): boolean;
+/** Track a custom event for metrics and experiments. */
+export declare function useTrack(): (key: string, data?: unknown, metricValue?: number) => void;

package/dist/flags/react.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { createClient } from "./client.js";
+const ClientContext = createContext(null);
+const isBrowser = typeof window !== "undefined";
+/**
+ * Provides a DevPulse client to the tree. On the server (SSR/RSC streaming)
+ * no network connection is opened; flags come from `options.bootstrap`, so the
+ * first client render matches the server HTML. Changing `context` calls identify().
+ */
+export function DevPulseProvider({ clientSideId, context, options, client: external, children }) {
+    const [client] = useState(() => external ?? createClient(clientSideId, context, isBrowser ? options : { ...options, streaming: false, sendEvents: false, bootstrap: options.bootstrap ?? {} }));
+    const contextJson = JSON.stringify(context);
+    const first = useRef(true);
+    useEffect(() => {
+        if (first.current) {
+            first.current = false;
+            return;
+        }
+        void client.identify(JSON.parse(contextJson));
+    }, [client, contextJson]);
+    useEffect(() => () => void (!external && client.close()), [client, external]);
+    return _jsx(ClientContext.Provider, { value: client, children: children });
+}
+export function useDevPulseClient() {
+    const client = useContext(ClientContext);
+    if (!client)
+        throw new Error("useDevPulseClient must be used inside <DevPulseProvider>");
+    return client;
+}
+/** Current value of one flag; re-renders only when that flag changes. */
+export function useFlag(key, defaultValue) {
+    return useFlagDetail(key, defaultValue).value;
+}
+export function useFlagDetail(key, defaultValue) {
+    const client = useDevPulseClient();
+    const defaultJson = JSON.stringify(defaultValue);
+    const subscribe = useMemo(() => (cb) => client.on(`change:${key}`, cb), [client, key]);
+    // Snapshot is the serialized value so useSyncExternalStore sees stable identities.
+    const snapshot = () => JSON.stringify(client.allFlags()[key] ?? null);
+    const serialized = useSyncExternalStore(subscribe, snapshot, snapshot);
+    // Record the evaluation (analytics) once per distinct value.
+    return useMemo(() => client.variationDetail(key, JSON.parse(defaultJson)), [client, key, defaultJson, serialized]); // eslint-disable-line react-hooks/exhaustive-deps
+}
+/** All flag values; re-renders when any flag changes. */
+export function useFlags() {
+    const client = useDevPulseClient();
+    const subscribe = useMemo(() => (cb) => client.on("change", cb), [client]);
+    const json = useSyncExternalStore(subscribe, () => JSON.stringify(client.allFlags()), () => JSON.stringify(client.allFlags()));
+    return useMemo(() => JSON.parse(json), [json]);
+}
+/** True once flags have loaded (always true when bootstrapped). */
+export function useFlagsReady() {
+    const client = useDevPulseClient();
+    const subscribe = useMemo(() => (cb) => client.on("ready", cb), [client]);
+    return useSyncExternalStore(subscribe, () => client.isInitialized, () => client.isInitialized);
+}
+/** Track a custom event for metrics and experiments. */
+export function useTrack() {
+    const client = useDevPulseClient();
+    return (key, data, metricValue) => client.track(key, data, metricValue);
+}

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { Daywalker, createDaywalker, daywalker, } from "./client.js";
 export { DaywalkerError, DaywalkerAuthError, DaywalkerRateLimitError, } from "./types.js";
 export type { DaywalkerConfig, RateLimitWindow, TokenPayload, ValidateErrorCode, ValidateResult, RetryOptions, SelfCheckResult, PublicJwk, SigningKey, } from "./types.js";
-export { resolveConfig, publicHostname, } from "./config.js";
+export { resolveConfig, publicHostname, assertSecureUrl, } from "./config.js";
 export type { ResolvedConfig, } from "./config.js";
 export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, computeContentDigest, sha256Base64, sha256Base64Url, calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, registerPublicKey, stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, bytesToHex, hexToBytes, maskSecret, redactSecrets, } from "./crypto/index.js";
 export type { SignedHeaders, SignRequestParams, VerifySignatureParams, VerifySignatureResult, } from "./crypto/index.js";

package/dist/index.js

@@ -1,4 +1,4 @@
 export { Daywalker, createDaywalker, daywalker, } from "./client.js";
 export { DaywalkerError, DaywalkerAuthError, DaywalkerRateLimitError, } from "./types.js";
-export { resolveConfig, publicHostname, } from "./config.js";
+export { resolveConfig, publicHostname, assertSecureUrl, } from "./config.js";
 export { SIGNATURE_VERSION, SIGNATURE_LABEL, SIGNATURE_ALG, MAX_CLOCK_SKEW_SECONDS, computeContentDigest, sha256Base64, sha256Base64Url, calculateJwkThumbprint, generateSigningKey, loadSigningKey, loadPublicKey, formatSignatureParams, createSignatureBase, signRequest, verifyRequestSignature, verifyJwtLease, registerPublicKey, stringToUtf8, utf8ToString, bytesToBase64, base64ToBytes, bytesToBase64Url, base64UrlToBytes, bytesToHex, hexToBytes, maskSecret, redactSecrets, } from "./crypto/index.js";

package/dist/next.d.ts

@@ -7,6 +7,13 @@ import type { TokenPayload } from "./types.js";
  */
 export declare const SERVER_ACTION_ID_PATTERN: RegExp;
 export declare const DEFAULT_BYPASS_PATHS: string[];
+/** File extensions treated as static assets (outside /api/) and passed through without auth. */
+export declare const STATIC_FILE_EXTENSIONS: RegExp;
+/**
+ * Static assets that skip auth: Next's build output and image optimizer, the favicon, and files with
+ * an allowlisted extension. `/_next/data/` (getServerSideProps JSON) and `/api/*` are never static.
+ */
+export declare function isStaticAssetPath(pathname: string): boolean;
 export interface NextMiddlewareOptions {
     client?: Daywalker;
     serviceSlug?: string;
@@ -28,8 +35,8 @@ export declare function sanitizeRedirectPath(path: string): string | null;
  * Implements:
  * 1. Server Action probe defense (CVE-2025-55182 scanner mitigation)
  * 2. Static asset and health check bypass
- * 3. Self-healing service error page routing with `from` back-redirect
- * 4. Distinct handling for API routes (JSON + CORS) vs UI pages (redirect)
+ * 3. Per-request token auth: requests without `Authorization: Bearer` / `x-api-token` get 401
+ * 4. Distinct handling for API routes (JSON + CORS) vs UI pages (redirect to `errorPath` with `from`)
  *
  * Example:
  *   // middleware.ts
@@ -42,6 +49,12 @@ export declare function sanitizeRedirectPath(path: string): string | null;
  *   };
  */
 export declare function createDaywalkerMiddleware(options?: NextMiddlewareOptions): (request: Request) => Promise<Response>;
+/**
+ * Service health gate: checks this service's own DAYWALKER_API_KEY (not the caller's token) and
+ * routes every request to `errorPath` while it is invalid, redirecting back once it heals.
+ * It does NOT authenticate callers; use `createDaywalkerMiddleware` or `withDaywalkerAuth` for that.
+ */
+export declare function createDaywalkerServiceHealthMiddleware(options?: NextMiddlewareOptions): (request: Request) => Promise<Response>;
 /**
  * Next.js App Router route handler wrapper with Daywalker token validation.
  * Extracts `Authorization: Bearer <token>` or `x-api-token`, validates via client,

package/dist/next.js

@@ -12,6 +12,23 @@ export const DEFAULT_BYPASS_PATHS = [
     "/robots.txt",
     "/sitemap.xml",
 ];
+/** File extensions treated as static assets (outside /api/) and passed through without auth. */
+export const STATIC_FILE_EXTENSIONS = /\.(?:js|css|png|jpe?g|gif|webp|avif|svg|ico|woff2?|map|txt)$/i;
+/**
+ * Static assets that skip auth: Next's build output and image optimizer, the favicon, and files with
+ * an allowlisted extension. `/_next/data/` (getServerSideProps JSON) and `/api/*` are never static.
+ */
+export function isStaticAssetPath(pathname) {
+    if (pathname === "/api" || pathname.startsWith("/api/"))
+        return false;
+    if (pathname.startsWith("/_next/static/") || pathname === "/_next/image" || pathname.startsWith("/_next/image/"))
+        return true;
+    if (pathname === "/favicon.ico")
+        return true;
+    if (pathname.startsWith("/_next/"))
+        return false;
+    return STATIC_FILE_EXTENSIONS.test(pathname);
+}
 /**
  * Sanitizes open redirect path parameter (`from`).
  * Prevents protocol-relative URLs (`//evil.com`), backslashes (`/\evil.com`), and control characters.
@@ -42,8 +59,8 @@ function extractToken(req) {
  * Implements:
  * 1. Server Action probe defense (CVE-2025-55182 scanner mitigation)
  * 2. Static asset and health check bypass
- * 3. Self-healing service error page routing with `from` back-redirect
- * 4. Distinct handling for API routes (JSON + CORS) vs UI pages (redirect)
+ * 3. Per-request token auth: requests without `Authorization: Bearer` / `x-api-token` get 401
+ * 4. Distinct handling for API routes (JSON + CORS) vs UI pages (redirect to `errorPath` with `from`)
  *
  * Example:
  *   // middleware.ts
@@ -57,6 +74,24 @@ function extractToken(req) {
  */
 export function createDaywalkerMiddleware(options = {}) {
     const client = options.client ?? daywalker;
+    return buildMiddleware(options, async (request) => {
+        const token = extractToken(request);
+        if (!token) {
+            return { ok: false, error: "INVALID_TOKEN", status: 401, message: "Missing Authorization header or x-api-token" };
+        }
+        return client.validateToken(token, { serviceSlug: options.serviceSlug });
+    });
+}
+/**
+ * Service health gate: checks this service's own DAYWALKER_API_KEY (not the caller's token) and
+ * routes every request to `errorPath` while it is invalid, redirecting back once it heals.
+ * It does NOT authenticate callers; use `createDaywalkerMiddleware` or `withDaywalkerAuth` for that.
+ */
+export function createDaywalkerServiceHealthMiddleware(options = {}) {
+    const client = options.client ?? daywalker;
+    return buildMiddleware(options, () => client.validateServiceKey({ serviceSlug: options.serviceSlug }));
+}
+function buildMiddleware(options, authenticate) {
     const bypassPaths = options.bypassPaths ?? DEFAULT_BYPASS_PATHS;
     const errorPath = options.errorPath ?? "/service-error";
     const homePath = options.homePath ?? "/";
@@ -80,20 +115,17 @@ export function createDaywalkerMiddleware(options = {}) {
             }
         }
         // 1. Bypass static files and health check probes
-        if (bypassPaths.some((path) => pathname === path || pathname.startsWith(`${path}/`)) ||
-            pathname.startsWith("/_next") ||
-            (pathname.includes(".") && !pathname.endsWith(".json"))) {
+        if (bypassPaths.some((path) => pathname === path || pathname.startsWith(`${path}/`)) || isStaticAssetPath(pathname)) {
             return globalThis.NextResponse?.next
                 ? globalThis.NextResponse.next()
                 : new Response(null, { headers: { "x-middleware-next": "1" } });
         }
-        // 2. Validate token (from request header, or service's configured DAYWALKER_API_KEY)
-        const incomingToken = extractToken(request);
-        const authResult = await client.validateToken(incomingToken ? { token: incomingToken, serviceSlug: options.serviceSlug } : { serviceSlug: options.serviceSlug });
+        // 2. Authenticate (caller's token, or the service key for the health gate)
+        const authResult = await authenticate(request);
         // 3. Handle service error page route
         if (pathname === errorPath) {
             if (authResult.ok) {
-                // If the service token is now valid, heal/redirect back to home or referer
+                // Authorized again: heal/redirect back to home
                 const redirectUrl = new URL(homePath, request.url);
                 return globalThis.NextResponse?.redirect
                     ? globalThis.NextResponse.redirect(redirectUrl)

package/dist/openfeature/server.d.ts

@@ -0,0 +1,26 @@
+import type { EvaluationContext, JsonValue, Logger as OFLogger, Provider, ResolutionDetails } from "@openfeature/server-sdk";
+import { OpenFeatureEventEmitter } from "@openfeature/server-sdk";
+import { type DevPulseNodeClient, type NodeClientOptions } from "../flags/node.js";
+/**
+ * OpenFeature provider for servers, backed by @shelbyb/daywalker-sdk/flags/node (local evaluation,
+ * real-time updates).
+ *
+ *   await OpenFeature.setProviderAndWait(new DevPulseServerProvider(sdkKey, { baseUrl }));
+ *   const enabled = await OpenFeature.getClient().getBooleanValue("new-checkout", false, { targetingKey: user.id });
+ */
+export declare class DevPulseServerProvider implements Provider {
+    readonly metadata: {
+        readonly name: "devpulse";
+    };
+    readonly runsOn: "server";
+    readonly events: OpenFeatureEventEmitter;
+    readonly client: DevPulseNodeClient;
+    constructor(sdkKeyOrClient: string | DevPulseNodeClient, options?: NodeClientOptions);
+    initialize(): Promise<void>;
+    onClose(): Promise<void>;
+    private resolve;
+    resolveBooleanEvaluation(key: string, def: boolean, ctx: EvaluationContext, _logger: OFLogger): Promise<ResolutionDetails<boolean>>;
+    resolveStringEvaluation(key: string, def: string, ctx: EvaluationContext, _logger: OFLogger): Promise<ResolutionDetails<string>>;
+    resolveNumberEvaluation(key: string, def: number, ctx: EvaluationContext, _logger: OFLogger): Promise<ResolutionDetails<number>>;
+    resolveObjectEvaluation<T extends JsonValue>(key: string, def: T, ctx: EvaluationContext, _logger: OFLogger): Promise<ResolutionDetails<T>>;
+}

package/dist/openfeature/server.js

@@ -0,0 +1,42 @@
+import { OpenFeatureEventEmitter, ProviderEvents } from "@openfeature/server-sdk";
+import { init } from "../flags/node.js";
+import { toDevPulseContext, toResolution, typeCheck } from "./shared.js";
+/**
+ * OpenFeature provider for servers, backed by @shelbyb/daywalker-sdk/flags/node (local evaluation,
+ * real-time updates).
+ *
+ *   await OpenFeature.setProviderAndWait(new DevPulseServerProvider(sdkKey, { baseUrl }));
+ *   const enabled = await OpenFeature.getClient().getBooleanValue("new-checkout", false, { targetingKey: user.id });
+ */
+export class DevPulseServerProvider {
+    metadata = { name: "devpulse" };
+    runsOn = "server";
+    events = new OpenFeatureEventEmitter();
+    client;
+    constructor(sdkKeyOrClient, options) {
+        this.client = typeof sdkKeyOrClient === "string" ? init(sdkKeyOrClient, options) : sdkKeyOrClient;
+        this.client.on("update", ({ key }) => this.events.emit(ProviderEvents.ConfigurationChanged, { flagsChanged: [key] }));
+    }
+    async initialize() {
+        await this.client.waitForInitialization();
+    }
+    async onClose() {
+        await this.client.close();
+    }
+    resolve(key, def, ctx, type) {
+        const detail = this.client.variationDetailSync(key, toDevPulseContext(ctx), def);
+        return toResolution(typeCheck(detail, type, def));
+    }
+    async resolveBooleanEvaluation(key, def, ctx, _logger) {
+        return this.resolve(key, def, ctx, "boolean");
+    }
+    async resolveStringEvaluation(key, def, ctx, _logger) {
+        return this.resolve(key, def, ctx, "string");
+    }
+    async resolveNumberEvaluation(key, def, ctx, _logger) {
+        return this.resolve(key, def, ctx, "number");
+    }
+    async resolveObjectEvaluation(key, def, ctx, _logger) {
+        return this.resolve(key, def, ctx, "object");
+    }
+}

package/dist/openfeature/shared.d.ts

@@ -0,0 +1,19 @@
+import type { EvaluationContext, ResolutionDetails } from "@openfeature/core";
+type Reason = {
+    kind: string;
+    errorKind?: string;
+    inExperiment?: boolean;
+} | null | undefined;
+type Detail<T> = {
+    value: T;
+    variationIndex: number | null;
+    reason: Reason;
+};
+/**
+ * OpenFeature context → DevPulse context. `targetingKey` becomes the key;
+ * `kind` selects the context kind (default "user"); multi-kind contexts pass through.
+ */
+export declare function toDevPulseContext(ctx: EvaluationContext): Record<string, unknown>;
+export declare function toResolution<T>(detail: Detail<T>): ResolutionDetails<T>;
+export declare function typeCheck<T>(detail: Detail<unknown>, expected: string, defaultValue: T): Detail<T>;
+export {};

package/dist/openfeature/shared.js

@@ -0,0 +1,40 @@
+import { ErrorCode, StandardResolutionReasons } from "@openfeature/core";
+/**
+ * OpenFeature context → DevPulse context. `targetingKey` becomes the key;
+ * `kind` selects the context kind (default "user"); multi-kind contexts pass through.
+ */
+export function toDevPulseContext(ctx) {
+    const { targetingKey, ...rest } = ctx;
+    if (rest.kind === "multi")
+        return rest;
+    return { ...rest, kind: typeof rest.kind === "string" ? rest.kind : "user", key: targetingKey ?? rest.key };
+}
+const ERRORS = {
+    FLAG_NOT_FOUND: ErrorCode.FLAG_NOT_FOUND,
+    WRONG_TYPE: ErrorCode.TYPE_MISMATCH,
+    USER_NOT_SPECIFIED: ErrorCode.TARGETING_KEY_MISSING,
+    CLIENT_NOT_READY: ErrorCode.PROVIDER_NOT_READY,
+    MALFORMED_FLAG: ErrorCode.PARSE_ERROR,
+};
+export function toResolution(detail) {
+    const r = detail.reason;
+    if (r?.kind === "ERROR") {
+        return { value: detail.value, reason: StandardResolutionReasons.ERROR, errorCode: ERRORS[r.errorKind ?? ""] ?? ErrorCode.GENERAL, errorMessage: r.errorKind };
+    }
+    let reason = StandardResolutionReasons.UNKNOWN;
+    if (r?.kind === "OFF")
+        reason = StandardResolutionReasons.DISABLED;
+    else if (r?.kind === "TARGET_MATCH" || r?.kind === "RULE_MATCH")
+        reason = r.inExperiment ? StandardResolutionReasons.SPLIT : StandardResolutionReasons.TARGETING_MATCH;
+    else if (r?.kind === "FALLTHROUGH")
+        reason = r.inExperiment ? StandardResolutionReasons.SPLIT : StandardResolutionReasons.DEFAULT;
+    else if (r?.kind === "PREREQUISITE_FAILED")
+        reason = StandardResolutionReasons.DISABLED;
+    return { value: detail.value, reason, ...(detail.variationIndex !== null ? { variant: String(detail.variationIndex) } : {}), flagMetadata: r ? { devpulseReason: r.kind } : {} };
+}
+export function typeCheck(detail, expected, defaultValue) {
+    const actual = Array.isArray(detail.value) ? "object" : typeof detail.value;
+    if (detail.reason?.kind !== "ERROR" && actual !== expected)
+        return { value: defaultValue, variationIndex: null, reason: { kind: "ERROR", errorKind: "WRONG_TYPE" } };
+    return detail;
+}

package/dist/openfeature/web.d.ts

@@ -0,0 +1,29 @@
+import type { EvaluationContext, JsonValue, Logger as OFLogger, Provider, ResolutionDetails } from "@openfeature/web-sdk";
+import { OpenFeatureEventEmitter } from "@openfeature/web-sdk";
+import { type ClientOptions } from "../flags/client.js";
+/**
+ * OpenFeature provider for browsers, backed by @shelbyb/daywalker-sdk/flags. Flag
+ * values update in real time and emit PROVIDER_CONFIGURATION_CHANGED.
+ *
+ *   await OpenFeature.setContext({ targetingKey: user.id });
+ *   await OpenFeature.setProviderAndWait(new DevPulseWebProvider(clientSideId, { baseUrl }));
+ */
+export declare class DevPulseWebProvider implements Provider {
+    private readonly clientSideId;
+    private readonly options;
+    readonly metadata: {
+        readonly name: "devpulse";
+    };
+    readonly runsOn: "client";
+    readonly events: OpenFeatureEventEmitter;
+    private client;
+    constructor(clientSideId: string, options: ClientOptions);
+    initialize(context?: EvaluationContext): Promise<void>;
+    onContextChange(_old: EvaluationContext, next: EvaluationContext): Promise<void>;
+    onClose(): Promise<void>;
+    private resolve;
+    resolveBooleanEvaluation(key: string, def: boolean, _ctx: EvaluationContext, _logger: OFLogger): ResolutionDetails<boolean>;
+    resolveStringEvaluation(key: string, def: string, _ctx: EvaluationContext, _logger: OFLogger): ResolutionDetails<string>;
+    resolveNumberEvaluation(key: string, def: number, _ctx: EvaluationContext, _logger: OFLogger): ResolutionDetails<number>;
+    resolveObjectEvaluation<T extends JsonValue>(key: string, def: T, _ctx: EvaluationContext, _logger: OFLogger): ResolutionDetails<T>;
+}