@constructive-io/site-deploy 0.1.0

package/esm/deploy.js

@@ -0,0 +1,262 @@
+/**
+ * The deploy pipeline.
+ *
+ * Everything below the manifest is server-owned: writing the release row fires
+ * the trigger that commits the manifest into the site's own merkle store, so
+ * the commit id this returns *is* the release — history, time travel and
+ * rollback are then pointer moves, not client bookkeeping.
+ *
+ * Ordering is the contract: bytes land before the manifest names them, and the
+ * manifest lands before anything points at it. A failure anywhere leaves the
+ * live site exactly as it was.
+ */
+import { diffCas, errorMessage, throwIfAborted, uploadMissing } from './cas-upload';
+import { buildCreateReleaseMutation, buildProvisionPreviewMutation, buildPublishMutation, buildReleaseQuery, buildSetPreviewMutation, buildUpdateReleaseMutation, deployNames, } from './documents';
+import { buildManifest, hashFile, manifestsEqual } from './manifest';
+import { DeployError } from './types';
+import { walkDirectory } from './walk';
+/** Preview ref names become hostname labels, so they must be one. */
+const PREVIEW_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/;
+/**
+ * Deploy a build as an immutable release.
+ *
+ * Hashes every file, uploads only the bytes the server does not already have,
+ * writes one manifest — and optionally publishes it or points a preview ref at
+ * it.
+ */
+export async function deploySite(options) {
+    const { api, storage = options.api, siteId, databaseId, bucketKey, scope = 'database', publish = false, preview, previewApex, concurrency = 8, batchSize = 100, retries = 2, skipIfUnchanged = false, dryRun = false, signal, onProgress, } = options;
+    const names = { ...deployNames(scope), ...options.names };
+    if (preview !== undefined && !PREVIEW_NAME_PATTERN.test(preview)) {
+        throw new DeployError('INVALID_PREVIEW_NAME', `Preview name must be a lowercase DNS label: "${preview}"`);
+    }
+    // 1. Hash the build. Content addressing means this is also the diff key.
+    const files = [];
+    let index = 0;
+    for await (const file of iterateSource(options.source, options.ignore)) {
+        throwIfAborted(signal);
+        if (options.ignore?.(file.path))
+            continue;
+        const hashed = hashFile(file, options.contentTypes);
+        files.push(hashed);
+        onProgress?.({
+            type: 'hashed',
+            path: hashed.path,
+            hash: hashed.hash,
+            size: hashed.size,
+            index: index++,
+        });
+    }
+    const manifest = buildManifest(files);
+    // 2. The release row is UNIQUE per site, so the first deploy creates it and
+    //    every later one patches it — the caller should not have to know which.
+    const existing = await fetchExistingRelease(api, names, siteId);
+    if (skipIfUnchanged &&
+        existing?.commitId &&
+        existing.storeId &&
+        existing.manifest &&
+        manifestsEqual(existing.manifest, manifest)) {
+        onProgress?.({ type: 'unchanged', commitId: existing.commitId });
+        return {
+            commitId: existing.commitId,
+            storeId: existing.storeId,
+            releaseId: existing.id,
+            manifest,
+            files: manifest.file_count,
+            uploaded: 0,
+            skipped: manifest.file_count,
+            bytesUploaded: 0,
+            published: false,
+            previewUrl: null,
+            unchanged: true,
+        };
+    }
+    // 3. Register the bytes and learn which ones are missing.
+    const uploadOptions = {
+        storage,
+        mutation: names.bulkUploadMutation,
+        bucketKey,
+        batchSize,
+        concurrency,
+        retries,
+        putObject: options.putObject,
+        signal,
+    };
+    const diff = await diffCas(files, uploadOptions);
+    onProgress?.({
+        type: 'diffed',
+        files: manifest.file_count,
+        toUpload: diff.missing.length,
+        skipped: diff.deduplicated.length,
+        bytesToUpload: diff.missing.reduce((sum, entry) => sum + entry.file.size, 0),
+    });
+    if (dryRun) {
+        return {
+            commitId: existing?.commitId ?? '',
+            storeId: existing?.storeId ?? '',
+            releaseId: existing?.id ?? '',
+            manifest,
+            files: manifest.file_count,
+            uploaded: 0,
+            skipped: diff.deduplicated.length,
+            bytesUploaded: 0,
+            published: false,
+            previewUrl: null,
+            unchanged: false,
+        };
+    }
+    // 4. Upload. Any failure here throws, so the manifest is never written over
+    //    bytes that are not there.
+    let done = 0;
+    const uploadResult = await uploadMissing(diff, {
+        ...uploadOptions,
+        onUploaded: (file) => {
+            done += 1;
+            onProgress?.({
+                type: 'uploaded',
+                path: file.path,
+                key: file.key,
+                size: file.size,
+                done,
+                total: diff.missing.length,
+            });
+        },
+    });
+    // 5. Write the manifest — this is the commit.
+    const release = existing
+        ? await updateRelease(api, names, existing.id, manifest)
+        : await createRelease(api, names, siteId, databaseId, manifest);
+    onProgress?.({
+        type: 'manifest',
+        commitId: release.commitId,
+        storeId: release.storeId,
+        created: !existing,
+    });
+    const result = {
+        commitId: release.commitId,
+        storeId: release.storeId,
+        releaseId: release.id,
+        manifest,
+        files: manifest.file_count,
+        uploaded: uploadResult.uploaded,
+        skipped: uploadResult.skipped,
+        bytesUploaded: uploadResult.bytesUploaded,
+        published: false,
+        previewUrl: null,
+        unchanged: false,
+    };
+    // 6. Point things at the commit. Separate steps: a failure here leaves a
+    //    complete, retryable release rather than a half-published site.
+    if (preview !== undefined) {
+        result.previewUrl = await pointPreview(api, names, {
+            siteId,
+            name: preview,
+            commitId: release.commitId,
+            apex: previewApex,
+        });
+        onProgress?.({
+            type: 'preview',
+            name: preview,
+            commitId: release.commitId,
+            url: result.previewUrl,
+        });
+    }
+    if (publish) {
+        await publishCommit(api, names, siteId, release.commitId);
+        result.published = true;
+        onProgress?.({ type: 'published', commitId: release.commitId });
+    }
+    return result;
+}
+/** Move `site.activeCommitId` — the go-live and the rollback are one thing. */
+export async function publishCommit(api, names, siteId, commitId) {
+    try {
+        await api(buildPublishMutation(names), {
+            input: { id: siteId, [names.sitePatchField]: { activeCommitId: commitId } },
+        });
+    }
+    catch (err) {
+        throw new DeployError('PUBLISH_FAILED', `Release ${commitId} was written but publishing it failed: ${errorMessage(err)}`, err);
+    }
+}
+async function* iterateSource(source, ignore) {
+    if (typeof source === 'string') {
+        yield* walkDirectory(source, ignore);
+        return;
+    }
+    if (Symbol.asyncIterator in source) {
+        yield* source;
+        return;
+    }
+    yield* source;
+}
+async function fetchExistingRelease(api, names, siteId) {
+    const data = await api(buildReleaseQuery(names), { siteId });
+    const connection = data[names.releasesQuery];
+    return connection?.nodes?.[0] ?? null;
+}
+async function createRelease(api, names, siteId, databaseId, manifest) {
+    if (!databaseId) {
+        throw new DeployError('MISSING_DATABASE_ID', `Site ${siteId} has no release yet, so databaseId is required to create one`);
+    }
+    const data = await api(buildCreateReleaseMutation(names), {
+        input: {
+            [names.releaseInputField]: { siteId, databaseId, manifest },
+        },
+    });
+    return readWrittenRelease(data, names);
+}
+async function updateRelease(api, names, releaseId, manifest) {
+    const data = await api(buildUpdateReleaseMutation(names), {
+        input: {
+            id: releaseId,
+            [names.releasePatchField]: { manifest },
+        },
+    });
+    return readWrittenRelease(data, names);
+}
+/**
+ * Read back the versioning the trigger stamped on the row.
+ *
+ * A release without a commit is not a release: it cannot be published, rolled
+ * back to, or previewed, so a missing id is a hard failure rather than a
+ * result with empty strings in it.
+ */
+function readWrittenRelease(data, names) {
+    const mutation = (data[names.createRelease] ?? data[names.updateRelease]);
+    const row = mutation?.[names.releasePayloadField];
+    if (!row?.id || !row.commitId || !row.storeId) {
+        throw new DeployError('RELEASE_NOT_VERSIONED', 'Release row came back without a commitId/storeId — the manifest was not committed');
+    }
+    return { id: row.id, commitId: row.commitId, storeId: row.storeId };
+}
+async function pointPreview(api, names, args) {
+    try {
+        // With an apex, provision so the hostname and its route exist (idempotent
+        // and it moves the ref too); without one, just move the ref.
+        if (args.apex) {
+            const data = await api(buildProvisionPreviewMutation(names), {
+                input: {
+                    siteId: args.siteId,
+                    name: args.name,
+                    commitId: args.commitId,
+                    apex: args.apex,
+                },
+            });
+            const payload = data[names.provisionPreview];
+            const hostname = payload?.result?.domain?.hostname;
+            return hostname ? `https://${hostname}` : null;
+        }
+        await api(buildSetPreviewMutation(names), {
+            input: {
+                targetSiteId: args.siteId,
+                targetName: args.name,
+                targetCommitId: args.commitId,
+            },
+        });
+        return null;
+    }
+    catch (err) {
+        throw new DeployError('PREVIEW_FAILED', `Release ${args.commitId} was written but preview "${args.name}" could not be pointed at it: ${errorMessage(err)}`, err);
+    }
+}

package/esm/documents.js

@@ -0,0 +1,137 @@
+/**
+ * GraphQL documents and generated-name derivation.
+ *
+ * Plain strings, no graphql dependency: the same documents work through the
+ * generated SDK, urql, Apollo or a bare fetch. Every field name is generated
+ * per scope — unprefixed at the tenant (`database`) scope, `platform`-prefixed
+ * on the self-hosted lane — so the names are derived in one place here rather
+ * than spelled out at each call site.
+ */
+/** Derive the deploy surface's field names for a scope. */
+export function deployNames(scope = 'database') {
+    const Prefix = scope === 'platform' ? 'Platform' : '';
+    const prefix = scope === 'platform' ? 'platform' : '';
+    const lower = (name) => (prefix ? `${prefix}${name}` : lowerFirst(name));
+    return {
+        bulkUploadMutation: `upload${Prefix}Files`,
+        releasesQuery: `${lower('SiteReleases')}`,
+        createRelease: `create${Prefix}SiteRelease`,
+        releaseInputField: lower('SiteRelease'),
+        updateRelease: `update${Prefix}SiteRelease`,
+        releasePatchField: `${lower('SiteRelease')}Patch`,
+        releasePayloadField: lower('SiteRelease'),
+        updateSite: `update${Prefix}Site`,
+        sitePatchField: `${lower('Site')}Patch`,
+        sitePayloadField: lower('Site'),
+        // Preview procedures are exposed unprefixed; a plane that generates them
+        // per scope can override these two.
+        provisionPreview: 'provisionSitePreview',
+        setPreview: 'setSitePreview',
+    };
+}
+function lowerFirst(value) {
+    return value.charAt(0).toLowerCase() + value.slice(1);
+}
+/** Bulk presigned-upload mutation for one storage plane. */
+export function buildBulkUploadMutation(mutation) {
+    return `
+  mutation BulkUpload($input: ${inputTypeName(mutation)}!) {
+    ${mutation}(input: $input) {
+      files {
+        uploadUrl
+        fileId
+        key
+        deduplicated
+      }
+    }
+  }
+`;
+}
+/** `uploadFiles` → `UploadFileBulkInput`, `uploadPlatformFiles` → … */
+function inputTypeName(mutation) {
+    const capitalized = mutation.charAt(0).toUpperCase() + mutation.slice(1);
+    return `${capitalized.replace(/s$/, '')}BulkInput`;
+}
+/** The site's existing release row, if it has one (the row is UNIQUE per site). */
+export function buildReleaseQuery(names) {
+    return `
+  query SiteRelease($siteId: UUID!) {
+    ${names.releasesQuery}(where: { siteId: { equalTo: $siteId } }, first: 1) {
+      nodes {
+        id
+        commitId
+        storeId
+        manifest
+      }
+    }
+  }
+`;
+}
+export function buildCreateReleaseMutation(names) {
+    return `
+  mutation CreateSiteRelease($input: ${typeName(names.createRelease)}Input!) {
+    ${names.createRelease}(input: $input) {
+      ${names.releasePayloadField} {
+        id
+        commitId
+        storeId
+      }
+    }
+  }
+`;
+}
+export function buildUpdateReleaseMutation(names) {
+    return `
+  mutation UpdateSiteRelease($input: ${typeName(names.updateRelease)}Input!) {
+    ${names.updateRelease}(input: $input) {
+      ${names.releasePayloadField} {
+        id
+        commitId
+        storeId
+      }
+    }
+  }
+`;
+}
+/** Publishing and rollback are the same mutation: move the pointer. */
+export function buildPublishMutation(names) {
+    return `
+  mutation PublishSiteRelease($input: ${typeName(names.updateSite)}Input!) {
+    ${names.updateSite}(input: $input) {
+      ${names.sitePayloadField} {
+        id
+        activeCommitId
+      }
+    }
+  }
+`;
+}
+/** Claims (or reuses) the preview hostname and points the ref at a commit. */
+export function buildProvisionPreviewMutation(names) {
+    return `
+  mutation ProvisionSitePreview($input: ${typeName(names.provisionPreview)}Input!) {
+    ${names.provisionPreview}(input: $input) {
+      result {
+        id
+        previewRef
+        domain {
+          hostname
+        }
+      }
+    }
+  }
+`;
+}
+/** Moves an existing ref without touching routing. */
+export function buildSetPreviewMutation(names) {
+    return `
+  mutation SetSitePreview($input: ${typeName(names.setPreview)}Input!) {
+    ${names.setPreview}(input: $input) {
+      result
+    }
+  }
+`;
+}
+function typeName(field) {
+    return field.charAt(0).toUpperCase() + field.slice(1);
+}

package/esm/index.js

@@ -0,0 +1,25 @@
+/**
+ * `@constructive-io/site-deploy` — deploy a static build as an immutable
+ * Constructive release.
+ *
+ * ```ts
+ * const result = await deploySite({
+ *   api,
+ *   siteId,
+ *   databaseId,
+ *   bucketKey: 'site-docs',
+ *   source: './dist',
+ *   publish: true,
+ * });
+ * ```
+ *
+ * The server owns versioning: writing the manifest commits it into the site's
+ * merkle store, so `result.commitId` is the release id you publish, roll back
+ * to, or point a preview ref at.
+ */
+export { contentTypeFor, DEFAULT_CONTENT_TYPE } from './content-type';
+export { deploySite, publishCommit } from './deploy';
+export { deployNames } from './documents';
+export { buildManifest, CAS_KEY_PATTERN, CAS_PREFIX, casKey, hashBytes, manifestsEqual, normalizePath } from './manifest';
+export { DeployError } from './types';
+export { walkDirectory } from './walk';

package/esm/manifest.js

@@ -0,0 +1,100 @@
+/**
+ * Manifest construction: the site-specific half of a deploy.
+ *
+ * The bytes of a build are content-addressed and say nothing about how the
+ * site is served; the manifest is what turns a bag of hashes into a site, by
+ * mapping each logical path to the hash, content type and size the edge
+ * serves for it.
+ */
+import { sha256 } from '@decryption/hashes/sha2';
+import { bytesToHex } from '@decryption/hashes/utils';
+import { contentTypeFor } from './content-type';
+import { DeployError } from './types';
+/** Prefix every file's bytes are stored under, in the site's own bucket. */
+export const CAS_PREFIX = 'cas/sha256/';
+/** The one legal shape of a CAS key. */
+export const CAS_KEY_PATTERN = /^cas\/sha256\/[0-9a-f]{64}$/;
+/** The content-addressed bucket key holding the bytes with this hash. */
+export function casKey(hash) {
+    return `${CAS_PREFIX}${hash}`;
+}
+/** SHA-256 of some bytes, hex — the CAS address and the served ETag. */
+export function hashBytes(bytes) {
+    return bytesToHex(sha256(bytes));
+}
+/**
+ * Normalize a logical path to the form the gateway looks up.
+ *
+ * Windows separators become `/` and a leading `./` or `/` is dropped, so the
+ * same build deploys identically from any OS. Anything that would escape the
+ * site root or collide with the CAS namespace is a hard error — a silently
+ * dropped file is a silently broken site.
+ */
+export function normalizePath(path) {
+    const normalized = path.replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+/, '');
+    if (!normalized) {
+        throw new DeployError('INVALID_PATH', `Empty logical path (from "${path}")`);
+    }
+    if (normalized.split('/').some((segment) => segment === '..' || segment === '.')) {
+        throw new DeployError('INVALID_PATH', `Logical path must not contain "." or ".." segments: "${path}"`);
+    }
+    if (normalized.startsWith(CAS_PREFIX)) {
+        throw new DeployError('INVALID_PATH', `Logical path must not start with "${CAS_PREFIX}" (that is the byte namespace): "${path}"`);
+    }
+    return normalized;
+}
+/** Hash one file and resolve its content type. */
+export function hashFile(file, contentTypes) {
+    const path = normalizePath(file.path);
+    const hash = hashBytes(file.bytes);
+    return {
+        path,
+        key: casKey(hash),
+        hash,
+        contentType: file.contentType ?? contentTypeFor(path, contentTypes),
+        size: file.bytes.byteLength,
+        bytes: file.bytes,
+    };
+}
+/**
+ * Build the release manifest from hashed files.
+ *
+ * `file_count`/`total_bytes` are derived here rather than trusted from a
+ * caller, so they can never disagree with `files`.
+ */
+export function buildManifest(files) {
+    const entries = {};
+    let totalBytes = 0;
+    let count = 0;
+    for (const file of files) {
+        if (entries[file.path]) {
+            throw new DeployError('INVALID_PATH', `Duplicate logical path: "${file.path}"`);
+        }
+        entries[file.path] = {
+            hash: file.hash,
+            content_type: file.contentType,
+            size: file.size,
+        };
+        totalBytes += file.size;
+        count += 1;
+    }
+    if (count === 0) {
+        throw new DeployError('EMPTY_SOURCE', 'Refusing to release an empty manifest');
+    }
+    return { files: entries, file_count: count, total_bytes: totalBytes };
+}
+/** Whether two manifests would serve byte-identical sites. */
+export function manifestsEqual(a, b) {
+    const aPaths = Object.keys(a.files);
+    const bPaths = Object.keys(b.files);
+    if (aPaths.length !== bPaths.length)
+        return false;
+    return aPaths.every((path) => {
+        const left = a.files[path];
+        const right = b.files[path];
+        return (right !== undefined &&
+            left.hash === right.hash &&
+            left.content_type === right.content_type &&
+            left.size === right.size);
+    });
+}

package/esm/types.js

@@ -0,0 +1,22 @@
+/**
+ * Types for the site deploy pipeline.
+ *
+ * A deploy is bytes plus one manifest: every file's bytes live in the site's
+ * bucket at `cas/sha256/<hash>`, and one `siteRelease` row maps logical paths
+ * to those hashes. Writing that row commits it into the site's own merkle
+ * store, so the returned commit id *is* the release id.
+ */
+/**
+ * A deploy failure. Never swallowed and never partially reported: if this
+ * throws before the manifest write, production is untouched.
+ */
+export class DeployError extends Error {
+    code;
+    cause;
+    constructor(code, message, cause) {
+        super(message);
+        this.name = 'DeployError';
+        this.code = code;
+        this.cause = cause;
+    }
+}

package/esm/walk.js

@@ -0,0 +1,49 @@
+/**
+ * Reading a build off disk.
+ *
+ * Node-only and loaded lazily, so the package stays usable in a browser (a UI
+ * that already holds the built files in memory passes them directly instead of
+ * a directory path).
+ */
+import { DeployError } from './types';
+/**
+ * Yield every file under `dir` with its POSIX path relative to `dir`.
+ *
+ * Dotfiles are included: a static build legitimately ships `.well-known/…`,
+ * and dropping files by a rule the caller cannot see is how a deploy silently
+ * loses a route. Use `ignore` to exclude paths explicitly.
+ */
+export async function* walkDirectory(dir, ignore) {
+    const { readdir, readFile } = await loadFs();
+    const { join, posix } = await loadPath();
+    async function* walk(absolute, prefix) {
+        const entries = await readdir(absolute, { withFileTypes: true });
+        for (const entry of entries) {
+            const logical = prefix ? posix.join(prefix, entry.name) : entry.name;
+            if (ignore?.(logical))
+                continue;
+            const child = join(absolute, entry.name);
+            if (entry.isDirectory()) {
+                yield* walk(child, logical);
+                continue;
+            }
+            // Symlinks to files are followed by readFile; anything that is neither a
+            // file nor a directory (socket, fifo) has no meaning in a static site.
+            if (!entry.isFile() && !entry.isSymbolicLink())
+                continue;
+            yield { path: logical, bytes: new Uint8Array(await readFile(child)) };
+        }
+    }
+    yield* walk(dir, '');
+}
+async function loadFs() {
+    try {
+        return await import('fs/promises');
+    }
+    catch (err) {
+        throw new DeployError('INVALID_PATH', 'Deploying from a directory path requires Node; pass the files directly instead', err);
+    }
+}
+async function loadPath() {
+    return import('path');
+}

package/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * `@constructive-io/site-deploy` — deploy a static build as an immutable
+ * Constructive release.
+ *
+ * ```ts
+ * const result = await deploySite({
+ *   api,
+ *   siteId,
+ *   databaseId,
+ *   bucketKey: 'site-docs',
+ *   source: './dist',
+ *   publish: true,
+ * });
+ * ```
+ *
+ * The server owns versioning: writing the manifest commits it into the site's
+ * merkle store, so `result.commitId` is the release id you publish, roll back
+ * to, or point a preview ref at.
+ */
+export { contentTypeFor, DEFAULT_CONTENT_TYPE } from './content-type';
+export { deploySite, publishCommit } from './deploy';
+export { deployNames } from './documents';
+export type { HashedFile } from './manifest';
+export { buildManifest, CAS_KEY_PATTERN, CAS_PREFIX, casKey, hashBytes, manifestsEqual, normalizePath } from './manifest';
+export type { DeployErrorCode, DeployFile, DeployProgress, DeploySiteOptions, DeploySiteResult, DeploySource, GraphQLExecutor, ManifestEntry, PutObject, ReleaseManifest, SiteDeployNames, } from './types';
+export { DeployError } from './types';
+export { walkDirectory } from './walk';

package/index.js

@@ -0,0 +1,42 @@
+"use strict";
+/**
+ * `@constructive-io/site-deploy` — deploy a static build as an immutable
+ * Constructive release.
+ *
+ * ```ts
+ * const result = await deploySite({
+ *   api,
+ *   siteId,
+ *   databaseId,
+ *   bucketKey: 'site-docs',
+ *   source: './dist',
+ *   publish: true,
+ * });
+ * ```
+ *
+ * The server owns versioning: writing the manifest commits it into the site's
+ * merkle store, so `result.commitId` is the release id you publish, roll back
+ * to, or point a preview ref at.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkDirectory = exports.DeployError = exports.normalizePath = exports.manifestsEqual = exports.hashBytes = exports.casKey = exports.CAS_PREFIX = exports.CAS_KEY_PATTERN = exports.buildManifest = exports.deployNames = exports.publishCommit = exports.deploySite = exports.DEFAULT_CONTENT_TYPE = exports.contentTypeFor = void 0;
+var content_type_1 = require("./content-type");
+Object.defineProperty(exports, "contentTypeFor", { enumerable: true, get: function () { return content_type_1.contentTypeFor; } });
+Object.defineProperty(exports, "DEFAULT_CONTENT_TYPE", { enumerable: true, get: function () { return content_type_1.DEFAULT_CONTENT_TYPE; } });
+var deploy_1 = require("./deploy");
+Object.defineProperty(exports, "deploySite", { enumerable: true, get: function () { return deploy_1.deploySite; } });
+Object.defineProperty(exports, "publishCommit", { enumerable: true, get: function () { return deploy_1.publishCommit; } });
+var documents_1 = require("./documents");
+Object.defineProperty(exports, "deployNames", { enumerable: true, get: function () { return documents_1.deployNames; } });
+var manifest_1 = require("./manifest");
+Object.defineProperty(exports, "buildManifest", { enumerable: true, get: function () { return manifest_1.buildManifest; } });
+Object.defineProperty(exports, "CAS_KEY_PATTERN", { enumerable: true, get: function () { return manifest_1.CAS_KEY_PATTERN; } });
+Object.defineProperty(exports, "CAS_PREFIX", { enumerable: true, get: function () { return manifest_1.CAS_PREFIX; } });
+Object.defineProperty(exports, "casKey", { enumerable: true, get: function () { return manifest_1.casKey; } });
+Object.defineProperty(exports, "hashBytes", { enumerable: true, get: function () { return manifest_1.hashBytes; } });
+Object.defineProperty(exports, "manifestsEqual", { enumerable: true, get: function () { return manifest_1.manifestsEqual; } });
+Object.defineProperty(exports, "normalizePath", { enumerable: true, get: function () { return manifest_1.normalizePath; } });
+var types_1 = require("./types");
+Object.defineProperty(exports, "DeployError", { enumerable: true, get: function () { return types_1.DeployError; } });
+var walk_1 = require("./walk");
+Object.defineProperty(exports, "walkDirectory", { enumerable: true, get: function () { return walk_1.walkDirectory; } });