apps 0.8.3 → 1.0.0-beta.0

package/dist/index-wfngzvv2.js

@@ -0,0 +1,228 @@
+import {
+  __enterFile,
+  __leaveFile,
+  newRegistry,
+  setActiveRegistry
+} from "./index-8wmxmfhc.js";
+import {
+  JsonSchemaObject,
+  PublishError
+} from "./index-mcjwntr2.js";
+
+// src/manifest/index.ts
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Crypto, Effect, FileSystem, Schema, Semaphore } from "effect";
+
+// src/manifest/collect.ts
+var collectRegistry = (registry, compileInputSchema) => {
+  const requirementKey = Symbol.for("executor/apps/requirement");
+  const problems = registry.problems.map((problem) => problem.message);
+  const app = registry.app;
+  const requirementSpecOf = (value) => typeof value === "object" && value !== null && (requirementKey in value) ? value[requirementKey] : undefined;
+  const canonicalJson = (value) => {
+    const sortKeys = (node) => {
+      if (Array.isArray(node))
+        return node.map(sortKeys);
+      if (typeof node === "object" && node !== null)
+        return Object.fromEntries(Object.entries(node).sort(([left], [right]) => left.localeCompare(right)).map(([key, child]) => [key, sortKeys(child)]));
+      return node;
+    };
+    return JSON.stringify(sortKeys(value));
+  };
+  const claims = new Map;
+  for (const [origin, registered] of registry.services) {
+    if (registered.file !== "app.ts")
+      continue;
+    const { decl } = registered;
+    claims.set(origin, {
+      origin,
+      reach: decl.reach ?? [],
+      params: decl.params ?? {},
+      auth: decl.auth ?? {}
+    });
+  }
+  const collectRequirement = (role, requirement, where) => {
+    const spec = requirementSpecOf(requirement);
+    if (spec === undefined) {
+      problems.push(`${where}: requirement '${role}' is not a service/requirement value`);
+      return;
+    }
+    const origin = spec.service.origin;
+    if (!claims.has(origin))
+      problems.push(`${where}: requirement '${role}' names ${origin}, which app.ts does not declare`);
+    if (spec.grant !== undefined && !(spec.grant in (spec.service.auth ?? {})))
+      problems.push(`${where}: requirement '${role}' pins grant '${spec.grant}', not a auth method on ${origin}`);
+    return {
+      role,
+      service: origin,
+      arity: spec.arity,
+      ...spec.grant === undefined ? {} : { grant: spec.grant },
+      ...spec.description === undefined ? {} : { description: spec.description }
+    };
+  };
+  if (app === undefined)
+    problems.push("app.ts must call defineApp({...})");
+  else if (typeof app.description !== "string" || app.description.trim().length === 0)
+    problems.push("app.ts: app description must not be empty");
+  for (const [file, summary] of registry.toolFiles) {
+    if (summary.definitions > 1 && summary.hasUnnamedTool)
+      problems.push(`${file}: multi-tool files must name every tool`);
+  }
+  const tools = [];
+  if (app !== undefined) {
+    for (const [name, registered] of registry.tools) {
+      const { spec, file } = registered;
+      const address = `${app.key}/${name}`;
+      if (typeof spec.description !== "string" || spec.description.trim().length === 0)
+        problems.push(`${file}: tool '${name}' description must not be empty`);
+      const requires = Object.entries(spec.requirements ?? {}).flatMap(([role, requirement]) => {
+        const collected = collectRequirement(role, requirement, address);
+        return collected === undefined ? [] : [collected];
+      }).sort((left, right) => left.role.localeCompare(right.role));
+      let compiled;
+      try {
+        compiled = compileInputSchema(spec.input, address);
+      } catch (error) {
+        compiled = {
+          problem: `${address}: input schema could not compile to JSON schema (${error instanceof Error ? error.message : String(error)})`
+        };
+      }
+      if ("problem" in compiled) {
+        problems.push(compiled.problem);
+        continue;
+      }
+      tools.push({
+        address,
+        name,
+        description: spec.description,
+        inputSchema: compiled.value,
+        annotations: spec.annotations ?? {},
+        requires,
+        file
+      });
+    }
+  }
+  if (problems.length > 0 || app === undefined)
+    return { problems };
+  const services = [...claims.values()].sort((left, right) => left.origin.localeCompare(right.origin));
+  const sortedTools = [...tools].sort((left, right) => left.address.localeCompare(right.address));
+  const appResult = { key: app.key, label: app.label, description: app.description };
+  const manifest = { app: appResult, services, tools: sortedTools };
+  return {
+    problems: [],
+    manifest,
+    canonical: canonicalJson(manifest)
+  };
+};
+
+// src/manifest/index.ts
+var hasStandardJsonSchema = (input) => ("~standard" in input) && typeof input["~standard"].jsonSchema?.input === "function";
+var compileInputSchema = (input, where) => {
+  if ("~standard" in input) {
+    if (!hasStandardJsonSchema(input))
+      return {
+        problem: `${where}: input is a Standard Schema without the jsonSchema extension — use a library that implements it (zod 4+, effect Schema) or pass raw JSON schema`
+      };
+  }
+  try {
+    const compiled = strictify(hasStandardJsonSchema(input) ? input["~standard"].jsonSchema.input({ target: "draft-2020-12" }) : structuredClone(input));
+    return { value: Schema.decodeUnknownSync(JsonSchemaObject)(compiled) };
+  } catch (error) {
+    return { problem: schemaPublishProblem(where, error) };
+  }
+};
+var schemaPublishProblem = (where, error) => `${where}: input schema could not compile to JSON schema (${error instanceof Error ? error.message : String(error)})`;
+var strictify = (node) => {
+  if (typeof node !== "object" || node === null)
+    return node;
+  if (Array.isArray(node))
+    return node.map(strictify);
+  const object = { ...node };
+  if (object.type === "object" && object.additionalProperties === undefined)
+    object.additionalProperties = false;
+  for (const key of ["items", "anyOf", "oneOf", "allOf"])
+    if (key in object)
+      object[key] = strictify(object[key]);
+  for (const key of ["properties", "$defs"])
+    if (object[key] !== undefined && typeof object[key] === "object" && object[key] !== null)
+      object[key] = Object.fromEntries(Object.entries(object[key]).map(([name, value]) => [
+        name,
+        strictify(value)
+      ]));
+  return object;
+};
+var digestOf = (content) => Effect.gen(function* () {
+  const crypto = yield* Crypto.Crypto;
+  const bytes = yield* Effect.orDie(crypto.digest("SHA-256", new TextEncoder().encode(content)));
+  return Array.from(bytes.slice(0, 8), (byte) => byte.toString(16).padStart(2, "0")).join("");
+});
+var loadPermit = Semaphore.makeUnsafe(1);
+var runNonce = 0;
+var baseAppImports = new Set;
+var moduleFailure = (where, error) => new PublishError({
+  problems: [
+    `${where}: failed to execute (${error instanceof Error ? error.message : String(error)})`
+  ]
+});
+var canonicalModuleUrl = (path, where) => Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const realPath = yield* fs.realPath(path).pipe(Effect.mapError((error) => moduleFailure(where, error)));
+  return pathToFileURL(realPath);
+});
+var importModule = (specifier, where) => Effect.tryPromise({
+  try: () => import(specifier).then(() => {
+    return;
+  }),
+  catch: (error) => moduleFailure(where, error)
+});
+var recordModuleProblems = (registry, effect) => effect.pipe(Effect.catchTag("PublishError", (error) => Effect.sync(() => {
+  registry.problems.push(...error.problems.map((message) => ({ message })));
+})));
+var executeModules = (appDir, files) => loadPermit.withPermit(Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+  const registry = newRegistry();
+  const previous = yield* Effect.sync(() => setActiveRegistry(registry));
+  const nonce = yield* Effect.sync(() => ++runNonce);
+  const execute = Effect.gen(function* () {
+    __enterFile("app.ts");
+    yield* recordModuleProblems(registry, Effect.gen(function* () {
+      const appUrl = yield* canonicalModuleUrl(`${appDir}/app.ts`, "app.ts");
+      const baseUrl = appUrl.href;
+      const specifier = baseAppImports.has(baseUrl) ? `${fileURLToPath(appUrl)}?m=${nonce}` : baseUrl;
+      yield* importModule(specifier, "app.ts");
+      yield* Effect.sync(() => baseAppImports.add(baseUrl));
+    }));
+    for (const file of files) {
+      const where = `tools/${file}`;
+      __enterFile(where);
+      yield* recordModuleProblems(registry, Effect.gen(function* () {
+        const url = yield* canonicalModuleUrl(`${appDir}/tools/${file}`, where);
+        yield* importModule(`${fileURLToPath(url)}?m=${nonce}`, where);
+      }));
+    }
+  });
+  yield* restore(execute).pipe(Effect.ensuring(Effect.sync(() => {
+    __leaveFile();
+    setActiveRegistry(previous);
+  })));
+  return registry;
+})));
+var loadApp = (appDir) => Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const files = (yield* fs.readDirectory(`${appDir}/tools`).pipe(Effect.mapError((error) => new PublishError({ problems: [`tools/: ${error.message}`] })))).filter((file) => file.endsWith(".ts")).sort();
+  const registry = yield* executeModules(appDir, files);
+  const collected = collectRegistry(registry, compileInputSchema);
+  if (collected.problems.length > 0)
+    return yield* new PublishError({ problems: collected.problems });
+  if (!("manifest" in collected))
+    return yield* Effect.die("validated registry projection unexpectedly missing");
+  return {
+    registry,
+    result: {
+      digest: `snap:${yield* digestOf(collected.canonical)}`,
+      ...collected.manifest
+    }
+  };
+});
+var manifest = (appDir) => Effect.map(loadApp(appDir), ({ result }) => result);
+
+export { loadApp, manifest };

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The authoring surface: what app code imports. Pure and synchronous —
+ * no effect dependency, no node builtins — so authored files run
+ * unmodified in any execution environment, including sandboxed workers.
+ *
+ * Host-side machinery lives behind subpaths: "apps/manifest" loads and
+ * validates authored sources, "apps/runner" executes them.
+ */
+export * from "./authoring/index";

package/dist/index.js

@@ -0,0 +1,26 @@
+import {
+  __enterFile,
+  __leaveFile,
+  defineApp,
+  defineTool,
+  newRegistry,
+  oauth,
+  requirementSpecOf,
+  secrets,
+  service,
+  setActiveRegistry,
+  toolSpecOf
+} from "./index-8wmxmfhc.js";
+export {
+  toolSpecOf,
+  setActiveRegistry,
+  service,
+  secrets,
+  requirementSpecOf,
+  oauth,
+  newRegistry,
+  defineTool,
+  defineApp,
+  __leaveFile,
+  __enterFile
+};

package/dist/manifest/collect.d.ts

@@ -0,0 +1,64 @@
+import type { AuthMethod, ParamSpec, Registry } from "../authoring/index";
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+type JsonSchemaObject = Readonly<Record<string, JsonValue>>;
+interface CollectedClaim {
+    readonly origin: string;
+    readonly reach: readonly string[];
+    readonly params: Readonly<Record<string, ParamSpec>>;
+    readonly auth: Readonly<Record<string, AuthMethod>>;
+}
+interface CollectedRequirement {
+    readonly role: string;
+    readonly service: string;
+    readonly arity: "one" | "optional" | "many";
+    readonly grant?: string;
+    readonly description?: string;
+}
+interface CollectedTool {
+    readonly address: string;
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchemaObject;
+    readonly annotations: {
+        readonly readOnly?: boolean;
+        readonly destructive?: boolean;
+        readonly scopes?: readonly string[];
+    };
+    readonly requires: readonly CollectedRequirement[];
+    readonly file: string;
+}
+interface CollectedManifest {
+    readonly app: {
+        readonly key: string;
+        readonly label: string;
+        readonly description: string;
+    };
+    readonly services: readonly CollectedClaim[];
+    readonly tools: readonly CollectedTool[];
+}
+/** Result of compiling one authored input schema during registry projection. */
+export type InputSchemaCompilation = {
+    readonly value: JsonSchemaObject;
+} | {
+    readonly problem: string;
+};
+/** Registry projection before the deployment-specific digest implementation. */
+export type RegistryCollection = {
+    readonly problems: readonly string[];
+} | {
+    readonly problems: readonly [];
+    readonly manifest: CollectedManifest;
+    readonly canonical: string;
+};
+/**
+ * Validate and project an executed authoring registry into deterministic data.
+ *
+ * This function is deliberately closure-free: the workerd runner injects its
+ * source into the guest while the local manifest calls the same function
+ * directly. Schema compilation is supplied because each runtime owns its
+ * boundary decoder.
+ */
+export declare const collectRegistry: (registry: Registry, compileInputSchema: (input: object, where: string) => InputSchemaCompilation) => RegistryCollection;
+export {};

package/dist/manifest/contract.d.ts

@@ -0,0 +1,55 @@
+import { Schema } from "effect";
+import type { AuthMethod, ParamSpec } from "../authoring/index";
+/** A service claim projected from a registered declaration. */
+export interface CollectedClaim {
+    readonly origin: string;
+    readonly reach: readonly string[];
+    readonly params: Readonly<Record<string, ParamSpec>>;
+    readonly auth: Readonly<Record<string, AuthMethod>>;
+}
+/** A tool requirement projected from an authoring value. */
+export interface CollectedRequirement {
+    readonly role: string;
+    readonly service: string;
+    readonly arity: "one" | "optional" | "many";
+    readonly grant?: string;
+    readonly description?: string;
+}
+/** JSON object accepted for a persisted tool input schema. */
+export declare const JsonSchemaObject: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+export type JsonSchemaObject = typeof JsonSchemaObject.Type;
+/** A validated, publishable tool row. */
+export interface ManifestTool {
+    readonly address: string;
+    readonly name: string;
+    readonly description: string;
+    readonly inputSchema: JsonSchemaObject;
+    readonly annotations: {
+        readonly readOnly?: boolean;
+        readonly destructive?: boolean;
+        readonly scopes?: readonly string[];
+    };
+    readonly requires: readonly CollectedRequirement[];
+    readonly file: string;
+}
+/** The deterministic public description of an executor app. */
+export interface AppManifestResult {
+    readonly digest: string;
+    readonly app: {
+        readonly key: string;
+        readonly label: string;
+        readonly description: string;
+    };
+    readonly services: readonly CollectedClaim[];
+    readonly tools: readonly ManifestTool[];
+}
+declare const PublishError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PublishError";
+} & Readonly<A>;
+/** All publish-time authoring problems from one registry load. */
+export declare class PublishError extends PublishError_base<{
+    readonly problems: readonly string[];
+}> {
+    get message(): string;
+}
+export {};

package/dist/manifest/contract.js

@@ -0,0 +1,8 @@
+import {
+  JsonSchemaObject,
+  PublishError
+} from "../index-mcjwntr2.js";
+export {
+  PublishError,
+  JsonSchemaObject
+};

package/dist/manifest/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Manifest: execute an authored app folder, read its registry, validate
+ * every claim, and emit the deterministic publish manifest. Defines run
+ * without user context; platform services begin at this boundary.
+ */
+import { Crypto, Effect, FileSystem } from "effect";
+import { type Registry } from "../authoring/index";
+import { PublishError, type AppManifestResult } from "./contract";
+export * from "./contract";
+/** A registry and its validated public projection. @internal */
+export interface LoadedApp {
+    readonly registry: Registry;
+    readonly result: AppManifestResult;
+}
+/** Loads an app once and returns both its live registry and manifest. @internal */
+export declare const loadApp: (appDir: string) => Effect.Effect<LoadedApp, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+/** Executes an app and returns its deterministic publish manifest. */
+export declare const manifest: (appDir: string) => Effect.Effect<AppManifestResult, PublishError, Crypto.Crypto | FileSystem.FileSystem>;

package/dist/manifest/index.js

@@ -0,0 +1,15 @@
+import {
+  loadApp,
+  manifest
+} from "../index-wfngzvv2.js";
+import"../index-8wmxmfhc.js";
+import {
+  JsonSchemaObject,
+  PublishError
+} from "../index-mcjwntr2.js";
+export {
+  manifest,
+  loadApp,
+  PublishError,
+  JsonSchemaObject
+};

package/dist/runner/index.d.ts

@@ -0,0 +1,4 @@
+import { type AppRunner } from "./protocol";
+export * from "./protocol";
+/** Creates a permissive in-process runner for local development and tests. */
+export declare const localRunner: (appDir: string) => AppRunner;

package/dist/runner/index.js

@@ -0,0 +1,61 @@
+import {
+  loadApp
+} from "../index-wfngzvv2.js";
+import"../index-8wmxmfhc.js";
+import"../index-mcjwntr2.js";
+import {
+  CallError
+} from "../index-dh4z81es.js";
+
+// src/runner/index.ts
+import { Effect } from "effect";
+var hasStandardValidate = (input) => ("~standard" in input) && typeof input["~standard"].validate === "function";
+var parseInput = (name, spec, input) => {
+  if (!hasStandardValidate(spec.input))
+    return Effect.fail(new CallError({ target: name, reason: "input schema does not implement Standard Schema validate" }));
+  const standard = spec.input["~standard"];
+  return Effect.tryPromise({
+    try: () => Promise.resolve(standard.validate(input)),
+    catch: (error) => new CallError({
+      target: name,
+      reason: `input validation threw (${error instanceof Error ? error.message : String(error)})`
+    })
+  }).pipe(Effect.flatMap((result) => result.issues === undefined ? Effect.succeed(result.value) : Effect.fail(new CallError({
+    target: name,
+    reason: `invalid input (${result.issues.map((issue) => issue.message).join("; ")})`
+  }))));
+};
+var localRunner = (appDir) => {
+  let cachedLoad;
+  const loaded = () => Effect.suspend(() => {
+    if (cachedLoad !== undefined)
+      return cachedLoad;
+    return Effect.flatMap(Effect.cached(loadApp(appDir)), (effect) => Effect.sync(() => {
+      cachedLoad = effect;
+      return effect;
+    }).pipe(Effect.flatten));
+  });
+  const loadedFor = (target) => loaded().pipe(Effect.mapError((error) => new CallError({ target, reason: `app failed to load (${error.message})` })));
+  return {
+    manifest: () => Effect.map(loaded(), ({ result }) => result),
+    call: (name, input, ctx) => Effect.gen(function* () {
+      const { registry } = yield* loadedFor(name);
+      const registered = registry.tools.get(name);
+      if (registered === undefined)
+        return yield* new CallError({ target: name, reason: "unknown tool" });
+      const parsed = yield* parseInput(name, registered.spec, input);
+      return yield* Effect.tryPromise({
+        try: () => registered.spec.handler(parsed, ctx),
+        catch: (error) => new CallError({
+          target: name,
+          reason: `handler failed (${error instanceof Error ? error.message : String(error)})`
+        })
+      });
+    }),
+    discover: (name, _binding) => Effect.fail(new CallError({ target: name, reason: "no dynamic tools yet" }))
+  };
+};
+export {
+  localRunner,
+  CallError
+};

package/dist/runner/protocol.d.ts

@@ -0,0 +1,28 @@
+import { Crypto, type Effect, FileSystem } from "effect";
+import type { AppManifestResult, PublishError } from "../manifest/contract";
+/** The capability exposed to one tool requirement role. */
+export interface ToolCtxEntry {
+    readonly grant: string;
+    readonly token?: string;
+    readonly secrets?: Readonly<Record<string, string>>;
+    fetch(path: string, init?: RequestInit): Promise<Response>;
+}
+/** Tool capabilities keyed by requirement role. */
+export type ToolCtx = Readonly<Record<string, ToolCtxEntry>>;
+declare const CallError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CallError";
+} & Readonly<A>;
+/** A runner operation failure associated with its target. */
+export declare class CallError extends CallError_base<{
+    readonly target: string;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+/** The platform protocol implemented by an app execution environment. */
+export interface AppRunner {
+    manifest(): Effect.Effect<AppManifestResult, PublishError, Crypto.Crypto | FileSystem.FileSystem>;
+    call(name: string, input: unknown, ctx: ToolCtx): Effect.Effect<unknown, CallError, Crypto.Crypto | FileSystem.FileSystem>;
+    discover(name: string, binding: unknown): Effect.Effect<unknown, CallError, Crypto.Crypto | FileSystem.FileSystem>;
+}
+export {};

package/dist/runner/protocol.js

@@ -0,0 +1,6 @@
+import {
+  CallError
+} from "../index-dh4z81es.js";
+export {
+  CallError
+};

package/dist/workerd/index.d.ts

@@ -0,0 +1,2 @@
+/** Worker-safe registry projection injected into sandboxed app workers. @internal */
+export { collectRegistry } from "../manifest/collect";

package/dist/workerd/index.js

@@ -0,0 +1,3 @@
+export {
+  collectRegistry
+};

package/package.json

@@ -1,47 +1,60 @@
 {
   "name": "apps",
-  "version": "0.8.3",
-  "description": "Create, validate, and render Heroku app.json manifests",
-  "main": "index.js",
-  "bin": {
-    "app": "./bin/apps",
-    "apps": "./bin/apps"
-  },
-  "scripts": {
-    "test": "mocha",
-    "build": "bin/build",
-    "doc": "bin/doc"
-  },
+  "version": "1.0.0-beta.0",
+  "description": "Author executor apps: declare services, auth, and tools in plain TypeScript; the executor platform runs, validates, and serves them.",
+  "license": "MIT",
+  "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/heroku/apps"
+    "url": "git+https://github.com/UsefulSoftwareCo/executor-rework.git",
+    "directory": "sdk/apps"
   },
-  "keywords": [
-    "app.json"
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src",
+    "README.md"
   ],
-  "author": "Zeke Sikelianos <zeke@sikelianos.com> (http://zeke.sikelianos.com/)",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/heroku/apps/issues"
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./authoring": {
+      "types": "./dist/authoring/index.d.ts",
+      "default": "./dist/authoring/index.js"
+    },
+    "./manifest": {
+      "types": "./dist/manifest/index.d.ts",
+      "default": "./dist/manifest/index.js"
+    },
+    "./manifest/contract": {
+      "types": "./dist/manifest/contract.d.ts",
+      "default": "./dist/manifest/contract.js"
+    },
+    "./runner": {
+      "types": "./dist/runner/index.d.ts",
+      "default": "./dist/runner/index.js"
+    },
+    "./runner/protocol": {
+      "types": "./dist/runner/protocol.d.ts",
+      "default": "./dist/runner/protocol.js"
+    },
+    "./workerd": {
+      "types": "./dist/workerd/index.d.ts",
+      "default": "./dist/workerd/index.js"
+    }
+  },
+  "peerDependencies": {
+    "effect": "4.0.0-beta.93"
   },
-  "homepage": "https://github.com/heroku/apps",
-  "dependencies": {
-    "revalidator": "https://github.com/facundoolano/revalidator/tarball/master",
-    "github-url-to-object": "^0.4.1",
-    "superagent": "^0.17.0",
-    "browserify-hogan": "^0.1.2",
-    "hogan.js": "^2.0.0",
-    "brfs": "^1.0.2",
-    "async": "^0.7.0",
-    "heroku-client": "^1.2.0",
-    "commander": "^2.2.0",
-    "marked": "^0.3.2"
+  "peerDependenciesMeta": {
+    "effect": {
+      "optional": false
+    }
   },
   "devDependencies": {
-    "mocha": "^1.18.0",
-    "browserify": "^3.38.0",
-    "uglify-js": "^2.4.13",
-    "cheerio": "^0.15.0",
-    "nixt": "^0.3.0"
+    "@types/node": "22",
+    "typescript": "5.9.3"
   }
 }