@hypequery/deployment 0.0.0-canary-20260719200737 → 0.1.0

package/dist/activation.js

@@ -1,611 +0,0 @@
-import { createHash } from 'node:crypto';
-import { constants } from 'node:fs';
-import { lstat, mkdir, mkdtemp, open, readdir, rename, rm, } from 'node:fs/promises';
-import path from 'node:path';
-import { prepareProtocolDeploymentReleaseEnvelope, validateProtocolDeploymentReleaseTarget, } from '@hypequery/protocol';
-const ACTIVATION_FILE = 'activation.json';
-const CLAIMS_DIRECTORY = 'claims';
-// Each predecessor has one filesystem slot for its successor. Renaming a
-// complete record into that slot is the cross-process compare-and-swap.
-const INITIAL_CLAIM = 'initial';
-const TARGET_FILE = 'target.json';
-const MAX_ACTIVATION_BYTES = 4096;
-const MAX_TARGET_BYTES = 1024;
-const IDENTITY_PATTERN = /^[0-9a-f]{64}$/;
-const ACTIVATION_IDENTITY_DOMAIN = 'hypequery:deployment-activation:v1\0';
-const TARGET_IDENTITY_DOMAIN = 'hypequery:deployment-target:v1\0';
-const textDecoder = new TextDecoder('utf-8', { fatal: true });
-export class DeploymentActivationError extends Error {
-    code;
-    constructor(code, message, options = {}) {
-        super(message, options.cause === undefined ? undefined : { cause: options.cause });
-        this.name = 'DeploymentActivationError';
-        this.code = code;
-    }
-}
-function activationError(code, message, cause) {
-    return new DeploymentActivationError(code, message, { cause });
-}
-function errorCode(error) {
-    return typeof error === 'object' && error !== null && 'code' in error
-        ? String(error.code)
-        : undefined;
-}
-function isOperationalFileSystemError(error) {
-    const code = errorCode(error);
-    return code !== undefined && !['EISDIR', 'ELOOP', 'ENOENT', 'ENOTDIR'].includes(code);
-}
-function sha256(domain, value) {
-    return createHash('sha256').update(domain).update(value).digest('hex');
-}
-function targetCanonical(target) {
-    return JSON.stringify({ project: target.project, environment: target.environment });
-}
-function targetsEqual(left, right) {
-    return left.project === right.project && left.environment === right.environment;
-}
-function validateTarget(input, code) {
-    try {
-        return validateProtocolDeploymentReleaseTarget(input);
-    }
-    catch (error) {
-        throw activationError(code, 'Deployment activation target is invalid.', error);
-    }
-}
-function requireIdentity(input, description, code) {
-    if (typeof input !== 'string' || !IDENTITY_PATTERN.test(input)) {
-        throw activationError(code, `${description} must be 64 lowercase hexadecimal characters.`);
-    }
-    return input;
-}
-function requireNullableIdentity(input, description, code) {
-    return input === null ? null : requireIdentity(input, description, code);
-}
-function activationPayloadCanonical(input) {
-    // Every value has already been reduced to a closed primitive shape, so this
-    // fixed construction order is also the canonical byte order persisted below.
-    return JSON.stringify({
-        kind: 'hypequery-deployment-activation',
-        version: 1,
-        target: {
-            project: input.target.project,
-            environment: input.target.environment,
-        },
-        releaseIdentity: input.releaseIdentity,
-        previousRevision: input.previousRevision,
-        previousReleaseIdentity: input.previousReleaseIdentity,
-        activatedAt: input.activatedAt,
-    });
-}
-function activationCanonical(record) {
-    return JSON.stringify({
-        kind: record.kind,
-        version: record.version,
-        revision: record.revision,
-        target: {
-            project: record.target.project,
-            environment: record.target.environment,
-        },
-        releaseIdentity: record.releaseIdentity,
-        previousRevision: record.previousRevision,
-        previousReleaseIdentity: record.previousReleaseIdentity,
-        activatedAt: record.activatedAt,
-    });
-}
-function prepareActivation(input) {
-    const payload = activationPayloadCanonical(input);
-    const revision = sha256(ACTIVATION_IDENTITY_DOMAIN, payload);
-    const record = Object.freeze({
-        kind: 'hypequery-deployment-activation',
-        version: 1,
-        revision,
-        target: input.target,
-        releaseIdentity: input.releaseIdentity,
-        previousRevision: input.previousRevision,
-        previousReleaseIdentity: input.previousReleaseIdentity,
-        activatedAt: input.activatedAt,
-    });
-    const canonical = activationCanonical(record);
-    return Object.freeze({ record, canonical, bytes: Buffer.from(canonical) });
-}
-function requireRecord(input) {
-    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-        throw new Error('Activation record must be an object.');
-    }
-    const value = input;
-    const expected = [
-        'activatedAt',
-        'kind',
-        'previousReleaseIdentity',
-        'previousRevision',
-        'releaseIdentity',
-        'revision',
-        'target',
-        'version',
-    ];
-    if (Object.keys(value).sort().join('\0') !== expected.join('\0')) {
-        throw new Error('Activation record fields are inconsistent.');
-    }
-    return value;
-}
-function prepareValidatedActivation(input) {
-    const value = requireRecord(input);
-    if (value.kind !== 'hypequery-deployment-activation' || value.version !== 1) {
-        throw new Error('Activation record kind or version is invalid.');
-    }
-    const target = validateTarget(value.target, 'HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE');
-    const releaseIdentity = requireIdentity(value.releaseIdentity, 'Stored release identity', 'HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE');
-    const previousRevision = requireNullableIdentity(value.previousRevision, 'Stored previous revision', 'HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE');
-    const previousReleaseIdentity = requireNullableIdentity(value.previousReleaseIdentity, 'Stored previous release identity', 'HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE');
-    if ((previousRevision === null) !== (previousReleaseIdentity === null)) {
-        throw new Error('Activation record predecessor is inconsistent.');
-    }
-    if (typeof value.activatedAt !== 'string') {
-        throw new Error('Activation timestamp is invalid.');
-    }
-    const timestamp = new Date(value.activatedAt);
-    if (!Number.isFinite(timestamp.valueOf()) || timestamp.toISOString() !== value.activatedAt) {
-        throw new Error('Activation timestamp is not a canonical ISO timestamp.');
-    }
-    const prepared = prepareActivation({
-        target,
-        releaseIdentity,
-        previousRevision,
-        previousReleaseIdentity,
-        activatedAt: value.activatedAt,
-    });
-    if (value.revision !== prepared.record.revision) {
-        throw new Error('Activation revision does not match its contents.');
-    }
-    return prepared;
-}
-/** Validate and recompute an immutable deployment activation record. */
-export function validateDeploymentActivationRecord(input) {
-    return prepareValidatedActivation(input).record;
-}
-function validateStoredActivation(input, expectedTarget, expectedPreviousRevision, expectedPreviousReleaseIdentity) {
-    const prepared = prepareValidatedActivation(input);
-    if (!targetsEqual(prepared.record.target, expectedTarget)) {
-        throw new Error('Activation record target is inconsistent.');
-    }
-    if (prepared.record.previousRevision !== expectedPreviousRevision
-        || prepared.record.previousReleaseIdentity !== expectedPreviousReleaseIdentity) {
-        throw new Error('Activation record predecessor is inconsistent.');
-    }
-    return prepared;
-}
-async function pathExists(filePath) {
-    try {
-        await lstat(filePath);
-        return true;
-    }
-    catch (error) {
-        if (errorCode(error) === 'ENOENT')
-            return false;
-        throw error;
-    }
-}
-async function requireRegularDirectory(directory, description) {
-    const stat = await lstat(directory);
-    if (stat.isSymbolicLink() || !stat.isDirectory()) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE', `${description} must be a regular directory: ${directory}`);
-    }
-}
-async function ensureRegularDirectory(directory, description) {
-    let created = false;
-    try {
-        created = await mkdir(directory, { recursive: true, mode: 0o700 }) !== undefined;
-    }
-    catch (error) {
-        if (errorCode(error) !== 'EEXIST')
-            throw error;
-    }
-    await requireRegularDirectory(directory, description);
-    return created;
-}
-async function syncDirectory(directory) {
-    if (process.platform === 'win32')
-        return;
-    const handle = await open(directory, constants.O_RDONLY);
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function writeExclusiveFile(filePath, bytes) {
-    const handle = await open(filePath, 'wx', 0o600);
-    try {
-        let offset = 0;
-        while (offset < bytes.byteLength) {
-            const result = await handle.write(bytes, offset, bytes.byteLength - offset);
-            if (result.bytesWritten < 1)
-                throw new Error('Filesystem write made no progress.');
-            offset += result.bytesWritten;
-        }
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function readRegularFile(filePath, maximumBytes) {
-    const initial = await lstat(filePath);
-    if (initial.isSymbolicLink() || !initial.isFile()
-        || initial.size < 1 || initial.size > maximumBytes) {
-        throw new Error(`Stored entry is not a bounded regular file: ${filePath}`);
-    }
-    const handle = await open(filePath, constants.O_RDONLY | constants.O_NOFOLLOW);
-    try {
-        const stat = await handle.stat();
-        if (!stat.isFile() || stat.size < 1 || stat.size > maximumBytes) {
-            throw new Error(`Stored entry is not a bounded regular file: ${filePath}`);
-        }
-        return await handle.readFile();
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function withStagingDirectory(root, prefix, action) {
-    const staging = await mkdtemp(path.join(root, prefix));
-    let result;
-    let failure;
-    try {
-        result = await action(staging);
-    }
-    catch (error) {
-        failure = { error };
-    }
-    try {
-        await rm(staging, { force: true, recursive: true });
-    }
-    catch (error) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_IO', `Could not clean deployment activation staging directory: ${staging}`, failure ? new AggregateError([failure.error, error]) : error);
-    }
-    if (failure)
-        throw failure.error;
-    return result;
-}
-async function readCanonicalTarget(targetDirectory, expectedTarget) {
-    try {
-        await requireRegularDirectory(targetDirectory, 'Deployment activation target');
-        const entries = (await readdir(targetDirectory)).sort();
-        if (entries.join('\0') !== `${CLAIMS_DIRECTORY}\0${TARGET_FILE}`) {
-            throw new Error('Deployment activation target contains undeclared or missing entries.');
-        }
-        await requireRegularDirectory(path.join(targetDirectory, CLAIMS_DIRECTORY), 'Deployment activation claims');
-        const bytes = await readRegularFile(path.join(targetDirectory, TARGET_FILE), MAX_TARGET_BYTES);
-        let input;
-        try {
-            input = JSON.parse(textDecoder.decode(bytes));
-        }
-        catch (error) {
-            throw new Error('Stored deployment activation target is invalid JSON.', { cause: error });
-        }
-        const target = validateTarget(input, 'HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE');
-        if (!targetsEqual(target, expectedTarget)
-            || !Buffer.from(bytes).equals(Buffer.from(targetCanonical(target)))) {
-            throw new Error('Stored deployment activation target is inconsistent.');
-        }
-    }
-    catch (error) {
-        if (error instanceof DeploymentActivationError)
-            throw error;
-        if (isOperationalFileSystemError(error))
-            throw error;
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE', 'Stored deployment activation target is invalid.', error);
-    }
-}
-async function ensureTargetDirectory(activationsRoot, target) {
-    const canonical = targetCanonical(target);
-    const targetKey = sha256(TARGET_IDENTITY_DOMAIN, canonical);
-    const destination = path.join(activationsRoot, targetKey);
-    if (await pathExists(destination)) {
-        await readCanonicalTarget(destination, target);
-        return destination;
-    }
-    await withStagingDirectory(activationsRoot, '.target-staging-', async (staging) => {
-        await mkdir(path.join(staging, CLAIMS_DIRECTORY), { mode: 0o700 });
-        await writeExclusiveFile(path.join(staging, TARGET_FILE), Buffer.from(canonical));
-        await syncDirectory(path.join(staging, CLAIMS_DIRECTORY));
-        await syncDirectory(staging);
-        try {
-            await rename(staging, destination);
-        }
-        catch (error) {
-            if (!await pathExists(destination))
-                throw error;
-            await readCanonicalTarget(destination, target);
-            return;
-        }
-        await syncDirectory(activationsRoot);
-    });
-    await readCanonicalTarget(destination, target);
-    return destination;
-}
-async function readStoredActivation(claimDirectory, target, previousRevision, previousReleaseIdentity) {
-    await requireRegularDirectory(claimDirectory, 'Deployment activation claim');
-    const entries = await readdir(claimDirectory);
-    if (entries.length !== 1 || entries[0] !== ACTIVATION_FILE) {
-        throw new Error('Deployment activation claim contains undeclared or missing entries.');
-    }
-    const bytes = await readRegularFile(path.join(claimDirectory, ACTIVATION_FILE), MAX_ACTIVATION_BYTES);
-    let input;
-    try {
-        input = JSON.parse(textDecoder.decode(bytes));
-    }
-    catch (error) {
-        throw new Error('Stored deployment activation is invalid JSON.', { cause: error });
-    }
-    const prepared = validateStoredActivation(input, target, previousRevision, previousReleaseIdentity);
-    if (!Buffer.from(bytes).equals(Buffer.from(prepared.bytes))) {
-        throw new Error('Stored deployment activation is not canonical JSON.');
-    }
-    return prepared;
-}
-async function visitHistory(targetDirectory, target, visitor) {
-    try {
-        await readCanonicalTarget(targetDirectory, target);
-        const claimsDirectory = path.join(targetDirectory, CLAIMS_DIRECTORY);
-        const claimNames = (await readdir(claimsDirectory)).sort();
-        for (const name of claimNames) {
-            if (name !== INITIAL_CLAIM && !IDENTITY_PATTERN.test(name)) {
-                throw new Error(`Deployment activation claim name is invalid: ${name}`);
-            }
-        }
-        const remaining = new Set(claimNames);
-        const revisions = new Set();
-        let previousRevision = null;
-        let previousReleaseIdentity = null;
-        // Following predecessor-named claims derives the head without trusting a
-        // mutable pointer. The remaining-set check rejects orphaned branches.
-        for (;;) {
-            const claimName = previousRevision ?? INITIAL_CLAIM;
-            if (!remaining.delete(claimName))
-                break;
-            const prepared = await readStoredActivation(path.join(claimsDirectory, claimName), target, previousRevision, previousReleaseIdentity);
-            if (revisions.has(prepared.record.revision)) {
-                throw new Error('Deployment activation history contains a cycle.');
-            }
-            revisions.add(prepared.record.revision);
-            visitor(prepared.record);
-            previousRevision = prepared.record.revision;
-            previousReleaseIdentity = prepared.record.releaseIdentity;
-        }
-        if (remaining.size > 0) {
-            throw new Error('Deployment activation history contains unreachable claims.');
-        }
-    }
-    catch (error) {
-        if (error instanceof DeploymentActivationError)
-            throw error;
-        if (isOperationalFileSystemError(error))
-            throw error;
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CORRUPT_STATE', 'Stored deployment activation history is invalid.', error);
-    }
-}
-async function resolveHistory(targetDirectory, target) {
-    const history = [];
-    await visitHistory(targetDirectory, target, record => { history.push(record); });
-    return Object.freeze(history);
-}
-async function resolveCurrent(targetDirectory, target) {
-    let current;
-    await visitHistory(targetDirectory, target, record => { current = record; });
-    return current;
-}
-function validateHistoryQuery(input) {
-    if (!Number.isSafeInteger(input?.limit) || input.limit < 1
-        || (input.before !== undefined && !IDENTITY_PATTERN.test(input.before))) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST', 'Deployment activation history query is invalid.');
-    }
-    return Object.freeze({
-        limit: input.limit,
-        ...(input.before === undefined ? {} : { before: input.before }),
-    });
-}
-async function resolveHistoryPage(targetDirectory, target, query) {
-    const retained = [];
-    let beforeFound = query.before === undefined;
-    let beforeReached = false;
-    await visitHistory(targetDirectory, target, record => {
-        if (record.revision === query.before) {
-            beforeFound = true;
-            beforeReached = true;
-            return;
-        }
-        if (beforeReached)
-            return;
-        retained.push(record);
-        if (retained.length > query.limit + 1)
-            retained.shift();
-    });
-    if (!beforeFound) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST', 'Deployment activation history cursor was not found.');
-    }
-    const hasOlder = retained.length > query.limit;
-    if (hasOlder)
-        retained.shift();
-    const activations = Object.freeze(retained);
-    return Object.freeze({
-        activations,
-        nextBefore: hasOlder ? activations[0].revision : null,
-    });
-}
-export function createFileSystemDeploymentActivationRegistry(options) {
-    if (typeof options.directory !== 'string' || options.directory.length < 1) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CONFIGURATION', 'Deployment activation directory is required.');
-    }
-    if (typeof options.releases?.read !== 'function') {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CONFIGURATION', 'A deployment release reader is required.');
-    }
-    const root = path.resolve(options.directory);
-    if (root === path.parse(root).root) {
-        throw activationError('HQ_DEPLOYMENT_ACTIVATION_CONFIGURATION', 'Deployment activation directory cannot be a filesystem root.');
-    }
-    const clock = options.clock ?? (() => new Date());
-    const activations = path.join(root, 'activations');
-    let initializationPromise;
-    async function initializeActivationRoot() {
-        const rootCreated = await ensureRegularDirectory(root, 'Deployment store root');
-        const activationsCreated = await ensureRegularDirectory(activations, 'Deployment activation store');
-        if (activationsCreated)
-            await syncDirectory(root);
-        if (rootCreated)
-            await syncDirectory(path.dirname(root));
-    }
-    async function activationRoot() {
-        const pending = initializationPromise ??= initializeActivationRoot();
-        try {
-            await pending;
-        }
-        catch (error) {
-            if (initializationPromise === pending)
-                initializationPromise = undefined;
-            throw error;
-        }
-        await requireRegularDirectory(root, 'Deployment store root');
-        await requireRegularDirectory(activations, 'Deployment activation store');
-        return activations;
-    }
-    async function history(targetInput) {
-        const target = validateTarget(targetInput, 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        try {
-            const activations = await activationRoot();
-            const key = sha256(TARGET_IDENTITY_DOMAIN, targetCanonical(target));
-            const targetDirectory = path.join(activations, key);
-            if (!await pathExists(targetDirectory))
-                return Object.freeze([]);
-            return await resolveHistory(targetDirectory, target);
-        }
-        catch (error) {
-            if (error instanceof DeploymentActivationError)
-                throw error;
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_IO', 'Could not read deployment activation history.', error);
-        }
-    }
-    async function current(targetInput) {
-        const target = validateTarget(targetInput, 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        try {
-            const key = sha256(TARGET_IDENTITY_DOMAIN, targetCanonical(target));
-            const targetDirectory = path.join(await activationRoot(), key);
-            if (!await pathExists(targetDirectory))
-                return undefined;
-            return await resolveCurrent(targetDirectory, target);
-        }
-        catch (error) {
-            if (error instanceof DeploymentActivationError)
-                throw error;
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_IO', 'Could not read the current deployment activation.', error);
-        }
-    }
-    async function historyPage(targetInput, queryInput) {
-        const target = validateTarget(targetInput, 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        const query = validateHistoryQuery(queryInput);
-        try {
-            const key = sha256(TARGET_IDENTITY_DOMAIN, targetCanonical(target));
-            const targetDirectory = path.join(await activationRoot(), key);
-            if (!await pathExists(targetDirectory)) {
-                return Object.freeze({ activations: Object.freeze([]), nextBefore: null });
-            }
-            return await resolveHistoryPage(targetDirectory, target, query);
-        }
-        catch (error) {
-            if (error instanceof DeploymentActivationError)
-                throw error;
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_IO', 'Could not read deployment activation history.', error);
-        }
-    }
-    async function activate(request) {
-        const target = validateTarget(request.target, 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        const releaseIdentity = requireIdentity(request.releaseIdentity, 'Deployment release identity', 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        const expectedRevision = requireNullableIdentity(request.expectedRevision, 'Expected deployment activation revision', 'HQ_DEPLOYMENT_ACTIVATION_INVALID_REQUEST');
-        let storedRelease;
-        try {
-            storedRelease = await options.releases.read(releaseIdentity);
-        }
-        catch (error) {
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_RELEASE_UNAVAILABLE', `Could not verify deployment release before activation: ${releaseIdentity}`, error);
-        }
-        if (!storedRelease) {
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_RELEASE_NOT_FOUND', `Deployment release is not stored: ${releaseIdentity}`);
-        }
-        let verifiedRelease;
-        try {
-            verifiedRelease = prepareProtocolDeploymentReleaseEnvelope(storedRelease.release);
-        }
-        catch (error) {
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_RELEASE_UNAVAILABLE', `Stored deployment release is invalid: ${releaseIdentity}`, error);
-        }
-        if (storedRelease.releaseIdentity !== releaseIdentity
-            || verifiedRelease.identity !== releaseIdentity) {
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_RELEASE_UNAVAILABLE', `Stored deployment release identity is inconsistent: ${releaseIdentity}`);
-        }
-        if (!targetsEqual(verifiedRelease.release.target, target)) {
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_TARGET_MISMATCH', 'Deployment release target does not match the activation target.');
-        }
-        try {
-            const activations = await activationRoot();
-            const targetDirectory = await ensureTargetDirectory(activations, target);
-            const existing = await resolveCurrent(targetDirectory, target);
-            if (existing?.releaseIdentity === releaseIdentity) {
-                return Object.freeze({ status: 'already-active', activation: existing });
-            }
-            if ((existing?.revision ?? null) !== expectedRevision) {
-                return Object.freeze({ status: 'conflict', current: existing ?? null });
-            }
-            let now;
-            try {
-                now = clock();
-                if (!(now instanceof Date) || !Number.isFinite(now.valueOf()))
-                    throw new Error('Invalid date.');
-            }
-            catch (error) {
-                throw activationError('HQ_DEPLOYMENT_ACTIVATION_CONFIGURATION', 'Deployment activation clock returned an invalid value.', error);
-            }
-            const prepared = prepareActivation({
-                target,
-                releaseIdentity,
-                previousRevision: existing?.revision ?? null,
-                previousReleaseIdentity: existing?.releaseIdentity ?? null,
-                activatedAt: now.toISOString(),
-            });
-            const claimsDirectory = path.join(targetDirectory, CLAIMS_DIRECTORY);
-            const claimName = existing?.revision ?? INITIAL_CLAIM;
-            const destination = path.join(claimsDirectory, claimName);
-            const published = await withStagingDirectory(
-            // Staging lives outside the exact target directory, so interrupted
-            // writers are invisible to history readers until the atomic rename.
-            activations, '.activation-staging-', async (staging) => {
-                await writeExclusiveFile(path.join(staging, ACTIVATION_FILE), prepared.bytes);
-                await syncDirectory(staging);
-                try {
-                    await rename(staging, destination);
-                }
-                catch (error) {
-                    if (!await pathExists(destination))
-                        throw error;
-                    return false;
-                }
-                await syncDirectory(claimsDirectory);
-                return true;
-            });
-            if (published) {
-                return Object.freeze({ status: 'activated', activation: prepared.record });
-            }
-            const resolved = await resolveCurrent(targetDirectory, target);
-            if (resolved?.releaseIdentity === releaseIdentity) {
-                return Object.freeze({ status: 'already-active', activation: resolved });
-            }
-            return Object.freeze({ status: 'conflict', current: resolved ?? null });
-        }
-        catch (error) {
-            if (error instanceof DeploymentActivationError)
-                throw error;
-            throw activationError('HQ_DEPLOYMENT_ACTIVATION_IO', 'Could not update deployment activation state.', error);
-        }
-    }
-    return Object.freeze({ activate, current, history, historyPage });
-}

package/dist/control-plane-adapters.d.ts

@@ -1,7 +0,0 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import type { DeploymentControlPlane } from './control-plane.js';
-export type DeploymentControlPlaneFetchHandler = (request: Request) => Promise<Response>;
-export type DeploymentControlPlaneNodeHandler = (request: IncomingMessage, response: ServerResponse) => Promise<void>;
-export declare function createDeploymentControlPlaneFetchHandler(controlPlane: DeploymentControlPlane): DeploymentControlPlaneFetchHandler;
-export declare function createDeploymentControlPlaneNodeHandler(controlPlane: DeploymentControlPlane): DeploymentControlPlaneNodeHandler;
-//# sourceMappingURL=control-plane-adapters.d.ts.map

package/dist/control-plane-adapters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"control-plane-adapters.d.ts","sourceRoot":"","sources":["../src/control-plane-adapters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EACV,sBAAsB,EAGvB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,kCAAkC,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AACzF,MAAM,MAAM,iCAAiC,GAAG,CAC9C,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,cAAc,KACrB,OAAO,CAAC,IAAI,CAAC,CAAC;AAkHnB,wBAAgB,wCAAwC,CACtD,YAAY,EAAE,sBAAsB,GACnC,kCAAkC,CAkBpC;AAED,wBAAgB,uCAAuC,CACrD,YAAY,EAAE,sBAAsB,GACnC,iCAAiC,CAgCnC"}