@chronicle.app/facebook 0.4.0 → 0.5.0

package/README.md

@@ -33,7 +33,7 @@ chronicle extract facebook \
 
 The extractor supports the following options:
 
-- `--input` (required): Path to the facebook file
+- `--input` (required): The Facebook export, as a folder or zip
 - `--type` (required): What to read: `messages`, `reactions`, `comments`, or `searches`
 - `--since`: Extract records from this date onwards
 - `--until`: Extract records up to this date

package/dist/connectors/FacebookTransformer.js

@@ -34,10 +34,11 @@ export default class FacebookTransformer extends ChronicleTransformer {
             const messageAction = {
                 '@type': 'MessageAction',
                 timestamp: record.data.timestamp,
-                '@key': ['@type', 'source', 'timestamp', 'agent.name', 'object.body'],
+                '@key': ['@type', 'source', 'timestamp', 'agent.name', 'result.body'],
                 source: 'facebook',
                 agent: sender,
-                object: message,
+                // Sending makes the message, so it's the action's result.
+                result: message,
             };
             actions.push(messageAction);
         }

package/dist/connectors/archive/FacebookArchiveExtractor.d.ts

@@ -1,4 +1,4 @@
-import { ArchiveExtractor } from '@chronicle.app/etl';
+import { ArchiveExtractor, Record, type Survey, type SurveyOptions } from '@chronicle.app/etl';
 import { z } from 'zod';
 export declare abstract class FacebookArchiveExtractor extends ArchiveExtractor<typeof FacebookArchiveExtractor> {
     static source: string;
@@ -20,8 +20,12 @@ export declare abstract class FacebookArchiveExtractor extends ArchiveExtractor<
         until?: Date | undefined;
         limit?: number | undefined;
     }>;
+    protected readonly exportName = "Facebook export";
+    /** The export's segments, by their paths in it: `''` when the export is one. */
     protected exportSegments: string[];
     initialize(): Promise<void>;
+    /** Whether a file or folder is in the export. */
+    protected exists(path: string): Promise<boolean>;
     protected discoverExportSegments(): Promise<void>;
     protected loadAccountInfo(): Promise<any>;
     protected iterateExportSegments(): AsyncGenerator<{
@@ -29,6 +33,12 @@ export declare abstract class FacebookArchiveExtractor extends ArchiveExtractor<
         facebookDir: string;
         fullPath: string;
     }>;
+    /**
+     * A survey of records as a run reads them: each counted under its record
+     * type and dated by its `timestamp`, as the transformer dates its action.
+     * The export has no index, so every file is read, and only the tallies are kept.
+     */
+    protected surveyOf(records: AsyncIterable<Record>, options: SurveyOptions, each?: (record: Record) => void): Promise<Survey>;
     protected readFacebookJson(filePath: string): Promise<any>;
     protected convertFacebookTimestamp(timestamp: number): string;
     protected fixFacebookTextEncoding(text: string): string;

package/dist/connectors/archive/FacebookArchiveExtractor.js

@@ -1,54 +1,49 @@
-import { ArchiveExtractor, Extractor } from '@chronicle.app/etl';
-import { readFile, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
+import { ArchiveExtractor, Extractor, countMonth, } from '@chronicle.app/etl';
+import { posix } from 'node:path';
 import { z } from 'zod';
+// The folders a Facebook export starts with, beside its other sections.
+const SECTIONS = new Set(['personal_information/', 'your_facebook_activity/']);
 export class FacebookArchiveExtractor extends ArchiveExtractor {
     static source = 'facebook';
     static strategy = 'archive';
     static schema = Extractor.schema.extend({
-        input: z.string().describe('Path to the Facebook export directory'),
+        input: z.string().describe('The Facebook export, as a folder or zip'),
     });
+    exportName = 'Facebook export';
+    /** The export's segments, by their paths in it: `''` when the export is one. */
     exportSegments = [];
     async initialize() {
         await this.discoverExportSegments();
         this.accountInfo = await this.loadAccountInfo();
     }
+    /** Whether a file or folder is in the export. */
+    async exists(path) {
+        return (await this.files.has(path)) || (await this.files.children(path)).length > 0;
+    }
     async discoverExportSegments() {
-        const config = this.config;
-        try {
-            const entries = await readdir(config.input, { withFileTypes: true });
-            // Check if this is a new format export (direct structure)
-            const hasDirectStructure = entries.some(entry => entry.isDirectory() &&
-                (entry.name === 'personal_information' || entry.name === 'your_facebook_activity'));
-            if (hasDirectStructure) {
-                // New format: direct structure
-                this.exportSegments = [config.input];
-                // Detected new Facebook export format (direct structure)
-            }
-            else {
-                // Old format: Find all export segment directories (meta-* or facebook-*)
-                this.exportSegments = entries
-                    .filter(entry => entry.isDirectory())
-                    .map(entry => entry.name)
-                    .filter(name => name.startsWith('meta-') || name.startsWith('facebook-'))
-                    .map(name => join(config.input, name));
-                // Discovered export segments (legacy format)
-            }
-        }
-        catch {
-            // Could not discover export segments
-            this.exportSegments = [config.input]; // Fallback to input path
+        const entries = await this.files.children('');
+        // Check if this is a new format export (direct structure)
+        if (entries.some(entry => SECTIONS.has(entry))) {
+            // New format: direct structure
+            this.exportSegments = [''];
+            return;
         }
+        // Old format: Find all export segment directories (meta-* or facebook-*)
+        const segments = entries
+            .filter(entry => entry.endsWith('/'))
+            .map(entry => entry.slice(0, -1))
+            .filter(name => name.startsWith('meta-') || name.startsWith('facebook-'));
+        // Without any, fall back to the export's root
+        this.exportSegments = segments.length > 0 ? segments : [''];
     }
     async loadAccountInfo() {
         // Try to find account info in any of the segments
         for (const segmentPath of this.exportSegments) {
             try {
                 // Check for new format (direct structure)
-                const directProfilePath = join(segmentPath, 'personal_information', 'profile_information', 'profile_information.json');
+                const directProfilePath = posix.join(segmentPath, 'personal_information', 'profile_information', 'profile_information.json');
                 try {
-                    const content = await readFile(directProfilePath, 'utf-8');
-                    const data = JSON.parse(content);
+                    const data = await this.readFacebookJson(directProfilePath);
                     return {
                         name: data.profile_v2?.name?.full_name || data.profile_v2?.name?.value || 'unknown',
                         email: data.profile_v2?.emails?.emails?.[0] ||
@@ -64,15 +59,13 @@ export class FacebookArchiveExtractor extends ArchiveExtractor {
                     // Not new format, try legacy format
                 }
                 // Legacy format: look for facebook-* subdirectories
-                const entries = await readdir(segmentPath, { withFileTypes: true });
-                const facebookDirs = entries
-                    .filter(entry => entry.isDirectory() && entry.name.startsWith('facebook-'))
-                    .map(entry => entry.name);
+                const facebookDirs = (await this.files.children(segmentPath))
+                    .filter(entry => entry.endsWith('/') && entry.startsWith('facebook-'))
+                    .map(entry => entry.slice(0, -1));
                 for (const fbDir of facebookDirs) {
                     try {
-                        const personalInfoPath = join(segmentPath, fbDir, 'personal_information', 'profile_information', 'profile_information.json');
-                        const content = await readFile(personalInfoPath, 'utf-8');
-                        const data = JSON.parse(content);
+                        const personalInfoPath = posix.join(segmentPath, fbDir, 'personal_information', 'profile_information', 'profile_information.json');
+                        const data = await this.readFacebookJson(personalInfoPath);
                         return {
                             name: data.profile_v2?.name?.full_name || data.profile_v2?.name?.value || 'unknown',
                             email: data.profile_v2?.emails?.emails?.[0] ||
@@ -98,31 +91,50 @@ export class FacebookArchiveExtractor extends ArchiveExtractor {
     }
     async *iterateExportSegments() {
         for (const segmentPath of this.exportSegments) {
-            try {
-                // Check if this is new format (direct structure)
-                const entries = await readdir(segmentPath, { withFileTypes: true });
-                const hasDirectStructure = entries.some(entry => entry.isDirectory() &&
-                    (entry.name === 'personal_information' || entry.name === 'your_facebook_activity'));
-                if (hasDirectStructure) {
-                    // New format: yield the segment path directly
-                    yield { segmentPath, facebookDir: '', fullPath: segmentPath };
-                }
-                else {
-                    // Legacy format: look for facebook-* subdirectories
-                    const facebookDirs = entries
-                        .filter(entry => entry.isDirectory() && entry.name.startsWith('facebook-'))
-                        .map(entry => entry.name);
-                    for (const facebookDir of facebookDirs) {
-                        const fullPath = join(segmentPath, facebookDir);
-                        yield { segmentPath, facebookDir, fullPath };
-                    }
-                }
+            // Check if this is new format (direct structure)
+            const entries = await this.files.children(segmentPath);
+            if (entries.some(entry => SECTIONS.has(entry))) {
+                // New format: yield the segment path directly
+                yield { segmentPath, facebookDir: '', fullPath: segmentPath };
             }
-            catch {
-                // Could not read segment
+            else {
+                // Legacy format: look for facebook-* subdirectories
+                const facebookDirs = entries
+                    .filter(entry => entry.endsWith('/') && entry.startsWith('facebook-'))
+                    .map(entry => entry.slice(0, -1));
+                for (const facebookDir of facebookDirs) {
+                    const fullPath = posix.join(segmentPath, facebookDir);
+                    yield { segmentPath, facebookDir, fullPath };
+                }
             }
         }
     }
+    /**
+     * A survey of records as a run reads them: each counted under its record
+     * type and dated by its `timestamp`, as the transformer dates its action.
+     * The export has no index, so every file is read, and only the tallies are kept.
+     */
+    async surveyOf(records, options, each) {
+        const kind = () => ({ count: 0, ...(options.byMonth && { byMonth: {} }) });
+        const { recordTypes } = this.constructor;
+        const survey = Object.fromEntries(recordTypes.map(recordType => [recordType, kind()]));
+        for await (const record of records) {
+            each?.(record);
+            // A record without a type is its extractor's first, as `createRecord` gives it.
+            const counted = survey[record.extraction.recordType ?? recordTypes[0]];
+            counted.count++;
+            if (!record.data.timestamp)
+                continue;
+            const time = new Date(record.data.timestamp);
+            if (!counted.earliest || time < counted.earliest)
+                counted.earliest = time;
+            if (!counted.latest || time > counted.latest)
+                counted.latest = time;
+            if (counted.byMonth)
+                countMonth(counted.byMonth, time);
+        }
+        return survey;
+    }
     async readFacebookJson(filePath) {
         return this.readArchiveJson(filePath);
     }

package/dist/connectors/archive/FacebookArchiveMessagesExtractor.d.ts

@@ -1,4 +1,4 @@
-import { Record } from '@chronicle.app/etl';
+import { Record, type Survey, type SurveyOptions } from '@chronicle.app/etl';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export declare class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
@@ -7,6 +7,10 @@ export declare class FacebookArchiveMessagesExtractor extends FacebookArchiveExt
     static default: boolean;
     static defaultTransformer: typeof FacebookTransformer;
     extract(): AsyncGenerator<Record>;
+    /** The messages a run reads and when they were sent, with how many conversations they're in. */
+    survey(options?: SurveyOptions): Promise<Survey>;
+    /** Every message in the export, in the order a run reads them, before its limit. */
+    private messages;
     private extractMessagesFromSegment;
     private extractFromMessageFolder;
     private extractMessagesFromConversation;

package/dist/connectors/archive/FacebookArchiveMessagesExtractor.js

@@ -1,5 +1,4 @@
-import { readdir, stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { posix } from 'node:path';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
@@ -8,28 +7,36 @@ export class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
     static default = true;
     static defaultTransformer = FacebookTransformer;
     async *extract() {
+        let recordCount = 0;
+        for await (const record of this.messages()) {
+            yield record;
+            recordCount++;
+            if (this.shouldStopExtracting(recordCount)) {
+                return;
+            }
+        }
+    }
+    /** The messages a run reads and when they were sent, with how many conversations they're in. */
+    async survey(options = {}) {
+        const conversations = new Set();
+        const survey = await this.surveyOf(this.messages(), options, record => conversations.add(record.context.conversationId));
+        survey.messages.measures = [
+            { key: 'conversations', label: 'conversations', value: conversations.size },
+        ];
+        return survey;
+    }
+    /** Every message in the export, in the order a run reads them, before its limit. */
+    async *messages() {
         await this.initialize();
         const processedConversations = new Set();
-        let recordCount = 0;
         for await (const { fullPath } of this.iterateExportSegments()) {
-            for await (const record of this.extractMessagesFromSegment(fullPath, processedConversations)) {
-                yield record;
-                recordCount++;
-                if (this.shouldStopExtracting(recordCount)) {
-                    return;
-                }
-            }
+            yield* this.extractMessagesFromSegment(fullPath, processedConversations);
         }
     }
     async *extractMessagesFromSegment(segmentPath, processedConversations) {
-        const messagesPath = join(segmentPath, 'your_facebook_activity', 'messages');
-        try {
-            await stat(messagesPath);
-        }
-        catch {
-            // No messages directory found
-            return;
-        }
+        const messagesPath = posix.join(segmentPath, 'your_facebook_activity', 'messages');
+        if (!(await this.exists(messagesPath)))
+            return; // No messages directory found
         // Process different message types
         yield* this.extractFromMessageFolder(messagesPath, 'inbox', processedConversations);
         yield* this.extractFromMessageFolder(messagesPath, 'archived_threads', processedConversations);
@@ -37,24 +44,20 @@ export class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
         yield* this.extractFromMessageFolder(messagesPath, 'filtered_threads', processedConversations);
     }
     async *extractFromMessageFolder(messagesPath, folderName, processedConversations) {
-        const folderPath = join(messagesPath, folderName);
-        try {
-            await stat(folderPath);
-        }
-        catch {
+        const folderPath = posix.join(messagesPath, folderName);
+        if (!(await this.exists(folderPath)))
             return; // Folder doesn't exist in this segment
-        }
         try {
-            const conversations = await readdir(folderPath, { withFileTypes: true });
+            const conversations = await this.files.children(folderPath);
             for (const conversation of conversations) {
-                if (!conversation.isDirectory())
+                if (!conversation.endsWith('/'))
                     continue;
-                const conversationId = conversation.name;
+                const conversationId = conversation.slice(0, -1);
                 // Skip if already processed (avoid duplicates across segments)
                 if (processedConversations.has(conversationId)) {
                     continue;
                 }
-                const conversationPath = join(folderPath, conversationId);
+                const conversationPath = posix.join(folderPath, conversationId);
                 try {
                     yield* this.extractMessagesFromConversation(conversationPath, conversationId, folderName);
                     processedConversations.add(conversationId);
@@ -70,7 +73,7 @@ export class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
     }
     async *extractMessagesFromConversation(conversationPath, conversationId, threadType) {
         try {
-            const files = await readdir(conversationPath);
+            const files = await this.files.children(conversationPath);
             const messageFiles = files.filter(file => file.startsWith('message_') && file.endsWith('.json'));
             if (messageFiles.length === 0) {
                 // No message files found in conversation
@@ -83,7 +86,7 @@ export class FacebookArchiveMessagesExtractor extends FacebookArchiveExtractor {
                 return aNum - bNum;
             });
             for (const messageFile of messageFiles) {
-                const filePath = join(conversationPath, messageFile);
+                const filePath = posix.join(conversationPath, messageFile);
                 try {
                     const data = await this.readFacebookJson(filePath);
                     yield* this.processConversationData(data, conversationId, threadType);

package/dist/connectors/archive/FacebookArchiveReactionsExtractor.d.ts

@@ -1,4 +1,4 @@
-import { Record } from '@chronicle.app/etl';
+import { Record, type Survey, type SurveyOptions } from '@chronicle.app/etl';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export declare class FacebookArchiveReactionsExtractor extends FacebookArchiveExtractor {
@@ -13,6 +13,10 @@ export declare class FacebookArchiveReactionsExtractor extends FacebookArchiveEx
      */
     keyOf(record: Record): string | null;
     extract(): AsyncGenerator<Record>;
+    /** The reactions and comments a run reads, and when each was made. */
+    survey(options?: SurveyOptions): Promise<Survey>;
+    /** Every reaction and comment in the export, in the order a run reads them, before its limit. */
+    private reactionsAndComments;
     private extractReactionsFromSegment;
     private extractFromReactionsFile;
     private extractFromCommentsFile;

package/dist/connectors/archive/FacebookArchiveReactionsExtractor.js

@@ -1,5 +1,4 @@
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { posix } from 'node:path';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export class FacebookArchiveReactionsExtractor extends FacebookArchiveExtractor {
@@ -16,41 +15,40 @@ export class FacebookArchiveReactionsExtractor extends FacebookArchiveExtractor
         return record.data.fbid ?? null;
     }
     async *extract() {
+        let recordCount = 0;
+        for await (const record of this.reactionsAndComments()) {
+            yield record;
+            recordCount++;
+            if (this.shouldStopExtracting(recordCount)) {
+                return;
+            }
+        }
+    }
+    /** The reactions and comments a run reads, and when each was made. */
+    async survey(options = {}) {
+        return this.surveyOf(this.reactionsAndComments(), options);
+    }
+    /** Every reaction and comment in the export, in the order a run reads them, before its limit. */
+    async *reactionsAndComments() {
         await this.initialize();
         const processedReactions = new Set();
-        let recordCount = 0;
         for await (const { fullPath } of this.iterateExportSegments()) {
-            for await (const record of this.extractReactionsFromSegment(fullPath, processedReactions)) {
-                yield record;
-                recordCount++;
-                if (this.shouldStopExtracting(recordCount)) {
-                    return;
-                }
-            }
+            yield* this.extractReactionsFromSegment(fullPath, processedReactions);
         }
     }
     async *extractReactionsFromSegment(segmentPath, processedReactions) {
-        const reactionsPath = join(segmentPath, 'your_facebook_activity', 'comments_and_reactions');
-        try {
-            await stat(reactionsPath);
-        }
-        catch {
-            // No reactions directory found
-            return;
-        }
+        const reactionsPath = posix.join(segmentPath, 'your_facebook_activity', 'comments_and_reactions');
+        if (!(await this.exists(reactionsPath)))
+            return; // No reactions directory found
         // Process different reaction/comment files
         yield* this.extractFromReactionsFile(reactionsPath, 'likes_and_reactions.json', processedReactions);
         yield* this.extractFromReactionsFile(reactionsPath, 'likes_and_reactions_1.json', processedReactions);
         yield* this.extractFromCommentsFile(reactionsPath, 'comments.json', processedReactions);
     }
     async *extractFromReactionsFile(reactionsPath, fileName, processedReactions) {
-        const filePath = join(reactionsPath, fileName);
-        try {
-            await stat(filePath);
-        }
-        catch {
+        const filePath = posix.join(reactionsPath, fileName);
+        if (!(await this.exists(filePath)))
             return; // File doesn't exist
-        }
         try {
             const data = await this.readFacebookJson(filePath);
             if (Array.isArray(data)) {
@@ -68,13 +66,9 @@ export class FacebookArchiveReactionsExtractor extends FacebookArchiveExtractor
         }
     }
     async *extractFromCommentsFile(reactionsPath, fileName, processedReactions) {
-        const filePath = join(reactionsPath, fileName);
-        try {
-            await stat(filePath);
-        }
-        catch {
+        const filePath = posix.join(reactionsPath, fileName);
+        if (!(await this.exists(filePath)))
             return; // File doesn't exist
-        }
         try {
             const data = await this.readFacebookJson(filePath);
             if (data.comments_v2 && Array.isArray(data.comments_v2)) {

package/dist/connectors/archive/FacebookArchiveSearchHistoryExtractor.d.ts

@@ -1,4 +1,4 @@
-import { Record } from '@chronicle.app/etl';
+import { Record, type Survey, type SurveyOptions } from '@chronicle.app/etl';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export declare class FacebookArchiveSearchHistoryExtractor extends FacebookArchiveExtractor {
@@ -7,6 +7,10 @@ export declare class FacebookArchiveSearchHistoryExtractor extends FacebookArchi
     static default: boolean;
     static defaultTransformer: typeof FacebookTransformer;
     extract(): AsyncGenerator<Record>;
+    /** The searches a run reads, and when each was made. */
+    survey(options?: SurveyOptions): Promise<Survey>;
+    /** Every search in the export, in the order a run reads them, before its limit. */
+    private searches;
     private extractSearchHistoryFromSegment;
     private processSearchHistoryData;
     private parseSearchData;

package/dist/connectors/archive/FacebookArchiveSearchHistoryExtractor.js

@@ -1,5 +1,4 @@
-import { stat } from 'node:fs/promises';
-import { join } from 'node:path';
+import { posix } from 'node:path';
 import { FacebookArchiveExtractor } from './FacebookArchiveExtractor.js';
 import FacebookTransformer from '../FacebookTransformer.js';
 export class FacebookArchiveSearchHistoryExtractor extends FacebookArchiveExtractor {
@@ -8,28 +7,31 @@ export class FacebookArchiveSearchHistoryExtractor extends FacebookArchiveExtrac
     static default = false;
     static defaultTransformer = FacebookTransformer;
     async *extract() {
+        let recordCount = 0;
+        for await (const record of this.searches()) {
+            yield record;
+            recordCount++;
+            if (this.shouldStopExtracting(recordCount)) {
+                return;
+            }
+        }
+    }
+    /** The searches a run reads, and when each was made. */
+    async survey(options = {}) {
+        return this.surveyOf(this.searches(), options);
+    }
+    /** Every search in the export, in the order a run reads them, before its limit. */
+    async *searches() {
         await this.initialize();
         const processedSearches = new Set();
-        let recordCount = 0;
         for await (const { fullPath } of this.iterateExportSegments()) {
-            for await (const record of this.extractSearchHistoryFromSegment(fullPath, processedSearches)) {
-                yield record;
-                recordCount++;
-                if (this.shouldStopExtracting(recordCount)) {
-                    return;
-                }
-            }
+            yield* this.extractSearchHistoryFromSegment(fullPath, processedSearches);
         }
     }
     async *extractSearchHistoryFromSegment(segmentPath, processedSearches) {
-        const searchHistoryPath = join(segmentPath, 'logged_information', 'search', 'your_search_history.json');
-        try {
-            await stat(searchHistoryPath);
-        }
-        catch {
-            // No search history file found
-            return;
-        }
+        const searchHistoryPath = posix.join(segmentPath, 'logged_information', 'search', 'your_search_history.json');
+        if (!(await this.exists(searchHistoryPath)))
+            return; // No search history file found
         try {
             const data = await this.readFacebookJson(searchHistoryPath);
             yield* this.processSearchHistoryData(data, processedSearches);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chronicle.app/facebook",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
@@ -22,9 +22,9 @@
   "type": "module",
   "description": "Chronicle plugin for Chronicle plugin for facebook",
   "devDependencies": {
-    "@chronicle.app/etl": "0.4.0",
-    "@chronicle.app/schema": "0.4.0",
-    "@chronicle.app/tsconfig": "0.4.0",
+    "@chronicle.app/etl": "0.5.0",
+    "@chronicle.app/schema": "0.5.0",
+    "@chronicle.app/tsconfig": "0.5.0",
     "@types/node": "^22.10.1",
     "typescript": "^5.7.2"
   },
@@ -61,6 +61,14 @@
         "strategies": {
           "archive": {
             "delivery": "export",
+            "layouts": [
+              {
+                "files": [
+                  "personal_information/profile_information/profile_information.json",
+                  "your_facebook_activity"
+                ]
+              }
+            ],
             "recordTypes": [
               "messages",
               "reactions",