@arcote.tech/arc 0.3.1 → 0.3.2

package/dist/adapters/event-publisher.d.ts

@@ -75,6 +75,15 @@ export interface EventPublisher {
      * @param views - Array of views to register
      */
     registerViews(views: ArcViewAny[]): void;
+    /**
+     * Subscribe to events of a specific type
+     * Used by listeners to react to events
+     *
+     * @param eventType - Event type name to subscribe to
+     * @param callback - Function to call when event is published
+     * @returns Unsubscribe function
+     */
+    subscribe(eventType: string, callback: (event: ArcEventInstance<ArcEventAny>) => Promise<void> | void): () => void;
 }
 /**
  * Local EventPublisher implementation
@@ -84,6 +93,7 @@ export declare class LocalEventPublisher implements EventPublisher {
     private readonly dataStorage;
     private views;
     private syncCallback?;
+    private subscribers;
     constructor(dataStorage: DataStorage);
     /**
      * Set a callback to be called after each event is published
@@ -94,7 +104,15 @@ export declare class LocalEventPublisher implements EventPublisher {
      * Register views that should be updated when events are published
      */
     registerViews(views: ArcViewAny[]): void;
+    /**
+     * Subscribe to events of a specific type
+     */
+    subscribe(eventType: string, callback: (event: ArcEventInstance<ArcEventAny>) => Promise<void> | void): () => void;
     publish(event: ArcEventInstance<ArcEventAny>): Promise<void>;
+    /**
+     * Notify all subscribers for an event type
+     */
+    private notifySubscribers;
     markSynced(eventIds: string[]): Promise<void>;
     getUnsyncedEvents(eventType?: string): Promise<EventWithSyncStatus[]>;
     /**

package/dist/adapters/index.d.ts

@@ -5,6 +5,7 @@
  * - Wire: Client-server communication
  * - CommandWire: Command execution over network
  * - EventPublisher: Event persistence and synchronization
+ * - QueryWire: Remote view queries via HTTP/SSE
  * - DataStorage: Data persistence (defined elsewhere)
  */
 export { AuthAdapter } from "./auth-adapter";
@@ -12,6 +13,8 @@ export type { DecodedToken } from "./auth-adapter";
 export { CommandWire } from "./command-wire";
 export { EventWire } from "./event-wire";
 export type { ReceivedEvent, SyncableEvent } from "./event-wire";
+export { QueryWire } from "./query-wire";
+export type { StreamConnection } from "./query-wire";
 export { Wire } from "./wire";
 export { EVENT_TABLES, LocalEventPublisher } from "./event-publisher";
 export type { EventPublisher, EventWithSyncStatus, StoredEvent, StoredEventSyncStatus, StoredEventTag, } from "./event-publisher";

package/dist/adapters/query-wire.d.ts

@@ -0,0 +1,34 @@
+/**
+ * QueryWire - Wire adapter for remote view queries via HTTP/SSE
+ *
+ * Provides:
+ * - One-shot queries via HTTP POST
+ * - Live queries via Server-Sent Events (SSE)
+ */
+import { Wire } from "./wire";
+export interface StreamConnection {
+    eventSource: EventSource;
+    unsubscribe: () => void;
+}
+export declare class QueryWire extends Wire {
+    constructor(baseUrl: string);
+    /**
+     * Execute a one-shot query on a view
+     *
+     * @param viewName - Name of the view to query
+     * @param options - Query options (where, orderBy, limit)
+     * @returns Query results
+     */
+    query(viewName: string, options?: any): Promise<any[]>;
+    /**
+     * Create a live query stream using SSE
+     *
+     * @param viewName - Name of the view to stream
+     * @param options - Query options (where, orderBy, limit)
+     * @param callback - Called when data changes
+     * @param token - Auth token for the stream (optional, uses wire token if not provided)
+     * @returns StreamConnection with unsubscribe method
+     */
+    stream(viewName: string, options: any, callback: (data: any[]) => void, token?: string | null): StreamConnection;
+}
+//# sourceMappingURL=query-wire.d.ts.map

package/dist/adapters/wire.d.ts

@@ -5,13 +5,21 @@
  * for making authenticated requests to the server.
  */
 export declare class Wire {
-    private readonly baseUrl;
     private token;
+    protected readonly baseUrl: string;
     constructor(baseUrl: string);
     /**
      * Set authentication token for requests
      */
     setAuthToken(token: string | null): void;
+    /**
+     * Get the current auth token
+     */
+    getAuthToken(): string | null;
+    /**
+     * Get the base URL
+     */
+    getBaseUrl(): string;
     /**
      * Make authenticated fetch request to server
      */

package/dist/context/context.d.ts

@@ -15,7 +15,7 @@ export declare class ArcContext<const Elements extends ArcContextElement<any>[]>
      * @param name - The name of the element to retrieve
      * @returns The element if found, undefined otherwise
      */
-    get(name: string): Elements[number] | undefined;
+    get<E extends Elements[number]>(name: E["name"]): E | undefined;
 }
 /**
  * Create a new context from an array of elements
@@ -33,6 +33,99 @@ export declare class ArcContext<const Elements extends ArcContextElement<any>[]>
  * ```
  */
 export declare function context<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcContext<Elements>;
+/**
+ * Check if an element has a valid queryContext method (returns non-any, non-unknown type)
+ */
+type HasValidQueryContext<E> = E extends {
+    queryContext: (...args: any[]) => infer R;
+} ? unknown extends R ? false : R extends Record<string, any> ? true : false : false;
+/**
+ * Check if an element has a valid mutateContext method (returns non-any, non-unknown type)
+ */
+type HasValidMutateContext<E> = E extends {
+    mutateContext: (...args: any[]) => infer R;
+} ? unknown extends R ? false : R extends ((...args: any[]) => any) | Record<string, any> ? true : false : false;
+/**
+ * Check if an element is a valid context element (has name and at least one valid context method)
+ * Elements without queryContext or mutateContext (like events, listeners) are still valid
+ */
+type IsValidContextElement<E> = E extends ArcContextElement<infer Name> ? Name extends string ? true : false : false;
+/**
+ * Filter type that keeps only valid context elements
+ * Invalid elements are converted to never and filtered out
+ */
+type FilterValidElements<Elements extends readonly any[]> = {
+    [K in keyof Elements]: IsValidContextElement<Elements[K]> extends true ? Elements[K] : never;
+};
+/**
+ * Flatten and filter elements from multiple contexts
+ */
+type MergedElements<Contexts extends ArcContextAny[]> = FilterValidElements<Contexts[number]["elements"]>;
+/**
+ * Debug type that shows which elements have valid queryContext
+ * Hover over this type to see: valid elements show their name, invalid show "⚠️ NO_QUERY: name"
+ *
+ * @example
+ * ```typescript
+ * // Use to debug which elements are missing queryContext:
+ * type Debug = DebugQueryElements<typeof myContext>;
+ * // Hover over Debug to see which elements are valid/invalid
+ * ```
+ */
+export type DebugQueryElements<C extends ArcContextAny> = {
+    [Element in C["elements"][number] as HasValidQueryContext<Element> extends true ? Element["name"] : `⚠️ NO_QUERY: ${Element["name"]}`]: Element extends {
+        queryContext: (...args: any[]) => infer R;
+    } ? R : "no queryContext method";
+};
+/**
+ * Debug type that shows which elements have valid mutateContext
+ * Hover over this type to see: valid elements show their name, invalid show "⚠️ NO_MUTATE: name"
+ *
+ * @example
+ * ```typescript
+ * // Use to debug which elements are missing mutateContext:
+ * type Debug = DebugMutateElements<typeof myContext>;
+ * // Hover over Debug to see which elements are valid/invalid
+ * ```
+ */
+export type DebugMutateElements<C extends ArcContextAny> = {
+    [Element in C["elements"][number] as HasValidMutateContext<Element> extends true ? Element["name"] : `⚠️ NO_MUTATE: ${Element["name"]}`]: Element extends {
+        mutateContext: (...args: any[]) => infer R;
+    } ? R : "no mutateContext method";
+};
+/**
+ * Combined debug type showing both query and mutate status for all elements
+ * Use this to get a complete picture of your context's type health
+ *
+ * @example
+ * ```typescript
+ * // Use to debug all elements:
+ * type Debug = DebugContextElements<typeof myContext>;
+ * // Hover over Debug to see status of all elements
+ * ```
+ */
+export type DebugContextElements<C extends ArcContextAny> = {
+    [Element in C["elements"][number] as Element["name"]]: {
+        name: Element["name"];
+        hasQueryContext: HasValidQueryContext<Element>;
+        hasMutateContext: HasValidMutateContext<Element>;
+        queryContextType: Element extends {
+            queryContext: (...args: any[]) => infer R;
+        } ? R : never;
+        mutateContextType: Element extends {
+            mutateContext: (...args: any[]) => infer R;
+        } ? R : never;
+    };
+};
+/**
+ * Extract only the elements that have issues (no valid query or mutate context when expected)
+ * This filters to show only problematic elements
+ */
+export type DebugInvalidElements<C extends ArcContextAny> = {
+    [Element in C["elements"][number] as HasValidQueryContext<Element> extends false ? HasValidMutateContext<Element> extends false ? Element["name"] : never : never]: {
+        issue: "Element has neither valid queryContext nor mutateContext";
+    };
+};
 /**
  * Merge multiple contexts into one
  *
@@ -43,10 +136,19 @@ export declare function context<const Elements extends ArcContextElement<any>[]>
  * ```typescript
  * const mergedContext = contextMerge(authContext, taskContext, chatContext);
  * ```
+ *
+ * @example Debug type issues
+ * ```typescript
+ * // If useQuery or useCommands lose types, debug with:
+ * type Debug = DebugContextElements<typeof mergedContext>;
+ * // Or for just invalid elements:
+ * type Invalid = DebugInvalidElements<typeof mergedContext>;
+ * ```
  */
-export declare function contextMerge<const Contexts extends ArcContextAny[]>(...contexts: Contexts): ArcContext<Contexts[number]["elements"]>;
+export declare function contextMerge<const Contexts extends ArcContextAny[]>(...contexts: Contexts): ArcContext<MergedElements<Contexts>>;
 /**
  * Type alias for any context (used in collections)
  */
 export type ArcContextAny = ArcContext<ArcContextElementAny[]>;
+export {};
 //# sourceMappingURL=context.d.ts.map

package/dist/context/index.d.ts

@@ -1,2 +1,2 @@
-export { ArcContext, context, contextMerge, type ArcContextAny, } from "./context";
+export { ArcContext, context, contextMerge, type ArcContextAny, type DebugContextElements, type DebugInvalidElements, type DebugMutateElements, type DebugQueryElements, } from "./context";
 //# sourceMappingURL=index.d.ts.map

package/dist/context-element/index.d.ts

@@ -3,8 +3,10 @@
  *
  * Provides dependency injection and element registration
  */
-export * from "./context-element";
 export * from "./command";
+export * from "./context-element";
 export * from "./event";
+export * from "./listener";
+export * from "./route";
 export * from "./view";
 //# sourceMappingURL=index.d.ts.map

package/dist/context-element/listener/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./listener";
+//# sourceMappingURL=index.d.ts.map

package/dist/context-element/listener/listener.d.ts

@@ -0,0 +1,170 @@
+import type { ModelAdapters } from "../../model/model-adapters";
+import type { Merge } from "../../utils";
+import { ArcContextElement, type ArcEnvironment } from "../context-element";
+import type { ArcEventAny } from "../event/event";
+import type { ArcEventInstance } from "../event/instance";
+/**
+ * Listener Data - Configuration for a listener
+ */
+export interface ArcListenerData {
+    name: string;
+    description?: string;
+    eventElements: ArcEventAny[];
+    queryElements: ArcContextElement<any>[];
+    mutationElements: ArcContextElement<any>[];
+    handler?: ArcListenerHandler<any, any>;
+    isAsync: boolean;
+}
+/**
+ * Listener Context - Available to listener handlers
+ */
+export type ArcListenerContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[]> = {
+    [K in QueryElements[number] as K["name"]]: K extends {
+        queryContext: (adapters: ModelAdapters) => infer R;
+    } ? R : never;
+} & {
+    [K in MutationElements[number] as K["name"]]: K extends {
+        mutateContext: (adapters: ModelAdapters) => infer R;
+    } ? R : never;
+} & {
+    get: <T extends ArcContextElement<any>>(element: T) => T extends {
+        queryContext: (adapters: ModelAdapters) => infer R;
+    } ? R : T extends {
+        mutateContext: (adapters: ModelAdapters) => infer R;
+    } ? R : never;
+    $auth?: {
+        params: any;
+        tokenName: string;
+    };
+};
+/**
+ * Listener Handler - Function that handles events
+ */
+export type ArcListenerHandler<Context, EventElements extends ArcEventAny[]> = (ctx: Context, event: ArcEventInstance<EventElements[number]>) => Promise<void> | void;
+/**
+ * Arc Listener - Reactive side effect triggered by events
+ *
+ * Listeners react to events and can:
+ * - Query state through query elements (views)
+ * - Mutate state through mutation elements (events, commands)
+ * - Run synchronously (blocking) or asynchronously (fire-and-forget)
+ *
+ * Listeners only run on the server.
+ *
+ * @example
+ * ```typescript
+ * const notifyOnTaskCreated = listener("notifyOnTaskCreated")
+ *   .listenTo([taskCreatedEvent])
+ *   .query([usersView])
+ *   .mutate([notificationSentEvent])
+ *   .handle(async (ctx, event) => {
+ *     const user = await ctx.usersView.findOne({ _id: event.payload.assignedTo });
+ *     if (user) {
+ *       await ctx.notificationSentEvent.emit({ userId: user._id, message: "New task!" });
+ *     }
+ *   });
+ * ```
+ */
+export declare class ArcListener<const Data extends ArcListenerData> extends ArcContextElement<Data["name"]> {
+    private readonly data;
+    private unsubscribers;
+    constructor(data: Data);
+    /**
+     * Set listener description for documentation
+     */
+    description<const Desc extends string>(description: Desc): ArcListener<Merge<Data, {
+        description: Desc;
+    }>>;
+    /**
+     * Specify which events this listener reacts to
+     *
+     * @param events - Array of event elements to listen to
+     */
+    listenTo<const Events extends ArcEventAny[]>(events: Events): ArcListener<Merge<Data, {
+        eventElements: Events;
+    }>>;
+    /**
+     * Add query elements (views) that this listener needs to read from
+     *
+     * @param elements - Array of view elements to query
+     */
+    query<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcListener<Merge<Data, {
+        queryElements: Elements;
+    }>>;
+    /**
+     * Add mutation elements (events, commands) that this listener needs to modify state
+     *
+     * @param elements - Array of event/command elements to mutate with
+     */
+    mutate<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcListener<Merge<Data, {
+        mutationElements: Elements;
+    }>>;
+    /**
+     * Mark listener as async (fire-and-forget)
+     * Async listeners don't block event processing
+     */
+    async(): ArcListener<Merge<Data, {
+        isAsync: true;
+    }>>;
+    /**
+     * Set the handler function for this listener
+     *
+     * @param handler - Function that handles events
+     */
+    handle<Handler extends ArcListenerHandler<ArcListenerContext<Data["queryElements"], Data["mutationElements"]>, Data["eventElements"]>>(handler: Handler): ArcListener<Merge<Data, {
+        handler: Handler;
+    }>>;
+    /**
+     * Get the events this listener is subscribed to
+     */
+    get eventElements(): ArcEventAny[];
+    /**
+     * Check if listener is async
+     */
+    get isAsync(): boolean;
+    /**
+     * Initialize listener - subscribe to events
+     * Only runs on server
+     */
+    init(environment: ArcEnvironment, adapters: ModelAdapters): Promise<void>;
+    /**
+     * Handle an incoming event
+     */
+    private handleEvent;
+    /**
+     * Build listener context with access to query and mutation elements
+     */
+    private buildListenerContext;
+    /**
+     * Cleanup - unsubscribe from all events
+     */
+    destroy(): void;
+}
+/**
+ * Create a new listener with the given name
+ *
+ * @param name - Unique listener name
+ * @returns New listener instance ready for configuration
+ *
+ * @example
+ * ```typescript
+ * const myListener = listener("myListener")
+ *   .listenTo([someEvent])
+ *   .mutate([anotherEvent])
+ *   .handle(async (ctx, event) => {
+ *     await ctx.anotherEvent.emit({ ... });
+ *   });
+ * ```
+ */
+export declare function listener<const Name extends string>(name: Name): ArcListener<{
+    readonly name: Name;
+    readonly eventElements: [];
+    readonly queryElements: [];
+    readonly mutationElements: [];
+    readonly isAsync: false;
+}>;
+/**
+ * Type alias for any listener (used in collections)
+ */
+export type ArcListenerAny = ArcListener<any>;
+//# sourceMappingURL=listener.d.ts.map

package/dist/context-element/route/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./route";
+export * from "./route-data";
+//# sourceMappingURL=index.d.ts.map

package/dist/context-element/route/route-data.d.ts

@@ -0,0 +1,42 @@
+import type { ArcTokenAny } from "../../token/token";
+import type { ArcContextElement } from "../context-element";
+/**
+ * HTTP methods supported by routes
+ */
+export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
+/**
+ * Route handler function
+ */
+export type RouteHandler<Ctx> = (ctx: Ctx, request: Request, params: Record<string, string>, url: URL) => Promise<Response> | Response;
+/**
+ * Route handlers object - maps HTTP methods to handlers
+ */
+export type RouteHandlers<Ctx> = {
+    [Method in HttpMethod]?: RouteHandler<Ctx>;
+};
+/**
+ * Protection check function for routes
+ * Returns true to allow, false to deny
+ */
+export type RouteProtectionCheck<T extends ArcTokenAny> = (tokenInstance: ReturnType<T["create"]>) => boolean | Promise<boolean>;
+/**
+ * Route protection configuration
+ */
+export type RouteProtection = {
+    token: ArcTokenAny;
+    check: RouteProtectionCheck<any>;
+};
+/**
+ * Route data configuration
+ */
+export type ArcRouteData = {
+    name: string;
+    path?: string;
+    description?: string;
+    queryElements: ArcContextElement<any>[];
+    mutationElements: ArcContextElement<any>[];
+    handlers: RouteHandlers<any>;
+    protections: RouteProtection[];
+    isPublic: boolean;
+};
+//# sourceMappingURL=route-data.d.ts.map

package/dist/context-element/route/route.d.ts

@@ -0,0 +1,163 @@
+import type { ModelAdapters } from "../../model/model-adapters";
+import type { ArcTokenAny } from "../../token/token";
+import type { TokenInstanceAny } from "../../token/token-instance";
+import type { Merge } from "../../utils";
+import { ArcContextElement } from "../context-element";
+import type { ArcRouteData, HttpMethod, RouteHandler, RouteHandlers, RouteProtectionCheck } from "./route-data";
+/**
+ * Route context passed to handlers
+ */
+export type ArcRouteContext<QueryElements extends ArcContextElement<any>[], MutationElements extends ArcContextElement<any>[]> = {
+    [K in QueryElements[number]["name"]]: QueryElements[number] extends {
+        name: K;
+        queryContext: (...args: any[]) => infer R;
+    } ? R : never;
+} & {
+    [K in MutationElements[number]["name"]]: MutationElements[number] extends {
+        name: K;
+        mutateContext: (...args: any[]) => infer R;
+    } ? R : never;
+} & {
+    get: <T extends ArcContextElement<any>>(element: T) => T extends {
+        queryContext: (...args: any[]) => infer R;
+    } ? R : T extends {
+        mutateContext: (...args: any[]) => infer R;
+    } ? R : never;
+    $auth?: {
+        params: Record<string, any>;
+        tokenName: string;
+    };
+};
+/**
+ * Arc Route - Custom HTTP endpoint handler
+ *
+ * Routes allow defining custom HTTP endpoints that can:
+ * - Handle GET, POST, PUT, DELETE, PATCH requests
+ * - Access views (query) and events/commands (mutate)
+ * - Be public or protected by tokens
+ * - Use path parameters (e.g., /users/:userId)
+ *
+ * @example
+ * ```typescript
+ * const stripeWebhook = route("stripeWebhook")
+ *   .path("/stripe/webhook")
+ *   .public()
+ *   .mutate([orderPaidEvent])
+ *   .handle({
+ *     POST: async (ctx, req) => {
+ *       const body = await req.json();
+ *       await ctx.orderPaidEvent.emit({ ... });
+ *       return new Response("OK");
+ *     }
+ *   });
+ * ```
+ */
+export declare class ArcRoute<const Data extends ArcRouteData> extends ArcContextElement<Data["name"]> {
+    private readonly data;
+    constructor(data: Data);
+    /**
+     * Set route description
+     */
+    description<const Desc extends string>(description: Desc): ArcRoute<Merge<Data, {
+        description: Desc;
+    }>>;
+    /**
+     * Set route path pattern
+     * Supports path parameters like /users/:userId
+     * Path will be prefixed with /route automatically
+     */
+    path<const P extends string>(path: P): ArcRoute<Merge<Data, {
+        path: P;
+    }>>;
+    /**
+     * Mark route as public (no authentication required)
+     */
+    public(): ArcRoute<Merge<Data, {
+        isPublic: true;
+    }>>;
+    /**
+     * Add query elements (views) that this route can read from
+     */
+    query<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcRoute<Merge<Data, {
+        queryElements: Elements;
+    }>>;
+    /**
+     * Add mutation elements (events, commands) that this route can use
+     */
+    mutate<const Elements extends ArcContextElement<any>[]>(elements: Elements): ArcRoute<Merge<Data, {
+        mutationElements: Elements;
+    }>>;
+    /**
+     * Add token-based protection to this route
+     * Check function returns true to allow, false to deny
+     * Token params available in ctx.$auth
+     */
+    protectBy<T extends ArcTokenAny>(token: T, check: RouteProtectionCheck<T>): ArcRoute<Data>;
+    /**
+     * Set route handlers for HTTP methods
+     */
+    handle<Handlers extends RouteHandlers<ArcRouteContext<Data["queryElements"], Data["mutationElements"]>>>(handlers: Handlers): ArcRoute<Merge<Data, {
+        handlers: Handlers;
+    }>>;
+    /**
+     * Get the route path (without /route prefix)
+     */
+    get routePath(): string;
+    /**
+     * Get the full route path (with /route prefix)
+     */
+    get fullPath(): string;
+    /**
+     * Check if route is public
+     */
+    get isPublic(): boolean;
+    /**
+     * Check if route has protections
+     */
+    get hasProtections(): boolean;
+    /**
+     * Get all protection configurations
+     */
+    get protections(): import("./route-data").RouteProtection[];
+    /**
+     * Get handler for a specific HTTP method
+     */
+    getHandler(method: HttpMethod): RouteHandler<any> | undefined;
+    /**
+     * Check if a pathname matches this route's path pattern
+     * Returns match result with extracted params
+     */
+    matchesPath(pathname: string): {
+        matches: boolean;
+        params: Record<string, string>;
+    };
+    /**
+     * Verify all protections pass for given token instances
+     */
+    verifyProtections(tokens: TokenInstanceAny[]): Promise<boolean>;
+    /**
+     * Build route context with access to query and mutation elements
+     */
+    buildContext(adapters: ModelAdapters, authParams?: {
+        params: Record<string, any>;
+        tokenName: string;
+    }): ArcRouteContext<Data["queryElements"], Data["mutationElements"]>;
+}
+/**
+ * Create a new route with the given name
+ */
+export declare function route<const Name extends string>(name: Name): ArcRoute<{
+    name: Name;
+    path: undefined;
+    description: undefined;
+    queryElements: [];
+    mutationElements: [];
+    handlers: {};
+    protections: [];
+    isPublic: false;
+}>;
+/**
+ * Type alias for any route
+ */
+export type ArcRouteAny = ArcRoute<any>;
+//# sourceMappingURL=route.d.ts.map

package/dist/context-element/view/view-data.d.ts

@@ -4,15 +4,14 @@ import type { ArcTokenAny } from "../../token/token";
 import type { ArcContextElement } from "../context-element";
 /**
  * Protection config for views
- * Defines read/write access conditions based on token params
+ * Defines read access conditions based on token params
+ * Write protection is handled by event protections, not view protections
  */
-export type ViewProtectionConfig = {
-    read: WhereCondition | false;
-    write: WhereCondition | false;
-};
+export type ViewProtectionConfig = WhereCondition | false;
 /**
  * Protection function for views
- * Receives token params and returns read/write conditions
+ * Receives token params and returns read conditions (where clause)
+ * Return false to deny access entirely
  */
 export type ViewProtectionFn<TokenParams> = (params: TokenParams) => ViewProtectionConfig;
 /**