@musallam/aio-libs-local 0.1.0

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2025 Adobe. All rights reserved.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,189 @@
+# @musallam/aio-libs-local
+
+Local and in-memory stand-ins for [`@adobe/aio-lib-files`](https://github.com/adobe/aio-lib-files) and [`@adobe/aio-lib-state`](https://github.com/adobe/aio-lib-state), so App Builder code can run outside Adobe I/O Runtime (local dev, unit tests, CI) without changing call sites.
+
+## Install
+
+```bash
+pnpm add -D @musallam/aio-libs-local
+```
+
+npm and yarn work too:
+
+```bash
+npm i -D @musallam/aio-libs-local
+# yarn add -D @musallam/aio-libs-local
+```
+
+Peer dependencies on the real Adobe libs are optional — you only need them when running against Runtime or parity tests.
+
+## Quick start (recommended): build-time aliasing
+
+Keep imports as `@adobe/aio-lib-files` and `@adobe/aio-lib-state`; configure your bundler or test runner to swap them for this package locally. This avoids pulling `@azure/storage-blob` into local bundles.
+
+### Webpack (`aio app build`)
+
+```js
+// webpack.config.js
+const isLocal = process.env.TARGET === "local";
+
+module.exports = {
+  resolve: {
+    alias: isLocal
+      ? {
+          "@adobe/aio-lib-files": "@musallam/aio-libs-local/files",
+          "@adobe/aio-lib-state": "@musallam/aio-libs-local/state",
+        }
+      : {},
+  },
+};
+```
+
+### Vite
+
+```js
+import { defineConfig } from "vite";
+
+export default defineConfig(({ mode }) => ({
+  resolve: {
+    alias:
+      mode === "development"
+        ? {
+            "@adobe/aio-lib-files": "@musallam/aio-libs-local/files",
+            "@adobe/aio-lib-state": "@musallam/aio-libs-local/state",
+          }
+        : {},
+  },
+}));
+```
+
+### Vitest
+
+```js
+// vitest.config.ts
+import path from "node:path";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: { environment: "node" },
+  resolve: {
+    alias: {
+      "@adobe/aio-lib-files": path.resolve("node_modules/@musallam/aio-libs-local/dist/files.js"),
+      "@adobe/aio-lib-state": path.resolve("node_modules/@musallam/aio-libs-local/dist/state.js"),
+    },
+  },
+});
+```
+
+## Quick start (no bundler): `/auto` entry point
+
+For plain Node scripts, REPLs, or `ts-node` without a bundler:
+
+```js
+const { Files, State } = require("@musallam/aio-libs-local/auto");
+
+const files = await Files.init();
+const state = await State.init();
+```
+
+Detection uses `process.env.__OW_API_KEY` as the Runtime signal. Unset it in `.env.local` to force stubs. Use `forceLocal()` / `forceRuntime()` from the auto module to override in tests.
+
+**Do not use `/auto` under webpack, Vite, or esbuild** — the bundler will include both implementations.
+
+## Explicit imports
+
+```js
+const filesLib = process.env.__OW_API_KEY
+  ? require("@adobe/aio-lib-files")
+  : require("@musallam/aio-libs-local/files");
+
+const stateLib = process.env.__OW_API_KEY
+  ? require("@adobe/aio-lib-state")
+  : require("@musallam/aio-libs-local/state");
+```
+
+## Local persistence
+
+**State** — optional disk backing:
+
+```js
+const state = await require("@musallam/aio-libs-local/state").init({
+  persist: "./.aio-state",
+});
+```
+
+**Files** — filesystem root (default: `.aio-files/` in cwd):
+
+```js
+const files = await require("@musallam/aio-libs-local/files").init({
+  root: "./.aio-files",
+});
+```
+
+Paths under `public/` are treated as publicly accessible, matching the real Files lib.
+
+## Fidelity gaps
+
+| Area                  | Real lib         | This stub                                   |
+| --------------------- | ---------------- | ------------------------------------------- |
+| Presigned URLs        | Azure SAS URLs   | `file://` absolute paths                    |
+| State TTL max         | 365 days         | 30 days (configurable via `MAX_TTL`)        |
+| State infinite TTL    | Not supported    | `ttl: -1` supported locally                 |
+| Consistency           | Eventual (cloud) | Immediate (memory/disk)                     |
+| Multi-tenant / region | Yes              | No                                          |
+| Error messages        | Adobe SDK format | Same `code` values; message text may differ |
+| Rate limiting         | Yes              | No                                          |
+
+## Development
+
+This repo uses **pnpm**, [Oxlint](https://oxc.rs/docs/guide/usage/linter.html), and [Oxfmt](https://oxc.rs/docs/guide/usage/formatter.html). Git hooks (via [Husky](https://typicode.github.io/husky/)) run lint-staged on commit and [Commitlint](https://commitlint.js.org/) on commit messages (Conventional Commits).
+
+```bash
+pnpm install          # installs deps and sets up git hooks (prepare → husky)
+pnpm run lint         # oxlint
+pnpm run fmt          # format in place
+pnpm run fmt:check    # CI-style format check
+```
+
+## Testing
+
+This package uses [Vitest](https://vitest.dev/). Development uses **pnpm** (`pnpm install` once in the repo root).
+
+All tests run **offline** against the local stubs only — they never connect to Azure Blob Storage or OpenWhisk / Adobe State, even if you have cloud credentials in your environment.
+
+```bash
+pnpm test              # full suite (unit, contract, bundler smoke)
+pnpm run test:unit     # unit + contract tests (no bundler smoke)
+pnpm run test:bundler  # Vite + esbuild alias smoke tests
+pnpm run test:watch    # watch mode
+```
+
+npm equivalents: `npm test`, `npm run test:unit`, etc.
+
+## Releasing
+
+Releases are automated with [semantic-release](https://semantic-release.gitbook.io/) on push to `main` / `master` (see [.github/workflows/release.yml](.github/workflows/release.yml)).
+
+1. Use [Conventional Commits](https://www.conventionalcommits.org/) (`feat:`, `fix:`, `chore:`, etc.) — enforced by commitlint on every commit.
+2. Merge to `main`; the Release workflow runs tests, then:
+   - Bumps `package.json` version
+   - Updates `CHANGELOG.md`
+   - Creates a [GitHub Release](https://github.com/ahmed-musallam/aio-libs-local/releases)
+   - Publishes `@musallam/aio-libs-local` to npm with [provenance](https://docs.npmjs.com/generating-provenance-statements)
+
+### npm trusted publishing (one-time setup)
+
+No `NPM_TOKEN` secret is required. Configure [trusted publishing](https://docs.npmjs.com/trusted-publishers) on npm for the package (or the `@musallam` scope):
+
+| Field             | Value                                               |
+| ----------------- | --------------------------------------------------- |
+| Provider          | GitHub Actions                                      |
+| Repository        | `ahmed-musallam/aio-libs-local`                     |
+| Workflow filename | `release.yml`                                       |
+| Environment       | _(leave empty unless you use a GitHub Environment)_ |
+
+Ensure the `@musallam` scope exists on npm and allows public packages (`publishConfig.access` is `public`). The workflow sets `id-token: write` for OIDC; do **not** set `registry-url` on `setup-node` in the release workflow.
+
+## License
+
+Apache-2.0

package/dist/auto.d.ts

@@ -0,0 +1,8 @@
+import type * as RealFiles from "@adobe/aio-lib-files";
+import type * as RealState from "@adobe/aio-lib-state";
+export declare function forceLocal(): void;
+export declare function forceRuntime(): void;
+export declare function resetForce(): void;
+/** Lazy proxy so forceLocal/forceRuntime apply on each access */
+export declare const Files: typeof RealFiles;
+export declare const State: typeof RealState;

package/dist/auto.js

@@ -0,0 +1,49 @@
+"use strict";
+/* aio-libs-local stub */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.State = exports.Files = void 0;
+exports.forceLocal = forceLocal;
+exports.forceRuntime = forceRuntime;
+exports.resetForce = resetForce;
+let forceMode = null;
+function forceLocal() {
+    forceMode = "local";
+}
+function forceRuntime() {
+    forceMode = "runtime";
+}
+function resetForce() {
+    forceMode = null;
+}
+function inRuntime() {
+    if (forceMode === "local")
+        return false;
+    if (forceMode === "runtime")
+        return true;
+    return !!process.env.__OW_API_KEY;
+}
+/**
+ * Runtime-switching entry point. Suitable for plain Node environments
+ * (scripts, tests without a bundler, REPLs).
+ *
+ * WARNING: For bundled apps (webpack, Vite, esbuild), prefer build-time
+ * aliasing — see README "Bundler integration".
+ */
+function loadFiles() {
+    return inRuntime() ? require("@adobe/aio-lib-files") : require("./files");
+}
+function loadState() {
+    return inRuntime() ? require("@adobe/aio-lib-state") : require("./state");
+}
+/** Lazy proxy so forceLocal/forceRuntime apply on each access */
+exports.Files = new Proxy({}, {
+    get(_target, prop) {
+        return loadFiles()[prop];
+    },
+});
+exports.State = new Proxy({}, {
+    get(_target, prop) {
+        return loadState()[prop];
+    },
+});
+module.exports = { Files: exports.Files, State: exports.State, forceLocal, forceRuntime, resetForce };

package/dist/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class AioLibError extends Error {
+    code: string;
+    sdk?: string;
+    sdkDetails?: unknown;
+    constructor(code: string, message: string, sdkDetails?: unknown);
+}
+export declare const ERROR_BAD_REQUEST = "ERROR_BAD_REQUEST";
+export declare const ERROR_BAD_ARGUMENT = "ERROR_BAD_ARGUMENT";
+export declare const ERROR_BAD_FILE_NAME = "ERROR_BAD_FILE_NAME";
+export declare const ERROR_FILE_NOT_EXISTS = "ERROR_FILE_NOT_EXISTS";
+export declare const ERROR_PAYLOAD_TOO_LARGE = "ERROR_PAYLOAD_TOO_LARGE";
+export declare const ERROR_UNAUTHORIZED = "ERROR_UNAUTHORIZED";
+export declare const ERROR_BAD_FILE_TYPE = "ERROR_BAD_FILE_TYPE";
+export declare const ERROR_OUT_OF_RANGE = "ERROR_OUT_OF_RANGE";
+export declare const ERROR_NOT_IMPLEMENTED = "ERROR_NOT_IMPLEMENTED";
+export declare function throwError(code: string, message: string, sdkDetails?: unknown): never;

package/dist/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+/* aio-libs-local stub */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_NOT_IMPLEMENTED = exports.ERROR_OUT_OF_RANGE = exports.ERROR_BAD_FILE_TYPE = exports.ERROR_UNAUTHORIZED = exports.ERROR_PAYLOAD_TOO_LARGE = exports.ERROR_FILE_NOT_EXISTS = exports.ERROR_BAD_FILE_NAME = exports.ERROR_BAD_ARGUMENT = exports.ERROR_BAD_REQUEST = exports.AioLibError = void 0;
+exports.throwError = throwError;
+class AioLibError extends Error {
+    code;
+    sdk;
+    sdkDetails;
+    constructor(code, message, sdkDetails) {
+        super(message);
+        this.name = "AioLibError";
+        this.code = code;
+        this.sdk = "AioLibsLocal";
+        this.sdkDetails = sdkDetails;
+    }
+}
+exports.AioLibError = AioLibError;
+exports.ERROR_BAD_REQUEST = "ERROR_BAD_REQUEST";
+exports.ERROR_BAD_ARGUMENT = "ERROR_BAD_ARGUMENT";
+exports.ERROR_BAD_FILE_NAME = "ERROR_BAD_FILE_NAME";
+exports.ERROR_FILE_NOT_EXISTS = "ERROR_FILE_NOT_EXISTS";
+exports.ERROR_PAYLOAD_TOO_LARGE = "ERROR_PAYLOAD_TOO_LARGE";
+exports.ERROR_UNAUTHORIZED = "ERROR_UNAUTHORIZED";
+exports.ERROR_BAD_FILE_TYPE = "ERROR_BAD_FILE_TYPE";
+exports.ERROR_OUT_OF_RANGE = "ERROR_OUT_OF_RANGE";
+exports.ERROR_NOT_IMPLEMENTED = "ERROR_NOT_IMPLEMENTED";
+function throwError(code, message, sdkDetails) {
+    throw new AioLibError(code, message, sdkDetails);
+}

package/dist/files.d.ts

@@ -0,0 +1,55 @@
+export declare const STUB_MARKER = "aio-libs-local stub";
+export interface InitOptions {
+    /** Root directory for file storage. Defaults to `.aio-files` in cwd. */
+    root?: string;
+}
+export interface RemoteFileProperties {
+    name: string;
+    creationTime: Date;
+    lastModified: Date;
+    contentLength: number;
+    contentType: string;
+    isDirectory: boolean;
+    isPublic: boolean;
+    url: string;
+    internalUrl: string;
+}
+export interface Files {
+    list(filePath?: string): Promise<RemoteFileProperties[]>;
+    read(filePath: string, options?: {
+        position?: number;
+        length?: number;
+    }): Promise<Buffer>;
+    write(filePath: string, content: string | Buffer | NodeJS.ReadableStream): Promise<number>;
+    delete(filePath: string, options?: {
+        progressCallback?: (f: string) => void;
+    }): Promise<string[]>;
+    copy(srcPath: string, destPath: string, options?: {
+        localSrc?: boolean;
+        localDest?: boolean;
+        noOverwrite?: boolean;
+        progressCallback?: (src: string, dest: string) => void;
+    }): Promise<Record<string, string>>;
+    getProperties(filePath: string): Promise<RemoteFileProperties>;
+    generatePresignURL(filePath: string, options: {
+        expiryInSeconds: number;
+        permissions?: string;
+        urlType?: string;
+    }): Promise<string>;
+    createReadStream(filePath: string, options?: {
+        position?: number;
+        length?: number;
+    }): Promise<NodeJS.ReadableStream>;
+    createWriteStream(filePath: string): Promise<NodeJS.WritableStream>;
+    revokeAllPresignURLs(): Promise<void>;
+}
+export declare function init(options?: InitOptions): Promise<Files>;
+export declare const FilePermissions: {
+    READ: string;
+    WRITE: string;
+    DELETE: string;
+};
+export declare const UrlType: {
+    external: string;
+    internal: string;
+};

package/dist/files.js

@@ -0,0 +1,399 @@
+"use strict";
+/* aio-libs-local stub */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UrlType = exports.FilePermissions = exports.STUB_MARKER = void 0;
+exports.init = init;
+const fs = __importStar(require("node:fs"));
+const fsp = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const promises_1 = require("node:stream/promises");
+const node_stream_1 = require("node:stream");
+const mime_types_1 = __importDefault(require("mime-types"));
+const errors_1 = require("./errors");
+const path_utils_1 = require("./path-utils");
+exports.STUB_MARKER = "aio-libs-local stub";
+const PUBLIC_PREFIX = "public";
+function assertNoTraversal(filePath) {
+    const segments = filePath.replace(/\\/g, "/").split("/");
+    if (segments.some((s) => s === "..")) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_NAME, `path traversal not allowed: ${filePath}`, { filePath });
+    }
+}
+function normalizeRemotePath(filePath) {
+    assertNoTraversal(filePath);
+    let res = filePath;
+    if (!res.startsWith("/"))
+        res = "/" + res;
+    res = path.posix.normalize(res);
+    while (res.startsWith("/"))
+        res = res.slice(1);
+    return res;
+}
+function isRemoteRoot(filePath) {
+    return filePath === "";
+}
+function isRemotePublic(filePath) {
+    return filePath === PUBLIC_PREFIX || filePath.startsWith(PUBLIC_PREFIX + "/");
+}
+function isRemoteDirectory(filePath) {
+    return filePath.endsWith("/") || filePath === "" || filePath === PUBLIC_PREFIX;
+}
+function throwIfRemoteDirectory(filePath, details) {
+    if (isRemoteDirectory(filePath)) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_TYPE, `${filePath} is a directory but should be a file`, details);
+    }
+}
+class LocalFiles {
+    root;
+    presignUrls = new Set();
+    constructor(root) {
+        this.root = path.resolve(root);
+    }
+    resolveLocal(normalizedPath) {
+        if (normalizedPath.includes("\0")) {
+            (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_NAME, `invalid file path: ${normalizedPath}`, {
+                filePath: normalizedPath,
+            });
+        }
+        const segments = normalizedPath.split("/").filter(Boolean);
+        for (const seg of segments) {
+            if (seg === "..") {
+                (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_NAME, `path traversal not allowed: ${normalizedPath}`, {
+                    filePath: normalizedPath,
+                });
+            }
+        }
+        const local = path.join(this.root, ...segments);
+        const resolved = path.resolve(local);
+        if (!(0, path_utils_1.isInsideRoot)(resolved, this.root)) {
+            (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_NAME, `path escapes storage root: ${normalizedPath}`, {
+                filePath: normalizedPath,
+            });
+        }
+        return resolved;
+    }
+    fileUrl(normalizedPath) {
+        const local = this.resolveLocal(normalizedPath);
+        return (0, path_utils_1.toFileUrl)(local);
+    }
+    async propsFromPath(normalizedPath, localPath) {
+        let stat;
+        try {
+            stat = await fsp.stat(localPath);
+        }
+        catch (e) {
+            if (e?.code === "ENOENT") {
+                (0, errors_1.throwError)(errors_1.ERROR_FILE_NOT_EXISTS, `file \`${normalizedPath}\` does not exist`, {
+                    filePath: normalizedPath,
+                });
+            }
+            throw e;
+        }
+        const isDirectory = stat.isDirectory();
+        const url = this.fileUrl(normalizedPath);
+        return {
+            name: normalizedPath,
+            creationTime: stat.birthtime,
+            lastModified: stat.mtime,
+            contentLength: isDirectory ? 0 : stat.size,
+            contentType: isDirectory
+                ? "application/x-directory"
+                : mime_types_1.default.lookup(normalizedPath) || "application/octet-stream",
+            isDirectory,
+            isPublic: isRemotePublic(normalizedPath),
+            url,
+            internalUrl: url,
+        };
+    }
+    async collectFiles(normalizedDir) {
+        const results = [];
+        const localDir = this.resolveLocal(normalizedDir);
+        const walk = async (dir, prefix) => {
+            let entries;
+            try {
+                entries = await fsp.readdir(dir, { withFileTypes: true });
+            }
+            catch (e) {
+                if (e?.code === "ENOENT")
+                    return;
+                throw e;
+            }
+            for (const ent of entries) {
+                const rel = prefix ? `${prefix}/${ent.name}` : ent.name;
+                const full = path.join(dir, ent.name);
+                if (ent.isDirectory()) {
+                    const norm = rel + "/";
+                    results.push(await this.propsFromPath(norm, full));
+                    await walk(full, rel);
+                }
+                else if (ent.isFile()) {
+                    results.push(await this.propsFromPath(rel, full));
+                }
+            }
+        };
+        if (isRemoteRoot(normalizedDir)) {
+            await fsp.mkdir(this.root, { recursive: true });
+            const top = await fsp.readdir(this.root, { withFileTypes: true });
+            for (const ent of top) {
+                const full = path.join(this.root, ent.name);
+                if (ent.isDirectory()) {
+                    const remoteName = ent.name === PUBLIC_PREFIX ? PUBLIC_PREFIX : `${ent.name}/`;
+                    results.push(await this.propsFromPath(remoteName, full));
+                    await walk(full, ent.name === PUBLIC_PREFIX ? PUBLIC_PREFIX : ent.name);
+                }
+                else {
+                    results.push(await this.propsFromPath(ent.name, full));
+                }
+            }
+            return results;
+        }
+        await walk(localDir, normalizedDir.replace(/\/$/, ""));
+        return results;
+    }
+    async list(filePath = "") {
+        const normalized = normalizeRemotePath(filePath);
+        if (isRemoteDirectory(normalized)) {
+            return this.collectFiles(normalized);
+        }
+        try {
+            const info = await this.getProperties(normalized);
+            return [info];
+        }
+        catch (e) {
+            if (e?.code === errors_1.ERROR_FILE_NOT_EXISTS)
+                return [];
+            throw e;
+        }
+    }
+    async read(filePath, options = {}) {
+        const normalized = normalizeRemotePath(filePath);
+        const details = { filePath, options };
+        throwIfRemoteDirectory(normalized, details);
+        const local = this.resolveLocal(normalized);
+        let stat;
+        try {
+            stat = await fsp.stat(local);
+        }
+        catch (e) {
+            if (e?.code === "ENOENT") {
+                (0, errors_1.throwError)(errors_1.ERROR_FILE_NOT_EXISTS, `file \`${normalized}\` does not exist`, details);
+            }
+            throw e;
+        }
+        const position = options.position ?? 0;
+        if (position > stat.size) {
+            (0, errors_1.throwError)(errors_1.ERROR_OUT_OF_RANGE, `options.position ${position} out of range for file ${normalized}`, details);
+        }
+        const length = options.length ?? stat.size - position;
+        const fd = await fsp.open(local, "r");
+        try {
+            const buf = Buffer.alloc(Math.min(length, stat.size - position));
+            await fd.read(buf, 0, buf.length, position);
+            return buf;
+        }
+        finally {
+            await fd.close();
+        }
+    }
+    async write(filePath, content) {
+        const normalized = normalizeRemotePath(filePath);
+        const details = { filePath: normalized };
+        throwIfRemoteDirectory(normalized, details);
+        const local = this.resolveLocal(normalized);
+        await fsp.mkdir(path.dirname(local), { recursive: true });
+        if (typeof content === "string") {
+            await fsp.writeFile(local, content, "utf8");
+            return Buffer.byteLength(content, "utf8");
+        }
+        if (Buffer.isBuffer(content)) {
+            await fsp.writeFile(local, content);
+            return content.length;
+        }
+        const ws = fs.createWriteStream(local);
+        await (0, promises_1.pipeline)(content, ws);
+        const stat = await fsp.stat(local);
+        return stat.size;
+    }
+    async delete(filePath, options = {}) {
+        const elements = await this.list(filePath);
+        const deleted = [];
+        for (const fp of elements) {
+            const name = fp.name;
+            const local = this.resolveLocal(name);
+            await fsp.rm(local, { recursive: true, force: true });
+            if (options.progressCallback)
+                options.progressCallback(name);
+            deleted.push(name);
+        }
+        return deleted;
+    }
+    async getProperties(filePath) {
+        const normalized = normalizeRemotePath(filePath);
+        return this.propsFromPath(normalized, this.resolveLocal(normalized));
+    }
+    async createReadStream(filePath, options = {}) {
+        const buf = await this.read(filePath, options);
+        return node_stream_1.Readable.from(buf);
+    }
+    async createWriteStream(filePath) {
+        const normalized = normalizeRemotePath(filePath);
+        throwIfRemoteDirectory(normalized, { filePath });
+        const local = this.resolveLocal(normalized);
+        await fsp.mkdir(path.dirname(local), { recursive: true });
+        return fs.createWriteStream(local);
+    }
+    async copy(srcPath, destPath, options = {}) {
+        if (options.localSrc && options.localDest) {
+            (0, errors_1.throwError)(errors_1.ERROR_BAD_FILE_TYPE, "local to local copy is not supported", {
+                srcPath,
+                destPath,
+                options,
+            });
+        }
+        const normalizeSrc = (p) => options.localSrc ? path.resolve(p) : this.resolveLocal(normalizeRemotePath(p));
+        const srcIsDir = options.localSrc
+            ? (await fsp.stat(normalizeSrc(srcPath)).catch(() => null))?.isDirectory()
+            : isRemoteDirectory(normalizeRemotePath(srcPath));
+        const srcFiles = [];
+        if (options.localSrc) {
+            const srcLocal = normalizeSrc(srcPath);
+            const stat = await fsp.stat(srcLocal).catch((e) => {
+                if (e?.code === "ENOENT") {
+                    (0, errors_1.throwError)(errors_1.ERROR_FILE_NOT_EXISTS, `file \`${srcPath}\` does not exist`, { srcPath });
+                }
+                throw e;
+            });
+            if (stat.isFile()) {
+                srcFiles.push(srcLocal);
+            }
+            else {
+                const walk = async (dir) => {
+                    for (const ent of await fsp.readdir(dir, { withFileTypes: true })) {
+                        const full = path.join(dir, ent.name);
+                        if (ent.isDirectory())
+                            await walk(full);
+                        else if (ent.isFile())
+                            srcFiles.push(full);
+                    }
+                };
+                await walk(srcLocal);
+            }
+        }
+        else {
+            const listed = await this.list(srcPath);
+            if (listed.length === 0) {
+                (0, errors_1.throwError)(errors_1.ERROR_FILE_NOT_EXISTS, `file \`${srcPath}\` does not exist`, { srcPath });
+            }
+            srcFiles.push(...listed.filter((f) => !f.isDirectory).map((f) => f.name));
+        }
+        const mapping = {};
+        const normSrc = options.localSrc ? srcPath : normalizeRemotePath(srcPath);
+        const normDest = options.localDest ? destPath : normalizeRemotePath(destPath);
+        for (const srcFile of srcFiles) {
+            let destFile;
+            if (options.localSrc) {
+                const rel = path.relative(normalizeSrc(srcPath), srcFile);
+                const base = normDest.endsWith("/") || (srcIsDir && !options.localDest)
+                    ? path.posix.join(normalizeRemotePath(normDest), rel.split(path.sep).join("/"))
+                    : normalizeRemotePath(normDest);
+                destFile = base;
+            }
+            else {
+                const rel = path.posix.relative(normSrc.replace(/\/$/, ""), srcFile);
+                destFile =
+                    srcIsDir && !normDest.endsWith("/")
+                        ? path.posix.join(normDest + "/", rel)
+                        : srcIsDir
+                            ? path.posix.join(normDest.endsWith("/") ? normDest : normDest + "/", rel)
+                            : normDest;
+            }
+            if (options.noOverwrite) {
+                try {
+                    if (options.localDest) {
+                        await fsp.access(path.resolve(destFile));
+                        continue;
+                    }
+                    else {
+                        await this.getProperties(destFile);
+                        continue;
+                    }
+                }
+                catch {
+                    // does not exist — proceed
+                }
+            }
+            if (options.localSrc && !options.localDest) {
+                const content = await fsp.readFile(srcFile);
+                await this.write(destFile, content);
+            }
+            else if (!options.localSrc && options.localDest) {
+                const content = await this.read(srcFile);
+                await fsp.mkdir(path.dirname(path.resolve(destFile)), { recursive: true });
+                await fsp.writeFile(path.resolve(destFile), content);
+            }
+            else if (!options.localSrc && !options.localDest) {
+                const content = await this.read(srcFile);
+                await this.write(destFile, content);
+            }
+            mapping[srcFile] = destFile;
+            if (options.progressCallback)
+                options.progressCallback(srcFile, destFile);
+        }
+        return mapping;
+    }
+    async generatePresignURL(filePath, options) {
+        const normalized = normalizeRemotePath(filePath);
+        throwIfRemoteDirectory(normalized, { filePath, options });
+        await this.getProperties(normalized);
+        const url = this.fileUrl(normalized);
+        this.presignUrls.add(url);
+        return url;
+    }
+    async revokeAllPresignURLs() {
+        this.presignUrls.clear();
+    }
+}
+async function init(options = {}) {
+    const root = path.resolve(options.root ?? path.join(process.cwd(), ".aio-files"));
+    await fsp.mkdir(root, { recursive: true });
+    return new LocalFiles(root);
+}
+exports.FilePermissions = { READ: "r", WRITE: "w", DELETE: "d" };
+exports.UrlType = { external: "external", internal: "internal" };
+module.exports = { init, FilePermissions: exports.FilePermissions, UrlType: exports.UrlType, STUB_MARKER: exports.STUB_MARKER };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * as Files from "./files";
+export * as State from "./state";
+export * as Auto from "./auto";
+export * from "./errors";

package/dist/index.js

@@ -0,0 +1,44 @@
+"use strict";
+/* aio-libs-local stub */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auto = exports.State = exports.Files = void 0;
+exports.Files = __importStar(require("./files"));
+exports.State = __importStar(require("./state"));
+exports.Auto = __importStar(require("./auto"));
+__exportStar(require("./errors"), exports);

package/dist/path-utils.d.ts

@@ -0,0 +1,4 @@
+/** True when `resolved` is the storage root or a path under it (Windows-safe). */
+export declare function isInsideRoot(resolved: string, root: string): boolean;
+/** Platform-correct file:// URL for a local filesystem path. */
+export declare function toFileUrl(localPath: string): string;

package/dist/path-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInsideRoot = isInsideRoot;
+exports.toFileUrl = toFileUrl;
+const path = __importStar(require("node:path"));
+const node_url_1 = require("node:url");
+/** True when `resolved` is the storage root or a path under it (Windows-safe). */
+function isInsideRoot(resolved, root) {
+    const normalizedRoot = path.resolve(root);
+    const normalizedResolved = path.resolve(resolved);
+    const relative = path.relative(normalizedRoot, normalizedResolved);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+/** Platform-correct file:// URL for a local filesystem path. */
+function toFileUrl(localPath) {
+    return (0, node_url_1.pathToFileURL)(path.resolve(localPath)).href;
+}

package/dist/state.d.ts

@@ -0,0 +1,42 @@
+export declare const MAX_TTL = 2592000;
+export interface InitOptions {
+    /** Persist state to a directory on disk. If omitted, state is in-memory. */
+    persist?: string;
+    /** Namespace prefix for keys (for parity testing). Optional. */
+    namespace?: string;
+}
+export interface PutOptions {
+    /** TTL in seconds. Default 86400 (24h). Max 2592000 (30d). -1 = no expiry. */
+    ttl?: number;
+}
+export interface StateValue {
+    value: any;
+    expiration?: string;
+}
+export interface State {
+    get(key: string): Promise<StateValue | undefined>;
+    put(key: string, value: any, options?: PutOptions): Promise<string>;
+    delete(key: string): Promise<string | null>;
+    deleteAll(options: {
+        match: string;
+    }): Promise<{
+        keys: number;
+    }>;
+    any(options?: {
+        match?: string;
+    }): Promise<boolean>;
+    stats(options?: {
+        match?: string;
+    }): Promise<{
+        keys: number;
+        bytesKeys: number;
+        bytesValues: number;
+    }>;
+    list(options?: {
+        match?: string;
+        countHint?: number;
+    }): AsyncGenerator<{
+        keys: string[];
+    }>;
+}
+export declare function init(initOptions?: InitOptions): Promise<State>;

package/dist/state.js

@@ -0,0 +1,244 @@
+"use strict";
+/* aio-libs-local stub */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TTL = void 0;
+exports.init = init;
+const fs = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+const errors_1 = require("./errors");
+exports.MAX_TTL = 2592000; // 30 days per local stub spec
+const DEFAULT_TTL = 86400;
+const MAX_VALUE_BYTES = 1024 * 1024; // 1MB
+const KEY_REGEX = /^[a-zA-Z0-9_\-.]{1,1024}$/;
+const MATCH_REGEX = /^[a-zA-Z0-9_\-.]{1,1024}$|^[a-zA-Z0-9_\-.]{0,1023}\*$/;
+const stores = new Map();
+function storeKey(options) {
+    return options.persist ?? options.namespace ?? "__memory__";
+}
+function getStore(options) {
+    const key = storeKey(options);
+    if (!stores.has(key))
+        stores.set(key, new Map());
+    return stores.get(key);
+}
+function namespacedKey(key, options) {
+    return options.namespace ? `${options.namespace}:${key}` : key;
+}
+function validateKey(key) {
+    if (!KEY_REGEX.test(key)) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_REQUEST, `invalid key: ${key}`, { key });
+    }
+}
+function validateMatch(match) {
+    if (!MATCH_REGEX.test(match)) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_REQUEST, `invalid match pattern: ${match}`, { match });
+    }
+}
+function validateTtl(ttl) {
+    if (ttl === -1)
+        return;
+    if (ttl < 0) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_REQUEST, "ttl must be -1 (no expiry) or a non-negative number", { ttl });
+    }
+    if (ttl > exports.MAX_TTL) {
+        (0, errors_1.throwError)(errors_1.ERROR_BAD_REQUEST, `ttl must be <= ${exports.MAX_TTL} seconds (30 days)`, { ttl });
+    }
+}
+function validateValue(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    const bytes = Buffer.byteLength(serialized, "utf8");
+    if (bytes > MAX_VALUE_BYTES) {
+        throw new errors_1.AioLibError(errors_1.ERROR_PAYLOAD_TOO_LARGE, "key, value or request payload is too large", {
+            bytes,
+            max: MAX_VALUE_BYTES,
+        });
+    }
+}
+function globToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    return new RegExp(`^${escaped}$`);
+}
+function matchesPattern(key, pattern) {
+    if (!pattern)
+        return true;
+    validateMatch(pattern);
+    return globToRegExp(pattern).test(key);
+}
+function isExpired(entry) {
+    return entry.expiresAt !== null && entry.expiresAt < Date.now();
+}
+function entryToStateValue(entry) {
+    return {
+        value: entry.value,
+        expiration: entry.expiresAt === null ? undefined : new Date(entry.expiresAt).toISOString(),
+    };
+}
+function debounce(fn, ms) {
+    let timer = null;
+    return () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(fn, ms);
+    };
+}
+async function loadFromDisk(persistDir, store) {
+    const filePath = path.join(persistDir, "state.json");
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const data = JSON.parse(raw);
+        store.clear();
+        for (const [k, v] of Object.entries(data)) {
+            store.set(k, v);
+        }
+    }
+    catch (e) {
+        if (e?.code !== "ENOENT")
+            throw e;
+    }
+}
+async function saveToDisk(persistDir, store) {
+    await fs.mkdir(persistDir, { recursive: true });
+    const filePath = path.join(persistDir, "state.json");
+    const obj = {};
+    for (const [k, v] of store.entries()) {
+        obj[k] = v;
+    }
+    await fs.writeFile(filePath, JSON.stringify(obj), "utf8");
+}
+async function init(initOptions = {}) {
+    const store = getStore(initOptions);
+    if (initOptions.persist) {
+        await loadFromDisk(initOptions.persist, store);
+    }
+    const persist = initOptions.persist
+        ? debounce(() => {
+            void saveToDisk(initOptions.persist, store);
+        }, 100)
+        : () => { };
+    const resolveKey = (key) => namespacedKey(key, initOptions);
+    const toLogicalKey = (storedKey) => initOptions.namespace ? storedKey.slice(initOptions.namespace.length + 1) : storedKey;
+    return {
+        async get(key) {
+            validateKey(key);
+            const nk = resolveKey(key);
+            const entry = store.get(nk);
+            if (!entry)
+                return undefined;
+            if (isExpired(entry)) {
+                store.delete(nk);
+                persist();
+                return undefined;
+            }
+            return entryToStateValue(entry);
+        },
+        async put(key, value, opts = {}) {
+            validateKey(key);
+            validateValue(value);
+            let ttl = opts.ttl ?? DEFAULT_TTL;
+            if (ttl === 0)
+                ttl = DEFAULT_TTL;
+            validateTtl(ttl);
+            const expiresAt = ttl === -1 ? null : Date.now() + ttl * 1000;
+            const nk = resolveKey(key);
+            store.set(nk, { value, expiresAt });
+            persist();
+            return key;
+        },
+        async delete(key) {
+            validateKey(key);
+            const nk = resolveKey(key);
+            if (!store.has(nk))
+                return null;
+            store.delete(nk);
+            persist();
+            return key;
+        },
+        async deleteAll(options) {
+            if (!options?.match) {
+                (0, errors_1.throwError)(errors_1.ERROR_BAD_REQUEST, "deleteAll requires { match } option", { options });
+            }
+            validateMatch(options.match);
+            let count = 0;
+            for (const [k, entry] of Array.from(store.entries())) {
+                const logicalKey = toLogicalKey(k);
+                if (matchesPattern(logicalKey, options.match) && !isExpired(entry)) {
+                    store.delete(k);
+                    count++;
+                }
+            }
+            persist();
+            return { keys: count };
+        },
+        async any(options = {}) {
+            for (const [k, entry] of store.entries()) {
+                const logicalKey = toLogicalKey(k);
+                if (matchesPattern(logicalKey, options.match) && !isExpired(entry)) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        async stats(options = {}) {
+            let keys = 0;
+            let bytesKeys = 0;
+            let bytesValues = 0;
+            for (const [k, entry] of store.entries()) {
+                const logicalKey = toLogicalKey(k);
+                if (!matchesPattern(logicalKey, options.match) || isExpired(entry))
+                    continue;
+                keys++;
+                bytesKeys += Buffer.byteLength(logicalKey, "utf8");
+                const serialized = typeof entry.value === "string" ? entry.value : JSON.stringify(entry.value);
+                bytesValues += Buffer.byteLength(serialized, "utf8");
+            }
+            return { keys, bytesKeys, bytesValues };
+        },
+        list(options = {}) {
+            return (async function* () {
+                const keys = [];
+                for (const [k, entry] of store.entries()) {
+                    const logicalKey = toLogicalKey(k);
+                    if (matchesPattern(logicalKey, options.match) && !isExpired(entry)) {
+                        keys.push(logicalKey);
+                    }
+                }
+                yield { keys };
+            })();
+        },
+    };
+}
+// CommonJS export shape matching @adobe/aio-lib-state
+module.exports = { init, MAX_TTL: exports.MAX_TTL };

package/package.json

@@ -0,0 +1,118 @@
+{
+  "name": "@musallam/aio-libs-local",
+  "version": "0.1.0",
+  "description": "Local/in-memory stand-ins for @adobe/aio-lib-files and @adobe/aio-lib-state",
+  "keywords": [
+    "adobe-io",
+    "app-builder",
+    "local-dev",
+    "openwhisk",
+    "testing"
+  ],
+  "homepage": "https://github.com/ahmed-musallam/aio-libs-local#readme",
+  "bugs": {
+    "url": "https://github.com/ahmed-musallam/aio-libs-local/issues"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ahmed-musallam/aio-libs-local.git"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js"
+    },
+    "./files": {
+      "types": "./dist/files.d.ts",
+      "import": "./dist/files.js",
+      "require": "./dist/files.js"
+    },
+    "./state": {
+      "types": "./dist/state.d.ts",
+      "import": "./dist/state.js",
+      "require": "./dist/state.js"
+    },
+    "./auto": {
+      "types": "./dist/auto.d.ts",
+      "import": "./dist/auto.js",
+      "require": "./dist/auto.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "pnpm run build && vitest run",
+    "test:unit": "pnpm run build && vitest run --exclude 'test/bundler/**'",
+    "test:bundler": "pnpm run build && vitest run test/bundler",
+    "test:watch": "vitest",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
+    "fmt": "oxfmt .",
+    "fmt:check": "oxfmt --check .",
+    "prepare": "husky",
+    "prepublishOnly": "pnpm run build"
+  },
+  "dependencies": {
+    "mime-types": "3.0.2"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "21.0.1",
+    "@commitlint/config-conventional": "21.0.1",
+    "@semantic-release/changelog": "6.0.3",
+    "@semantic-release/commit-analyzer": "13.0.1",
+    "@semantic-release/exec": "7.1.0",
+    "@semantic-release/git": "10.0.1",
+    "@semantic-release/github": "12.0.8",
+    "@semantic-release/npm": "13.1.5",
+    "@semantic-release/release-notes-generator": "14.1.1",
+    "@types/mime-types": "3.0.1",
+    "@types/node": "25.9.1",
+    "esbuild": "0.28.0",
+    "husky": "9.1.7",
+    "lint-staged": "17.0.5",
+    "oxfmt": "0.51.0",
+    "oxlint": "1.66.0",
+    "semantic-release": "25.0.3",
+    "typescript": "6.0.3",
+    "vite": "8.0.14",
+    "vitest": "4.1.7"
+  },
+  "peerDependencies": {
+    "@adobe/aio-lib-files": "*",
+    "@adobe/aio-lib-state": "*"
+  },
+  "peerDependenciesMeta": {
+    "@adobe/aio-lib-files": {
+      "optional": true
+    },
+    "@adobe/aio-lib-state": {
+      "optional": true
+    }
+  },
+  "lint-staged": {
+    "*.{ts,js,mjs,cjs}": [
+      "oxfmt",
+      "oxlint --fix"
+    ]
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.30.3",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  }
+}