@loopress/cli 0.20.1 → 0.22.0

package/dist/config/project-config.manager.js

@@ -12,7 +12,7 @@ export class ProjectConfigManager {
         const base = toSlug(name, 'project');
         let id = base;
         let suffix = 2;
-        while (config.projects[id]) {
+        while (Object.hasOwn(config.projects, id)) {
             id = `${base}-${suffix}`;
             suffix++;
         }
@@ -100,7 +100,7 @@ export class ProjectConfigManager {
         const project = config.projects[projectId];
         if (!project)
             return;
-        delete project.environments[envName];
+        Reflect.deleteProperty(project.environments, envName);
         if (config.currentProject?.id === projectId && config.currentProject.env === envName) {
             const remaining = Object.keys(project.environments);
             config.currentProject = remaining.length > 0 ? { env: remaining[0], id: projectId } : null;
@@ -109,7 +109,7 @@ export class ProjectConfigManager {
     }
     removeProject(id) {
         const config = this.readConfig();
-        delete config.projects[id];
+        Reflect.deleteProperty(config.projects, id);
         if (config.currentProject?.id === id) {
             const [nextId] = Object.keys(config.projects);
             const nextProject = nextId ? config.projects[nextId] : undefined;
@@ -126,7 +126,7 @@ export class ProjectConfigManager {
     }
     setCurrent(projectId, envName) {
         const config = this.readConfig();
-        if (!config.projects[projectId])
+        if (!Object.hasOwn(config.projects, projectId))
             return;
         config.currentProject = { env: envName, id: projectId };
         this.writeConfig(config);
@@ -137,8 +137,7 @@ export class ProjectConfigManager {
         if (!project)
             return;
         project.environments[envName] = env;
-        if (!config.currentProject)
-            config.currentProject = { env: envName, id: projectId };
+        config.currentProject ??= { env: envName, id: projectId };
         this.writeConfig(config);
     }
     setEnvironmentApiId(projectId, envName, apiEnvironmentId) {

package/dist/lib/base.d.ts

@@ -1,6 +1,6 @@
 import { Command } from '@oclif/core';
-import { EnvironmentConfig } from '../types/config.js';
-import { LoopressLocalConfig } from '../utils/loopress-config.js';
+import { type EnvironmentConfig } from '../types/config.js';
+import { type LoopressLocalConfig } from '../utils/loopress-config.js';
 import { WpClient } from './wp-client.js';
 export declare abstract class LoopressCommand extends Command {
     static baseFlags: {
@@ -22,6 +22,14 @@ export declare abstract class LoopressCommand extends Command {
     protected get wp(): WpClient;
     init(): Promise<void>;
     protected maybeAutoRotate(): Promise<void>;
+    protected pullDirectory<T>(dir: string, items: T[], orphans: string[], options: {
+        alwaysCreateDir?: boolean;
+        dryRunMessage: string;
+        orphanReason: string;
+        pulledMessage: string;
+        title: (item: T) => string;
+        write: (item: T, dir: string) => Promise<void>;
+    }): Promise<void>;
     protected removeOrphanedFiles(dir: string, orphans: string[], reason: string): Promise<void>;
     protected resolveAcfPath(override?: string): string;
     protected resolveApiPath(override?: string): string;
@@ -31,4 +39,5 @@ export declare abstract class LoopressCommand extends Command {
     protected resolveSnippetsPath(override?: string): string;
     private pickEnvironment;
     private resolveEnvironment;
+    private resolveEnvironmentForConfiguredProject;
 }

package/dist/lib/base.js

@@ -1,9 +1,11 @@
 import { confirm } from '@inquirer/prompts';
 import { Command, Flags } from '@oclif/core';
-import { rm } from 'node:fs/promises';
+import { Listr } from 'listr2';
+import { mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
 import { configManager } from '../config/project-config.manager.js';
 import { readLocalConfig } from '../utils/loopress-config.js';
+import { pluralize } from '../utils/pluralize.js';
 import { isInteractive } from './interactive.js';
 import { isAppPasswordStale, rotateAppPassword } from './rotate-app-password.js';
 import { WpClient } from './wp-client.js';
@@ -45,6 +47,7 @@ export class LoopressCommand extends Command {
         const { flags } = (await this.parse({
             args: this.ctor.args,
             baseFlags: this.ctor.baseFlags,
+            enableJsonFlag: this.ctor.enableJsonFlag,
             flags: this.ctor.flags,
             strict: this.ctor.strict,
         }));
@@ -76,6 +79,31 @@ export class LoopressCommand extends Command {
             // swallowed: see comment above
         }
     }
+    // Shared shape of every resource's directory pull: write each item, then reconcile local
+    // files against the remote list (see removeOrphanedFiles above). `dryRunMessage` and
+    // `pulledMessage` are fully-formed by the caller (label pluralization varies per resource,
+    // e.g. ACF's `type` is a fixed category name, never pluralized), the "[dry-run] Would "
+    // prefix and the orphans notice are the only wording this method owns.
+    async pullDirectory(dir, items, orphans, options) {
+        if (this.dryRun) {
+            this.log(`[dry-run] ${options.dryRunMessage}`);
+            if (orphans.length > 0) {
+                this.log(`[dry-run] Would remove ${pluralize(orphans.length, 'local file')} ${options.orphanReason}: ${orphans.join(', ')}`);
+            }
+            return;
+        }
+        if (options.alwaysCreateDir === true || items.length > 0)
+            await mkdir(dir, { recursive: true });
+        await new Listr(items.map((item) => ({
+            async task(_ctx, task) {
+                await options.write(item, dir);
+                task.output = `Pulled: ${options.title(item)}`;
+            },
+            title: `Pull ${options.title(item)}`,
+        })), { renderer: this.jsonEnabled() ? 'silent' : 'default' }).run();
+        await this.removeOrphanedFiles(dir, orphans, options.orphanReason);
+        this.log(options.pulledMessage);
+    }
     // Orphan cleanup shared by every pull command (see Push Deletion Rules in the product docs):
     // in a TTY the list is shown and confirmed first (Enter accepts), --yes skips the prompt, and
     // outside a TTY the files are removed with a warning, the behavior scripts relied on before
@@ -83,10 +111,10 @@ export class LoopressCommand extends Command {
     async removeOrphanedFiles(dir, orphans, reason) {
         if (orphans.length === 0)
             return;
-        const description = `${orphans.length} local file${orphans.length === 1 ? '' : 's'} ${reason}: ${orphans.join(', ')}`;
+        const description = `${pluralize(orphans.length, 'local file')} ${reason}: ${orphans.join(', ')}`;
         if (!this.yes && isInteractive()) {
-            const proceed = await confirm({ default: true, message: `Remove ${description}?` });
-            if (!proceed) {
+            const isProceed = await confirm({ default: true, message: `Remove ${description}?` });
+            if (!isProceed) {
                 this.log(`Kept ${description}`);
                 return;
             }
@@ -142,26 +170,7 @@ export class LoopressCommand extends Command {
     }
     resolveEnvironment(envName) {
         if (this.localConfig.projectId) {
-            const { projectId } = this.localConfig;
-            const project = configManager.getProject(projectId);
-            if (!project) {
-                this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
-            }
-            const envNames = Object.keys(project.environments);
-            if (envNames.length === 0) {
-                this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
-            }
-            if (envName)
-                return { env: this.pickEnvironment(project, envName), projectId };
-            if (envNames.length === 1) {
-                return { env: project.environments[envNames[0]], projectId };
-            }
-            const current = configManager.getCurrentProject();
-            const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
-            if (!currentEnv) {
-                this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
-            }
-            return { env: currentEnv, projectId };
+            return this.resolveEnvironmentForConfiguredProject(this.localConfig.projectId, envName);
         }
         if (envName) {
             const current = configManager.getCurrentProject();
@@ -176,4 +185,25 @@ export class LoopressCommand extends Command {
             return { env, projectId: current.id };
         this.error('No environment configured. Run `lps project config` first.');
     }
+    resolveEnvironmentForConfiguredProject(projectId, envName) {
+        const project = configManager.getProject(projectId);
+        if (!project) {
+            this.error(`Project "${projectId}" (from loopress.json) not found. Run \`lps project config\` to configure it.`);
+        }
+        const envNames = Object.keys(project.environments);
+        if (envNames.length === 0) {
+            this.error(`Project "${project.name}" has no environments configured. Run \`lps project config\` to add one.`);
+        }
+        if (envName)
+            return { env: this.pickEnvironment(project, envName), projectId };
+        if (envNames.length === 1) {
+            return { env: project.environments[envNames[0]], projectId };
+        }
+        const current = configManager.getCurrentProject();
+        const currentEnv = current?.id === projectId ? configManager.getCurrentEnv() : null;
+        if (!currentEnv) {
+            this.error(`Project "${project.name}" has multiple environments. Run \`lps project switch\` to pick one.`);
+        }
+        return { env: currentEnv, projectId };
+    }
 }

package/dist/lib/bootstrap-full-install.d.ts

@@ -1,4 +1,4 @@
-import { WpClient } from './wp-client.js';
+import { type WpClient } from './wp-client.js';
 /**
  * Installs and activates Loopress Full on a site that doesn't have it yet: downloads the
  * latest release zip, creates a temporary admin (the only way to get `install_plugins` from

package/dist/lib/dev-watch.d.ts

@@ -0,0 +1,16 @@
+import { type LoopressLocalConfig } from '../utils/loopress-config.js';
+export type ResourceType = 'api' | 'pages' | 'plugins' | 'snippets';
+export declare const RESOURCE_TYPES: ResourceType[];
+export type WatchTarget = {
+    commandId: string;
+    path: string;
+    type: ResourceType;
+};
+export declare function resolveResourceTypes(only?: ResourceType[], skip?: ResourceType[]): ResourceType[];
+export declare function buildWatchTargets(types: ResourceType[], localConfig: LoopressLocalConfig, cwd: string): WatchTarget[];
+export declare function resourceTypeForPath(filePath: string, targets: WatchTarget[]): ResourceType | undefined;
+export type DebouncedBatcher = {
+    cancel: () => void;
+    queue: (path: string) => void;
+};
+export declare function createDebouncedBatcher(flush: (paths: string[]) => Promise<void>, debounceMs: number): DebouncedBatcher;

package/dist/lib/dev-watch.js

@@ -0,0 +1,71 @@
+import { existsSync } from 'node:fs';
+import { join, sep } from 'node:path';
+export const RESOURCE_TYPES = ['snippets', 'pages', 'api', 'plugins'];
+// `only` narrows the default set, `skip` then removes from whatever that set is, same
+// precedence a combined `--only=a,b --skip=b` reads as: watch a, b, then drop b.
+export function resolveResourceTypes(only, skip = []) {
+    const base = only && only.length > 0 ? only : RESOURCE_TYPES;
+    return base.filter((type) => !skip.includes(type));
+}
+// One target per requested type that actually has something to watch: a missing directory (no
+// `api/` folder yet) or an empty plugin manifest is left out silently, matching `push`'s own
+// directories which are all optional. `plugins` watches the whole `loopress.json` lockfile since
+// the plugin manifest is a field in it, not its own directory.
+export function buildWatchTargets(types, localConfig, cwd) {
+    const rootDir = join(cwd, localConfig.rootDir ?? '.');
+    const candidates = {
+        api: { commandId: 'api:push', path: join(rootDir, localConfig.apiDir ?? 'api'), type: 'api' },
+        pages: { commandId: 'page:push', path: join(rootDir, localConfig.pageDir ?? 'pages'), type: 'pages' },
+        plugins: { commandId: 'plugin:push', path: join(cwd, 'loopress.json'), type: 'plugins' },
+        snippets: { commandId: 'snippet:push', path: join(rootDir, localConfig.snippetsDir ?? 'snippets'), type: 'snippets' },
+    };
+    return types
+        .map((type) => candidates[type])
+        .filter((target) => {
+        if (target.type === 'plugins')
+            return Object.keys(localConfig.plugins ?? {}).length > 0;
+        return existsSync(target.path);
+    });
+}
+// A changed file belongs to whichever target's path is a prefix of it (directory targets) or
+// equals it (the `loopress.json` file target for `plugins`).
+export function resourceTypeForPath(filePath, targets) {
+    return targets.find((target) => filePath === target.path || filePath.startsWith(target.path + sep))?.type;
+}
+// Groups file events that land within `debounceMs` of each other into one `flush` call. If a
+// flush is still running when the timer fires again (a slow push outlasting the next debounce
+// window), the new paths just accumulate in `pending` instead of starting a second, overlapping
+// flush; once the in-flight one finishes it immediately flushes whatever queued up meanwhile.
+export function createDebouncedBatcher(flush, debounceMs) {
+    const pending = new Set();
+    let timer;
+    let isBusy = false;
+    const schedule = () => {
+        clearTimeout(timer);
+        timer = setTimeout(() => {
+            runFlush().catch(() => { });
+        }, debounceMs);
+    };
+    const runFlush = async () => {
+        if (isBusy || pending.size === 0)
+            return;
+        isBusy = true;
+        const paths = [...pending];
+        pending.clear();
+        try {
+            await flush(paths);
+        }
+        finally {
+            isBusy = false;
+            if (pending.size > 0)
+                schedule();
+        }
+    };
+    return {
+        cancel() { clearTimeout(timer); },
+        queue(path) {
+            pending.add(path);
+            schedule();
+        },
+    };
+}

package/dist/lib/find-orphaned-files.d.ts

@@ -1,7 +1,8 @@
-export interface OrphanMatcher {
+export type OrphanMatcher = {
     extensions: string[];
     key(base: string): null | string;
-}
+    recursive?: boolean;
+};
 export declare function findOrphanedFiles(dir: string, keep: Set<string>, matcher: OrphanMatcher): Promise<string[]>;
 export declare function numericPrefixKey(base: string): null | string;
 export declare function basenameKey(base: string): string;

package/dist/lib/find-orphaned-files.js

@@ -1,15 +1,51 @@
 import { readdir } from 'node:fs/promises';
-import { extname } from 'node:path';
-export async function findOrphanedFiles(dir, keep, matcher) {
-    let files;
+import { extname, join } from 'node:path';
+// Same shape as load-files.ts's own walker, kept separate rather than shared: this one
+// filters against a list of extensions (page/snippet pull need more than one), that one
+// against a single extension, and reconciling the two would cost more than the ~15 duplicated
+// lines it would save.
+async function walk(dir, extensions) {
+    let entries;
     try {
-        files = await readdir(dir);
+        entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
         if (error.code === 'ENOENT')
             return [];
         throw error;
     }
+    const relativePaths = [];
+    for (const entry of entries) {
+        if (entry.isDirectory()) {
+            // join() builds the real OS path to actually walk, but the returned identity is always
+            // '/'-joined regardless of platform: it's matched against `keep`, filenames the server
+            // sends with '/', never the OS separator. join() here (backslash on Windows) would make
+            // every nested file's identity never match, findOrphanedFiles() would then report a
+            // live, kept file as orphaned and pull.ts would delete it.
+            const nested = await walk(join(dir, entry.name), extensions);
+            relativePaths.push(...nested.map((relativePath) => `${entry.name}/${relativePath}`));
+        }
+        else if (extensions.includes(extname(entry.name))) {
+            relativePaths.push(entry.name);
+        }
+    }
+    return relativePaths;
+}
+export async function findOrphanedFiles(dir, keep, matcher) {
+    let files;
+    if (matcher.recursive) {
+        files = await walk(dir, matcher.extensions);
+    }
+    else {
+        try {
+            files = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+    }
     return files.filter((file) => {
         const ext = extname(file);
         if (!matcher.extensions.includes(ext))

package/dist/lib/github-release.js

@@ -22,7 +22,7 @@ export async function downloadLatestFullZip() {
         headers: { accept: 'application/vnd.github+json', 'user-agent': 'loopress-cli' },
         searchParams: { 'per_page': 30 },
     }).json();
-    const pluginRelease = releases.find((release) => RELEASE_TAG_PATTERN.test(release.tag_name));
+    const pluginRelease = releases.find((release) => release.tag_name.startsWith("wordpress-plugin@"));
     if (!pluginRelease) {
         throw new Error(`No "wordpress-plugin@*" release found in ${REPO}.`);
     }

package/dist/lib/guard-production-push.d.ts

@@ -0,0 +1,12 @@
+type GuardProductionPushOptions = {
+    dryRun: boolean;
+    error: (message: string) => never;
+    onRefuse?: () => void;
+    siteConfig: {
+        name: string;
+        url: string;
+    };
+    yes: boolean;
+};
+export declare function guardProductionPush(options: GuardProductionPushOptions): Promise<void>;
+export {};

package/dist/lib/guard-production-push.js

@@ -0,0 +1,20 @@
+import { confirm } from '@inquirer/prompts';
+import { isInteractive } from './interactive.js';
+// Pushing to an environment named "production" needs explicit intent: a TTY confirmation
+// (Enter accepts), or --yes in scripts and CI. Dry runs are exempt, they change nothing.
+// Shared by PushCommand (lib/push-command.ts, guards a single resource push) and the
+// top-level `lps push` (commands/push.ts, guards once before delegating to 8 sub-commands).
+export async function guardProductionPush(options) {
+    const { dryRun, error, onRefuse, siteConfig, yes } = options;
+    if (dryRun || yes || siteConfig.name.toLowerCase() !== 'production')
+        return;
+    if (!isInteractive()) {
+        onRefuse?.();
+        error('Target environment is "production". Pass --yes to confirm the push in a non-interactive run.');
+    }
+    const isProceed = await confirm({ default: true, message: `Push to production (${siteConfig.url})?` });
+    if (!isProceed) {
+        onRefuse?.();
+        error('Aborted.');
+    }
+}

package/dist/lib/interactive.js

@@ -3,5 +3,5 @@
 // Every command that prompts routes its decision through this so the CLI never hangs on a
 // question nobody can answer.
 export function isInteractive() {
-    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY) && !process.env.CI;
+    return process.stdin.isTTY && process.stdout.isTTY && !process.env.CI;
 }

package/dist/lib/load-files.d.ts

@@ -2,4 +2,5 @@ export declare function loadFiles<T>(dir: string, options: {
     extension: string;
     onSkip(message: string): void;
     parse(raw: string, filePath: string): T;
+    recursive?: boolean;
 }): Promise<T[]>;

package/dist/lib/load-files.js

@@ -1,25 +1,54 @@
 import { readdir, readFile } from 'node:fs/promises';
 import { extname, join } from 'node:path';
-// Loads every `<extension>` file of a flat directory through `parse`. One file is read in
-// isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
-// only skip that file, never abort loading the rest of the directory, so `parse` throwing is
-// reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
-// "nothing to load", not an error.
-export async function loadFiles(dir, options) {
+// Recursion for the api resource type only (path-param route files can live in
+// subdirectories, e.g. api/invoice-pdf/[order_id].php); every other resource type stays
+// flat. withFileTypes avoids a second stat() per entry to tell files from directories.
+async function walk(dir, extension) {
     let entries;
     try {
-        entries = await readdir(dir);
+        entries = await readdir(dir, { withFileTypes: true });
     }
     catch (error) {
         if (error.code === 'ENOENT')
             return [];
         throw error;
     }
-    const items = [];
+    const filePaths = [];
     for (const entry of entries) {
-        if (extname(entry) !== options.extension)
-            continue;
-        const filePath = join(dir, entry);
+        const entryPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            filePaths.push(...(await walk(entryPath, extension)));
+        }
+        else if (extname(entry.name) === extension) {
+            filePaths.push(entryPath);
+        }
+    }
+    return filePaths;
+}
+// Loads every `<extension>` file of a directory through `parse`. One file is read in
+// isolation: a corrupted or hand-broken file (unreadable, bad JSON, failed validation) must
+// only skip that file, never abort loading the rest of the directory, so `parse` throwing is
+// reported through `onSkip` and the loop moves on. ENOENT on the directory itself means
+// "nothing to load", not an error.
+export async function loadFiles(dir, options) {
+    let filePaths;
+    if (options.recursive) {
+        filePaths = await walk(dir, options.extension);
+    }
+    else {
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        filePaths = entries.filter((entry) => extname(entry) === options.extension).map((entry) => join(dir, entry));
+    }
+    const items = [];
+    for (const filePath of filePaths) {
         try {
             items.push(options.parse(await readFile(filePath, 'utf8'), filePath));
         }

package/dist/lib/load-snippets.d.ts

@@ -1,2 +1,2 @@
-import { Snippet } from '../types/snippet.js';
+import { type Snippet } from '../types/snippet.js';
 export declare function loadSnippets(path: string, onSkip?: (message: string) => void): Promise<Snippet[]>;

package/dist/lib/load-snippets.js

@@ -8,77 +8,84 @@ const TYPE_BY_EXTENSION = {
     '.php': 'php',
     '.txt': 'text',
 };
+// One snippet's files are read in isolation: a corrupted or hand-broken sidecar (bad JSON,
+// unreadable file, ...) must only skip that snippet, not abort loading every other one.
+async function loadSnippet(path, file, onSkip) {
+    const ext = extname(file);
+    if (!Object.hasOwn(TYPE_BY_EXTENSION, ext))
+        return undefined;
+    const filePath = join(path, file);
+    const metaPath = join(path, `${basename(file, ext)}.json`);
+    let content;
+    try {
+        content = await readFile(filePath, 'utf8');
+    }
+    catch (error) {
+        onSkip?.(`Skipping "${filePath}": ${error.message}`);
+        return undefined;
+    }
+    let id;
+    let name;
+    let type;
+    let isActive = false;
+    let tags = [];
+    let location = null;
+    let insertMethod = null;
+    let priority = 10;
+    let shortcodeAttributes = [];
+    try {
+        const metaContent = await readFile(metaPath, 'utf8');
+        const meta = JSON.parse(metaContent);
+        id = meta.id;
+        // `||`, not `??`: an empty-string name in the sidecar JSON counts as absent too.
+        // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+        name = meta.name || undefined;
+        type = parseType(meta.type) ?? undefined;
+        isActive = Boolean(meta.active);
+        tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
+        location = parseLocation(meta.location);
+        insertMethod = parseInsertMethod(meta.insertMethod);
+        priority = meta.priority ?? 10;
+        shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            onSkip?.(`Skipping "${metaPath}": ${error.message}`);
+            return undefined;
+        }
+    }
+    const resolvedType = type ?? (Object.hasOwn(TYPE_BY_EXTENSION, ext) ? TYPE_BY_EXTENSION[ext] : 'php');
+    return {
+        active: isActive,
+        code: content,
+        id,
+        insertMethod: insertMethod ?? 'auto',
+        location: location ?? defaultLocationForType(resolvedType),
+        name: name ?? basename(file, ext),
+        path: filePath,
+        priority,
+        shortcodeAttributes,
+        tags,
+        type: resolvedType,
+    };
+}
 // Shared by `snippet push` (pushes to the project's own WordPress site) and `snippet publish`
 // (publishes to the Loopress api as a shared source) — both read the same local `snippets/`
 // directory the same way. `onSkip` is optional so callers that don't care about per-file
 // warnings (e.g. `snippet publish`) can ignore them; skipped files are simply left out either way.
 export async function loadSnippets(path, onSkip) {
-    const snippets = [];
     let files;
     try {
         files = await readdir(path);
     }
     catch (error) {
-        throw new Error(`Error loading snippets: ${error.message}`);
+        throw new Error(`Error loading snippets: ${error.message}`, { cause: error });
     }
+    const snippets = [];
     for (const file of files) {
-        const ext = extname(file);
-        if (!(ext in TYPE_BY_EXTENSION))
-            continue;
-        const filePath = join(path, file);
-        const metaPath = join(path, `${basename(file, ext)}.json`);
-        // One snippet's files are read in isolation: a corrupted or hand-broken sidecar (bad JSON,
-        // unreadable file, ...) must only skip that snippet, not abort loading every other one.
-        let content;
-        try {
-            content = await readFile(filePath, 'utf8');
-        }
-        catch (error) {
-            onSkip?.(`Skipping "${filePath}": ${error.message}`);
-            continue;
-        }
-        let id;
-        let name;
-        let type;
-        let active = false;
-        let tags = [];
-        let location = null;
-        let insertMethod = null;
-        let priority = 10;
-        let shortcodeAttributes = [];
-        try {
-            const metaContent = await readFile(metaPath, 'utf8');
-            const meta = JSON.parse(metaContent);
-            id = meta.id === undefined ? undefined : Number(meta.id);
-            name = meta.name ? String(meta.name) : undefined;
-            type = parseType(meta.type) ?? undefined;
-            active = Boolean(meta.active);
-            tags = Array.isArray(meta.tags) ? meta.tags.map(String) : [];
-            location = parseLocation(meta.location);
-            insertMethod = parseInsertMethod(meta.insertMethod);
-            priority = meta.priority === undefined ? 10 : Number(meta.priority);
-            shortcodeAttributes = Array.isArray(meta.shortcodeAttributes) ? meta.shortcodeAttributes.map(String) : [];
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT') {
-                onSkip?.(`Skipping "${metaPath}": ${error.message}`);
-                continue;
-            }
-        }
-        const resolvedType = type ?? (ext in TYPE_BY_EXTENSION ? TYPE_BY_EXTENSION[ext] : 'php');
-        snippets.push({
-            active,
-            code: content,
-            id,
-            insertMethod: insertMethod ?? 'auto',
-            location: location ?? defaultLocationForType(resolvedType),
-            name: name ?? basename(file, ext),
-            path: filePath,
-            priority,
-            shortcodeAttributes,
-            tags,
-            type: resolvedType,
-        });
+        const snippet = await loadSnippet(path, file, onSkip);
+        if (snippet)
+            snippets.push(snippet);
     }
     return snippets;
 }