@skene/flows-sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) 2026 Skene Technologies. All rights reserved.
+
+@skene/flows-sdk is proprietary software of Skene Technologies. It is not open source, and no
+license to copy, modify, distribute, sublicense or create derivative works of it is granted by
+its publication on npm or anywhere else. Use of the package is permitted only under a separate
+written agreement with Skene Technologies, such as the terms under which you use Skene.
+
+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 SKENE TECHNOLOGIES BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR ITS USE.

package/README.md

@@ -1,3 +1,60 @@
-# Temporary Holding Version
+# @skene/flows-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.
+The Skene Flows SDK sends product events straight into your own database. Skene then reads them
+from there with a read-only role, so no event, payload or key reaches Skene.
+
+1. Install the SDK: `npm install @skene/flows-sdk`.
+2. Apply the Flows SDK kit in your database, as the role that will own schema `skene`. It ships in
+   this package as `kit/apply.sql` (after the install, `node_modules/@skene/flows-sdk/kit/apply.sql`),
+   with its rollback beside it as `kit/rollback.sql`. It creates schema `skene` with the events table
+   and the one collection function, `skene.collect_events`.
+3. On Supabase, add `skene` to the Data API's exposed schemas.
+4. Send events:
+
+```ts
+import { browserStores, createFlowsClient, sendOnPageHide, supabaseTransport } from '@skene/flows-sdk';
+
+const flows = createFlowsClient({
+  transport: supabaseTransport({ url: 'https://<project-ref>.supabase.co', key: '<publishable key>' }),
+  ...browserStores(),
+});
+sendOnPageHide(flows);
+
+flows.track('visit');
+flows.identify(user.id);
+flows.track('signup', { plan: 'pro' });
+```
+
+How it behaves:
+
+- Each event gets a UUID once, which is kept across retries, and a sequence number within its
+  installation. Each `createFlowsClient` is a new installation; only the unsent buffer is kept per
+  tab, so a reload resends it.
+- An event leaves the buffer only when your database answers `accepted` or `duplicate`.
+  `conflict` and `invalid` are dropped and reported to `onDrop`. Anything else is retried with
+  backoff.
+- `onReceipt` receives each event your database answered `accepted` or `duplicate`, with that
+  answer and the time the database first received the event. The answer comes only after your
+  database committed the event, and the event has already left the buffer, so a receipt you record
+  always names an event your database holds. A page-hide send, a failed or unanswered request and a
+  refused event get no receipt. A `duplicate` carries the first receive time. An error your callback
+  throws is ignored.
+- A send on page hide reads no answer, so it never clears an event.
+- `identify` changes later events only.
+- When the buffer is full, a new event is dropped after it is numbered. Its loss shows as a gap.
+  A server installation's gap stops the interval from being sealed; a browser installation's gap is
+  reported in the package's manifest for you to judge.
+- Your database takes an event only if it is timed at most 5 minutes ahead of its clock and at most
+  7 days behind it. An event kept unsent longer is answered `invalid`.
+- `track` and `identify` refuse text holding a lone surrogate or a NUL, which PostgreSQL cannot
+  store. If your database still refuses a whole batch (HTTP 400), the SDK splits it until the one
+  bad event is alone and drops it as `invalid`.
+- Events sent with the publishable key are recorded as sent from a browser, because anyone with
+  that key can send them. Send conversion-critical events from your server, with your own
+  transport or the secret key.
+
+## License
+
+Proprietary. Copyright (c) 2026 Skene Technologies, all rights reserved; see [LICENSE](LICENSE).
+The package is public on npm so that you can install it, but it is not open source: it is for use
+with Skene under your agreement with Skene Technologies.

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+/** A property value the measurement can seal: short text, a safe integer or a boolean. */
+export type PropertyValue = string | number | boolean;
+/** One event as the collection function receives it. */
+export type FlowsEvent = Readonly<{
+    event_id: string;
+    event_name: string;
+    occurred_at: string;
+    person_id: string | null;
+    anonymous_id: string | null;
+    installation_id: string;
+    sequence: number;
+    properties?: Readonly<Record<string, PropertyValue>>;
+}>;
+export type ReceiptStatus = 'accepted' | 'duplicate' | 'conflict' | 'invalid';
+/** The database's answer for one event, after its transaction committed. */
+export type Receipt = Readonly<{
+    event_id: string | null;
+    status: ReceiptStatus;
+    received_at: string | null;
+}>;
+/**
+ * Sends one batch and returns the database's receipts. It throws when there is no answer to trust,
+ * and throws a RefusedBatchError when the database refused the batch whole because of what it holds.
+ * With keepalive the request may outlive the page, and its answer is never read.
+ */
+export type Transport = (events: readonly FlowsEvent[], options: Readonly<{
+    keepalive: boolean;
+}>) => Promise<readonly Receipt[]>;
+/** Where the SDK keeps state between page loads. Every method may throw; the SDK then keeps memory only. */
+export type Store = Readonly<{
+    get(key: string): string | null;
+    set(key: string, value: string): void;
+}>;
+export type FlowsOptions = Readonly<{
+    transport: Transport;
+    /** Kept per device: the anonymous id and the identified person. Default: memory. */
+    deviceStore?: Store;
+    /** Kept per tab or process: the unsent buffer, so a reload resends it. Default: memory. */
+    bufferStore?: Store;
+    /** Events kept while unsent, 1 to 10,000. Default 1,000. */
+    maxBuffer?: number;
+    /** Delay before the first retry, doubled per failure up to maxRetryMs. Defaults 1 s and 60 s. */
+    initialRetryMs?: number;
+    maxRetryMs?: number;
+    /** Delay between a track call and the send it schedules. Default 1 s. */
+    flushDelayMs?: number;
+    /** Called once per event the database refused, or the full buffer dropped. */
+    onDrop?: (event: FlowsEvent, reason: 'conflict' | 'invalid' | 'buffer_full') => void;
+    /**
+     * Called once per event the database acknowledged (accepted or duplicate), with its receipt, after
+     * the event has left the saved buffer. The answer exists only after the database committed the
+     * event, so this is never called for an event the database does not hold: not for a page-hide
+     * send, a failed or unanswered request, or a refused event. An error it throws is ignored.
+     */
+    onReceipt?: (event: FlowsEvent, receipt: Receipt) => void;
+    /** Injected for tests; defaults are the platform's. */
+    now?: () => number;
+    uuid?: () => string;
+    random?: () => number;
+    schedule?: (run: () => void, delayMs: number) => unknown;
+    cancel?: (handle: unknown) => void;
+}>;
+export type FlushResult = Readonly<{
+    sent: number;
+    cleared: number;
+    dropped: number;
+    failed: boolean;
+}>;
+export type FlowsClient = Readonly<{
+    /** Numbers, buffers and schedules one event; returns it, or null when the buffer was full and it was dropped. */
+    track(eventName: string, properties?: Readonly<Record<string, PropertyValue>>): FlowsEvent | null;
+    /** Later events carry this person id instead of the anonymous id; earlier events are never rewritten. */
+    identify(personId: string): void;
+    /** Sends the oldest batch now and processes its receipts. One send runs at a time. */
+    flush(): Promise<FlushResult>;
+    /** Sends the oldest batch with keepalive and reads no answer, so nothing leaves the buffer. */
+    flushOnHide(): void;
+    /** The unsent events, oldest first. */
+    pending(): readonly FlowsEvent[];
+    readonly installationId: string;
+}>;
+/** The database refused a batch whole because of what it holds (HTTP 400), so resending it unchanged cannot help. */
+export declare class RefusedBatchError extends Error {
+    constructor(message: string);
+}
+export declare function createFlowsClient(options: FlowsOptions): FlowsClient;
+/** Receipts read from a collection answer, or an error when it is not one. */
+export declare function readReceipts(body: unknown): readonly Receipt[];
+/**
+ * The transport for a Supabase project (or any PostgREST): it calls skene.collect_events through the
+ * project's Data API with its key. In a browser use the public key: those events are recorded as sent
+ * from a browser. A 400 answer (the database could not read what the batch holds) throws a
+ * RefusedBatchError, so the batch is split; any other non-2xx answer or an unreadable body throws,
+ * so the batch is retried.
+ */
+export declare function supabaseTransport(config: Readonly<{
+    url: string;
+    key: string;
+    schema?: string;
+    fetch?: typeof fetch;
+}>): Transport;
+/** Browser storage: localStorage for the device's identities, sessionStorage for the tab's unsent buffer. */
+export declare function browserStores(): Readonly<{
+    deviceStore: Store;
+    bufferStore: Store;
+}>;
+type PageDocument = EventTarget & Readonly<{
+    visibilityState: string;
+}>;
+/** Sends the buffer with keepalive whenever the page is hidden; returns the function that stops it. */
+export declare function sendOnPageHide(client: FlowsClient, page?: PageDocument): () => void;
+export {};

package/dist/index.js

@@ -0,0 +1,313 @@
+// Plan row L2-4 (LCH-03.sdk): the Skene Flows SDK. It numbers and buffers events on the device and
+// writes them into the customer's own database through skene.collect_events, the function the Flows
+// SDK kit creates there (kit/apply.sql in this package). No event, payload or key
+// reaches Skene. The rule record is docs/adr/20261010-flows-sdk-route-contract.md.
+//
+// An event leaves the buffer only when the database answers accepted or duplicate for its id, or
+// refuses it as conflict or invalid (a retry cannot change either answer). A failed or unanswered
+// request keeps every event and retries with exponential backoff. A batch the database refuses
+// whole (HTTP 400) is halved until the one event it cannot read is alone, and that event is dropped
+// as invalid, so it never holds back the events behind it. A send on page hide observes no answer,
+// so it never clears an event. Every event is numbered within its installation before it is
+// buffered, so an event that is dropped because the buffer is full leaves a sequence gap. An
+// installation is one client: its id is new on every createFlowsClient and lives only in memory, so
+// two contexts (a duplicated tab, a reload, a second process) never number events in one series.
+const BATCH = 100;
+const MAX_TEXT = 200;
+const MAX_KEY = 120;
+const MAX_PROPERTIES = 20;
+const KEYS = { anonymous: 'skene_flows_anonymous_id', person: 'skene_flows_person_id', buffer: 'skene_flows_buffer' };
+/** The database refused a batch whole because of what it holds (HTTP 400), so resending it unchanged cannot help. */
+export class RefusedBatchError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'RefusedBatchError';
+    }
+}
+/**
+ * Text PostgreSQL can store as JSON: no lone UTF-16 surrogate (a string cut through an emoji) and no
+ * NUL. Either makes the database refuse the whole request before the collection function runs.
+ */
+function storable(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const unit = value.charCodeAt(index);
+        if (unit === 0)
+            return false;
+        if (unit >= 0xdc00 && unit <= 0xdfff)
+            return false;
+        if (unit >= 0xd800 && unit <= 0xdbff) {
+            const next = value.charCodeAt(index + 1);
+            if (!(next >= 0xdc00 && next <= 0xdfff))
+                return false;
+            index += 1;
+        }
+    }
+    return true;
+}
+/** The kit's text rule: 1 to max characters, nothing trim() removes at either end, no C0 control character. */
+function textOk(value, max = MAX_TEXT) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > max || value.trim() !== value)
+        return false;
+    for (let index = 0; index < value.length; index += 1)
+        if (value.charCodeAt(index) < 32)
+            return false;
+    return storable(value);
+}
+function propertiesOk(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const entries = Object.entries(value);
+    return entries.length >= 1 && entries.length <= MAX_PROPERTIES && entries.every(([key, item]) => textOk(key, MAX_KEY)
+        && (typeof item === 'boolean' || typeof item === 'string' && item.length <= MAX_TEXT && storable(item)
+            || typeof item === 'number' && Number.isSafeInteger(item)));
+}
+/** Reads a store, treating a missing or throwing store as empty: the SDK then keeps memory only. */
+function read(store, key) {
+    try {
+        return store?.get(key) ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function write(store, key, value) {
+    try {
+        store?.set(key, value);
+    }
+    catch { /* memory only: the store refused */ }
+}
+function storedEvents(text) {
+    if (text === null)
+        return [];
+    try {
+        const parsed = JSON.parse(text);
+        return Array.isArray(parsed) ? parsed.filter((item) => typeof item === 'object' && item !== null && typeof item.event_id === 'string') : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function createFlowsClient(options) {
+    const device = options.deviceStore;
+    const bufferStore = options.bufferStore;
+    const maxBuffer = Math.min(10_000, Math.max(1, Math.trunc(options.maxBuffer ?? 1000)));
+    const initialRetryMs = options.initialRetryMs ?? 1000;
+    const maxRetryMs = options.maxRetryMs ?? 60_000;
+    const flushDelayMs = options.flushDelayMs ?? 1000;
+    const now = options.now ?? Date.now;
+    const uuid = options.uuid ?? (() => globalThis.crypto.randomUUID());
+    const random = options.random ?? Math.random;
+    const schedule = options.schedule ?? ((run, delayMs) => setTimeout(run, delayMs));
+    const cancel = options.cancel ?? ((handle) => clearTimeout(handle));
+    const remembered = (store, key) => {
+        const found = read(store, key);
+        if (found !== null && found.length > 0)
+            return found;
+        const created = uuid();
+        write(store, key, created);
+        return created;
+    };
+    const anonymousId = remembered(device, KEYS.anonymous);
+    // Never stored: a copied store (a duplicated tab, a window.open that keeps its opener) would
+    // otherwise give two contexts one series, and the second to send a number would lose its event as
+    // a conflict that no gap shows. A restored buffer keeps its events' own installation and numbers.
+    const installationId = uuid();
+    let personId = read(device, KEYS.person);
+    let nextSequence = 1;
+    let buffer = storedEvents(read(bufferStore, KEYS.buffer)).slice(0, maxBuffer);
+    let failures = 0;
+    let timer = null;
+    let sending = null;
+    // Halved on each whole-batch refusal until the event the database cannot read is alone.
+    let batchLimit = BATCH;
+    const save = () => write(bufferStore, KEYS.buffer, JSON.stringify(buffer));
+    const plan = (delayMs) => {
+        timer = schedule(() => { timer = null; void client.flush(); }, delayMs);
+    };
+    const retryDelay = () => Math.round(random() * Math.min(maxRetryMs, initialRetryMs * 2 ** Math.min(failures - 1, 30)));
+    const send = async () => {
+        const batch = buffer.slice(0, batchLimit);
+        if (batch.length === 0)
+            return { sent: 0, cleared: 0, dropped: 0, failed: false };
+        let receipts;
+        try {
+            receipts = await options.transport(batch, { keepalive: false });
+        }
+        catch (error) {
+            if (error instanceof RefusedBatchError) {
+                const [only] = batch;
+                if (batch.length === 1 && only !== undefined) {
+                    buffer = buffer.filter(event => event !== only);
+                    save();
+                    batchLimit = BATCH;
+                    options.onDrop?.(only, 'invalid');
+                    if (buffer.length > 0)
+                        plan(0);
+                    return { sent: 1, cleared: 0, dropped: 1, failed: false };
+                }
+                batchLimit = Math.ceil(batch.length / 2);
+                plan(0);
+                return { sent: batch.length, cleared: 0, dropped: 0, failed: true };
+            }
+            failures += 1;
+            plan(retryDelay());
+            return { sent: batch.length, cleared: 0, dropped: 0, failed: true };
+        }
+        const answers = new Map();
+        // An answer that is not a list answers no event, so every event in the batch stays for a retry.
+        for (const receipt of Array.isArray(receipts) ? receipts : []) {
+            if (typeof receipt?.event_id === 'string')
+                answers.set(receipt.event_id, receipt);
+        }
+        const sentIds = new Set(batch.map(event => event.event_id));
+        const acknowledged = [];
+        let dropped = 0;
+        buffer = buffer.filter(event => {
+            if (!sentIds.has(event.event_id))
+                return true;
+            const receipt = answers.get(event.event_id);
+            if (receipt?.status === 'accepted' || receipt?.status === 'duplicate') {
+                acknowledged.push([event, receipt]);
+                return false;
+            }
+            if (receipt?.status === 'conflict' || receipt?.status === 'invalid') {
+                dropped += 1;
+                options.onDrop?.(event, receipt.status);
+                return false;
+            }
+            return true;
+        });
+        save();
+        const cleared = acknowledged.length;
+        // Plan row L2-8B (LCH-08.queues): a receipt is handed on only after the database answered, which
+        // PostgREST does only once the transaction committed, and only once its event has left the saved
+        // buffer. A throwing callback is the customer's error to handle: it is ignored here, so it can
+        // neither put the event back nor stop the events behind it from being sent.
+        for (const [event, receipt] of acknowledged) {
+            try {
+                options.onReceipt?.(event, receipt);
+            }
+            catch { /* see above */ }
+        }
+        const unanswered = batch.length - cleared - dropped;
+        // Backoff resets only when every event sent was answered; an unanswered event keeps doubling it.
+        if (unanswered > 0) {
+            failures += 1;
+            plan(retryDelay());
+        }
+        else {
+            failures = 0;
+            batchLimit = BATCH;
+            if (buffer.length > 0)
+                plan(0);
+        }
+        return { sent: batch.length, cleared, dropped, failed: unanswered > 0 };
+    };
+    const client = {
+        installationId,
+        track(eventName, properties) {
+            if (!textOk(eventName))
+                throw new TypeError('An event name is 1 to 200 characters, trimmed, without control characters');
+            if (properties !== undefined && !propertiesOk(properties)) {
+                throw new TypeError('Properties are 1 to 20 keys of at most 120 characters, each short text, a safe integer or a boolean');
+            }
+            const event = {
+                event_id: uuid(), event_name: eventName, occurred_at: new Date(now()).toISOString(),
+                person_id: personId, anonymous_id: personId === null ? anonymousId : null,
+                installation_id: installationId, sequence: nextSequence,
+                ...(properties === undefined ? {} : { properties: { ...properties } }),
+            };
+            nextSequence += 1;
+            if (buffer.length >= maxBuffer) {
+                options.onDrop?.(event, 'buffer_full');
+                return null;
+            }
+            buffer.push(event);
+            save();
+            if (sending === null && timer === null)
+                plan(flushDelayMs);
+            return event;
+        },
+        identify(id) {
+            if (!textOk(id))
+                throw new TypeError('A person id is 1 to 200 characters, trimmed, without control characters');
+            personId = id;
+            write(device, KEYS.person, id);
+        },
+        flush() {
+            if (sending !== null)
+                return sending;
+            if (timer !== null) {
+                cancel(timer);
+                timer = null;
+            }
+            sending = send().finally(() => { sending = null; });
+            return sending;
+        },
+        flushOnHide() {
+            const batch = buffer.slice(0, BATCH);
+            if (batch.length === 0)
+                return;
+            options.transport(batch, { keepalive: true }).catch(() => undefined);
+        },
+        pending: () => [...buffer],
+    };
+    if (buffer.length > 0)
+        plan(0);
+    return client;
+}
+/** Receipts read from a collection answer, or an error when it is not one. */
+export function readReceipts(body) {
+    if (!Array.isArray(body))
+        throw new TypeError('The collection answer is not a list of receipts');
+    return body.map(item => {
+        const row = typeof item === 'object' && item !== null ? item : {};
+        const status = row['status'];
+        if (status !== 'accepted' && status !== 'duplicate' && status !== 'conflict' && status !== 'invalid') {
+            throw new TypeError('A receipt has no known status');
+        }
+        return { event_id: typeof row['event_id'] === 'string' ? row['event_id'] : null, status,
+            received_at: typeof row['received_at'] === 'string' ? row['received_at'] : null };
+    });
+}
+/**
+ * The transport for a Supabase project (or any PostgREST): it calls skene.collect_events through the
+ * project's Data API with its key. In a browser use the public key: those events are recorded as sent
+ * from a browser. A 400 answer (the database could not read what the batch holds) throws a
+ * RefusedBatchError, so the batch is split; any other non-2xx answer or an unreadable body throws,
+ * so the batch is retried.
+ */
+export function supabaseTransport(config) {
+    const endpoint = new URL('rest/v1/rpc/collect_events', config.url.endsWith('/') ? config.url : `${config.url}/`).toString();
+    const call = config.fetch ?? globalThis.fetch.bind(globalThis);
+    return async (events, { keepalive }) => {
+        const response = await call(endpoint, {
+            method: 'POST', keepalive,
+            headers: { apikey: config.key, authorization: `Bearer ${config.key}`, 'content-type': 'application/json',
+                'content-profile': config.schema ?? 'skene', accept: 'application/json' },
+            body: JSON.stringify({ p_events: events }),
+        });
+        if (keepalive)
+            return [];
+        if (response.status === 400)
+            throw new RefusedBatchError('The collection call answered 400');
+        if (!response.ok)
+            throw new Error(`The collection call answered ${response.status}`);
+        return readReceipts(await response.json());
+    };
+}
+/** Browser storage: localStorage for the device's identities, sessionStorage for the tab's unsent buffer. */
+export function browserStores() {
+    const wrap = (name) => ({
+        get: key => globalThis[name]?.getItem(key) ?? null,
+        set: (key, value) => { globalThis[name]?.setItem(key, value); },
+    });
+    return { deviceStore: wrap('localStorage'), bufferStore: wrap('sessionStorage') };
+}
+/** Sends the buffer with keepalive whenever the page is hidden; returns the function that stops it. */
+export function sendOnPageHide(client, page = globalThis.document) {
+    const listener = () => { if (page.visibilityState === 'hidden')
+        client.flushOnHide(); };
+    page.addEventListener('visibilitychange', listener);
+    return () => page.removeEventListener('visibilitychange', listener);
+}

package/kit/apply.sql

@@ -0,0 +1,430 @@
+-- Plan row L2-4 (LCH-03.sdk): the Skene Flows SDK route's change to the customer's own Postgres. The
+-- customer applies it, as the role that will own schema `skene`, in the database the SDK writes to;
+-- Skene never runs it and holds no credential that could. Rollback: rollback.sql beside it.
+-- The rule record is docs/adr/20261010-flows-sdk-route-contract.md (revised by L2-4).
+--
+-- What it creates, all in schema `skene`:
+--   events                    the collection table, append-only and keyed by event_id. Each row is one
+--                             event the SDK sent: its id, name and time, the person id after identify
+--                             or the anonymous id before it, the SDK installation and its sequence
+--                             number, up to 20 short properties, whether a browser sent it, and the
+--                             database's receive time.
+--   collect_events(jsonb)     the one way in: a batch of 1 to 100 events, answered per event after the
+--                             transaction commits: accepted (new), duplicate (an identical retry, with
+--                             the first receive time), conflict (the same id, or the same installation
+--                             sequence from the same origin, with other content; refused) or invalid
+--                             (refused). An event timed more than 5 minutes ahead of the database's
+--                             clock, or more than 7 days behind it (the SDK's maximum buffer age), is
+--                             invalid.
+--   sequence_gaps             each run of sequence numbers an installation skipped, per origin: an event
+--                             the SDK numbered that never arrived, with the time span it may cover.
+--   measurement_events        the read contract's relation over events.
+--   measurement_packages,     a sealed package: its manifest and its rows, which Skene's worker reads
+--   measurement_package_events in one read-only snapshot and checks against the owner qualification's
+--                             row count and SHA-256.
+--   seal_measurement_package(...) seals one closed interval into a package and returns the manifest to
+--                             give Skene, with how many of its rows a browser sent. It refuses an
+--                             interval a server installation's sequence gap overlaps, a row the worker
+--                             would refuse, or more than 50,000 rows. A browser installation's gap does
+--                             not refuse the seal, because anyone holding the public key can forge one;
+--                             the manifest reports how many overlap (browser_gaps) and which
+--                             installations (browser_gap_installations), for the owner to judge before
+--                             qualifying the package.
+--
+-- Who may call collect_events: on Supabase the kit grants it to anon and authenticated, the roles of
+-- your project's public key, and to service_role, the role of its secret key; add `skene` to the
+-- Data API's exposed schemas. An event whose caller is anon or authenticated is recorded as sent from
+-- a browser: anyone holding the public key can send one, so send conversion-critical events from your
+-- server. Nothing limits how many events the public key may send, so the table can grow without
+-- bound; delete rows you no longer need as your retention. Anywhere else, grant it to your backend's
+-- role yourself:
+--   grant usage on schema skene to <backend>;
+--   grant execute on function skene.collect_events(jsonb) to <backend>;
+--
+-- Not visible here: an event lost after an installation's last delivered event (a closed tab with
+-- unsent events, a buffer that never reconnected) leaves no gap. Seal an interval only some time after
+-- it ends, so retries have had time to arrive.
+--
+-- After applying, give your read-only Skene role exactly this, and nothing on skene.events:
+--   grant usage on schema skene to <reader>;
+--   grant select on skene.measurement_packages, skene.measurement_package_events to <reader>;
+-- and register the destination with schema skene.
+begin;
+do $$
+begin
+  if to_regnamespace('skene') is not null then
+    raise exception 'Schema skene already exists; the Flows SDK kit creates it';
+  end if;
+end;
+$$;
+create schema skene;
+revoke all on schema skene from public;
+
+-- The worker's text rule: 1 to 200 characters, no C0 control character, and nothing JavaScript's
+-- trim() would remove at either end.
+create function skene.measurement_text_ok(v text, p_max integer default 200) returns boolean
+language sql immutable set search_path = '' as $$
+  select coalesce(length(v) between 1 and p_max
+    and v = pg_catalog.btrim(v, E' \t\n\x0b\x0c\r             

  　')
+    and v = pg_catalog.translate(v, E'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f'
+      || E'\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f', ''), false)
+$$;
+
+-- One JSON value of a sealed entry property, written exactly as JSON.stringify writes it, or null
+-- when the worker would refuse it: text of at most 200 characters, a safe integer or a boolean.
+create function skene.measurement_property_json(v jsonb) returns text
+language sql immutable set search_path = '' as $$
+  select case pg_catalog.jsonb_typeof(v)
+    when 'string' then case when length(v #>> '{}') <= 200 then pg_catalog.to_json(v #>> '{}')::text end
+    when 'boolean' then v::text
+    when 'number' then case when (v::text)::numeric = trunc((v::text)::numeric)
+      and abs((v::text)::numeric) <= 9007199254740991 then ((v::text)::numeric)::bigint::text end
+  end
+$$;
+
+
+-- A uuid written exactly as the SDK writes one (lowercase, hyphenated), or null.
+create function skene.canonical_uuid(v jsonb) returns uuid
+language plpgsql immutable set search_path = '' as $$
+declare
+  parsed uuid;
+begin
+  if v is null or pg_catalog.jsonb_typeof(v) <> 'string' then return null; end if;
+  begin
+    parsed := (v #>> '{}')::uuid;
+  exception when invalid_text_representation then
+    return null;
+  end;
+  return case when parsed::text = v #>> '{}' then parsed end;
+end;
+$$;
+
+-- An event time written exactly as JavaScript's Date.prototype.toISOString writes one, or null.
+create function skene.canonical_time(v jsonb) returns timestamptz
+language plpgsql immutable set search_path = '' as $$
+declare
+  parsed timestamptz;
+begin
+  if v is null or pg_catalog.jsonb_typeof(v) <> 'string' then return null; end if;
+  begin
+    parsed := (v #>> '{}')::timestamptz;
+  exception when invalid_datetime_format or datetime_field_overflow then
+    return null;
+  end;
+  if not pg_catalog.isfinite(parsed) or parsed < 'epoch'::timestamptz then return null; end if;
+  return case when pg_catalog.to_char(parsed at time zone 'UTC', 'YYYY-MM-DD"T"HH24:MI:SS.MS"Z"') = v #>> '{}'
+    then parsed end;
+end;
+$$;
+
+-- An event's properties: none, or an object of 1 to 20 keys of at most 120 characters whose values
+-- the worker can seal (short text, a safe integer or a boolean).
+create function skene.properties_ok(v jsonb) returns boolean
+language sql immutable set search_path = '' as $$
+  select v is null or pg_catalog.jsonb_typeof(v) = 'object'
+    and (select count(*) from pg_catalog.jsonb_each(v)) between 1 and 20
+    and not exists (select 1 from pg_catalog.jsonb_each(v) p
+      where not skene.measurement_text_ok(p.key, 120) or skene.measurement_property_json(p.value) is null)
+$$;
+
+create table skene.events (
+  event_id uuid primary key,
+  event_name text not null check (skene.measurement_text_ok(event_name)),
+  occurred_at timestamptz not null
+    check (occurred_at >= 'epoch'::timestamptz and date_trunc('milliseconds', occurred_at) = occurred_at),
+  person_id text check (person_id is null or skene.measurement_text_ok(person_id)),
+  anonymous_id text check (anonymous_id is null or skene.measurement_text_ok(anonymous_id)),
+  installation_id uuid not null,
+  sequence bigint not null check (sequence between 1 and 9007199254740991),
+  properties jsonb check (skene.properties_ok(properties)),
+  origin text not null check (origin in ('browser', 'server')),
+  received_at timestamptz not null default pg_catalog.now(),
+  check (num_nonnulls(person_id, anonymous_id) = 1),
+  -- Per origin, so an event sent with the public key can never take a server installation's number.
+  unique (installation_id, origin, sequence)
+);
+
+-- Append-only: a row is never changed. Deleting rows is the owner's retention, and expires any
+-- package sealed over them only if the package itself is deleted.
+create function skene.refuse_event_update() returns trigger
+language plpgsql set search_path = '' as $$
+begin
+  raise exception 'skene.events is append-only';
+end;
+$$;
+create trigger events_append_only before update on skene.events
+  for each row execute function skene.refuse_event_update();
+
+-- The one way in. See the header for its answers. A malformed event is answered invalid and the rest
+-- of the batch still lands; a malformed batch is refused whole.
+create function skene.collect_events(p_events jsonb)
+returns table (event_id uuid, status text, received_at timestamptz)
+language plpgsql security definer set search_path = '' as $$
+#variable_conflict use_column
+declare
+  v_origin text := case when pg_catalog.current_setting('role', true) in ('anon', 'authenticated')
+    then 'browser' else 'server' end;
+  v_item jsonb;
+  v_id uuid;
+  v_installation uuid;
+  v_at timestamptz;
+  v_name text;
+  v_person text;
+  v_anonymous text;
+  v_sequence bigint;
+  v_properties jsonb;
+  v_received timestamptz;
+  v_first skene.events%rowtype;
+begin
+  if p_events is null or pg_catalog.jsonb_typeof(p_events) <> 'array'
+    or pg_catalog.jsonb_array_length(p_events) not between 1 and 100 then
+    raise exception 'A batch is a JSON array of 1 to 100 events' using errcode = '22023';
+  end if;
+  for v_item in select e.value from pg_catalog.jsonb_array_elements(p_events) e loop
+    v_id := case when pg_catalog.jsonb_typeof(v_item) = 'object' then skene.canonical_uuid(v_item -> 'event_id') end;
+    if v_id is null
+      or exists (select 1 from pg_catalog.jsonb_object_keys(v_item) k where k not in ('event_id', 'event_name',
+        'occurred_at', 'person_id', 'anonymous_id', 'installation_id', 'sequence', 'properties'))
+      or pg_catalog.jsonb_typeof(v_item -> 'event_name') is distinct from 'string'
+      or pg_catalog.jsonb_typeof(v_item -> 'sequence') is distinct from 'number'
+      or coalesce(pg_catalog.jsonb_typeof(v_item -> 'person_id'), 'null') not in ('string', 'null')
+      or coalesce(pg_catalog.jsonb_typeof(v_item -> 'anonymous_id'), 'null') not in ('string', 'null')
+      or coalesce(pg_catalog.jsonb_typeof(v_item -> 'properties'), 'null') not in ('object', 'null') then
+      event_id := v_id; status := 'invalid'; received_at := null;
+      return next;
+      continue;
+    end if;
+    v_name := v_item ->> 'event_name';
+    v_at := skene.canonical_time(v_item -> 'occurred_at');
+    v_installation := skene.canonical_uuid(v_item -> 'installation_id');
+    v_person := v_item ->> 'person_id';
+    v_anonymous := v_item ->> 'anonymous_id';
+    v_properties := case when pg_catalog.jsonb_typeof(v_item -> 'properties') = 'object' then v_item -> 'properties' end;
+    v_sequence := case when (v_item ->> 'sequence')::numeric = trunc((v_item ->> 'sequence')::numeric)
+      and (v_item ->> 'sequence')::numeric between 1 and 9007199254740991 then (v_item ->> 'sequence')::bigint end;
+    if v_at is null or v_installation is null or v_sequence is null or not skene.measurement_text_ok(v_name)
+      or num_nonnulls(v_person, v_anonymous) <> 1
+      or v_person is not null and not skene.measurement_text_ok(v_person)
+      or v_anonymous is not null and not skene.measurement_text_ok(v_anonymous)
+      or not skene.properties_ok(v_properties) then
+      event_id := v_id; status := 'invalid'; received_at := null;
+      return next;
+      continue;
+    end if;
+    -- The table's two keys do the deduplication: a new id lands, anything else is compared. Only an
+    -- event timed within the window lands: at most 5 minutes ahead of the database's clock and at most
+    -- 7 days behind it, the SDK's maximum buffer age. Outside it, an identical retry of an event
+    -- stored earlier is still a duplicate, and anything else is invalid.
+    v_received := null;
+    if v_at between pg_catalog.now() - interval '7 days' and pg_catalog.now() + interval '5 minutes' then
+      insert into skene.events as e (event_id, event_name, occurred_at, person_id, anonymous_id, installation_id,
+          sequence, properties, origin)
+        values (v_id, v_name, v_at, v_person, v_anonymous, v_installation, v_sequence, v_properties, v_origin)
+        on conflict do nothing
+        returning e.received_at into v_received;
+    end if;
+    if v_received is not null then
+      event_id := v_id; status := 'accepted'; received_at := v_received;
+      return next;
+      continue;
+    end if;
+    select * into v_first from skene.events e where e.event_id = v_id;
+    if found and (v_first.event_name, v_first.occurred_at, v_first.person_id, v_first.anonymous_id,
+        v_first.installation_id, v_first.sequence, v_first.properties)
+      is not distinct from (v_name, v_at, v_person, v_anonymous, v_installation, v_sequence, v_properties) then
+      event_id := v_id; status := 'duplicate'; received_at := v_first.received_at;
+    elsif v_at not between pg_catalog.now() - interval '7 days' and pg_catalog.now() + interval '5 minutes' then
+      event_id := v_id; status := 'invalid'; received_at := null;
+    else
+      event_id := v_id; status := 'conflict'; received_at := null;
+    end if;
+    return next;
+  end loop;
+end;
+$$;
+
+-- Each run of sequence numbers an installation skipped, per origin. The missing events were numbered
+-- between the two delivered events around the run, so they happened between those two times (either
+-- order, if the device's clock moved back). A run before an installation's first delivered event has
+-- no earlier event. The span a gap may cover (gap_from to gap_to) is also held to what its events'
+-- receive times allow: the kit refuses an event timed more than 7 days before it arrived or more than
+-- 5 minutes after, so a missing event that could still have landed lies within those bounds.
+create view skene.sequence_gaps as
+select s.installation_id, s.origin, s.previous_sequence, s.sequence as next_sequence,
+  s.sequence - coalesce(s.previous_sequence, 0) - 1 as missing,
+  s.previous_occurred_at as after_occurred_at, s.occurred_at as before_occurred_at,
+  case when s.previous_sequence is null then s.received_at - interval '7 days'
+    else greatest(least(s.previous_occurred_at, s.occurred_at), least(s.previous_received_at, s.received_at) - interval '7 days')
+  end as gap_from,
+  least(greatest(s.previous_occurred_at, s.occurred_at),
+    greatest(s.previous_received_at, s.received_at) + interval '5 minutes') as gap_to
+from (select e.installation_id, e.origin, e.sequence, e.occurred_at, e.received_at,
+    lag(e.sequence) over w as previous_sequence, lag(e.occurred_at) over w as previous_occurred_at,
+    lag(e.received_at) over w as previous_received_at
+  from skene.events e window w as (partition by e.installation_id, e.origin order by e.sequence)) s
+where coalesce(s.previous_sequence, 0) + 1 < s.sequence;
+
+-- The read contract (docs/adr/20261005-destination-read-contract.md), plus properties and origin.
+create view skene.measurement_events as
+select e.event_id::text as event_id, e.person_id, e.anonymous_id, e.event_name, e.occurred_at,
+  e.properties, e.origin
+from skene.events e;
+
+create table skene.measurement_packages (
+  snapshot_reference text primary key,
+  source_id text not null,
+  query_contract text not null check (query_contract in ('postgres-package-0001', 'postgres-package-0002')),
+  from_inclusive_ms bigint not null check (from_inclusive_ms >= 0),
+  to_exclusive_ms bigint not null,
+  event_names text[] not null,
+  row_count integer not null check (row_count between 0 and 50000),
+  rows_sha256 text not null check (length(rows_sha256) = 64),
+  browser_rows integer not null check (browser_rows between 0 and row_count),
+  browser_gaps integer not null default 0 check (browser_gaps >= 0),
+  browser_gap_installations uuid[] not null default '{}',
+  sealed_at timestamptz not null default now(),
+  check (from_inclusive_ms < to_exclusive_ms)
+);
+create table skene.measurement_package_events (
+  snapshot_reference text not null references skene.measurement_packages(snapshot_reference)
+    on delete cascade deferrable initially deferred,
+  event_id text not null,
+  person_id text,
+  anonymous_id text,
+  event_name text not null,
+  occurred_at timestamptz not null,
+  entry_properties jsonb,
+  origin text not null,
+  primary key (snapshot_reference, event_id)
+);
+
+-- Seal one closed interval [p_from, p_to) of the declared events into a package, and return the
+-- manifest Skene's owner qualification must match, with how many rows a browser sent and which event
+-- names they carry, and how many browser installations' sequence gaps overlap the interval and whose. Without p_entry_property_keys the package is postgres-package-0001; with them it is
+-- 0002 and each row seals those keys of its properties. The digest is the worker's
+-- (lib/measurement-sources/qualified-package.ts): one line per row, ordered by occurred_at, event_id in
+-- C collation, each JSON.stringify([event_id, person_id, anonymous_id, event_name, occurred_at_ms(,
+-- pairs)]) followed by a line feed.
+create function skene.seal_measurement_package(p_snapshot_reference text, p_source_id text,
+  p_from timestamptz, p_to timestamptz, p_event_names text[], p_entry_property_keys text[] default null)
+returns table (source_id text, query_contract text, snapshot_reference text, from_inclusive_ms bigint,
+  to_exclusive_ms bigint, event_names text[], row_count integer, rows_sha256 text, browser_rows integer,
+  browser_event_names text[], browser_gaps integer, browser_gap_installations uuid[], sealed_at timestamptz)
+language plpgsql security invoker set search_path = '' as $$
+declare
+  v_from_ms bigint;
+  v_to_ms bigint;
+  v_contract text := case when p_entry_property_keys is null then 'postgres-package-0001' else 'postgres-package-0002' end;
+  v_count integer;
+  v_problem bigint;
+  v_browser_gaps bigint;
+  v_browser_installations uuid[];
+  v_digest text;
+begin
+  if not skene.measurement_text_ok(p_snapshot_reference) or not skene.measurement_text_ok(p_source_id) then
+    raise exception 'A package needs a snapshot reference and a source id of 1 to 200 characters, trimmed, without control characters';
+  end if;
+  if p_from is null or p_to is null or not isfinite(p_from) or not isfinite(p_to) or p_from >= p_to
+    or date_trunc('milliseconds', p_from) <> p_from or date_trunc('milliseconds', p_to) <> p_to
+    or p_from < 'epoch'::timestamptz then
+    raise exception 'A package needs a closed interval from before to after, on whole milliseconds, not before 1970';
+  end if;
+  v_from_ms := (extract(epoch from p_from) * 1000)::bigint;
+  v_to_ms := (extract(epoch from p_to) * 1000)::bigint;
+  if p_event_names is null or cardinality(p_event_names) not between 2 and 20
+    or exists (select 1 from unnest(p_event_names) n where not skene.measurement_text_ok(n))
+    or p_event_names is distinct from (select array_agg(distinct n collate "C" order by n collate "C") from unnest(p_event_names) n) then
+    raise exception 'A package needs 2 to 20 distinct event names, sorted by code point';
+  end if;
+  if p_entry_property_keys is not null and (cardinality(p_entry_property_keys) not between 1 and 20
+    or exists (select 1 from unnest(p_entry_property_keys) k where not skene.measurement_text_ok(k, 120))
+    or (select count(distinct k) from unnest(p_entry_property_keys) k) <> cardinality(p_entry_property_keys)) then
+    raise exception 'Entry property keys are 1 to 20 distinct names of at most 120 characters';
+  end if;
+  if exists (select 1 from skene.measurement_packages m where m.snapshot_reference = p_snapshot_reference) then
+    raise exception 'Snapshot % is already sealed; a package is never resealed', p_snapshot_reference;
+  end if;
+  -- An incomplete interval is never sealed: a numbered event that never arrived may have happened in it.
+  -- Only a server installation's gap refuses: anyone holding the public key can forge a browser gap,
+  -- so those are reported in the manifest for the owner to judge instead.
+  select count(*) filter (where g.origin = 'server'), count(*) filter (where g.origin = 'browser'),
+      coalesce(array_agg(distinct g.installation_id order by g.installation_id) filter (where g.origin = 'browser'), '{}')
+    into v_problem, v_browser_gaps, v_browser_installations
+    from skene.sequence_gaps g where g.gap_from < p_to and g.gap_to >= p_from;
+  if v_problem > 0 then
+    raise exception '% server sequence gaps overlap this interval, so it is incomplete; it was not sealed', v_problem;
+  end if;
+  insert into skene.measurement_package_events(snapshot_reference, event_id, person_id, anonymous_id,
+      event_name, occurred_at, entry_properties, origin)
+    select p_snapshot_reference, m.event_id, m.person_id, m.anonymous_id, m.event_name, m.occurred_at,
+      case when p_entry_property_keys is null then null
+        else (select jsonb_object_agg(k, m.properties -> k) from unnest(p_entry_property_keys) k
+          where m.properties ? k and jsonb_typeof(m.properties -> k) <> 'null') end,
+      m.origin
+    from skene.measurement_events m
+    where m.event_name = any(p_event_names) and m.occurred_at >= p_from and m.occurred_at < p_to;
+  get diagnostics v_count = row_count;
+  if v_count > 50000 then
+    raise exception 'The interval holds % rows; a package holds at most 50,000', v_count;
+  end if;
+  select count(*) into v_problem from skene.measurement_package_events r
+    where r.snapshot_reference = p_snapshot_reference and (not skene.measurement_text_ok(r.event_id)
+      or r.person_id is not null and not skene.measurement_text_ok(r.person_id)
+      or r.anonymous_id is not null and not skene.measurement_text_ok(r.anonymous_id)
+      or exists (select 1 from jsonb_each(coalesce(r.entry_properties, '{}'::jsonb)) p
+        where skene.measurement_property_json(p.value) is null));
+  if v_problem > 0 then
+    raise exception '% rows carry an id over 200 characters, padded or with a control character, or an entry property that is not short text, a safe integer or a boolean; nothing was sealed', v_problem;
+  end if;
+  select encode(sha256(convert_to(coalesce(string_agg(
+      '[' || to_json(r.event_id)::text || ',' || coalesce(to_json(r.person_id)::text, 'null')
+      || ',' || coalesce(to_json(r.anonymous_id)::text, 'null') || ',' || to_json(r.event_name)::text
+      || ',' || trunc(extract(epoch from r.occurred_at) * 1000)::bigint::text
+      || case when v_contract = 'postgres-package-0001' then ''
+        else ',' || coalesce((select '[' || string_agg('[' || to_json(p.key)::text || ','
+          || skene.measurement_property_json(p.value) || ']', ',' order by p.key collate "C") || ']'
+          from jsonb_each(r.entry_properties) p), 'null') end
+      || ']' || E'\n', '' order by r.occurred_at, r.event_id collate "C"), ''), 'UTF8')), 'hex')
+    into v_digest
+    from skene.measurement_package_events r where r.snapshot_reference = p_snapshot_reference;
+  insert into skene.measurement_packages(snapshot_reference, source_id, query_contract, from_inclusive_ms,
+      to_exclusive_ms, event_names, row_count, rows_sha256, browser_rows, browser_gaps, browser_gap_installations)
+    values (p_snapshot_reference, p_source_id, v_contract, v_from_ms, v_to_ms, p_event_names, v_count, v_digest,
+      (select count(*) from skene.measurement_package_events r
+        where r.snapshot_reference = p_snapshot_reference and r.origin = 'browser'),
+      v_browser_gaps, v_browser_installations);
+  return query select m.source_id, m.query_contract, m.snapshot_reference, m.from_inclusive_ms, m.to_exclusive_ms,
+    m.event_names, m.row_count, m.rows_sha256, m.browser_rows,
+    coalesce((select array_agg(distinct r.event_name collate "C" order by r.event_name collate "C")
+      from skene.measurement_package_events r
+      where r.snapshot_reference = p_snapshot_reference and r.origin = 'browser'), '{}'::text[]),
+    m.browser_gaps, m.browser_gap_installations, m.sealed_at from skene.measurement_packages m
+    where m.snapshot_reference = p_snapshot_reference;
+end;
+$$;
+
+revoke all on function skene.collect_events(jsonb) from public;
+revoke all on function skene.seal_measurement_package(text, text, timestamptz, timestamptz, text[], text[]) from public;
+revoke all on function skene.measurement_text_ok(text, integer) from public;
+revoke all on function skene.measurement_property_json(jsonb) from public;
+revoke all on function skene.canonical_uuid(jsonb) from public;
+revoke all on function skene.canonical_time(jsonb) from public;
+revoke all on function skene.properties_ok(jsonb) from public;
+revoke all on function skene.refuse_event_update() from public;
+revoke all on skene.events, skene.sequence_gaps, skene.measurement_events, skene.measurement_packages,
+  skene.measurement_package_events from public;
+
+-- On Supabase: the public key's roles and the secret key's role may call collect_events, nothing else.
+do $$
+declare
+  r text;
+begin
+  foreach r in array array['anon', 'authenticated', 'service_role'] loop
+    if exists (select 1 from pg_catalog.pg_roles where rolname = r) then
+      execute format('grant usage on schema skene to %I', r);
+      execute format('grant execute on function skene.collect_events(jsonb) to %I', r);
+    end if;
+  end loop;
+end;
+$$;
+commit;

package/kit/rollback.sql

@@ -0,0 +1,28 @@
+-- Rollback of apply.sql, run by the same role in the same database. The collected events and the
+-- sealed packages are the customer's records: the rollback refuses while either holds a row, so
+-- nothing is discarded by it. Move or delete them first if they should go (deleting a package expires
+-- its snapshot: a measurement bound to it then reports the snapshot as expired, never a read of
+-- current rows). Then it removes schema skene and everything the kit created in it.
+begin;
+do $$
+begin
+  if exists (select 1 from skene.measurement_packages) or exists (select 1 from skene.events) then
+    raise exception 'The Flows SDK kit rollback keeps collected events and sealed packages; move or delete them first';
+  end if;
+end;
+$$;
+drop function skene.seal_measurement_package(text, text, timestamptz, timestamptz, text[], text[]);
+drop table skene.measurement_package_events;
+drop table skene.measurement_packages;
+drop view skene.measurement_events;
+drop view skene.sequence_gaps;
+drop function skene.collect_events(jsonb);
+drop table skene.events;
+drop function skene.refuse_event_update();
+drop function skene.properties_ok(jsonb);
+drop function skene.canonical_time(jsonb);
+drop function skene.canonical_uuid(jsonb);
+drop function skene.measurement_property_json(jsonb);
+drop function skene.measurement_text_ok(text, integer);
+drop schema skene;
+commit;

package/package.json

@@ -1,6 +1,32 @@
 {
   "name": "@skene/flows-sdk",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Skene Flows SDK: numbers, buffers and writes product events into your own database through the Flows SDK kit's skene.collect_events.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "kit",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SkeneTechnologies/skene-cloud-rebuild.git",
+    "directory": "packages/flows-sdk"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org",
+    "provenance": false
+  }
+}