@loopress/cli 0.32.2 → 0.34.0

package/dist/lib/php-files-command.js

@@ -4,14 +4,18 @@ import { createHash } from 'node:crypto';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, relative, sep } from 'node:path';
 import { authManager } from '../config/auth.manager.js';
+import {} from '../types/config.js';
 import { firstTopLevelSideEffect, startsWithStrictTypes } from '../utils/php-top-level.js';
 import { pluralize } from '../utils/pluralize.js';
 import { resolveResourceDir, RESOURCE_DIR_DEFAULTS } from '../utils/resource-dirs.js';
 import { ApiClient } from './api-client.js';
 import { LoopressCommand } from './base.js';
+import {} from './diff-state.js';
+import { isExcluded } from './exclude.js';
 import { basenameKey, findOrphanedFiles } from './find-orphaned-files.js';
 import { isInteractive } from './interactive.js';
 import { loadFiles as loadDirectoryFiles } from './load-files.js';
+import { errorMessage } from './narrow.js';
 import { PushCommand } from './push-command.js';
 import { getResourceStateProvider } from './resource-state.js';
 import { isApplicative404 } from './wp-client.js';
@@ -82,7 +86,7 @@ export function resourcePushCommand(spec) {
         static enableJsonFlag = true;
         static examples = [
             `$ lps ${spec.cliName} push`,
-            `$ lps ${spec.cliName} push --path ./${RESOURCE_DIR_DEFAULTS[spec.dirKind]}`,
+            `$ lps ${spec.cliName} push ./${RESOURCE_DIR_DEFAULTS[spec.dirKind]}`,
             `$ lps ${spec.cliName} push --prune`,
         ];
         static flags = {
@@ -116,7 +120,7 @@ export function resourcePushCommand(spec) {
             // confirmation), but their removal itself happens inside the same atomic swap as the push
             // below, not as separate DELETE calls, so a mid-push failure can't remove server-side
             // files without also landing the new ones.
-            const pruneList = flags.prune ? await this.resolvePruneList(new Set(files.map((file) => file.filename))) : [];
+            const pruneList = flags.prune ? await this.resolvePruneList(new Set(files.map((file) => file.filename)), path) : [];
             if (this.dryRun) {
                 await this.writeAfterPushSnapshot(provider, path, beforeState);
                 return { changes: this.previewChanges, pruned: pruneList, pushed: files.map((file) => file.filename), status: 'dry-run' };
@@ -158,14 +162,14 @@ export function resourcePushCommand(spec) {
                 result = await this.wp.post(`${spec.endpoint}/batch`, body);
             }
             catch (error) {
-                this.error(`Push failed, nothing was changed on ${this.siteConfig.url}: ${error.message}`);
+                this.error(`Push failed, nothing was changed on ${this.siteConfig.url}: ${errorMessage(error)}`);
             }
             for (const file of result.files) {
                 this.log(file.syntax_check === 'skipped'
                     ? `Pushed: ${file.filename} (syntax check skipped, unavailable on this host)`
                     : `Pushed: ${file.filename}`);
                 if (file.public) {
-                    this.warn(`${file.filename}: PUBLIC route, no authentication required. Anyone on the internet can call it. See https://loopress.dev/api/routes/#authentication-and-permissions`);
+                    this.warn(`${file.filename}: PUBLIC route, no authentication required. Anyone on the internet can call it. See https://docs.loopress.dev/api/routes/#authentication-and-permissions`);
                 }
             }
             for (const filename of result.pruned)
@@ -178,9 +182,10 @@ export function resourcePushCommand(spec) {
         // local path in CI must not silently wipe production routes, and unlike `pull`'s local
         // deletions these are not recoverable from the repo. Only decides *which* filenames to
         // prune; pushBatch() is what actually removes them, atomically alongside the push.
-        async resolvePruneList(localFilenames) {
+        // A file excluded from this environment (loopress.json) is left alone, never pruned.
+        async resolvePruneList(localFilenames, path) {
             const remote = await this.wp.get(spec.endpoint);
-            const orphans = remote.map((file) => file.filename).filter((name) => !localFilenames.has(name));
+            const orphans = remote.map((file) => file.filename).filter((name) => !localFilenames.has(name) && !isExcluded(join(path, `${name}.php`)));
             if (orphans.length === 0)
                 return [];
             const summary = `${pluralize(orphans.length, spec.noun)} on ${this.siteConfig.url} not present locally: ${orphans.join(', ')}`;
@@ -216,7 +221,7 @@ export function resourcePullCommand(spec) {
         static args = pathArg(spec.pathNoun);
         static description = spec.pullDescription;
         static enableJsonFlag = true;
-        static examples = [`$ lps ${spec.cliName} pull`, `$ lps ${spec.cliName} pull --path ./${RESOURCE_DIR_DEFAULTS[spec.dirKind]}`];
+        static examples = [`$ lps ${spec.cliName} pull`, `$ lps ${spec.cliName} pull ./${RESOURCE_DIR_DEFAULTS[spec.dirKind]}`];
         static flags = { ...LoopressCommand.dryRunFlag, ...LoopressCommand.yesFlag };
         async run() {
             const { args } = await this.parse(ResourcePull);
@@ -294,7 +299,7 @@ export function resourceListCommand(spec) {
 }
 export function resourceRmCommand(spec) {
     class ResourceRm extends LoopressCommand {
-        // `remove` matches `lps app remove` and `lps option remove`, `rm` stays for existing scripts.
+        // `rm` is canonical everywhere, `remove` stays an alias for existing scripts.
         static aliases = [`${spec.cliName}:remove`];
         static args = {
             filename: Args.string({

package/dist/lib/plugin-detection.d.ts

@@ -6,4 +6,3 @@ import { type WpClient } from './wp-client.js';
  * see Loopress Full itself.
  */
 export declare function isLoopressFullActive(wp: WpClient): Promise<boolean>;
-export declare const INTEGRATION_MISSING: RegExp;

package/dist/lib/plugin-detection.js

@@ -1,3 +1,5 @@
+import {} from '../types/plugin.js';
+import {} from './wp-client.js';
 const FULL_PLUGIN_PREFIX = 'loopress-full/';
 /**
  * Checks `wp/v2/plugins` directly rather than through `parseInstalledPlugins`
@@ -9,7 +11,3 @@ export async function isLoopressFullActive(wp) {
     const plugins = await wp.get('wp/v2/plugins');
     return plugins.some((plugin) => plugin.plugin.startsWith(FULL_PLUGIN_PREFIX) && plugin.status === 'active');
 }
-// How the Loopress plugin reports a resource's integration missing: "ACF is not active", "No
-// supported form plugin is active", "No supported snippet plugin is active". Global Styles say a
-// classic theme is active. The aggregate commands skip such a resource the project doesn't use.
-export const INTEGRATION_MISSING = /\bis not active\b|\bNo supported .+ plugin is active\b|\bis a classic theme\b/;

package/dist/lib/push-command.d.ts

@@ -1,5 +1,6 @@
 import { LoopressCommand } from './base.js';
 import { type ResourceState } from './diff-state.js';
+import { type ScannedItem } from './environment-urls.js';
 import { type ResourceStateProvider } from './resource-state.js';
 export type PushChange = {
     id: string;
@@ -7,7 +8,7 @@ export type PushChange = {
 };
 export declare function pushChanges(local: ResourceState, remote: ResourceState, options?: {
     mirror?: boolean;
-    writes?: (id: string) => boolean;
+    writes?: ((id: string) => boolean) | undefined;
 }): PushChange[];
 export declare function logChanges(log: (message: string) => void, changes: Array<{
     id: string;
@@ -19,6 +20,7 @@ export declare abstract class PushCommand extends LoopressCommand {
         'production-confirmed': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
+    static honorsExclude: boolean;
     protected failedCount: number;
     protected previewChanges: PushChange[];
     protected previewStates?: {
@@ -28,6 +30,7 @@ export declare abstract class PushCommand extends LoopressCommand {
     private refusedByGuard;
     protected captureBeforePushState(provider: ResourceStateProvider, dir: string, writes?: (id: string) => boolean): Promise<ResourceState | undefined>;
     catch(err: Error): Promise<void>;
+    finally(error: Error | undefined): Promise<void>;
     protected guardProductionPush(): Promise<void>;
     init(): Promise<void>;
     protected previewRemote(provider: ResourceStateProvider, dir: string): Promise<ResourceState>;
@@ -40,6 +43,7 @@ export declare abstract class PushCommand extends LoopressCommand {
     protected runPushTasks<T>(items: T[], label: (item: T) => string, task: (item: T, task?: {
         output: string;
     }) => Promise<void>): Promise<void>;
+    protected warnEnvironmentUrls(items: ScannedItem[]): void;
     protected writeAfterPushSnapshot(provider: ResourceStateProvider, dir: string, beforeState: ResourceState | undefined): Promise<void>;
     private guardOutsideEdits;
 }

package/dist/lib/push-command.js

@@ -2,15 +2,37 @@ import { confirm } from '@inquirer/prompts';
 import { Flags } from '@oclif/core';
 import got from 'got';
 import { Listr } from 'listr2';
+import { execFileSync } from 'node:child_process';
 import { resolve } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { authManager } from '../config/auth.manager.js';
+import {} from '../types/config.js';
 import { API_URL } from './api-client.js';
 import { LoopressCommand } from './base.js';
+import {} from './diff-state.js';
+import { environmentUrlWarnings } from './environment-urls.js';
+import { heldBackPaths } from './exclude.js';
 import { guardProductionPush } from './guard-production-push.js';
 import { isInteractive } from './interactive.js';
+import { errorMessage } from './narrow.js';
+import {} from './resource-state.js';
 import { readSnapshot, recordToState, writeSnapshot } from './snapshot-store.js';
 import { withoutSpinner, withSpinner } from './spinner.js';
+// The Git state the deployment record carries: the HEAD commit and whether the working tree has
+// uncommitted changes. Empty outside a Git repository (or without git), so nothing is sent then.
+function gitState() {
+    try {
+        // eslint-disable-next-line sonarjs/no-os-command-from-path -- git is resolved from PATH like in every dev tool
+        const git = (args) => execFileSync('git', args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 2000 }).trim();
+        const commit = git(['rev-parse', 'HEAD']);
+        if (!commit)
+            return {};
+        return { commit, dirty: git(['status', '--porcelain', '--untracked-files=normal']) !== '' };
+    }
+    catch {
+        return {};
+    }
+}
 export function pushChanges(local, remote, options = {}) {
     const changes = [...local.keys()]
         .filter((id) => options.writes?.(id) ?? true)
@@ -40,6 +62,7 @@ export class PushCommand extends LoopressCommand {
         }),
         'production-confirmed': Flags.boolean({ hidden: true }),
     };
+    static honorsExclude = true;
     failedCount = 0;
     // A dry run's per-item preview, set by captureBeforePushState: what the push would create,
     // change or leave as it is on the site.
@@ -72,7 +95,7 @@ export class PushCommand extends LoopressCommand {
             catch (error) {
                 // The push reports the unreadable files itself, but an empty `changes` must not read as
                 // "nothing changes".
-                this.warn(`Could not list what this push would change: ${error.message}`);
+                this.warn(`Could not list what this push would change: ${errorMessage(error)}`);
             }
             logChanges((message) => { this.log(message); }, this.previewChanges);
             return undefined;
@@ -84,18 +107,29 @@ export class PushCommand extends LoopressCommand {
             }, dir);
         }
         catch (error) {
-            this.warn(`Could not read remote state for a rollback snapshot: ${error.message}`);
+            this.warn(`Could not read remote state for a rollback snapshot: ${errorMessage(error)}`);
             return undefined;
         }
         await this.guardOutsideEdits(provider, dir, remote, writes);
         return remote;
     }
     async catch(err) {
+        // Unset when init() failed before resolving the environment, despite its declared type.
         if (!this.dryRun && !this.refusedByGuard && this.siteConfig) {
             await this.recordDeployment('failure');
         }
         await super.catch(err);
     }
+    // Lists what the environment's `exclude` globs (loopress.json) kept out of this push, so a
+    // feature held back from it is never forgotten there.
+    async finally(error) {
+        const paths = error ? [] : heldBackPaths();
+        if (paths.length > 0) {
+            const prefix = this.dryRun ? '[dry-run] ' : '';
+            this.log(`${prefix}Held back from ${this.siteConfig.name} (exclude in loopress.json): ${paths.join(', ')}`);
+        }
+        await super.finally(error);
+    }
     async guardProductionPush() {
         await guardProductionPush({
             dryRun: this.dryRun,
@@ -120,7 +154,7 @@ export class PushCommand extends LoopressCommand {
             return await provider.remote(this.wp, () => { }, dir);
         }
         catch (error) {
-            this.error(`The site would refuse this push: ${error.message}`);
+            this.error(`The site would refuse this push: ${errorMessage(error)}`);
         }
     }
     async recordDeployment(status) {
@@ -130,7 +164,7 @@ export class PushCommand extends LoopressCommand {
         try {
             await withSpinner('Recording the deployment', async () => got.post(`${API_URL}/deployments`, {
                 headers: { Authorization: `Bearer ${token}` },
-                json: { status, url: this.siteConfig.url },
+                json: { status, url: this.siteConfig.url, command: this.id, ...gitState() },
                 timeout: { request: 3000 },
             }));
         }
@@ -186,12 +220,19 @@ export class PushCommand extends LoopressCommand {
             })), { concurrent: false, exitOnError: false, renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
         });
     }
+    // Absolute URLs to another environment of the project in what this push sends: warned about,
+    // never rewritten, on a dry run too.
+    warnEnvironmentUrls(items) {
+        const prefix = this.dryRun ? '[dry-run] ' : '';
+        for (const warning of environmentUrlWarnings(items, this.siteConfig, this.projectEnvironments))
+            this.warn(`${prefix}${warning}`);
+    }
     // Pairs `beforeState` (from captureBeforePushState, read before this push touched anything)
     // with a fresh remote read taken right after the push, and writes both as one rollback
     // snapshot. Reading the after-state from WordPress itself, rather than assuming it matches
     // the local files that were pushed, is what keeps this correct for every resource's own
     // partial-push semantics: a readonly option skipped by `option push`, a snippet or form
-    // that gets a server-assigned id on create, a theme-styles push that only touches the
+    // that gets a server-assigned id on create, a theme-style push that only touches the
     // active stylesheet, an API/hook push that leaves server-side files alone unless `--prune`.
     // `lps <resource> rollback`'s drift check compares the environment's state at rollback time
     // against exactly this after-state, so it has to be what actually landed, not what was sent.
@@ -211,7 +252,7 @@ export class PushCommand extends LoopressCommand {
             });
         }
         catch (error) {
-            this.warn(`Could not save a rollback snapshot after this push: ${error.message}`);
+            this.warn(`Could not save a rollback snapshot after this push: ${errorMessage(error)}`);
         }
     }
     // Refuses to silently overwrite a change made on the site outside Loopress (wp-admin, another
@@ -247,7 +288,7 @@ export class PushCommand extends LoopressCommand {
             local = await provider.local(dir, () => { }, this.wp);
         }
         catch (error) {
-            this.error(`Could not check for changes made on ${this.siteConfig.url} outside Loopress: ${error.message}. Retry, or pass --overwrite.`);
+            this.error(`Could not check for changes made on ${this.siteConfig.url} outside Loopress: ${errorMessage(error)}. Retry, or pass --overwrite.`);
         }
         const overwritten = [...local.keys()].filter((id) => (writes?.(id) ?? true) &&
             remote.get(id) !== undefined &&

package/dist/lib/put-or-create.d.ts

@@ -6,8 +6,8 @@ type PutOrCreateOptions = {
     postPayload?: Record<string, unknown>;
     putEndpoint: (id: number) => string;
 };
-export declare function putOrCreate<T>(wp: WpClient, options: PutOrCreateOptions): Promise<{
-    body: T;
+export declare function putOrCreate(wp: WpClient, options: PutOrCreateOptions): Promise<{
+    body: Record<string, unknown>;
     created: boolean;
 }>;
 export {};

package/dist/lib/readdir-tolerant.js

@@ -1,13 +1,18 @@
+import {} from 'node:fs';
 import { readdir, stat } from 'node:fs/promises';
-import { join, relative, sep } from 'node:path';
+import { join, relative, resolve, sep } from 'node:path';
+import { withoutExcluded } from './exclude.js';
+import { errorCode } from './narrow.js';
 export async function readdirTolerant(dir, options) {
     try {
+        // Excluded paths (lib/exclude.ts) are hidden here, so every resource listing through this
+        // helper leaves them out of a push or a diff on the environment that excludes them.
         return options?.withFileTypes
-            ? await readdir(dir, { recursive: options.recursive, withFileTypes: true })
-            : await readdir(dir, { recursive: options?.recursive });
+            ? withoutExcluded(dir, await readdir(dir, { recursive: options.recursive, withFileTypes: true }), (entry) => resolve(entry.parentPath, entry.name))
+            : withoutExcluded(dir, await readdir(dir, { recursive: options?.recursive }), (entry) => entry);
     }
     catch (error) {
-        if (error.code === 'ENOENT')
+        if (errorCode(error) === 'ENOENT')
             return [];
         throw error;
     }

package/dist/lib/resource-selection.d.ts

@@ -0,0 +1,9 @@
+import { Flags } from '@oclif/core';
+export declare const RESOURCE_IDS: readonly ["plugin", "composer", "cpt", "taxonomy", "meta", "role", "acf", "api", "hook", "block", "form", "pattern", "template", "part", "css", "theme-style", "page", "menu", "option", "snippet"];
+export type ResourceId = (typeof RESOURCE_IDS)[number];
+export declare function selectionFlags(noun: string, valid: readonly string[]): {
+    only: ReturnType<typeof Flags.string>;
+    skip: ReturnType<typeof Flags.string>;
+};
+export declare function parseSelectionFlag(raw: string[] | undefined, flagName: 'only' | 'skip', valid: readonly string[], fail: (message: string) => never): string[];
+export declare function selectResources<T extends string>(all: readonly T[], only?: readonly string[], skip?: readonly string[]): T[];

package/dist/lib/resource-selection.js

@@ -0,0 +1,49 @@
+import { Flags } from '@oclif/core';
+// One singular id per resource, shared by every command taking `--only` / `--skip`
+// (`lps dev`, `lps diff`, `lps push`). Each command accepts the subset it can act on.
+export const RESOURCE_IDS = [
+    'plugin',
+    'composer',
+    'cpt',
+    'taxonomy',
+    'meta',
+    'role',
+    'acf',
+    'api',
+    'hook',
+    'block',
+    'form',
+    'pattern',
+    'template',
+    'part',
+    'css',
+    'theme-style',
+    'page',
+    'menu',
+    'option',
+    'snippet',
+];
+// Comma-separated or repeated: `--only a,b`, `--only a --only b`, or both.
+export function selectionFlags(noun, valid) {
+    return {
+        only: Flags.string({ description: `Only ${noun} these resources (comma-separated or repeated): ${valid.join(', ')}`, multiple: true }),
+        skip: Flags.string({ description: `${noun.charAt(0).toUpperCase()}${noun.slice(1)} every resource except these (comma-separated or repeated)`, multiple: true }),
+    };
+}
+// Splits the raw flag values and rejects any id outside `valid`.
+export function parseSelectionFlag(raw, flagName, valid, fail) {
+    return (raw ?? [])
+        .flatMap((value) => value.split(','))
+        .map((value) => value.trim())
+        .filter(Boolean)
+        .map((value) => {
+        if (!valid.includes(value))
+            fail(`Unknown resource "${value}" in --${flagName}. Valid resources: ${valid.join(', ')}`);
+        return value;
+    });
+}
+// `only` narrows `all`, `skip` then removes from whatever that is, so a combined
+// `--only=a,b --skip=b` reads as: a, b, then drop b. The result always follows `all`'s order.
+export function selectResources(all, only = [], skip = []) {
+    return all.filter((id) => (only.length === 0 || only.includes(id)) && !skip.includes(id));
+}

package/dist/lib/resource-state.d.ts

@@ -3,6 +3,8 @@ import { type ResourceState } from './diff-state.js';
 import { type WpClient } from './wp-client.js';
 export type ResourceStateProvider = {
     dirKind: ResourceDirKind;
+    fileExtension?: string;
+    fileName?(id: string): string | undefined;
     local(dir: string, onWarn: (message: string) => void, wp?: WpClient): Promise<ResourceState>;
     remote(wp: WpClient, onWarn: (message: string) => void, dir: string): Promise<ResourceState>;
     resource: string;

package/dist/lib/resource-state.js

@@ -1,20 +1,24 @@
 import { readFile } from 'node:fs/promises';
 import { basename, join, relative, sep } from 'node:path';
 import { ACF_OBJECT_TYPES, acfEndpoint, acfNormalizeEndpoint, getAcfKey } from '../utils/acf-format.js';
+import { blockFilesToPush, BLOCKS_ENDPOINT, excludedBlockFiles, formatBlockProblems, readLocalBlocks } from '../utils/block-format.js';
 import { CPT_SPEC, fileExtension, META_SPEC, parseDeclaredFile, PATTERN_SPEC, ROLE_SPEC, TAXONOMY_SPEC, } from '../utils/declared-type-format.js';
 import { FORM_ENDPOINT, getFormId } from '../utils/form-format.js';
 import { getMenuSlug, MENU_ENDPOINT, MENU_LOCATIONS_ENDPOINT } from '../utils/menu-format.js';
 import { optionEndpoint, parseLocalOption } from '../utils/option-format.js';
 import { formatPageProblems, PAGES_ENDPOINT, readLocalHtmlFiles, readLocalPages } from '../utils/page-format.js';
+import {} from '../utils/resource-dirs.js';
 import { normalizeSnippet, SNIPPETS_ENDPOINT, stripPhpOpeningTag } from '../utils/snippet-format.js';
 import { CHILD_THEME_ENDPOINT, parsePartFile, parseTemplateFile, TEMPLATE_SLUG_RULE } from '../utils/template-format.js';
 import { canonicalGlobalStyles, getActiveThemeGlobalStyles, globalStylesEndpoint, THEME_STYLES_FILE_SUFFIX, } from '../utils/theme-styles-format.js';
+import {} from './diff-state.js';
 import { loadFiles } from './load-files.js';
 import { loadSnippets } from './load-snippets.js';
+import { causeOf, errorCode, isRecord } from './narrow.js';
 import { isApplicative404, isNotFoundError } from './wp-client.js';
 function readJson(raw) {
     const parsed = JSON.parse(raw);
-    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    if (!isRecord(parsed) || Array.isArray(parsed)) {
         throw new Error('not a JSON object');
     }
     return parsed;
@@ -59,7 +63,7 @@ const snippetProvider = {
         catch (error) {
             // A directory that was never created is "nothing tracked locally", the same tolerance
             // loadFiles/readdirTolerant already have; loadSnippets wraps the ENOENT in its own Error.
-            if (error.cause?.code === 'ENOENT')
+            if (errorCode(causeOf(error)) === 'ENOENT')
                 return state;
             throw error;
         }
@@ -87,6 +91,7 @@ const snippetProvider = {
 // stance as form-format.ts.
 const formProvider = {
     dirKind: 'form',
+    fileExtension: '.json',
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -133,6 +138,7 @@ async function normalizeAcf(wp, type, objects) {
 }
 const acfProvider = {
     dirKind: 'acf',
+    fileExtension: '.json',
     async local(dir, onWarn, wp) {
         const state = new Map();
         for (const type of ACF_OBJECT_TYPES) {
@@ -166,20 +172,21 @@ const acfProvider = {
     title: 'ACF',
 };
 // ---- PHP file directories (API routes, hooks) -----------------------------------------
+function filesToState(files) {
+    const state = new Map();
+    for (const file of files)
+        state.set(file.filename, file.content);
+    return state;
+}
 // api/ and hooks/ are both just a recursive directory of PHP files whose text is compared
 // verbatim (line diff on change), no server-side normalization to undo. Only the directory
 // kind, the endpoint and the labels differ.
 function phpFilesProvider(spec) {
-    const toState = (files) => {
-        const state = new Map();
-        for (const file of files)
-            state.set(file.filename, file.content);
-        return state;
-    };
     return {
         dirKind: spec.dirKind,
+        fileExtension: '.php',
         async local(dir, onWarn) {
-            return toState(await loadFiles(dir, {
+            return filesToState(await loadFiles(dir, {
                 extension: '.php',
                 onSkip: onWarn,
                 parse: (raw, filePath) => ({
@@ -190,7 +197,7 @@ function phpFilesProvider(spec) {
             }));
         },
         async remote(wp) {
-            return toState(await wp.get(spec.endpoint));
+            return filesToState(await wp.get(spec.endpoint));
         },
         resource: spec.resource,
         title: spec.title,
@@ -208,6 +215,30 @@ const hookProvider = phpFilesProvider({
     resource: 'hook',
     title: 'Hooks',
 });
+// ---- Dynamic blocks -------------------------------------------------------------------
+// Keyed by slug, compared on the whole folder (file name => text). A local problem fails the
+// resource, the same stance as pages: pushing would stop on it anyway.
+const blockProvider = {
+    dirKind: 'block',
+    // A block is a folder: only the bare `blocks/<slug>` path names a site-only block.
+    fileExtension: '',
+    // A file the environment excludes inside a block folder keeps the site's copy, as the push
+    // sends it back: without `wp`, that file is just left out.
+    async local(dir, _onWarn, wp) {
+        const { blocks, problems } = await readLocalBlocks(dir);
+        if (problems.length > 0)
+            throw new Error(formatBlockProblems(problems));
+        const withExcluded = wp !== undefined && blocks.some((block) => excludedBlockFiles(dir, block.slug).length > 0);
+        const site = withExcluded ? new Map((await wp.get(BLOCKS_ENDPOINT)).map((block) => [block.slug, block.files])) : undefined;
+        return new Map(blocks.map((block) => [block.slug, site ? blockFilesToPush(dir, block, site.get(block.slug)) : block.files]));
+    },
+    async remote(wp) {
+        const blocks = await wp.get(BLOCKS_ENDPOINT);
+        return new Map(blocks.map((block) => [block.slug, block.files]));
+    },
+    resource: 'block',
+    title: 'Dynamic blocks',
+};
 // ---- Pages ------------------------------------------------------------------------------
 // Keyed by slug (the page's identity on both sides). `link` is server-derived and never
 // compared. A local problem (a `.php` in pages/, a bad header) fails the whole resource rather
@@ -240,13 +271,16 @@ async function childThemeState(wp, kind) {
     const state = new Map(files.map(({ slug, ...rest }) => [slug, rest]));
     for (const entry of child.customized) {
         const [dir, slug] = entry.split('/', 2);
-        if (dir === kind)
-            state.set(slug, { ...state.get(slug), siteEditor: 'customized' });
+        if (dir === kind && slug !== undefined) {
+            const existing = state.get(slug);
+            state.set(slug, { ...(isRecord(existing) && existing), siteEditor: 'customized' });
+        }
     }
     return state;
 }
 const templateProvider = {
     dirKind: 'template',
+    fileExtension: '.html',
     async local(dir) {
         const { files, problems } = await readLocalHtmlFiles(dir, parseTemplateFile, TEMPLATE_SLUG_RULE);
         if (problems.length > 0)
@@ -259,6 +293,7 @@ const templateProvider = {
 };
 const partProvider = {
     dirKind: 'part',
+    fileExtension: '.html',
     async local(dir) {
         const { files, problems } = await readLocalHtmlFiles(dir, parsePartFile, TEMPLATE_SLUG_RULE);
         if (problems.length > 0)
@@ -287,6 +322,12 @@ function canonicalMenu(menu) {
 }
 const menuProvider = {
     dirKind: 'menu',
+    fileExtension: '.json',
+    fileName(id) {
+        if (id === MENU_LOCATIONS_FILE)
+            return `${id}.json`;
+        return id.startsWith('menu/') ? `${id.slice('menu/'.length)}.json` : undefined;
+    },
     async local(dir, onWarn) {
         const state = new Map();
         const entries = await loadFiles(dir, {
@@ -324,6 +365,7 @@ const menuProvider = {
 function declaredTypeProvider(spec, title) {
     return {
         dirKind: spec.dirKind,
+        fileExtension: fileExtension(spec),
         async local(dir, onWarn) {
             const entries = await loadFiles(dir, {
                 extension: fileExtension(spec),
@@ -353,6 +395,7 @@ const patternProvider = declaredTypeProvider(PATTERN_SPEC, 'Patterns');
 // sides so it can never itself show up as drift.
 const optionsProvider = {
     dirKind: 'options',
+    fileExtension: '.json',
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -398,6 +441,8 @@ const optionsProvider = {
 // individually rather than colliding on a single key.
 const themeStylesProvider = {
     dirKind: 'themeStyles',
+    fileExtension: '.json',
+    fileName: (stylesheet) => `${stylesheet}${THEME_STYLES_FILE_SUFFIX}`,
     async local(dir, onWarn) {
         const entries = await loadFiles(dir, {
             extension: '.json',
@@ -421,7 +466,7 @@ const themeStylesProvider = {
         const item = await wp.get(globalStylesEndpoint(id));
         return new Map([[stylesheet, canonicalGlobalStyles(item)]]);
     },
-    resource: 'theme-styles',
+    resource: 'theme-style',
     title: 'Theme styles',
 };
 export const RESOURCE_STATE_PROVIDERS = [
@@ -430,6 +475,7 @@ export const RESOURCE_STATE_PROVIDERS = [
     acfProvider,
     apiProvider,
     hookProvider,
+    blockProvider,
     templateProvider,
     partProvider,
     pageProvider,
@@ -476,7 +522,7 @@ export async function composerLocalState(rootDir) {
             state.set(file, await readFile(join(rootDir, file), 'utf8'));
         }
         catch (error) {
-            if (error.code !== 'ENOENT')
+            if (errorCode(error) !== 'ENOENT')
                 throw error;
         }
     }

package/dist/lib/rollback-command.d.ts

@@ -1,7 +1,7 @@
 import { LoopressCommand } from './base.js';
 import { type SnapshotSummary } from './snapshot-store.js';
 export type RollbackResult = {
-    drift?: {
+    drift?: undefined | {
         added: string[];
         changed: string[];
         removed: string[];

package/dist/lib/rollback-command.js

@@ -9,6 +9,7 @@ import { LoopressCommand } from './base.js';
 import { compareStates, isEmptyDiff } from './diff-state.js';
 import { guardProductionPush } from './guard-production-push.js';
 import { isInteractive } from './interactive.js';
+import { errorMessage } from './narrow.js';
 import { getResourceStateProvider } from './resource-state.js';
 import { materializeSnapshot } from './rollback-materialize.js';
 import { listSnapshots, readSnapshot, recordToState } from './snapshot-store.js';
@@ -33,7 +34,7 @@ function indentPatch(patch) {
 // anything, this runs the equivalent of `lps <resource> diff` between the environment's current
 // state and the state the original push expected to leave behind, and requires explicit
 // confirmation (the same interactive/`--yes` shape as guardProductionPush) when they differ.
-// `command` is the CLI topic when it isn't the resource key (e.g. `theme style` for theme-styles).
+// `command` is the CLI topic when it isn't the resource key (e.g. `theme style` for theme-style).
 export function resourceRollbackCommand(resource, options) {
     const command = options.command ?? resource;
     class ResourceRollback extends LoopressCommand {
@@ -69,7 +70,7 @@ export function resourceRollbackCommand(resource, options) {
                 snapshot = await readSnapshot(rootDir, resource, this.siteConfig.name, flags.to);
             }
             catch (error) {
-                this.error(error.message);
+                this.error(errorMessage(error));
             }
             await guardProductionPush({
                 dryRun: this.dryRun,
@@ -140,7 +141,7 @@ export function resourceRollbackCommand(resource, options) {
                 // A cleanup failure here must never hide a real error from the push above: warn about
                 // it and let the original error (if any) keep propagating instead of being replaced.
                 await rm(tmpDir, { force: true, recursive: true }).catch((error) => {
-                    this.warn(`Could not remove the temporary directory "${tmpDir}": ${error.message}`);
+                    this.warn(`Could not remove the temporary directory "${tmpDir}": ${errorMessage(error)}`);
                 });
             }
             this.log(`Rolled back ${provider.title} to the snapshot from ${snapshot.createdAt}.`);