agl 1.0.17 → 21.0.2

package/dist_ts_migration/v1_embeddeddatabaselocation.d.ts

@@ -0,0 +1,28 @@
+import * as plugins from '../dist_ts/plugins.js';
+export interface IEmbeddedDatabaseLocationMigrationOptions {
+    sourceDirectory: string;
+    destinationDirectory: string;
+    sourceSocketPath: string;
+    destinationSocketPath: string;
+}
+export interface IEmbeddedDatabaseLocationMigrationResult {
+    localDb: plugins.smartdb.LocalSmartDb;
+    connectionUri: string;
+}
+export interface IRebaseCompletedEmbeddedDatabaseLocationMigrationOptions {
+    sourceDirectory: string;
+    previousDestinationDirectory: string;
+    destinationDirectory: string;
+}
+export declare const rebaseCompletedEmbeddedDatabaseLocationMigration: (optionsArg: IRebaseCompletedEmbeddedDatabaseLocationMigrationOptions) => Promise<void>;
+export declare class EmbeddedDatabaseLocationMigration {
+    private readonly options;
+    private readonly journalPath;
+    private sourceDb?;
+    private importDestinationDb?;
+    private operationalDestinationDb?;
+    constructor(options: IEmbeddedDatabaseLocationMigrationOptions);
+    get hasOwnedResources(): boolean;
+    stop(): Promise<void>;
+    run(): Promise<IEmbeddedDatabaseLocationMigrationResult | undefined>;
+}

package/dist_ts_migration/v1_embeddeddatabaselocation.js

@@ -0,0 +1,415 @@
+import * as plugins from '../dist_ts/plugins.js';
+import { isSocketListening, } from '../dist_ts/functions.embeddeddb.js';
+const migrationVersion = 1;
+const journalFileName = '.smartdb-location-migration.json';
+const maximumJournalBytes = 16 * 1024;
+const directoryIdentity = async (directoryArg) => {
+    try {
+        const stats = await plugins.fs.promises.lstat(directoryArg, { bigint: true });
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+            throw new Error(`Controller database path must be a real directory: ${directoryArg}`);
+        }
+        return {
+            device: stats.dev.toString(10),
+            inode: stats.ino.toString(10),
+        };
+    }
+    catch (errorArg) {
+        if (errorArg.code === 'ENOENT')
+            return undefined;
+        throw errorArg;
+    }
+};
+const identitiesEqual = (leftArg, rightArg) => leftArg.device === rightArg.device && leftArg.inode === rightArg.inode;
+const assertExactKeys = (valueArg, expectedArg) => {
+    const actual = Object.keys(valueArg).sort();
+    const expected = [...expectedArg].sort();
+    if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+        throw new Error('The embedded database migration journal has unexpected fields.');
+    }
+};
+const parseJournal = (valueArg) => {
+    if (!valueArg || typeof valueArg !== 'object' || Array.isArray(valueArg)) {
+        throw new Error('The embedded database migration journal is malformed.');
+    }
+    const value = valueArg;
+    if (value.version !== migrationVersion) {
+        throw new Error('The embedded database migration journal version is unsupported.');
+    }
+    if (value.phase !== 'prepared' && value.phase !== 'completed') {
+        throw new Error('The embedded database migration journal phase is invalid.');
+    }
+    assertExactKeys(value, [
+        'version',
+        'phase',
+        'sourceDirectory',
+        'destinationDirectory',
+        'device',
+        'inode',
+        ...(value.phase === 'completed'
+            ? ['destinationDevice', 'destinationInode', 'contentDigestSha256']
+            : []),
+    ]);
+    for (const key of ['sourceDirectory', 'destinationDirectory', 'device', 'inode']) {
+        if (typeof value[key] !== 'string' || value[key].length === 0) {
+            throw new Error(`The embedded database migration journal ${key} is invalid.`);
+        }
+    }
+    if (!/^\d+$/.test(value.device)
+        || !/^\d+$/.test(value.inode)) {
+        throw new Error('The embedded database migration journal source identity is invalid.');
+    }
+    if (value.phase === 'completed') {
+        if (typeof value.destinationDevice !== 'string'
+            || !/^\d+$/.test(value.destinationDevice)
+            || typeof value.destinationInode !== 'string'
+            || !/^\d+$/.test(value.destinationInode)
+            || typeof value.contentDigestSha256 !== 'string'
+            || !/^[a-f0-9]{64}$/.test(value.contentDigestSha256)) {
+            throw new Error('The embedded database migration journal completion is invalid.');
+        }
+    }
+    return value;
+};
+const readJournal = async (journalPathArg) => {
+    let handle;
+    try {
+        handle = await plugins.fs.promises.open(journalPathArg, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NOFOLLOW);
+    }
+    catch (errorArg) {
+        if (errorArg.code === 'ENOENT')
+            return undefined;
+        throw errorArg;
+    }
+    try {
+        const stats = await handle.stat();
+        if (!stats.isFile() || stats.size < 2 || stats.size > maximumJournalBytes) {
+            throw new Error('The embedded database migration journal is not a bounded regular file.');
+        }
+        if (typeof process.getuid === 'function' && stats.uid !== process.getuid()) {
+            throw new Error('The embedded database migration journal is not owned by the current user.');
+        }
+        if ((stats.mode & 0o077) !== 0) {
+            throw new Error('The embedded database migration journal must not be group or world accessible.');
+        }
+        return parseJournal(JSON.parse(await handle.readFile('utf8')));
+    }
+    finally {
+        await handle.close();
+    }
+};
+const syncDirectory = async (directoryArg) => {
+    const handle = await plugins.fs.promises.open(directoryArg, plugins.fs.constants.O_RDONLY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+const writeJournal = async (journalPathArg, journalArg) => {
+    const parentDirectory = plugins.path.dirname(journalPathArg);
+    await plugins.fs.promises.mkdir(parentDirectory, { recursive: true, mode: 0o700 });
+    const parentStats = await plugins.fs.promises.lstat(parentDirectory);
+    if (!parentStats.isDirectory() || parentStats.isSymbolicLink()) {
+        throw new Error(`Controller data path must be a real directory: ${parentDirectory}`);
+    }
+    const temporaryPath = `${journalPathArg}.${process.pid}-${plugins.crypto.randomBytes(8).toString('hex')}.tmp`;
+    let handle;
+    try {
+        handle = await plugins.fs.promises.open(temporaryPath, plugins.fs.constants.O_WRONLY
+            | plugins.fs.constants.O_CREAT
+            | plugins.fs.constants.O_EXCL
+            | plugins.fs.constants.O_NOFOLLOW, 0o600);
+        await handle.writeFile(`${JSON.stringify(journalArg)}\n`, 'utf8');
+        await handle.sync();
+        await handle.close();
+        handle = undefined;
+        await plugins.fs.promises.rename(temporaryPath, journalPathArg);
+        await syncDirectory(parentDirectory);
+    }
+    catch (errorArg) {
+        if (handle)
+            await handle.close().catch(() => undefined);
+        await plugins.fs.promises.unlink(temporaryPath).catch(() => undefined);
+        throw errorArg;
+    }
+};
+const assertJournalMatches = (journalArg, optionsArg) => {
+    if (journalArg.sourceDirectory !== optionsArg.sourceDirectory
+        || journalArg.destinationDirectory !== optionsArg.destinationDirectory) {
+        throw new Error('The embedded database migration journal belongs to another migration.');
+    }
+};
+export const rebaseCompletedEmbeddedDatabaseLocationMigration = async (optionsArg) => {
+    const sourceDirectory = plugins.path.resolve(optionsArg.sourceDirectory);
+    const previousDestinationDirectory = plugins.path.resolve(optionsArg.previousDestinationDirectory);
+    const destinationDirectory = plugins.path.resolve(optionsArg.destinationDirectory);
+    const previousJournalPath = plugins.path.join(plugins.path.dirname(previousDestinationDirectory), journalFileName);
+    const destinationJournalPath = plugins.path.join(plugins.path.dirname(destinationDirectory), journalFileName);
+    const previous = await readJournal(previousJournalPath);
+    if (!previous || previous.phase !== 'completed') {
+        throw new Error('The embedded database migration journal is not completed for rebasing.');
+    }
+    assertJournalMatches(previous, {
+        sourceDirectory,
+        destinationDirectory: previousDestinationDirectory,
+        sourceSocketPath: '',
+        destinationSocketPath: '',
+    });
+    const destinationIdentity = await directoryIdentity(destinationDirectory);
+    if (!destinationIdentity || !identitiesEqual(destinationIdentity, {
+        device: previous.destinationDevice,
+        inode: previous.destinationInode,
+    })) {
+        throw new Error('The rebased embedded database directory identity does not match its journal.');
+    }
+    const rebased = {
+        ...previous,
+        destinationDirectory,
+        destinationDevice: destinationIdentity.device,
+        destinationInode: destinationIdentity.inode,
+    };
+    const existing = await readJournal(destinationJournalPath);
+    if (existing) {
+        if (existing.phase !== 'completed'
+            || existing.sourceDirectory !== rebased.sourceDirectory
+            || existing.destinationDirectory !== rebased.destinationDirectory
+            || existing.device !== rebased.device
+            || existing.inode !== rebased.inode
+            || existing.destinationDevice !== rebased.destinationDevice
+            || existing.destinationInode !== rebased.destinationInode
+            || existing.contentDigestSha256 !== rebased.contentDigestSha256) {
+            throw new Error('The rebased embedded database migration journal conflicts with its source.');
+        }
+        return;
+    }
+    await writeJournal(destinationJournalPath, rebased);
+    const persisted = await readJournal(destinationJournalPath);
+    if (!persisted
+        || persisted.phase !== 'completed'
+        || persisted.sourceDirectory !== rebased.sourceDirectory
+        || persisted.destinationDirectory !== rebased.destinationDirectory
+        || persisted.destinationDevice !== rebased.destinationDevice
+        || persisted.destinationInode !== rebased.destinationInode
+        || persisted.contentDigestSha256 !== rebased.contentDigestSha256) {
+        throw new Error('The rebased embedded database migration journal was not persisted.');
+    }
+};
+const databaseNamesFromCollections = (collectionsArg) => [...new Set(collectionsArg.map((collection) => collection.db))].sort();
+const assertDatabaseNamesMatch = (sourceArg, destinationArg) => {
+    if (sourceArg.length !== destinationArg.length
+        || sourceArg.some((databaseName, index) => databaseName !== destinationArg[index])) {
+        throw new Error('The migrated SmartDB root contains a different logical database set.');
+    }
+};
+const aggregateContentDigests = (digestsArg) => {
+    const hash = plugins.crypto.createHash('sha256');
+    for (const [databaseName, digest] of [...digestsArg.entries()].sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))) {
+        hash.update(databaseName, 'utf8');
+        hash.update('\0');
+        hash.update(digest.sha256, 'ascii');
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+};
+const assertCurrentStorageFormat = async (directoryArg) => {
+    const databaseEntries = await plugins.fs.promises.readdir(directoryArg, { withFileTypes: true });
+    for (const databaseEntry of databaseEntries) {
+        if (!databaseEntry.isDirectory() || databaseEntry.name.startsWith('.__rustdb_'))
+            continue;
+        const collectionEntries = await plugins.fs.promises.readdir(plugins.path.join(directoryArg, databaseEntry.name), { withFileTypes: true });
+        if (collectionEntries.some((entry) => (entry.isFile()
+            && entry.name.endsWith('.json')
+            && !entry.name.endsWith('.indexes.json')))) {
+            throw new Error(`The legacy controller database uses an old SmartDB storage format at ${directoryArg}. `
+                + 'Start it once with the previous controller version before upgrading.');
+        }
+    }
+};
+const assertDigestMatch = (sourceArg, destinationArg) => {
+    if (sourceArg.format !== destinationArg.format
+        || sourceArg.algorithm !== destinationArg.algorithm
+        || sourceArg.sha256 !== destinationArg.sha256
+        || sourceArg.scannedBsonBytes !== destinationArg.scannedBsonBytes
+        || sourceArg.collections !== destinationArg.collections
+        || sourceArg.documents !== destinationArg.documents
+        || sourceArg.indexes !== destinationArg.indexes) {
+        throw new Error('The migrated controller database content digest does not match its source.');
+    }
+};
+export class EmbeddedDatabaseLocationMigration {
+    options;
+    journalPath;
+    sourceDb;
+    importDestinationDb;
+    operationalDestinationDb;
+    constructor(options) {
+        this.options = options;
+        this.options = {
+            ...options,
+            sourceDirectory: plugins.path.resolve(options.sourceDirectory),
+            destinationDirectory: plugins.path.resolve(options.destinationDirectory),
+        };
+        this.journalPath = plugins.path.join(plugins.path.dirname(this.options.destinationDirectory), journalFileName);
+    }
+    get hasOwnedResources() {
+        return Boolean(this.sourceDb || this.importDestinationDb || this.operationalDestinationDb);
+    }
+    async stop() {
+        const errors = [];
+        for (const entry of [
+            ['operationalDestinationDb', this.operationalDestinationDb],
+            ['importDestinationDb', this.importDestinationDb],
+            ['sourceDb', this.sourceDb],
+        ]) {
+            const [key, database] = entry;
+            if (!database)
+                continue;
+            try {
+                await database.stop();
+                if (this[key] === database)
+                    this[key] = undefined;
+            }
+            catch (errorArg) {
+                errors.push(errorArg);
+            }
+        }
+        if (errors.length === 1)
+            throw errors[0];
+        if (errors.length > 1) {
+            throw new AggregateError(errors, 'Embedded database migration cleanup failed.');
+        }
+    }
+    async run() {
+        if (this.options.sourceDirectory === this.options.destinationDirectory)
+            return undefined;
+        let journal = await readJournal(this.journalPath);
+        if (journal)
+            assertJournalMatches(journal, this.options);
+        const sourceIdentity = await directoryIdentity(this.options.sourceDirectory);
+        const destinationIdentity = await directoryIdentity(this.options.destinationDirectory);
+        if (journal?.phase === 'completed') {
+            if (!destinationIdentity) {
+                throw new Error(`The migrated controller database is missing at ${this.options.destinationDirectory}. `
+                    + `The retained legacy backup at ${this.options.sourceDirectory} was not restored automatically.`);
+            }
+            if (!identitiesEqual(destinationIdentity, {
+                device: journal.destinationDevice,
+                inode: journal.destinationInode,
+            })) {
+                throw new Error('The migrated controller database directory identity has changed.');
+            }
+            return undefined;
+        }
+        if (!journal) {
+            if (!sourceIdentity)
+                return undefined;
+            if (destinationIdentity) {
+                throw new Error(`Both the legacy and current controller database directories exist: `
+                    + `${this.options.sourceDirectory} and ${this.options.destinationDirectory}. `
+                    + 'Refusing to choose between them without a migration journal.');
+            }
+            journal = {
+                version: migrationVersion,
+                phase: 'prepared',
+                sourceDirectory: this.options.sourceDirectory,
+                destinationDirectory: this.options.destinationDirectory,
+                ...sourceIdentity,
+            };
+            await writeJournal(this.journalPath, journal);
+            journal = await readJournal(this.journalPath);
+            if (!journal)
+                throw new Error('The embedded database migration journal was not persisted.');
+            assertJournalMatches(journal, this.options);
+        }
+        if (journal.phase !== 'prepared') {
+            throw new Error('The embedded database migration journal is not resumable.');
+        }
+        if (!sourceIdentity || !identitiesEqual(sourceIdentity, journal)) {
+            throw new Error('The legacy controller database directory identity has changed.');
+        }
+        if (await isSocketListening(this.options.sourceSocketPath)) {
+            throw new Error(`The legacy controller database is still in use at ${this.options.sourceDirectory}. `
+                + 'Stop the old controller before starting this version so its data can be migrated safely.');
+        }
+        await assertCurrentStorageFormat(this.options.sourceDirectory);
+        try {
+            this.sourceDb = new plugins.smartdb.LocalSmartDb({
+                folderPath: this.options.sourceDirectory,
+            });
+            await this.sourceDb.start();
+            const sourceServer = this.sourceDb.getServer();
+            const sourceDatabaseNames = databaseNamesFromCollections(await sourceServer.getCollections());
+            const sourceDigests = new Map();
+            this.importDestinationDb = new plugins.smartdb.LocalSmartDb({
+                folderPath: this.options.destinationDirectory,
+            });
+            await this.importDestinationDb.start();
+            const destinationServer = this.importDestinationDb.getServer();
+            for (const databaseName of sourceDatabaseNames) {
+                const exported = await sourceServer.exportDatabase({ databaseName });
+                const sourceDigest = await sourceServer.getDatabaseContentDigest({ databaseName });
+                const importResult = await destinationServer.importDatabase({
+                    databaseName,
+                    source: exported,
+                });
+                const destinationDigest = await destinationServer.getDatabaseContentDigest({ databaseName });
+                assertDigestMatch(sourceDigest, destinationDigest);
+                const exportedDocuments = exported.collections.reduce((sum, collection) => sum + collection.documents.length, 0);
+                const exportedIndexes = exported.collections.reduce((sum, collection) => sum + collection.indexes.length, 0);
+                if (importResult.collections !== exported.collections.length
+                    || importResult.documents !== exportedDocuments
+                    || sourceDigest.collections !== exported.collections.length
+                    || sourceDigest.documents !== exportedDocuments
+                    || sourceDigest.indexes !== exportedIndexes) {
+                    throw new Error(`The migrated database '${databaseName}' counts do not match its export.`);
+                }
+                sourceDigests.set(databaseName, sourceDigest);
+            }
+            assertDatabaseNamesMatch(sourceDatabaseNames, databaseNamesFromCollections(await destinationServer.getCollections()));
+            await this.importDestinationDb.stop();
+            this.importDestinationDb = undefined;
+            this.operationalDestinationDb = new plugins.smartdb.LocalSmartDb({
+                folderPath: this.options.destinationDirectory,
+                socketPath: this.options.destinationSocketPath,
+            });
+            const operationalConnection = await this.operationalDestinationDb.start();
+            const operationalServer = this.operationalDestinationDb.getServer();
+            assertDatabaseNamesMatch(sourceDatabaseNames, databaseNamesFromCollections(await operationalServer.getCollections()));
+            for (const [databaseName, sourceDigest] of sourceDigests) {
+                assertDigestMatch(sourceDigest, await operationalServer.getDatabaseContentDigest({ databaseName }));
+            }
+            const completedDestinationIdentity = await directoryIdentity(this.options.destinationDirectory);
+            if (!completedDestinationIdentity) {
+                throw new Error('The migrated controller database directory disappeared before completion.');
+            }
+            const completed = {
+                ...journal,
+                phase: 'completed',
+                destinationDevice: completedDestinationIdentity.device,
+                destinationInode: completedDestinationIdentity.inode,
+                contentDigestSha256: aggregateContentDigests(sourceDigests),
+            };
+            await writeJournal(this.journalPath, completed);
+            await this.sourceDb.stop();
+            this.sourceDb = undefined;
+            const result = {
+                localDb: this.operationalDestinationDb,
+                connectionUri: operationalConnection.connectionUri,
+            };
+            this.operationalDestinationDb = undefined;
+            return result;
+        }
+        catch (errorArg) {
+            try {
+                await this.stop();
+            }
+            catch (cleanupErrorArg) {
+                throw new AggregateError([errorArg, cleanupErrorArg], 'Embedded database migration failed and cleanup was incomplete.', { cause: errorArg });
+            }
+            throw errorArg;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v1_embeddeddatabaselocation.js","sourceRoot":"","sources":["../../ts_migration/v1_embeddeddatabaselocation.ts"],"names":[],"mappings":"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"}

package/dist_ts_migration/v22_projectfilesystemidentitymigration.d.ts

@@ -0,0 +1,7 @@
+import * as plugins from '../dist_ts/plugins.js';
+export declare class ProtocolV22ProjectFilesystemIdentityMigration {
+    private readonly database;
+    private readonly controllerId;
+    constructor(database: plugins.smartdata.SmartdataDb | undefined, controllerId: string);
+    run(): Promise<void>;
+}

package/dist_ts_migration/v22_projectfilesystemidentitymigration.js

@@ -0,0 +1,105 @@
+import * as plugins from '../dist_ts/plugins.js';
+import { assertControllerProjectDocument, ControllerProjectModel, } from '../dist_ts/classes.authmodels.js';
+import { CanonicalDirectoryError, resolveCanonicalDirectory, } from '../dist_ts/functions.canonicaldirectory.js';
+import { AuthError } from '../dist_ts/interfaces.auth.js';
+const migrationPageLimit = 128;
+const persistedBodyFromRawDocument = (valueArg) => {
+    const body = { ...valueArg };
+    delete body._id;
+    delete body._smartdataRevision;
+    return body;
+};
+const hasIdentityState = (valueArg) => Object.hasOwn(valueArg, 'directoryIdentityState');
+export class ProtocolV22ProjectFilesystemIdentityMigration {
+    database;
+    controllerId;
+    constructor(database, controllerId) {
+        this.database = database;
+        this.controllerId = controllerId;
+    }
+    async run() {
+        if (!this.database) {
+            throw new AuthError('not_initialized', 'The authentication store database is unavailable.');
+        }
+        const collection = ControllerProjectModel.collection.mongoDbCollection;
+        let lastId;
+        while (true) {
+            const cursor = collection.find({
+                controllerId: this.controllerId,
+                ...(lastId ? { _id: { $gt: lastId } } : {}),
+            }).sort({ _id: 1 }).limit(migrationPageLimit);
+            let documents;
+            try {
+                documents = await cursor.toArray();
+            }
+            finally {
+                await cursor.close();
+            }
+            for (const raw of documents) {
+                const body = persistedBodyFromRawDocument(raw);
+                if (body.directoryIdentityState === 'unbound')
+                    continue;
+                if (body.directoryIdentityState === 'bound'
+                    && Object.hasOwn(body, 'directoryIdentity')) {
+                    try {
+                        assertControllerProjectDocument(body);
+                        continue;
+                    }
+                    catch {
+                        // Pre-release leaf-only or incomplete bindings are terminally unbound below.
+                    }
+                }
+                const trulyLegacy = !hasIdentityState(body);
+                let identity;
+                if (trulyLegacy) {
+                    try {
+                        identity = await resolveCanonicalDirectory(String(body.directory));
+                    }
+                    catch (errorArg) {
+                        if (!(errorArg instanceof CanonicalDirectoryError))
+                            throw errorArg;
+                        identity = undefined;
+                    }
+                }
+                const migratedBody = { ...body };
+                delete migratedBody.directoryDevice;
+                delete migratedBody.directoryInode;
+                delete migratedBody.directoryIdentity;
+                const migrated = {
+                    ...migratedBody,
+                    directoryIdentityState: identity ? 'bound' : 'unbound',
+                    ...(identity ? { directoryIdentity: { ancestry: identity.ancestry } } : {}),
+                };
+                assertControllerProjectDocument(migrated);
+                const selector = raw._smartdataRevision === undefined
+                    ? { _id: raw._id, _smartdataRevision: { $exists: false } }
+                    : { _id: raw._id, _smartdataRevision: raw._smartdataRevision };
+                const replaced = await collection.findOneAndReplace(selector, { _id: raw._id, ...migrated, _smartdataRevision: plugins.crypto.randomUUID() }, { returnDocument: 'after', includeResultMetadata: false, upsert: false });
+                if (!replaced) {
+                    const concurrent = await collection.findOne({ _id: raw._id });
+                    const concurrentBody = concurrent
+                        ? persistedBodyFromRawDocument(concurrent)
+                        : undefined;
+                    let concurrentlyMigrated = false;
+                    if (concurrentBody && hasIdentityState(concurrentBody)) {
+                        try {
+                            assertControllerProjectDocument(concurrentBody);
+                            concurrentlyMigrated = true;
+                        }
+                        catch {
+                            concurrentlyMigrated = false;
+                        }
+                    }
+                    if (!concurrentlyMigrated) {
+                        throw new AuthError('concurrent_change', 'The project filesystem identity migration changed concurrently.');
+                    }
+                }
+            }
+            const last = documents.at(-1);
+            if (!last || documents.length < migrationPageLimit)
+                break;
+            lastId = last._id;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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