@knowledgefutures/sdk 0.1.0 → 0.2.1

package/dist/analytics/envelope.d.ts

@@ -1,135 +0,0 @@
-/**
- * The event format: what a client sends (a hint), the checks it must pass,
- * and the fixed row it becomes in the shared `kf.events` table. The SDK and
- * the `kf/analytics` collector both import this file, so the format has
- * exactly one definition.
- *
- * Ported from the mitp-oecs collector (schema 1). Schema 2 adds `site`,
- * `environment`, `source` and `scope`, lets any lowercase word be a subject
- * type, and lets a server event say where its reader was.
- *
- * The rule the format exists for: what can be read off the request is
- * derived by the collector and never taken from a browser. A beacon cannot
- * name its project, its time, its country or its device. Only `referrer`
- * is necessarily client-declared (a beacon's own Referer header is the page
- * it was sent from, not where the reader came from), so `referrer_host` and
- * `is_unique` are the two fields a determined client can move.
- */
-export declare const SCHEMA = 2;
-export declare const KINDS: readonly ["view", "download", "search", "custom"];
-export type Kind = (typeof KINDS)[number];
-/**
- * `beacon`: a browser, attributed by its Origin or a public site key —
- * plausible, never proven. `server`: the project's own server, signed with
- * its secret.
- */
-export type Source = 'beacon' | 'server';
-export declare const UTM_KEYS: readonly ["source", "medium", "campaign", "term", "content"];
-export type UtmKey = (typeof UTM_KEYS)[number];
-/** What a page or a server sends. Everything is optional except `kind`. */
-export interface Hint {
-    kind: Kind;
-    /** `<type>:<id>`, e.g. `pub:za65x7nh`. The type is a lowercase word of the project's choosing. */
-    subject?: string;
-    /** A stable identifier for the subject, usually a DOI URL. */
-    subjectUri?: string;
-    path?: string;
-    /** Where the reader came from: `document.referrer`, not the current page. */
-    referrer?: string;
-    /** The download format, the search query, or a custom event's name. Required for `custom`. */
-    name?: string;
-    /** The project's own tenant, e.g. a PubPub community id. */
-    scope?: string;
-    /** Project-specific detail: at most 16 string values. */
-    props?: Record<string, string>;
-    utm?: Partial<Record<UtmKey, string>>;
-}
-/**
- * A server event may also say where its reader was: the Worker that served a
- * PDF knows the reader's country and user agent, and the collector, which
- * only sees the project's server, does not.
- */
-export interface ServerHint extends Hint {
-    hostname?: string;
-    country?: string;
-    userAgent?: string;
-}
-/** One row of `kf.events`. Column order is `FIELDS` order. */
-export interface EventRow {
-    schema: number;
-    site: string;
-    project: string;
-    environment: string;
-    source: Source;
-    ts: string;
-    day: string;
-    kind: Kind;
-    subject_type: string | null;
-    subject_id: string | null;
-    subject_uri: string | null;
-    path: string | null;
-    hostname: string | null;
-    country: string | null;
-    device: Device;
-    referrer_host: string | null;
-    is_unique: boolean;
-    utm_source: string | null;
-    utm_medium: string | null;
-    utm_campaign: string | null;
-    utm_term: string | null;
-    utm_content: string | null;
-    name: string | null;
-    scope: string | null;
-    props: Record<string, string>;
-}
-export type Device = 'bot' | 'tablet' | 'mobile' | 'desktop' | 'unknown';
-/**
- * The Cloudflare Pipelines stream schema, generated from here rather than
- * kept beside it: `wrangler pipelines streams create --schema-file`.
- */
-export declare const FIELDS: ReadonlyArray<{
-    name: keyof EventRow;
-    type: 'int32' | 'string' | 'timestamp' | 'bool' | 'json';
-    required: boolean;
-}>;
-/**
- * Caps. A hint is a few hundred bytes; anything near these is abuse or a bug.
- * Over-long values of the right type are truncated; the wrong type is a 422.
- */
-export declare const LIMITS: {
-    /** Characters of request body. */
-    readonly body: 4096;
-    readonly props: 16;
-    readonly propKey: 40;
-    readonly propValue: 200;
-    readonly subjectId: 64;
-    readonly scope: 64;
-    /** `subjectUri` and `referrer`. */
-    readonly uri: 500;
-    readonly path: 300;
-    /** `name`, each `utm_*`, a server hint's `hostname` and `userAgent`. */
-    readonly text: 200;
-};
-/**
- * Why a hint is refused, in words a developer can act on, or null when it is
- * fine. Unknown top-level keys are refused: that is what keeps one table
- * combinable across every project. Project detail goes in `props`.
- */
-export declare function validateHint(hint: unknown, source: Source): string | null;
-/** What the collector knows from the request and its site registry, never from the hint. */
-export interface RowContext {
-    site: string;
-    project: string;
-    environment: string;
-    source: Source;
-    /** A beacon's page host (from its Origin). For a server event, the hint's `hostname` wins. */
-    hostname: string | null;
-    /** `request.cf.country`. For a server event, the hint's `country` wins. */
-    country: string | null;
-    /** For a server event, the hint's `userAgent` wins. */
-    userAgent: string;
-    now: Date;
-}
-/** The row a hint becomes. Call `validateHint` first; this trusts its input's types. */
-export declare function buildRow(hint: Hint | ServerHint, ctx: RowContext): EventRow;
-export declare function device(userAgent: string): Device;

package/dist/analytics/envelope.js

@@ -1,231 +0,0 @@
-/**
- * The event format: what a client sends (a hint), the checks it must pass,
- * and the fixed row it becomes in the shared `kf.events` table. The SDK and
- * the `kf/analytics` collector both import this file, so the format has
- * exactly one definition.
- *
- * Ported from the mitp-oecs collector (schema 1). Schema 2 adds `site`,
- * `environment`, `source` and `scope`, lets any lowercase word be a subject
- * type, and lets a server event say where its reader was.
- *
- * The rule the format exists for: what can be read off the request is
- * derived by the collector and never taken from a browser. A beacon cannot
- * name its project, its time, its country or its device. Only `referrer`
- * is necessarily client-declared (a beacon's own Referer header is the page
- * it was sent from, not where the reader came from), so `referrer_host` and
- * `is_unique` are the two fields a determined client can move.
- */
-export const SCHEMA = 2;
-export const KINDS = ['view', 'download', 'search', 'custom'];
-export const UTM_KEYS = ['source', 'medium', 'campaign', 'term', 'content'];
-/**
- * The Cloudflare Pipelines stream schema, generated from here rather than
- * kept beside it: `wrangler pipelines streams create --schema-file`.
- */
-export const FIELDS = [
-    { name: 'schema', type: 'int32', required: true },
-    { name: 'site', type: 'string', required: true },
-    { name: 'project', type: 'string', required: true },
-    { name: 'environment', type: 'string', required: true },
-    { name: 'source', type: 'string', required: true },
-    { name: 'ts', type: 'timestamp', required: true },
-    { name: 'day', type: 'string', required: true },
-    { name: 'kind', type: 'string', required: true },
-    { name: 'subject_type', type: 'string', required: false },
-    { name: 'subject_id', type: 'string', required: false },
-    { name: 'subject_uri', type: 'string', required: false },
-    { name: 'path', type: 'string', required: false },
-    { name: 'hostname', type: 'string', required: false },
-    { name: 'country', type: 'string', required: false },
-    { name: 'device', type: 'string', required: true },
-    { name: 'referrer_host', type: 'string', required: false },
-    { name: 'is_unique', type: 'bool', required: true },
-    { name: 'utm_source', type: 'string', required: false },
-    { name: 'utm_medium', type: 'string', required: false },
-    { name: 'utm_campaign', type: 'string', required: false },
-    { name: 'utm_term', type: 'string', required: false },
-    { name: 'utm_content', type: 'string', required: false },
-    { name: 'name', type: 'string', required: false },
-    { name: 'scope', type: 'string', required: false },
-    { name: 'props', type: 'json', required: false },
-];
-/**
- * Caps. A hint is a few hundred bytes; anything near these is abuse or a bug.
- * Over-long values of the right type are truncated; the wrong type is a 422.
- */
-export const LIMITS = {
-    /** Characters of request body. */
-    body: 4096,
-    props: 16,
-    propKey: 40,
-    propValue: 200,
-    subjectId: 64,
-    scope: 64,
-    /** `subjectUri` and `referrer`. */
-    uri: 500,
-    path: 300,
-    /** `name`, each `utm_*`, a server hint's `hostname` and `userAgent`. */
-    text: 200,
-};
-const SUBJECT_TYPE = /^[a-z][a-z0-9-]{0,31}$/;
-const COUNTRY = /^[A-Z]{2}$/;
-const CLIENT_KEYS = new Set([
-    'kind',
-    'subject',
-    'subjectUri',
-    'path',
-    'referrer',
-    'name',
-    'scope',
-    'props',
-    'utm',
-]);
-const SERVER_KEYS = new Set([
-    ...CLIENT_KEYS,
-    'hostname',
-    'country',
-    'userAgent',
-]);
-const OPTIONAL_STRINGS = ['subject', 'subjectUri', 'path', 'referrer', 'name', 'scope'];
-/**
- * Why a hint is refused, in words a developer can act on, or null when it is
- * fine. Unknown top-level keys are refused: that is what keeps one table
- * combinable across every project. Project detail goes in `props`.
- */
-export function validateHint(hint, source) {
-    if (!hint || typeof hint !== 'object' || Array.isArray(hint))
-        return 'body must be an object';
-    const h = hint;
-    const allowed = source === 'server' ? SERVER_KEYS : CLIENT_KEYS;
-    for (const key of Object.keys(h)) {
-        if (!allowed.has(key)) {
-            return SERVER_KEYS.has(key)
-                ? `"${key}" is accepted from a server event only`
-                : `unknown key "${key}"`;
-        }
-    }
-    if (!KINDS.includes(h.kind))
-        return `kind must be one of ${KINDS.join(', ')}`;
-    for (const key of OPTIONAL_STRINGS) {
-        if (h[key] !== undefined && typeof h[key] !== 'string')
-            return `${key} must be a string`;
-    }
-    if (h.kind === 'custom' && !h.name)
-        return 'custom events need a name';
-    if (typeof h.subject === 'string') {
-        const colon = h.subject.indexOf(':');
-        const type = colon < 0 ? h.subject : h.subject.slice(0, colon);
-        if (!SUBJECT_TYPE.test(type) || colon === h.subject.length - 1) {
-            return 'subject must be "<type>:<id>", the type a lowercase word such as pub or page';
-        }
-    }
-    if (h.props !== undefined) {
-        if (!h.props || typeof h.props !== 'object' || Array.isArray(h.props)) {
-            return 'props must be an object';
-        }
-        const entries = Object.entries(h.props);
-        if (entries.length > LIMITS.props) {
-            return `props has ${entries.length} keys, at most ${LIMITS.props} are allowed`;
-        }
-        for (const [k, v] of entries) {
-            if (k.length > LIMITS.propKey) {
-                return `props key "${k.slice(0, LIMITS.propKey)}…" is longer than ${LIMITS.propKey} characters`;
-            }
-            if (typeof v !== 'string')
-                return `props.${k} must be a string`;
-            if (v.length > LIMITS.propValue) {
-                return `props.${k} is longer than ${LIMITS.propValue} characters`;
-            }
-        }
-    }
-    if (h.utm !== undefined) {
-        if (!h.utm || typeof h.utm !== 'object' || Array.isArray(h.utm))
-            return 'utm must be an object';
-        for (const [k, v] of Object.entries(h.utm)) {
-            if (!UTM_KEYS.includes(k))
-                return `utm.${k} is not one of ${UTM_KEYS.join(', ')}`;
-            if (typeof v !== 'string')
-                return `utm.${k} must be a string`;
-        }
-    }
-    if (source === 'server') {
-        for (const key of ['hostname', 'userAgent']) {
-            if (h[key] !== undefined && typeof h[key] !== 'string')
-                return `${key} must be a string`;
-        }
-        if (h.country !== undefined && (typeof h.country !== 'string' || !COUNTRY.test(h.country))) {
-            return 'country must be a two-letter code in capitals';
-        }
-    }
-    return null;
-}
-/** The row a hint becomes. Call `validateHint` first; this trusts its input's types. */
-export function buildRow(hint, ctx) {
-    const server = ctx.source === 'server' ? hint : undefined;
-    const hostname = clip(server?.hostname, LIMITS.text)?.toLowerCase() ?? ctx.hostname;
-    const country = server ? (server.country ?? null) : ctx.country;
-    const userAgent = server ? (server.userAgent ?? '') : ctx.userAgent;
-    let subjectType = null;
-    let subjectId = null;
-    if (hint.subject) {
-        const colon = hint.subject.indexOf(':');
-        subjectType = colon < 0 ? hint.subject : hint.subject.slice(0, colon);
-        subjectId = colon < 0 ? null : hint.subject.slice(colon + 1, colon + 1 + LIMITS.subjectId);
-    }
-    const referrerHost = hostOf(hint.referrer);
-    const utm = hint.utm ?? {};
-    const ts = ctx.now.toISOString();
-    return {
-        schema: SCHEMA,
-        site: ctx.site,
-        project: ctx.project,
-        environment: ctx.environment,
-        source: ctx.source,
-        ts,
-        day: ts.slice(0, 10),
-        kind: hint.kind,
-        subject_type: subjectType,
-        subject_id: subjectId,
-        subject_uri: clip(hint.subjectUri, LIMITS.uri),
-        path: clip(hint.path, LIMITS.path),
-        hostname,
-        country,
-        device: device(userAgent),
-        referrer_host: referrerHost,
-        // The pubpub heuristic: no referrer, or one from another host, is a fresh
-        // visit. It counts visits, not people — no cookie, no fingerprint, no IP.
-        is_unique: !referrerHost || referrerHost !== hostname,
-        utm_source: clip(utm.source, LIMITS.text),
-        utm_medium: clip(utm.medium, LIMITS.text),
-        utm_campaign: clip(utm.campaign, LIMITS.text),
-        utm_term: clip(utm.term, LIMITS.text),
-        utm_content: clip(utm.content, LIMITS.text),
-        name: clip(hint.name, LIMITS.text),
-        scope: clip(hint.scope, LIMITS.scope),
-        props: hint.props ?? {},
-    };
-}
-export function device(userAgent) {
-    if (!userAgent)
-        return 'unknown';
-    if (/bot|crawl|spider|slurp|fetch/i.test(userAgent))
-        return 'bot';
-    if (/iPad|Tablet/i.test(userAgent))
-        return 'tablet';
-    if (/Mobi|Android|iPhone/i.test(userAgent))
-        return 'mobile';
-    return 'desktop';
-}
-function clip(v, max) {
-    return v ? v.slice(0, max) : null;
-}
-function hostOf(url) {
-    if (!url)
-        return null;
-    try {
-        return new URL(url.slice(0, LIMITS.uri)).hostname.toLowerCase() || null;
-    }
-    catch {
-        return null;
-    }
-}

package/dist/analytics/errors.d.ts

@@ -1,24 +0,0 @@
-/**
- * The only error project code sees from analytics. The collector's statuses
- * map onto these codes, so a `catch` written against the memory double
- * handles the live service the same way.
- */
-export type AnalyticsErrorCode = 
-/** No binding: the environment doesn't declare `kf/analytics@1`. */
-'not_configured'
-/** The event or query itself is wrong. The message names the field. Fix the call. */
- | 'invalid'
-/** The collector refused the site's credentials. */
- | 'forbidden'
-/** The collector is down, unreachable or rate-limiting. Safe to retry. */
- | 'unavailable';
-export declare class AnalyticsError extends Error {
-    readonly code: AnalyticsErrorCode;
-    /** The collector's HTTP status, when there was one. For logs, not for branching. */
-    readonly status?: number | undefined;
-    readonly name = "AnalyticsError";
-    constructor(code: AnalyticsErrorCode, message: string, 
-    /** The collector's HTTP status, when there was one. For logs, not for branching. */
-    status?: number | undefined);
-}
-export declare function isAnalyticsError(e: unknown, code?: AnalyticsErrorCode): e is AnalyticsError;

package/dist/analytics/errors.js

@@ -1,20 +0,0 @@
-/**
- * The only error project code sees from analytics. The collector's statuses
- * map onto these codes, so a `catch` written against the memory double
- * handles the live service the same way.
- */
-export class AnalyticsError extends Error {
-    code;
-    status;
-    name = 'AnalyticsError';
-    constructor(code, message, 
-    /** The collector's HTTP status, when there was one. For logs, not for branching. */
-    status) {
-        super(message);
-        this.code = code;
-        this.status = status;
-    }
-}
-export function isAnalyticsError(e, code) {
-    return e instanceof AnalyticsError && (code === undefined || e.code === code);
-}

package/dist/analytics/index.d.ts

@@ -1,38 +0,0 @@
-import { ANALYTICS_ENV } from './binding.js';
-import type { Analytics } from './types.js';
-/**
- * `@knowledgefutures/sdk/analytics` — numbers for a project that declares
- * `kf/analytics@1`, with nothing to configure:
- *
- *   import { analytics } from '@knowledgefutures/sdk/analytics'
- *   analytics.beaconTag()                         // into every page's <head>
- *   await analytics.track({ kind: 'download', subject: 'pub:za65x7nh', name: 'pdf' })
- *   const { rows } = await analytics.query({ cube: 'subjects', from, to, groupBy: ['subject_id'], order: '-views', limit: 10 })
- *
- * The console writes `KF_ANALYTICS_URL` into every environment that declares
- * the service; `kf dev` writes `log:`, which prints events and answers
- * queries from memory. Code never sees which it has.
- */
-export type * from './types.js';
-export type { Cube, CubeRow, Dim, Metric, Query, QueryResult } from './cubes.js';
-export type { Hint, Kind, ServerHint } from './envelope.js';
-export { CUBES } from './cubes.js';
-export { AnalyticsError, isAnalyticsError, type AnalyticsErrorCode } from './errors.js';
-type Env = Partial<Record<typeof ANALYTICS_ENV, string | undefined>>;
-export interface AnalyticsOptions {
-    /** For tests, or a runtime whose global fetch needs wrapping. */
-    fetch?: typeof fetch;
-}
-/**
- * A client from an explicit environment: a Worker's `env` (when
- * `nodejs_compat` is off, `process.env` is empty), a script's, a test's. A
- * string is the binding itself.
- */
-export declare function createAnalytics(env: Env | string, options?: AnalyticsOptions): Analytics;
-/**
- * The zero-config client. It reads `process.env` on first use, never at
- * import, so importing it costs nothing where analytics isn't declared and a
- * missing binding fails at the call that needed it, with the fix in the
- * message.
- */
-export declare const analytics: Analytics;

package/dist/analytics/index.js

@@ -1,98 +0,0 @@
-import { ANALYTICS_ENV, decodeAnalyticsBinding } from './binding.js';
-import { validateQuery } from './cubes.js';
-import { validateHint } from './envelope.js';
-import { AnalyticsError } from './errors.js';
-import { memoryAnalytics } from './memory.js';
-export { CUBES } from './cubes.js';
-export { AnalyticsError, isAnalyticsError } from './errors.js';
-/**
- * A client from an explicit environment: a Worker's `env` (when
- * `nodejs_compat` is off, `process.env` is empty), a script's, a test's. A
- * string is the binding itself.
- */
-export function createAnalytics(env, options = {}) {
-    const value = typeof env === 'string' ? env : env[ANALYTICS_ENV];
-    if (!value)
-        throw unconfigured();
-    const binding = decodeAnalyticsBinding(value);
-    if (binding === 'log') {
-        return memoryAnalytics({
-            site: 'local',
-            environment: 'local',
-            log: (row) => console.log('kf-analytics', JSON.stringify(row)),
-        });
-    }
-    return remote(binding, options.fetch ?? ((...a) => fetch(...a)));
-}
-function remote(b, doFetch) {
-    const auth = `Basic ${btoa(`${b.site}:${b.secret}`)}`;
-    const call = async (path, body) => {
-        let res;
-        try {
-            res = await doFetch(`${b.endpoint}${path}`, {
-                method: 'POST',
-                headers: { authorization: auth, 'content-type': 'application/json' },
-                body: JSON.stringify(body),
-            });
-        }
-        catch (e) {
-            throw new AnalyticsError('unavailable', `the collector is unreachable: ${String(e)}`);
-        }
-        if (res.ok)
-            return res;
-        const detail = (await res.text().catch(() => '')).slice(0, 300) || res.statusText;
-        const code = res.status === 401 || res.status === 403
-            ? 'forbidden'
-            : res.status === 429 || res.status >= 500
-                ? 'unavailable'
-                : 'invalid';
-        throw new AnalyticsError(code, `${path}: ${detail}`, res.status);
-    };
-    return {
-        async track(event) {
-            const problem = validateHint(event, 'server');
-            if (problem)
-                throw new AnalyticsError('invalid', problem);
-            await call('/v1/e', event);
-        },
-        async query(q) {
-            const problem = validateQuery(q);
-            if (problem)
-                throw new AnalyticsError('invalid', problem);
-            const res = await call('/v1/query', q);
-            return (await res.json());
-        },
-        beaconTag({ keyed = false } = {}) {
-            const site = keyed ? ` data-site="${b.site}"` : '';
-            return `<script src="${b.endpoint}/v1/b.js"${site} defer></script>`;
-        },
-    };
-}
-/**
- * The zero-config client. It reads `process.env` on first use, never at
- * import, so importing it costs nothing where analytics isn't declared and a
- * missing binding fails at the call that needed it, with the fix in the
- * message.
- */
-export const analytics = (() => {
-    let resolved;
-    const current = () => {
-        if (resolved)
-            return resolved;
-        const env = globalThis.process?.env;
-        if (!env?.[ANALYTICS_ENV])
-            throw unconfigured();
-        resolved = createAnalytics(env);
-        return resolved;
-    };
-    // async, so a missing binding is a rejected promise like every other failure, not a throw.
-    return {
-        track: async (...a) => current().track(...a),
-        query: async (q) => current().query(q),
-        beaconTag: (...a) => current().beaconTag(...a),
-    };
-})();
-function unconfigured() {
-    return new AnalyticsError('not_configured', `${ANALYTICS_ENV} is not set: declare kf/analytics@1 in kf.project.jsonc for this environment, ` +
-        `run under \`kf dev\`, or pass the environment to createAnalytics(env)`);
-}

package/dist/analytics/memory.d.ts

@@ -1,35 +0,0 @@
-import { type EventRow, type Hint, type RowContext } from './envelope.js';
-import type { Analytics } from './types.js';
-export interface MemoryAnalyticsOptions {
-    site?: string;
-    project?: string;
-    environment?: string;
-    /** The host a server event is filed under when it names none. */
-    hostname?: string;
-    /** The clock rows are stamped with. */
-    now?: () => Date;
-    /** Print each row as the collector would store it: what `kf dev` shows. */
-    log?: (row: EventRow) => void;
-}
-export interface MemoryAnalytics extends Analytics {
-    /** Every row recorded, in order, exactly as the collector would write it. */
-    readonly events: readonly EventRow[];
-    /**
-     * Record a browser beacon, as the collector would on receiving it — to seed
-     * a test with page views. `ctx` sets what the collector reads off the
-     * request (`hostname`, `country`, `userAgent`) or overrides the clock.
-     */
-    beacon(hint: Hint, ctx?: Partial<Pick<RowContext, 'hostname' | 'country' | 'userAgent' | 'now'>>): void;
-    clear(): void;
-}
-/**
- * The analytics service in memory, for tests and `kf dev`. It validates and
- * builds rows with the collector's own code (`envelope.ts`) and answers
- * queries with the compactor's reference (`cubes.ts`), so a test that
- * asserts on numbers here asserts on the service's semantics.
- *
- * One difference, on purpose: there is no nightly job, so an event is
- * queryable at once and `through` is the last day that has events, today
- * included. The live service never has today.
- */
-export declare function memoryAnalytics(options?: MemoryAnalyticsOptions): MemoryAnalytics;

package/dist/analytics/memory.js

@@ -1,66 +0,0 @@
-import { cubeRows, runQuery, validateQuery, } from './cubes.js';
-import { buildRow, validateHint, } from './envelope.js';
-import { AnalyticsError } from './errors.js';
-/**
- * The analytics service in memory, for tests and `kf dev`. It validates and
- * builds rows with the collector's own code (`envelope.ts`) and answers
- * queries with the compactor's reference (`cubes.ts`), so a test that
- * asserts on numbers here asserts on the service's semantics.
- *
- * One difference, on purpose: there is no nightly job, so an event is
- * queryable at once and `through` is the last day that has events, today
- * included. The live service never has today.
- */
-export function memoryAnalytics(options = {}) {
-    const site = options.site ?? 'memory';
-    const project = options.project ?? 'test/project';
-    const environment = options.environment ?? 'production';
-    const now = options.now ?? (() => new Date());
-    const events = [];
-    const record = (row) => {
-        events.push(row);
-        options.log?.(row);
-    };
-    const context = (source, ctx = {}) => ({
-        site,
-        project,
-        environment,
-        source,
-        hostname: options.hostname ?? 'localhost',
-        country: null,
-        userAgent: source === 'beacon' ? 'Mozilla/5.0 (Macintosh)' : '',
-        now: now(),
-        ...ctx,
-    });
-    return {
-        events,
-        async track(event) {
-            const problem = validateHint(event, 'server');
-            if (problem)
-                throw new AnalyticsError('invalid', problem);
-            record(buildRow(event, context('server')));
-        },
-        beacon(hint, ctx) {
-            const problem = validateHint(hint, 'beacon');
-            if (problem)
-                throw new AnalyticsError('invalid', problem);
-            record(buildRow(hint, context('beacon', ctx)));
-        },
-        async query(q) {
-            const problem = validateQuery(q);
-            if (problem)
-                throw new AnalyticsError('invalid', problem);
-            const env = q.environment ?? environment;
-            const mine = events.filter((e) => e.environment === env);
-            const rows = runQuery(cubeRows(q.cube, mine), q);
-            const through = mine.reduce((max, e) => (max && max > e.day ? max : e.day), null);
-            return { rows, through };
-        },
-        beaconTag() {
-            return '';
-        },
-        clear() {
-            events.length = 0;
-        },
-    };
-}

package/dist/analytics/testing.d.ts

@@ -1,6 +0,0 @@
-/**
- * `@knowledgefutures/sdk/analytics/testing` — the service in memory, same
- * interface, no network. Seed page views with `beacon()`, then assert on
- * `query()`: the numbers follow the service's own rules.
- */
-export { memoryAnalytics, type MemoryAnalytics, type MemoryAnalyticsOptions } from './memory.js';

package/dist/analytics/testing.js

@@ -1,6 +0,0 @@
-/**
- * `@knowledgefutures/sdk/analytics/testing` — the service in memory, same
- * interface, no network. Seed page views with `beacon()`, then assert on
- * `query()`: the numbers follow the service's own rules.
- */
-export { memoryAnalytics } from './memory.js';