@99ways/posthog-page-experiments 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented here. The project follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.1.0] - 2026-09-17
+
+### Added
+
+- Code-first A/B and multivariate page execution backed by PostHog feature flags.
+- Eligibility checks that run before feature-flag evaluation.
+- Declarative DOM updates and ordered custom functions.
+- URL variant overrides for QA.
+- Configurable fallback, timeout, and debug behavior.
+- ESM, browser/IIFE, and TypeScript declaration builds.
+- Unit and real-browser tests using an actual `posthog-js` client.
+
+[0.1.0]: https://github.com/99ways-io/posthog-page-experiments/releases/tag/v0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 99Ways
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,252 @@
+# PostHog Page Experiments
+
+Code-first page experiments for PostHog. Apply A/B and multivariate variants to existing websites with eligibility checks, URL QA overrides, and safe fallbacks.
+
+Use it when PostHog should handle assignment and analysis, but the tested experience lives in an existing page that you need to change with JavaScript or targeted DOM updates.
+
+> [!NOTE]
+> This is an independent community project from [99Ways](https://99ways.io). It is not affiliated with or endorsed by PostHog.
+
+## Why it exists
+
+A direct `posthog.getFeatureFlag()` call is enough for a simple product branch. Page experiments tend to repeat more browser-side work:
+
+- wait for the page and PostHog to become ready;
+- exclude visitors who cannot receive the change before recording an exposure;
+- map variants and apply several DOM or custom-code steps;
+- fall back safely when a flag is late, disabled, or misconfigured;
+- let reviewers force a variant through the URL.
+
+PostHog Page Experiments packages that execution logic without replacing PostHog's feature flags, experiment analysis, or no-code tools.
+
+## Install
+
+```bash
+npm install @99ways/posthog-page-experiments posthog-js
+```
+
+The package has no runtime dependencies. It works with an existing PostHog browser client, whether you pass that client directly or expose it as `window.posthog`.
+
+## Quick start
+
+```ts
+import { runExperiment } from '@99ways/posthog-page-experiments'
+import posthog from 'posthog-js'
+
+posthog.init('YOUR_PROJECT_KEY', {
+  api_host: 'https://us.i.posthog.com',
+})
+
+const activeVariant = await runExperiment('pricing-page-headline', {
+  posthog,
+
+  // Checked before PostHog evaluates the flag. Ineligible visitors return null
+  // and are not included in the experiment by this call.
+  isEligible: () => document.querySelector('.pricing-hero') !== null,
+
+  variants: {
+    control: [],
+    test: [
+      {
+        selector: '.pricing-hero h1',
+        updates: {
+          innerText: 'A clearer reason to choose the product',
+        },
+      },
+    ],
+  },
+})
+
+console.log(activeVariant) // 'control', 'test', another configured variant, or null
+```
+
+The default variant must be present in `variants`. An empty `control: []` keeps the original page unchanged while making fallback behavior explicit.
+
+### Direct browser script
+
+After `0.1.0` is published, the minified browser build will be available from npm CDNs:
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/@99ways/posthog-page-experiments@0.1.0/dist/posthog-page-experiments.min.js"></script>
+<script>
+  window.runExperiment('pricing-page-headline', {
+    isEligible: () => document.querySelector('.pricing-hero') !== null,
+    variants: {
+      control: [],
+      test: [
+        {
+          selector: '.pricing-hero h1',
+          updates: { innerText: 'A clearer reason to choose the product' },
+        },
+      ],
+    },
+  })
+</script>
+```
+
+Load PostHog before the experiment code, or let the package wait up to `featureFlagTimeoutMs` for a late-loading `window.posthog` client.
+
+## Protect experiment validity with eligibility
+
+PostHog records an experiment exposure when your code evaluates the flag. If a visitor cannot receive the page change—because the relevant page, state, or element is absent—evaluate that condition first:
+
+```ts
+runExperiment('checkout-reassurance', {
+  isEligible: async () => {
+    const checkout = document.querySelector('[data-checkout]')
+    const hasExistingOrder = await hasCompletedOrder()
+    return checkout !== null && !hasExistingOrder
+  },
+  variants: {
+    control: [],
+    test: [
+      {
+        selector: '[data-checkout-reassurance]',
+        updates: { innerText: 'Free returns within 30 days' },
+      },
+    ],
+  },
+})
+```
+
+`isEligible` runs after `DOMContentLoaded` and before the URL override or PostHog is read. It may be synchronous or asynchronous. A false result resolves `runExperiment()` to `null`; an error rejects the promise without evaluating the flag.
+
+Eligibility should describe who can actually receive the tested experience. It is not a replacement for audience targeting in PostHog.
+
+## QA a variant through the URL
+
+Add a query parameter whose name is the feature-flag key:
+
+```text
+https://example.com/pricing?pricing-page-headline=test
+```
+
+A configured URL variant takes precedence over PostHog, which makes review possible before a rollout exists. Eligibility still runs first. An unknown variant falls back to the configured default.
+
+## Choose the right tool
+
+Use this package when:
+
+- you are changing an existing server-rendered or static page;
+- the variant needs a few DOM changes or custom browser functions;
+- PostHog already owns assignment and experiment analysis;
+- eligibility, fallback, and repeatable QA matter.
+
+Use raw PostHog feature-flag calls when the flag is already part of your application's render logic. Use PostHog's no-code tooling when the change can be authored and maintained there without custom execution logic. This package is deliberately not a visual editor, framework wrapper, or experiment-analysis SDK.
+
+## API
+
+### `runExperiment(featureFlag, options)`
+
+Returns `Promise<string | null>`:
+
+- the applied variant name when the visitor is eligible;
+- `null` when browser globals are unavailable or `isEligible` returns false.
+
+The promise rejects if eligibility or a variant handler throws.
+
+| Option | Type | Default | Purpose |
+| --- | --- | --- | --- |
+| `variants` | `Record<string, VariantHandler>` | Required | Complete map of supported variants. Must include the default. |
+| `defaultVariant` | `string` | `control` | Used for unavailable, disabled, empty, timed-out, or unknown flag values. |
+| `isEligible` | `() => boolean \| PromiseLike<boolean>` | `() => true` | Runs before the flag is evaluated. |
+| `posthog` | `PostHogClient` | `window.posthog` | Explicit initialized client for module use. |
+| `featureFlagTimeoutMs` | `number` | `4000` | Maximum wait for PostHog and its first feature-flag notification. |
+| `debug` | `boolean` | `false` | Enables lifecycle and fallback diagnostics. |
+
+Boolean flags map `true` to `test` and `false` to the default variant. String-valued flags map directly to the matching configured variant.
+
+### Variant handlers
+
+A variant can be one function or an ordered array containing DOM changes and functions:
+
+```ts
+runExperiment('offer-card', {
+  variants: {
+    control: [],
+    test: [
+      {
+        selector: '.offer-card',
+        updates: {
+          style: {
+            backgroundColor: '#111827',
+            color: '#ffffff',
+            padding: '24px',
+          },
+          innerText: 'A focused offer',
+          callback(element, variant) {
+            element.dataset.experimentVariant = variant
+          },
+        },
+      },
+      () => {
+        document.documentElement.dataset.hasOfferExperiment = 'true'
+      },
+    ],
+  },
+})
+```
+
+- Every matching element is updated.
+- Style names may be camelCase, kebab-case, or CSS custom properties. Values are stringified and applied with `!important`; include units such as `'24px'` when needed.
+- `innerText` replaces plain text.
+- `innerHTML` is assigned without sanitization. Only use trusted markup.
+- Element callbacks and custom functions run synchronously in array order. Returned promises are not awaited.
+
+## Flicker and loading strategy
+
+This package waits for DOM readiness, eligibility, and the PostHog flag before changing the page. A client-rendered visual treatment can therefore flash the original experience.
+
+For visible above-the-fold changes:
+
+1. load PostHog and the experiment code as early as your performance budget allows;
+2. bootstrap or cache PostHog flags when your architecture supports it;
+3. hide only the specific experiment target with a short, fail-safe timeout when a flash would be worse than a brief concealment;
+4. prefer server-side or application-rendered variants when flicker-free rendering is essential.
+
+The package does not inject a global anti-flicker snippet because a generic page-hiding strategy can damage Core Web Vitals and trap content when scripts fail.
+
+## Current boundaries
+
+- Variants apply once. The package does not observe later SPA mutations, revert changes, or clean up effects.
+- Selectors that match nothing are skipped. Use `isEligible` when a missing target means the visitor must not enter the experiment.
+- Handlers are synchronous from the package's perspective; asynchronous work inside them is not awaited.
+- A thrown handler error stops the remaining steps and rejects the returned promise.
+- The package runs in browsers. Importing it during server rendering is safe, but calling it without browser globals resolves to `null`.
+
+## Compatibility and versioning
+
+The distributed JavaScript targets modern evergreen browsers and uses standard browser APIs including `Promise`, `URLSearchParams`, and `querySelectorAll`.
+
+There is no runtime dependency on `posthog-js`. Compatibility is structural: the client must expose `__loaded`, `onFeatureFlags()`, and `getFeatureFlag()`. CI tests the current release against `posthog-js` 1.433.9 in Chromium.
+
+The project follows Semantic Versioning. Before `1.0.0`, breaking public-API changes may ship in a minor release; they will be called out in the changelog. The internal experiment class is not part of the public contract.
+
+## Try the local demo
+
+```bash
+bun install
+bun run demo
+```
+
+Open the URL printed in the terminal. The demo uses the same URL override as production QA, so it works without a PostHog account.
+
+More neutral examples are in [`examples/`](./examples).
+
+## Development
+
+```bash
+bun install
+bun run typecheck
+bun run test
+bun run build
+bun run check:package
+```
+
+Unit tests cover the execution contract. Playwright loads the shipped IIFE bundle in Chromium with an actual `posthog-js` client.
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for contribution guidance and [SECURITY.md](./SECURITY.md) for private vulnerability reporting.
+
+## License
+
+[MIT](./LICENSE) © 99Ways

package/dist/index.d.ts

@@ -0,0 +1,35 @@
+export type Awaitable<T> = T | PromiseLike<T>;
+export interface PostHogClient {
+    __loaded?: boolean;
+    getFeatureFlag(featureFlag: string): boolean | string | null | undefined;
+    onFeatureFlags(callback: () => void): (() => void) | void;
+}
+export type StyleUpdates = Record<string, string | number | null | undefined>;
+export interface ElementUpdates {
+    style?: StyleUpdates;
+    callback?: (element: HTMLElement, variant: string) => unknown;
+    innerText?: string;
+    innerHTML?: string;
+}
+export interface ElementChange {
+    selector: string;
+    updates: ElementUpdates;
+}
+export type VariantStep = ElementChange | (() => unknown);
+export type VariantHandler = VariantStep[] | (() => unknown);
+export interface ExperimentOptions {
+    variants: Record<string, VariantHandler>;
+    defaultVariant?: string;
+    isEligible?: () => Awaitable<boolean>;
+    posthog?: PostHogClient;
+    debug?: boolean;
+    featureFlagTimeoutMs?: number;
+}
+export type ExperimentResult = string | null;
+export declare function runExperiment(featureFlag: string, options: ExperimentOptions): Promise<ExperimentResult>;
+declare global {
+    interface Window {
+        posthog?: PostHogClient;
+        runExperiment: typeof runExperiment;
+    }
+}

package/dist/index.js

@@ -0,0 +1 @@
+class m{featureFlag;variants;defaultVariant;isEligible;explicitPostHog;debug;featureFlagTimeoutMs;runPromise=null;constructor(e,t){this.featureFlag=e;if(!e.trim())throw TypeError("featureFlag must be a non-empty string.");if(this.defaultVariant=t.defaultVariant??"control",this.variants=new Map(Object.entries(t.variants)),this.isEligible=t.isEligible??(()=>!0),this.explicitPostHog=t.posthog,this.debug=t.debug??!1,this.featureFlagTimeoutMs=t.featureFlagTimeoutMs??4000,!Number.isFinite(this.featureFlagTimeoutMs)||this.featureFlagTimeoutMs<0)throw RangeError("featureFlagTimeoutMs must be a finite number greater than or equal to 0.");if(!this.defaultVariant.trim())throw TypeError("defaultVariant must be a non-empty string.");if(!this.variants.has(this.defaultVariant))throw TypeError(`variants must include the default variant '${this.defaultVariant}'.`)}run(){if(!this.runPromise)this.runPromise=this.runOnce();return this.runPromise}async runOnce(){if(typeof window>"u"||typeof document>"u")return this.log("Browser globals are unavailable; skipping the experiment."),null;if(await this.waitForDOMContentLoaded(),this.log("Checking eligibility before evaluating the feature flag."),!await this.isEligible())return this.log("Visitor is ineligible; skipping feature-flag evaluation and variant application."),null;let e=await this.resolveVariant(),t=this.getConfiguredVariantOrDefault(e);return this.log(`Activated variant '${t}'.`),this.applyVariant(t),t}getVariantFromQueryParam(){return new URLSearchParams(window.location.search).get(this.featureFlag)}getPostHog(){let e=this.explicitPostHog??window.posthog;if(e&&e.__loaded===!0&&typeof e.onFeatureFlags==="function"&&typeof e.getFeatureFlag==="function")return e;return}resolveVariant(){let e=this.getVariantFromQueryParam();if(e)return this.log(`Using query-string override variant '${e}'.`),Promise.resolve(e);return this.log("Waiting for initialized PostHog and its first feature-flag notification."),new Promise((t)=>{let i=!1,n,a=!1,r,o,u=()=>{if(!n)return!1;let s=n;n=void 0;try{s()}catch(l){this.warn(`Could not unsubscribe from feature flag '${this.featureFlag}'.`,l)}return!0},d=()=>{if(r!==void 0)clearInterval(r);if(o!==void 0)clearTimeout(o);if(!u())a=!0},g=(s)=>{if(i)return;i=!0,d(),t(s)},p=()=>{if(i)return!0;let s=this.getPostHog();if(!s)return!1;if(r!==void 0)clearInterval(r),r=void 0;try{this.log("PostHog is initialized; subscribing to feature flags.");let l=s.onFeatureFlags(()=>{try{let f=this.getPostHog();if(!f)throw Error("The initialized PostHog instance is no longer available.");let h=f.getFeatureFlag(this.featureFlag),c=this.mapFeatureFlagValue(h);this.log(`PostHog resolved variant '${c}' from raw value ${JSON.stringify(h)}.`),g(c)}catch(f){this.warn(`Could not read feature flag '${this.featureFlag}'. Applying '${this.defaultVariant}'.`,f),g(this.defaultVariant)}});if(typeof l==="function")n=l;if(a)a=!1,u();return!0}catch(l){return this.warn(`Could not subscribe to feature flag '${this.featureFlag}'. Applying '${this.defaultVariant}'.`,l),g(this.defaultVariant),!0}};if(o=setTimeout(()=>{this.warn(`Feature flag '${this.featureFlag}' was not resolved within ${this.featureFlagTimeoutMs}ms. Applying '${this.defaultVariant}'.`),g(this.defaultVariant)},this.featureFlagTimeoutMs),!p())r=setInterval(p,50)})}mapFeatureFlagValue(e){if(e===!0)return"test";if(e===!1||e===null||e===void 0||e==="")return this.defaultVariant;return e}getConfiguredVariantOrDefault(e){if(this.variants.has(e))return e;return this.warn(`Variant '${e}' is not configured for '${this.featureFlag}'. Applying '${this.defaultVariant}'.`),this.defaultVariant}waitForDOMContentLoaded(){if(document.readyState!=="loading")return this.log("DOM is already ready; skipping the DOMContentLoaded wait."),Promise.resolve();return this.log("Waiting for DOMContentLoaded."),new Promise((e)=>{document.addEventListener("DOMContentLoaded",()=>{this.log("DOMContentLoaded received."),e()},{once:!0})})}applyVariant(e){let t=this.variants.get(e);if(!t)return;this.log(`Applying variant '${e}'.`),this.applyHandler(t,e),this.log(`Finished applying variant '${e}'.`)}applyHandler(e,t){if(typeof e==="function"){e();return}e.forEach((i)=>{if(typeof i==="function"){i();return}this.applyUpdates(i.selector,i.updates,t)})}applyUpdates(e,t,i){let n=document.querySelectorAll(e);if(!n.length){this.warn(`No elements found for selector '${e}'.`);return}this.log(`Selector '${e}' matched ${n.length} element(s).`),n.forEach((a)=>{if(t.style)Object.entries(t.style).forEach(([r,o])=>{if(o===null||o===void 0)return;let u=r.startsWith("--")?r:r.replace(/[A-Z]/g,(d)=>`-${d.toLowerCase()}`);a.style.setProperty(u,String(o),"important")});if(t.innerText!==void 0)a.innerText=t.innerText;if(t.innerHTML!==void 0)a.innerHTML=t.innerHTML;t.callback?.(a,i)})}log(e,...t){if(this.debug)console.log(`[Experiment:${this.featureFlag}] ${e}`,...t)}warn(e,...t){if(this.debug)console.warn(`[Experiment:${this.featureFlag}] ${e}`,...t)}}function y(e,t){return new m(e,t).run()}export{y as runExperiment};

package/dist/posthog-page-experiments.min.js

@@ -0,0 +1 @@
+(()=>{class m{featureFlag;variants;defaultVariant;isEligible;explicitPostHog;debug;featureFlagTimeoutMs;runPromise=null;constructor(e,t){this.featureFlag=e;if(!e.trim())throw TypeError("featureFlag must be a non-empty string.");if(this.defaultVariant=t.defaultVariant??"control",this.variants=new Map(Object.entries(t.variants)),this.isEligible=t.isEligible??(()=>!0),this.explicitPostHog=t.posthog,this.debug=t.debug??!1,this.featureFlagTimeoutMs=t.featureFlagTimeoutMs??4000,!Number.isFinite(this.featureFlagTimeoutMs)||this.featureFlagTimeoutMs<0)throw RangeError("featureFlagTimeoutMs must be a finite number greater than or equal to 0.");if(!this.defaultVariant.trim())throw TypeError("defaultVariant must be a non-empty string.");if(!this.variants.has(this.defaultVariant))throw TypeError(`variants must include the default variant '${this.defaultVariant}'.`)}run(){if(!this.runPromise)this.runPromise=this.runOnce();return this.runPromise}async runOnce(){if(typeof window>"u"||typeof document>"u")return this.log("Browser globals are unavailable; skipping the experiment."),null;if(await this.waitForDOMContentLoaded(),this.log("Checking eligibility before evaluating the feature flag."),!await this.isEligible())return this.log("Visitor is ineligible; skipping feature-flag evaluation and variant application."),null;let e=await this.resolveVariant(),t=this.getConfiguredVariantOrDefault(e);return this.log(`Activated variant '${t}'.`),this.applyVariant(t),t}getVariantFromQueryParam(){return new URLSearchParams(window.location.search).get(this.featureFlag)}getPostHog(){let e=this.explicitPostHog??window.posthog;if(e&&e.__loaded===!0&&typeof e.onFeatureFlags==="function"&&typeof e.getFeatureFlag==="function")return e;return}resolveVariant(){let e=this.getVariantFromQueryParam();if(e)return this.log(`Using query-string override variant '${e}'.`),Promise.resolve(e);return this.log("Waiting for initialized PostHog and its first feature-flag notification."),new Promise((t)=>{let i=!1,n,a=!1,r,o,u=()=>{if(!n)return!1;let s=n;n=void 0;try{s()}catch(l){this.warn(`Could not unsubscribe from feature flag '${this.featureFlag}'.`,l)}return!0},d=()=>{if(r!==void 0)clearInterval(r);if(o!==void 0)clearTimeout(o);if(!u())a=!0},g=(s)=>{if(i)return;i=!0,d(),t(s)},p=()=>{if(i)return!0;let s=this.getPostHog();if(!s)return!1;if(r!==void 0)clearInterval(r),r=void 0;try{this.log("PostHog is initialized; subscribing to feature flags.");let l=s.onFeatureFlags(()=>{try{let f=this.getPostHog();if(!f)throw Error("The initialized PostHog instance is no longer available.");let h=f.getFeatureFlag(this.featureFlag),c=this.mapFeatureFlagValue(h);this.log(`PostHog resolved variant '${c}' from raw value ${JSON.stringify(h)}.`),g(c)}catch(f){this.warn(`Could not read feature flag '${this.featureFlag}'. Applying '${this.defaultVariant}'.`,f),g(this.defaultVariant)}});if(typeof l==="function")n=l;if(a)a=!1,u();return!0}catch(l){return this.warn(`Could not subscribe to feature flag '${this.featureFlag}'. Applying '${this.defaultVariant}'.`,l),g(this.defaultVariant),!0}};if(o=setTimeout(()=>{this.warn(`Feature flag '${this.featureFlag}' was not resolved within ${this.featureFlagTimeoutMs}ms. Applying '${this.defaultVariant}'.`),g(this.defaultVariant)},this.featureFlagTimeoutMs),!p())r=setInterval(p,50)})}mapFeatureFlagValue(e){if(e===!0)return"test";if(e===!1||e===null||e===void 0||e==="")return this.defaultVariant;return e}getConfiguredVariantOrDefault(e){if(this.variants.has(e))return e;return this.warn(`Variant '${e}' is not configured for '${this.featureFlag}'. Applying '${this.defaultVariant}'.`),this.defaultVariant}waitForDOMContentLoaded(){if(document.readyState!=="loading")return this.log("DOM is already ready; skipping the DOMContentLoaded wait."),Promise.resolve();return this.log("Waiting for DOMContentLoaded."),new Promise((e)=>{document.addEventListener("DOMContentLoaded",()=>{this.log("DOMContentLoaded received."),e()},{once:!0})})}applyVariant(e){let t=this.variants.get(e);if(!t)return;this.log(`Applying variant '${e}'.`),this.applyHandler(t,e),this.log(`Finished applying variant '${e}'.`)}applyHandler(e,t){if(typeof e==="function"){e();return}e.forEach((i)=>{if(typeof i==="function"){i();return}this.applyUpdates(i.selector,i.updates,t)})}applyUpdates(e,t,i){let n=document.querySelectorAll(e);if(!n.length){this.warn(`No elements found for selector '${e}'.`);return}this.log(`Selector '${e}' matched ${n.length} element(s).`),n.forEach((a)=>{if(t.style)Object.entries(t.style).forEach(([r,o])=>{if(o===null||o===void 0)return;let u=r.startsWith("--")?r:r.replace(/[A-Z]/g,(d)=>`-${d.toLowerCase()}`);a.style.setProperty(u,String(o),"important")});if(t.innerText!==void 0)a.innerText=t.innerText;if(t.innerHTML!==void 0)a.innerHTML=t.innerHTML;t.callback?.(a,i)})}log(e,...t){if(this.debug)console.log(`[Experiment:${this.featureFlag}] ${e}`,...t)}warn(e,...t){if(this.debug)console.warn(`[Experiment:${this.featureFlag}] ${e}`,...t)}}function y(e,t){return new m(e,t).run()}if(typeof window<"u")window.runExperiment=y;})();

package/package.json

@@ -0,0 +1,73 @@
+{
+  "name": "@99ways/posthog-page-experiments",
+  "version": "0.1.0",
+  "description": "Code-first page experiments for PostHog with eligibility checks, URL QA overrides, and safe fallbacks.",
+  "type": "module",
+  "license": "MIT",
+  "author": "99Ways",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/99ways-io/posthog-page-experiments.git"
+  },
+  "bugs": {
+    "url": "https://github.com/99ways-io/posthog-page-experiments/issues"
+  },
+  "homepage": "https://github.com/99ways-io/posthog-page-experiments#readme",
+  "keywords": [
+    "posthog",
+    "ab-testing",
+    "experimentation",
+    "feature-flags",
+    "cro",
+    "growth-engineering",
+    "javascript",
+    "typescript"
+  ],
+  "files": [
+    "dist",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./browser": "./dist/posthog-page-experiments.min.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "unpkg": "./dist/posthog-page-experiments.min.js",
+  "jsdelivr": "./dist/posthog-page-experiments.min.js",
+  "sideEffects": [
+    "./dist/posthog-page-experiments.min.js"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "packageManager": "bun@1.4.2",
+  "scripts": {
+    "clean": "bun -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\"",
+    "build": "bun run clean && bun run build:module && bun run build:browser && bun run build:types",
+    "build:module": "bun build ./src/index.ts --outfile ./dist/index.js --format esm --target browser --minify",
+    "build:browser": "bun build ./src/browser.ts --outfile ./dist/posthog-page-experiments.min.js --format iife --target browser --minify",
+    "build:types": "tsc -p tsconfig.build.json",
+    "build:test-fixture": "bun build ./tests/fixtures/posthog.ts --outfile ./tests/fixtures/posthog.bundle.js --format iife --target browser",
+    "typecheck": "tsc --noEmit",
+    "test": "bun run test:unit && bun run test:browser",
+    "test:unit": "bun test ./src/index.test.ts",
+    "test:browser": "bun run build && bun run build:test-fixture && playwright test",
+    "check:package": "npm pack --dry-run && publint",
+    "demo": "bun run build && bun ./scripts/serve-demo.ts"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.63.0",
+    "@types/bun": "^1.4.2",
+    "posthog-js": "^1.433.9",
+    "publint": "^0.3.24",
+    "typescript": "^7.0.2"
+  }
+}