@routier/core 0.2.0 → 0.3.0

package/dist/plugins/types.d.ts

@@ -7,6 +7,28 @@ import { ITranslatedValue } from "./translators";
  * Interface for a database plugin, which provides query, destroy, and bulk operations.
  */
 export interface IDbPlugin {
+    /**
+     * Uniquely identifies the database this plugin talks to, INCLUDING host or path where a
+     * bare name would collide — `orders.db` in two directories is two databases, and `mydb`
+     * on two hosts is two databases. Two instances over the same database must return the
+     * same string, in this process and in any other; two over different databases must not.
+     *
+     * Used to scope schema subscription channels, so instances of one database (another tab,
+     * a worker) see each other's change notifications and unrelated databases holding the
+     * same schema do not.
+     *
+     * Required rather than optional on purpose. An absent value used to fall back to scoping
+     * by schema alone, which shares one channel across every database holding that schema —
+     * the exact cross-talk this prevents, arrived at by omission. Requiring it also makes a
+     * wrapper that forgets to forward it a compile error rather than a silent regression.
+     *
+     * Derive it, never generate it: a random value is unique per PROCESS, not per database,
+     * so another tab would never match one and cross-context notifications would stop.
+     *
+     * Must not contain credentials — it becomes part of a channel key, so build it from
+     * host/port/database rather than returning a connection string.
+     */
+    readonly databaseName: string;
     /**
      * Executes a query operation on the database.
      * @param event The query event containing schema, parent, and query operation.
@@ -41,8 +63,12 @@ export type DbPluginEvent = {
     schemas: SchemaCollection;
     /** Unique id of the event. */
     id: string;
-    /** Source of the request */
-    source: "data-store" | "collection" | "view" | "capability";
+    /** The class/component that triggered this event */
+    source: string;
+    /** The action/operation type being performed */
+    action: "query" | "persist" | "destroy";
+    /** Optional context about why this operation is happening */
+    reason?: string;
 };
 /**
  * Event for a specific plugin operation, extending the base event with an operation payload.
@@ -67,20 +93,69 @@ export type ReplicationPluginOptions = {
      */
     read?: IDbPlugin;
 };
-export type OptimisticReplicationPluginOptions = {
-    /** The primary database plugin that handles all write operations, do not include in the list of replicas. */
-    source: IDbPlugin;
-    /** Array of replica database plugins that can be used for read operations. */
-    replicas: IDbPlugin[];
-    /** Must be a MemoryPlugin */
-    read: IDbPlugin;
+/**
+ * A value inside a delta. Arrays and Dates are values, not sub-structures to descend into.
+ *
+ * Descending into them would be both wrong and useless: an element-wise array delta cannot
+ * express "the last element was removed", and a partial Date is meaningless.
+ */
+type DeltaValue<V> = V extends readonly unknown[] ? V : V extends Date ? V : V extends object ? DeltaProperties<V> : V;
+type DeltaProperties<T> = {
+    [K in keyof T]?: DeltaValue<T[K]>;
 };
+/**
+ * What changed about an entity, expressed as a **partial entity**.
+ *
+ * A change two levels deep appears where it actually lives —
+ * `{ nested: { inner: { value } } }` — not as a flattened key.
+ *
+ * This deliberately carries no storage vocabulary. It used to be typed
+ * `{ [key: string]: string | number | Date }`, which was wrong twice over: it excluded
+ * booleans, nulls, arrays and objects that the schema happily allows, and its flat
+ * scalar shape was really a SQL `SET column = ?` list — one storage family's concern
+ * leaking into the contract every plugin sees.
+ *
+ * Translating this into storage terms belongs to the plugin. A document store can merge it
+ * as-is; a SQL plugin decides which columns it touches and how a nested value is encoded
+ * (see `toColumnAssignments` in `@routier/sql-plugin-core`, which stores nested objects and
+ * arrays as JSON). Core does not need to know, and must not.
+ */
+export type EntityDelta<T extends {}> = DeltaProperties<InferType<T>>;
 export type EntityUpdateInfo<T extends {}> = {
     entity: InferType<T>;
     changeType: EntityChangeType;
-    delta: {
-        [key: string]: string | number | Date;
+    delta: EntityDelta<T>;
+    /**
+     * Present when the schema declares a `.concurrency()` token: the update must be
+     * applied ONLY IF the stored row's `column` still equals `expected` (the value the
+     * writer read). The entity/delta already carry the bumped value to store on success.
+     * A plugin that finds a mismatch must fail the whole save with an
+     * OptimisticConcurrencyError naming the conflicted rows — never apply partially.
+     */
+    concurrency?: {
+        column: string;
+        expected: number;
     };
+    /**
+     * The values these properties held BEFORE this update — keyed like `delta`, which holds
+     * the values they hold after.
+     *
+     * DATASTORE-INTERNAL. The datastore strips it before the plugin is called
+     * (`DataStore.onSavePreparedChanges`), so no plugin ever receives it and nothing goes over
+     * a wire. It exists for save-pipeline participants that must undo work keyed by an old
+     * value — a search index has to delete the rows for terms that just left a field, and
+     * `delta` only says what the field says now.
+     *
+     * Always populated for an update. It is part of what an update IS, not something a
+     * declaration switches on — a consumer can rely on it without knowing what else the store
+     * declared, and there is one code path to reason about rather than two.
+     *
+     * Which properties appear depends on what the change-tracking mode can know. Proxy and
+     * immutable name exactly the properties that changed. Diff detects change by comparing a
+     * content hash, so it cannot say WHICH property moved and reports every root property —
+     * the same "assume everything" convention its empty `delta` already uses.
+     */
+    previous?: EntityDelta<T>;
 };
 export type TaggedEntity<T> = {
     entity: T;
@@ -100,3 +175,4 @@ export type IQuery<TRoot extends {}, TShape> = {
     get changeTracking(): boolean;
 };
 export type EntityChangeType = "propertiesChanged" | "markedDirty" | "notModified";
+export {};

package/dist/plugins/wire/handler.d.ts

@@ -0,0 +1,122 @@
+import { ReadonlySchemaCollection } from "../../collections/ReadonlySchemaCollection";
+import { Filter, ParamsFilter } from "../../expressions";
+import { CompiledSchema } from "../../schema";
+import { IDbPlugin } from "../types";
+import { ScopeProvider } from "./query";
+import { SerializedRequest, SerializedResponse } from "./types";
+/**
+ * The receiving half: takes a serialized request, executes it, returns a serialized response.
+ *
+ * Deliberately not a server. It is one async function from JSON to JSON, with no notion of HTTP, so
+ * the same handler sits behind Express, a Cloudflare Worker, a Lambda, a WebSocket message, or a
+ * worker `postMessage`. Transport is the caller's business; this is the part that would otherwise be
+ * rewritten per framework.
+ *
+ * ```ts
+ * const handle = createRequestHandler({ plugin, schemas });
+ *
+ * app.post("/routier", async (req, res) => res.json(await handle(req.body)));
+ * ```
+ *
+ * ## Security is YOURS, and this gives you the two places to put it
+ *
+ * There is no built-in notion of a user, a tenant, a role or a token, and there should not be: this
+ * library cannot know what your identities are or what they may see. What it can do is make sure
+ * there is nowhere for a decision to be forgotten. Two hooks, and both receive a `context` you built
+ * from the request:
+ *
+ *  - **`authorize`** — may this caller do this at all? Called once per request, before anything is
+ *    deserialized or executed, with the action and every collection the request touches.
+ *  - **`scope`** — which ROWS may this caller see? A filter the receiver ANDs into every read of a
+ *    collection, and checks every written row against.
+ *
+ * With neither supplied, the endpoint answers anything for anyone. That is the correct default for a
+ * function with no idea who is calling it — and the moment you name a context type, passing one
+ * becomes required, so a policy cannot be half-wired.
+ *
+ * ```ts
+ * const handle = createRequestHandler<{ tenantId: string }>({
+ *     plugin,
+ *     schemas,
+ *     authorize: ({ action, context }) => context.tenantId != null || "not signed in",
+ *     scope: ({ context }) => ({ filter: ([row, p]) => row.tenantId === p.tenantId, params: context }),
+ * });
+ *
+ * app.post("/routier", async (req, res) => {
+ *     const context = { tenantId: req.user?.tenantId };   // from the REQUEST, never from the body
+ *     res.json(await handle(req.body, context));
+ * });
+ * ```
+ *
+ * ## Errors are values
+ *
+ * A failure comes back as `{ ok: false, error }` rather than as a rejected promise, so a transport
+ * cannot accidentally turn a query error into a 500 with no body. The caller decides the status.
+ */
+/** What a hook is told about the request it is judging. */
+export type RequestInfo<TContext> = {
+    action: "query" | "persist" | "destroy";
+    /** Every collection this request touches, including the inner side of any join. */
+    collectionNames: string[];
+    /** Whatever the transport built from the request — a user, a tenant, a token. Never the body. */
+    context: TContext;
+    /** The raw request, for a policy that needs to look closer. Treat it as caller-controlled input. */
+    request: SerializedRequest;
+};
+/**
+ * May this request proceed?
+ *
+ * `true` to allow. `false` or a string to refuse — a string becomes the error message, which is the
+ * cheapest way to say WHY without inventing an error type. Throwing also refuses.
+ *
+ * Called once, before deserialization, so a refused request never reaches a schema or a plugin.
+ */
+export type AuthorizeHook<TContext> = (info: RequestInfo<TContext>) => boolean | string | Promise<boolean | string>;
+/** What a scope hook is asked. One collection at a time, since each may be scoped differently. */
+export type ScopeInfo<TContext> = {
+    collectionName: string;
+    schema: CompiledSchema<any>;
+    context: TContext;
+    action: "query" | "persist";
+};
+/**
+ * The rows of one collection this caller may touch, as a filter.
+ *
+ * Written exactly like a collection's own `.scope()` — a filter, optionally with params — so the same
+ * expression is pushed into the database on reads and checked against each row on writes. Return
+ * `null` for a collection this caller may see in full.
+ *
+ * ```ts
+ * scope: ({ collectionName, context }) =>
+ *     collectionName === "orders"
+ *         ? { filter: ([row, p]) => row.tenantId === p.tenantId, params: { tenantId: context.tenantId } }
+ *         : null
+ * ```
+ */
+export type ScopeHook<TContext> = (info: ScopeInfo<TContext>) => {
+    filter: Filter<any> | ParamsFilter<any, any>;
+    params?: {};
+} | null;
+export type RequestHandlerOptions<TContext> = {
+    /** The plugin that actually holds the data. Anything implementing `IDbPlugin`. */
+    plugin: IDbPlugin;
+    /** Every collection this endpoint will answer for. A name absent from here is refused. */
+    schemas: ReadonlySchemaCollection;
+    /** May this caller do this? See `AuthorizeHook`. Absent means yes, to everyone. */
+    authorize?: AuthorizeHook<TContext>;
+    /** Which rows may this caller touch? See `ScopeHook`. Absent means all of them. */
+    scope?: ScopeHook<TContext>;
+    /**
+     * Whether a `destroy` request may drop the database. **Defaults to false.**
+     *
+     * `HttpTransportDbPlugin` never sends one, but an endpoint answers whatever arrives — and a
+     * hand-written `{"kind":"destroy"}` would otherwise wipe the store for anyone who could reach
+     * the route. Destroying a database is not something a remote caller should be able to ask for by
+     * default, so it is opt-in and still passes through `authorize`.
+     */
+    allowDestroy?: boolean;
+};
+export type RequestHandler<TContext> = (request: SerializedRequest, context: TContext) => Promise<SerializedResponse>;
+export declare const createRequestHandler: <TContext = void>(options: RequestHandlerOptions<TContext>) => RequestHandler<TContext>;
+/** Re-exported so a caller can type its own scope provider without reaching for the query module. */
+export type { ScopeProvider };

package/dist/plugins/wire/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './query';
+export * from './persist';
+export * from './handler';

package/dist/plugins/wire/persist.d.ts

@@ -0,0 +1,43 @@
+import { BulkPersistChanges, BulkPersistResult } from "../../collections";
+import { CompiledSchema } from "../../schema";
+import { ReadonlySchemaCollection } from "../../collections/ReadonlySchemaCollection";
+import { SchemaResolver } from "./query";
+import { SerializedPersistRequest, SerializedResponse } from "./types";
+/**
+ * Saves, in the form that survives a wire.
+ *
+ * Simpler than a query, because a change set holds no functions: adds, updates and removes are
+ * entities, and an entity reaching a plugin has already been through `preprocess` — so it is in
+ * STORAGE shape, where a Date is already an ISO string and a nested object is already whatever the
+ * schema said to store. It is JSON by the time it gets here.
+ *
+ * Two things are deliberately left behind:
+ *
+ * - **Tags.** `SchemaPersistChanges.tags` is caller-side metadata for correlating a save with its
+ *   echo locally. The receiver has no use for it and no business seeing it.
+ * - **Schema ids.** Collections are NAMED. An id is a hash of the schema's own shape, so it would
+ *   couple both sides to identical schema definitions; a name lets the receiver resolve its own.
+ */
+export declare const serializeBulkPersist: (changes: BulkPersistChanges, schemas: ReadonlySchemaCollection) => SerializedPersistRequest;
+/**
+ * Rebuilds a change set from its wire form, keyed by the RECEIVER's schema ids.
+ *
+ * @throws when a named collection is not one this store declares. A save aimed at data this side
+ * does not have must not be silently dropped — the caller would be told it succeeded.
+ */
+export declare const deserializeBulkPersist: (request: SerializedPersistRequest, resolveSchema: SchemaResolver) => {
+    changes: BulkPersistChanges;
+    schemas: CompiledSchema<any>[];
+};
+/**
+ * Serializes the ECHO of a save — the part the change tracker cannot do without.
+ *
+ * A save's result is not a receipt. It carries the rows as the database wrote them, including any
+ * identity the database assigned, and the change tracker matches each one back to the addition that
+ * produced it. Returning a count instead would leave every inserted entity without its key.
+ */
+export declare const serializePersistResult: (result: BulkPersistResult, schemas: ReadonlySchemaCollection) => SerializedResponse;
+/** Rebuilds a save's echo against the SENDER's schema ids, which is what its change tracker holds. */
+export declare const deserializePersistResult: (response: Extract<SerializedResponse, {
+    kind: "persist";
+}>, resolveSchema: SchemaResolver) => BulkPersistResult;

package/dist/plugins/wire/query.d.ts

@@ -0,0 +1,49 @@
+import { Expression } from "../../expressions";
+import { CompiledSchema } from "../../schema";
+import { QueryOptionsCollection } from "../query/QueryOptionsCollection";
+import { SerializedQueryOption } from "./types";
+/**
+ * Splits options into the PREFIX that can be sent and the remainder that cannot.
+ *
+ * A prefix, not a filtered subset, and that is the whole correctness argument. Options are ordered,
+ * and most are not idempotent: sending `count` while keeping `map` local would count unmapped rows,
+ * and applying `take` on both sides would window twice. So the split stops at the first option that
+ * cannot travel, and everything from there on runs where the closures are.
+ *
+ * It is the same shape as the database/memory split this composes with — one more cut of the same
+ * ordered list, for one more reason.
+ */
+export declare const splitSendableOptions: <T>(options: QueryOptionsCollection<T>) => {
+    sendable: QueryOptionsCollection<T>;
+    local: QueryOptionsCollection<T>;
+};
+export declare const serializeQueryOptions: <T>(options: QueryOptionsCollection<T>) => SerializedQueryOption[];
+/** How the receiver finds a collection it was sent the NAME of. */
+export type SchemaResolver = (collectionName: string) => CompiledSchema<any> | null;
+/**
+ * A filter the RECEIVER adds to every read of a collection, whatever the sender asked for.
+ *
+ * Returns `null` for a collection with nothing to add. See `createRequestHandler` for the policy
+ * side; this is only how it reaches the options.
+ */
+export type ScopeProvider = (schema: CompiledSchema<any>) => Expression | null;
+/**
+ * Rebuilds query options from their wire form, against the receiver's own schemas.
+ *
+ * The closures that were dropped are reconstructed here rather than sent:
+ *
+ * - a **sort selector** from its property, which is all `JsonTranslator.sort` reads;
+ * - a **filter predicate** from its expression tree, via `toStrictPredicate` — which THROWS rather
+ *   than keeping a row it cannot judge, because on a receiver a filter that quietly stops filtering
+ *   returns rows the requester excluded.
+ *
+ * @throws when a named property or collection is not declared by the receiver's schemas. A payload
+ * describing data this side does not have is a disagreement, and it has to be loud.
+ */
+export declare const deserializeQueryOptions: (serialized: SerializedQueryOption[], schema: CompiledSchema<any>, resolveSchema: SchemaResolver, 
+/**
+ * A receiver-side filter per collection, applied to this collection AND to every collection a
+ * join reaches. Prepended, so it is ANDed with whatever the sender sent and there is no order of
+ * options that removes it.
+ */
+scopeFor?: ScopeProvider) => QueryOptionsCollection<any>;

package/dist/plugins/wire/types.d.ts

@@ -0,0 +1,123 @@
+import { SerializedExpression } from "../../expressions";
+import { JoinKind } from "../query/join";
+import { QueryOrdering } from "../query/types";
+/**
+ * The wire format for a whole Routier operation.
+ *
+ * This is what makes a plugin that owns no database possible: the query itself travels, and a
+ * receiver executes it against whatever plugin IT has. Nothing here is HTTP-specific — it is plain
+ * JSON, so the same payload works over fetch, a WebSocket, a worker `postMessage`, or a queue.
+ *
+ * ## Two rules shape every type below
+ *
+ * 1. **No functions cross.** A query option carries live closures — a sort selector, a filter
+ *    predicate, a map projection — and none of them survive `JSON.stringify`. Where a closure can
+ *    be REBUILT from data it is dropped and reconstructed on arrival (a sort selector from its
+ *    property, a filter predicate from its expression tree). Where it cannot, the option does not
+ *    travel at all and the sender runs it locally; see `map` and `group`.
+ * 2. **The receiver's schema is the authority.** Collections are named, never described. A payload
+ *    says "teams", and the receiver resolves its own compiled schema for that name. Sending a
+ *    schema would let the sender decide what its properties are, which is backwards for anything
+ *    crossing a trust boundary — and it is the same reason `expressionFromJson` takes the schema
+ *    rather than reading an id out of the payload.
+ */
+/** A query option, in the form that survives a wire. */
+export type SerializedQueryOption = {
+    name: "skip";
+    value: number;
+} | {
+    name: "take";
+    value: number;
+}
+/** The selector is dropped and rebuilt from the property on arrival. */
+ | {
+    name: "sort";
+    value: {
+        propertyName: string;
+        direction: QueryOrdering;
+    };
+}
+/**
+ * The expression only — no closure and no params bag.
+ *
+ * A filter reaching a query option is already BOUND: `ParamReferenceExpression` never escapes
+ * the parser, so every param value is already a literal in the tree. The receiver rebuilds a
+ * runnable predicate from the tree with `toStrictPredicate`.
+ */
+ | {
+    name: "filter";
+    value: {
+        expression: SerializedExpression;
+    };
+} | {
+    name: "nearest";
+    value: {
+        propertyName: string;
+        vector: number[];
+        count: number;
+    };
+} | {
+    name: "join";
+    value: {
+        kind: JoinKind;
+        /** Named, not described — the receiver resolves its own schema for it. */
+        innerCollectionName: string;
+        outerKeyPath: string;
+        innerKeyPath: string;
+        innerOptions: SerializedQueryOption[];
+        semiJoinKeyThreshold: number;
+    };
+} | {
+    name: "count" | "min" | "max" | "sum" | "distinct";
+    value: true;
+};
+export type SerializedQueryRequest = {
+    kind: "query";
+    collectionName: string;
+    options: SerializedQueryOption[];
+};
+/** One entity update, as `EntityUpdateInfo` minus nothing — every field of it is already JSON. */
+export type SerializedUpdate = {
+    entity: unknown;
+    changeType: "propertiesChanged" | "markedDirty" | "notModified";
+    delta: unknown;
+    concurrency?: {
+        column: string;
+        expected: number;
+    };
+};
+export type SerializedSchemaChanges = {
+    collectionName: string;
+    adds: unknown[];
+    updates: SerializedUpdate[];
+    removes: unknown[];
+};
+export type SerializedPersistRequest = {
+    kind: "persist";
+    changes: SerializedSchemaChanges[];
+};
+export type SerializedDestroyRequest = {
+    kind: "destroy";
+};
+export type SerializedRequest = SerializedQueryRequest | SerializedPersistRequest | SerializedDestroyRequest;
+/** What a receiver sends back. Errors are a value, not a transport status. */
+export type SerializedResponse = {
+    ok: true;
+    kind: "query";
+    value: unknown;
+} | {
+    ok: true;
+    kind: "persist";
+    changes: Array<{
+        collectionName: string;
+        adds: unknown[];
+        updates: unknown[];
+        removes: unknown[];
+    }>;
+} | {
+    ok: true;
+    kind: "destroy";
+} | {
+    ok: false;
+    error: string;
+};

package/dist/results/Result.d.ts

@@ -11,13 +11,13 @@ declare abstract class BaseResult {
 }
 export declare class Result extends BaseResult {
     static success<T>(data: T): ResultType<T>;
-    static success<T>(): ResultType<never>;
+    static success(): ResultType<never>;
     static error<T>(error: any): ResultType<T>;
     static partial<T>(data: T, error: any): PartialResultType<T>;
 }
 export declare class PluginEventResult extends BaseResult {
     static success<T>(id: string, data: T): PluginEventResultType<T>;
-    static success<T>(id: string): PluginEventResultType<never>;
+    static success(id: string): PluginEventResultType<never>;
     static error<T>(id: string, error: any): PluginEventResultType<T>;
     static partial<T>(id: string, data: T, error: any): PluginEventPartialResultType<T>;
     static assertSuccess<T>(result: PluginEventResultType<T>): asserts result is {

package/dist/results/index.cjs

@@ -0,0 +1,174 @@
+(() => {
+"use strict";
+var __webpack_modules__ = ({
+718(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+__webpack_require__.d(__webpack_exports__, {
+  D: () => (PluginEventResult),
+  Q: () => (Result)
+});
+class BaseResult {
+    static ERROR = "error";
+    static SUCCESS = "success";
+    static PARTIAL = "partial";
+    static resolve(result, resolve, reject) {
+        if (result.ok === BaseResult.SUCCESS) {
+            resolve(result.data);
+            return;
+        }
+        if (result.ok === BaseResult.PARTIAL) {
+            reject({
+                partial: result.data,
+                error: result.error
+            });
+            return;
+        }
+        reject(result.error);
+    }
+    static assertSuccess(result) {
+        if (result.ok !== BaseResult.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+class Result extends BaseResult {
+    static success(data) {
+        return {
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(error) {
+        return {
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(data, error) {
+        return {
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+}
+class PluginEventResult extends BaseResult {
+    static success(id, data) {
+        return {
+            id,
+            ok: Result.SUCCESS,
+            data
+        };
+    }
+    static error(id, error) {
+        return {
+            id,
+            ok: Result.ERROR,
+            error
+        };
+    }
+    static partial(id, data, error) {
+        return {
+            id,
+            ok: Result.PARTIAL,
+            data,
+            error
+        };
+    }
+    static assertSuccess(result) {
+        if (result.ok !== Result.SUCCESS) {
+            throw new Error(`Expected success result, but got ${result.ok}: ${result.error}`);
+        }
+    }
+}
+
+
+},
+
+});
+// The module cache
+var __webpack_module_cache__ = {};
+
+// The require function
+function __webpack_require__(moduleId) {
+
+// Check if module is in cache
+var cachedModule = __webpack_module_cache__[moduleId];
+if (cachedModule !== undefined) {
+return cachedModule.exports;
+}
+// Create a new module (and put it into the cache)
+var module = (__webpack_module_cache__[moduleId] = {
+exports: {}
+});
+// Execute the module function
+__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+
+// Return the exports of the module
+return module.exports;
+
+}
+
+// webpack/runtime/define_property_getters
+(() => {
+__webpack_require__.d = (exports, definition) => {
+	for(var key in definition) {
+        if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+            Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+        }
+    }
+};
+})();
+// webpack/runtime/has_own_property
+(() => {
+__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+})();
+// webpack/runtime/make_namespace_object
+(() => {
+// define __esModule on exports
+__webpack_require__.r = (exports) => {
+	if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+		Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+	}
+	Object.defineProperty(exports, '__esModule', { value: true });
+};
+})();
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it needs to be isolated against other modules in the chunk.
+(() => {
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  PluginEventResult: () => (/* reexport */ Result/* .PluginEventResult */.D),
+  toPromise: () => (/* reexport */ toPromise),
+  Result: () => (/* reexport */ Result/* .Result */.Q)
+});
+
+// EXTERNAL MODULE: ./src/results/Result.ts
+var Result = __webpack_require__(718);
+;// CONCATENATED MODULE: ./src/results/utils.ts
+
+function toPromise(fn) {
+    return new Promise((resolve, reject)=>{
+        fn((r)=>{
+            if (r.ok === Result/* .Result.ERROR */.Q.ERROR) {
+                reject(r.error);
+                return;
+            }
+            resolve(r.data);
+        });
+    });
+}
+
+;// CONCATENATED MODULE: ./src/results/index.ts
+
+
+
+
+})();
+
+module.exports = __webpack_exports__;
+})()
+;
+//# sourceMappingURL=index.cjs.map