@nudojs/harvester 0.2.2 → 0.2.4

package/dist/index.d.ts

@@ -1,12 +1,12 @@
-import { TypeValue } from '@nudojs/core';
+import { Abs } from '@nudojs/core';
 
 /**
- * The result of harvesting a set of `.d.ts` files: a Nudo env shaped exactly
- * like `EnvDefinition` (`{ globals, modules }`), plus harvest statistics.
+ * Harvested env：Abs 原生（与 EnvDefinition 同形）。
+ * 收集与物化全程 Abs，不再经 TypeValue 桥。
  */
 type HarvestedEnv = {
-    globals: Record<string, TypeValue>;
-    modules: Record<string, Record<string, TypeValue>>;
+    globals: Record<string, Abs>;
+    modules: Record<string, Record<string, Abs>>;
     stats: {
         files: number;
         symbols: number;

package/dist/index.js

@@ -1,11 +1,76 @@
 // src/index.ts
 import { readFileSync, statSync } from "fs";
 import ts from "typescript";
-import { typeValueEquals, getFnSig, T } from "@nudojs/core";
+import {
+  abs as makeAbs,
+  lit as termLit,
+  numLit,
+  strLit,
+  boolLit,
+  objOf,
+  joinAbs
+} from "@nudojs/core";
 var MAX_ALIAS_DEPTH = 8;
 function scopeKey(scope) {
   return scope.moduleName ?? "\0global";
 }
+function absExact(shape) {
+  return makeAbs(shape, void 0, void 0, "exact");
+}
+function absNever() {
+  return absExact({ k: "never" });
+}
+function absUnknown() {
+  return makeAbs({ k: "unknown" }, void 0, void 0, "partial");
+}
+function absPrim(type) {
+  return absExact({ k: "prim", type });
+}
+function absNullLit() {
+  return makeAbs({ k: "unknown" }, termLit(null), void 0, "exact");
+}
+function absUndefLit() {
+  return makeAbs({ k: "unknown" }, termLit(void 0), void 0, "exact");
+}
+function absLit(value) {
+  if (typeof value === "number") return numLit(value);
+  if (typeof value === "string") return strLit(value);
+  if (typeof value === "boolean") return boolLit(value);
+  if (typeof value === "bigint") return absPrim("bigint");
+  if (value === null) return absNullLit();
+  return absUndefLit();
+}
+function absArr(element) {
+  return absExact({ k: "arr", element });
+}
+function absPromise(inner) {
+  return absExact({ k: "eff", eff: "promise", inner });
+}
+function absObj(properties) {
+  const slots = {};
+  for (const [k, v] of Object.entries(properties)) {
+    slots[k] = { value: v };
+  }
+  return objOf(slots);
+}
+function absBrand(name, properties) {
+  return absExact({ k: "brand", name, shape: absObj(properties) });
+}
+function absFnSig(paramTypes, returnType) {
+  return absExact({
+    k: "fn",
+    params: paramTypes.map((_, i) => `_arg${i}`),
+    paramTypes,
+    returnType
+  });
+}
+function absUnion(members) {
+  if (members.length === 0) return absNever();
+  return members.reduce((acc, m) => joinAbs(acc, m));
+}
+function isPlainUnknown(a) {
+  return a.shape.k === "unknown" && !(a.term?.op === "lit");
+}
 function harvestDts(files, opts) {
   const maxBytes = opts?.maxFileBytes ?? 15e5;
   const deadline = opts?.maxMs !== void 0 ? Date.now() + opts.maxMs : void 0;
@@ -70,7 +135,7 @@ function emitEnvModule(env, pkgName) {
     if (keys.length < 2) continue;
     const constName = `mod${constIndex++}`;
     constNameByRecord.set(record, constName);
-    constLines.push(`  const ${constName}: Record<string, TypeValue> = {`);
+    constLines.push(`  const ${constName}: Record<string, unknown> = {`);
     emitEntries(constLines, record, 2);
     constLines.push(`  };`);
     constLines.push("");
@@ -78,11 +143,9 @@ function emitEnvModule(env, pkgName) {
   const lines = [];
   lines.push("// Auto-generated by nudo harvest \u2014 DO NOT EDIT");
   lines.push(`// Source package: ${pkgName}`);
-  if (constLines.length > 0) {
-    lines.push('import { type TypeValue, T } from "@nudojs/core";');
-  } else {
-    lines.push(`import { T } from "@nudojs/core";`);
-  }
+  lines.push(
+    'import { num, str, bool, never as absNever, unknown as absUnknown, numLit, strLit, boolLit, objOf, relationFn, abs as makeAbs } from "@nudojs/core";'
+  );
   lines.push("");
   lines.push("export function defineEnv() {");
   lines.push(...constLines);
@@ -159,6 +222,11 @@ function collectStatement(ctx, stmt, scope) {
         ctx.skipped++;
         continue;
       }
+      const iface = decl.type ? interfaceDeclOf(ctx, decl.type) : void 0;
+      if (iface) {
+        expandInterfaceAsModuleMembers(ctx, scope, iface);
+        continue;
+      }
       ctx.pending.push({ t: "var", scope, name: decl.name.text, typeNode: decl.type });
       ctx.symbols++;
     }
@@ -259,6 +327,36 @@ function registerTypeDecl(ctx, scope, name, decl) {
     ctx.qualifiedInterfaces.set(qualified, decl);
   }
 }
+function interfaceDeclOf(ctx, typeNode) {
+  if (!ts.isTypeReferenceNode(typeNode)) return void 0;
+  const name = typeNameString(typeNode.typeName);
+  const d = ctx.interfaces.get(name) ?? ctx.qualifiedInterfaces.get(name);
+  return d && ts.isInterfaceDeclaration(d) ? d : void 0;
+}
+function expandInterfaceAsModuleMembers(ctx, scope, iface) {
+  for (const member of iface.members) {
+    if (ts.isMethodSignature(member)) {
+      const name = memberName(member);
+      if (name === void 0) continue;
+      const existing = ctx.pending.find(
+        (p) => p.t === "fn" && p.name === name && scopeKey(p.scope) === scopeKey(scope)
+      );
+      if (existing && existing.t === "fn") {
+        existing.decls.push(member);
+        continue;
+      }
+      ctx.pending.push({ t: "fn", scope, name, decls: [member] });
+      ctx.symbols++;
+      continue;
+    }
+    if (ts.isPropertySignature(member)) {
+      const name = memberName(member);
+      if (name === void 0) continue;
+      ctx.pending.push({ t: "var", scope, name, typeNode: member.type });
+      ctx.symbols++;
+    }
+  }
+}
 function registerAlias(ctx, scope, stmt) {
   const name = stmt.name.text;
   if (!ctx.aliases.has(name)) ctx.aliases.set(name, stmt);
@@ -273,15 +371,15 @@ function materialize(ctx) {
     if (p.t === "fn") {
       if (rec[p.name] !== void 0) continue;
       const value = signatureToFnSig(ctx, p.decls[0]);
-      const sig = getFnSig(value);
+      const sig = value.shape.k === "fn" ? value.shape : void 0;
       if (sig) {
         const returns = [];
         for (const decl of p.decls) {
           if (!decl.type) continue;
           const ret = mapType(ctx, decl.type, 0);
-          if (ret.kind !== "unknown") returns.push(ret);
+          if (!isPlainUnknown(ret)) returns.push(ret);
         }
-        sig.returnType = returns.length > 0 ? returns.reduce((acc, r) => typeValueEquals(acc, r) ? acc : T.union(acc, r)) : T.unknown;
+        sig.returnType = returns.length > 0 ? absUnion(returns) : absUnknown();
       }
       rec[p.name] = value;
       continue;
@@ -289,8 +387,8 @@ function materialize(ctx) {
     if (rec[p.name] !== void 0) continue;
     switch (p.t) {
       case "var": {
-        const mapped = p.typeNode ? mapType(ctx, p.typeNode, 0) : T.unknown;
-        if (mapped.kind === "unknown") {
+        const mapped = p.typeNode ? mapType(ctx, p.typeNode, 0) : absUnknown();
+        if (isPlainUnknown(mapped)) {
           ctx.skipped++;
           break;
         }
@@ -304,19 +402,19 @@ function materialize(ctx) {
           const params = [];
           if (ctor) {
             for (const param of ctor.parameters) {
-              let type = param.type ? mapType(ctx, param.type, 0) : T.unknown;
-              if (param.questionToken) type = T.union(type, T.undefined);
+              let type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
+              if (param.questionToken) type = absUnion([type, absUndefLit()]);
               params.push(type);
             }
           }
-          rec[p.name] = T.fnSig(params, instanceFor(ctx, p.lookup ?? p.name));
+          rec[p.name] = absFnSig(params, instanceFor(ctx, p.lookup ?? p.name));
         } else {
           rec[p.name] = instanceFor(ctx, p.lookup ?? p.name);
         }
         break;
       }
       case "enum":
-        rec[p.name] = T.unknown;
+        rec[p.name] = absUnknown();
         break;
     }
   }
@@ -340,9 +438,9 @@ function instanceFor(ctx, key) {
   const cached = ctx.instanceCache.get(key);
   if (cached !== void 0) return cached;
   const decl = ctx.interfaces.get(key) ?? ctx.qualifiedInterfaces.get(key);
-  if (!decl) return T.unknown;
+  if (!decl) return absUnknown();
   if (ctx.expanding.has(key)) {
-    return T.instanceOf(decl.name?.text ?? key, {});
+    return absBrand(decl.name?.text ?? key, {});
   }
   ctx.expanding.add(key);
   const properties = {};
@@ -354,8 +452,8 @@ function instanceFor(ctx, key) {
       if (ts.isPropertySignature(member) || ts.isPropertyDeclaration(member)) {
         const name = memberName(member);
         if (name === void 0) continue;
-        let type = member.type ? mapType(ctx, member.type, 0) : T.unknown;
-        if (member.questionToken) type = T.union(type, T.undefined);
+        let type = member.type ? mapType(ctx, member.type, 0) : absUnknown();
+        if (member.questionToken) type = absUnion([type, absUndefLit()]);
         properties[name] = type;
       } else if (ts.isMethodSignature(member) || ts.isMethodDeclaration(member)) {
         const name = memberName(member);
@@ -370,7 +468,7 @@ function instanceFor(ctx, key) {
   } finally {
     ctx.expanding.delete(key);
   }
-  const value = T.instanceOf(decl.name?.text ?? key, properties);
+  const value = absBrand(decl.name?.text ?? key, properties);
   ctx.instanceCache.set(key, value);
   return value;
 }
@@ -379,15 +477,15 @@ function signatureToFnSig(ctx, sig) {
     let type;
     if (param.dotDotDotToken) {
       const inner = param.type && ts.isArrayTypeNode(param.type) ? param.type.elementType : param.type;
-      type = inner ? T.array(mapType(ctx, inner, 0)) : T.unknown;
+      type = inner ? absArr(mapType(ctx, inner, 0)) : absUnknown();
     } else {
-      type = param.type ? mapType(ctx, param.type, 0) : T.unknown;
+      type = param.type ? mapType(ctx, param.type, 0) : absUnknown();
     }
-    if (param.questionToken && !param.dotDotDotToken) type = T.union(type, T.undefined);
+    if (param.questionToken && !param.dotDotDotToken) type = absUnion([type, absUndefLit()]);
     return type;
   });
-  const returnType = sig.type ? mapType(ctx, sig.type, 0) : T.unknown;
-  return T.fnSig(paramTypes, returnType);
+  const returnType = sig.type ? mapType(ctx, sig.type, 0) : absUnknown();
+  return absFnSig(paramTypes, returnType);
 }
 function mapTypeMembers(ctx, members, depth) {
   const properties = {};
@@ -395,8 +493,8 @@ function mapTypeMembers(ctx, members, depth) {
     if (ts.isPropertySignature(member)) {
       const name = memberName(member);
       if (name === void 0) continue;
-      let type = member.type ? mapType(ctx, member.type, depth) : T.unknown;
-      if (member.questionToken) type = T.union(type, T.undefined);
+      let type = member.type ? mapType(ctx, member.type, depth) : absUnknown();
+      if (member.questionToken) type = absUnion([type, absUndefLit()]);
       properties[name] = type;
     } else if (ts.isMethodSignature(member)) {
       const name = memberName(member);
@@ -410,57 +508,60 @@ function mapTypeRef(ctx, node, depth) {
   const name = typeNameString(node.typeName);
   const args = node.typeArguments ?? [];
   if ((name === "Array" || name === "ReadonlyArray") && args.length >= 1) {
-    return T.array(mapType(ctx, args[0], depth));
+    return absArr(mapType(ctx, args[0], depth));
   }
   if (name === "Promise" && args.length >= 1) {
-    return T.promise(mapType(ctx, args[0], depth));
+    return absPromise(mapType(ctx, args[0], depth));
   }
   if (name === "Record") {
-    return T.object({});
+    return absObj({});
   }
   if (ctx.interfaces.has(name) || ctx.qualifiedInterfaces.has(name)) {
     return instanceFor(ctx, name);
   }
   const alias = ctx.aliases.get(name) ?? ctx.qualifiedAliases.get(name);
   if (alias) return mapType(ctx, alias.type, depth + 1);
-  return T.unknown;
+  return absUnknown();
 }
 function mapType(ctx, node, depth) {
-  if (!node || depth > MAX_ALIAS_DEPTH) return T.unknown;
+  if (!node || depth > MAX_ALIAS_DEPTH) return absUnknown();
   if (ts.isParenthesizedTypeNode(node)) return mapType(ctx, node.type, depth);
   if (ts.isTypeReferenceNode(node)) return mapTypeRef(ctx, node, depth);
-  if (ts.isArrayTypeNode(node)) return T.array(mapType(ctx, node.elementType, depth));
+  if (ts.isArrayTypeNode(node)) return absArr(mapType(ctx, node.elementType, depth));
   if (ts.isTupleTypeNode(node)) {
     for (const element of node.elements) {
       const inner = ts.isNamedTupleMember(element) ? element.type : element;
-      return T.array(mapType(ctx, inner, depth));
+      return absArr(mapType(ctx, inner, depth));
     }
-    return T.unknown;
+    return absUnknown();
   }
   if (ts.isUnionTypeNode(node)) {
-    return T.union(...node.types.map((t) => mapType(ctx, t, depth)));
+    return absUnion(node.types.map((t) => mapType(ctx, t, depth)));
   }
   if (ts.isIntersectionTypeNode(node)) {
     const members = node.types.map((t) => mapType(ctx, t, depth));
-    if (members.length > 0 && members.every((m) => m.kind === "object")) {
+    if (members.length > 0 && members.every((m) => m.shape.k === "obj")) {
       const properties = {};
       for (const member of members) {
-        Object.assign(properties, member.properties);
+        if (member.shape.k !== "obj") continue;
+        for (const [k, slot] of Object.entries(member.shape.slots)) {
+          properties[k] = slot.value;
+        }
       }
-      return T.object(properties);
+      return absObj(properties);
     }
-    return members[0] ?? T.unknown;
+    return members[0] ?? absUnknown();
   }
   if (ts.isLiteralTypeNode(node)) {
     const lit = node.literal;
-    if (ts.isStringLiteral(lit)) return T.literal(lit.text);
-    if (ts.isNumericLiteral(lit)) return T.literal(Number(lit.text));
-    if (lit.kind === ts.SyntaxKind.TrueKeyword) return T.literal(true);
-    if (lit.kind === ts.SyntaxKind.FalseKeyword) return T.literal(false);
+    if (ts.isStringLiteral(lit)) return absLit(lit.text);
+    if (ts.isNumericLiteral(lit)) return absLit(Number(lit.text));
+    if (lit.kind === ts.SyntaxKind.TrueKeyword) return absLit(true);
+    if (lit.kind === ts.SyntaxKind.FalseKeyword) return absLit(false);
     if (ts.isPrefixUnaryExpression(lit) && lit.operator === ts.SyntaxKind.MinusToken && ts.isNumericLiteral(lit.operand)) {
-      return T.literal(-Number(lit.operand.text));
+      return absLit(-Number(lit.operand.text));
     }
-    return T.unknown;
+    return absUnknown();
   }
   if (ts.isFunctionTypeNode(node)) return signatureToFnSig(ctx, node);
   if (ts.isTypeLiteralNode(node)) {
@@ -468,41 +569,41 @@ function mapType(ctx, node, depth) {
     if (ctor) {
       const params = [];
       for (const param of ctor.parameters) {
-        let type = param.type ? mapType(ctx, param.type, depth) : T.unknown;
-        if (param.questionToken) type = T.union(type, T.undefined);
+        let type = param.type ? mapType(ctx, param.type, depth) : absUnknown();
+        if (param.questionToken) type = absUnion([type, absUndefLit()]);
         params.push(type);
       }
-      return T.fnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : T.unknown);
+      return absFnSig(params, ctor.type ? mapType(ctx, ctor.type, depth) : absUnknown());
     }
-    return T.object(mapTypeMembers(ctx, node.members, depth));
+    return absObj(mapTypeMembers(ctx, node.members, depth));
   }
   if (ts.isTypeOperatorNode(node)) {
-    return node.operator === ts.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : T.unknown;
+    return node.operator === ts.SyntaxKind.ReadonlyKeyword ? mapType(ctx, node.type, depth) : absUnknown();
   }
   switch (node.kind) {
     case ts.SyntaxKind.StringKeyword:
-      return T.string;
+      return absPrim("string");
     case ts.SyntaxKind.NumberKeyword:
-      return T.number;
+      return absPrim("number");
     case ts.SyntaxKind.BooleanKeyword:
-      return T.boolean;
+      return absPrim("boolean");
     case ts.SyntaxKind.BigIntKeyword:
-      return T.bigint;
+      return absPrim("bigint");
     case ts.SyntaxKind.SymbolKeyword:
-      return T.symbol;
+      return absPrim("symbol");
     case ts.SyntaxKind.AnyKeyword:
     case ts.SyntaxKind.UnknownKeyword:
     case ts.SyntaxKind.ObjectKeyword:
-      return T.unknown;
+      return absUnknown();
     case ts.SyntaxKind.VoidKeyword:
     case ts.SyntaxKind.UndefinedKeyword:
-      return T.undefined;
+      return absUndefLit();
     case ts.SyntaxKind.NeverKeyword:
-      return T.never;
+      return absNever();
     case ts.SyntaxKind.NullKeyword:
-      return T.null;
+      return absNullLit();
     default:
-      return T.unknown;
+      return absUnknown();
   }
 }
 function indent(level) {
@@ -513,66 +614,74 @@ function emitKey(key) {
 }
 function emitEntries(lines, record, level) {
   for (const [key, value] of Object.entries(record)) {
-    lines.push(`${indent(level)}${emitKey(key)}: ${emitType(value, /* @__PURE__ */ new Set())},`);
+    lines.push(`${indent(level)}${emitKey(key)}: ${emitAbs(value, /* @__PURE__ */ new Set())},`);
   }
 }
-function emitType(tv, expanding) {
-  switch (tv.kind) {
-    case "literal":
-      if (tv.value === null) return "T.null";
-      if (tv.value === void 0) return "T.undefined";
-      return `T.literal(${JSON.stringify(tv.value)})`;
-    case "primitive":
-      return `T.${tv.type}`;
-    case "unknown":
-      return "T.unknown";
+function emitAbs(a, expanding) {
+  const s = a.shape;
+  switch (s.k) {
     case "never":
-      return "T.never";
-    case "array":
-      return `T.array(${emitType(tv.element, expanding)})`;
+      return "absNever";
+    case "unknown":
+      if (a.term?.op === "lit") {
+        const v = a.term.value;
+        if (v === null) return `makeAbs({ k: "unknown" }, { op: "lit", value: null }, undefined, "exact")`;
+        if (v === void 0) return `makeAbs({ k: "unknown" }, { op: "lit", value: undefined }, undefined, "exact")`;
+        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
+        if (typeof v === "boolean") return `boolLit(${v})`;
+        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+      }
+      return "absUnknown";
+    case "any":
+      return "absUnknown";
+    case "prim": {
+      if (a.term?.op === "lit") {
+        const v = a.term.value;
+        if (typeof v === "number") return `numLit(${JSON.stringify(v)})`;
+        if (typeof v === "boolean") return `boolLit(${v})`;
+        if (typeof v === "string") return `strLit(${JSON.stringify(v)})`;
+      }
+      if (s.type === "number") return "num()";
+      if (s.type === "string") return "str()";
+      if (s.type === "boolean") return "bool()";
+      return "absUnknown";
+    }
+    case "arr":
+      return `makeAbs({ k: "arr", element: ${emitAbs(s.element, expanding)} }, undefined, undefined, "exact")`;
     case "tuple":
-      return `T.tuple([${tv.elements.map((e) => emitType(e, expanding)).join(", ")}])`;
-    case "promise":
-      return `T.promise(${emitType(tv.value, expanding)})`;
-    case "object": {
-      const entries = Object.entries(tv.properties).map(
-        ([key, value]) => `${emitKey(key)}: ${emitType(value, expanding)}`
+      return `makeAbs({ k: "tuple", elements: [${s.elements.map((e) => emitAbs(e, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
+    case "eff":
+      return `makeAbs({ k: "eff", eff: ${JSON.stringify(s.eff)}, inner: ${emitAbs(s.inner, expanding)} }, undefined, undefined, "exact")`;
+    case "obj": {
+      const entries = Object.entries(s.slots).map(
+        ([key, slot]) => `${emitKey(key)}: { value: ${emitAbs(slot.value, expanding)} }`
       );
-      return `T.object({ ${entries.join(", ")} })`;
+      return `objOf({ ${entries.join(", ")} })`;
     }
-    case "instance": {
-      if (expanding.has(tv.className)) {
-        return `T.instanceOf(${JSON.stringify(tv.className)}, {})`;
+    case "brand": {
+      if (expanding.has(s.name)) {
+        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: absUnknown }, undefined, undefined, "path")`;
       }
-      expanding.add(tv.className);
+      expanding.add(s.name);
       try {
-        const entries = Object.entries(tv.properties).map(
-          ([key, value]) => `${emitKey(key)}: ${emitType(value, expanding)}`
-        );
-        return `T.instanceOf(${JSON.stringify(tv.className)}, { ${entries.join(", ")} })`;
+        return `makeAbs({ k: "brand", name: ${JSON.stringify(s.name)}, shape: ${emitAbs(s.shape, expanding)} }, undefined, undefined, "path")`;
       } finally {
-        expanding.delete(tv.className);
+        expanding.delete(s.name);
       }
     }
-    case "union": {
-      if (tv.members.length === 0) return "T.never";
-      if (tv.members.length === 1) return emitType(tv.members[0], expanding);
-      return `T.union(${tv.members.map((m) => emitType(m, expanding)).join(", ")})`;
+    case "sum": {
+      if (s.members.length === 0) return "absNever";
+      if (s.members.length === 1) return emitAbs(s.members[0], expanding);
+      return `makeAbs({ k: "sum", members: [${s.members.map((m) => emitAbs(m, expanding)).join(", ")}] }, undefined, undefined, "exact")`;
     }
-    case "function": {
-      const sig = getFnSig(tv);
-      if (!sig) return "T.unknown";
-      const params = sig.paramTypes.map((p) => emitType(p, expanding)).join(", ");
-      const ret = emitType(sig.returnType, expanding);
-      if (sig.throwsType && sig.throwsType.kind !== "never") {
-        return `T.fnSig([${params}], ${ret}, ${emitType(sig.throwsType, expanding)})`;
-      }
-      return `T.fnSig([${params}], ${ret})`;
+    case "fn": {
+      const pts = s.paramTypes ?? [];
+      const params = pts.map((p) => emitAbs(p, expanding)).join(", ");
+      const ret = s.returnType ? emitAbs(s.returnType, expanding) : "absUnknown";
+      return `relationFn([${params}], ${ret}, { conf: "exact" })`;
     }
-    case "refined":
-      return emitType(tv.base, expanding);
     default:
-      return "T.unknown";
+      return "absUnknown";
   }
 }
 export {

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@nudojs/harvester",
-  "version": "0.2.2",
+  "version": "0.2.4",
+  "engines": {
+    "node": ">=20"
+  },
   "description": "Harvests TypeScript .d.ts declarations into Nudo env definitions",
   "type": "module",
   "license": "MIT",
@@ -27,7 +30,7 @@
   },
   "dependencies": {
     "typescript": "^5.8.0",
-    "@nudojs/core": "0.4.0"
+    "@nudojs/core": "1.0.1"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm --dts"