@marktiderman/genesis-chat 0.0.0-stage → 0.1.1

package/dist/client-BtdALFCx.d.ts

@@ -0,0 +1,349 @@
+import { SupabaseClient } from '@supabase/supabase-js';
+
+/**
+ * @feat:chat
+ * The chat contract: what the genesis_chat schema (migration 0001) stores, in
+ * the app's words. Everything here is plain data, shared by web, native and
+ * the server.
+ */
+/** owner, admin or member of a conversation; observer when the kind's observer check lets you read it. */
+type ChatRole = "owner" | "admin" | "member" | "observer";
+/** Built in: image, file, voice, video, link. Apps add their own (form, lesson, worksheet…). */
+type AttachmentKind = "image" | "file" | "voice" | "video" | "link" | (string & {});
+type AttachmentProvider = "storage" | "mux" | "cloudflare" | "external" | "none";
+interface ChatAttachment {
+    id: string;
+    messageId: string;
+    position: number;
+    kind: AttachmentKind;
+    /** The app's reference for its own kinds, e.g. `{ formId, versionHash }`. */
+    ref: Record<string, unknown>;
+    provider: AttachmentProvider;
+    /** The object in the genesis-chat bucket (`<conversation>/<uploader>/<name>.<ext>`). */
+    path: string | null;
+    providerId: string | null;
+    playbackId: string | null;
+    url: string | null;
+    status: "pending" | "ready" | "failed";
+    name: string | null;
+    mime: string | null;
+    bytes: number | null;
+    width: number | null;
+    height: number | null;
+    durationMs: number | null;
+    /** Peaks 0–100, at most 128, drawn before the audio loads. */
+    waveform: number[] | null;
+    posterPath: string | null;
+    thumbhash: string | null;
+    transcript: string | null;
+    transcriptStatus: "pending" | "ready" | "failed" | "off" | null;
+}
+interface ChatReaction {
+    emoji: string;
+    userId: string;
+}
+interface ChatMessage {
+    id: string;
+    conversationId: string;
+    seq: number;
+    clientId: string;
+    senderId: string | null;
+    senderRole: ChatRole | "system";
+    kind: "text" | "system";
+    /** Markdown. Empty for a deleted message. */
+    body: string;
+    mentions: string[];
+    replyToId: string | null;
+    threadRootId: string | null;
+    threadCount: number;
+    threadLastAt: string | null;
+    topic: string | null;
+    visibility: "everyone" | "observers";
+    silent: boolean;
+    meta: Record<string, unknown>;
+    createdAt: string;
+    editedAt: string | null;
+    deletedAt: string | null;
+    attachments: ChatAttachment[];
+    reactions: ChatReaction[];
+}
+interface ChatConversation {
+    id: string;
+    kind: string;
+    title: string | null;
+    subjectType: string | null;
+    subjectId: string | null;
+    settings: {
+        who_posts?: "members" | "admins";
+    } & Record<string, unknown>;
+    status: "open" | "pending" | "solved" | "closed" | null;
+    assigneeId: string | null;
+    lastSeq: number;
+    lastMessageAt: string | null;
+    createdAt: string;
+    archivedAt: string | null;
+}
+interface ChatMember {
+    conversationId: string;
+    userId: string;
+    role: ChatRole;
+    lastReadSeq: number;
+    joinedAt: string;
+}
+/** A kind's rules, as genesis_chat.kinds holds them. */
+interface ChatKindRules {
+    kind: string;
+    label: string;
+    /** 2 for a direct conversation. */
+    maxMembers: number | null;
+    whoPosts: "members" | "admins";
+    membership: "app" | "admins";
+    threads: boolean;
+    observersPost: boolean;
+}
+/** The latest message, as the inbox previews it. */
+interface ChatPreview {
+    id: string;
+    seq: number;
+    senderId: string | null;
+    kind: "text" | "system";
+    body: string;
+    deleted: boolean;
+    createdAt: string;
+    attachment: AttachmentKind | null;
+}
+interface ChatInboxItem {
+    conversationId: string;
+    kind: string;
+    title: string | null;
+    subjectType: string | null;
+    subjectId: string | null;
+    status: ChatConversation["status"];
+    role: ChatRole;
+    /** The other person, in a two-person kind. */
+    otherUserId: string | null;
+    memberCount: number;
+    lastSeq: number;
+    lastReadSeq: number;
+    /** Counted to 99. */
+    unread: number;
+    mentioned: boolean;
+    muted: boolean;
+    pinned: boolean;
+    archived: boolean;
+    lastMessageAt: string | null;
+    lastMessage: ChatPreview | null;
+}
+/** What a sender attaches; files are uploaded first (ChatClient.upload). */
+interface AttachmentInput {
+    kind: AttachmentKind;
+    path?: string;
+    provider?: AttachmentProvider;
+    providerId?: string;
+    url?: string;
+    ref?: Record<string, unknown>;
+    status?: "pending" | "ready";
+    name?: string;
+    mime?: string;
+    bytes?: number;
+    width?: number;
+    height?: number;
+    durationMs?: number;
+    waveform?: number[];
+    posterPath?: string;
+    thumbhash?: string;
+}
+interface SendInput {
+    conversationId: string;
+    /** Made once per message on the device, so a retry never posts twice. */
+    clientId: string;
+    body?: string;
+    attachments?: AttachmentInput[];
+    replyToId?: string | null;
+    threadRootId?: string | null;
+    topic?: string | null;
+    mentions?: string[];
+    visibility?: "everyone" | "observers";
+    silent?: boolean;
+}
+/** A message on its way: shown at once, swapped for the server's when it lands. */
+interface PendingMessage {
+    clientId: string;
+    input: SendInput;
+    senderId: string;
+    createdAt: string;
+    status: "sending" | "failed";
+    error?: string;
+    /** Local previews for files still uploading (object URLs or file URIs). */
+    previews?: Record<number, string>;
+    /** What each file is, in order, so a pending bubble can draw it (a voice note's duration and waveform, a file's name). */
+    files?: PendingFile[];
+}
+interface PendingFile {
+    name: string;
+    contentType: string;
+    kind: AttachmentKind;
+    meta?: Partial<AttachmentInput>;
+    /** Not kept between launches (bytes with nowhere to save them): attach it again. */
+    lost?: boolean;
+}
+/** A live hint from Realtime: something changed; fetch to see what. */
+type ChatSignal = {
+    type: "message";
+    conversationId: string;
+    id: string;
+    seq?: number;
+    op: "insert" | "update";
+} | {
+    type: "reaction";
+    conversationId: string;
+    messageId: string;
+} | {
+    type: "members";
+    conversationId: string;
+} | {
+    type: "conversation";
+    conversationId: string;
+} | {
+    type: "inbox";
+    conversationId: string;
+    seq?: number;
+};
+/** Ephemeral, never stored: someone typing or recording. */
+interface ChatActivity {
+    userId: string;
+    activity: "typing" | "recording-voice" | "recording-video";
+    at: number;
+}
+
+/**
+ * @feat:chat
+ * The chat client: the app's own Supabase (migration 0001, the genesis_chat
+ * schema) under row level security. Reads are table selects; every write is a
+ * genesis_chat function. Live updates are hints on private Realtime topics,
+ * after which the client fetches again, so nothing is trusted from the wire.
+ */
+
+/** Any supabase-js client; the app's generated Database types don't need to list genesis_chat. */
+type ChatSupabase = SupabaseClient<any, any, any>;
+declare const CHAT_SCHEMA = "genesis_chat";
+declare const CHAT_BUCKET = "genesis-chat";
+declare const conversationTopic: (conversationId: string) => string;
+declare const userTopic: (userId: string) => string;
+/** A refusal from the database, with its SQLSTATE (`42501` not allowed, `22023` bad input, `GS429` too many). */
+declare class ChatError extends Error {
+    readonly code: string | undefined;
+    readonly operation: string;
+    constructor(message: string, code: string | undefined, operation: string);
+    get forbidden(): boolean;
+    get rateLimited(): boolean;
+    /** Worth trying again: the network, not the database, said no. */
+    get transient(): boolean;
+}
+type Row = Record<string, unknown>;
+declare function toAttachment(r: Row): ChatAttachment;
+declare function toMessage(r: Row): ChatMessage;
+interface MessagePage {
+    messages: ChatMessage[];
+    /** More, older messages exist before the first one. */
+    hasEarlier: boolean;
+}
+interface ChatClientOptions {
+    /** Signed file links live this long (seconds). Default an hour. */
+    signedUrlSeconds?: number;
+}
+interface Subscription {
+    unsubscribe(): void;
+}
+interface ConversationChannel extends Subscription {
+    /** Tell the others you are typing or recording (throttle to once every 3 seconds). */
+    signal(activity: ChatActivity["activity"]): void;
+}
+declare function createChatClient(supabase: ChatSupabase, options?: ChatClientOptions): {
+    supabase: ChatSupabase;
+    inbox(opts?: {
+        kind?: string;
+        archived?: boolean;
+        limit?: number;
+        before?: string;
+    }): Promise<ChatInboxItem[]>;
+    observed(kind: string, opts?: {
+        status?: string;
+        limit?: number;
+        before?: string;
+    }): Promise<Row[]>;
+    unreadTotal(): Promise<number>;
+    conversation(id: string): Promise<ChatConversation | null>;
+    /** A kind's rules (how many members, who posts, threads), for what the UI offers. */
+    kind(kind: string): Promise<ChatKindRules | null>;
+    myRole(id: string): Promise<ChatRole | null>;
+    canPost(id: string): Promise<boolean>;
+    members(id: string): Promise<ChatMember[]>;
+    /**
+     * A page of messages, oldest first: the latest `limit` (default 50), or those
+     * before `beforeSeq`, or (to catch up after a reconnect) those after `afterSeq`.
+     * A thread's replies with `threadRootId`; one topic's with `topic`.
+     */
+    messages(conversationId: string, opts?: {
+        beforeSeq?: number;
+        afterSeq?: number;
+        limit?: number;
+        threadRootId?: string;
+        topic?: string;
+    }): Promise<MessagePage>;
+    message(id: string): Promise<ChatMessage | null>;
+    startConversation(kind: string, memberIds: string[], opts?: {
+        title?: string;
+        subjectType?: string;
+        subjectId?: string;
+    }): Promise<string>;
+    /** Sends a message. Safe to retry with the same clientId. */
+    send(input: SendInput): Promise<ChatMessage>;
+    edit(messageId: string, body: string, mentions?: string[]): Promise<ChatMessage>;
+    remove(messageId: string): Promise<void>;
+    react(messageId: string, emoji: string, on?: boolean): Promise<void>;
+    markRead(conversationId: string, seq?: number): Promise<number>;
+    setMySettings(conversationId: string, s: {
+        mutedUntil?: string | null;
+        notify?: "all" | "mentions" | "none";
+        archived?: boolean;
+        pinned?: boolean;
+    }): Promise<void>;
+    updateConversation(conversationId: string, s: {
+        title?: string;
+        settings?: Record<string, unknown>;
+    }): Promise<void>;
+    addMembers(conversationId: string, userIds: string[]): Promise<void>;
+    removeMember(conversationId: string, userId?: string): Promise<void>;
+    setStatus(conversationId: string, status: ChatConversation["status"], assigneeId?: string | null): Promise<void>;
+    pin(messageId: string, on?: boolean): Promise<void>;
+    pins(conversationId: string): Promise<string[]>;
+    save(messageId: string, on?: boolean, note?: string): Promise<void>;
+    report(messageId: string, reason: "spam" | "harassment" | "safety" | "other", note?: string): Promise<string>;
+    /**
+     * Uploads a file into the conversation's folder for the signed-in person and
+     * returns its path, ready to attach. Resumable for big files is the native
+     * renderer's job (Supabase TUS); this is the plain upload.
+     */
+    upload(conversationId: string, userId: string, file: Blob | ArrayBuffer, opts: {
+        name: string;
+        contentType: string;
+        id?: string;
+    }): Promise<string>;
+    /** Signed links for files, cached until shortly before they expire. */
+    fileUrls(paths: string[]): Promise<Record<string, string>>;
+    /** Your inbox's live hints (a new message anywhere you are, a membership change). */
+    subscribeInbox(userId: string, onSignal: (s: ChatSignal) => void): Subscription;
+    /**
+     * A conversation's live hints, plus who is typing or recording. `onReconnect`
+     * runs whenever the channel (re)joins, the moment to fetch what was missed.
+     */
+    subscribeConversation(conversationId: string, me: string, handlers: {
+        onSignal: (s: ChatSignal) => void;
+        onActivity?: (a: ChatActivity) => void;
+        onReconnect?: () => void;
+    }): ConversationChannel;
+};
+type ChatClient = ReturnType<typeof createChatClient>;
+
+export { type AttachmentKind as A, type ChatClient as C, type MessagePage as M, type PendingMessage as P, type SendInput as S, type ChatConversation as a, type ChatMember as b, type ChatRole as c, type ChatKindRules as d, type ChatMessage as e, type ChatActivity as f, type ChatSignal as g, type ChatInboxItem as h, type ChatSupabase as i, type ChatAttachment as j, type AttachmentInput as k, type PendingFile as l, type AttachmentProvider as m, CHAT_BUCKET as n, CHAT_SCHEMA as o, type ChatClientOptions as p, ChatError as q, type ChatPreview as r, type ChatReaction as s, type ConversationChannel as t, type Subscription as u, conversationTopic as v, createChatClient as w, toAttachment as x, toMessage as y, userTopic as z };

package/dist/index.d.ts

@@ -0,0 +1,185 @@
+import { A as AttachmentKind, e as ChatMessage, P as PendingMessage, f as ChatActivity, k as AttachmentInput, C as ChatClient, l as PendingFile, S as SendInput } from './client-BtdALFCx.js';
+export { m as AttachmentProvider, n as CHAT_BUCKET, o as CHAT_SCHEMA, j as ChatAttachment, p as ChatClientOptions, a as ChatConversation, q as ChatError, h as ChatInboxItem, d as ChatKindRules, b as ChatMember, r as ChatPreview, s as ChatReaction, c as ChatRole, g as ChatSignal, i as ChatSupabase, t as ConversationChannel, M as MessagePage, u as Subscription, v as conversationTopic, w as createChatClient, x as toAttachment, y as toMessage, z as userTopic } from './client-BtdALFCx.js';
+import '@supabase/supabase-js';
+
+/**
+ * @feat:chat
+ * Media rules shared by every platform: which files may be sent (the same list
+ * migration 0001 checks), what kind an upload becomes, the default limits, and
+ * the waveform a voice note carries so its bubble draws before the audio loads.
+ */
+
+/**
+ * A random UUID (v4): `crypto.randomUUID` where the platform has it (some React Native
+ * runtimes don't), else `crypto.getRandomValues`, else Math.random as a last resort. Ids
+ * only need to be unique per sender: the server checks (sender, client_id).
+ */
+declare function randomId(): string;
+/** Mirrors genesis_chat.allowed_extension. Never SVG or HTML, which a browser runs as a page. */
+declare const ALLOWED_EXTENSIONS: readonly ["png", "jpg", "jpeg", "webp", "gif", "heic", "heif", "m4a", "aac", "mp3", "ogg", "oga", "opus", "weba", "webm", "mp4", "mov", "pdf", "txt", "csv", "docx", "xlsx", "pptx"];
+/** The extension a file is stored under: from its content type, else its name. */
+declare function fileExtension(name: string, contentType?: string): string;
+declare function isAllowedExtension(ext: string): boolean;
+/** What an upload becomes in a message. */
+declare function attachmentKindFor(contentType: string, opts?: {
+    recordedVoice?: boolean;
+}): AttachmentKind;
+/** Default limits (decision 5): an app may lower them, not raise them past the bucket's 100 MB. */
+declare const CHAT_LIMITS: {
+    /** Voice notes and videos, for members. */
+    readonly recordingMs: number;
+    /** For owners, admins and observers (coaches, staff). */
+    readonly staffRecordingMs: number;
+    readonly fileBytes: number;
+    readonly videoBytes: number;
+    readonly attachmentsPerMessage: 20;
+    readonly bodyChars: 10000;
+};
+/** The longest recording this role may make. */
+declare function recordingLimitMs(role: string | null | undefined): number;
+/**
+ * Peaks for a waveform: `count` values 0–100 from raw samples (-1…1), the loudest
+ * in each bucket, scaled so the loudest bucket is 100. Quiet recordings still show
+ * a shape; silence shows a flat line.
+ */
+declare function waveformPeaks(samples: ArrayLike<number>, count?: number): number[];
+/**
+ * Peaks from a level meter read while recording (expo-audio's `metering`, in dB,
+ * about -160…0): resampled to `count` values 0–100.
+ */
+declare function waveformFromMetering(levelsDb: number[], count?: number): number[];
+/** 0:42, 1:05:09. */
+declare function formatDuration(ms: number | null | undefined): string;
+/** Playback speeds offered for voice and video (free for everyone, decision 5). */
+declare const PLAYBACK_RATES: readonly [1, 1.5, 2];
+declare function nextPlaybackRate(rate: number): number;
+
+/**
+ * @feat:chat
+ * Pure thread logic, the same on every platform: merging the server's messages
+ * with ones still on their way, grouping a run of messages from one sender,
+ * day dividers, the unread line, reactions by emoji, and the typing line.
+ */
+
+type ThreadItem = {
+    type: "message";
+    message: ChatMessage;
+    pending?: undefined;
+} | {
+    type: "pending";
+    pending: PendingMessage;
+    message?: undefined;
+};
+/**
+ * The server's messages (by seq), then what is still sending, oldest first. A
+ * pending message the server already has (same clientId) is dropped, so a send
+ * that landed never shows twice.
+ */
+declare function mergeThread(server: ChatMessage[], pending: PendingMessage[]): ThreadItem[];
+/** Adds or replaces messages in a page, keeping it sorted and free of duplicates. */
+declare function upsertMessages(existing: ChatMessage[], incoming: ChatMessage[]): ChatMessage[];
+declare function itemSender(item: ThreadItem): string | null;
+declare function itemTime(item: ThreadItem): string;
+/** Runs of one sender within five minutes share a header (name, avatar). */
+declare function startsGroup(items: ThreadItem[], index: number, gapMs?: number): boolean;
+declare function sameDay(a: string, b: string): boolean;
+/** A day divider goes before this item. */
+declare function startsDay(items: ThreadItem[], index: number): boolean;
+/** "Today", "Yesterday", "Monday", or "12 Mar 2026". */
+declare function dayLabel(iso: string, now?: Date, locale?: string): string;
+/** The first message after what you had read, from someone else: where "New" goes. */
+declare function firstUnreadId(messages: ChatMessage[], lastReadSeq: number, me: string): string | null;
+interface ReactionSummary {
+    emoji: string;
+    count: number;
+    mine: boolean;
+    userIds: string[];
+}
+/** Reactions by emoji, most first, then in first-used order. */
+declare function summarizeReactions(message: ChatMessage, me: string): ReactionSummary[];
+/** Who is doing what now: activity older than six seconds has stopped. */
+declare function currentActivity(activity: ChatActivity[], now?: number, staleMs?: number): ChatActivity[];
+/** "Sam is typing…", "Sam and Lee are typing…", "Sam is recording a voice message…". */
+declare function activityLine(activity: ChatActivity[], nameOf: (userId: string) => string): string | null;
+/** Sends activity at most once every `everyMs`. */
+declare function throttle(fn: () => void, everyMs?: number): () => void;
+/** The ids @mentioned in markdown written as `@[Name](user:<uuid>)`. */
+declare function parseMentions(body: string): string[];
+/** A one-line preview: text, or what was attached. */
+declare function previewText(body: string, attachment: string | null | undefined, deleted?: boolean): string;
+
+/**
+ * @feat:chat
+ * The send queue: a message shows at once as pending, its files upload, then it
+ * is sent with the clientId made when it was written, so a retry (after a lost
+ * connection, a closed app) never posts twice. Messages to one conversation go
+ * in the order they were written. Storage is the platform's (memory by default;
+ * localStorage on web, MMKV or SQLite on native), behind OutboxStore.
+ */
+
+/** A file still on the device, uploaded when its message is sent. */
+interface LocalFile {
+    /** The bytes, or (native) a file URI the platform reads in `readFile`. */
+    data: Blob | ArrayBuffer | string;
+    name: string;
+    contentType: string;
+    /** A preview to show while it uploads (an object URL, a file URI). */
+    previewUrl?: string;
+    /** Known up front: a voice note's duration and waveform, a photo's size. */
+    meta?: Partial<Omit<AttachmentInput, "path" | "kind">> & {
+        kind?: AttachmentInput["kind"];
+    };
+}
+interface QueuedMessage extends Omit<PendingMessage, "files"> {
+    files: LocalFile[];
+    /** What each file is, kept with the saved copy (PendingMessage.files). */
+    pendingFiles?: PendingFile[];
+    /** Files lost on a relaunch (bytes that weren't persisted). */
+    lostFiles?: number;
+    attempts: number;
+}
+interface OutboxStore {
+    load(): Promise<QueuedMessage[]>;
+    save(queue: QueuedMessage[]): Promise<void>;
+}
+declare const memoryOutboxStore: () => OutboxStore;
+interface OutboxOptions {
+    client: ChatClient;
+    userId: string;
+    store?: OutboxStore;
+    /** Reads a native file URI into bytes for upload. */
+    readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
+    /** Upload hook, e.g. resumable uploads on native. Defaults to client.upload. */
+    upload?: (conversationId: string, file: LocalFile) => Promise<string>;
+    /** Called with every change, for the UI. */
+    onChange?: (queue: QueuedMessage[]) => void;
+    /** Called when a message lands. */
+    onSent?: (message: ChatMessage, clientId: string) => void;
+    /** Makes client ids. Default: a random UUID (works where crypto.randomUUID is missing). */
+    newId?: () => string;
+    /**
+     * Keeps a file held as bytes (a pasted image, a recording) between launches: write it
+     * somewhere and return a URI `readFile` can read (native: the app's cache directory).
+     * Without it, such a file isn't saved, and after a relaunch its message asks for it again.
+     */
+    persistFile?: (file: LocalFile) => Promise<string>;
+}
+declare function createOutbox(opts: OutboxOptions): {
+    /** Queues a message; it shows at once and sends in order. Returns its clientId. */
+    send(input: Omit<SendInput, "clientId"> & {
+        clientId?: string;
+    }, files?: LocalFile[]): Promise<string>;
+    retry(clientId: string): Promise<void>;
+    /** Gives a message whose files were lost on a relaunch its files again, and sends it. */
+    reattach(clientId: string, files: LocalFile[]): Promise<void>;
+    /** Retries every failed message (after the connection comes back). */
+    retryAll(): Promise<void>;
+    discard(clientId: string): Promise<void>;
+    pending(conversationId?: string): PendingMessage[];
+    /** A new client id, made the way this outbox makes them. */
+    newId: typeof randomId;
+    load: () => Promise<void>;
+};
+type Outbox = ReturnType<typeof createOutbox>;
+
+export { ALLOWED_EXTENSIONS, AttachmentInput, AttachmentKind, CHAT_LIMITS, ChatActivity, ChatClient, ChatMessage, type LocalFile, type Outbox, type OutboxOptions, type OutboxStore, PLAYBACK_RATES, PendingFile, PendingMessage, type QueuedMessage, type ReactionSummary, SendInput, type ThreadItem, activityLine, attachmentKindFor, createOutbox, currentActivity, dayLabel, fileExtension, firstUnreadId, formatDuration, isAllowedExtension, itemSender, itemTime, memoryOutboxStore, mergeThread, nextPlaybackRate, parseMentions, previewText, randomId, recordingLimitMs, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages, waveformFromMetering, waveformPeaks };

package/dist/index.js

@@ -0,0 +1,4 @@
+export { activityLine, createOutbox, currentActivity, dayLabel, firstUnreadId, itemSender, itemTime, memoryOutboxStore, mergeThread, parseMentions, previewText, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages } from './chunk-SAY24E6V.js';
+export { ALLOWED_EXTENSIONS, CHAT_BUCKET, CHAT_LIMITS, CHAT_SCHEMA, ChatError, PLAYBACK_RATES, attachmentKindFor, conversationTopic, createChatClient, fileExtension, formatDuration, isAllowedExtension, nextPlaybackRate, randomId, recordingLimitMs, toAttachment, toMessage, userTopic, waveformFromMetering, waveformPeaks } from './chunk-JQXZUEEL.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/native.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/native.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=native.js.map
+//# sourceMappingURL=native.js.map

package/dist/native.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"native.js"}