@absolutejs/agent-sandbox 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AbsoluteJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,23 @@
+# @absolutejs/agent-sandbox
+
+Deny-by-default capability sandboxing for agent actions. Grants are scoped to
+one durable run and one signed agent identity, expire, carry per-capability use
+limits, and are verified through an issuer-agnostic callback.
+
+HTTP access is restricted by origin, method, path, body/response size, and
+credential alias. Filesystem access uses boundary-safe absolute roots. Process
+access uses exact executable allowlists, argument prefixes, working roots,
+timeouts, and output limits. Credentials are resolved inside adapters and never
+returned to the agent.
+
+The broker persists an operation before executing it. Repeating the same
+`grantId + requestId` returns the recorded result instead of repeating the
+external action. Use the Postgres store in production or the memory store in
+tests. The built-in fetch adapter rejects redirects so an allowed origin cannot
+bounce an agent to an ungranted destination.
+
+An adapter failure is deliberately left locked for reconciliation: the remote
+system may have accepted the effect before the error reached the broker, so an
+automatic retry would risk duplication. Filesystem adapters must resolve
+symlinks/real paths before access; process adapters must enforce the grant's
+timeout and output ceilings at the operating-system boundary.

package/dist/adapters.d.ts

@@ -0,0 +1,6 @@
+import type { AgentSandboxAdapter } from "./types";
+export type AgentSandboxFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+/** Fetch adapter with manual redirects so a granted origin cannot redirect elsewhere. */
+export declare const createFetchAgentSandboxAdapter: ({ fetch: fetcher, }?: {
+    fetch?: AgentSandboxFetch;
+}) => AgentSandboxAdapter;

package/dist/broker.d.ts

@@ -0,0 +1,12 @@
+import type { AgentCapabilityGrant, AgentSandbox, AgentSandboxAction, AgentSandboxAdapter, AgentSandboxOperationStore } from "./types";
+export declare const createAgentSandbox: ({ store, adapters, verifyGrant, resolveCredential, now, id, }: {
+    store: AgentSandboxOperationStore;
+    adapters: Partial<Record<AgentSandboxAction["kind"], AgentSandboxAdapter>>;
+    verifyGrant: (grant: AgentCapabilityGrant) => boolean | Promise<boolean>;
+    resolveCredential: (input: {
+        alias: string;
+        grant: AgentCapabilityGrant;
+    }) => Promise<string>;
+    now?: () => number;
+    id?: () => string;
+}) => AgentSandbox;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./policy";
+export * from "./memory";
+export * from "./postgres";
+export * from "./broker";
+export * from "./adapters";

package/dist/index.js

@@ -0,0 +1,273 @@
+// @bun
+// src/policy.ts
+import { isAbsolute, normalize, relative, resolve } from "path";
+var byteLength = (value) => value === undefined ? 0 : typeof value === "string" ? new TextEncoder().encode(value).byteLength : value.byteLength;
+var within = (root, requested) => {
+  if (!isAbsolute(root) || !isAbsolute(requested))
+    return false;
+  const remainder = relative(resolve(root), resolve(normalize(requested)));
+  return remainder === "" || !remainder.startsWith("..") && !isAbsolute(remainder);
+};
+var originMatches = (allowed, url) => {
+  const candidate = new URL(allowed.replace("*.", "placeholder."));
+  if (candidate.protocol !== url.protocol || candidate.port !== url.port)
+    return false;
+  if (!allowed.includes("*."))
+    return candidate.hostname === url.hostname;
+  const suffix = candidate.hostname.slice("placeholder".length);
+  return url.hostname.endsWith(suffix) && url.hostname.length > suffix.length;
+};
+var checkCredentials = (allowed, requested) => {
+  for (const alias of Object.values(requested ?? {})) {
+    if (!allowed?.includes(alias))
+      throw new Error(`Credential alias is not granted: ${alias}`);
+  }
+};
+var authorizeHttp = (capability, action) => {
+  const url = new URL(action.url);
+  if (url.username || url.password)
+    throw new Error("HTTP URL credentials are denied");
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(url.hostname)))
+    throw new Error("HTTP capability requires HTTPS except on loopback");
+  if (!capability.origins.some((origin) => originMatches(origin, url)))
+    throw new Error("HTTP origin is not granted");
+  if (capability.methods && !capability.methods.map((value) => value.toUpperCase()).includes(action.method.toUpperCase()))
+    throw new Error("HTTP method is not granted");
+  if (capability.pathPrefixes && !capability.pathPrefixes.some((prefix) => decodeURIComponent(url.pathname) === prefix || decodeURIComponent(url.pathname).startsWith(prefix.endsWith("/") ? prefix : `${prefix}/`)))
+    throw new Error("HTTP path is not granted");
+  const forbiddenHeaders = new Set([
+    "authorization",
+    "proxy-authorization",
+    "cookie",
+    "host",
+    "connection",
+    "content-length",
+    "transfer-encoding"
+  ]);
+  for (const name of Object.keys(action.headers ?? {})) {
+    if (forbiddenHeaders.has(name.toLowerCase()))
+      throw new Error(`Sensitive HTTP header must use a credential alias: ${name}`);
+  }
+  if (byteLength(action.body) > (capability.maxRequestBytes ?? 1048576))
+    throw new Error("HTTP request body exceeds grant");
+  checkCredentials(capability.credentialAliases, action.credentials);
+};
+var authorizeFilesystem = (capability, action) => {
+  const root = capability.roots.find((entry) => within(entry.path, action.path) && (entry.access === "read-write" || entry.access === action.operation));
+  if (!root)
+    throw new Error("Filesystem path or operation is not granted");
+  if (action.operation === "write" && byteLength(action.data) > (capability.maxWriteBytes ?? 1048576))
+    throw new Error("Filesystem write exceeds grant");
+};
+var startsWithArgs = (args, prefix) => prefix.every((value, index) => args[index] === value);
+var authorizeProcess = (capability, action) => {
+  if (!capability.executables.includes(action.executable))
+    throw new Error("Executable is not granted");
+  if (capability.argumentPrefixes && !capability.argumentPrefixes.some((prefix) => startsWithArgs(action.args, prefix)))
+    throw new Error("Process arguments are not granted");
+  if (action.cwd && !capability.workingDirectories?.some((root) => within(root, action.cwd)))
+    throw new Error("Working directory is not granted");
+  checkCredentials(capability.credentialAliases, action.credentials);
+};
+var authorizeAgentSandboxAction = (capability, action) => {
+  if (capability.kind !== action.kind)
+    throw new Error("Capability kind does not match action");
+  if (capability.kind === "http" && action.kind === "http")
+    return authorizeHttp(capability, action);
+  if (capability.kind === "filesystem" && action.kind === "filesystem")
+    return authorizeFilesystem(capability, action);
+  if (capability.kind === "process" && action.kind === "process")
+    return authorizeProcess(capability, action);
+  throw new Error("Unsupported sandbox action");
+};
+// src/memory.ts
+var createMemoryAgentSandboxOperationStore = () => {
+  const operations = new Map;
+  const uses = new Map;
+  return {
+    begin: async ({ grantId, capabilityId, requestId, maxUses }) => {
+      const key = `${grantId}:${requestId}`;
+      const existing = operations.get(key);
+      if (existing?.state === "completed")
+        return {
+          state: "completed",
+          result: structuredClone(existing.result)
+        };
+      if (existing)
+        return { state: "in_progress" };
+      const usageKey = `${grantId}:${capabilityId}`;
+      const used = uses.get(usageKey) ?? 0;
+      if (maxUses !== undefined && used >= maxUses)
+        return { state: "limit_exceeded" };
+      uses.set(usageKey, used + 1);
+      operations.set(key, { state: "in_progress" });
+      return { state: "acquired" };
+    },
+    complete: async ({ grantId, requestId, result }) => {
+      const key = `${grantId}:${requestId}`;
+      if (operations.get(key)?.state !== "in_progress")
+        return false;
+      operations.set(key, {
+        state: "completed",
+        result: structuredClone(result)
+      });
+      return true;
+    },
+    fail: async () => {}
+  };
+};
+// src/postgres.ts
+var safe = (value) => {
+  if (!/^[a-z_][a-z0-9_]*$/i.test(value))
+    throw new Error("Invalid SQL namespace");
+  return value;
+};
+var agentSandboxPostgresSchemaSql = (schema = "agent_sandbox") => {
+  const ns = safe(schema);
+  return `CREATE SCHEMA IF NOT EXISTS ${ns};
+CREATE TABLE IF NOT EXISTS ${ns}.operations (grant_id text NOT NULL, request_id text NOT NULL, capability_id text NOT NULL, state text NOT NULL, result jsonb, created_at timestamptz NOT NULL, updated_at timestamptz NOT NULL, PRIMARY KEY (grant_id, request_id));
+CREATE TABLE IF NOT EXISTS ${ns}.capability_usage (grant_id text NOT NULL, capability_id text NOT NULL, uses integer NOT NULL, PRIMARY KEY (grant_id, capability_id));`;
+};
+var createPostgresAgentSandboxOperationStore = ({
+  client,
+  schema = "agent_sandbox"
+}) => {
+  const ns = safe(schema);
+  return {
+    begin: (input) => client.transaction(async (tx) => {
+      const existing = (await tx.query(`SELECT state,result FROM ${ns}.operations WHERE grant_id=$1 AND request_id=$2 FOR UPDATE`, [input.grantId, input.requestId])).rows[0];
+      if (existing?.state === "completed" && existing.result)
+        return { state: "completed", result: existing.result };
+      if (existing)
+        return { state: "in_progress" };
+      await tx.query(`INSERT INTO ${ns}.capability_usage (grant_id,capability_id,uses) VALUES ($1,$2,0) ON CONFLICT DO NOTHING`, [input.grantId, input.capabilityId]);
+      const usage = (await tx.query(`SELECT uses FROM ${ns}.capability_usage WHERE grant_id=$1 AND capability_id=$2 FOR UPDATE`, [input.grantId, input.capabilityId])).rows[0]?.uses ?? 0;
+      if (input.maxUses !== undefined && usage >= input.maxUses)
+        return { state: "limit_exceeded" };
+      await tx.query(`UPDATE ${ns}.capability_usage SET uses=uses+1 WHERE grant_id=$1 AND capability_id=$2`, [input.grantId, input.capabilityId]);
+      await tx.query(`INSERT INTO ${ns}.operations (grant_id,request_id,capability_id,state,created_at,updated_at) VALUES ($1,$2,$3,'in_progress',$4::timestamptz,$4::timestamptz)`, [input.grantId, input.requestId, input.capabilityId, input.now]);
+      return { state: "acquired" };
+    }),
+    complete: async (input) => (await client.query(`UPDATE ${ns}.operations SET state='completed',result=$3::jsonb,updated_at=$4::timestamptz WHERE grant_id=$1 AND request_id=$2 AND state='in_progress' RETURNING request_id`, [
+      input.grantId,
+      input.requestId,
+      JSON.stringify(input.result),
+      input.now
+    ])).rows.length === 1,
+    fail: async (input) => {
+      await client.query(`UPDATE ${ns}.operations SET state='failed' WHERE grant_id=$1 AND request_id=$2 AND state='in_progress'`, [input.grantId, input.requestId]);
+    }
+  };
+};
+// src/broker.ts
+var stable = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).sort(([a], [b]) => a.localeCompare(b))) : item);
+var digest = async (value) => `sha256:${Buffer.from(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(stable(value)))).toString("hex")}`;
+var createAgentSandbox = ({
+  store,
+  adapters,
+  verifyGrant,
+  resolveCredential,
+  now = Date.now,
+  id = () => crypto.randomUUID()
+}) => ({
+  execute: async ({ grant, action }) => {
+    if (!await verifyGrant(grant))
+      throw new Error("Capability grant proof is invalid");
+    const timestamp = now();
+    if (!Number.isFinite(Date.parse(grant.expiresAt)) || Date.parse(grant.expiresAt) <= timestamp)
+      throw new Error("Capability grant is expired");
+    const capability = grant.capabilities.find((value) => value.id === action.capabilityId);
+    if (!capability)
+      throw new Error("Capability is not granted");
+    authorizeAgentSandboxAction(capability, action);
+    const adapter = adapters[action.kind];
+    if (!adapter)
+      throw new Error(`No sandbox adapter for ${action.kind}`);
+    const requestDigest = await digest(action);
+    const begun = await store.begin({
+      grantId: grant.id,
+      capabilityId: capability.id,
+      requestId: action.requestId,
+      maxUses: capability.maxUses,
+      now: new Date(timestamp).toISOString()
+    });
+    if (begun.state === "completed")
+      return begun.result;
+    if (begun.state === "in_progress")
+      throw new Error("Sandbox action is already in progress");
+    if (begun.state === "limit_exceeded")
+      throw new Error("Capability use limit exceeded");
+    try {
+      const output = await adapter.execute({
+        grant,
+        capability,
+        action,
+        resolveCredential: (alias) => resolveCredential({ alias, grant })
+      });
+      const receipt = {
+        id: id(),
+        grantId: grant.id,
+        runId: grant.runId,
+        requestId: action.requestId,
+        capabilityId: capability.id,
+        kind: action.kind,
+        requestDigest,
+        outputDigest: await digest(output),
+        startedAt: new Date(timestamp).toISOString(),
+        completedAt: new Date(now()).toISOString()
+      };
+      const result = { output, receipt };
+      if (!await store.complete({
+        grantId: grant.id,
+        requestId: action.requestId,
+        result,
+        now: receipt.completedAt
+      }))
+        throw new Error("Sandbox operation completion was lost");
+      return result;
+    } catch (error) {
+      await store.fail({ grantId: grant.id, requestId: action.requestId });
+      throw error;
+    }
+  }
+});
+// src/adapters.ts
+var readLimited = async (response, limit) => {
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (bytes.byteLength > limit)
+    throw new Error("HTTP response exceeds grant");
+  return new TextDecoder().decode(bytes);
+};
+var createFetchAgentSandboxAdapter = ({
+  fetch: fetcher = fetch
+} = {}) => ({
+  execute: async ({ capability, action, resolveCredential }) => {
+    if (capability.kind !== "http" || action.kind !== "http")
+      throw new Error("HTTP adapter received another action kind");
+    const headers = new Headers(action.headers);
+    for (const [header, alias] of Object.entries(action.credentials ?? {}))
+      headers.set(header, await resolveCredential(alias));
+    const response = await fetcher(action.url, {
+      method: action.method,
+      headers,
+      body: action.body,
+      redirect: "manual"
+    });
+    if (response.status >= 300 && response.status < 400)
+      throw new Error("HTTP redirects are denied by the sandbox adapter");
+    const body = await readLimited(response, capability.maxResponseBytes ?? 1048576);
+    return {
+      status: response.status,
+      headers: Object.fromEntries(response.headers),
+      body
+    };
+  }
+});
+export {
+  createPostgresAgentSandboxOperationStore,
+  createMemoryAgentSandboxOperationStore,
+  createFetchAgentSandboxAdapter,
+  createAgentSandbox,
+  authorizeAgentSandboxAction,
+  agentSandboxPostgresSchemaSql
+};

package/dist/manifest.d.ts

@@ -0,0 +1 @@
+export declare const manifest: import("@absolutejs/manifest").PackageManifest<unknown, never>;

package/dist/manifest.js

@@ -0,0 +1,23 @@
+// @bun
+// src/manifest.ts
+import { defineManifest } from "@absolutejs/manifest";
+import { Type } from "@sinclair/typebox";
+var manifest = defineManifest()({
+  contract: 2,
+  identity: {
+    name: "@absolutejs/agent-sandbox",
+    category: "security",
+    tagline: "Give agents narrow capabilities, never ambient authority.",
+    description: "Deny-by-default, expiring capability grants and idempotent provider-neutral action adapters for HTTP, filesystem, process, and credential-safe agent actions.",
+    docsUrl: "https://github.com/absolutejs/agent-sandbox",
+    accent: "#ef4444"
+  },
+  settings: Type.Object({}),
+  slots: {},
+  implements: [],
+  tools: {},
+  wiring: []
+});
+export {
+  manifest
+};

package/dist/manifest.json

@@ -0,0 +1,19 @@
+{
+	"contract": 2,
+	"identity": {
+		"name": "@absolutejs/agent-sandbox",
+		"category": "security",
+		"tagline": "Give agents narrow capabilities, never ambient authority.",
+		"description": "Deny-by-default, expiring capability grants and idempotent provider-neutral action adapters for HTTP, filesystem, process, and credential-safe agent actions.",
+		"docsUrl": "https://github.com/absolutejs/agent-sandbox",
+		"accent": "#ef4444"
+	},
+	"settings": {
+		"type": "object",
+		"properties": {}
+	},
+	"slots": {},
+	"implements": [],
+	"wiring": [],
+	"tools": {}
+}

package/dist/memory.d.ts

@@ -0,0 +1,2 @@
+import type { AgentSandboxOperationStore } from "./types";
+export declare const createMemoryAgentSandboxOperationStore: () => AgentSandboxOperationStore;

package/dist/policy.d.ts

@@ -0,0 +1,2 @@
+import type { AgentCapability, AgentSandboxAction } from "./types";
+export declare const authorizeAgentSandboxAction: (capability: AgentCapability, action: AgentSandboxAction) => void;

package/dist/postgres.d.ts

@@ -0,0 +1,15 @@
+import type { AgentSandboxOperationStore } from "./types";
+export type AgentSandboxSqlResult<Row> = {
+    rows: Row[];
+};
+export type AgentSandboxSqlTransaction = {
+    query<Row = Record<string, unknown>>(sql: string, params?: readonly unknown[]): Promise<AgentSandboxSqlResult<Row>>;
+};
+export type AgentSandboxSqlClient = AgentSandboxSqlTransaction & {
+    transaction<Value>(work: (tx: AgentSandboxSqlTransaction) => Promise<Value>): Promise<Value>;
+};
+export declare const agentSandboxPostgresSchemaSql: (schema?: string) => string;
+export declare const createPostgresAgentSandboxOperationStore: ({ client, schema, }: {
+    client: AgentSandboxSqlClient;
+    schema?: string;
+}) => AgentSandboxOperationStore;

package/dist/types.d.ts

@@ -0,0 +1,141 @@
+export type AgentIdentityPin = {
+    descriptorId: string;
+    descriptorVersion: string;
+    descriptorDigest: string;
+};
+export type HttpCapability = {
+    id: string;
+    kind: "http";
+    origins: string[];
+    methods?: string[];
+    pathPrefixes?: string[];
+    credentialAliases?: string[];
+    maxRequestBytes?: number;
+    maxResponseBytes?: number;
+    maxUses?: number;
+};
+export type FilesystemCapability = {
+    id: string;
+    kind: "filesystem";
+    roots: Array<{
+        path: string;
+        access: "read" | "write" | "read-write";
+    }>;
+    maxWriteBytes?: number;
+    maxReadBytes?: number;
+    maxUses?: number;
+};
+export type ProcessCapability = {
+    id: string;
+    kind: "process";
+    executables: string[];
+    argumentPrefixes?: string[][];
+    workingDirectories?: string[];
+    credentialAliases?: string[];
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    maxUses?: number;
+};
+export type AgentCapability = HttpCapability | FilesystemCapability | ProcessCapability;
+export type AgentCapabilityGrant = {
+    id: string;
+    runId: string;
+    actor: {
+        tenantId: string;
+        userId: string;
+        agentId: string;
+        delegationId?: string;
+    };
+    agent: AgentIdentityPin;
+    issuedAt: string;
+    expiresAt: string;
+    capabilities: AgentCapability[];
+    issuer: string;
+    proof?: unknown;
+};
+export type HttpAction = {
+    kind: "http";
+    capabilityId: string;
+    requestId: string;
+    url: string;
+    method: string;
+    headers?: Record<string, string>;
+    body?: string | Uint8Array;
+    credentials?: Record<string, string>;
+};
+export type FilesystemAction = {
+    kind: "filesystem";
+    capabilityId: string;
+    requestId: string;
+    operation: "read" | "write";
+    path: string;
+    data?: string | Uint8Array;
+};
+export type ProcessAction = {
+    kind: "process";
+    capabilityId: string;
+    requestId: string;
+    executable: string;
+    args: string[];
+    cwd?: string;
+    credentials?: Record<string, string>;
+};
+export type AgentSandboxAction = HttpAction | FilesystemAction | ProcessAction;
+export type AgentSandboxReceipt = {
+    id: string;
+    grantId: string;
+    runId: string;
+    requestId: string;
+    capabilityId: string;
+    kind: AgentSandboxAction["kind"];
+    requestDigest: string;
+    outputDigest: string;
+    startedAt: string;
+    completedAt: string;
+};
+export type AgentSandboxResult = {
+    output: unknown;
+    receipt: AgentSandboxReceipt;
+};
+export type AgentSandboxOperationStore = {
+    begin(input: {
+        grantId: string;
+        capabilityId: string;
+        requestId: string;
+        maxUses?: number;
+        now: string;
+    }): Promise<{
+        state: "acquired";
+    } | {
+        state: "in_progress";
+    } | {
+        state: "limit_exceeded";
+    } | {
+        state: "completed";
+        result: AgentSandboxResult;
+    }>;
+    complete(input: {
+        grantId: string;
+        requestId: string;
+        result: AgentSandboxResult;
+        now: string;
+    }): Promise<boolean>;
+    fail(input: {
+        grantId: string;
+        requestId: string;
+    }): Promise<void>;
+};
+export type AgentSandboxAdapter = {
+    execute(input: {
+        grant: AgentCapabilityGrant;
+        capability: AgentCapability;
+        action: AgentSandboxAction;
+        resolveCredential(alias: string): Promise<string>;
+    }): Promise<unknown>;
+};
+export type AgentSandbox = {
+    execute(input: {
+        grant: AgentCapabilityGrant;
+        action: AgentSandboxAction;
+    }): Promise<AgentSandboxResult>;
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@absolutejs/agent-sandbox",
+  "version": "0.1.0",
+  "description": "Deny-by-default capability grants and provider-neutral HTTP, filesystem, process, and credential-safe action adapters for AI agents.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/absolutejs/agent-sandbox.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "absolutejs": {
+    "manifestContract": 2
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest.d.ts",
+      "import": "./dist/manifest.js"
+    },
+    "./manifest.json": "./dist/manifest.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "format": "prettier --write \"./**/*.{ts,json,md,yml}\"",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "build": "rm -rf dist && bun build src/index.ts src/manifest.ts --outdir dist --target=bun --external @absolutejs/manifest --external @sinclair/typebox && tsc -p tsconfig.build.json && absolute-manifest emit",
+    "check:package": "bun run typecheck && bun run test && bun run build"
+  },
+  "dependencies": {
+    "@absolutejs/manifest": "^0.2.0",
+    "@sinclair/typebox": "^0.34.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "prettier": "3.5.3",
+    "typescript": "5.8.3"
+  }
+}