@pmate/log-sdk 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,55 @@
-# Temporary Holding Version
+# @pmate/log-sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+## Background
+PMate logs need to connect anonymous page visits, signed-in Profiles and backend requests without merging different Profiles of one Account. This SDK adds access/profile context to the existing topic log protocol. It reuses `@pmate/log` for browser delivery and supports the same ingest protocol or a trusted Store sink on Node.
+
+## Identity
+`accessId` is a random tab visit ID. Reload/history restore reuses sessionStorage; a new document navigation starts a visit (including new/duplicated tabs). An SPA route change retains it. After 30 minutes without interaction, the next interaction or explicit event starts another visit. Storage failures fall back to memory. Background vitals do not extend the visit. This is not a persistent visitor ID.
+
+`profileId` is optional and scoped by `appId`. Logging in keeps accessId, logout clears profileId, and queued events retain their original identity. No Account-level identity merging occurs. Browser identity is client-reported; Node identity must come from verified server authentication. Neither accessId nor telemetry is an authorization proof.
+
+## React
+```tsx
+import { LogProvider, useLog } from '@pmate/log-sdk/react'
+const options = {
+  appId: 'pmate:hello', serviceId: 'pmate:hello', environment: 'prod',
+  endpoint: 'https://log-api.pmate.chat', key: 'REGISTERED_PUBLIC_INTAKE_KEY',
+  apiOrigins: ['https://api.example.com'],
+}
+function App({ profileId }) {
+  return <LogProvider options={options} profileId={profileId}><Content /></LogProvider>
+}
+function Content() {
+  const log = useLog()
+  return <button onClick={() => log.append('application', {data:{event:'feature.opened'}})}>Open</button>
+}
+```
+Keep provider options stable. Initialization happens after mount, is SSR-safe, and suppresses React StrictMode's discarded initialization. Automatic PV/vitals/errors retain the existing browser SDK behavior. `beforeSend` can redact application-specific paths or drop an event. Never include credentials or request/response bodies.
+
+## Browser
+```ts
+import { createLogger } from '@pmate/log-sdk/browser'
+const log = createLogger(options)
+log.setProfileId(selectedProfileId) // null on logout
+await log.fetch('https://api.example.com/resource')
+await log.close()
+```
+`log.fetch` adds `x-pmate-access-id` and `x-request-id` only to explicitly allowed API origins. It also sends `x-pmate-profile-id` when a profile is selected; this is an untrusted selection claim, not authentication. The server must verify the selected profile belongs to the authenticated account and expected App before passing it to Node context. It refuses redirects on those requests. APIs must allow these headers in CORS. Global fetch is never patched. Only the wrapped requests carry correlation.
+
+## Node
+```ts
+import { createLogger } from '@pmate/log-sdk/node'
+const log = createLogger({
+  appId: 'pmate:hello', serviceId: 'pmate:hello-api', environment: 'prod',
+  endpoint: 'https://log-api.pmate.chat', token: process.env.LOG_INGEST_TOKEN,
+})
+await log.withRequest(request, {profileId: authenticatedProfile?.id}, async scope => {
+  log.append('application', {data:{event:'http.request', requestId:scope.requestId}})
+  // business work; report completion/error without raw bodies
+})
+await log.close()
+```
+Use authenticatedProfile from server authentication, never a client body/header. AsyncLocalStorage isolates concurrent requests and anonymous requests clear inherited identity. Alternatively provide `sink(batch, signal)` backed by existing `@pmate/store`; the sink must preserve item IDs/time, respect cancellation and report acceptance. The queue is bounded, attempts at most three times with the original event ID, reports failures without payloads, and does not block business work. `close()` stops admission and drains outstanding events; telemetry is best effort.
+
+## Counting
+The envelope `id` is the event deduplication key. PV counts pv events; sessions deduplicate `(appId, accessId)`; Profile UV deduplicates `(appId, profileId)` in a defined time window/topic. Missing identifiers are reported separately. Never count HTTP requests or vitals as page views, or infer first-ever visits from a limited retention window.

package/dist/access.d.ts

@@ -0,0 +1,11 @@
+export declare const ACCESS_IDLE_MS: number;
+export declare function createAccessSession(options: {
+    appId: string;
+    storage?: Pick<Storage, "getItem" | "setItem">;
+    now?: () => number;
+    randomId?: () => string;
+    fresh?: boolean;
+}): {
+    snapshot: () => string;
+    touch(): string;
+};

package/dist/access.js

@@ -0,0 +1,32 @@
+import { validId } from "./shared.js";
+export const ACCESS_IDLE_MS = 30 * 60 * 1000;
+export function createAccessSession(options) {
+    const now = options.now ?? Date.now, randomId = options.randomId ?? (() => crypto.randomUUID());
+    const key = `pmate.log.access.v1:${options.appId}`;
+    let session;
+    if (!options.fresh)
+        try {
+            const stored = JSON.parse(options.storage?.getItem(key) ?? "null");
+            if (validId(stored?.id) && Number.isSafeInteger(stored?.lastActivity) && stored.lastActivity <= now() && now() - stored.lastActivity < ACCESS_IDLE_MS)
+                session = stored;
+        }
+        catch { /* Storage may be disabled or corrupt. */ }
+    session ??= { id: randomId(), lastActivity: now() };
+    const save = () => { try {
+        options.storage?.setItem(key, JSON.stringify(session));
+    }
+    catch { /* In-memory session remains usable. */ } };
+    save();
+    return {
+        snapshot: () => session.id,
+        touch() {
+            const time = now();
+            if (time - session.lastActivity >= ACCESS_IDLE_MS || time < session.lastActivity)
+                session = { id: randomId(), lastActivity: time };
+            else
+                session.lastActivity = time;
+            save();
+            return session.id;
+        },
+    };
+}

package/dist/browser.d.ts

@@ -0,0 +1,18 @@
+import { type BrowserLogOptions } from "@pmate/log";
+import { type LogContext, type LogInput } from "./shared.js";
+export type BrowserLoggerOptions = BrowserLogOptions & {
+    appId: string;
+    profileId?: string | null;
+    apiOrigins?: string[];
+};
+export type BrowserLogger = ReturnType<typeof createLogger>;
+/** Own one instance per application document. Server imports never touch window. */
+export declare function createLogger(options: BrowserLoggerOptions): {
+    getContext: () => LogContext;
+    setProfileId(value?: string | null): void;
+    append(topic: string, input: LogInput | string): void;
+    /** Explicit request wrapper: never patches global fetch or decorates unlisted origins. */
+    fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+    flush: () => Promise<void>;
+    close(): Promise<void>;
+};

package/dist/browser.js

@@ -0,0 +1,105 @@
+import { createLogger as createTransport } from "@pmate/log";
+import { createAccessSession } from "./access.js";
+import { ACCESS_HEADER, PROFILE_HEADER, REQUEST_HEADER, validId, validateAppId, withContext } from "./shared.js";
+/** Own one instance per application document. Server imports never touch window. */
+export function createLogger(options) {
+    if (typeof window === "undefined")
+        throw Error("Browser logger requires a browser");
+    validateAppId(options.appId);
+    if (options.profileId != null && !validId(options.profileId))
+        throw Error("Invalid profileId");
+    let storage;
+    try {
+        storage = window.sessionStorage;
+    }
+    catch { /* Private browsing fallback. */ }
+    const navigation = performance.getEntriesByType?.("navigation")[0];
+    // New documents reached by navigation (including cloned tabs) start a visit;
+    // reload and history restoration may reuse the tab's stored visit.
+    const access = createAccessSession({ appId: options.appId, storage, fresh: navigation?.type === "navigate" });
+    let profileId = options.profileId ?? undefined, closed = false;
+    const context = () => ({ appId: options.appId, accessId: access.snapshot(), ...(profileId ? { profileId } : {}), identitySource: "browser" });
+    const views = new Map();
+    const origins = new Set((options.apiOrigins ?? []).map(value => {
+        const url = new URL(value);
+        if (url.origin !== value || url.username || url.password)
+            throw Error("apiOrigins must contain exact origins");
+        return value;
+    }));
+    const touch = () => { if (!closed)
+        access.touch(); };
+    const events = ["pointerdown", "keydown", "scroll", "touchstart"];
+    for (const event of events)
+        window.addEventListener(event, touch, { passive: true });
+    let transport;
+    try {
+        transport = createTransport({ ...options, beforeSend(topic, input) {
+                if (topic === "pv")
+                    access.touch();
+                const viewId = input.data?.pageViewId;
+                let captured = context();
+                if (topic === "pv" && typeof viewId === "string") {
+                    views.set(viewId, captured);
+                    if (views.size > 256)
+                        views.delete(views.keys().next().value);
+                }
+                else if (topic === "vitals" && typeof viewId === "string") {
+                    // Delayed document metrics retain the identity of their original visit.
+                    const original = views.get(viewId);
+                    if (original)
+                        captured = original;
+                    else
+                        captured = { appId: options.appId, identitySource: "browser" };
+                }
+                const decorated = withContext(input, captured);
+                return options.beforeSend ? options.beforeSend(topic, decorated) : decorated;
+            } });
+    }
+    catch (error) {
+        for (const event of events)
+            window.removeEventListener(event, touch);
+        throw error;
+    }
+    return {
+        getContext: context,
+        setProfileId(value) {
+            if (closed)
+                return;
+            if (value != null && !validId(value))
+                throw Error("Invalid profileId");
+            const next = value ?? undefined;
+            if (next === profileId)
+                return;
+            profileId = next;
+            access.touch();
+            transport.append("application", { data: { event: next ? "identity.identified" : "identity.cleared" } });
+        },
+        append(topic, input) { if (!closed) {
+            access.touch();
+            transport.append(topic, input);
+        } },
+        /** Explicit request wrapper: never patches global fetch or decorates unlisted origins. */
+        fetch(input, init) {
+            const url = new URL(input instanceof Request ? input.url : String(input), location.href);
+            if (!closed && origins.has(url.origin)) {
+                access.touch();
+                const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+                headers.set(ACCESS_HEADER, access.snapshot());
+                // Selection only: servers must verify ownership before using this identity.
+                if (profileId)
+                    headers.set(PROFILE_HEADER, profileId);
+                else
+                    headers.delete(PROFILE_HEADER);
+                if (!validId(headers.get(REQUEST_HEADER)))
+                    headers.set(REQUEST_HEADER, crypto.randomUUID());
+                // Refuse redirects so correlation headers cannot leak to another origin.
+                return fetch(input, { ...init, headers, redirect: "error" });
+            }
+            return fetch(input, init);
+        },
+        flush: transport.flush,
+        async close() { if (closed)
+            return; closed = true; for (const event of events)
+            window.removeEventListener(event, touch); await transport.close(); },
+    };
+}

package/dist/node.d.ts

@@ -0,0 +1,32 @@
+import { type LogContext, type LogEntry, type LogInput } from "./shared.js";
+export type LogBatch = {
+    serviceId: string;
+    environment: string;
+    topic: string;
+    items: LogEntry[];
+};
+export type NodeLoggerOptions = {
+    appId: string;
+    serviceId: string;
+    environment: string;
+    endpoint?: string;
+    token?: string;
+    /** A trusted sink may use @pmate/store appendMany; retain each entry's id/time. */
+    sink?: (batch: LogBatch, signal: AbortSignal) => Promise<void>;
+    maxQueue?: number;
+    flushIntervalMs?: number;
+    onWarning?: (event: {
+        code: "log_dropped" | "log_send_failed";
+        count: number;
+    }) => void;
+};
+export declare function createLogger(options: NodeLoggerOptions): {
+    getContext: () => LogContext;
+    /** verifiedProfile comes from server authentication, never request headers/body. */
+    withRequest<T>(request: Request, verifiedProfile: {
+        profileId?: string | null;
+    }, run: (scope: LogContext) => T): T;
+    append(topic: string, input: LogInput | string): void;
+    flush: () => Promise<void>;
+    close(): Promise<void>;
+};

package/dist/node.js

@@ -0,0 +1,128 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { ACCESS_HEADER, REQUEST_HEADER, redact, validId, validateAppId, withContext } from "./shared.js";
+export function createLogger(options) {
+    validateAppId(options.appId);
+    if (!/^[a-z0-9][a-z0-9-]*:[a-z0-9][a-z0-9_-]*$/.test(options.serviceId) || !/^[a-zA-Z0-9_.:-]{1,64}$/.test(options.environment))
+        throw Error("Invalid service or environment");
+    const endpoint = options.endpoint ? new URL(options.endpoint) : undefined;
+    if (endpoint && (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && ["localhost", "127.0.0.1"].includes(endpoint.hostname)))))
+        throw Error("Invalid log endpoint");
+    if (!options.sink && (!endpoint || !options.token))
+        throw Error("Provide a log ingest endpoint/token or a sink");
+    const warn = (code, count) => { try {
+        (options.onWarning ?? (event => console.warn(JSON.stringify(event))))({ code, count });
+    }
+    catch { /* Warnings cannot interrupt work. */ } };
+    const context = new AsyncLocalStorage();
+    const anonymous = { appId: options.appId, identitySource: "anonymous" };
+    const queue = [];
+    const maxQueue = Number.isFinite(options.maxQueue) ? Math.max(1, Math.min(1000, Math.floor(options.maxQueue))) : 200;
+    let closing = false, stalled = false, pending;
+    const sink = options.sink ?? (async (batch, signal) => {
+        const response = await fetch(`${endpoint.href.replace(/\/$/, "")}/logs/batch`, { method: "POST", redirect: "error", signal,
+            headers: { "content-type": "application/json", authorization: `Bearer ${options.token}` }, body: JSON.stringify(batch) });
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw Object.assign(Error("Log ingest failed"), { retryable: response.status >= 500 || [408, 429].includes(response.status) });
+        }
+        const result = await response.json();
+        if (result?.success !== true || result?.data?.accepted !== batch.items.length)
+            throw Error("Log ingest incomplete");
+    });
+    const flush = () => {
+        if (pending)
+            return pending;
+        if (stalled)
+            return Promise.resolve();
+        pending = (async () => {
+            // Snapshot admission budget so a busy process cannot make flush endless.
+            let budget = queue.length * 3;
+            while (queue.length && budget > 0) {
+                const topic = queue[0].topic;
+                const selected = [];
+                let bytes = 512;
+                for (const item of queue) {
+                    if (item.topic !== topic || selected.length >= 50 || bytes + item.bytes > 48000)
+                        continue;
+                    selected.push(item);
+                    bytes += item.bytes;
+                }
+                for (const item of selected) {
+                    queue.splice(queue.indexOf(item), 1);
+                    item.attempts++;
+                }
+                budget -= selected.length;
+                const controller = new AbortController();
+                let timeout;
+                const writing = Promise.resolve().then(() => sink({ serviceId: options.serviceId, environment: options.environment, topic, items: selected.map(item => item.entry) }, controller.signal));
+                void writing.then(() => { stalled = false; }, () => { stalled = false; });
+                try {
+                    await Promise.race([writing, new Promise((_, reject) => {
+                            timeout = setTimeout(() => { stalled = true; controller.abort(); reject(Error("Log sink timed out")); }, 8000);
+                        })]);
+                }
+                catch (error) {
+                    warn("log_send_failed", selected.length);
+                    for (const item of selected) {
+                        if (!stalled && error?.retryable !== false && item.attempts < 3 && queue.length < maxQueue)
+                            queue.push(item);
+                        else
+                            warn("log_dropped", 1);
+                    }
+                }
+                finally {
+                    clearTimeout(timeout);
+                }
+                if (stalled)
+                    break;
+            }
+        })().finally(() => { pending = undefined; });
+        return pending;
+    };
+    const timer = setInterval(() => { void flush(); }, Math.max(1000, options.flushIntervalMs ?? 5000));
+    timer.unref();
+    return {
+        getContext: () => context.getStore() ?? anonymous,
+        /** verifiedProfile comes from server authentication, never request headers/body. */
+        withRequest(request, verifiedProfile, run) {
+            if (verifiedProfile.profileId != null && !validId(verifiedProfile.profileId))
+                throw Error("Invalid verified profileId");
+            const accessId = request.headers.get(ACCESS_HEADER), requestId = request.headers.get(REQUEST_HEADER);
+            const scope = { appId: options.appId, ...(validId(accessId) ? { accessId } : {}),
+                ...(verifiedProfile.profileId ? { profileId: verifiedProfile.profileId } : {}),
+                requestId: validId(requestId) ? requestId : randomUUID(), identitySource: verifiedProfile.profileId ? "authenticated" : "anonymous" };
+            return context.run(scope, () => run(scope));
+        },
+        append(topic, input) {
+            if (closing)
+                return;
+            if (!/^[a-z][a-z0-9-]{0,31}$/.test(topic))
+                throw Error("Invalid topic");
+            try {
+                const value = withContext(input, context.getStore() ?? anonymous);
+                const entry = { id: randomUUID(), time: value.time ?? Date.now(),
+                    ...(value.content !== undefined ? { content: redact(value.content) } : {}), data: redact(value.data) };
+                const bytes = new TextEncoder().encode(JSON.stringify(entry)).length;
+                if (!Number.isSafeInteger(entry.time) || entry.time < 0 || bytes > 32000) {
+                    warn("log_dropped", 1);
+                    return;
+                }
+                if (queue.length >= maxQueue) {
+                    queue.shift();
+                    warn("log_dropped", 1);
+                }
+                queue.push({ topic, entry, bytes, attempts: 0 });
+            }
+            catch {
+                warn("log_dropped", 1);
+            }
+        },
+        flush,
+        async close() { closing = true; clearInterval(timer); await flush(); if (queue.length && !stalled)
+            await flush(); if (queue.length) {
+            warn("log_dropped", queue.length);
+            queue.length = 0;
+        } },
+    };
+}

package/dist/react.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from "react";
+import { type BrowserLogger, type BrowserLoggerOptions } from "./browser.js";
+export type ReactLogger = Pick<BrowserLogger, "append" | "fetch" | "flush">;
+/** Keep options stable for the Provider's lifetime. Update identity through profileId. */
+export declare function LogProvider({ options, profileId, children }: {
+    options: Omit<BrowserLoggerOptions, "profileId">;
+    profileId?: string | null;
+    children: ReactNode;
+}): import("react").FunctionComponentElement<import("react").ProviderProps<ReactLogger | null>>;
+export declare function useLog(): ReactLogger;

package/dist/react.js

@@ -0,0 +1,80 @@
+import { createContext, createElement, useContext, useEffect, useMemo, useRef } from "react";
+import { createLogger } from "./browser.js";
+const Context = createContext(null);
+/** Keep options stable for the Provider's lifetime. Update identity through profileId. */
+export function LogProvider({ options, profileId, children }) {
+    const initial = useRef(options);
+    const identity = useRef(profileId);
+    const logger = useRef(undefined);
+    const generation = useRef(0);
+    const ready = useMemo(() => {
+        let resolve;
+        const promise = new Promise(done => { resolve = done; });
+        return { promise, resolve };
+    }, []);
+    const buffered = useRef([]);
+    identity.current = profileId;
+    const value = useMemo(() => ({
+        append(topic, input) {
+            if (logger.current) {
+                logger.current.setProfileId(identity.current);
+                logger.current.append(topic, input);
+            }
+            else {
+                if (buffered.current.length >= 200)
+                    buffered.current.shift();
+                buffered.current.push({ topic, input, profileId: identity.current });
+            }
+        },
+        async fetch(input, init) {
+            const instance = logger.current ?? await ready.promise;
+            instance?.setProfileId(identity.current);
+            return instance ? instance.fetch(input, init) : fetch(input, init);
+        },
+        flush() { return logger.current?.flush() ?? Promise.resolve(); },
+    }), []);
+    useEffect(() => {
+        const current = ++generation.current;
+        // StrictMode's first setup is cleaned up before this microtask. Only the
+        // committed mount installs browser observers and emits the initial PV.
+        queueMicrotask(() => {
+            if (generation.current !== current)
+                return;
+            let instance;
+            try {
+                instance = createLogger({ ...initial.current, profileId: identity.current });
+            }
+            catch {
+                buffered.current.length = 0;
+                ready.resolve(undefined);
+                console.warn("PMate telemetry initialization failed");
+                return;
+            }
+            logger.current = instance;
+            ready.resolve(instance);
+            for (const item of buffered.current.splice(0)) {
+                instance.setProfileId(item.profileId);
+                instance.append(item.topic, item.input);
+            }
+            instance.setProfileId(identity.current);
+        });
+        return () => {
+            generation.current++;
+            const instance = logger.current;
+            logger.current = undefined;
+            if (instance)
+                void instance.close();
+            const disposed = generation.current;
+            queueMicrotask(() => { if (generation.current === disposed)
+                ready.resolve(undefined); });
+        };
+    }, []);
+    useEffect(() => { logger.current?.setProfileId(profileId); }, [profileId]);
+    return createElement(Context.Provider, { value }, children);
+}
+export function useLog() {
+    const logger = useContext(Context);
+    if (!logger)
+        throw Error("useLog requires LogProvider");
+    return logger;
+}

package/dist/shared.d.ts

@@ -0,0 +1,24 @@
+export declare const SCHEMA_VERSION = 1;
+export declare const ACCESS_HEADER = "x-pmate-access-id";
+export declare const PROFILE_HEADER = "x-pmate-profile-id";
+export declare const REQUEST_HEADER = "x-request-id";
+export type LogContext = {
+    appId: string;
+    accessId?: string;
+    profileId?: string;
+    requestId?: string;
+    identitySource: "browser" | "authenticated" | "anonymous";
+};
+export type LogInput = {
+    time?: number;
+    content?: string;
+    data?: Record<string, unknown>;
+};
+export type LogEntry = LogInput & {
+    id: string;
+    time: number;
+};
+export declare const validId: (value: unknown) => value is string;
+export declare function validateAppId(appId: string): void;
+export declare function withContext(input: LogInput | string, context: LogContext): LogInput;
+export declare function redact(value: unknown, depth?: number, seen?: WeakSet<object>): unknown;

package/dist/shared.js

@@ -0,0 +1,30 @@
+export const SCHEMA_VERSION = 1;
+export const ACCESS_HEADER = "x-pmate-access-id";
+export const PROFILE_HEADER = "x-pmate-profile-id";
+export const REQUEST_HEADER = "x-request-id";
+export const validId = (value) => typeof value === "string" && /^[a-zA-Z0-9_.:@-]{1,128}$/.test(value);
+export function validateAppId(appId) {
+    if (!/^[a-zA-Z0-9_.@-]+:[a-zA-Z0-9_.-]+$/.test(appId))
+        throw Error("Invalid appId");
+}
+export function withContext(input, context) {
+    const value = typeof input === "string" ? { content: input } : input;
+    // Reserved identity fields cannot be supplied by an individual event.
+    const { appId: _app, accessId: _access, profileId: _profile, requestId: _request, identitySource: _source, ...data } = value.data ?? {};
+    return { ...value, data: { ...data, ...context, contextVersion: SCHEMA_VERSION } };
+}
+const sensitive = /^(authorization|cookie|setcookie|password|secret|token|accesstoken|refreshtoken|accesskey|apikey|privatekey|requestbody|responsebody)$/i;
+export function redact(value, depth = 0, seen = new WeakSet()) {
+    if (typeof value === "string")
+        return value.slice(0, 4000).replace(/\bBearer\s+[^\s,;]+/gi, "Bearer [redacted]");
+    if (value === null || typeof value === "boolean" || typeof value === "number")
+        return value;
+    if (typeof value !== "object")
+        return String(value);
+    if (depth >= 6 || seen.has(value))
+        return "[truncated]";
+    seen.add(value);
+    if (Array.isArray(value))
+        return value.slice(0, 50).map(item => redact(item, depth + 1, seen));
+    return Object.fromEntries(Object.entries(value).slice(0, 100).filter(([key]) => !sensitive.test(key.replace(/[_-]/g, ""))).map(([key, item]) => [key, redact(item, depth + 1, seen)]));
+}

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "@pmate/log-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "PMate browser, React and Node logs with access and profile context",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    }
+  },
+  "dependencies": {
+    "@pmate/log": "0.1.2"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "jsdom": "^26.1.0",
+    "react": "^19.1.1",
+    "react-dom": "^19.1.1",
+    "typescript": "^5.8.3",
+    "vitest": "^4.0.17",
+    "web-vitals": "^5.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
 }