@hiai-gg/docsmint 0.3.3 → 0.3.5

package/dist/storage-quota.d.ts

@@ -0,0 +1,56 @@
+/** Server-only, persistence-agnostic storage quota contract. */
+export type StorageQuotaContext = Readonly<{
+    actorUserId: string;
+    requestId: string;
+    idempotencyKey: string;
+    signal?: AbortSignal;
+}>;
+export type StorageQuotaReservationRequest = StorageQuotaContext & Readonly<{
+    bytes: number;
+}>;
+export type StorageQuotaReservation = Readonly<{
+    status: "reserved" | "already_reserved";
+    reservationId: string;
+    reservedBytes: number;
+    usageBytes: number;
+    limitBytes: number;
+    expiresAt: string;
+}>;
+export type StorageQuotaRejection = Readonly<{
+    status: "rejected";
+    usageBytes: number;
+    limitBytes: number;
+    requestedBytes: number;
+}>;
+export type StorageQuotaCommitRequest = StorageQuotaContext & Readonly<{
+    reservationId: string;
+    actualBytes: number;
+}>;
+export type StorageQuotaReleaseRequest = StorageQuotaContext & Readonly<{
+    reservationId: string;
+}>;
+export type StorageQuotaCommitResult = Readonly<{
+    status: "committed" | "already_committed";
+}>;
+export type StorageQuotaReleaseResult = Readonly<{
+    status: "released" | "already_released" | "not_found";
+}>;
+export type StorageQuotaAdapter = Readonly<{
+    /** Must atomically check usage and create an idempotent reservation. */
+    reserve(request: StorageQuotaReservationRequest): Promise<StorageQuotaReservation | StorageQuotaRejection>;
+    commit(request: StorageQuotaCommitRequest): Promise<StorageQuotaCommitResult>;
+    release(request: StorageQuotaReleaseRequest): Promise<StorageQuotaReleaseResult>;
+}>;
+export type StorageQuotaService = Readonly<{
+    reserve(request: StorageQuotaReservationRequest): Promise<StorageQuotaReservation>;
+    commit(request: StorageQuotaCommitRequest): Promise<StorageQuotaCommitResult>;
+    release(request: StorageQuotaReleaseRequest): Promise<StorageQuotaReleaseResult>;
+}>;
+export declare class StorageQuotaExceededError extends Error {
+    readonly code: "STORAGE_QUOTA_EXCEEDED";
+    readonly usageBytes: number;
+    readonly limitBytes: number;
+    readonly requestedBytes: number;
+    constructor(rejection: StorageQuotaRejection);
+}
+export declare function createStorageQuotaService(adapter: StorageQuotaAdapter): StorageQuotaService;

package/dist/storage-quota.js

@@ -0,0 +1,91 @@
+/** Server-only, persistence-agnostic storage quota contract. */
+export class StorageQuotaExceededError extends Error {
+    code = "STORAGE_QUOTA_EXCEEDED";
+    usageBytes;
+    limitBytes;
+    requestedBytes;
+    constructor(rejection) {
+        super("Storage quota exceeded");
+        this.name = "StorageQuotaExceededError";
+        this.usageBytes = rejection.usageBytes;
+        this.limitBytes = rejection.limitBytes;
+        this.requestedBytes = rejection.requestedBytes;
+    }
+}
+function assertContext(context) {
+    for (const [name, value] of [
+        ["actorUserId", context.actorUserId],
+        ["requestId", context.requestId],
+        ["idempotencyKey", context.idempotencyKey],
+    ]) {
+        if (!value.trim())
+            throw new TypeError(`${name} must not be empty`);
+    }
+    if (context.signal?.aborted) {
+        throw new DOMException("Storage quota operation aborted", "AbortError");
+    }
+}
+function assertPositiveBytes(bytes, name) {
+    if (!Number.isSafeInteger(bytes) || bytes <= 0) {
+        throw new TypeError(`${name} must be a positive safe integer`);
+    }
+}
+function assertNonnegativeBytes(bytes, name) {
+    if (!Number.isSafeInteger(bytes) || bytes < 0) {
+        throw new TypeError(`${name} must be a non-negative safe integer`);
+    }
+}
+function assertReservation(result) {
+    assertReservationId(result.reservationId);
+    assertPositiveBytes(result.reservedBytes, "reservedBytes");
+    assertNonnegativeBytes(result.usageBytes, "usageBytes");
+    assertNonnegativeBytes(result.limitBytes, "limitBytes");
+    if (Number.isNaN(Date.parse(result.expiresAt))) {
+        throw new TypeError("expiresAt must be an ISO-compatible timestamp");
+    }
+}
+function assertRejection(result) {
+    assertNonnegativeBytes(result.usageBytes, "usageBytes");
+    assertNonnegativeBytes(result.limitBytes, "limitBytes");
+    assertPositiveBytes(result.requestedBytes, "requestedBytes");
+}
+function assertReservationId(value) {
+    if (!value.trim())
+        throw new TypeError("reservationId must not be empty");
+}
+export function createStorageQuotaService(adapter) {
+    return Object.freeze({
+        async reserve(request) {
+            assertContext(request);
+            assertPositiveBytes(request.bytes, "bytes");
+            const result = await adapter.reserve(Object.freeze({ ...request }));
+            if (result.status === "rejected") {
+                assertRejection(result);
+                throw new StorageQuotaExceededError(result);
+            }
+            assertReservation(result);
+            return Object.freeze({ ...result });
+        },
+        async commit(request) {
+            assertContext(request);
+            assertReservationId(request.reservationId);
+            assertPositiveBytes(request.actualBytes, "actualBytes");
+            const result = await adapter.commit(Object.freeze({ ...request }));
+            if (result.status !== "committed" && result.status !== "already_committed") {
+                throw new TypeError("Storage quota adapter returned an invalid commit status");
+            }
+            return Object.freeze({ ...result });
+        },
+        async release(request) {
+            assertContext(request);
+            assertReservationId(request.reservationId);
+            const result = await adapter.release(Object.freeze({ ...request }));
+            if (result.status !== "released" &&
+                result.status !== "already_released" &&
+                result.status !== "not_found") {
+                throw new TypeError("Storage quota adapter returned an invalid release status");
+            }
+            return Object.freeze({ ...result });
+        },
+    });
+}

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "@hiai-gg/docsmint",
-  "version": "0.3.3",
+  "version": "0.3.5",
   "type": "module",
   "browser": {
+    "./dist/backend-launcher.js": false,
     "./dist/lifecycle.js": false,
+    "./dist/storage-quota.js": false,
     "./dist/workspace.js": false
   },
   "license": "Apache-2.0",
@@ -61,6 +63,16 @@
       "import": "./dist/workspace.js",
       "types": "./dist/workspace.d.ts"
     },
+    "./backend/launcher": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/backend-launcher.js",
+      "types": "./dist/backend-launcher.d.ts"
+    },
+    "./storage-quota": {
+      "browser": "./dist/server-only-browser-entry.js",
+      "import": "./dist/storage-quota.js",
+      "types": "./dist/storage-quota.d.ts"
+    },
     "./frontend/dashboard": {
       "import": "./dist/frontend/dashboard.js",
       "types": "./dist/frontend/dashboard.d.ts"

package/packages/cli/src/index.ts

@@ -24,7 +24,7 @@ import { registerSearch } from "./commands/search.js";
 import { registerSnapshot } from "./commands/snapshot.js";
 import { registerUpdate } from "./commands/update.js";
 
-const VERSION = "0.3.3";
+const VERSION = "0.3.5";
 
 const program = new Command();
 program

package/packages/mcp-server/src/index.ts

@@ -35,7 +35,7 @@ interface McpToolResult {
 
 const server = new McpServer({
 	name: "hiai-docs",
-	version: "0.3.3",
+	version: "0.3.5",
 });
 
 /**