agl 1.0.17 → 21.0.2

package/dist_ts/classes.controllermanagement.d.ts

@@ -0,0 +1,32 @@
+import { type IControllerStatus, type IReq_ControllerUpgradeLaunch, type IReq_ControllerUpgradePrepareBegin, type IReq_ControllerUpgradeFinalize } from '../dist_ts_interfaces/index.js';
+export interface IControllerStatusExpectation {
+    packageName: string;
+    packageVersion: string;
+    protocolVersion?: number;
+    upgradeManagementVersion: number;
+}
+export declare const controllerUpgradePrepareBeginRequestTimeoutMs = 30000;
+export declare const assertControllerStatus: (statusArg: unknown, expectationArg: IControllerStatusExpectation) => IControllerStatus;
+export declare const requestControllerUpgradePrepareBegin: (portArg: number, tokenArg: string, targetVersionArg: string, gracePeriodMsArg: number) => Promise<IReq_ControllerUpgradePrepareBegin["response"]>;
+export declare const requestControllerUpgradeFinalize: (portArg: number, tokenArg: string, modeArg: IReq_ControllerUpgradeFinalize["request"]["mode"], timeoutMsArg?: number) => Promise<IReq_ControllerUpgradeFinalize["response"]>;
+export declare const queryControllerStatus: (portArg: number, expectationArg: IControllerStatusExpectation, timeoutMsArg?: number) => Promise<IControllerStatus>;
+export declare const tryQueryControllerStatus: (portArg: number, expectationArg: IControllerStatusExpectation) => Promise<IControllerStatus | undefined>;
+export declare const isLoopbackPortListening: (portArg: number, timeoutMsArg?: number) => Promise<boolean>;
+export declare const requestControllerUpgradeLaunch: (portArg: number, tokenArg: string, timeoutMsArg?: number) => Promise<IReq_ControllerUpgradeLaunch["response"]>;
+export declare const waitUntilControllerExited: (optionsArg: {
+    pid: number;
+    cliPath: string;
+    port: number;
+    expectedProcessGroupId: number;
+    expectedFingerprint: string;
+    command: "__serve" | "foreground";
+}, timeoutMsArg: number) => Promise<boolean>;
+export declare const resolveControllerStopSignal: (statusArg: IControllerStatus, phaseArg: "cooperative" | "hard") => {
+    signal: NodeJS.Signals;
+    signalProcessGroup: boolean;
+};
+export declare const stopVerifiedController: (optionsArg: {
+    status: IControllerStatus;
+    cliPath: string;
+    port: number;
+}) => Promise<void>;

package/dist_ts/classes.controllermanagement.js

@@ -0,0 +1,222 @@
+import * as plugins from './plugins.js';
+import { controllerPackageName, } from '../dist_ts_interfaces/index.js';
+import { inspectControllerProcess, signalVerifiedControllerProcess, } from './classes.processinspection.js';
+const currentCliName = String(controllerPackageName) === 'agl' ? 'agl' : 'hcon';
+const currentRuntimeName = currentCliName === 'agl' ? 'AGL' : currentCliName;
+const harnessStates = ['starting', 'ready', 'stopping', 'stopped', 'failed'];
+export const controllerUpgradePrepareBeginRequestTimeoutMs = 30_000;
+const isControllerHarnessStatus = (statusArg) => {
+    if (typeof statusArg !== 'object' || statusArg === null)
+        return false;
+    const status = statusArg;
+    return ((status.harnessId === 'opencode' || status.harnessId === 'flex')
+        && harnessStates.some((stateArg) => status.state === stateArg)
+        && typeof status.healthy === 'boolean'
+        && (status.pid === undefined || Number.isSafeInteger(status.pid))
+        && (status.version === undefined || typeof status.version === 'string'));
+};
+const isControllerUpgradeStatus = (statusArg) => {
+    if (!statusArg || typeof statusArg !== 'object' || Array.isArray(statusArg))
+        return false;
+    const status = statusArg;
+    return Object.keys(status).length === 3
+        && typeof status.fromVersion === 'string'
+        && status.fromVersion.length > 0
+        && Buffer.byteLength(status.fromVersion, 'utf8') <= 128
+        && typeof status.toVersion === 'string'
+        && status.toVersion.length > 0
+        && Buffer.byteLength(status.toVersion, 'utf8') <= 128
+        && typeof status.phase === 'string'
+        && ['preparing', 'pausing', 'installing', 'restarting', 'continuing', 'completed', 'failed']
+            .includes(status.phase);
+};
+export const assertControllerStatus = (statusArg, expectationArg) => {
+    if (typeof statusArg !== 'object' || statusArg === null) {
+        throw new Error(`The service on the management port is not an ${currentRuntimeName} endpoint.`);
+    }
+    const status = statusArg;
+    const harnesses = Array.isArray(status.harnesses) ? status.harnesses : [];
+    const openCode = harnesses.find((entryArg) => entryArg?.harnessId === 'opencode');
+    const flex = harnesses.find((entryArg) => entryArg?.harnessId === 'flex');
+    if (status.packageName !== expectationArg.packageName
+        || status.packageVersion !== expectationArg.packageVersion
+        || (expectationArg.protocolVersion !== undefined
+            && status.protocolVersion !== expectationArg.protocolVersion)
+        || status.upgradeManagementVersion !== expectationArg.upgradeManagementVersion
+        || !Number.isSafeInteger(status.controllerPid)
+        || !Number.isSafeInteger(status.processGroupId)
+        || typeof status.processFingerprint !== 'string'
+        || status.processFingerprint.length < 8
+        || status.processFingerprint.length > 256
+        || (status.processMode !== 'detached' && status.processMode !== 'foreground')
+        || (status.lifecycleState !== 'starting'
+            && status.lifecycleState !== 'ready'
+            && status.lifecycleState !== 'stopping'
+            && status.lifecycleState !== 'stopped')
+        || typeof status.startedAt !== 'number'
+        || typeof status.setupRequired !== 'boolean'
+        || (status.upgrade !== undefined && !isControllerUpgradeStatus(status.upgrade))
+        || harnesses.length !== 2
+        || !openCode
+        || !flex
+        || !harnesses.every((entryArg) => isControllerHarnessStatus(entryArg))) {
+        throw new Error('The service on the management port has an incompatible controller identity.');
+    }
+    return status;
+};
+export const requestControllerUpgradePrepareBegin = async (portArg, tokenArg, targetVersionArg, gracePeriodMsArg) => {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), controllerUpgradePrepareBeginRequestTimeoutMs);
+    let socket;
+    try {
+        socket = await plugins.typedsocket.TypedSocket.createClient(new plugins.typedrequest.TypedRouter(), `http://127.0.0.1:${portArg}`, {
+            autoReconnect: false,
+            maxRetries: 0,
+            abortSignal: abortController.signal,
+        });
+        const response = await socket.createTypedRequest('controller.upgrade.prepare.begin', undefined, {
+            timeoutMs: controllerUpgradePrepareBeginRequestTimeoutMs,
+            abortSignal: abortController.signal,
+        }).fire({ token: tokenArg, targetVersion: targetVersionArg, gracePeriodMs: gracePeriodMsArg });
+        if (!response
+            || typeof response !== 'object'
+            || Array.isArray(response)
+            || Object.keys(response).length !== 1
+            || response.accepted !== true)
+            throw new Error('The controller returned an invalid upgrade preparation response.');
+        return response;
+    }
+    finally {
+        clearTimeout(timeout);
+        await socket?.stop();
+    }
+};
+export const requestControllerUpgradeFinalize = async (portArg, tokenArg, modeArg, timeoutMsArg = 60_000) => {
+    const socket = await plugins.typedsocket.TypedSocket.createClient(new plugins.typedrequest.TypedRouter(), `http://127.0.0.1:${portArg}`, { autoReconnect: false, maxRetries: 0 });
+    try {
+        return await socket.createTypedRequest('controller.upgrade.finalize', undefined, { timeoutMs: timeoutMsArg }).fire({ token: tokenArg, mode: modeArg });
+    }
+    finally {
+        await socket.stop();
+    }
+};
+export const queryControllerStatus = async (portArg, expectationArg, timeoutMsArg = 2_500) => {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), timeoutMsArg);
+    let socket;
+    try {
+        const router = new plugins.typedrequest.TypedRouter();
+        socket = await plugins.typedsocket.TypedSocket.createClient(router, `http://127.0.0.1:${portArg}`, {
+            autoReconnect: false,
+            maxRetries: 0,
+            abortSignal: abortController.signal,
+        });
+        const request = socket.createTypedRequest('controller.status', undefined, { timeoutMs: timeoutMsArg, abortSignal: abortController.signal });
+        return assertControllerStatus(await request.fire({}), expectationArg);
+    }
+    finally {
+        clearTimeout(timeout);
+        await socket?.stop();
+    }
+};
+export const tryQueryControllerStatus = async (portArg, expectationArg) => {
+    try {
+        return await queryControllerStatus(portArg, expectationArg);
+    }
+    catch {
+        return undefined;
+    }
+};
+export const isLoopbackPortListening = async (portArg, timeoutMsArg = 500) => {
+    return await new Promise((resolve) => {
+        const socket = plugins.net.createConnection({ host: '127.0.0.1', port: portArg });
+        let settled = false;
+        const finish = (resultArg) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            socket.destroy();
+            resolve(resultArg);
+        };
+        const timeout = setTimeout(() => finish(false), timeoutMsArg);
+        socket.once('connect', () => finish(true));
+        socket.once('error', () => finish(false));
+    });
+};
+export const requestControllerUpgradeLaunch = async (portArg, tokenArg, timeoutMsArg = 15_000) => {
+    const abortController = new AbortController();
+    const timeout = setTimeout(() => abortController.abort(), timeoutMsArg);
+    let socket;
+    try {
+        const router = new plugins.typedrequest.TypedRouter();
+        socket = await plugins.typedsocket.TypedSocket.createClient(router, `http://127.0.0.1:${portArg}`, {
+            autoReconnect: false,
+            maxRetries: 0,
+            abortSignal: abortController.signal,
+        });
+        const response = await socket.createTypedRequest('controller.upgrade.launch', undefined, { timeoutMs: timeoutMsArg, abortSignal: abortController.signal }).fire({ token: tokenArg });
+        if (!response
+            || typeof response !== 'object'
+            || response.accepted !== true
+            || !Number.isSafeInteger(response.workerPid)
+            || response.workerPid < 2
+            || typeof response.logFilePath !== 'string'
+            || !plugins.path.isAbsolute(response.logFilePath)) {
+            throw new Error(`The controller returned an invalid ${currentCliName} upgrade launch response.`);
+        }
+        return response;
+    }
+    finally {
+        clearTimeout(timeout);
+        await socket?.stop();
+    }
+};
+export const waitUntilControllerExited = async (optionsArg, timeoutMsArg) => {
+    const deadline = Date.now() + timeoutMsArg;
+    while (Date.now() < deadline) {
+        if (!await inspectControllerProcess(optionsArg))
+            return true;
+        await new Promise((resolve) => setTimeout(resolve, 150));
+    }
+    return !await inspectControllerProcess(optionsArg);
+};
+export const resolveControllerStopSignal = (statusArg, phaseArg) => {
+    if (phaseArg === 'cooperative') {
+        return { signal: 'SIGTERM', signalProcessGroup: false };
+    }
+    const signalProcessGroup = statusArg.processMode === 'detached';
+    if (signalProcessGroup && statusArg.processGroupId !== statusArg.controllerPid) {
+        throw new Error('The detached controller is not the verified leader of its process group.');
+    }
+    return { signal: 'SIGKILL', signalProcessGroup };
+};
+export const stopVerifiedController = async (optionsArg) => {
+    const command = optionsArg.status.processMode === 'detached'
+        ? '__serve'
+        : 'foreground';
+    const processIdentity = {
+        pid: optionsArg.status.controllerPid,
+        cliPath: optionsArg.cliPath,
+        port: optionsArg.port,
+        expectedProcessGroupId: optionsArg.status.processGroupId,
+        expectedFingerprint: optionsArg.status.processFingerprint,
+        command,
+    };
+    const cooperativeSignal = resolveControllerStopSignal(optionsArg.status, 'cooperative');
+    await signalVerifiedControllerProcess({
+        ...processIdentity,
+        ...cooperativeSignal,
+    });
+    if (await waitUntilControllerExited(processIdentity, 30_000))
+        return;
+    const hardSignal = resolveControllerStopSignal(optionsArg.status, 'hard');
+    await signalVerifiedControllerProcess({
+        ...processIdentity,
+        ...hardSignal,
+    });
+    if (!await waitUntilControllerExited(processIdentity, 15_000)) {
+        throw new Error('The exact controller process survived verified hard-stop escalation.');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.controllermanagement.js","sourceRoot":"","sources":["../../ts/classes.controllermanagement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EACL,qBAAqB,GAMtB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,wBAAwB,EACxB,+BAA+B,GAChC,MAAM,gCAAgC,CAAC;AAExC,MAAM,cAAc,GAAG,MAAM,CAAC,qBAAqB,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC;AAChF,MAAM,kBAAkB,GAAG,cAAc,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,cAAc,CAAC;AAS7E,MAAM,aAAa,GAAG,CAAC,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,QAAQ,CAAU,CAAC;AACtF,MAAM,CAAC,MAAM,6CAA6C,GAAG,MAAM,CAAC;AAEpE,MAAM,yBAAyB,GAAG,CAAC,SAAkB,EAAW,EAAE;IAChE,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACtE,MAAM,MAAM,GAAG,SAAoC,CAAC;IACpD,OAAO,CACL,CAAC,MAAM,CAAC,SAAS,KAAK,UAAU,IAAI,MAAM,CAAC,SAAS,KAAK,MAAM,CAAC;WAC7D,aAAa,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,KAAK,QAAQ,CAAC;WAC3D,OAAO,MAAM,CAAC,OAAO,KAAK,SAAS;WACnC,CAAC,MAAM,CAAC,GAAG,KAAK,SAAS,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;WAC9D,CAAC,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,OAAO,MAAM,CAAC,OAAO,KAAK,QAAQ,CAAC,CACxE,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,yBAAyB,GAAG,CAAC,SAAkB,EAAW,EAAE;IAChE,IAAI,CAAC,SAAS,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC;QAAE,OAAO,KAAK,CAAC;IAC1F,MAAM,MAAM,GAAG,SAAoC,CAAC;IACpD,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,KAAK,CAAC;WAClC,OAAO,MAAM,CAAC,WAAW,KAAK,QAAQ;WACtC,MAAM,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC;WAC7B,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,IAAI,GAAG;WACpD,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ;WACpC,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC;WAC3B,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,GAAG;WAClD,OAAO,MAAM,CAAC,KAAK,KAAK,QAAQ;WAChC,CAAC,WAAW,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,CAAC;aACzF,QAAQ,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AAC9B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,CACpC,SAAkB,EAClB,cAA4C,EACzB,EAAE;IACrB,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACxD,MAAM,IAAI,KAAK,CAAC,gDAAgD,kBAAkB,YAAY,CAAC,CAAC;IAClG,CAAC;IACD,MAAM,MAAM,GAAG,SAAuC,CAAC;IACvD,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAC1E,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,UAAU,CAAC,CAAC;IAClF,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,EAAE,SAAS,KAAK,MAAM,CAAC,CAAC;IAC1E,IACE,MAAM,CAAC,WAAW,KAAK,cAAc,CAAC,WAAW;WAC9C,MAAM,CAAC,cAAc,KAAK,cAAc,CAAC,cAAc;WACvD,CAAC,cAAc,CAAC,eAAe,KAAK,SAAS;eAC3C,MAAM,CAAC,eAAe,KAAK,cAAc,CAAC,eAAe,CAAC;WAC5D,MAAM,CAAC,wBAAwB,KAAK,cAAc,CAAC,wBAAwB;WAC3E,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,aAAa,CAAC;WAC3C,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,cAAc,CAAC;WAC5C,OAAO,MAAM,CAAC,kBAAkB,KAAK,QAAQ;WAC7C,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAG,CAAC;WACpC,MAAM,CAAC,kBAAkB,CAAC,MAAM,GAAG,GAAG;WACtC,CAAC,MAAM,CAAC,WAAW,KAAK,UAAU,IAAI,MAAM,CAAC,WAAW,KAAK,YAAY,CAAC;WAC1E,CAAC,MAAM,CAAC,cAAc,KAAK,UAAU;eACnC,MAAM,CAAC,cAAc,KAAK,OAAO;eACjC,MAAM,CAAC,cAAc,KAAK,UAAU;eACpC,MAAM,CAAC,cAAc,KAAK,SAAS,CAAC;WACtC,OAAO,MAAM,CAAC,SAAS,KAAK,QAAQ;WACpC,OAAO,MAAM,CAAC,aAAa,KAAK,SAAS;WACzC,CAAC,MAAM,CAAC,OAAO,KAAK,SAAS,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;WAC5E,SAAS,CAAC,MAAM,KAAK,CAAC;WACtB,CAAC,QAAQ;WACT,CAAC,IAAI;WACL,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC,EACtE,CAAC;QACD,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC;IACjG,CAAC;IACD,OAAO,MAA2B,CAAC;AACrC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,oCAAoC,GAAG,KAAK,EACvD,OAAe,EACf,QAAgB,EAChB,gBAAwB,EACxB,gBAAwB,EACiC,EAAE;IAC3D,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;IAC9C,MAAM,OAAO,GAAG,UAAU,CACxB,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,EAC7B,6CAA6C,CAC9C,CAAC;IACF,IAAI,MAAmD,CAAC;IACxD,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CACzD,IAAI,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,EACtC,oBAAoB,OAAO,EAAE,EAC7B;YACE,aAAa,EAAE,KAAK;YACpB,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,eAAe,CAAC,MAAM;SACpC,CACF,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAC9C,kCAAkC,EAClC,SAAS,EACT;YACE,SAAS,EAAE,6CAA6C;YACxD,WAAW,EAAE,eAAe,CAAC,MAAM;SACpC,CACF,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,EAAE,gBAAgB,EAAE,CAAC,CAAC;QAC9F,IACE,CAAC,QAAQ;eACN,OAAO,QAAQ,KAAK,QAAQ;eAC5B,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC;eACvB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC;eAClC,QAAQ,CAAC,QAAQ,KAAK,IAAI;YAC7B,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;QACtF,OAAO,QAAQ,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,OAAO,CAAC,CAAC;QACtB,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC;IACvB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,KAAK,EACnD,OAAe,EACf,QAAgB,EAChB,OAA0D,EAC1D,YAAY,GAAG,MAAM,EACgC,EAAE;IACvD,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CAC/D,IAAI,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,EACtC,oBAAoB,OAAO,EAAE,EAC7B,EAAE,aAAa,EAAE,KAAK,EAAE,UAAU,EAAE,CAAC,EAAE,CACxC,CAAC;IACF,IAAI,CAAC;QACH,OAAO,MAAM,MAAM,CAAC,kBAAkB,CACpC,6BAA6B,EAC7B,SAAS,EACT,EAAE,SAAS,EAAE,YAAY,EAAE,CAC5B,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;IAC7C,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,CAAC,IAAI,EAAE,CAAC;IACtB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,qBAAqB,GAAG,KAAK,EACxC,OAAe,EACf,cAA4C,EAC5C,YAAY,GAAG,KAAK,EACQ,EAAE;IAC9B,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;IAC9C,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,EAAE,YAAY,CAAC,CAAC;IACxE,IAAI,MAAmD,CAAC;IACxD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CACzD,MAAM,EACN,oBAAoB,OAAO,EAAE,EAC7B;YACE,aAAa,EAAE,KAAK;YACpB,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,eAAe,CAAC,MAAM;SACpC,CACF,CAAC;QACF,MAAM,OAAO,GAAG,MAAM,CAAC,kBAAkB,CACvC,mBAAmB,EACnB,SAAS,EACT,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,CAAC,MAAM,EAAE,CACjE,CAAC;QACF,OAAO,sBAAsB,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC,CAAC;IACxE,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,OAAO,CAAC,CAAC;QACtB,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC;IACvB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,wBAAwB,GAAG,KAAK,EAC3C,OAAe,EACf,cAA4C,EACJ,EAAE;IAC1C,IAAI,CAAC;QACH,OAAO,MAAM,qBAAqB,CAAC,OAAO,EAAE,cAAc,CAAC,CAAC;IAC9D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAC1C,OAAe,EACf,YAAY,GAAG,GAAG,EACA,EAAE;IACpB,OAAO,MAAM,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,EAAE;QAC5C,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC;QAClF,IAAI,OAAO,GAAG,KAAK,CAAC;QACpB,MAAM,MAAM,GAAG,CAAC,SAAkB,EAAE,EAAE;YACpC,IAAI,OAAO;gBAAE,OAAO;YACpB,OAAO,GAAG,IAAI,CAAC;YACf,YAAY,CAAC,OAAO,CAAC,CAAC;YACtB,MAAM,CAAC,OAAO,EAAE,CAAC;YACjB,OAAO,CAAC,SAAS,CAAC,CAAC;QACrB,CAAC,CAAC;QACF,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;QAC3C,MAAM,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IAC5C,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,KAAK,EACjD,OAAe,EACf,QAAgB,EAChB,YAAY,GAAG,MAAM,EAC8B,EAAE;IACrD,MAAM,eAAe,GAAG,IAAI,eAAe,EAAE,CAAC;IAC9C,MAAM,OAAO,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,eAAe,CAAC,KAAK,EAAE,EAAE,YAAY,CAAC,CAAC;IACxE,IAAI,MAAmD,CAAC;IACxD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,WAAW,EAAE,CAAC;QACtD,MAAM,GAAG,MAAM,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,YAAY,CACzD,MAAM,EACN,oBAAoB,OAAO,EAAE,EAC7B;YACE,aAAa,EAAE,KAAK;YACpB,UAAU,EAAE,CAAC;YACb,WAAW,EAAE,eAAe,CAAC,MAAM;SACpC,CACF,CAAC;QACF,MAAM,QAAQ,GAAG,MAAM,MAAM,CAAC,kBAAkB,CAC9C,2BAA2B,EAC3B,SAAS,EACT,EAAE,SAAS,EAAE,YAAY,EAAE,WAAW,EAAE,eAAe,CAAC,MAAM,EAAE,CACjE,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;QAC5B,IACE,CAAC,QAAQ;eACN,OAAO,QAAQ,KAAK,QAAQ;eAC5B,QAAQ,CAAC,QAAQ,KAAK,IAAI;eAC1B,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,SAAS,CAAC;eACzC,QAAQ,CAAC,SAAS,GAAG,CAAC;eACtB,OAAO,QAAQ,CAAC,WAAW,KAAK,QAAQ;eACxC,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,EACjD,CAAC;YACD,MAAM,IAAI,KAAK,CAAC,sCAAsC,cAAc,2BAA2B,CAAC,CAAC;QACnG,CAAC;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,OAAO,CAAC,CAAC;QACtB,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC;IACvB,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,yBAAyB,GAAG,KAAK,EAC5C,UAOC,EACD,YAAoB,EACF,EAAE;IACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC;IAC3C,OAAO,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,MAAM,wBAAwB,CAAC,UAAU,CAAC;YAAE,OAAO,IAAI,CAAC;QAC7D,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC,CAAC;IAC3D,CAAC;IACD,OAAO,CAAC,MAAM,wBAAwB,CAAC,UAAU,CAAC,CAAC;AACrD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACzC,SAA4B,EAC5B,QAAgC,EACyB,EAAE;IAC3D,IAAI,QAAQ,KAAK,aAAa,EAAE,CAAC;QAC/B,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,KAAK,EAAE,CAAC;IAC1D,CAAC;IACD,MAAM,kBAAkB,GAAG,SAAS,CAAC,WAAW,KAAK,UAAU,CAAC;IAChE,IAAI,kBAAkB,IAAI,SAAS,CAAC,cAAc,KAAK,SAAS,CAAC,aAAa,EAAE,CAAC;QAC/E,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,kBAAkB,EAAE,CAAC;AACnD,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,sBAAsB,GAAG,KAAK,EAAE,UAI5C,EAAiB,EAAE;IAClB,MAAM,OAAO,GAA6B,UAAU,CAAC,MAAM,CAAC,WAAW,KAAK,UAAU;QACpF,CAAC,CAAC,SAAS;QACX,CAAC,CAAC,YAAY,CAAC;IACjB,MAAM,eAAe,GAAG;QACtB,GAAG,EAAE,UAAU,CAAC,MAAM,CAAC,aAAa;QACpC,OAAO,EAAE,UAAU,CAAC,OAAO;QAC3B,IAAI,EAAE,UAAU,CAAC,IAAI;QACrB,sBAAsB,EAAE,UAAU,CAAC,MAAM,CAAC,cAAc;QACxD,mBAAmB,EAAE,UAAU,CAAC,MAAM,CAAC,kBAAkB;QACzD,OAAO;KACR,CAAC;IACF,MAAM,iBAAiB,GAAG,2BAA2B,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IACxF,MAAM,+BAA+B,CAAC;QACpC,GAAG,eAAe;QAClB,GAAG,iBAAiB;KACrB,CAAC,CAAC;IACH,IAAI,MAAM,yBAAyB,CAAC,eAAe,EAAE,MAAM,CAAC;QAAE,OAAO;IACrE,MAAM,UAAU,GAAG,2BAA2B,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1E,MAAM,+BAA+B,CAAC;QACpC,GAAG,eAAe;QAClB,GAAG,UAAU;KACd,CAAC,CAAC;IACH,IAAI,CAAC,MAAM,yBAAyB,CAAC,eAAe,EAAE,MAAM,CAAC,EAAE,CAAC;QAC9D,MAAM,IAAI,KAAK,CACb,sEAAsE,CACvE,CAAC;IACJ,CAAC;AACH,CAAC,CAAC"}

package/dist_ts/classes.draftmanager.d.ts

@@ -0,0 +1,30 @@
+import { type IControllerDraftAttachment, type IControllerSessionDraft, type IControllerSessionDraftUpdate } from '../dist_ts_interfaces/interfaces.js';
+export declare class ControllerDraftConflictError extends Error {
+    readonly draft: IControllerSessionDraft;
+    constructor(draft: IControllerSessionDraft);
+}
+export declare class ControllerDraftLimitError extends Error {
+    constructor(messageArg: string);
+}
+export interface IControllerDraftMutationResult {
+    draft: IControllerSessionDraft;
+    update?: IControllerSessionDraftUpdate;
+}
+export declare class ControllerDraftManager {
+    private readonly drafts;
+    private nonEmptyDrafts;
+    private aggregateAttachmentBytes;
+    get(keyArg: string): IControllerSessionDraft;
+    update(keyArg: string, expectedRevisionArg: number, patchArg: {
+        text?: string;
+        attachments?: readonly IControllerDraftAttachment[];
+    }): IControllerDraftMutationResult;
+    snapshot(keyArg: string, revisionArg: number): IControllerSessionDraft;
+    clearExact(keyArg: string, revisionArg: number): IControllerDraftMutationResult;
+    purge(keyArg: string): void;
+    purgePrefix(prefixArg: string): void;
+    clear(): void;
+    private assertDraftFields;
+    private assertAdmission;
+    private store;
+}

package/dist_ts/classes.draftmanager.js

@@ -0,0 +1,179 @@
+import { controllerMaxDraftAttachmentBytes, controllerMaxDraftAttachmentTotalBytes, controllerMaxDraftAttachments, controllerMaxDraftTextBytes, } from '../dist_ts_interfaces/interfaces.js';
+const maximumDraftIdentities = 4_096;
+const maximumNonEmptyDrafts = 512;
+const maximumAggregateAttachmentBytes = 64 * 1024 * 1024;
+export class ControllerDraftConflictError extends Error {
+    draft;
+    constructor(draft) {
+        super('The composer draft changed concurrently.');
+        this.draft = draft;
+        this.name = 'ControllerDraftConflictError';
+    }
+}
+export class ControllerDraftLimitError extends Error {
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'ControllerDraftLimitError';
+    }
+}
+const cloneAttachment = (attachmentArg) => ({ ...attachmentArg });
+const cloneDraft = (draftArg) => ({
+    text: draftArg.text,
+    attachments: draftArg.attachments.map(cloneAttachment),
+    revision: draftArg.revision,
+});
+const emptyDraft = () => ({ text: '', attachments: [], revision: 0 });
+const attachmentBytes = (draftArg) => (draftArg.attachments.reduce((sum, attachment) => sum + attachment.size, 0));
+const isNonEmpty = (draftArg) => (draftArg.text.length > 0 || draftArg.attachments.length > 0);
+const attachmentsEqual = (leftArg, rightArg) => leftArg.length === rightArg.length && leftArg.every((left, index) => {
+    const right = rightArg[index];
+    return right !== undefined
+        && left.id === right.id
+        && left.name === right.name
+        && left.mediaType === right.mediaType
+        && left.size === right.size
+        && left.kind === right.kind
+        && left.dataBase64 === right.dataBase64;
+});
+export class ControllerDraftManager {
+    drafts = new Map();
+    nonEmptyDrafts = 0;
+    aggregateAttachmentBytes = 0;
+    get(keyArg) {
+        return cloneDraft(this.drafts.get(keyArg) ?? emptyDraft());
+    }
+    update(keyArg, expectedRevisionArg, patchArg) {
+        const current = this.drafts.get(keyArg) ?? emptyDraft();
+        if (current.revision !== expectedRevisionArg) {
+            throw new ControllerDraftConflictError(cloneDraft(current));
+        }
+        if (patchArg.text === undefined && patchArg.attachments === undefined) {
+            throw new Error('A draft update must replace text, attachments, or both.');
+        }
+        const nextText = patchArg.text ?? current.text;
+        const nextAttachments = patchArg.attachments === undefined
+            ? current.attachments
+            : patchArg.attachments.map(cloneAttachment);
+        this.assertDraftFields(nextText, nextAttachments);
+        const textChanged = nextText !== current.text;
+        const attachmentsChanged = !attachmentsEqual(nextAttachments, current.attachments);
+        if (!textChanged && !attachmentsChanged)
+            return { draft: cloneDraft(current) };
+        if (current.revision >= Number.MAX_SAFE_INTEGER) {
+            throw new ControllerDraftLimitError('The draft revision limit was reached.');
+        }
+        const next = {
+            text: nextText,
+            attachments: nextAttachments,
+            revision: current.revision + 1,
+        };
+        this.assertAdmission(keyArg, current, next);
+        this.store(keyArg, current, next);
+        return {
+            draft: cloneDraft(next),
+            update: {
+                revision: next.revision,
+                ...(textChanged ? { text: next.text } : {}),
+                ...(attachmentsChanged
+                    ? { attachments: next.attachments.map(cloneAttachment) }
+                    : {}),
+            },
+        };
+    }
+    snapshot(keyArg, revisionArg) {
+        const current = this.drafts.get(keyArg) ?? emptyDraft();
+        if (current.revision !== revisionArg) {
+            throw new ControllerDraftConflictError(cloneDraft(current));
+        }
+        if (current.revision >= Number.MAX_SAFE_INTEGER) {
+            throw new ControllerDraftLimitError('The draft revision limit was reached.');
+        }
+        if (!current.text.trim())
+            throw new Error('The composer draft text must not be blank.');
+        return cloneDraft(current);
+    }
+    clearExact(keyArg, revisionArg) {
+        const current = this.drafts.get(keyArg);
+        if (!current || current.revision !== revisionArg) {
+            return { draft: cloneDraft(current ?? emptyDraft()) };
+        }
+        if (current.revision >= Number.MAX_SAFE_INTEGER) {
+            throw new ControllerDraftLimitError('The draft revision limit was reached.');
+        }
+        const next = {
+            text: '',
+            attachments: [],
+            revision: current.revision + 1,
+        };
+        this.store(keyArg, current, next);
+        return {
+            draft: cloneDraft(next),
+            update: { revision: next.revision, text: '', attachments: [] },
+        };
+    }
+    purge(keyArg) {
+        const current = this.drafts.get(keyArg);
+        if (!current)
+            return;
+        this.drafts.delete(keyArg);
+        if (isNonEmpty(current))
+            this.nonEmptyDrafts -= 1;
+        this.aggregateAttachmentBytes -= attachmentBytes(current);
+    }
+    purgePrefix(prefixArg) {
+        for (const key of this.drafts.keys()) {
+            if (key.startsWith(prefixArg))
+                this.purge(key);
+        }
+    }
+    clear() {
+        this.drafts.clear();
+        this.nonEmptyDrafts = 0;
+        this.aggregateAttachmentBytes = 0;
+    }
+    assertDraftFields(textArg, attachmentsArg) {
+        if (Buffer.byteLength(textArg, 'utf8') > controllerMaxDraftTextBytes) {
+            throw new ControllerDraftLimitError('The draft text exceeds the controller byte limit.');
+        }
+        if (attachmentsArg.length > controllerMaxDraftAttachments) {
+            throw new ControllerDraftLimitError('The draft attachment count exceeds the controller limit.');
+        }
+        const ids = new Set();
+        let bytes = 0;
+        for (const attachment of attachmentsArg) {
+            if (ids.has(attachment.id))
+                throw new Error('Draft attachment IDs must be unique.');
+            ids.add(attachment.id);
+            if (attachment.size > controllerMaxDraftAttachmentBytes) {
+                throw new ControllerDraftLimitError('A draft attachment exceeds the controller byte limit.');
+            }
+            bytes += attachment.size;
+        }
+        if (bytes > controllerMaxDraftAttachmentTotalBytes) {
+            throw new ControllerDraftLimitError('The draft attachments exceed the controller total byte limit.');
+        }
+    }
+    assertAdmission(keyArg, currentArg, nextArg) {
+        if (!this.drafts.has(keyArg) && this.drafts.size >= maximumDraftIdentities) {
+            throw new ControllerDraftLimitError('The controller draft identity limit is exhausted.');
+        }
+        const nextNonEmptyCount = this.nonEmptyDrafts
+            - (isNonEmpty(currentArg) ? 1 : 0)
+            + (isNonEmpty(nextArg) ? 1 : 0);
+        if (nextNonEmptyCount > maximumNonEmptyDrafts) {
+            throw new ControllerDraftLimitError('The controller non-empty draft limit is exhausted.');
+        }
+        const nextAttachmentBytes = this.aggregateAttachmentBytes
+            - attachmentBytes(currentArg)
+            + attachmentBytes(nextArg);
+        if (nextAttachmentBytes > maximumAggregateAttachmentBytes) {
+            throw new ControllerDraftLimitError('The controller draft attachment memory limit is exhausted.');
+        }
+    }
+    store(keyArg, currentArg, nextArg) {
+        this.nonEmptyDrafts += (isNonEmpty(nextArg) ? 1 : 0) - (isNonEmpty(currentArg) ? 1 : 0);
+        this.aggregateAttachmentBytes += attachmentBytes(nextArg) - attachmentBytes(currentArg);
+        this.drafts.set(keyArg, nextArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.draftmanager.js","sourceRoot":"","sources":["../../ts/classes.draftmanager.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iCAAiC,EACjC,sCAAsC,EACtC,6BAA6B,EAC7B,2BAA2B,GAI5B,MAAM,gCAAgC,CAAC;AAExC,MAAM,sBAAsB,GAAG,KAAK,CAAC;AACrC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAClC,MAAM,+BAA+B,GAAG,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AAEzD,MAAM,OAAO,4BAA6B,SAAQ,KAAK;IACzB;IAA5B,YAA4B,KAA8B;QACxD,KAAK,CAAC,0CAA0C,CAAC,CAAC;QADxB,UAAK,GAAL,KAAK,CAAyB;QAExD,IAAI,CAAC,IAAI,GAAG,8BAA8B,CAAC;IAC7C,CAAC;CACF;AAED,MAAM,OAAO,yBAA0B,SAAQ,KAAK;IAClD,YAAY,UAAkB;QAC5B,KAAK,CAAC,UAAU,CAAC,CAAC;QAClB,IAAI,CAAC,IAAI,GAAG,2BAA2B,CAAC;IAC1C,CAAC;CACF;AAOD,MAAM,eAAe,GAAG,CACtB,aAAyC,EACb,EAAE,CAAC,CAAC,EAAE,GAAG,aAAa,EAAE,CAAC,CAAC;AAExD,MAAM,UAAU,GAAG,CAAC,QAAiC,EAA2B,EAAE,CAAC,CAAC;IAClF,IAAI,EAAE,QAAQ,CAAC,IAAI;IACnB,WAAW,EAAE,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,eAAe,CAAC;IACtD,QAAQ,EAAE,QAAQ,CAAC,QAAQ;CAC5B,CAAC,CAAC;AAEH,MAAM,UAAU,GAAG,GAA4B,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,CAAC;AAE/F,MAAM,eAAe,GAAG,CAAC,QAAiC,EAAU,EAAE,CAAC,CACrE,QAAQ,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,UAAU,EAAE,EAAE,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC,CAC3E,CAAC;AAEF,MAAM,UAAU,GAAG,CAAC,QAAiC,EAAW,EAAE,CAAC,CACjE,QAAQ,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,QAAQ,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAC5D,CAAC;AAEF,MAAM,gBAAgB,GAAG,CACvB,OAA8C,EAC9C,QAA+C,EACtC,EAAE,CAAC,OAAO,CAAC,MAAM,KAAK,QAAQ,CAAC,MAAM,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;IAChF,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC9B,OAAO,KAAK,KAAK,SAAS;WACrB,IAAI,CAAC,EAAE,KAAK,KAAK,CAAC,EAAE;WACpB,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;WACxB,IAAI,CAAC,SAAS,KAAK,KAAK,CAAC,SAAS;WAClC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;WACxB,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;WACxB,IAAI,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU,CAAC;AAC5C,CAAC,CAAC,CAAC;AAEH,MAAM,OAAO,sBAAsB;IAChB,MAAM,GAAG,IAAI,GAAG,EAAmC,CAAC;IAC7D,cAAc,GAAG,CAAC,CAAC;IACnB,wBAAwB,GAAG,CAAC,CAAC;IAE9B,GAAG,CAAC,MAAc;QACvB,OAAO,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC,CAAC;IAC7D,CAAC;IAEM,MAAM,CACX,MAAc,EACd,mBAA2B,EAC3B,QAAgF;QAEhF,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QACxD,IAAI,OAAO,CAAC,QAAQ,KAAK,mBAAmB,EAAE,CAAC;YAC7C,MAAM,IAAI,4BAA4B,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,QAAQ,CAAC,WAAW,KAAK,SAAS,EAAE,CAAC;YACtE,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;QAC7E,CAAC;QAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;QAC/C,MAAM,eAAe,GAAG,QAAQ,CAAC,WAAW,KAAK,SAAS;YACxD,CAAC,CAAC,OAAO,CAAC,WAAW;YACrB,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;QAC9C,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC;QAClD,MAAM,WAAW,GAAG,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC;QAC9C,MAAM,kBAAkB,GAAG,CAAC,gBAAgB,CAAC,eAAe,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;QACnF,IAAI,CAAC,WAAW,IAAI,CAAC,kBAAkB;YAAE,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAC/E,IAAI,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAChD,MAAM,IAAI,yBAAyB,CAAC,uCAAuC,CAAC,CAAC;QAC/E,CAAC;QAED,MAAM,IAAI,GAA4B;YACpC,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,eAAe;YAC5B,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,CAAC;SAC/B,CAAC;QACF,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAC5C,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAClC,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC;YACvB,MAAM,EAAE;gBACN,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC3C,GAAG,CAAC,kBAAkB;oBACpB,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE;oBACxD,CAAC,CAAC,EAAE,CAAC;aACR;SACF,CAAC;IACJ,CAAC;IAEM,QAAQ,CAAC,MAAc,EAAE,WAAmB;QACjD,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,UAAU,EAAE,CAAC;QACxD,IAAI,OAAO,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;YACrC,MAAM,IAAI,4BAA4B,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;QAC9D,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAChD,MAAM,IAAI,yBAAyB,CAAC,uCAAuC,CAAC,CAAC;QAC/E,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;QACxF,OAAO,UAAU,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;IAEM,UAAU,CACf,MAAc,EACd,WAAmB;QAEnB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,QAAQ,KAAK,WAAW,EAAE,CAAC;YACjD,OAAO,EAAE,KAAK,EAAE,UAAU,CAAC,OAAO,IAAI,UAAU,EAAE,CAAC,EAAE,CAAC;QACxD,CAAC;QACD,IAAI,OAAO,CAAC,QAAQ,IAAI,MAAM,CAAC,gBAAgB,EAAE,CAAC;YAChD,MAAM,IAAI,yBAAyB,CAAC,uCAAuC,CAAC,CAAC;QAC/E,CAAC;QACD,MAAM,IAAI,GAA4B;YACpC,IAAI,EAAE,EAAE;YACR,WAAW,EAAE,EAAE;YACf,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,CAAC;SAC/B,CAAC;QACF,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;QAClC,OAAO;YACL,KAAK,EAAE,UAAU,CAAC,IAAI,CAAC;YACvB,MAAM,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE;SAC/D,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,MAAc;QACzB,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACxC,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,UAAU,CAAC,OAAO,CAAC;YAAE,IAAI,CAAC,cAAc,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,wBAAwB,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;IAC5D,CAAC;IAEM,WAAW,CAAC,SAAiB;QAClC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,CAAC;YACrC,IAAI,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;gBAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACjD,CAAC;IACH,CAAC;IAEM,KAAK;QACV,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,IAAI,CAAC,cAAc,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,wBAAwB,GAAG,CAAC,CAAC;IACpC,CAAC;IAEO,iBAAiB,CACvB,OAAe,EACf,cAAqD;QAErD,IAAI,MAAM,CAAC,UAAU,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG,2BAA2B,EAAE,CAAC;YACrE,MAAM,IAAI,yBAAyB,CAAC,mDAAmD,CAAC,CAAC;QAC3F,CAAC;QACD,IAAI,cAAc,CAAC,MAAM,GAAG,6BAA6B,EAAE,CAAC;YAC1D,MAAM,IAAI,yBAAyB,CAAC,0DAA0D,CAAC,CAAC;QAClG,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,GAAG,EAAU,CAAC;QAC9B,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,KAAK,MAAM,UAAU,IAAI,cAAc,EAAE,CAAC;YACxC,IAAI,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACpF,GAAG,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;YACvB,IAAI,UAAU,CAAC,IAAI,GAAG,iCAAiC,EAAE,CAAC;gBACxD,MAAM,IAAI,yBAAyB,CAAC,uDAAuD,CAAC,CAAC;YAC/F,CAAC;YACD,KAAK,IAAI,UAAU,CAAC,IAAI,CAAC;QAC3B,CAAC;QACD,IAAI,KAAK,GAAG,sCAAsC,EAAE,CAAC;YACnD,MAAM,IAAI,yBAAyB,CAAC,+DAA+D,CAAC,CAAC;QACvG,CAAC;IACH,CAAC;IAEO,eAAe,CACrB,MAAc,EACd,UAAmC,EACnC,OAAgC;QAEhC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;YAC3E,MAAM,IAAI,yBAAyB,CAAC,mDAAmD,CAAC,CAAC;QAC3F,CAAC;QACD,MAAM,iBAAiB,GAAG,IAAI,CAAC,cAAc;cACzC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;cAChC,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,IAAI,iBAAiB,GAAG,qBAAqB,EAAE,CAAC;YAC9C,MAAM,IAAI,yBAAyB,CAAC,oDAAoD,CAAC,CAAC;QAC5F,CAAC;QACD,MAAM,mBAAmB,GAAG,IAAI,CAAC,wBAAwB;cACrD,eAAe,CAAC,UAAU,CAAC;cAC3B,eAAe,CAAC,OAAO,CAAC,CAAC;QAC7B,IAAI,mBAAmB,GAAG,+BAA+B,EAAE,CAAC;YAC1D,MAAM,IAAI,yBAAyB,CAAC,4DAA4D,CAAC,CAAC;QACpG,CAAC;IACH,CAAC;IAEO,KAAK,CACX,MAAc,EACd,UAAmC,EACnC,OAAgC;QAEhC,IAAI,CAAC,cAAc,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxF,IAAI,CAAC,wBAAwB,IAAI,eAAe,CAAC,OAAO,CAAC,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC;QACxF,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,CAAC;CACF"}

package/dist_ts/classes.embeddeddb.d.ts

@@ -0,0 +1,30 @@
+export { embeddedDatabaseSocketPath } from './functions.embeddeddb.js';
+export interface IEmbeddedControllerDatabaseOptions {
+    /** directory holding the smartdb storage files and its unix socket */
+    dataDirectory: string;
+    /** previous installed default, logically migrated only while its engine is stopped */
+    legacyDataDirectory?: string;
+}
+/**
+ * The controller's embedded database engine: a @push.rocks/smartdb
+ * LocalSmartDb over a unix socket inside the data directory. The socket
+ * path is deterministic so a second controller process (e.g. the
+ * temp-password CLI) attaches to the running daemon's engine instead of
+ * opening the storage files a second time; only the process that booted
+ * the engine stops it.
+ */
+export declare class EmbeddedControllerDatabase {
+    private readonly options;
+    private localDb?;
+    private connectionUri?;
+    private startPromise?;
+    private migrationRunner?;
+    constructor(options: IEmbeddedControllerDatabaseOptions);
+    get socketPath(): string;
+    get ownsEngine(): boolean;
+    /** Starts (or attaches to) the engine and returns the smartdata-ready URI. */
+    start(): Promise<string>;
+    private startOnce;
+    stop(): Promise<void>;
+    private isSocketListening;
+}