@driggsby/deploy 0.0.1 → 0.2.0

package/LICENSE

@@ -0,0 +1,117 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable patent license to make, have made, use,
+offer to sell, sell, import, and otherwise transfer the Work.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without limitation,
+any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or
+FITNESS FOR A PARTICULAR PURPOSE.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law or agreed to in writing, shall any Contributor be liable to You
+for damages, including any direct, indirect, special, incidental, or
+consequential damages arising as a result of this License or out of the use or
+inability to use the Work.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations.
+However, in accepting such obligations, You may act only on Your own behalf and
+on Your sole responsibility.

package/README.md

@@ -1,4 +1,66 @@
 # @driggsby/deploy
 
-This version is a name reservation. The real package arrives with the next
-release, published via npm trusted publishing with provenance.
+The deploy protocol client for [Driggsby](https://driggsby.com) apps — small
+static web apps, each served at its own `driggsby.dev` address, with live
+data through the Driggsby SDK. Driggsby assigns every app's address at
+first deploy: the readable name from `driggsby.json` plus a unique ending,
+like `money-dash-x7k2qf.driggsby.dev`, saved back into `driggsby.json`.
+
+Most people want the full CLI instead:
+
+```bash
+npx driggsby@latest login
+npx driggsby@latest deploy
+```
+
+This package exists for two narrower uses.
+
+## One-command deploys in Node-only sandboxes
+
+In an environment that can't run a browser sign-in but can hold a token in
+`DRIGGSBY_TOKEN`:
+
+```bash
+npx @driggsby/deploy
+```
+
+This reads `driggsby.json` in the current directory, deploys the `serve`
+folder, and makes it live. A first deploy creates the app and saves its
+assigned address back into `driggsby.json` — keep (commit) that updated
+file, because it is the only record of the app's address; a checkout that
+discards it makes the next deploy create a second app at a new address.
+
+## As a library
+
+```ts
+import {
+  collectDeployFiles,
+  deployProjectFiles,
+  readProjectConfig,
+} from "@driggsby/deploy";
+
+const projectDirectory = process.cwd();
+const config = await readProjectConfig(projectDirectory);
+const collected = await collectDeployFiles(config.serveDirectory);
+const { outcome } = await deployProjectFiles(
+  { baseUrl: "https://app.driggsby.com", token },
+  projectDirectory,
+  config.slug,
+  collected,
+  { live: true },
+);
+```
+
+`collectDeployFiles` walks the serve folder (skipping dotfiles, symlinks,
+node_modules, and `driggsby.json`), hashes every file, and enforces the
+deploy limits locally.
+`deployProjectFiles` offers the manifest, creates the app on first deploy
+(persisting the assigned slug into `driggsby.json` before any upload),
+uploads only content Driggsby doesn't already have, and finalizes the
+version.
+
+Zero runtime dependencies; Node.js 18 or newer; macOS, Linux, and Windows.
+
+## License
+
+Apache-2.0

package/bin/driggsby-deploy.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/cli.js";

package/dist/base-url.d.ts

@@ -0,0 +1,3 @@
+export declare const PUBLIC_BASE_URL = "https://app.driggsby.com";
+export declare function isLoopbackBaseUrl(baseUrl: string): boolean;
+export declare function resolveBaseUrl(env: NodeJS.ProcessEnv): string;

package/dist/base-url.js

@@ -0,0 +1,46 @@
+// The single home of the base-URL policy: which origin API requests (and
+// the bearer token they carry) may travel to, and what DRIGGSBY_BASE_URL is
+// allowed to override it with. The driggsby CLI wraps these exports rather
+// than restating them — two copies of this policy would let an edit to one
+// silently change where a credential may travel under the other.
+import { DeployError } from "./errors.js";
+export const PUBLIC_BASE_URL = "https://app.driggsby.com";
+function isLoopbackHostname(hostname) {
+    return hostname === "localhost" || hostname === "127.0.0.1";
+}
+// Whether this base URL points at this machine. Plain http — and, in the
+// driggsby CLI, the machine's saved sign-in — is acceptable only here (or at
+// Driggsby itself). The input must already be a parseable URL.
+export function isLoopbackBaseUrl(baseUrl) {
+    return isLoopbackHostname(new URL(baseUrl).hostname);
+}
+// Resolves the API origin from the environment. The token travels only over
+// https, or plain http to a local dev server on this machine.
+export function resolveBaseUrl(env) {
+    const raw = env.DRIGGSBY_BASE_URL?.trim();
+    if (raw === undefined || raw === "") {
+        return PUBLIC_BASE_URL;
+    }
+    const trimmed = raw.replace(/\/+$/, "");
+    let parsed;
+    try {
+        // Validate eagerly so a broken override fails with one clear message
+        // instead of a confusing fetch error later.
+        parsed = new URL(trimmed);
+    }
+    catch {
+        throw new DeployError(`DRIGGSBY_BASE_URL is set but is not a valid URL. Unset it to use\n${PUBLIC_BASE_URL}.`);
+    }
+    if (parsed.protocol !== "https:" &&
+        !(parsed.protocol === "http:" && isLoopbackHostname(parsed.hostname))) {
+        throw new DeployError(`DRIGGSBY_BASE_URL must be an https URL (or http on localhost). Unset it\nto use ${PUBLIC_BASE_URL}.`);
+    }
+    // API paths are appended to this value directly, so a query or fragment
+    // would end up in the middle of every request path. Checked on the raw
+    // string, not URL.search/.hash — a bare trailing "?" or "#" parses to an
+    // empty search/hash yet still corrupts every appended path.
+    if (trimmed.includes("?") || trimmed.includes("#")) {
+        throw new DeployError(`DRIGGSBY_BASE_URL can't include a query or fragment. Unset it to use\n${PUBLIC_BASE_URL}.`);
+    }
+    return trimmed;
+}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,16 @@
+// Side-effect entry for bin/driggsby-deploy.js. Kept separate from
+// entrypoint.ts so tests exercise runDeployEntrypoint without triggering a
+// real deploy on import.
+import process from "node:process";
+import { runDeployEntrypoint } from "./entrypoint.js";
+process.exitCode = await runDeployEntrypoint({
+    argv: process.argv.slice(2),
+    cwd: process.cwd(),
+    env: process.env,
+    out: (text) => {
+        process.stdout.write(text);
+    },
+    error: (text) => {
+        process.stderr.write(text);
+    },
+});

package/dist/client.d.ts

@@ -0,0 +1,52 @@
+export interface DeployApi {
+    baseUrl: string;
+    token: string;
+    requestTimeoutMs?: number;
+}
+export interface ManifestFile {
+    path: string;
+    sha256: string;
+    byteSize: number;
+}
+export interface CreatedVersion {
+    versionId: string;
+    versionNumber: number;
+    appSlug: string;
+    missingBlobSha256s: string[];
+}
+export interface FinalizedVersion {
+    kind: "finalized";
+    appSlug: string;
+    versionNumber: number;
+    live: boolean;
+    url: string | null;
+}
+export interface BlobsMissing {
+    kind: "blobs-missing";
+    missingBlobSha256s: string[];
+}
+export interface VersionSummary {
+    versionId: string;
+    number: number;
+    status: "uploading" | "ready";
+    live: boolean;
+    fileCount: number;
+    totalBytes: number;
+    createdAt: string;
+}
+export interface VersionList {
+    appSlug: string;
+    url: string;
+    liveVersionNumber: number | null;
+    versions: VersionSummary[];
+}
+export interface CreatedApp {
+    appSlug: string;
+    url: string;
+}
+export declare function createApp(api: DeployApi, baseName: string, appName?: string): Promise<CreatedApp>;
+export declare function createVersion(api: DeployApi, slug: string, files: ManifestFile[], appName?: string): Promise<CreatedVersion>;
+export declare function uploadBlob(api: DeployApi, sha256: string, bytes: Uint8Array, signal?: AbortSignal): Promise<void>;
+export declare function finalizeVersion(api: DeployApi, versionId: string, live: boolean): Promise<FinalizedVersion | BlobsMissing>;
+export declare function listVersions(api: DeployApi, slug: string): Promise<VersionList>;
+export declare function setLiveVersion(api: DeployApi, slug: string, versionNumber: number): Promise<FinalizedVersion>;

package/dist/client.js

@@ -0,0 +1,292 @@
+// The deploy API protocol client: one function per endpoint, exact request
+// shapes, fail-closed response parsing. Every request carries the app token,
+// so redirects are always refused — the token goes to the configured API
+// origin and nowhere else.
+import { DeployApiError, DeployError } from "./errors.js";
+import { slugProblem } from "./limits.js";
+const JSON_REQUEST_TIMEOUT_MS = 30_000;
+// Blob uploads carry up to 25 MB, which legitimately takes minutes on a
+// slow link; the timeout exists so a stalled connection fails with a clear
+// signal instead of hanging indefinitely.
+const BLOB_UPLOAD_TIMEOUT_MS = 300_000;
+// Every endpoint answers with a small JSON object; anything enormous is not
+// a real Driggsby response. The cap bounds what gets parsed and surfaced,
+// not what the network buffers — the request timeout bounds that. Same
+// treatment as the CLI's sign-in client.
+const MAX_RESPONSE_BODY_CHARS = 1_000_000;
+const UNEXPECTED_RESPONSE_MESSAGE = "The Driggsby deploy API sent a response we didn't recognize. Please try\n" +
+    "again in a minute.";
+// Creates the app itself. The server assigns the final slug — the readable
+// base name passed here plus a unique ending — and every later deploy
+// targets that assigned slug, so callers must persist it (in driggsby.json)
+// before uploading anything. The request field is base_name, not slug: the
+// two are different values on the two sides of this round trip, and the API
+// keeps them visibly distinct.
+export async function createApp(api, baseName, appName) {
+    const body = { base_name: baseName };
+    if (appName !== undefined) {
+        body.app_name = appName;
+    }
+    const parsed = await requestJson(api, "POST", "/deploy/apps", {
+        json: body,
+        expectedStatus: 201,
+    });
+    const appSlug = stringField(parsed, "app_slug");
+    // The assigned slug gets written into driggsby.json and reused as a URL
+    // path segment, so it is shape-validated like every other server field —
+    // a malformed answer must fail here, never land on disk.
+    if (slugProblem(appSlug) !== null) {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    return { appSlug, url: stringField(parsed, "url") };
+}
+// app_name here is NOT a leftover of the old create-by-deploy flow: the
+// server intentionally keeps rename-on-redeploy, applying a sent app_name
+// to the existing app once the deploy is accepted.
+export async function createVersion(api, slug, files, appName) {
+    const body = {
+        files: files.map((file) => ({ path: file.path, sha256: file.sha256, byte_size: file.byteSize })),
+    };
+    if (appName !== undefined) {
+        body.app_name = appName;
+    }
+    const parsed = await requestJson(api, "POST", `/deploy/apps/${encodeURIComponent(slug)}/versions`, {
+        json: body,
+        expectedStatus: 201,
+    });
+    const versionId = stringField(parsed, "version_id");
+    const versionNumber = integerField(parsed, "version_number");
+    const appSlug = stringField(parsed, "app_slug");
+    const missing = stringArrayField(parsed, "missing_blob_sha256s");
+    return { versionId, versionNumber, appSlug, missingBlobSha256s: missing };
+}
+export async function uploadBlob(api, sha256, bytes, signal) {
+    const path = `/deploy/blobs/${encodeURIComponent(sha256)}`;
+    if (signal === undefined) {
+        await requestJson(api, "PUT", path, { rawBody: bytes, expectedStatus: 200 });
+        return;
+    }
+    // The caller's signal (the upload pool's) outlives this one request, so
+    // the forwarding listener is detached once the request settles —
+    // otherwise every upload in a large deploy would leave one listener
+    // behind on the shared signal for the rest of the round.
+    const scoped = new AbortController();
+    const forward = () => {
+        scoped.abort(signal.reason);
+    };
+    if (signal.aborted) {
+        forward();
+    }
+    else {
+        signal.addEventListener("abort", forward, { once: true });
+    }
+    try {
+        await requestJson(api, "PUT", path, {
+            rawBody: bytes,
+            expectedStatus: 200,
+            signal: scoped.signal,
+        });
+    }
+    finally {
+        signal.removeEventListener("abort", forward);
+    }
+}
+export async function finalizeVersion(api, versionId, live) {
+    const response = await rawRequest(api, "POST", `/deploy/versions/${encodeURIComponent(versionId)}/finalize`, {
+        json: live ? {} : { live: false },
+    });
+    if (response.status === 409) {
+        const parsed = await parseJsonBody(response);
+        if (typeof parsed === "object" && parsed !== null && errorCode(parsed) === "blobs_missing") {
+            return {
+                kind: "blobs-missing",
+                missingBlobSha256s: stringArrayField(parsed, "missing_blob_sha256s"),
+            };
+        }
+        throw apiErrorFrom(response, parsed);
+    }
+    const parsed = await expectStatus(response, 200);
+    return parseFinalized(parsed);
+}
+export async function listVersions(api, slug) {
+    const parsed = await requestJson(api, "GET", `/deploy/apps/${encodeURIComponent(slug)}/versions`, {
+        expectedStatus: 200,
+    });
+    const rawVersions = parsed.versions;
+    if (!Array.isArray(rawVersions)) {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    const liveVersionNumber = parsed.live_version_number;
+    return {
+        appSlug: stringField(parsed, "app_slug"),
+        url: stringField(parsed, "url"),
+        liveVersionNumber: typeof liveVersionNumber === "number" && Number.isSafeInteger(liveVersionNumber)
+            ? liveVersionNumber
+            : null,
+        versions: rawVersions.map((raw) => {
+            if (typeof raw !== "object" || raw === null) {
+                throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+            }
+            const record = raw;
+            const status = record.status;
+            if (status !== "uploading" && status !== "ready") {
+                throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+            }
+            return {
+                versionId: stringField(record, "version_id"),
+                number: integerField(record, "number"),
+                status,
+                live: record.live === true,
+                fileCount: integerField(record, "file_count"),
+                totalBytes: integerField(record, "total_bytes"),
+                createdAt: stringField(record, "created_at"),
+            };
+        }),
+    };
+}
+export async function setLiveVersion(api, slug, versionNumber) {
+    const parsed = await requestJson(api, "POST", `/deploy/apps/${encodeURIComponent(slug)}/live-version`, {
+        json: { version_number: versionNumber },
+        expectedStatus: 200,
+    });
+    return parseFinalized(parsed);
+}
+async function requestJson(api, method, path, options) {
+    const response = await rawRequest(api, method, path, options);
+    return expectStatus(response, options.expectedStatus ?? 200);
+}
+async function rawRequest(api, method, path, options) {
+    const headers = { authorization: `Bearer ${api.token}` };
+    let body;
+    if (options.json !== undefined) {
+        headers["content-type"] = "application/json";
+        body = JSON.stringify(options.json);
+    }
+    else if (options.rawBody !== undefined) {
+        headers["content-type"] = "application/octet-stream";
+        body = options.rawBody;
+    }
+    const timeoutMs = api.requestTimeoutMs ??
+        (options.rawBody === undefined ? JSON_REQUEST_TIMEOUT_MS : BLOB_UPLOAD_TIMEOUT_MS);
+    const timeoutSignal = AbortSignal.timeout(timeoutMs);
+    return fetch(`${api.baseUrl}${path}`, {
+        method,
+        headers,
+        ...(body === undefined ? {} : { body }),
+        // The bearer token must never travel to a redirect target.
+        redirect: "error",
+        // A stalled connection fails as a TimeoutError instead of hanging; the
+        // caller's own signal (if any) can also cancel the request early.
+        signal: options.signal === undefined ? timeoutSignal : anyAbortSignal(options.signal, timeoutSignal),
+    });
+}
+// AbortSignal.any needs Node 20.3+, and these packages support Node 18, so
+// combine the two signals by hand. Each combined signal lives for one
+// request; the reasons are forwarded so a timeout still reads as a
+// TimeoutError.
+function anyAbortSignal(first, second) {
+    const controller = new AbortController();
+    for (const signal of [first, second]) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            break;
+        }
+        signal.addEventListener("abort", () => {
+            controller.abort(signal.reason);
+        }, { once: true, signal: controller.signal });
+    }
+    return controller.signal;
+}
+async function expectStatus(response, expected) {
+    const parsed = await parseJsonBody(response);
+    if (response.status !== expected) {
+        throw apiErrorFrom(response, parsed);
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    return parsed;
+}
+async function parseJsonBody(response) {
+    let text;
+    try {
+        text = await response.text();
+    }
+    catch (error) {
+        // A body that never finishes arriving surfaces here as the request
+        // signal's TimeoutError. That is a stalled connection, not a malformed
+        // body, so it must propagate to the network-failure guidance instead of
+        // reading as an unrecognized response.
+        const name = error.name;
+        if (name === "TimeoutError" || name === "AbortError") {
+            throw error;
+        }
+        return null;
+    }
+    if (text.length > MAX_RESPONSE_BODY_CHARS) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function apiErrorFrom(response, parsed) {
+    const retryAfterSeconds = parseRetryAfterSeconds(response.headers.get("retry-after"));
+    if (typeof parsed === "object" && parsed !== null) {
+        const code = errorCode(parsed);
+        const description = parsed.error_description;
+        if (code !== null) {
+            return new DeployApiError(response.status, code, typeof description === "string" ? description : "", retryAfterSeconds);
+        }
+    }
+    return new DeployApiError(response.status, "unexpected_response", UNEXPECTED_RESPONSE_MESSAGE, retryAfterSeconds);
+}
+// Only the whole-seconds Retry-After form is honored; the HTTP-date form (or
+// anything malformed) reads as "no header" and the caller uses its default.
+function parseRetryAfterSeconds(header) {
+    if (header === null || !/^[0-9]+$/.test(header.trim())) {
+        return null;
+    }
+    return Number.parseInt(header.trim(), 10);
+}
+function errorCode(parsed) {
+    const code = parsed.error;
+    return typeof code === "string" ? code : null;
+}
+function parseFinalized(parsed) {
+    return {
+        kind: "finalized",
+        appSlug: stringField(parsed, "app_slug"),
+        versionNumber: integerField(parsed, "version_number"),
+        live: parsed.live === true,
+        url: typeof parsed.url === "string" ? parsed.url : null,
+    };
+}
+function stringField(record, field) {
+    const value = record[field];
+    if (typeof value !== "string") {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    return value;
+}
+// Every numeric field in the protocol is a count or a version number, so
+// anything that isn't a plain exact integer is a malformed response — and
+// rejecting it here keeps values like 1.79e308 from ever reaching a
+// rendered table.
+function integerField(record, field) {
+    const value = record[field];
+    if (typeof value !== "number" || !Number.isSafeInteger(value)) {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    return value;
+}
+function stringArrayField(record, field) {
+    const value = record[field];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+        throw new DeployError(UNEXPECTED_RESPONSE_MESSAGE);
+    }
+    return value;
+}

package/dist/deploy.d.ts

@@ -0,0 +1,28 @@
+import { type CreatedApp, type DeployApi } from "./client.ts";
+import { DeployApiError } from "./errors.ts";
+import { type CollectedDeploy } from "./manifest.ts";
+export interface DeployOptions {
+    live: boolean;
+    appName?: string;
+}
+export interface DeployOutcome {
+    appSlug: string;
+    versionNumber: number;
+    live: boolean;
+    url: string | null;
+    fileCount: number;
+    uploadedBlobCount: number;
+    uploadedBytes: number;
+    unchangedFileCount: number;
+}
+export interface ProjectDeployOptions extends DeployOptions {
+    onAppCreated?: (created: CreatedApp) => void;
+}
+export interface ProjectDeployResult {
+    outcome: DeployOutcome;
+    createdApp: CreatedApp | null;
+}
+export declare function deployProjectFiles(api: DeployApi, projectDirectory: string, slug: string, collected: CollectedDeploy, options: ProjectDeployOptions): Promise<ProjectDeployResult>;
+export declare function deployCollectedFiles(api: DeployApi, slug: string, collected: CollectedDeploy, options: DeployOptions): Promise<DeployOutcome>;
+export declare function retryDelayMs(error: DeployApiError): number;
+export declare function runWithConcurrencyLimit<Item, Result>(items: readonly Item[], limit: number, worker: (item: Item, signal: AbortSignal) => Promise<Result>): Promise<Result[]>;