@hexclave/shared 1.0.61 → 1.0.62

package/dist/{transactions-7q13mxhG.d.ts → transactions-CHNUJ42J.d.ts}

@@ -4,7 +4,8 @@ import { InferType } from "yup";
 //#region src/interface/crud/transactions.d.ts
 declare const transactionEntrySchema: import("yup").MixedSchema<{
   type: "money_transfer";
-  customer_type: "user" | "team" | "custom";
+  customer_id: string;
+  customer_type: "team" | "user" | "custom";
   charged_amount: {
     USD?: string | undefined;
     EUR?: string | undefined;
@@ -19,32 +20,31 @@ declare const transactionEntrySchema: import("yup").MixedSchema<{
   };
   adjusted_transaction_id: string | null;
   adjusted_entry_index: number | null;
-  customer_id: string;
 } | {
   type: "item_quantity_change";
+  item_id: string;
+  customer_id: string;
   quantity: number;
-  customer_type: "user" | "team" | "custom";
+  customer_type: "team" | "user" | "custom";
   adjusted_transaction_id: string | null;
   adjusted_entry_index: number | null;
-  customer_id: string;
-  item_id: string;
 } | {
-  subscription_id?: string | undefined;
   one_time_purchase_id?: string | undefined;
+  subscription_id?: string | undefined;
   type: "product_grant";
+  customer_id: string;
+  product_id: string | null;
   quantity: number;
-  customer_type: "user" | "team" | "custom";
+  customer_type: "team" | "user" | "custom";
   product: {
+    free_trial?: DayInterval | undefined;
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    free_trial?: DayInterval | undefined;
-    display_name: string;
-    customer_type: "user" | "team" | "custom";
     server_only: boolean;
+    customer_type: "team" | "user" | "custom";
     stackable: boolean;
     prices: Record<string, {
-      free_trial?: DayInterval | undefined;
       USD?: string | undefined;
       EUR?: string | undefined;
       GBP?: string | undefined;
@@ -53,17 +53,17 @@ declare const transactionEntrySchema: import("yup").MixedSchema<{
       AUD?: string | undefined;
       CAD?: string | undefined;
       interval?: DayInterval | undefined;
+      free_trial?: DayInterval | undefined;
     }>;
+    display_name: string;
     included_items: Record<string, {
-      repeat?: "never" | DayInterval | undefined;
       quantity?: number | undefined;
+      repeat?: "never" | DayInterval | undefined;
       expires?: "never" | "when-purchase-expires" | "when-repeated" | undefined;
     }>;
   };
-  product_id: string | null;
   adjusted_transaction_id: string | null;
   adjusted_entry_index: number | null;
-  customer_id: string;
   price_id: string | null;
 } | {
   type: "product_revocation";
@@ -84,11 +84,12 @@ declare const transactionSchema: import("yup").ObjectSchema<{
   created_at_millis: number;
   effective_at_millis: number;
   type: "purchase" | "subscription-cancellation" | "subscription-renewal" | "manual-item-quantity-change" | "refund" | "chargeback" | "product-change" | null;
-  customer_type: "user" | "team" | "custom";
+  customer_type: "team" | "user" | "custom";
   customer_id: string;
   entries: ({
     type: "money_transfer";
-    customer_type: "user" | "team" | "custom";
+    customer_id: string;
+    customer_type: "team" | "user" | "custom";
     charged_amount: {
       USD?: string | undefined;
       EUR?: string | undefined;
@@ -103,32 +104,31 @@ declare const transactionSchema: import("yup").ObjectSchema<{
     };
     adjusted_transaction_id: string | null;
     adjusted_entry_index: number | null;
-    customer_id: string;
   } | {
     type: "item_quantity_change";
+    item_id: string;
+    customer_id: string;
     quantity: number;
-    customer_type: "user" | "team" | "custom";
+    customer_type: "team" | "user" | "custom";
     adjusted_transaction_id: string | null;
     adjusted_entry_index: number | null;
-    customer_id: string;
-    item_id: string;
   } | {
-    subscription_id?: string | undefined;
     one_time_purchase_id?: string | undefined;
+    subscription_id?: string | undefined;
     type: "product_grant";
+    customer_id: string;
+    product_id: string | null;
     quantity: number;
-    customer_type: "user" | "team" | "custom";
+    customer_type: "team" | "user" | "custom";
     product: {
+      free_trial?: DayInterval | undefined;
       client_metadata?: {} | null | undefined;
       client_read_only_metadata?: {} | null | undefined;
       server_metadata?: {} | null | undefined;
-      free_trial?: DayInterval | undefined;
-      display_name: string;
-      customer_type: "user" | "team" | "custom";
       server_only: boolean;
+      customer_type: "team" | "user" | "custom";
       stackable: boolean;
       prices: Record<string, {
-        free_trial?: DayInterval | undefined;
         USD?: string | undefined;
         EUR?: string | undefined;
         GBP?: string | undefined;
@@ -137,17 +137,17 @@ declare const transactionSchema: import("yup").ObjectSchema<{
         AUD?: string | undefined;
         CAD?: string | undefined;
         interval?: DayInterval | undefined;
+        free_trial?: DayInterval | undefined;
       }>;
+      display_name: string;
       included_items: Record<string, {
-        repeat?: "never" | DayInterval | undefined;
         quantity?: number | undefined;
+        repeat?: "never" | DayInterval | undefined;
         expires?: "never" | "when-purchase-expires" | "when-repeated" | undefined;
       }>;
     };
-    product_id: string | null;
     adjusted_transaction_id: string | null;
     adjusted_entry_index: number | null;
-    customer_id: string;
     price_id: string | null;
   } | {
     type: "product_revocation";
@@ -179,4 +179,4 @@ declare const transactionSchema: import("yup").ObjectSchema<{
 type Transaction = InferType<typeof transactionSchema>;
 //#endregion
 export { transactionEntrySchema as a, TransactionType as i, Transaction as n, transactionSchema as o, TransactionEntry as r, TRANSACTION_TYPES as t };
-//# sourceMappingURL=transactions-7q13mxhG.d.ts.map
+//# sourceMappingURL=transactions-CHNUJ42J.d.ts.map

package/dist/transactions-CHNUJ42J.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions-CHNUJ42J.d.ts","names":[],"sources":["../src/interface/crud/transactions.ts"],"mappings":";;;;cAwFa,sBAAA,gBAAsB,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMxB,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEC,gBAAA,GAAmB,SAAS,QAAQ,sBAAA;AAAA,cAEnC,iBAAA;AAAA,KAUD,eAAA,WAA0B,iBAAiB;AAAA,cAE1C,iBAAA,gBAAiB,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAkBlB,WAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEA,WAAA,GAAc,SAAS,QAAQ,iBAAA"}

package/dist/{users-7MKfEyyq.d.ts → users-DHNRwoSz.d.ts}

@@ -1,5 +1,5 @@
 import { c as CrudTypeOf, s as CrudSchemaFromOptions } from "./crud-CqmEW9s6.js";
-import { t as WebhookEvent } from "./webhooks-C5gG85Ce.js";
+import { t as WebhookEvent } from "./webhooks-8Ts1Clcb.js";
 import * as yup$1 from "yup";
 import { InferType } from "yup";
 
@@ -80,10 +80,10 @@ declare const usersCrudServerReadSchema: yup$1.ObjectSchema<{
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    id: string;
     display_name: string;
-    profile_image_url: string | null;
+    id: string;
     created_at_millis: number;
+    profile_image_url: string | null;
   } | null;
   selected_team_id: string | null;
   profile_image_url: string | null;
@@ -162,34 +162,34 @@ declare const usersCrudServerReadSchema: yup$1.ObjectSchema<{
   requires_totp_mfa: undefined;
 }, "">;
 declare const usersCrudServerCreateSchema: yup$1.ObjectSchema<{
+  primary_email: string | null | undefined;
+  display_name: string | null | undefined;
   client_metadata: {} | null | undefined;
   client_read_only_metadata: {} | null | undefined;
   server_metadata: {} | null | undefined;
-  primary_email: string | null | undefined;
+  is_anonymous: boolean | undefined;
+  password: string | null | undefined;
+  country_code: string | null | undefined;
+  profile_image_url: string | null | undefined;
   primary_email_verified: boolean | undefined;
   primary_email_auth_enabled: boolean | undefined;
-  display_name: string | null | undefined;
-  profile_image_url: string | null | undefined;
   otp_auth_enabled: boolean | undefined;
   passkey_auth_enabled: boolean | undefined;
-  is_anonymous: boolean | undefined;
   restricted_by_admin: boolean | undefined;
   restricted_by_admin_reason: string | null | undefined;
   restricted_by_admin_private_details: string | null | undefined;
-  country_code: string | null | undefined;
   risk_scores: {
     sign_up: {
       bot: number;
       free_trial_abuse: number;
     };
   } | undefined;
-  password: string | null | undefined;
   password_hash: string | undefined;
   totp_secret_base64: string | null | undefined;
 } & {
   oauth_providers: {
-    id: string;
     email: string | null;
+    id: string;
     account_id: string;
   }[] | undefined;
   is_anonymous: boolean | undefined;
@@ -233,10 +233,10 @@ declare const usersCrud: CrudSchemaFromOptions<{
       client_metadata?: {} | null | undefined;
       client_read_only_metadata?: {} | null | undefined;
       server_metadata?: {} | null | undefined;
-      id: string;
       display_name: string;
-      profile_image_url: string | null;
+      id: string;
       created_at_millis: number;
+      profile_image_url: string | null;
     } | null;
     selected_team_id: string | null;
     profile_image_url: string | null;
@@ -368,34 +368,34 @@ declare const usersCrud: CrudSchemaFromOptions<{
     };
   }, "">;
   serverCreateSchema: yup$1.ObjectSchema<{
+    primary_email: string | null | undefined;
+    display_name: string | null | undefined;
     client_metadata: {} | null | undefined;
     client_read_only_metadata: {} | null | undefined;
     server_metadata: {} | null | undefined;
-    primary_email: string | null | undefined;
+    is_anonymous: boolean | undefined;
+    password: string | null | undefined;
+    country_code: string | null | undefined;
+    profile_image_url: string | null | undefined;
     primary_email_verified: boolean | undefined;
     primary_email_auth_enabled: boolean | undefined;
-    display_name: string | null | undefined;
-    profile_image_url: string | null | undefined;
     otp_auth_enabled: boolean | undefined;
     passkey_auth_enabled: boolean | undefined;
-    is_anonymous: boolean | undefined;
     restricted_by_admin: boolean | undefined;
     restricted_by_admin_reason: string | null | undefined;
     restricted_by_admin_private_details: string | null | undefined;
-    country_code: string | null | undefined;
     risk_scores: {
       sign_up: {
         bot: number;
         free_trial_abuse: number;
       };
     } | undefined;
-    password: string | null | undefined;
     password_hash: string | undefined;
     totp_secret_base64: string | null | undefined;
   } & {
     oauth_providers: {
-      id: string;
       email: string | null;
+      id: string;
       account_id: string;
     }[] | undefined;
     is_anonymous: boolean | undefined;
@@ -467,10 +467,10 @@ declare const userCreatedWebhookEvent: WebhookEvent<yup$1.ObjectSchema<{
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    id: string;
     display_name: string;
-    profile_image_url: string | null;
+    id: string;
     created_at_millis: number;
+    profile_image_url: string | null;
   } | null;
   selected_team_id: string | null;
   profile_image_url: string | null;
@@ -558,10 +558,10 @@ declare const userUpdatedWebhookEvent: WebhookEvent<yup$1.ObjectSchema<{
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    id: string;
     display_name: string;
-    profile_image_url: string | null;
+    id: string;
     created_at_millis: number;
+    profile_image_url: string | null;
   } | null;
   selected_team_id: string | null;
   profile_image_url: string | null;
@@ -650,4 +650,4 @@ declare const userDeletedWebhookEvent: WebhookEvent<yup$1.ObjectSchema<{
 }, "">>;
 //#endregion
 export { userCreatedWebhookEvent as a, usersCrud as c, usersCrudServerReadSchema as d, usersCrudServerUpdateSchema as f, signUpRiskScoresSchema as i, usersCrudServerCreateSchema as l, UsersCrud as n, userDeletedWebhookEvent as o, riskScoreFieldSchema as r, userUpdatedWebhookEvent as s, SignUpRiskScoresCrud as t, usersCrudServerDeleteSchema as u };
-//# sourceMappingURL=users-7MKfEyyq.d.ts.map
+//# sourceMappingURL=users-DHNRwoSz.d.ts.map

package/dist/{users-7MKfEyyq.d.ts.map → users-DHNRwoSz.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"users-7MKfEyyq.d.ts","names":[],"sources":["../src/interface/crud/users.ts"],"mappings":";;;;;;cAea,oBAAA,EAAoB,KAAA,CAAA,YAAA,SAAA,KAAA,CAAA,SAAA;AAAA,cACpB,sBAAA,EAAsB,KAAA,CAAA,YAAA;;;;;GAKjC,KAAA,CAAA,SAAA;;;;;;KACU,oBAAA,GAAuB,SAAS,QAAQ,sBAAA;AAAA,cAqBvC,2BAAA,EAA2B,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GAyBvC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEY,yBAAA,EAAyB,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CrC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEY,2BAAA,EAA2B,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM3B,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,2BAAA,EAA2B,KAAA,CAAA,WAAA,iBAAA,KAAA,CAAA,SAAA;AAAA,cAE3B,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiCD,SAAA,GAAY,UAAU,QAAQ,SAAA;AAAA,cAc7B,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACvB,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAQvB,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA"}
+{"version":3,"file":"users-DHNRwoSz.d.ts","names":[],"sources":["../src/interface/crud/users.ts"],"mappings":";;;;;;cAea,oBAAA,EAAoB,KAAA,CAAA,YAAA,SAAA,KAAA,CAAA,SAAA;AAAA,cACpB,sBAAA,EAAsB,KAAA,CAAA,YAAA;;;;;GAKjC,KAAA,CAAA,SAAA;;;;;;KACU,oBAAA,GAAuB,SAAS,QAAQ,sBAAA;AAAA,cAqBvC,2BAAA,EAA2B,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GAyBvC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEY,yBAAA,EAAyB,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CrC,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEY,2BAAA,EAA2B,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAM3B,KAAA,CAAA,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAEA,2BAAA,EAA2B,KAAA,CAAA,WAAA,iBAAA,KAAA,CAAA,SAAA;AAAA,cAE3B,SAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiCD,SAAA,GAAY,UAAU,QAAQ,SAAA;AAAA,cAc7B,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cACvB,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAQvB,uBAAA,EAAuB,YAAA,CAAA,KAAA,CAAA,YAAA"}

package/dist/utils/tar.d.ts

@@ -0,0 +1,26 @@
+//#region src/utils/tar.d.ts
+type TarEntry = {
+  path: string;
+  data: Uint8Array;
+};
+type TarLimits = {
+  maxEntries: number;
+  maxTotalBytes: number;
+};
+/**
+ * Serializes entries into an (uncompressed) ustar tarball. Entries whose path
+ * ends with "/" are written as directories and must have empty data.
+ */
+declare function createTar(entries: TarEntry[]): Uint8Array<ArrayBuffer>;
+/**
+ * Parses an (uncompressed) ustar tarball produced by `createTar` (or any tool
+ * emitting the plain ustar subset). Strict by design — see module comment.
+ * Directory entries are returned with a trailing "/" and empty data.
+ *
+ * Throws `StatusError(400, ...)` on malformed or unsafe input so backend routes
+ * can surface it directly to the uploader.
+ */
+declare function parseTar(bytes: Uint8Array, limits: TarLimits): TarEntry[];
+//#endregion
+export { TarEntry, TarLimits, createTar, parseTar };
+//# sourceMappingURL=tar.d.ts.map

package/dist/utils/tar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar.d.ts","names":[],"sources":["../../src/utils/tar.tsx"],"mappings":";KAeY,QAAA;EAEV,IAAA;EACA,IAAA,EAAM,UAAU;AAAA;AAAA,KAGN,SAAA;EACV,UAAA;EACA,aAAa;AAAA;;AALG;AAGlB;;iBAqDgB,SAAA,CAAU,OAAA,EAAS,QAAA,KAAa,UAAA,CAAW,WAAA;;AAnD5C;AAmDf;;;;;;iBA2EgB,QAAA,CAAS,KAAA,EAAO,UAAA,EAAY,MAAA,EAAQ,SAAA,GAAY,QAAA"}

package/dist/utils/tar.js

@@ -0,0 +1,138 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let __errors_js = require("./errors.js");
+//#region src/utils/tar.tsx
+const BLOCK_SIZE = 512;
+function writeOctal(header, offset, length, value) {
+	if (value < 0 || !Number.isSafeInteger(value)) throw new __errors_js.HexclaveAssertionError(`Invalid tar octal value: ${value}`);
+	const str = value.toString(8).padStart(length - 1, "0");
+	if (str.length > length - 1) throw new __errors_js.HexclaveAssertionError(`Tar octal value too large for field: ${value} (field length ${length})`);
+	for (let i = 0; i < str.length; i++) header[offset + i] = str.charCodeAt(i);
+}
+function writeString(header, offset, length, value) {
+	const bytes = new TextEncoder().encode(value);
+	if (bytes.length > length) throw new __errors_js.HexclaveAssertionError(`Tar string too long for field: ${value}`);
+	header.set(bytes, offset);
+}
+function splitUstarPath(path) {
+	if (new TextEncoder().encode(path).length <= 100) return {
+		prefix: "",
+		name: path
+	};
+	const parts = path.split("/");
+	for (let i = parts.length - 1; i > 0; i--) {
+		const prefix = parts.slice(0, i).join("/");
+		const name = parts.slice(i).join("/");
+		const prefixLen = new TextEncoder().encode(prefix).length;
+		const nameLen = new TextEncoder().encode(name).length;
+		if (prefixLen <= 155 && nameLen > 0 && nameLen <= 100) return {
+			prefix,
+			name
+		};
+	}
+}
+/**
+* Serializes entries into an (uncompressed) ustar tarball. Entries whose path
+* ends with "/" are written as directories and must have empty data.
+*/
+function createTar(entries) {
+	const chunks = [];
+	for (const entry of entries) {
+		if (entry.path.startsWith("/") || entry.path.split("/").includes("..") || entry.path === "") throw new __errors_js.HexclaveAssertionError(`Invalid tar entry path: ${JSON.stringify(entry.path)}`);
+		const isDirectory = entry.path.endsWith("/");
+		if (isDirectory && entry.data.length > 0) throw new __errors_js.HexclaveAssertionError(`Tar directory entry must have empty data: ${entry.path}`);
+		const split = splitUstarPath(entry.path) ?? throwPathTooLong(entry.path);
+		const header = new Uint8Array(BLOCK_SIZE);
+		writeString(header, 0, 100, split.name);
+		writeOctal(header, 100, 8, isDirectory ? 493 : 420);
+		writeOctal(header, 108, 8, 0);
+		writeOctal(header, 116, 8, 0);
+		writeOctal(header, 124, 12, entry.data.length);
+		writeOctal(header, 136, 12, 0);
+		header[156] = isDirectory ? 53 : 48;
+		writeString(header, 257, 6, "ustar");
+		header[263] = 48;
+		header[264] = 48;
+		writeString(header, 345, 155, split.prefix);
+		header.fill(32, 148, 156);
+		let checksum = 0;
+		for (const byte of header) checksum += byte;
+		header.fill(0, 148, 156);
+		writeOctal(header, 148, 7, checksum);
+		header[155] = 32;
+		chunks.push(header);
+		if (entry.data.length > 0) {
+			chunks.push(entry.data);
+			const padding = (BLOCK_SIZE - entry.data.length % BLOCK_SIZE) % BLOCK_SIZE;
+			if (padding > 0) chunks.push(new Uint8Array(padding));
+		}
+	}
+	chunks.push(new Uint8Array(2 * BLOCK_SIZE));
+	const total = chunks.reduce((sum, c) => sum + c.length, 0);
+	const result = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		result.set(chunk, offset);
+		offset += chunk.length;
+	}
+	return result;
+}
+function throwPathTooLong(path) {
+	throw new __errors_js.StatusError(400, `File path too long to be packaged: ${JSON.stringify(path)}`);
+}
+function readString(block, offset, length) {
+	let end = offset;
+	while (end < offset + length && block[end] !== 0) end++;
+	return new TextDecoder().decode(block.subarray(offset, end));
+}
+function readOctal(block, offset, length) {
+	const str = readString(block, offset, length).trim();
+	if (str === "") return 0;
+	if (!/^[0-7]+$/.test(str)) throw new __errors_js.StatusError(400, "Invalid tarball: malformed octal header field");
+	return parseInt(str, 8);
+}
+/**
+* Parses an (uncompressed) ustar tarball produced by `createTar` (or any tool
+* emitting the plain ustar subset). Strict by design — see module comment.
+* Directory entries are returned with a trailing "/" and empty data.
+*
+* Throws `StatusError(400, ...)` on malformed or unsafe input so backend routes
+* can surface it directly to the uploader.
+*/
+function parseTar(bytes, limits) {
+	const entries = [];
+	let offset = 0;
+	let totalBytes = 0;
+	while (offset + BLOCK_SIZE <= bytes.length) {
+		const header = bytes.subarray(offset, offset + BLOCK_SIZE);
+		if (header.every((b) => b === 0)) return entries;
+		if (readString(header, 257, 6) !== "ustar") throw new __errors_js.StatusError(400, "Invalid tarball: not a ustar archive");
+		let expectedChecksum = 0;
+		for (let i = 0; i < BLOCK_SIZE; i++) expectedChecksum += i >= 148 && i < 156 ? 32 : header[i];
+		if (readOctal(header, 148, 8) !== expectedChecksum) throw new __errors_js.StatusError(400, "Invalid tarball: header checksum mismatch");
+		const typeflag = header[156];
+		if (typeflag !== 48 && typeflag !== 0 && typeflag !== 53) throw new __errors_js.StatusError(400, "Invalid tarball: only regular files and directories are supported");
+		const prefix = readString(header, 345, 155);
+		const name = readString(header, 0, 100);
+		const path = prefix === "" ? name : `${prefix}/${name}`;
+		if (path === "" || path.startsWith("/") || path.split("/").includes("..") || path.includes("\\")) throw new __errors_js.StatusError(400, `Invalid tarball: unsafe entry path ${JSON.stringify(path)}`);
+		const size = readOctal(header, 124, 12);
+		const isDirectory = typeflag === 53;
+		if (isDirectory && size !== 0) throw new __errors_js.StatusError(400, "Invalid tarball: directory entry with non-zero size");
+		offset += BLOCK_SIZE;
+		if (offset + size > bytes.length) throw new __errors_js.StatusError(400, "Invalid tarball: truncated file data");
+		totalBytes += size;
+		if (entries.length + 1 > limits.maxEntries) throw new __errors_js.StatusError(400, `Tarball contains too many files (max ${limits.maxEntries})`);
+		if (totalBytes > limits.maxTotalBytes) throw new __errors_js.StatusError(400, `Tarball contents too large (max ${limits.maxTotalBytes} bytes)`);
+		entries.push({
+			path: isDirectory && !path.endsWith("/") ? `${path}/` : path,
+			data: bytes.slice(offset, offset + size)
+		});
+		offset += size + (BLOCK_SIZE - size % BLOCK_SIZE) % BLOCK_SIZE;
+	}
+	throw new __errors_js.StatusError(400, "Invalid tarball: missing end-of-archive marker");
+}
+//#endregion
+exports.createTar = createTar;
+exports.parseTar = parseTar;
+
+//# sourceMappingURL=tar.js.map

package/dist/utils/tar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tar.js","names":["HexclaveAssertionError","StatusError"],"sources":["../../src/utils/tar.tsx"],"sourcesContent":["// A minimal, dependency-free ustar (POSIX.1-1988) tarball writer/reader.\n//\n// Why hand-rolled: the `hexclave deploy` CLI packages a source directory into a\n// tarball and the backend unpacks it to forward the files to Vercel. Both ends\n// are our own code, so we only need the ustar subset we produce ourselves\n// (regular files + directories), and hand-rolling avoids adding an npm\n// dependency to the CLI and backend. The reader is intentionally strict — it\n// rejects anything our writer wouldn't produce (symlinks, PAX extensions,\n// absolute or `..` paths) because on the backend it processes untrusted user\n// uploads.\n\nimport { HexclaveAssertionError, StatusError } from \"./errors\";\n\nconst BLOCK_SIZE = 512;\n\nexport type TarEntry = {\n  // Relative POSIX path, e.g. \"src/index.ts\". Directories end with \"/\".\n  path: string,\n  data: Uint8Array,\n};\n\nexport type TarLimits = {\n  maxEntries: number,\n  maxTotalBytes: number,\n};\n\nfunction writeOctal(header: Uint8Array, offset: number, length: number, value: number): void {\n  if (value < 0 || !Number.isSafeInteger(value)) {\n    throw new HexclaveAssertionError(`Invalid tar octal value: ${value}`);\n  }\n  const str = value.toString(8).padStart(length - 1, \"0\");\n  if (str.length > length - 1) {\n    throw new HexclaveAssertionError(`Tar octal value too large for field: ${value} (field length ${length})`);\n  }\n  for (let i = 0; i < str.length; i++) {\n    header[offset + i] = str.charCodeAt(i);\n  }\n  // NUL terminator (field is left NUL-filled past the digits).\n}\n\nfunction writeString(header: Uint8Array, offset: number, length: number, value: string): void {\n  const bytes = new TextEncoder().encode(value);\n  if (bytes.length > length) {\n    throw new HexclaveAssertionError(`Tar string too long for field: ${value}`);\n  }\n  header.set(bytes, offset);\n}\n\n// Splits a path into (prefix, name) fitting ustar's 155+100 byte fields.\n// Returns undefined if the path can't be represented.\nfunction splitUstarPath(path: string): { prefix: string, name: string } | undefined {\n  const bytes = new TextEncoder().encode(path);\n  if (bytes.length <= 100) {\n    return { prefix: \"\", name: path };\n  }\n  // Find a \"/\" such that everything before it fits in prefix (<=155) and\n  // everything after fits in name (<=100). Prefer the longest possible prefix.\n  const parts = path.split(\"/\");\n  for (let i = parts.length - 1; i > 0; i--) {\n    const prefix = parts.slice(0, i).join(\"/\");\n    const name = parts.slice(i).join(\"/\");\n    const prefixLen = new TextEncoder().encode(prefix).length;\n    const nameLen = new TextEncoder().encode(name).length;\n    if (prefixLen <= 155 && nameLen > 0 && nameLen <= 100) {\n      return { prefix, name };\n    }\n  }\n  return undefined;\n}\n\n/**\n * Serializes entries into an (uncompressed) ustar tarball. Entries whose path\n * ends with \"/\" are written as directories and must have empty data.\n */\nexport function createTar(entries: TarEntry[]): Uint8Array<ArrayBuffer> {\n  const chunks: Uint8Array[] = [];\n  for (const entry of entries) {\n    if (entry.path.startsWith(\"/\") || entry.path.split(\"/\").includes(\"..\") || entry.path === \"\") {\n      throw new HexclaveAssertionError(`Invalid tar entry path: ${JSON.stringify(entry.path)}`);\n    }\n    const isDirectory = entry.path.endsWith(\"/\");\n    if (isDirectory && entry.data.length > 0) {\n      throw new HexclaveAssertionError(`Tar directory entry must have empty data: ${entry.path}`);\n    }\n    const split = splitUstarPath(entry.path) ?? throwPathTooLong(entry.path);\n    const header = new Uint8Array(BLOCK_SIZE);\n    writeString(header, 0, 100, split.name);\n    writeOctal(header, 100, 8, isDirectory ? 0o755 : 0o644); // mode\n    writeOctal(header, 108, 8, 0); // uid\n    writeOctal(header, 116, 8, 0); // gid\n    writeOctal(header, 124, 12, entry.data.length); // size\n    writeOctal(header, 136, 12, 0); // mtime — fixed at 0 so tarballs are deterministic for identical input\n    header[156] = isDirectory ? 0x35 /* '5' */ : 0x30 /* '0' */; // typeflag\n    writeString(header, 257, 6, \"ustar\");\n    header[263] = 0x30; // version \"00\"\n    header[264] = 0x30;\n    writeString(header, 345, 155, split.prefix);\n    // Checksum: sum of all header bytes with the checksum field as spaces.\n    header.fill(0x20, 148, 156);\n    let checksum = 0;\n    for (const byte of header) checksum += byte;\n    header.fill(0, 148, 156);\n    writeOctal(header, 148, 7, checksum);\n    header[155] = 0x20;\n    chunks.push(header);\n    if (entry.data.length > 0) {\n      chunks.push(entry.data);\n      const padding = (BLOCK_SIZE - (entry.data.length % BLOCK_SIZE)) % BLOCK_SIZE;\n      if (padding > 0) chunks.push(new Uint8Array(padding));\n    }\n  }\n  chunks.push(new Uint8Array(2 * BLOCK_SIZE)); // end-of-archive marker\n  const total = chunks.reduce((sum, c) => sum + c.length, 0);\n  const result = new Uint8Array(total);\n  let offset = 0;\n  for (const chunk of chunks) {\n    result.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return result;\n}\n\nfunction throwPathTooLong(path: string): never {\n  throw new StatusError(400, `File path too long to be packaged: ${JSON.stringify(path)}`);\n}\n\nfunction readString(block: Uint8Array, offset: number, length: number): string {\n  let end = offset;\n  while (end < offset + length && block[end] !== 0) end++;\n  return new TextDecoder().decode(block.subarray(offset, end));\n}\n\nfunction readOctal(block: Uint8Array, offset: number, length: number): number {\n  const str = readString(block, offset, length).trim();\n  if (str === \"\") return 0;\n  if (!/^[0-7]+$/.test(str)) {\n    throw new StatusError(400, \"Invalid tarball: malformed octal header field\");\n  }\n  return parseInt(str, 8);\n}\n\n/**\n * Parses an (uncompressed) ustar tarball produced by `createTar` (or any tool\n * emitting the plain ustar subset). Strict by design — see module comment.\n * Directory entries are returned with a trailing \"/\" and empty data.\n *\n * Throws `StatusError(400, ...)` on malformed or unsafe input so backend routes\n * can surface it directly to the uploader.\n */\nexport function parseTar(bytes: Uint8Array, limits: TarLimits): TarEntry[] {\n  const entries: TarEntry[] = [];\n  let offset = 0;\n  let totalBytes = 0;\n  while (offset + BLOCK_SIZE <= bytes.length) {\n    const header = bytes.subarray(offset, offset + BLOCK_SIZE);\n    if (header.every((b) => b === 0)) {\n      // End-of-archive marker (we accept a single zero block too).\n      return entries;\n    }\n    const magic = readString(header, 257, 6);\n    if (magic !== \"ustar\") {\n      throw new StatusError(400, \"Invalid tarball: not a ustar archive\");\n    }\n    let expectedChecksum = 0;\n    for (let i = 0; i < BLOCK_SIZE; i++) {\n      expectedChecksum += (i >= 148 && i < 156) ? 0x20 : header[i];\n    }\n    if (readOctal(header, 148, 8) !== expectedChecksum) {\n      throw new StatusError(400, \"Invalid tarball: header checksum mismatch\");\n    }\n    const typeflag = header[156];\n    if (typeflag !== 0x30 && typeflag !== 0 && typeflag !== 0x35) {\n      throw new StatusError(400, \"Invalid tarball: only regular files and directories are supported\");\n    }\n    const prefix = readString(header, 345, 155);\n    const name = readString(header, 0, 100);\n    const path = prefix === \"\" ? name : `${prefix}/${name}`;\n    if (path === \"\" || path.startsWith(\"/\") || path.split(\"/\").includes(\"..\") || path.includes(\"\\\\\")) {\n      throw new StatusError(400, `Invalid tarball: unsafe entry path ${JSON.stringify(path)}`);\n    }\n    const size = readOctal(header, 124, 12);\n    const isDirectory = typeflag === 0x35;\n    if (isDirectory && size !== 0) {\n      throw new StatusError(400, \"Invalid tarball: directory entry with non-zero size\");\n    }\n    offset += BLOCK_SIZE;\n    if (offset + size > bytes.length) {\n      throw new StatusError(400, \"Invalid tarball: truncated file data\");\n    }\n    totalBytes += size;\n    if (entries.length + 1 > limits.maxEntries) {\n      throw new StatusError(400, `Tarball contains too many files (max ${limits.maxEntries})`);\n    }\n    if (totalBytes > limits.maxTotalBytes) {\n      throw new StatusError(400, `Tarball contents too large (max ${limits.maxTotalBytes} bytes)`);\n    }\n    entries.push({\n      path: isDirectory && !path.endsWith(\"/\") ? `${path}/` : path,\n      data: bytes.slice(offset, offset + size),\n    });\n    offset += size + ((BLOCK_SIZE - (size % BLOCK_SIZE)) % BLOCK_SIZE);\n  }\n  throw new StatusError(400, \"Invalid tarball: missing end-of-archive marker\");\n}\n\nconst TEST_LIMITS: TarLimits = { maxEntries: 1000, maxTotalBytes: 10 * 1024 * 1024 };\n\nimport.meta.vitest?.test(\"createTar/parseTar roundtrip\", ({ expect }) => {\n  const entries: TarEntry[] = [\n    { path: \"package.json\", data: new TextEncoder().encode(`{\"name\":\"x\"}`) },\n    { path: \"src/\", data: new Uint8Array(0) },\n    { path: \"src/index.ts\", data: new TextEncoder().encode(\"export const a = 1;\\n\") },\n    { path: \"empty.txt\", data: new Uint8Array(0) },\n    { path: \"binary.bin\", data: new Uint8Array([0, 1, 2, 255, 254, 253]) },\n  ];\n  const tar = createTar(entries);\n  expect(tar.length % 512).toBe(0);\n  const parsed = parseTar(tar, TEST_LIMITS);\n  expect(parsed.map((e) => e.path)).toEqual(entries.map((e) => e.path));\n  for (let i = 0; i < entries.length; i++) {\n    expect([...parsed[i].data]).toEqual([...entries[i].data]);\n  }\n});\n\nimport.meta.vitest?.test(\"createTar/parseTar long paths use the ustar prefix field\", ({ expect }) => {\n  const longDir = Array.from({ length: 12 }, (_, i) => `directory-number-${i}`).join(\"/\");\n  const path = `${longDir}/file.txt`;\n  expect(path.length).toBeGreaterThan(100);\n  const tar = createTar([{ path, data: new TextEncoder().encode(\"hello\") }]);\n  const parsed = parseTar(tar, TEST_LIMITS);\n  expect(parsed).toHaveLength(1);\n  expect(parsed[0].path).toBe(path);\n  expect(new TextDecoder().decode(parsed[0].data)).toBe(\"hello\");\n});\n\nimport.meta.vitest?.test(\"createTar rejects unsafe paths\", ({ expect }) => {\n  expect(() => createTar([{ path: \"/etc/passwd\", data: new Uint8Array(0) }])).toThrow();\n  expect(() => createTar([{ path: \"../escape\", data: new Uint8Array(0) }])).toThrow();\n  expect(() => createTar([{ path: \"a/../b\", data: new Uint8Array(0) }])).toThrow();\n  expect(() => createTar([{ path: \"\", data: new Uint8Array(0) }])).toThrow();\n});\n\nimport.meta.vitest?.test(\"parseTar rejects malformed and unsafe archives\", ({ expect }) => {\n  expect(() => parseTar(new Uint8Array(1024), TEST_LIMITS)).not.toThrow(); // all-zero = empty archive\n  expect(() => parseTar(new TextEncoder().encode(\"too short to contain a single header block\"), TEST_LIMITS)).toThrow(\"missing end-of-archive marker\");\n  const garbageBlock = new Uint8Array(512).fill(0x41 /* 'A' */);\n  expect(() => parseTar(garbageBlock, TEST_LIMITS)).toThrow(\"not a ustar archive\");\n\n  // Corrupt a valid archive's checksum.\n  const tar = createTar([{ path: \"a.txt\", data: new TextEncoder().encode(\"hi\") }]);\n  const corrupted = tar.slice();\n  corrupted[0] ^= 0xff;\n  expect(() => parseTar(corrupted, TEST_LIMITS)).toThrow(\"checksum mismatch\");\n\n  // Truncated data section.\n  expect(() => parseTar(tar.subarray(0, 512), TEST_LIMITS)).toThrow(\"truncated\");\n\n  // Limits.\n  expect(() => parseTar(tar, { maxEntries: 0, maxTotalBytes: 1000 })).toThrow(\"too many files\");\n  expect(() => parseTar(tar, { maxEntries: 10, maxTotalBytes: 1 })).toThrow(\"too large\");\n});\n"],"mappings":"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"}

package/dist/{webhooks-C5gG85Ce.d.ts → webhooks-8Ts1Clcb.d.ts}

@@ -20,10 +20,10 @@ declare const webhookEvents: readonly [WebhookEvent<yup$1.ObjectSchema<{
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    id: string;
     display_name: string;
-    profile_image_url: string | null;
+    id: string;
     created_at_millis: number;
+    profile_image_url: string | null;
   } | null;
   selected_team_id: string | null;
   profile_image_url: string | null;
@@ -110,10 +110,10 @@ declare const webhookEvents: readonly [WebhookEvent<yup$1.ObjectSchema<{
     client_metadata?: {} | null | undefined;
     client_read_only_metadata?: {} | null | undefined;
     server_metadata?: {} | null | undefined;
-    id: string;
     display_name: string;
-    profile_image_url: string | null;
+    id: string;
     created_at_millis: number;
+    profile_image_url: string | null;
   } | null;
   selected_team_id: string | null;
   profile_image_url: string | null;
@@ -323,4 +323,4 @@ declare const webhookEvents: readonly [WebhookEvent<yup$1.ObjectSchema<{
 }];
 //#endregion
 export { webhookEvents as n, WebhookEvent as t };
-//# sourceMappingURL=webhooks-C5gG85Ce.d.ts.map
+//# sourceMappingURL=webhooks-8Ts1Clcb.d.ts.map

package/dist/{webhooks-C5gG85Ce.d.ts.map → webhooks-8Ts1Clcb.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"webhooks-C5gG85Ce.d.ts","names":[],"sources":["../src/interface/webhooks.ts"],"mappings":";;;KAMY,YAAA,WAAuB,KAAA,CAAI,MAAA;EACrC,IAAA;EACA,MAAA,EAAQ,CAAC;EACT,QAAA;IACE,OAAA;IACA,WAAA;IACA,IAAA;EAAA;AAAA;AAAA,cAIS,aAAA,YAAa,YAAA,CAAA,KAAA,CAAA,YAAA"}
+{"version":3,"file":"webhooks-8Ts1Clcb.d.ts","names":[],"sources":["../src/interface/webhooks.ts"],"mappings":";;;KAMY,YAAA,WAAuB,KAAA,CAAI,MAAA;EACrC,IAAA;EACA,MAAA,EAAQ,CAAC;EACT,QAAA;IACE,OAAA;IACA,WAAA;IACA,IAAA;EAAA;AAAA;AAAA,cAIS,aAAA,YAAa,YAAA,CAAA,KAAA,CAAA,YAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hexclave/shared",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "repository": "https://github.com/hexclave/hexclave",
   "files": [
     "README.md",