agl 40.5.1 → 41.0.0

package/dist_ts/functions.flexprivatesnapshot.js

@@ -0,0 +1,461 @@
+import * as plugins from './plugins.js';
+import { assertFlexPrivateCandidateDocument, assertFlexPrivateChunkDocument, flexPrivateChunkBytes, } from './classes.flexmodels.private.js';
+/*
+ * A private snapshot is stored as the JSON of the snapshot cut into content-addressed chunks
+ * (`IFlexPrivateChunkDocument`), listed in order by a candidate (`IFlexPrivateCandidateDocument`)
+ * that names the SHA-256 of the whole JSON. The JSON is cut in runs, and a chunk never spans two
+ * runs:
+ *
+ * - a growing list of a projection (`packedLists`) is its own run, packed entry by entry from the
+ *   list's start into chunks of up to 64 KiB (an entry over the chunk size is cut in slices), so a
+ *   chunk's end depends only on the entries before it;
+ * - everything else, and the whole snapshot of the other domains, is cut into slices of
+ *   `flexPrivateChunkBytes` from the run's start.
+ *
+ * A save rebuilds only what its change touches: it keeps the layout of the candidate it replaces
+ * (`IFlexPrivateLayout`: each chunk with its bytes and where each list entry lies in them), takes
+ * every chunk whose bytes the change leaves in place, and serializes, hashes and encodes only the
+ * entries and chunks from the change on. The whole-snapshot SHA-256 is one pass over the chunks'
+ * bytes in order. A build without a previous layout is the full path: it serializes every entry.
+ * Both produce the bytes AGL 40.5.0 wrote; `test/test.flexprivatesnapshot.node.ts` proves it
+ * against that serializer.
+ */
+/** The lists of a domain snapshot that grow entry by entry, each packed in its own run. */
+const packedLists = {
+    projection: ['messages', 'reversionSegments'],
+};
+/**
+ * The list a domain snapshot stores as the last member of its one run. Its entries' bytes stay
+ * where they are when the snapshot's other members keep their length, so a save that changes the
+ * list's newest entries rebuilds the run's first slice and the slices from the change on.
+ */
+const streamedLists = {
+    agentEvents: 'events',
+};
+/** A chunk of a growing list stays under this size, so a change rewrites little of the list. */
+const privateListChunkBytes = 64 * 1024;
+const sha256 = (valueArg) => plugins.crypto.createHash('sha256').update(valueArg).digest('hex');
+export const privateCandidateDocumentId = (candidateIdArg) => `flex-private-candidate:${candidateIdArg}`;
+/**
+ * Private chunks are addressed by their content within one domain incarnation, so a save stores
+ * only the chunks it changed and shares the others with the snapshot it replaces.
+ */
+export const privateChunkDocumentId = (ownerArg, chunkDigestArg) => `flex-private-chunk:${sha256(JSON.stringify([
+    ownerArg.controllerId,
+    ownerArg.storageKey,
+    ownerArg.domain,
+    ownerArg.sessionId ?? null,
+    ownerArg.archiveId ?? null,
+    ownerArg.incarnationId,
+    chunkDigestArg,
+]))}`;
+const ownerKey = (ownerArg) => JSON.stringify([
+    ownerArg.controllerId,
+    ownerArg.storageKey,
+    ownerArg.domain,
+    ownerArg.sessionId ?? null,
+    ownerArg.archiveId ?? null,
+    ownerArg.incarnationId,
+]);
+/** A snapshot that streams `keyArg` when it is the last member and a list; else its JSON whole. */
+const streamedRun = (snapshotArg, keyArg) => {
+    const keys = Object.keys(snapshotArg);
+    const value = keyArg === undefined ? undefined : Reflect.get(snapshotArg, keyArg);
+    if (keyArg === undefined || keys.at(-1) !== keyArg || !Array.isArray(value)) {
+        return { kind: 'sliced', head: JSON.stringify(snapshotArg), tail: '' };
+    }
+    const rest = JSON.stringify(Object.fromEntries(keys.slice(0, -1).map((key) => [key, Reflect.get(snapshotArg, key)])));
+    return {
+        kind: 'sliced',
+        head: `${rest.slice(0, -1)}${rest === '{}' ? '' : ','}${JSON.stringify(keyArg)}:[`,
+        list: { key: keyArg, entries: value },
+        tail: ']}',
+    };
+};
+/** The runs of a snapshot's JSON, in order. */
+const describeRuns = (snapshotArg, domainArg) => {
+    if (snapshotArg === null || typeof snapshotArg !== 'object' || Array.isArray(snapshotArg)) {
+        return [{ kind: 'sliced', head: JSON.stringify(snapshotArg), tail: '' }];
+    }
+    const listKeys = packedLists[domainArg] ?? [];
+    if (listKeys.length === 0)
+        return [streamedRun(snapshotArg, streamedLists[domainArg])];
+    const runs = [];
+    let frame = '{';
+    let first = true;
+    for (const [key, value] of Object.entries(snapshotArg)) {
+        if (value === undefined)
+            continue;
+        frame += `${first ? '' : ','}${JSON.stringify(key)}:`;
+        first = false;
+        if (listKeys.includes(key) && Array.isArray(value) && value.length > 0) {
+            runs.push({ kind: 'sliced', head: `${frame}[`, tail: '' });
+            runs.push({ kind: 'packed', key, entries: value });
+            frame = ']';
+        }
+        else {
+            frame += JSON.stringify(value);
+        }
+    }
+    runs.push({ kind: 'sliced', head: `${frame}}`, tail: '' });
+    return runs;
+};
+/** How many entries two lists share from their start, by identity. */
+const sharedPrefix = (leftArg, rightArg) => {
+    const limit = Math.min(leftArg.length, rightArg.length);
+    let index = 0;
+    while (index < limit && leftArg[index] === rightArg[index])
+        index++;
+    return index;
+};
+const bufferSegment = (bufferArg) => ({
+    bytes: bufferArg.byteLength,
+    copy: (targetArg, targetOffsetArg, fromArg, toArg) => {
+        bufferArg.copy(targetArg, targetOffsetArg, fromArg, toArg);
+    },
+});
+/** The bytes `fromArg` to `toArg` of a sliced run, read from its chunks. */
+const previousSegment = (runArg, fromArg, toArg) => ({
+    bytes: toArg - fromArg,
+    copy: (targetArg, targetOffsetArg, startArg, endArg) => {
+        let offset = fromArg + startArg;
+        let target = targetOffsetArg;
+        while (offset < fromArg + endArg) {
+            const index = Math.floor(offset / flexPrivateChunkBytes);
+            const within = offset - index * flexPrivateChunkBytes;
+            const length = Math.min(fromArg + endArg - offset, flexPrivateChunkBytes - within);
+            runArg.chunks[index].data.copy(targetArg, target, within, within + length);
+            offset += length;
+            target += length;
+        }
+    },
+});
+/**
+ * Fills the chunks `rangesArg` names (sorted, disjoint, in run offsets) from the run's segments in
+ * one pass.
+ */
+const fillRanges = (segmentsArg, rangesArg) => {
+    let rangeIndex = 0;
+    let position = 0;
+    for (const segment of segmentsArg) {
+        const segmentEnd = position + segment.bytes;
+        while (rangeIndex < rangesArg.length && rangesArg[rangeIndex].end <= position)
+            rangeIndex++;
+        for (let index = rangeIndex; index < rangesArg.length && rangesArg[index].start < segmentEnd; index++) {
+            const range = rangesArg[index];
+            const from = Math.max(range.start, position);
+            const to = Math.min(range.end, segmentEnd);
+            if (from < to)
+                segment.copy(range.data, from - range.start, from - position, to - position);
+        }
+        position = segmentEnd;
+    }
+};
+/** `textArg` as UTF-8 in memory of its own, never a slice of Node's shared buffer pool. */
+const ownBytes = (textArg) => {
+    const data = Buffer.alloc(Buffer.byteLength(textArg, 'utf8'));
+    data.write(textArg, 'utf8');
+    return data;
+};
+const updateSlicedRun = (previousArg, sourceArg, mintArg) => {
+    const head = ownBytes(sourceArg.head);
+    const tail = ownBytes(sourceArg.tail);
+    const entries = sourceArg.list?.entries ?? [];
+    const previousList = previousArg?.list !== undefined && previousArg.list.key === sourceArg.list?.key
+        ? previousArg.list
+        : undefined;
+    const kept = previousList ? sharedPrefix(entries, previousList.entries) : 0;
+    // The pieces of the kept entries are taken from the previous run's bytes, never serialized again.
+    const previousListStart = previousArg?.head.byteLength ?? 0;
+    const keptEnd = kept > 0 ? previousList.ends[kept - 1] : previousListStart;
+    const fresh = [];
+    for (let index = kept; index < entries.length; index++) {
+        fresh.push(Buffer.from(`${index === 0 ? '' : ','}${JSON.stringify(entries[index]) ?? 'null'}`, 'utf8'));
+    }
+    const shift = head.byteLength - previousListStart;
+    const ends = [];
+    for (let index = 0; index < kept; index++)
+        ends.push(previousList.ends[index] + shift);
+    let offset = head.byteLength + keptEnd - previousListStart;
+    for (const piece of fresh) {
+        offset += piece.byteLength;
+        ends.push(offset);
+    }
+    const bytes = offset + tail.byteLength;
+    // The bytes from `cleanFrom` to `cleanTo` are the previous run's bytes at the same offsets.
+    let cleanFrom = Number.POSITIVE_INFINITY;
+    let cleanTo = 0;
+    if (previousArg && head.byteLength === previousArg.head.byteLength) {
+        cleanFrom = head.equals(previousArg.head) ? 0 : head.byteLength;
+        const listUnchanged = previousList
+            ? kept === entries.length && kept === previousList.entries.length
+            : sourceArg.list === undefined && previousArg.list === undefined;
+        cleanTo = listUnchanged && tail.equals(previousArg.tail) ? bytes : keptEnd;
+    }
+    const count = Math.max(1, Math.ceil(bytes / flexPrivateChunkBytes));
+    const chunks = [];
+    const ranges = [];
+    for (let index = 0; index < count; index++) {
+        const start = index * flexPrivateChunkBytes;
+        const end = Math.min(start + flexPrivateChunkBytes, bytes);
+        const previousChunk = previousArg?.chunks[index];
+        if (previousChunk
+            && start >= cleanFrom
+            && end <= cleanTo
+            && Math.min(start + flexPrivateChunkBytes, previousArg.bytes) === end) {
+            chunks.push(previousChunk);
+        }
+        else {
+            chunks.push(undefined);
+            ranges.push({ index, start, end, data: Buffer.alloc(end - start) });
+        }
+    }
+    if (ranges.length > 0) {
+        fillRanges([
+            bufferSegment(head),
+            ...(kept > 0 ? [previousSegment(previousArg, previousListStart, keptEnd)] : []),
+            ...fresh.map(bufferSegment),
+            bufferSegment(tail),
+        ], ranges);
+        for (const range of ranges)
+            chunks[range.index] = mintArg(range.data);
+    }
+    for (const piece of fresh)
+        piece.fill(0);
+    return {
+        kind: 'sliced',
+        head,
+        ...(sourceArg.list ? { list: { key: sourceArg.list.key, entries, ends } } : {}),
+        tail,
+        bytes,
+        chunks: chunks,
+    };
+};
+/** The index of the last chunk that starts at or before piece `pieceArg`: the chunk holding it. */
+const chunkHolding = (chunksArg, pieceArg) => {
+    let low = 0;
+    let high = chunksArg.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >>> 1;
+        if (chunksArg[middle].first <= pieceArg)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+};
+const copyOf = (partsArg, bytesArg) => {
+    const data = Buffer.alloc(bytesArg);
+    let offset = 0;
+    for (const part of partsArg)
+        offset += part.copy(data, offset);
+    return data;
+};
+const updatePackedRun = (previousArg, sourceArg, mintArg) => {
+    const entries = sourceArg.entries;
+    const kept = previousArg ? sharedPrefix(entries, previousArg.entries) : 0;
+    if (previousArg && kept === entries.length && kept === previousArg.entries.length) {
+        return { ...previousArg, entries };
+    }
+    // Chunks end where the packing from the list's start ends them, so every chunk before the one
+    // holding the last kept piece stays; packing resumes at that chunk's start, where it began
+    // empty. A kept piece cut in slices ends its own chunks, so packing resumes after it.
+    const chunks = [];
+    let restart = 0;
+    let restartChunk;
+    if (previousArg && kept > 0) {
+        const holding = chunkHolding(previousArg.chunks, kept - 1);
+        const chunk = previousArg.chunks[holding];
+        if (chunk.sliced) {
+            chunks.push(...previousArg.chunks.slice(0, holding + 1));
+            restart = kept;
+        }
+        else {
+            chunks.push(...previousArg.chunks.slice(0, holding));
+            restart = chunk.first;
+            restartChunk = chunk;
+        }
+    }
+    const pieceBytes = previousArg ? previousArg.pieceBytes.slice(0, kept) : [];
+    let pending = [];
+    let pendingBytes = 0;
+    let pendingFirst = restart;
+    const fresh = [];
+    const flush = (endArg) => {
+        if (pending.length === 0)
+            return;
+        chunks.push({
+            chunk: mintArg(copyOf(pending, pendingBytes)),
+            first: pendingFirst,
+            end: endArg,
+            sliced: false,
+        });
+        pending = [];
+        pendingBytes = 0;
+    };
+    let keptOffset = 0;
+    for (let index = restart; index < entries.length; index++) {
+        let piece;
+        if (index < kept) {
+            const length = previousArg.pieceBytes[index];
+            piece = restartChunk.chunk.data.subarray(keptOffset, keptOffset + length);
+            keptOffset += length;
+        }
+        else {
+            piece = Buffer.from(`${index === 0 ? '' : ','}${JSON.stringify(entries[index])}`, 'utf8');
+            pieceBytes.push(piece.byteLength);
+            fresh.push(piece);
+        }
+        if (pendingBytes > 0 && pendingBytes + piece.byteLength > privateListChunkBytes)
+            flush(index);
+        if (piece.byteLength <= flexPrivateChunkBytes - pendingBytes) {
+            if (pending.length === 0)
+                pendingFirst = index;
+            pending.push(piece);
+            pendingBytes += piece.byteLength;
+            continue;
+        }
+        flush(index);
+        for (let offset = 0; offset < piece.byteLength; offset += flexPrivateChunkBytes) {
+            chunks.push({
+                chunk: mintArg(copyOf([piece.subarray(offset, Math.min(offset + flexPrivateChunkBytes, piece.byteLength))], Math.min(flexPrivateChunkBytes, piece.byteLength - offset))),
+                first: index,
+                end: index + 1,
+                sliced: true,
+            });
+        }
+    }
+    flush(entries.length);
+    for (const piece of fresh)
+        piece.fill(0);
+    return { kind: 'packed', key: sourceArg.key, entries, pieceBytes, chunks };
+};
+/** The candidate and chunk documents that store `snapshot`, and the layout they leave. */
+export const buildFlexPrivateSnapshot = (optionsArg) => {
+    const owner = optionsArg.owner;
+    const key = ownerKey(owner);
+    const previous = optionsArg.previous?.owner === key ? optionsArg.previous : undefined;
+    const minted = [];
+    const mint = (dataArg) => {
+        const digest = sha256(dataArg);
+        const chunk = {
+            id: privateChunkDocumentId(owner, digest),
+            sha256: digest,
+            bytes: dataArg.byteLength,
+            data: dataArg,
+            holders: 0,
+        };
+        minted.push(chunk);
+        return chunk;
+    };
+    try {
+        const previousPacked = new Map();
+        const previousSliced = [];
+        for (const run of previous?.runs ?? []) {
+            if (run.kind === 'packed')
+                previousPacked.set(run.key, run);
+            else
+                previousSliced.push(run);
+        }
+        let slicedIndex = 0;
+        const runs = describeRuns(optionsArg.snapshot, owner.domain).map((source) => (source.kind === 'packed'
+            ? updatePackedRun(previousPacked.get(source.key), source, mint)
+            : updateSlicedRun(previousSliced[slicedIndex++], source, mint)));
+        const chunks = runs.flatMap((run) => (run.kind === 'packed' ? run.chunks.map((entry) => entry.chunk) : run.chunks));
+        if (chunks.length === 0)
+            chunks.push(mint(Buffer.alloc(0)));
+        // The whole-snapshot digest: one pass over the chunks' bytes, never joined into one buffer.
+        const hash = plugins.crypto.createHash('sha256');
+        let bytes = 0;
+        for (const chunk of chunks) {
+            hash.update(chunk.data);
+            bytes += chunk.bytes;
+        }
+        const digest = hash.digest('hex');
+        const identity = {
+            domain: owner.domain,
+            incarnationId: owner.incarnationId,
+            ...(owner.sessionId !== undefined ? { sessionId: owner.sessionId } : {}),
+            ...(owner.archiveId !== undefined ? { archiveId: owner.archiveId } : {}),
+        };
+        const made = new Set(minted);
+        const documents = [];
+        chunks.forEach((chunk, index) => {
+            if (!made.has(chunk) || optionsArg.sharedChunkIds.has(chunk.id))
+                return;
+            documents.push({
+                id: chunk.id,
+                controllerId: owner.controllerId,
+                scopeId: owner.storageKey,
+                candidateId: optionsArg.candidateId,
+                revision: optionsArg.revision,
+                index,
+                sha256: chunk.sha256,
+                bytes: chunk.bytes,
+                data: chunk.data.toString('base64'),
+                createdAt: optionsArg.createdAt,
+                ...identity,
+            });
+        });
+        const candidate = {
+            id: privateCandidateDocumentId(optionsArg.candidateId),
+            controllerId: owner.controllerId,
+            scopeId: owner.storageKey,
+            candidateId: optionsArg.candidateId,
+            revision: optionsArg.revision,
+            sha256: digest,
+            bytes,
+            chunks: chunks.map(({ id, sha256: chunkDigest, bytes: chunkBytes }, index) => ({
+                id, index, sha256: chunkDigest, bytes: chunkBytes,
+            })),
+            createdAt: optionsArg.createdAt,
+            ...identity,
+        };
+        assertFlexPrivateCandidateDocument(candidate);
+        for (const document of documents)
+            assertFlexPrivateChunkDocument(document);
+        return {
+            layout: { owner: key, runs, chunks, bytes, sha256: digest },
+            candidate,
+            chunks: documents,
+            minted,
+        };
+    }
+    catch (errorArg) {
+        for (const chunk of minted)
+            chunk.data.fill(0);
+        throw errorArg;
+    }
+};
+/** Marks the layout's chunks as held by one more cached snapshot. */
+export const holdFlexPrivateLayout = (layoutArg) => {
+    for (const chunk of new Set(layoutArg.chunks))
+        chunk.holders += 1;
+};
+/**
+ * Ends one cached snapshot's hold on the layout: zeroes its own run frames and the chunks no
+ * layout holds now.
+ */
+export const releaseFlexPrivateLayout = (layoutArg) => {
+    for (const chunk of new Set(layoutArg.chunks)) {
+        chunk.holders -= 1;
+        if (chunk.holders <= 0) {
+            chunk.holders = 0;
+            chunk.data.fill(0);
+        }
+    }
+    for (const run of layoutArg.runs) {
+        if (run.kind !== 'sliced')
+            continue;
+        run.head.fill(0);
+        run.tail.fill(0);
+    }
+};
+/** Zeroes the chunks no cached layout holds, such as those of a build that was not cached. */
+export const discardFlexPrivateChunks = (chunksArg) => {
+    for (const chunk of chunksArg) {
+        if (chunk.holders === 0)
+            chunk.data.fill(0);
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"functions.flexprivatesnapshot.js","sourceRoot":"","sources":["../../ts/functions.flexprivatesnapshot.ts"],"names":[],"mappings":"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"}

package/dist_ts/functions.inferencecli.d.ts

@@ -3,9 +3,10 @@ import type { IAglProxyStatus } from './classes.proxycontrol.js';
 type TAccountPlacementKey = 'lifecycle' | 'lapsesAt' | 'placementScore' | 'placementRank' | 'lastResort';
 /**
  * The status a running proxy answers with: one started from an AGL before 38.3.0 reports no accounts and no usage
- * observations, and one before 38.4.0 no lifecycle, placement or placement journal.
+ * observations, one before 38.4.0 no lifecycle, placement or placement journal, and one before confined runs neither
+ * its confined listener nor its runs.
  */
-export type TReportedProxyStatus = Omit<IAglProxyStatus, 'accounts' | 'usageObservations' | 'nextPlacement' | 'recentPlacements'> & Partial<Pick<IAglProxyStatus, 'usageObservations' | 'nextPlacement' | 'recentPlacements'>> & {
+export type TReportedProxyStatus = Omit<IAglProxyStatus, 'accounts' | 'usageObservations' | 'nextPlacement' | 'recentPlacements' | 'confinedSocketPath' | 'confinedRuns'> & Partial<Pick<IAglProxyStatus, 'usageObservations' | 'nextPlacement' | 'recentPlacements' | 'confinedSocketPath' | 'confinedRuns'>> & {
     accounts?: Array<Omit<IAglProxyStatus['accounts'][number], TAccountPlacementKey> & Partial<Pick<IAglProxyStatus['accounts'][number], TAccountPlacementKey>>>;
 };
 export declare const formatProxyStatus: (unitArg: string, statusArg: TReportedProxyStatus | undefined) => string;