rastack 0.0.52 → 0.0.54

package/dist/auth/cognito.d.ts

@@ -0,0 +1,169 @@
+/**
+ * `rastack/auth` — the framework-free Cognito auth core.
+ *
+ * React API Stack verifies Cognito RS256 JWTs on the server (`rastack-server
+ * --jwks --issuer --audience`) and scopes row-level security by the token's
+ * `sub` / `cognito:groups`. This module is the *client* half: the pure,
+ * dependency-free logic for the standard browser sign-in flow — **Cognito
+ * Hosted UI, OAuth 2.0 Authorization Code + PKCE** — that produces exactly the
+ * `identity` (`sub`), `groups`, and bearer `getToken` the `<RAStackProvider>`
+ * consumes.
+ *
+ * Everything here is a pure function (no React, no `window`, no network): URL
+ * builders, PKCE (S256 over Web Crypto), the `/oauth2/token` request body,
+ * JWT decoding, expiry checks, redirect parsing, and session shaping. The React
+ * layer (`tools/auth/provider.tsx`) is a thin wrapper over these; the tests
+ * (`tools/test/auth.spec.ts`) drive them directly.
+ */
+/** Static configuration of a Cognito Hosted UI app client (public SPA client). */
+export interface CognitoAuthConfig {
+    /**
+     * The Hosted UI domain, without a scheme — either the Cognito prefix domain
+     * (`myapp.auth.us-east-1.amazoncognito.com`) or a custom domain
+     * (`auth.example.com`).
+     */
+    domain: string;
+    /** The app client id (a public SPA client, *no* client secret). */
+    clientId: string;
+    /** An allowed callback URL — where Cognito redirects back after sign-in. */
+    redirectUri: string;
+    /**
+     * An allowed sign-out URL — where Cognito redirects after sign-out. Defaults
+     * to `redirectUri`.
+     */
+    logoutUri?: string;
+    /** OAuth scopes to request. Defaults to `["openid", "email", "profile"]`. */
+    scopes?: string[];
+    /** AWS region — used only to derive the default issuer for reference. */
+    region?: string;
+    /** The Cognito user pool id — used only to derive the default issuer. */
+    userPoolId?: string;
+}
+/** The claims we read off a decoded Cognito ID/access token. */
+export interface CognitoClaims {
+    sub: string;
+    exp?: number;
+    iat?: number;
+    iss?: string;
+    aud?: string;
+    token_use?: string;
+    email?: string;
+    email_verified?: boolean;
+    "cognito:username"?: string;
+    "cognito:groups"?: string[];
+    [claim: string]: unknown;
+}
+/** The signed-in user, projected from the ID token's claims. */
+export interface CognitoUser {
+    /** The Cognito `sub` — the stable identity the framework stamps rows with. */
+    sub: string;
+    email?: string;
+    username?: string;
+    /** `cognito:groups` — the verified group claims (empty array if none). */
+    groups: string[];
+}
+/** A live session: the tokens plus the decoded user and its expiry. */
+export interface CognitoSession {
+    idToken: string;
+    accessToken: string;
+    refreshToken?: string;
+    /** Absolute expiry, epoch milliseconds. */
+    expiresAt: number;
+    user: CognitoUser;
+    claims: CognitoClaims;
+}
+/** The raw shape of a Cognito `/oauth2/token` JSON response. */
+export interface CognitoTokenResponse {
+    id_token: string;
+    access_token: string;
+    refresh_token?: string;
+    expires_in?: number;
+    token_type?: string;
+}
+/** What `parseRedirect` recovers from a callback URL's query string. */
+export interface RedirectParams {
+    code?: string;
+    state?: string;
+    error?: string;
+    errorDescription?: string;
+}
+/** The Hosted UI origin, e.g. `https://myapp.auth.us-east-1.amazoncognito.com`. */
+export declare function hostedUiOrigin(config: CognitoAuthConfig): string;
+/** The issuer a Cognito user pool signs tokens with (for server verification). */
+export declare function issuerUrl(config: CognitoAuthConfig): string | undefined;
+/** Build the Hosted UI `/oauth2/authorize` URL to redirect the browser to. */
+export declare function authorizeUrl(config: CognitoAuthConfig, params: {
+    state: string;
+    codeChallenge: string;
+}): string;
+/** Build the Hosted UI `/logout` URL that clears the Cognito session cookie. */
+export declare function logoutUrl(config: CognitoAuthConfig): string;
+/** The token endpoint the authorization code is exchanged at. */
+export declare function tokenEndpoint(config: CognitoAuthConfig): string;
+/**
+ * The `application/x-www-form-urlencoded` body for a `/oauth2/token` call —
+ * either exchanging an authorization `code` or a `refresh_token` grant.
+ */
+export declare function tokenRequestBody(config: CognitoAuthConfig, grant: {
+    grantType: "authorization_code";
+    code: string;
+    codeVerifier: string;
+} | {
+    grantType: "refresh_token";
+    refreshToken: string;
+}): string;
+/** Encode raw bytes as base64url (no padding). Browser + Node safe. */
+export declare function base64UrlEncode(bytes: Uint8Array): string;
+/** Decode a base64url string to bytes. */
+export declare function base64UrlDecodeToBytes(input: string): Uint8Array;
+/** Decode a base64url string to a UTF-8 string. */
+export declare function base64UrlDecode(input: string): string;
+/** A cryptographically random PKCE `code_verifier` (43–128 chars, base64url). */
+export declare function randomCodeVerifier(random?: Uint8Array): string;
+/** The S256 `code_challenge` derived from a verifier (SHA-256 → base64url). */
+export declare function codeChallengeFromVerifier(verifier: string, subtle?: SubtleCrypto): Promise<string>;
+/** Generate a fresh PKCE `{ verifier, challenge }` pair. */
+export declare function createPkcePair(random?: Uint8Array, subtle?: SubtleCrypto): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+/** A random opaque `state` value to correlate the redirect (CSRF guard). */
+export declare function randomState(random?: Uint8Array): string;
+/**
+ * Decode a JWT's payload **without verifying its signature** — the client only
+ * reads claims for UX; the server is the sole authority that *verifies* the
+ * token (RS256 against the pinned JWKS). Throws on a malformed token.
+ */
+export declare function decodeJwt<T = CognitoClaims>(token: string): T;
+/** Project a decoded ID token's claims into the app-facing `CognitoUser`. */
+export declare function userFromClaims(claims: CognitoClaims): CognitoUser;
+/** Build a `CognitoSession` from a token response, decoding the ID token. */
+export declare function sessionFromTokens(tokens: CognitoTokenResponse, now?: number): CognitoSession;
+/**
+ * Whether a session is still usable — present and not within `skewMs` of its
+ * expiry (so callers refresh a little early rather than mid-request).
+ */
+export declare function isSessionValid(session: CognitoSession | null | undefined, now?: number, skewMs?: number): boolean;
+/**
+ * Parse the callback URL's query string into the OAuth params. Accepts a full
+ * URL, a bare search string (`?code=…`), or a `URLSearchParams`.
+ */
+export declare function parseRedirect(input: string | URLSearchParams): RedirectParams;
+/**
+ * Mint a **local, unsigned** session for server-less development.
+ * `<RAStackProvider mode="local">` runs the whole API in the browser with no
+ * identity provider to redirect to, so `mode: "local"` on the auth provider
+ * grants a simulated Cognito session on sign-in: a real-shaped
+ * (header.payload.signature) JWT carrying `sub` / `cognito:groups`, so
+ * `decodeJwt`, owner stamping, and the write-gating UI all behave exactly as
+ * they would against a real pool — the server-less dev shim.
+ * **Never trust these tokens on a server** — they carry a literal `"local"`
+ * signature; swap `mode` to `"hosted-ui"` for a deployed, Cognito-protected
+ * backend.
+ */
+export declare function localSession(user?: {
+    sub?: string;
+    email?: string;
+    username?: string;
+    groups?: string[];
+}, now?: number, ttlMs?: number): CognitoSession;

package/dist/auth/cognito.js

@@ -0,0 +1,296 @@
+"use strict";
+/**
+ * `rastack/auth` — the framework-free Cognito auth core.
+ *
+ * React API Stack verifies Cognito RS256 JWTs on the server (`rastack-server
+ * --jwks --issuer --audience`) and scopes row-level security by the token's
+ * `sub` / `cognito:groups`. This module is the *client* half: the pure,
+ * dependency-free logic for the standard browser sign-in flow — **Cognito
+ * Hosted UI, OAuth 2.0 Authorization Code + PKCE** — that produces exactly the
+ * `identity` (`sub`), `groups`, and bearer `getToken` the `<RAStackProvider>`
+ * consumes.
+ *
+ * Everything here is a pure function (no React, no `window`, no network): URL
+ * builders, PKCE (S256 over Web Crypto), the `/oauth2/token` request body,
+ * JWT decoding, expiry checks, redirect parsing, and session shaping. The React
+ * layer (`tools/auth/provider.tsx`) is a thin wrapper over these; the tests
+ * (`tools/test/auth.spec.ts`) drive them directly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hostedUiOrigin = hostedUiOrigin;
+exports.issuerUrl = issuerUrl;
+exports.authorizeUrl = authorizeUrl;
+exports.logoutUrl = logoutUrl;
+exports.tokenEndpoint = tokenEndpoint;
+exports.tokenRequestBody = tokenRequestBody;
+exports.base64UrlEncode = base64UrlEncode;
+exports.base64UrlDecodeToBytes = base64UrlDecodeToBytes;
+exports.base64UrlDecode = base64UrlDecode;
+exports.randomCodeVerifier = randomCodeVerifier;
+exports.codeChallengeFromVerifier = codeChallengeFromVerifier;
+exports.createPkcePair = createPkcePair;
+exports.randomState = randomState;
+exports.decodeJwt = decodeJwt;
+exports.userFromClaims = userFromClaims;
+exports.sessionFromTokens = sessionFromTokens;
+exports.isSessionValid = isSessionValid;
+exports.parseRedirect = parseRedirect;
+exports.localSession = localSession;
+const DEFAULT_SCOPES = ["openid", "email", "profile"];
+/** Strip any scheme/trailing slash a caller may have included in `domain`. */
+function normalizeDomain(domain) {
+    return domain.replace(/^https?:\/\//, "").replace(/\/+$/, "");
+}
+/** The Hosted UI origin, e.g. `https://myapp.auth.us-east-1.amazoncognito.com`. */
+function hostedUiOrigin(config) {
+    return `https://${normalizeDomain(config.domain)}`;
+}
+/** The issuer a Cognito user pool signs tokens with (for server verification). */
+function issuerUrl(config) {
+    if (!config.region || !config.userPoolId)
+        return undefined;
+    return `https://cognito-idp.${config.region}.amazonaws.com/${config.userPoolId}`;
+}
+/** Build the Hosted UI `/oauth2/authorize` URL to redirect the browser to. */
+function authorizeUrl(config, params) {
+    const query = new URLSearchParams({
+        response_type: "code",
+        client_id: config.clientId,
+        redirect_uri: config.redirectUri,
+        scope: (config.scopes ?? DEFAULT_SCOPES).join(" "),
+        state: params.state,
+        code_challenge: params.codeChallenge,
+        code_challenge_method: "S256",
+    });
+    return `${hostedUiOrigin(config)}/oauth2/authorize?${query.toString()}`;
+}
+/** Build the Hosted UI `/logout` URL that clears the Cognito session cookie. */
+function logoutUrl(config) {
+    const query = new URLSearchParams({
+        client_id: config.clientId,
+        logout_uri: config.logoutUri ?? config.redirectUri,
+    });
+    return `${hostedUiOrigin(config)}/logout?${query.toString()}`;
+}
+/** The token endpoint the authorization code is exchanged at. */
+function tokenEndpoint(config) {
+    return `${hostedUiOrigin(config)}/oauth2/token`;
+}
+/**
+ * The `application/x-www-form-urlencoded` body for a `/oauth2/token` call —
+ * either exchanging an authorization `code` or a `refresh_token` grant.
+ */
+function tokenRequestBody(config, grant) {
+    const body = new URLSearchParams({
+        client_id: config.clientId,
+    });
+    if (grant.grantType === "authorization_code") {
+        body.set("grant_type", "authorization_code");
+        body.set("code", grant.code);
+        body.set("redirect_uri", config.redirectUri);
+        body.set("code_verifier", grant.codeVerifier);
+    }
+    else {
+        body.set("grant_type", "refresh_token");
+        body.set("refresh_token", grant.refreshToken);
+    }
+    return body.toString();
+}
+// -- base64url ---------------------------------------------------------------
+/** Encode raw bytes as base64url (no padding). Browser + Node safe. */
+function base64UrlEncode(bytes) {
+    let base64;
+    if (typeof btoa === "function") {
+        let binary = "";
+        for (let i = 0; i < bytes.length; i++)
+            binary += String.fromCharCode(bytes[i]);
+        base64 = btoa(binary);
+    }
+    else {
+        base64 = Buffer.from(bytes).toString("base64");
+    }
+    return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** Decode a base64url string to bytes. */
+function base64UrlDecodeToBytes(input) {
+    const base64 = input
+        .replace(/-/g, "+")
+        .replace(/_/g, "/")
+        .padEnd(Math.ceil(input.length / 4) * 4, "=");
+    if (typeof atob === "function") {
+        const binary = atob(base64);
+        const bytes = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++)
+            bytes[i] = binary.charCodeAt(i);
+        return bytes;
+    }
+    return new Uint8Array(Buffer.from(base64, "base64"));
+}
+/** Decode a base64url string to a UTF-8 string. */
+function base64UrlDecode(input) {
+    const bytes = base64UrlDecodeToBytes(input);
+    if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder().decode(bytes);
+    }
+    return Buffer.from(bytes).toString("utf-8");
+}
+/** UTF-8 encode a string to bytes. */
+function utf8Bytes(input) {
+    if (typeof TextEncoder !== "undefined")
+        return new TextEncoder().encode(input);
+    return new Uint8Array(Buffer.from(input, "utf-8"));
+}
+// -- PKCE --------------------------------------------------------------------
+function subtleCrypto(subtle) {
+    const s = subtle ?? (globalThis.crypto && globalThis.crypto.subtle);
+    if (!s) {
+        throw new Error("Web Crypto (crypto.subtle) is required for PKCE; pass a SubtleCrypto explicitly.");
+    }
+    return s;
+}
+/** A cryptographically random PKCE `code_verifier` (43–128 chars, base64url). */
+function randomCodeVerifier(random) {
+    let bytes = random;
+    if (!bytes) {
+        bytes = new Uint8Array(new ArrayBuffer(32));
+        if (globalThis.crypto?.getRandomValues) {
+            globalThis.crypto.getRandomValues(bytes);
+        }
+        else {
+            throw new Error("crypto.getRandomValues is required to generate a code verifier.");
+        }
+    }
+    return base64UrlEncode(bytes);
+}
+/** The S256 `code_challenge` derived from a verifier (SHA-256 → base64url). */
+async function codeChallengeFromVerifier(verifier, subtle) {
+    const digest = await subtleCrypto(subtle).digest("SHA-256", 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    utf8Bytes(verifier));
+    return base64UrlEncode(new Uint8Array(digest));
+}
+/** Generate a fresh PKCE `{ verifier, challenge }` pair. */
+async function createPkcePair(random, subtle) {
+    const verifier = randomCodeVerifier(random);
+    const challenge = await codeChallengeFromVerifier(verifier, subtle);
+    return { verifier, challenge };
+}
+/** A random opaque `state` value to correlate the redirect (CSRF guard). */
+function randomState(random) {
+    return randomCodeVerifier(random ?? undefined);
+}
+// -- JWT ---------------------------------------------------------------------
+/**
+ * Decode a JWT's payload **without verifying its signature** — the client only
+ * reads claims for UX; the server is the sole authority that *verifies* the
+ * token (RS256 against the pinned JWKS). Throws on a malformed token.
+ */
+function decodeJwt(token) {
+    const parts = token.split(".");
+    if (parts.length < 2)
+        throw new Error("Malformed JWT: expected 3 segments.");
+    try {
+        return JSON.parse(base64UrlDecode(parts[1]));
+    }
+    catch (error) {
+        throw new Error(`Malformed JWT payload: ${error.message}`);
+    }
+}
+/** Project a decoded ID token's claims into the app-facing `CognitoUser`. */
+function userFromClaims(claims) {
+    const groups = claims["cognito:groups"];
+    return {
+        sub: claims.sub,
+        email: claims.email,
+        username: claims["cognito:username"] ?? claims.email ?? claims.sub,
+        groups: Array.isArray(groups) ? groups : [],
+    };
+}
+/** Build a `CognitoSession` from a token response, decoding the ID token. */
+function sessionFromTokens(tokens, now = Date.now()) {
+    const claims = decodeJwt(tokens.id_token);
+    // Prefer the token's own `exp`; fall back to `expires_in` from the response.
+    const expiresAt = claims.exp
+        ? claims.exp * 1000
+        : now + (tokens.expires_in ?? 3600) * 1000;
+    return {
+        idToken: tokens.id_token,
+        accessToken: tokens.access_token,
+        refreshToken: tokens.refresh_token,
+        expiresAt,
+        user: userFromClaims(claims),
+        claims,
+    };
+}
+/**
+ * Whether a session is still usable — present and not within `skewMs` of its
+ * expiry (so callers refresh a little early rather than mid-request).
+ */
+function isSessionValid(session, now = Date.now(), skewMs = 30000) {
+    return !!session && session.expiresAt - skewMs > now;
+}
+// -- Redirect parsing --------------------------------------------------------
+/**
+ * Parse the callback URL's query string into the OAuth params. Accepts a full
+ * URL, a bare search string (`?code=…`), or a `URLSearchParams`.
+ */
+function parseRedirect(input) {
+    let params;
+    if (input instanceof URLSearchParams) {
+        params = input;
+    }
+    else {
+        const q = input.includes("?") ? input.slice(input.indexOf("?") + 1) : input;
+        params = new URLSearchParams(q);
+    }
+    return {
+        code: params.get("code") ?? undefined,
+        state: params.get("state") ?? undefined,
+        error: params.get("error") ?? undefined,
+        errorDescription: params.get("error_description") ?? undefined,
+    };
+}
+// -- Local (server-less) sessions -------------------------------------------
+/**
+ * Base64url-encode a JSON value — the building block of the unsigned tokens the
+ * local session mode mints.
+ */
+function encodeSegment(value) {
+    return base64UrlEncode(utf8Bytes(JSON.stringify(value)));
+}
+/**
+ * Mint a **local, unsigned** session for server-less development.
+ * `<RAStackProvider mode="local">` runs the whole API in the browser with no
+ * identity provider to redirect to, so `mode: "local"` on the auth provider
+ * grants a simulated Cognito session on sign-in: a real-shaped
+ * (header.payload.signature) JWT carrying `sub` / `cognito:groups`, so
+ * `decodeJwt`, owner stamping, and the write-gating UI all behave exactly as
+ * they would against a real pool — the server-less dev shim.
+ * **Never trust these tokens on a server** — they carry a literal `"local"`
+ * signature; swap `mode` to `"hosted-ui"` for a deployed, Cognito-protected
+ * backend.
+ */
+function localSession(user = {}, now = Date.now(), ttlMs = 3600000) {
+    const sub = user.sub ?? "local-dev";
+    const exp = Math.floor((now + ttlMs) / 1000);
+    const claims = {
+        sub,
+        email: user.email,
+        email_verified: true,
+        "cognito:username": user.username ?? user.email ?? sub,
+        "cognito:groups": user.groups ?? [],
+        token_use: "id",
+        iss: "rastack:local",
+        iat: Math.floor(now / 1000),
+        exp,
+    };
+    const header = { alg: "none", typ: "JWT", kid: "rastack-local" };
+    const token = `${encodeSegment(header)}.${encodeSegment(claims)}.local`;
+    return {
+        idToken: token,
+        accessToken: token,
+        expiresAt: exp * 1000,
+        user: userFromClaims(claims),
+        claims,
+    };
+}

package/dist/auth/index.d.ts

@@ -0,0 +1,2 @@
+/** `rastack/auth` pure core — Cognito Hosted UI / PKCE, JWT, and session logic. */
+export * from "./cognito";

package/dist/auth/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** `rastack/auth` pure core — Cognito Hosted UI / PKCE, JWT, and session logic. */
+__exportStar(require("./cognito"), exports);

package/dist/entity-generation/get-method.js

@@ -21,7 +21,7 @@ function generateGetAPIMethod(url, model, operationId, responseBody, isList, pat
     export function use${operationIdUpper}(
   options?: ListQueryOptions<${paramNames}, ${responseBody}>
 ) {
-  const { isAuthenticated } = useAuth0();
+  const { isReady } = useCognitoAuth();
   const pathParameters: (keyof ${paramNames})[] = [${pathParameters.map((item) => `'${item}'`).join(", ")}]
   ${pathParameterString.join("\n")}
 
@@ -29,7 +29,7 @@ function generateGetAPIMethod(url, model, operationId, responseBody, isList, pat
     ${method}Url: \`${url}\`,
     queryKey: ${modelCamel}QueriesKeys.${operationId},
     pathParameters,
-    isAuthenticated,
+    isAuthenticated: isReady,
     options,
   });
 }`,
@@ -45,7 +45,7 @@ function generateGetAPIMethod(url, model, operationId, responseBody, isList, pat
 export function use${operationIdUpper}(
   options?: GetQueryOptions<${paramNames}>
 ) {
-  const { isAuthenticated } = useAuth0();
+  const { isReady } = useCognitoAuth();
   const pathParameters: string[] = [${pathParameters.map((item) => `'${item}'`).join(", ")}]
   ${pathParameterString.join("\n")}
   const requiredParams: string[] = [${requiredParameters.map((item) => `'${item}'`).join(", ")}]
@@ -56,7 +56,7 @@ export function use${operationIdUpper}(
     pathParameters,
     //@ts-ignore
     requiredParams,
-    isAuthenticated,
+    isAuthenticated: isReady,
     options,
   });
 }`,

package/dist/entity-generation/imports.js

@@ -62,7 +62,7 @@ function generateImportStatements(importStatements, modelName) {
         .filter((importStatement) => importStatement.startsWith("I") || importStatement.startsWith("Deref"))
         .join(", ");
     let importData = "import { useForm, FormProps, FormUpdate, useUpdateQuery } from 'rastack/hooks';\n";
-    importData = importData + 'import { useAuth0 } from "@auth0/auth0-react";\n';
+    importData = importData + 'import { useCognitoAuth } from "rastack/auth";\n';
     if (queryImports) {
         importData += `import { ${queryImports} } from 'rastack/hooks';\n`;
     }

package/dist/wasm/rastack_wasm.d.ts

@@ -65,8 +65,8 @@ export interface InitOutput {
     readonly rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
     readonly rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
     readonly rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
-    readonly wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_: (a: number, b: number, c: any) => [number, number];
-    readonly wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+    readonly wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_: (a: number, b: number, c: any) => [number, number];
+    readonly wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_exn_store: (a: number) => void;

package/dist/wasm/rastack_wasm.js

@@ -303,7 +303,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_(a, state0.b, arg0, arg1);
+                        return wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -376,7 +376,7 @@ function __wbg_get_imports() {
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 83, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_);
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_);
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0) {
@@ -415,15 +415,15 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_(arg0, arg1, arg2);
+function wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
+function wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
 }
 
 const RastackApiFinalization = (typeof FinalizationRegistry === 'undefined')

package/dist/wasm/rastack_wasm_bg.wasm.d.ts

@@ -16,8 +16,8 @@ export const rust_zstd_wasm_shim_memcpy: (a: number, b: number, c: number) => nu
 export const rust_zstd_wasm_shim_memmove: (a: number, b: number, c: number) => number;
 export const rust_zstd_wasm_shim_memset: (a: number, b: number, c: number) => number;
 export const rust_zstd_wasm_shim_qsort: (a: number, b: number, c: number, d: number) => void;
-export const wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___wasm_bindgen_1a7aa9db5392c486___JsValue__core_7d5f0a2ba6a62c33___result__Result_____wasm_bindgen_1a7aa9db5392c486___JsError___true_: (a: number, b: number, c: any) => [number, number];
-export const wasm_bindgen_1a7aa9db5392c486___convert__closures_____invoke___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined___js_sys_191ff9fb2bd47800___Function_fn_wasm_bindgen_1a7aa9db5392c486___JsValue_____wasm_bindgen_1a7aa9db5392c486___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
+export const wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___wasm_bindgen_ac0f9960a408a037___JsValue__core_9b3796e30d99ddb7___result__Result_____wasm_bindgen_ac0f9960a408a037___JsError___true_: (a: number, b: number, c: any) => [number, number];
+export const wasm_bindgen_ac0f9960a408a037___convert__closures_____invoke___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined___js_sys_10c47e7ecd0a94ab___Function_fn_wasm_bindgen_ac0f9960a408a037___JsValue_____wasm_bindgen_ac0f9960a408a037___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
 export const __wbindgen_malloc: (a: number, b: number) => number;
 export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_exn_store: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rastack",
-  "version": "0.0.52",
+  "version": "0.0.54",
   "description": "",
   "main": "runtime.ts",
   "types": "runtime.ts",