@sequenceholdings/managed-functions 0.2.0 → 0.3.1

package/dist/sdk-range.d.ts

@@ -0,0 +1,2 @@
+export declare function concreteOrStaleSdkSpec(spec: string | undefined, minimum: string): string | null;
+export declare function sdkConstraintIsOlder(declared: string, minimum: string): boolean;

package/dist/sdk-range.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.concreteOrStaleSdkSpec = concreteOrStaleSdkSpec;
+exports.sdkConstraintIsOlder = sdkConstraintIsOlder;
+function parseSemver(raw) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)$/.exec(raw.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function compare(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        const diff = left[index] - right[index];
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
+function caretCeiling(version) {
+    const [major, minor, patch] = version;
+    if (major > 0)
+        return [major + 1, 0, 0];
+    if (minor > 0)
+        return [major, minor + 1, 0];
+    return [major, minor, patch + 1];
+}
+function openBounds() {
+    return { min: [0, 0, 0], minInclusive: true, max: null, maxInclusive: false };
+}
+function raiseFloor(bounds, version, inclusive) {
+    const diff = compare(version, bounds.min);
+    if (diff > 0 || (diff === 0 && bounds.minInclusive && !inclusive)) {
+        bounds.min = version;
+        bounds.minInclusive = inclusive;
+    }
+}
+function lowerCeiling(bounds, version, inclusive) {
+    if (!bounds.max) {
+        bounds.max = version;
+        bounds.maxInclusive = inclusive;
+        return;
+    }
+    const diff = compare(version, bounds.max);
+    if (diff < 0 || (diff === 0 && bounds.maxInclusive && !inclusive)) {
+        bounds.max = version;
+        bounds.maxInclusive = inclusive;
+    }
+}
+function applyComparator(bounds, token) {
+    const match = /^(>=|<=|>|<|\^|~|=)?v?(\d+\.\d+\.\d+)$/.exec(token);
+    if (!match)
+        return false;
+    const version = parseSemver(match[2]);
+    if (!version)
+        return false;
+    const operator = match[1] ?? '=';
+    if (operator === '=') {
+        raiseFloor(bounds, version, true);
+        lowerCeiling(bounds, version, true);
+    }
+    else if (operator === '>' || operator === '>=') {
+        raiseFloor(bounds, version, operator === '>=');
+    }
+    else if (operator === '<' || operator === '<=') {
+        lowerCeiling(bounds, version, operator === '<=');
+    }
+    else if (operator === '^') {
+        raiseFloor(bounds, version, true);
+        lowerCeiling(bounds, caretCeiling(version), false);
+    }
+    else if (operator === '~') {
+        raiseFloor(bounds, version, true);
+        lowerCeiling(bounds, [version[0], version[1] + 1, 0], false);
+    }
+    else {
+        return false;
+    }
+    return true;
+}
+function clauseBounds(clause) {
+    const hyphen = /^v?(\d+\.\d+\.\d+)\s+-\s+v?(\d+\.\d+\.\d+)$/.exec(clause.trim());
+    if (hyphen) {
+        const low = parseSemver(hyphen[1]);
+        const high = parseSemver(hyphen[2]);
+        if (!low || !high)
+            return null;
+        const bounds = openBounds();
+        raiseFloor(bounds, low, true);
+        lowerCeiling(bounds, high, true);
+        return bounds;
+    }
+    const bounds = openBounds();
+    for (const token of clause.trim().split(/\s+/)) {
+        if (token.length === 0)
+            continue;
+        if (!applyComparator(bounds, token))
+            return null;
+    }
+    return bounds;
+}
+function clauseIsEntirelyOlder(clause, minimum) {
+    const bounds = clauseBounds(clause);
+    if (!bounds)
+        return null;
+    if (!bounds.max)
+        return false;
+    if (compare(bounds.min, bounds.max) > 0)
+        return true;
+    const diff = compare(bounds.max, minimum);
+    if (diff < 0)
+        return true;
+    return diff === 0 && !bounds.maxInclusive;
+}
+function concreteOrStaleSdkSpec(spec, minimum) {
+    if (!spec)
+        return null;
+    const trimmed = spec.trim();
+    if (trimmed === '' || trimmed === '*' || trimmed === 'latest' || trimmed.startsWith('workspace:')) {
+        return null;
+    }
+    const exact = /^=?v?(\d+\.\d+\.\d+)$/.exec(trimmed);
+    if (exact)
+        return exact[1] ?? null;
+    const target = parseSemver(minimum);
+    if (!target)
+        return null;
+    const alternatives = trimmed.split('||').map((part) => part.trim()).filter((part) => part.length > 0);
+    if (alternatives.length === 0)
+        return null;
+    for (const alternative of alternatives) {
+        const older = clauseIsEntirelyOlder(alternative, target);
+        if (older !== true)
+            return null;
+    }
+    return trimmed;
+}
+function sdkConstraintIsOlder(declared, minimum) {
+    if (/^v?\d+\.\d+\.\d+$/.test(declared)) {
+        const installed = parseSemver(declared);
+        const required = parseSemver(minimum);
+        if (!installed || !required)
+            return false;
+        return compare(installed, required) < 0;
+    }
+    return concreteOrStaleSdkSpec(declared, minimum) === declared;
+}

package/dist/storage.d.ts

@@ -6,6 +6,15 @@ export declare function createFunctionStorageClient({ baseUrl, headers, mode, }:
     capabilities: () => Promise<{
         canProvision: boolean;
         uploadMethods: string[];
+        pendingUploads: {
+            perPrincipal: number;
+            perWorkspace: number;
+        };
+        uploadBatchLimit: number;
+        importConcurrency: {
+            default: number;
+            max: number;
+        };
     }>;
     list: (options?: import("@sequenceholdings/storage").StorageListOptions) => Promise<{
         items: {
@@ -369,6 +378,73 @@ export declare function createFunctionStorageClient({ baseUrl, headers, mode, }:
                 versionId: string | null;
                 maxBytes: number;
             }>;
+            startBatch: (items: import("@sequenceholdings/storage").StartStorageUpload[]) => Promise<{
+                items: {
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "pending" | "complete" | "aborted";
+                    versionId: string | null;
+                    maxBytes: number;
+                }[];
+            }>;
+            list: () => Promise<{
+                items: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                }[];
+                limits: {
+                    perPrincipal: number;
+                    perWorkspace: number;
+                };
+            }>;
+            reconcile: (input?: {
+                abortIncomplete?: boolean;
+            }) => Promise<{
+                completed: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+                aborted: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+                pending: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+            }>;
             resume(id: string, source: import("@sequenceholdings/storage").StorageUploadSource, options?: import("@sequenceholdings/storage").StorageTransferOptions & {
                 size?: number;
             }): Promise<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sequenceholdings/managed-functions",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Managed Function context and opt-in cache runtime",
   "license": "UNLICENSED",
   "main": "./dist/index.js",
@@ -48,7 +48,7 @@
     "vitest": "^4.1.11",
     "esbuild": "^0.25.0",
     "tsup": "^8.3.0",
-    "@sequenceholdings/orm": "2.1.1"
+    "@sequenceholdings/orm": "2.3.0"
   },
   "engines": {
     "node": ">=20"