From LaunchDarkly

import * as ld from 'launchdarkly-node-server-sdk';const ldServer = ld.init('sdk-your-server-key');await ldServer.waitForInitialization();// ldServer is ready

import { AvsbServer } from '@avsbhq/node';const server = new AvsbServer({ sdkKey: 'sdk_production_xxxxxxxxxxxxxxxx' });const result = await server.onReady();// result.success === true  →  ready to answer (fresh, or degraded below)// result.degraded === true →  serving a cached datafile; a refresh failed, so retry keeps polling

import * as LDClient from 'launchdarkly-js-client-sdk';const ctx = { kind: 'user', key: 'u_123', plan: 'pro' };const ldClient = LDClient.initialize('client-side-id', ctx);await ldClient.waitForInitialization();

import { AvsbClient } from '@avsbhq/browser';const client = new AvsbClient({ sdkKey: 'sdk_production_xxxxxxxxxxxxxxxx', context: { kind: 'user', key: 'u_123', plan: 'pro' } });const result = await client.onReady();

// Replace the whole context (triggers flag re-evaluation)await ldClient.identify({ kind: 'user', key: 'u_456', plan: 'enterprise' });// Partial attribute update: no direct equivalent; must re-identify with full ctx

// Replace the full context (equivalent to LD identify)client.identify({ kind: 'user', key: 'u_456', plan: 'enterprise' });// Patch only specific attributes on an existing context: no full replacementclient.updateAttributes({ plan: 'enterprise' });// Optionally target a specific context kind in a multi-context:client.updateAttributes({ tier: 'gold' }, 'organization');// Link an anonymous pre-login identity to a signed-up user. Synchronous:// it records the moment, it does not move past decisions.client.alias({ kind: 'user', key: 'anon_abc' }, { kind: 'user', key: 'u_456' }); // previousContext, newContext

// Raw value onlyconst showBanner = ldClient.variation('show_banner', ctx, false);// With reason (separate call)const detail = ldClient.variationDetail('show_banner', ctx, false);// detail.value, detail.reason.kind, detail.variationIndex

interface PricingConfig { currency: string; seats: number; }// Every call returns Flag<T>: no separate 'detail' variant neededconst flag = server.forUser(ctx).getBoolFlag('show_banner', false);flag.value          // booleanflag.isEnabled()    // true only for a real decision (rule, holdout, bandit, sticky, override)flag.variationKey   // string key (e.g. 'on') or null if default servedflag.source         // 'rule' | 'default' | 'holdout' | 'sticky' | 'not_found' | ...flag.reasons        // string[] (human-readable reasons array)flag.ruleId         // matched rule id or null// Typed evaluator variantsconst theme  = server.forUser(ctx).getStringFlag('homepage_theme', 'default');const limit  = server.forUser(ctx).getNumberFlag('rate_limit', 100);const config = server.forUser(ctx).getJsonFlag<PricingConfig>('pricing_config', { currency: 'USD', seats: 1 });// Browser client (context already bound at construction / identify)const flag2 = client.getBoolFlag('show_banner', false);

ldClient.track('purchase_completed', ctx, { orderId: 'ord_99' }, 49.99);

// Browser: context already bound. LaunchDarkly's positional metric value// becomes `revenue` (money) or `value` (a plain numeric metric).client.track('purchase_completed', { revenue: 49.99 });// Server: pass context in payloadserver.track('purchase_completed', { context: { kind: 'user', key: 'u_123' }, revenue: 49.99 });// Server with forUser scopeserver.forUser({ kind: 'user', key: 'u_123' }).track('purchase_completed', {  revenue: 49.99,});

import type { LDMultiKindContext } from 'launchdarkly-js-client-sdk';const multiCtx: LDMultiKindContext = { kind: 'multi', user: { kind: 'user', key: 'u_123', plan: 'pro' }, organization: { kind: 'organization', key: 'org_42', tier: 'enterprise' } };ldClient.variation('enterprise_feature', multiCtx, false);

import type { MultiContext } from '@avsbhq/core';const multiCtx: MultiContext = { kind: 'multi', user: { kind: 'user', key: 'u_123', plan: 'pro' }, organization: { kind: 'organization', key: 'org_42', tier: 'enterprise' } };// In the dashboard, set hashAttribute to 'organization.key' to bucket by orgserver.forUser(multiCtx).getBoolFlag('enterprise_feature', false);

ldClient.on('change', (changes: Record<string, { current: unknown; previous: unknown }>) => {  // changes is a map of flagKey → { current, previous }});

// Subscribe to individual flag changesconst unsub = client.on('flagChange', ({ flagKey, previousValue, newValue }) => {  console.log(flagKey, previousValue, '→', newValue);}); // Call unsub() to stop listening// Subscribe to any datafile update (e.g. to force a re-render)client.on('configUpdate', ({ publishedAt, reason }) => {  // reason: 'poll' | 'stream' | 'manual'});

// Server componentimport { init } from '@launchdarkly/node-server-sdk';const ldClient = init(process.env.LD_SDK_KEY!);await ldClient.waitForInitialization();const bootstrapData = ldClient.allFlagsState(ctx);// Pass serialized state to client

// Server component (app/layout.tsx)import { fetchDatafile } from '@avsbhq/browser/server';const datafile = await fetchDatafile(process.env.AVSB_SDK_KEY!);// Pass datafile to the client-side AvsbProvider// Client provider (app/providers.tsx)'use client'import type { ReactNode } from 'react';import { AvsbProvider } from '@avsbhq/react';import type { FlagDatafile } from '@avsbhq/react';export function Providers({ datafile, children }: { datafile: FlagDatafile | null; children: ReactNode }) {  return (    <AvsbProvider      sdkKey={process.env.NEXT_PUBLIC_AVSB_SDK_KEY!}      context={{ kind: 'user', key: 'anon' }}      bootstrap={datafile ?? undefined}    >      {children}    </AvsbProvider>  );}

// Provide a StickyBucketingService implementation at initimport { createClient } from 'redis';import { RedisStickyBucketService } from './my-sticky-service';const redisClient = createClient({ url: process.env.REDIS_URL });const ldStickyServer = ld.init(process.env.LD_SDK_KEY!, {  stickyBucketService: new RedisStickyBucketService(redisClient),});

import type { StickyBucketService, StickyAssignment } from '@avsbhq/core';class MyStickyService implements StickyBucketService {  // Both methods are synchronous, so back them with a warm local cache.  private cache = new Map<string, StickyAssignment>();  lookup(userId: string, flagKey: string): StickyAssignment | null {    // { variationId, ruleId, ruleType, assignedAt } or null    return this.cache.get(`${userId}:${flagKey}`) ?? null;  }  save(userId: string, flagKey: string, assignment: StickyAssignment): void {    this.cache.set(`${userId}:${flagKey}`, assignment);  }}const stickyServer = new AvsbServer({  sdkKey: process.env.AVSB_SDK_KEY!,  stickyBucketService: new MyStickyService(),});

const flag = server.forUser(ctx).getBoolFlag('checkout_redesign', false);if (flag.source === 'holdout') {  // This user is in the holdout group: they see the control across all flags  // in this holdout. Do not count them in experiment metrics.}

await ldClient.close();

// Flush any buffered events and stop polling/streamingawait server.close();   // server SDKawait client.close();   // browser SDK (also calls flush() internally)

import { TestData } from 'launchdarkly-node-server-sdk';const td = TestData.dataSource();td.update(td.flag('show_banner').booleanFlag().variationForAll(true));const ldTestServer = ld.init('sdk-key', { dataSource: td });

import { createMockClient } from '@avsbhq/test';const mockClient = createMockClient({  flags: {    show_banner: true,    homepage_theme: 'blue',    rate_limit: 100,  },});// mockClient conforms to the full AvsbClient interface// Inject it wherever your code expects an AvsbClient