create-croissant 0.1.0 → 0.1.2

package/template/apps/web/node_modules/@better-auth/utils/dist/password.node.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const node_crypto = require('node:crypto');
+
+const config = {
+  N: 16384,
+  r: 16,
+  p: 1,
+  dkLen: 64
+};
+function generateKey(password, salt) {
+  return new Promise((resolve, reject) => {
+    node_crypto.scrypt(
+      password.normalize("NFKC"),
+      salt,
+      config.dkLen,
+      {
+        N: config.N,
+        r: config.r,
+        p: config.p,
+        maxmem: 128 * config.N * config.r * 2
+      },
+      (err, key) => {
+        if (err)
+          reject(err);
+        else
+          resolve(key);
+      }
+    );
+  });
+}
+async function hashPassword(password) {
+  const salt = node_crypto.randomBytes(16).toString("hex");
+  const key = await generateKey(password, salt);
+  return `${salt}:${key.toString("hex")}`;
+}
+async function verifyPassword(hash, password) {
+  const [salt, key] = hash.split(":");
+  if (!salt || !key) {
+    throw new Error("Invalid password hash");
+  }
+  const targetKey = await generateKey(password, salt);
+  return targetKey.toString("hex") === key;
+}
+
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;

package/template/apps/web/node_modules/@better-auth/utils/dist/password.node.d.cts

@@ -0,0 +1,4 @@
+declare function hashPassword(password: string): Promise<string>;
+declare function verifyPassword(hash: string, password: string): Promise<boolean>;
+
+export { hashPassword, verifyPassword };

package/template/apps/web/node_modules/@better-auth/utils/dist/password.node.d.mts

@@ -0,0 +1,4 @@
+declare function hashPassword(password: string): Promise<string>;
+declare function verifyPassword(hash: string, password: string): Promise<boolean>;
+
+export { hashPassword, verifyPassword };

package/template/apps/web/node_modules/@better-auth/utils/dist/password.node.d.ts

@@ -0,0 +1,4 @@
+declare function hashPassword(password: string): Promise<string>;
+declare function verifyPassword(hash: string, password: string): Promise<boolean>;
+
+export { hashPassword, verifyPassword };

package/template/apps/web/node_modules/@better-auth/utils/dist/password.node.mjs

@@ -0,0 +1,44 @@
+import { randomBytes, scrypt } from 'node:crypto';
+
+const config = {
+  N: 16384,
+  r: 16,
+  p: 1,
+  dkLen: 64
+};
+function generateKey(password, salt) {
+  return new Promise((resolve, reject) => {
+    scrypt(
+      password.normalize("NFKC"),
+      salt,
+      config.dkLen,
+      {
+        N: config.N,
+        r: config.r,
+        p: config.p,
+        maxmem: 128 * config.N * config.r * 2
+      },
+      (err, key) => {
+        if (err)
+          reject(err);
+        else
+          resolve(key);
+      }
+    );
+  });
+}
+async function hashPassword(password) {
+  const salt = randomBytes(16).toString("hex");
+  const key = await generateKey(password, salt);
+  return `${salt}:${key.toString("hex")}`;
+}
+async function verifyPassword(hash, password) {
+  const [salt, key] = hash.split(":");
+  if (!salt || !key) {
+    throw new Error("Invalid password hash");
+  }
+  const targetKey = await generateKey(password, salt);
+  return targetKey.toString("hex") === key;
+}
+
+export { hashPassword, verifyPassword };

package/template/apps/web/node_modules/@better-auth/utils/dist/random.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+function expandAlphabet(alphabet) {
+  switch (alphabet) {
+    case "a-z":
+      return "abcdefghijklmnopqrstuvwxyz";
+    case "A-Z":
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    case "0-9":
+      return "0123456789";
+    case "-_":
+      return "-_";
+    default:
+      throw new Error(`Unsupported alphabet: ${alphabet}`);
+  }
+}
+function createRandomStringGenerator(...baseAlphabets) {
+  const baseCharSet = baseAlphabets.map(expandAlphabet).join("");
+  if (baseCharSet.length === 0) {
+    throw new Error(
+      "No valid characters provided for random string generation."
+    );
+  }
+  const baseCharSetLength = baseCharSet.length;
+  return (length, ...alphabets) => {
+    if (length <= 0) {
+      throw new Error("Length must be a positive integer.");
+    }
+    let charSet = baseCharSet;
+    let charSetLength = baseCharSetLength;
+    if (alphabets.length > 0) {
+      charSet = alphabets.map(expandAlphabet).join("");
+      charSetLength = charSet.length;
+    }
+    const maxValid = Math.floor(256 / charSetLength) * charSetLength;
+    const buf = new Uint8Array(length * 2);
+    const bufLength = buf.length;
+    let result = "";
+    let bufIndex = bufLength;
+    let rand;
+    while (result.length < length) {
+      if (bufIndex >= bufLength) {
+        crypto.getRandomValues(buf);
+        bufIndex = 0;
+      }
+      rand = buf[bufIndex++];
+      if (rand < maxValid) {
+        result += charSet[rand % charSetLength];
+      }
+    }
+    return result;
+  };
+}
+
+exports.createRandomStringGenerator = createRandomStringGenerator;

package/template/apps/web/node_modules/@better-auth/utils/dist/random.d.cts

@@ -0,0 +1,4 @@
+type Alphabet = "a-z" | "A-Z" | "0-9" | "-_";
+declare function createRandomStringGenerator<A extends Alphabet>(...baseAlphabets: A[]): <SubA extends Alphabet>(length: number, ...alphabets: SubA[]) => string;
+
+export { createRandomStringGenerator };

package/template/apps/web/node_modules/@better-auth/utils/dist/random.d.mts

@@ -0,0 +1,4 @@
+type Alphabet = "a-z" | "A-Z" | "0-9" | "-_";
+declare function createRandomStringGenerator<A extends Alphabet>(...baseAlphabets: A[]): <SubA extends Alphabet>(length: number, ...alphabets: SubA[]) => string;
+
+export { createRandomStringGenerator };

package/template/apps/web/node_modules/@better-auth/utils/dist/random.d.ts

@@ -0,0 +1,4 @@
+type Alphabet = "a-z" | "A-Z" | "0-9" | "-_";
+declare function createRandomStringGenerator<A extends Alphabet>(...baseAlphabets: A[]): <SubA extends Alphabet>(length: number, ...alphabets: SubA[]) => string;
+
+export { createRandomStringGenerator };

package/template/apps/web/node_modules/@better-auth/utils/dist/random.mjs

@@ -0,0 +1,53 @@
+function expandAlphabet(alphabet) {
+  switch (alphabet) {
+    case "a-z":
+      return "abcdefghijklmnopqrstuvwxyz";
+    case "A-Z":
+      return "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    case "0-9":
+      return "0123456789";
+    case "-_":
+      return "-_";
+    default:
+      throw new Error(`Unsupported alphabet: ${alphabet}`);
+  }
+}
+function createRandomStringGenerator(...baseAlphabets) {
+  const baseCharSet = baseAlphabets.map(expandAlphabet).join("");
+  if (baseCharSet.length === 0) {
+    throw new Error(
+      "No valid characters provided for random string generation."
+    );
+  }
+  const baseCharSetLength = baseCharSet.length;
+  return (length, ...alphabets) => {
+    if (length <= 0) {
+      throw new Error("Length must be a positive integer.");
+    }
+    let charSet = baseCharSet;
+    let charSetLength = baseCharSetLength;
+    if (alphabets.length > 0) {
+      charSet = alphabets.map(expandAlphabet).join("");
+      charSetLength = charSet.length;
+    }
+    const maxValid = Math.floor(256 / charSetLength) * charSetLength;
+    const buf = new Uint8Array(length * 2);
+    const bufLength = buf.length;
+    let result = "";
+    let bufIndex = bufLength;
+    let rand;
+    while (result.length < length) {
+      if (bufIndex >= bufLength) {
+        crypto.getRandomValues(buf);
+        bufIndex = 0;
+      }
+      rand = buf[bufIndex++];
+      if (rand < maxValid) {
+        result += charSet[rand % charSetLength];
+      }
+    }
+    return result;
+  };
+}
+
+export { createRandomStringGenerator };

package/template/apps/web/node_modules/@better-auth/utils/dist/rsa.cjs

@@ -0,0 +1,76 @@
+'use strict';
+
+const index = require('./index.cjs');
+
+const rsa = {
+  generateKeyPair: async (modulusLength = 2048, hash = "SHA-256") => {
+    return await index.getWebcryptoSubtle().generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: { name: hash }
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+  },
+  exportKey: async (key, format) => {
+    return await index.getWebcryptoSubtle().exportKey(format, key);
+  },
+  importKey: async (key, usage = "encrypt", hash = "SHA-256") => {
+    return await index.getWebcryptoSubtle().importKey(
+      "jwk",
+      key,
+      {
+        name: "RSA-OAEP",
+        hash: { name: hash }
+      },
+      true,
+      [usage]
+    );
+  },
+  encrypt: async (key, data) => {
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await index.getWebcryptoSubtle().encrypt(
+      { name: "RSA-OAEP" },
+      key,
+      encodedData
+    );
+  },
+  decrypt: async (key, data) => {
+    return await index.getWebcryptoSubtle().decrypt({ name: "RSA-OAEP" }, key, data);
+  },
+  sign: async (key, data, saltLength = 32) => {
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await index.getWebcryptoSubtle().sign(
+      {
+        name: "RSA-PSS",
+        saltLength
+      },
+      key,
+      encodedData
+    );
+  },
+  verify: async (key, {
+    signature,
+    data,
+    saltLength = 32
+  }) => {
+    if (typeof signature === "string") {
+      signature = new TextEncoder().encode(signature);
+    }
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await index.getWebcryptoSubtle().verify(
+      {
+        name: "RSA-PSS",
+        saltLength
+      },
+      key,
+      signature,
+      encodedData
+    );
+  }
+};
+
+exports.rsa = rsa;

package/template/apps/web/node_modules/@better-auth/utils/dist/rsa.d.cts

@@ -0,0 +1,16 @@
+type ExportFormat = "jwk" | "spki" | "pkcs8";
+declare const rsa: {
+    generateKeyPair: (modulusLength?: 2048 | 4096, hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKeyPair>;
+    exportKey: <E extends ExportFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+    importKey: (key: JsonWebKey, usage?: "encrypt" | "decrypt", hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKey>;
+    encrypt: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    decrypt: (key: CryptoKey, data: ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    sign: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView, saltLength?: number) => Promise<ArrayBuffer>;
+    verify: (key: CryptoKey, { signature, data, saltLength, }: {
+        signature: ArrayBuffer | ArrayBufferView | string;
+        data: string | ArrayBuffer | ArrayBufferView | string;
+        saltLength?: number;
+    }) => Promise<boolean>;
+};
+
+export { rsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/rsa.d.mts

@@ -0,0 +1,16 @@
+type ExportFormat = "jwk" | "spki" | "pkcs8";
+declare const rsa: {
+    generateKeyPair: (modulusLength?: 2048 | 4096, hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKeyPair>;
+    exportKey: <E extends ExportFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+    importKey: (key: JsonWebKey, usage?: "encrypt" | "decrypt", hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKey>;
+    encrypt: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    decrypt: (key: CryptoKey, data: ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    sign: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView, saltLength?: number) => Promise<ArrayBuffer>;
+    verify: (key: CryptoKey, { signature, data, saltLength, }: {
+        signature: ArrayBuffer | ArrayBufferView | string;
+        data: string | ArrayBuffer | ArrayBufferView | string;
+        saltLength?: number;
+    }) => Promise<boolean>;
+};
+
+export { rsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/rsa.d.ts

@@ -0,0 +1,16 @@
+type ExportFormat = "jwk" | "spki" | "pkcs8";
+declare const rsa: {
+    generateKeyPair: (modulusLength?: 2048 | 4096, hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKeyPair>;
+    exportKey: <E extends ExportFormat>(key: CryptoKey, format: E) => Promise<E extends "jwk" ? JsonWebKey : ArrayBuffer>;
+    importKey: (key: JsonWebKey, usage?: "encrypt" | "decrypt", hash?: "SHA-256" | "SHA-384" | "SHA-512") => Promise<CryptoKey>;
+    encrypt: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    decrypt: (key: CryptoKey, data: ArrayBuffer | ArrayBufferView) => Promise<ArrayBuffer>;
+    sign: (key: CryptoKey, data: string | ArrayBuffer | ArrayBufferView, saltLength?: number) => Promise<ArrayBuffer>;
+    verify: (key: CryptoKey, { signature, data, saltLength, }: {
+        signature: ArrayBuffer | ArrayBufferView | string;
+        data: string | ArrayBuffer | ArrayBufferView | string;
+        saltLength?: number;
+    }) => Promise<boolean>;
+};
+
+export { rsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/rsa.mjs

@@ -0,0 +1,74 @@
+import { getWebcryptoSubtle } from './index.mjs';
+
+const rsa = {
+  generateKeyPair: async (modulusLength = 2048, hash = "SHA-256") => {
+    return await getWebcryptoSubtle().generateKey(
+      {
+        name: "RSA-OAEP",
+        modulusLength,
+        publicExponent: new Uint8Array([1, 0, 1]),
+        hash: { name: hash }
+      },
+      true,
+      ["encrypt", "decrypt"]
+    );
+  },
+  exportKey: async (key, format) => {
+    return await getWebcryptoSubtle().exportKey(format, key);
+  },
+  importKey: async (key, usage = "encrypt", hash = "SHA-256") => {
+    return await getWebcryptoSubtle().importKey(
+      "jwk",
+      key,
+      {
+        name: "RSA-OAEP",
+        hash: { name: hash }
+      },
+      true,
+      [usage]
+    );
+  },
+  encrypt: async (key, data) => {
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await getWebcryptoSubtle().encrypt(
+      { name: "RSA-OAEP" },
+      key,
+      encodedData
+    );
+  },
+  decrypt: async (key, data) => {
+    return await getWebcryptoSubtle().decrypt({ name: "RSA-OAEP" }, key, data);
+  },
+  sign: async (key, data, saltLength = 32) => {
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await getWebcryptoSubtle().sign(
+      {
+        name: "RSA-PSS",
+        saltLength
+      },
+      key,
+      encodedData
+    );
+  },
+  verify: async (key, {
+    signature,
+    data,
+    saltLength = 32
+  }) => {
+    if (typeof signature === "string") {
+      signature = new TextEncoder().encode(signature);
+    }
+    const encodedData = typeof data === "string" ? new TextEncoder().encode(data) : data;
+    return await getWebcryptoSubtle().verify(
+      {
+        name: "RSA-PSS",
+        saltLength
+      },
+      key,
+      signature,
+      encodedData
+    );
+  }
+};
+
+export { rsa };

package/template/apps/web/node_modules/@better-auth/utils/dist/shared/utils.ecd028f7.d.cts

@@ -0,0 +1,22 @@
+type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array<ArrayBuffer>` in TypeScript 5.7
+ * and beyond.
+ *
+ * **Context**
+ *
+ * `Uint8Array` became a generic type in TypeScript 5.7, requiring types defined simply as
+ * `Uint8Array` to be refactored to `Uint8Array<ArrayBuffer>` starting in Deno 2.2. `Uint8Array` is
+ * _not_ generic in Deno 2.1.x and earlier, though, so this type helps bridge this gap.
+ *
+ * Inspired by Deno's std library:
+ *
+ * https://github.com/denoland/std/blob/b5a5fe4f96b91c1fe8dba5cc0270092dd11d3287/bytes/_types.ts#L11
+ */
+type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+type SHAFamily = "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+type EncodingFormat = "hex" | "base64" | "base64url" | "base64urlnopad" | "none";
+type ECDSACurve = "P-256" | "P-384" | "P-521";
+type ExportKeyFormat = "jwk" | "spki" | "pkcs8" | "raw";
+
+export type { EncodingFormat as E, SHAFamily as S, TypedArray as T, Uint8Array_ as U, ECDSACurve as a, ExportKeyFormat as b };

package/template/apps/web/node_modules/@better-auth/utils/dist/shared/utils.ecd028f7.d.mts

@@ -0,0 +1,22 @@
+type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array<ArrayBuffer>` in TypeScript 5.7
+ * and beyond.
+ *
+ * **Context**
+ *
+ * `Uint8Array` became a generic type in TypeScript 5.7, requiring types defined simply as
+ * `Uint8Array` to be refactored to `Uint8Array<ArrayBuffer>` starting in Deno 2.2. `Uint8Array` is
+ * _not_ generic in Deno 2.1.x and earlier, though, so this type helps bridge this gap.
+ *
+ * Inspired by Deno's std library:
+ *
+ * https://github.com/denoland/std/blob/b5a5fe4f96b91c1fe8dba5cc0270092dd11d3287/bytes/_types.ts#L11
+ */
+type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+type SHAFamily = "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+type EncodingFormat = "hex" | "base64" | "base64url" | "base64urlnopad" | "none";
+type ECDSACurve = "P-256" | "P-384" | "P-521";
+type ExportKeyFormat = "jwk" | "spki" | "pkcs8" | "raw";
+
+export type { EncodingFormat as E, SHAFamily as S, TypedArray as T, Uint8Array_ as U, ECDSACurve as a, ExportKeyFormat as b };

package/template/apps/web/node_modules/@better-auth/utils/dist/shared/utils.ecd028f7.d.ts

@@ -0,0 +1,22 @@
+type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * Equivalent to `Uint8Array` before TypeScript 5.7, and `Uint8Array<ArrayBuffer>` in TypeScript 5.7
+ * and beyond.
+ *
+ * **Context**
+ *
+ * `Uint8Array` became a generic type in TypeScript 5.7, requiring types defined simply as
+ * `Uint8Array` to be refactored to `Uint8Array<ArrayBuffer>` starting in Deno 2.2. `Uint8Array` is
+ * _not_ generic in Deno 2.1.x and earlier, though, so this type helps bridge this gap.
+ *
+ * Inspired by Deno's std library:
+ *
+ * https://github.com/denoland/std/blob/b5a5fe4f96b91c1fe8dba5cc0270092dd11d3287/bytes/_types.ts#L11
+ */
+type Uint8Array_ = ReturnType<Uint8Array["slice"]>;
+type SHAFamily = "SHA-1" | "SHA-256" | "SHA-384" | "SHA-512";
+type EncodingFormat = "hex" | "base64" | "base64url" | "base64urlnopad" | "none";
+type ECDSACurve = "P-256" | "P-384" | "P-521";
+type ExportKeyFormat = "jwk" | "spki" | "pkcs8" | "raw";
+
+export type { EncodingFormat as E, SHAFamily as S, TypedArray as T, Uint8Array_ as U, ECDSACurve as a, ExportKeyFormat as b };

package/template/apps/web/node_modules/@better-auth/utils/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@better-auth/utils",
+  "version": "0.4.0",
+  "license": "MIT",
+  "description": "A collection of utilities for better-auth",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "keywords": [
+    "auth",
+    "utils",
+    "typescript",
+    "better-auth",
+    "better-auth-utils"
+  ],
+  "author": "Bereket Engida",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/better-auth/utils"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.10.1",
+    "bumpp": "^9.9.0",
+    "happy-dom": "^15.11.7",
+    "typescript": "^5.8.2",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.1.8"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./base32": {
+      "import": "./dist/base32.mjs",
+      "require": "./dist/base32.cjs"
+    },
+    "./base64": {
+      "import": "./dist/base64.mjs",
+      "require": "./dist/base64.cjs"
+    },
+    "./binary": {
+      "import": "./dist/binary.mjs",
+      "require": "./dist/binary.cjs"
+    },
+    "./hash": {
+      "import": "./dist/hash.mjs",
+      "require": "./dist/hash.cjs"
+    },
+    "./ecdsa": {
+      "import": "./dist/ecdsa.mjs",
+      "require": "./dist/ecdsa.cjs"
+    },
+    "./hex": {
+      "import": "./dist/hex.mjs",
+      "require": "./dist/hex.cjs"
+    },
+    "./hmac": {
+      "import": "./dist/hmac.mjs",
+      "require": "./dist/hmac.cjs"
+    },
+    "./otp": {
+      "import": "./dist/otp.mjs",
+      "require": "./dist/otp.cjs"
+    },
+    "./random": {
+      "import": "./dist/random.mjs",
+      "require": "./dist/random.cjs"
+    },
+    "./rsa": {
+      "import": "./dist/rsa.mjs",
+      "require": "./dist/rsa.cjs"
+    },
+    "./password": {
+      "node": {
+        "import": "./dist/password.node.mjs",
+        "require": "./dist/password.node.cjs"
+      },
+      "import": "./dist/password.mjs",
+      "require": "./dist/password.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@noble/hashes": "^2.0.1"
+  },
+  "scripts": {
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "build": "unbuild",
+    "lint:fix": "biome check . --write"
+  }
+}

package/template/apps/web/node_modules/better-call/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bereket Engida
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/template/apps/web/node_modules/better-call/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;